switchroom 0.16.29 → 0.16.46

package/telegram-plugin/tests/claude-code-event-contract.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect } from 'vitest'
+import {
+  projectTranscriptLine,
+  projectSubagentLine,
+  assistantLineCarriesAnswerSurface,
+  type SessionEvent,
+} from '../session-tail.js'
+
+/**
+ * CONTRACT / CANARY: the Claude Code transcript event shapes the liveness
+ * surface depends on.
+ *
+ * switchroom has NO stream-json path — the status/liveness surface is derived
+ * entirely by scraping Claude Code's on-disk per-session JSONL transcript
+ * (see session-tail.ts header). Those shapes are UNDOCUMENTED and
+ * version-fragile: a 2.1.x release changed a single logical assistant message
+ * from "one JSONL line carrying all content blocks in source order" to
+ * "multiple JSONL lines sharing one message.id, one content-block per line,
+ * with the terminal stop_reason stamped on EVERY split line". That silently
+ * dropped background sub-agent handbacks (the terminal fired on the leading
+ * thinking split line before the answer text line was projected).
+ *
+ * This file PINS every wire shape the projector consumes, using fixtures
+ * captured verbatim from a live 2.1.199 transcript. If an upstream release
+ * changes the shape such that the projector stops emitting the expected
+ * SessionEvents, THIS TEST FAILS LOUDLY at CI — instead of the card silently
+ * blanking in production. When it fails: re-capture the fixtures from a real
+ * transcript, confirm the projector still emits the same SessionEvents, and
+ * update the fixtures + this contract deliberately.
+ */
+
+const kinds = (evs: SessionEvent[]): string[] => evs.map((e) => e.kind)
+
+describe('Claude Code event-stream contract (canary)', () => {
+  it('queue-operation enqueue carries the channel meta the gateway keys currentTurn on', () => {
+    // enqueue is the ONLY event that carries chatId — losing it kills the
+    // whole per-turn liveness surface (progress card, draft-mirror, floor).
+    const line = JSON.stringify({
+      type: 'queue-operation',
+      operation: 'enqueue',
+      content:
+        '<channel source="telegram" chat_id="12345" message_id="678" message_thread_id="9">hi</channel>',
+    })
+    expect(projectTranscriptLine(line)).toEqual([
+      {
+        kind: 'enqueue',
+        chatId: '12345',
+        messageId: '678',
+        threadId: '9',
+        rawContent:
+          '<channel source="telegram" chat_id="12345" message_id="678" message_thread_id="9">hi</channel>',
+      },
+    ])
+  })
+
+  it('assistant thinking block projects to a thinking event (phase-distinct signal)', () => {
+    // 2.1.x thinking block shape: { type, thinking, signature }.
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        id: 'msg_a',
+        stop_reason: 'tool_use',
+        stop_details: { type: 'tool_use' }, // new field in 2.1.x — must be ignored gracefully
+        content: [{ type: 'thinking', thinking: 'let me look', signature: 'sig' }],
+      },
+    })
+    expect(kinds(projectTranscriptLine(line))).toEqual(['thinking'])
+  })
+
+  it('assistant tool_use block still carries {id, name, input}', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        id: 'msg_b',
+        stop_reason: 'tool_use',
+        content: [{ type: 'tool_use', id: 'toolu_1', name: 'Bash', input: { command: 'ls' } }],
+      },
+    })
+    expect(projectTranscriptLine(line)).toEqual([
+      { kind: 'tool_use', toolName: 'Bash', toolUseId: 'toolu_1', input: { command: 'ls' } },
+    ])
+  })
+
+  it('user tool_result block still carries tool_use_id + is_error', () => {
+    const line = JSON.stringify({
+      type: 'user',
+      message: {
+        content: [{ type: 'tool_result', tool_use_id: 'toolu_1', is_error: true, content: 'boom' }],
+      },
+    })
+    const evs = projectTranscriptLine(line)
+    expect(evs).toHaveLength(1)
+    expect(evs[0]).toMatchObject({ kind: 'tool_result', toolUseId: 'toolu_1', isError: true })
+  })
+
+  it('system/turn_duration remains the main-agent terminal', () => {
+    const line = JSON.stringify({ type: 'system', subtype: 'turn_duration', durationMs: 4200 })
+    expect(projectTranscriptLine(line)).toEqual([{ kind: 'turn_end', durationMs: 4200 }])
+  })
+
+  it('SPLIT assistant message: each content-block is its own line sharing message.id', () => {
+    // The 2.1.x split shape, captured verbatim. text and tool_use are NEVER
+    // co-located anymore; each block is a separate line. The projector must
+    // still emit each block's event exactly once, in order, across lines.
+    const thinking = JSON.stringify({
+      type: 'assistant',
+      message: { id: 'msg_split', stop_reason: 'tool_use', content: [{ type: 'thinking', thinking: 't', signature: 's' }] },
+    })
+    const tool = JSON.stringify({
+      type: 'assistant',
+      message: { id: 'msg_split', stop_reason: 'tool_use', content: [{ type: 'tool_use', id: 'toolu_9', name: 'Read', input: { file_path: '/x' } }] },
+    })
+    const all = [...projectTranscriptLine(thinking), ...projectTranscriptLine(tool)]
+    expect(kinds(all)).toEqual(['thinking', 'tool_use'])
+    // No duplicate emission of the tool_use across the split lines.
+    expect(all.filter((e) => e.kind === 'tool_use')).toHaveLength(1)
+  })
+
+  it('CANARY: end_turn stamped on the thinking-only split line must NOT be a terminal', () => {
+    // The exact shape that dropped sub-agent handbacks: line 1 of a split
+    // terminal message is thinking-only but carries stop_reason end_turn.
+    expect(
+      assistantLineCarriesAnswerSurface([{ type: 'thinking', thinking: 't', signature: 's' }]),
+    ).toBe(false)
+    // A content-bearing line (the real final answer) DOES carry the surface.
+    expect(assistantLineCarriesAnswerSurface([{ type: 'text', text: 'final answer' }])).toBe(true)
+    // Empty/whitespace text is not an answer surface.
+    expect(assistantLineCarriesAnswerSurface([{ type: 'text', text: '   ' }])).toBe(false)
+
+    const st = { hasEmittedStart: true }
+    const thinkingEndTurn = JSON.stringify({
+      type: 'assistant',
+      message: { id: 'msg_t', stop_reason: 'end_turn', content: [{ type: 'thinking', thinking: 't', signature: 's' }] },
+    })
+    expect(
+      projectSubagentLine(thinkingEndTurn, 'agentX', st).some((e) => e.kind === 'sub_agent_turn_end'),
+    ).toBe(false)
+  })
+
+  it('sub-agent kickoff: first user message string prompt fires sub_agent_started', () => {
+    const st = { hasEmittedStart: false }
+    const line = JSON.stringify({
+      type: 'user',
+      isSidechain: true,
+      message: { role: 'user', content: 'Review PR #123 and report back.' },
+    })
+    expect(projectSubagentLine(line, 'agentX', st)).toEqual([
+      { kind: 'sub_agent_started', agentId: 'agentX', firstPromptText: 'Review PR #123 and report back.' },
+    ])
+  })
+})

package/telegram-plugin/tests/codespan-escaping-golden.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Golden regression tests for GFM code-span escaping (#2695 / #2701).
+ *
+ * Inside a GFM inline code span (`` `…` ``) content is LITERAL — backslash
+ * escaping does NOT apply. #2695 renamed `escapeHtml`→`escapeMarkdown`
+ * blindly across the auth/quota/usage surfaces, so identifiers containing
+ * `_ * ~ [ ] | =` were rendered with visible backslashes inside code spans
+ * (e.g. `openai\_key` instead of `openai_key`), and the /usage table cell
+ * corrupted the row when a label carried a `_`/`*`.
+ *
+ * These goldens are the ONLY guard for this class of bug: the rendered
+ * rich-message content isn't observable through the mtcute UAT harness
+ * (it can't read message text formatting), so a unit assertion on the
+ * exact string is the regression fence. If any of these re-introduce a
+ * stray backslash before an identifier char inside a code span, they fail.
+ */
+import { describe, it, expect } from 'vitest';
+import { codeSpanSafe, escapeMarkdown } from '../format.js';
+import {
+  renderAuthSnapshotFormat2,
+  renderFallbackAnnouncement,
+  type AccountSnapshot,
+} from '../auth-snapshot-format.js';
+import {
+  buildThrottlingMessage,
+  buildRecoveryMessage,
+} from '../quota-watch.js';
+import type { QuotaUtilization } from '../quota-check.js';
+
+const NOW = new Date('2026-05-15T00:53:00Z');
+
+// Two representative payloads that broke under escapeMarkdown-in-code-span:
+// an email/label with an underscore, and a vault-key-shaped secret ref.
+const LABEL_UNDERSCORE = 'ken_max';
+const SECRET_REF = 'secret:OPENAI_API_KEY';
+
+function quota(part: Partial<QuotaUtilization>): QuotaUtilization {
+  return {
+    fiveHourUtilizationPct: 0,
+    sevenDayUtilizationPct: 0,
+    fiveHourResetAt: null,
+    sevenDayResetAt: null,
+    representativeClaim: null,
+    overageStatus: null,
+    overageDisabledReason: null,
+    ...part,
+  };
+}
+
+function snap(part: Partial<AccountSnapshot>): AccountSnapshot {
+  return {
+    label: 'unset@example.com',
+    isActive: false,
+    quota: null,
+    ...part,
+  };
+}
+
+/**
+ * Assert `value` renders LITERALLY inside a code span somewhere in `rendered`:
+ *  - the exact `` `value` `` span is present, and
+ *  - no backslash-escaped variant of the value leaked (no `\_`, `\*`, etc.).
+ */
+function expectLiteralInCodeSpan(rendered: string, value: string) {
+  expect(rendered).toContain('`' + value + '`');
+  // The buggy output would be `` `secret:OPENAI\_API\_KEY` `` — assert no
+  // backslash immediately precedes any char of the value's active set.
+  const escaped = escapeMarkdown(value);
+  if (escaped !== value) {
+    // escapeMarkdown would have produced a different (backslashed) string;
+    // that exact string must NOT appear.
+    expect(rendered).not.toContain('`' + escaped + '`');
+  }
+  // Belt-and-suspenders: no stray backslash before an identifier char.
+  expect(rendered).not.toMatch(/\\[_*~=\[\]|]/);
+}
+
+describe('codeSpanSafe helper', () => {
+  it('leaves identifier chars untouched (no backslash)', () => {
+    expect(codeSpanSafe(LABEL_UNDERSCORE)).toBe(LABEL_UNDERSCORE);
+    expect(codeSpanSafe(SECRET_REF)).toBe(SECRET_REF);
+    expect(codeSpanSafe('a_b*c~d=e[f]g|h')).toBe('a_b*c~d=e[f]g|h');
+  });
+
+  it('neutralizes an embedded backtick so it cannot close the span', () => {
+    const out = codeSpanSafe('a`b');
+    // A raw backtick would close the surrounding span; the transform must
+    // insert a separator so `` `${out}` `` cannot be split into two spans.
+    expect(out).not.toBe('a`b');
+    expect(out.startsWith('a`')).toBe(true);
+    // The zero-width space sits right after the backtick.
+    expect(out).toContain('`​');
+  });
+
+  it('escapeMarkdown (the WRONG helper for code spans) would backslash these', () => {
+    // Guards the premise: if someone reverts to escapeMarkdown, the output
+    // differs — proving these goldens actually catch the regression.
+    expect(escapeMarkdown(LABEL_UNDERSCORE)).toBe('ken\\_max');
+    expect(escapeMarkdown(SECRET_REF)).toContain('\\_');
+  });
+});
+
+describe('/auth card — code-span labels render literally (#2695)', () => {
+  it('renders an underscore label literally in the /usage table account cell', () => {
+    const rendered = renderAuthSnapshotFormat2(
+      [snap({ label: LABEL_UNDERSCORE, isActive: true, quota: quota({ fiveHourUtilizationPct: 10, sevenDayUtilizationPct: 20 }) })],
+      { now: NOW },
+    );
+    // The account cell wraps the label (plus the (active) suffix) in a code span.
+    expect(rendered).toContain('`' + LABEL_UNDERSCORE + ' (active)`');
+    expect(rendered).not.toContain('ken\\_max');
+    expect(rendered).not.toMatch(/\\[_*~=\[\]|]/);
+  });
+
+  it('renders a secret-ref-shaped label literally in the account cell', () => {
+    const rendered = renderAuthSnapshotFormat2(
+      [snap({ label: SECRET_REF, quota: quota({ fiveHourUtilizationPct: 5, sevenDayUtilizationPct: 5 }) })],
+      { now: NOW },
+    );
+    expect(rendered).toContain('`' + SECRET_REF + '`');
+    expect(rendered).not.toMatch(/\\[_*~=\[\]|]/);
+  });
+
+  it('renders the label literally in the fallback-announcement code spans', () => {
+    const rendered = renderFallbackAnnouncement({
+      oldLabel: LABEL_UNDERSCORE,
+      newLabel: 'new_acct',
+      triggerAgent: 'clerk',
+      oldQuota: null,
+      newQuota: quota({ fiveHourUtilizationPct: 3, sevenDayUtilizationPct: 4 }),
+      now: NOW,
+    });
+    // Code spans are literal (the fix). The **bold** header legitimately
+    // escapes the label — that is emphasis context, out of scope here — so we
+    // only assert the code-span form, not a global no-backslash rule.
+    expect(rendered).toContain('`' + LABEL_UNDERSCORE + '`');
+    expect(rendered).toContain('`new_acct`');
+    expect(rendered).not.toContain('`ken\\_max`');
+  });
+});
+
+describe('quota card — code-span labels render literally (#2695)', () => {
+  it('throttling card renders an underscore label literally', () => {
+    const rendered = buildThrottlingMessage(
+      'clerk',
+      snap({ label: LABEL_UNDERSCORE, isActive: true, quota: quota({ fiveHourUtilizationPct: 85, sevenDayUtilizationPct: 40 }) }),
+    );
+    expectLiteralInCodeSpan(rendered, LABEL_UNDERSCORE);
+  });
+
+  it('throttling card renders a secret-ref label literally (non-active use hint)', () => {
+    const rendered = buildThrottlingMessage(
+      'clerk',
+      snap({ label: SECRET_REF, isActive: false, quota: quota({ fiveHourUtilizationPct: 90, sevenDayUtilizationPct: 30 }) }),
+    );
+    expectLiteralInCodeSpan(rendered, SECRET_REF);
+  });
+
+  it('recovery card renders an underscore label literally', () => {
+    const rendered = buildRecoveryMessage(
+      'clerk',
+      snap({ label: LABEL_UNDERSCORE, isActive: true, quota: quota({ fiveHourUtilizationPct: 10, sevenDayUtilizationPct: 5 }) }),
+    );
+    expectLiteralInCodeSpan(rendered, LABEL_UNDERSCORE);
+  });
+});

package/telegram-plugin/tests/credits-watch.test.ts

@@ -188,6 +188,24 @@ describe("evaluateCreditState — transition decisions (machinery, explicit fata
     // The underscore is escaped so it can't open an italic run inside **…**.
     expect(d.message).toContain("ev\\_il");
   });
+
+  // Boundary-escaping after the #2695 escaper de-dup: the entry message escapes
+  // BOTH the agent name and the raw reason via the consolidated `escapeMarkdown`
+  // import. A metacharacter-laden value through each site proves the import swap
+  // preserved escaping at this call-site.
+  it("escapes metacharacters in both the agent name and the cached reason (#2695)", () => {
+    const d = evaluateCreditState({
+      agentName: "a_b*c",
+      currentReason: "weird_reason*x",
+      prev: HEALTHY,
+      now: NOW,
+      fatalReasons: new Set(["weird_reason*x"]),
+    });
+    expect(d.kind).toBe("notify");
+    if (d.kind !== "notify") return;
+    expect(d.message).toContain("a\\_b\\*c");
+    expect(d.message).toContain("weird\\_reason\\*x");
+  });
 });
 
 describe("evaluateCreditState — subscription-only default (the fix)", () => {

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

@@ -0,0 +1,223 @@
+/**
+ * Tests for the fleet-wide consistent-formatting bundle:
+ *
+ *   1. addParagraphSpacers extension — a visible U+00A0 spacer line at EVERY
+ *      block transition (paragraph→list, list→paragraph, heading→anything,
+ *      blockquote/table boundaries), never inside a list/table interior.
+ *   2. normalizePunctuation — em/en dashes → comma/hyphen, leading `•`/`·`
+ *      list markers → `- `, on code-masked text, idempotent.
+ *   3. stripExcessBold — over-bold tripwire: >30% bold or fully-bolded
+ *      paragraphs/lists lose their bold markers; short messages exempt.
+ */
+import { describe, test, expect } from 'vitest'
+import {
+  addParagraphSpacers,
+  normalizeParagraphBreaks,
+  normalizePunctuation,
+  stripExcessBold,
+  splitMarkdownChunks,
+  PARAGRAPH_SPACER,
+} from '../format.js'
+
+const SP = PARAGRAPH_SPACER // U+00A0
+
+describe('addParagraphSpacers — uniform block spacing', () => {
+  test('still spaces prose→prose (existing behaviour)', () => {
+    const out = addParagraphSpacers('Alpha.\n\nBravo.')
+    expect(out).toBe(`Alpha.\n\n${SP}\n\nBravo.`)
+  })
+
+  test('spaces paragraph→list transition', () => {
+    const out = addParagraphSpacers('Intro.\n\n- one\n- two')
+    expect(out).toBe(`Intro.\n\n${SP}\n\n- one\n- two`)
+  })
+
+  test('spaces list→paragraph transition', () => {
+    const out = addParagraphSpacers('- one\n- two\n\nOutro.')
+    expect(out).toBe(`- one\n- two\n\n${SP}\n\nOutro.`)
+  })
+
+  test('spaces heading→anything', () => {
+    expect(addParagraphSpacers('# Title\n\nBody.')).toBe(`# Title\n\n${SP}\n\nBody.`)
+    expect(addParagraphSpacers('# Title\n\n- a\n- b')).toBe(`# Title\n\n${SP}\n\n- a\n- b`)
+  })
+
+  test('spaces blockquote and table boundaries', () => {
+    expect(addParagraphSpacers('> quoted\n\nProse.')).toBe(`> quoted\n\n${SP}\n\nProse.`)
+    const table = '| a | b |\n| --- | --- |\n| 1 | 2 |'
+    expect(addParagraphSpacers(`Prose.\n\n${table}`)).toBe(`Prose.\n\n${SP}\n\n${table}`)
+    expect(addParagraphSpacers(`${table}\n\nProse.`)).toBe(`${table}\n\n${SP}\n\nProse.`)
+  })
+
+  test('does NOT space between items of the same loose list', () => {
+    const input = '- one\n\n- two\n\n- three'
+    expect(addParagraphSpacers(input)).toBe(input)
+  })
+
+  test('does NOT space inside a tight list or table interior (single \\n)', () => {
+    const list = 'Intro.\n\n- a\n- b\n- c'
+    expect(addParagraphSpacers(list)).toBe(`Intro.\n\n${SP}\n\n- a\n- b\n- c`)
+    const table = '| a |\n| --- |\n| 1 |\n| 2 |'
+    expect(addParagraphSpacers(table)).toBe(table)
+  })
+
+  test('idempotent across every transition kind', () => {
+    const input = '# H\n\nProse one.\n\n- a\n- b\n\nProse two.\n\n> quote'
+    const once = addParagraphSpacers(input)
+    expect(addParagraphSpacers(once)).toBe(once)
+  })
+
+  test('never touches code fences', () => {
+    const input = '```\nA\n\nB\n```\n\n```\nC\n```'
+    expect(addParagraphSpacers(input)).toBe(input)
+  })
+
+  test('full pipeline: mixed prose+list+heading message gets uniform gaps', () => {
+    const raw = 'Summary line.\n- item one\n- item two\nClosing prose.'
+    const out = addParagraphSpacers(normalizeParagraphBreaks(raw))
+    // Every block transition carries exactly one visible spacer line.
+    expect(out).toBe(
+      `Summary line.\n\n${SP}\n\n- item one\n- item two\n\n${SP}\n\nClosing prose.`,
+    )
+  })
+
+  test('chunk-boundary interaction: a cut in a spacer gap strips the spacer', () => {
+    const a = 'A'.repeat(60)
+    const b = 'B'.repeat(60)
+    const text = `${a}\n\n${SP}\n\n${b}`
+    const chunks = splitMarkdownChunks(text, 80)
+    expect(chunks.length).toBe(2)
+    expect(chunks[0]).toBe(a)
+    expect(chunks[1]).toBe(b)
+  })
+})
+
+describe('normalizePunctuation', () => {
+  test('spaced em-dash → comma', () => {
+    expect(normalizePunctuation('voice came back — three PRs stacked')).toBe(
+      'voice came back, three PRs stacked',
+    )
+  })
+
+  test('spaced en-dash → comma', () => {
+    expect(normalizePunctuation('one thing – another thing')).toBe('one thing, another thing')
+  })
+
+  test('bare em-dash between words → comma', () => {
+    expect(normalizePunctuation('word—word')).toBe('word, word')
+  })
+
+  test('bare en-dash between words → hyphen (ranges survive as ASCII)', () => {
+    expect(normalizePunctuation('2019–2024')).toBe('2019-2024')
+    expect(normalizePunctuation('pre–war')).toBe('pre-war')
+  })
+
+  test('digit-flanked spaced dash → hyphen range, not comma', () => {
+    expect(normalizePunctuation('3 – 5 days')).toBe('3-5 days')
+    expect(normalizePunctuation('10 — 20')).toBe('10-20')
+  })
+
+  test('leading • and · bullets → `- ` (indent preserved)', () => {
+    expect(normalizePunctuation('• one\n• two')).toBe('- one\n- two')
+    expect(normalizePunctuation('  · indented')).toBe('  - indented')
+  })
+
+  test('mid-line bullet glyph untouched', () => {
+    expect(normalizePunctuation('rated 4.5 • 120 reviews')).toBe('rated 4.5 • 120 reviews')
+  })
+
+  test('never touches code spans or fences', () => {
+    const input = 'run `a — b` now\n\n```\nx — y\n• bullet\n```'
+    expect(normalizePunctuation(input)).toBe(input)
+  })
+
+  test('idempotent', () => {
+    const once = normalizePunctuation('a — b\n• c\nd—e\n1–2')
+    expect(normalizePunctuation(once)).toBe(once)
+  })
+
+  test('consecutive spaced dashes all normalize in ONE pass (#2755 finding 2)', () => {
+    expect(normalizePunctuation('a — b — c')).toBe('a, b, c')
+    expect(normalizePunctuation('one — two — three — four')).toBe('one, two, three, four')
+    expect(normalizePunctuation('x—y—z')).toBe('x, y, z')
+    expect(normalizePunctuation('1–2–3')).toBe('1-2-3')
+  })
+
+  test('cross-path ordering: normalizePunctuation before scrubVoice yields the comma treatment', async () => {
+    // The stream path runs normalizePunctuation BEFORE scrubVoice, same as
+    // reply/edit — so a spaced em-dash gets the comma substitution on every
+    // path, and scrubVoice (period substitution) finds no dash left. Pins
+    // the #2755 finding-1 ordering contract.
+    const { scrubVoice } = await import('../text-voice-scrub.js')
+    const input = 'voice came back — three PRs stacked'
+    const normalized = normalizePunctuation(input)
+    const scrub = scrubVoice(normalized)
+    expect(normalized).toBe('voice came back, three PRs stacked')
+    expect(scrub.replaced).toBe(0)
+    expect(scrub.scrubbed).toBe(normalized)
+  })
+})
+
+describe('stripExcessBold', () => {
+  const filler =
+    'This is an ordinary paragraph of connected prose that provides enough plain ' +
+    'characters to clear the one-hundred character exemption comfortably.'
+
+  test('short messages (<100 chars) exempt even when fully bold', () => {
+    const input = '**Everything here is bold.**'
+    expect(stripExcessBold(input)).toBe(input)
+  })
+
+  test('strips all bold when >30% of non-code chars are bold', () => {
+    const bold = '**' + 'B'.repeat(80) + '**'
+    const input = `${bold} plus a little plain text tail here.`
+    const out = stripExcessBold(input)
+    expect(out).not.toContain('**')
+    expect(out).toContain('B'.repeat(80))
+  })
+
+  test('keeps bold when clearly under threshold', () => {
+    const input = `${filler} The key fact is **42**.`
+    expect(stripExcessBold(input)).toBe(input)
+  })
+
+  test('strips a fully-bolded multi-line paragraph, leaves others', () => {
+    const input = `${filler}\n\n**This whole paragraph is bold.**\n**Every single line of it.**`
+    const out = stripExcessBold(input)
+    expect(out).toContain('This whole paragraph is bold.')
+    expect(out).not.toContain('**This whole paragraph is bold.**')
+    expect(out.startsWith(filler)).toBe(true)
+  })
+
+  test('single short fully-bolded line (pseudo-heading) survives', () => {
+    const input = `**Summary**\n\n${filler}`
+    expect(stripExcessBold(input)).toBe(input)
+  })
+
+  test('strips a list whose EVERY item is fully bolded', () => {
+    const input = `${filler}\n\n- **alpha item**\n- **bravo item**\n- **charlie item**`
+    const out = stripExcessBold(input)
+    expect(out).toContain('- alpha item')
+    expect(out).not.toContain('**alpha item**')
+  })
+
+  test('leaves a list where only some items are bolded', () => {
+    const input = `${filler}\n\n- **alpha item**\n- plain bravo\n- plain charlie`
+    expect(stripExcessBold(input)).toBe(input)
+  })
+
+  test('code regions neither counted nor modified', () => {
+    const fence = '```\n**not really bold**\n' + 'x'.repeat(400) + '\n```'
+    const input = `${filler} Key: **fact**.\n\n${fence}`
+    const out = stripExcessBold(input)
+    expect(out).toContain('**not really bold**')
+    expect(out).toContain('**fact**')
+  })
+
+  test('idempotent', () => {
+    const bold = '**' + 'B'.repeat(80) + '**'
+    const input = `${bold} plus a little plain text tail.`
+    const once = stripExcessBold(input)
+    expect(stripExcessBold(once)).toBe(once)
+  })
+})