switchroom 0.18.18 → 0.18.19

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

@@ -12,8 +12,6 @@ import { describe, test, expect } from 'vitest'
 import {
   normalizeParagraphBreaks,
   splitCollapsedInlineBullets,
-  addParagraphSpacers,
-  PARAGRAPH_SPACER,
 } from '../format.js'
 
 describe('normalizeParagraphBreaks', () => {
@@ -433,96 +431,44 @@ describe('splitCollapsedInlineBullets', () => {
 })
 
 // ---------------------------------------------------------------------------
-// addParagraphSpacers — restore a VISIBLE blank line between prose paragraphs.
+// Paragraph gap spacing — plain \n\n, no NBSP spacer (#2669 follow-up).
 //
-// The rich GFM renderer (post-#2669) collapses a `\n\n` paragraph gap TIGHT, so
-// multi-paragraph replies render jammed together — the operator-confirmed
-// regression vs the old HTML path (`parse_mode:"HTML"`, `\n\n` → real blank
-// line). addParagraphSpacers wedges a U+00A0 spacer paragraph into each prose
-// `\n\n` gap so the rich renderer shows a visible empty line. Conservative:
-// only between two prose blocks, never adjacent to list/table/code/quote/heading.
+// The NBSP paragraph-spacer (addParagraphSpacers / PARAGRAPH_SPACER) was
+// REMOVED: its premise — that the Bot API 10.1 rich GFM renderer collapses a
+// `\n\n` gap TIGHT — is false for the live renderer, which shows a `\n\n` gap
+// as one normal blank line. The spacer therefore injected a spurious SECOND
+// blank line (`\n\n \n\n`) between every paragraph fleet-wide. Paragraph
+// spacing now relies on the plain `\n\n` that normalizeParagraphBreaks already
+// guarantees. These tests pin: multi-paragraph output has exactly one blank
+// line per gap, and no U+00A0 anywhere.
 // ---------------------------------------------------------------------------
 
-describe('addParagraphSpacers', () => {
-  const gap = `\n\n${PARAGRAPH_SPACER}\n\n`
+describe('paragraph gap spacing — single blank line, no NBSP', () => {
+  const NBSP = String.fromCharCode(0xa0)
 
-  test('the spacer is a single non-breaking space (U+00A0), not an ASCII space', () => {
-    expect(PARAGRAPH_SPACER).toBe(' ')
+  test('a two-paragraph prose body has exactly one blank-line gap and no NBSP', () => {
+    const out = normalizeParagraphBreaks('Paragraph one.\n\nParagraph two.')
+    expect(out).toBe('Paragraph one.\n\nParagraph two.')
+    expect(out).not.toContain(NBSP)
+    // Exactly one empty line between the two content lines.
+    expect(out.split('\n')).toEqual(['Paragraph one.', '', 'Paragraph two.'])
   })
 
-  test('inserts a visible spacer paragraph into a prose `\\n\\n` gap', () => {
-    expect(addParagraphSpacers('Paragraph one.\n\nParagraph two.')).toBe(
-      `Paragraph one.${gap}Paragraph two.`,
-    )
-  })
-
-  test('spaces every gap in a three-paragraph body', () => {
-    expect(addParagraphSpacers('One.\n\nTwo.\n\nThree.')).toBe(
-      `One.${gap}Two.${gap}Three.`,
-    )
-  })
-
-  test('is idempotent — a spaced gap is not doubled on a second pass', () => {
-    const once = addParagraphSpacers('Alpha.\n\nBravo.')
-    expect(addParagraphSpacers(once)).toBe(once)
-  })
-
-  test('leaves a single-`\\n` separation alone (only `\\n\\n` gaps are spaced)', () => {
-    // normalizeParagraphBreaks owns lone-break promotion; this pass only adds a
-    // visible spacer where a genuine blank-line gap already exists.
-    const input = 'Line one.\nLine two.'
-    expect(addParagraphSpacers(input)).toBe(input)
+  test('a three-paragraph body keeps single-blank-line gaps, no NBSP', () => {
+    const out = normalizeParagraphBreaks('One.\n\nTwo.\n\nThree.')
+    expect(out).toBe('One.\n\nTwo.\n\nThree.')
+    expect(out).not.toContain(NBSP)
+    // No gap is a DOUBLE blank line (`\n\n\n`), which the old spacer produced.
+    expect(out).not.toMatch(/\n\n\n/)
   })
 
-  test('spaces prose↔list transitions (uniform block spacing), list interior tight', () => {
-    expect(addParagraphSpacers('Here are the steps.\n\n- first\n- second')).toBe(
-      `Here are the steps.${gap}- first\n- second`,
-    )
-    expect(addParagraphSpacers('- first\n- second\n\nClosing prose after the list.')).toBe(
-      `- first\n- second${gap}Closing prose after the list.`,
-    )
+  test('prose->list transition is a single `\n\n` boundary, list interior tight', () => {
+    const out = normalizeParagraphBreaks('Here are the steps.\n\n- first\n- second')
+    expect(out).toBe('Here are the steps.\n\n- first\n- second')
+    expect(out).not.toContain(NBSP)
   })
 
-  test('spaces a prose→table boundary; table rows stay contiguous', () => {
-    const table = '| a | b |\n| --- | --- |\n| 1 | 2 |'
-    expect(addParagraphSpacers(`Intro.\n\n${table}`)).toBe(`Intro.${gap}${table}`)
-  })
-
-  test('spaces prose↔fence boundaries; fence interior untouched', () => {
-    const input = 'Look here.\n\n```js\nconst a = 1;\n```\n\nDone.'
-    expect(addParagraphSpacers(input)).toBe(
-      `Look here.${gap}\`\`\`js\nconst a = 1;\n\`\`\`${gap}Done.`,
-    )
-  })
-
-  test('spaces heading→anything and blockquote boundaries', () => {
-    expect(addParagraphSpacers('Intro prose.\n\n## Section\n\nBody prose.')).toBe(
-      `Intro prose.${gap}## Section${gap}Body prose.`,
-    )
-    expect(addParagraphSpacers('Said.\n\n> a quote\n\nAfter.')).toBe(
-      `Said.${gap}> a quote${gap}After.`,
-    )
-  })
-
-  test('does NOT space between items of the same loose list / same-kind blocks', () => {
-    const looseList = '- first\n\n- second\n\n- third'
-    expect(addParagraphSpacers(looseList)).toBe(looseList)
-    const quotes = '> one\n\n> two'
-    expect(addParagraphSpacers(quotes)).toBe(quotes)
-  })
-
-  test('never reaches inside a fenced block (interior blank line untouched)', () => {
-    const input = 'Before.\n\n```\nline 1\n\nline 2\n```\n\nAfter.'
-    const out = addParagraphSpacers(input)
-    // The fence interior — including its own blank line — is byte-for-byte intact.
-    expect(out).toContain('```\nline 1\n\nline 2\n```')
-  })
-
-  test('a body with no paragraph gap is returned unchanged', () => {
-    expect(addParagraphSpacers('just one paragraph, no gap')).toBe('just one paragraph, no gap')
-  })
-
-  test('composes after normalizeParagraphBreaks: prose gap spaced, list left tight', () => {
+  test('composed prose+list body: one blank line per gap, no NBSP, no double gap', () => {
     const input = [
       'Summary of the change.',
       '',
@@ -531,12 +477,11 @@ describe('addParagraphSpacers', () => {
       '- adds a normalizer',
       '- lifts the cap',
     ].join('\n')
-    const out = addParagraphSpacers(normalizeParagraphBreaks(input))
-    // The two prose paragraphs gain a visible spacer between them.
-    expect(out).toContain(`Summary of the change.${gap}It does two things.`)
-    // The prose→list transition gains a spacer too (uniform block spacing),
-    // but the list INTERIOR stays tight.
-    expect(out).toContain(`It does two things.${gap}- adds a normalizer\n- lifts the cap`)
+    const out = normalizeParagraphBreaks(input)
+    expect(out).toContain('Summary of the change.\n\nIt does two things.')
+    expect(out).toContain('It does two things.\n\n- adds a normalizer\n- lifts the cap')
+    expect(out).not.toContain(NBSP)
+    expect(out).not.toMatch(/\n\n\n/)
   })
 })
 
@@ -577,12 +522,12 @@ describe('normalizeParagraphBreaks — inline bullet split integration', () => {
  * ragged / oversized gap: CommonMark discards it so it buys no visible space,
  * but it reads as noise in the raw text. Step 1 of normalizeParagraphBreaks now
  * collapses any run of blank lines — including whitespace-only interior lines —
- * to exactly one clean `\n\n`, WITHOUT ever eating the deliberate U+00A0
- * paragraph spacer that addParagraphSpacers (#2692) adds later for a visible
- * gap on the rich-message path.
+ * to exactly one clean `\n\n`. The collapse is deliberately ASCII-only, so a
+ * genuine user-typed U+00A0 line survives (the conservative choice; there is no
+ * longer an NBSP paragraph spacer to protect — that pass was removed).
  */
 describe('normalizeParagraphBreaks — whitespace-only blank-line collapse (Bug 2)', () => {
-  const NBSP = ' '
+  const NBSP = String.fromCharCode(0xa0)
 
   test('a lone-space blank line between paragraphs collapses to a clean `\\n\\n` (real string)', () => {
     const input =
@@ -635,14 +580,11 @@ describe('normalizeParagraphBreaks — whitespace-only blank-line collapse (Bug
     expect(normalizeParagraphBreaks(input)).toBe(input)
   })
 
-  test('the deliberate U+00A0 spacer from addParagraphSpacers is preserved (no #2692 regression)', () => {
-    const normalized = normalizeParagraphBreaks('Alpha para.\n\nBravo para.')
-    const spaced = addParagraphSpacers(normalized)
-    // addParagraphSpacers wedges a U+00A0-only line to force a visible gap.
-    expect(spaced).toContain('\n\n' + PARAGRAPH_SPACER + '\n\n')
-    expect(spaced.split('\n')).toContain(NBSP)
-    // And re-running the normalizer must NOT eat that intentional spacer.
-    expect(normalizeParagraphBreaks(spaced)).toBe(spaced)
+  test('a genuine user-typed U+00A0-only line survives (ASCII-only collapse)', () => {
+    // The blank-line collapse is deliberately ASCII-only, so a non-breaking
+    // space a user actually typed on its own line is not silently eaten.
+    const input = 'Alpha para.\n' + NBSP + '\nBravo para.'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
   })
 
   test('idempotent: collapsing a stray gap twice is stable', () => {

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

@@ -120,13 +120,12 @@ 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 () => {
+  it('rich path sends the multi-paragraph `\\n\\n` gap byte-exact (no NBSP spacer)', async () => {
+    // The NBSP paragraph-spacer pass was removed in the #2669 follow-up — the
+    // rich renderer shows a plain `\n\n` gap as one blank line, so the handler
+    // passes the text through unchanged.
     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 deps = makeDeps(bot)
 
     const pending = handleStreamReply(
       { chat_id: '1', text: 'Para one.\n\nPara two.', done: true },
@@ -137,14 +136,13 @@ describe('handleStreamReply', () => {
     await pending
 
     expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
-    expect(richSendMarkdown(bot)).toBe('Para one.\n\nSPACER\n\nPara two.')
+    expect(richSendMarkdown(bot)).toBe('Para one.\n\nPara two.')
+    expect(richSendMarkdown(bot)).not.toContain(String.fromCharCode(0xa0))
   })
 
-  it('does NOT apply addParagraphSpacers on the literal format=text path', async () => {
+  it('literal format=text path is byte-exact too', async () => {
     const state = makeState()
-    const deps = makeDeps(bot, {
-      addParagraphSpacers: (t) => t.replace(/\n\n/g, '\n\nSPACER\n\n'),
-    })
+    const deps = makeDeps(bot)
 
     const pending = handleStreamReply(
       { chat_id: '1', text: 'Para one.\n\nPara two.', format: 'text', done: true },
@@ -155,7 +153,6 @@ describe('handleStreamReply', () => {
     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.')
   })
 

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

@@ -19,8 +19,6 @@ import {
   repairEscapedWhitespace,
   escapeMarkdown,
   splitMarkdownChunks,
-  addParagraphSpacers,
-  PARAGRAPH_SPACER,
   RICH_MESSAGE_MAX_CHARS,
 } from '../format.js'
 
@@ -187,62 +185,119 @@ describe('splitMarkdownChunks', () => {
   })
 
   // -------------------------------------------------------------------------
-  // 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).
+  // Chunk-boundary blank-line hygiene. Paragraph gaps are now plain `\n\n`
+  // (the NBSP spacer was removed in the #2669 follow-up). When a cut lands in
+  // a gap, the boundary must not leave a chunk that opens or ends with a bare
+  // blank line, and no visible content may be dropped.
   // -------------------------------------------------------------------------
 
-  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.
+  test('no chunk starts or ends with a bare blank line at a `\\n\\n` gap cut', () => {
     const A = 'Alpha sentence one'
     const B = 'Bravo sentence two'
-    const spaced = addParagraphSpacers(`${A}.\n\n${B}.`)
-    const chunks = splitMarkdownChunks(spaced, 33)
+    const text = `${A}.\n\n${B}.`
+    const chunks = splitMarkdownChunks(text, 33)
     expect(chunks.length).toBeGreaterThan(1)
-    const spacerOnly = new RegExp(`^[ \\t]*${PARAGRAPH_SPACER}[ \\t]*$`)
+    const blankOnly = /^[ \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)
+      expect(blankOnly.test(lines[0])).toBe(false)
+      expect(blankOnly.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 text = `${A}.\n\n${B}.`
+    const chunks = splitMarkdownChunks(text, 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', () => {
+  test('blank-line-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]*$`)
+    const text = paras.join('\n\n')
+    const blankOnly = /^[ \t]*$/
     for (const cap of [20, 31, 40, 64]) {
-      const chunks = splitMarkdownChunks(spaced, cap)
+      const chunks = splitMarkdownChunks(text, 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)
+        expect(blankOnly.test(lines[0])).toBe(false)
+        expect(blankOnly.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.)
+      // No visible word is dropped: concatenating the chunks' non-blank tokens
+      // reproduces the original word sequence. (Word-level, not line-level,
+      // because a small cap may split mid-word — the chunker's normal
+      // space-boundary behaviour.)
+      const words = (s: string): string[] => s.split(/\s+/).filter((w) => w.length > 0)
       expect(words(chunks.join(' '))).toEqual(words(paras.join(' ')))
     }
   })
 
+  // -------------------------------------------------------------------------
+  // Entity-aware chunking (#finding-3): a cut must never bisect an inline
+  // span (`**bold**`, `` `code` ``, `_italic_`, `[label](href)`), which would
+  // strand an unclosed delimiter in the emitted chunk.
+  // -------------------------------------------------------------------------
+
+  test('a bold/code/link span straddling the cap is not bisected (balanced delimiters)', () => {
+    // Build a body where each inline span sits right around a small cap so the
+    // naive space/newline cut would land inside it. Every span is shorter than
+    // the smallest cap tried (the longest is the 34-char link), so a straddling
+    // span can always be kept whole — the entity-aware back-off must do so.
+    const filler = 'x'.repeat(30)
+    const body =
+      `${filler} **bold span here** ` +
+      `${filler} \`code span here\` ` +
+      `${filler} [label here](https://ex.com/a-b-c) ` +
+      `${filler} _italic span here_ ${filler}`
+    for (const cap of [40, 50, 60, 70, 80]) {
+      const chunks = splitMarkdownChunks(body, cap)
+      for (const c of chunks) {
+        // Balanced `**` and single-backtick delimiters in every chunk.
+        expect((c.match(/\*\*/g) ?? []).length % 2).toBe(0)
+        expect((c.match(/`/g) ?? []).length % 2).toBe(0)
+        // No chunk ends mid-link (an open `](` with no closing `)`), and no
+        // chunk starts with an orphan link tail.
+        const opens = (c.match(/\]\(/g) ?? []).length
+        const closesAfterOpen = (c.match(/\]\([^)\n]*\)/g) ?? []).length
+        expect(opens).toBe(closesAfterOpen)
+      }
+      // Nothing is dropped.
+      const words = (s: string): string[] => s.split(/\s+/).filter((w) => w.length > 0)
+      expect(words(chunks.join(' '))).toEqual(words(body))
+    }
+  })
+
+  test('a `***bold-italic***` / `___…___` span straddling the cap keeps SINGLE-marker balance', () => {
+    // Regression for the triple-marker case: without the `***…***` pattern, the
+    // bold pattern matches only the inner `**…**`, so a cut inside `***x***`
+    // strands the lone outer `*` (odd asterisk count → the italic is lost). A
+    // `**`-PAIR balance check misses that, so assert SINGLE-`*` / SINGLE-`_`
+    // balance in every chunk.
+    const filler = 'x'.repeat(30)
+    const body =
+      `${filler} ***bold italic here*** ` +
+      `${filler} ___under bold here___ ${filler}`
+    for (const cap of [40, 50, 60, 70]) {
+      const chunks = splitMarkdownChunks(body, cap)
+      for (const c of chunks) {
+        // SINGLE-marker balance: an even count of `*` and of `_` in every chunk
+        // (a stranded lone `*`/`_` from a bisected triple span makes it odd).
+        expect((c.match(/\*/g) ?? []).length % 2).toBe(0)
+        expect((c.match(/_/g) ?? []).length % 2).toBe(0)
+      }
+      // Each triple span survives intact in exactly one chunk.
+      const rejoined = chunks.join('\n')
+      expect(rejoined).toContain('***bold italic here***')
+      expect(rejoined).toContain('___under bold here___')
+      // Nothing dropped.
+      const words = (s: string): string[] => s.split(/\s+/).filter((w) => w.length > 0)
+      expect(words(chunks.join(' '))).toEqual(words(body))
+    }
+  })
+
   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)

package/telegram-plugin/tests/turn-flush-safety.test.ts

@@ -31,9 +31,7 @@ import {
   normalizeParagraphBreaks,
   normalizePunctuation,
   stripExcessBold,
-  addParagraphSpacers,
   splitMarkdownChunks,
-  PARAGRAPH_SPACER,
   RICH_MESSAGE_MAX_CHARS,
 } from '../format.js'
 
@@ -130,7 +128,9 @@ describe('decideTurnFlush — prose+trailing-sentinel is suppressed, not leaked
 // the real gateway turn-flush render pipeline (post-#2669 rich-markdown path):
 //   decideTurnFlush -> join('\n\n')
 //   -> repairEscapedWhitespace -> normalizeParagraphBreaks
-//   -> addParagraphSpacers -> splitMarkdownChunks -> sendRichMessage
+//   -> splitMarkdownChunks -> sendRichMessage
+// (no paragraph-spacer pass — the NBSP spacer was removed in the #2669
+//  follow-up; gaps are plain `\n\n`, one visible blank line)
 // so it pins the end-to-end fix, not just the pure decision. The corpus is a
 // REAL captured-transcript shape (three separate content[i].text blocks, one
 // stored UNTRIMMED with a trailing '\n' exactly as session-tail.ts pushes
@@ -156,8 +156,7 @@ describe('#2798 turn-flush block separation — real multi-block transcript shap
     const d = decideTurnFlush({ chatId: '12345', replyCalled: false, capturedText: blocks })
     expect(d.kind).toBe('flush')
     const joined = (d as { kind: 'flush'; text: string }).text
-    const normalized = normalizeParagraphBreaks(repairEscapedWhitespace(joined))
-    return addParagraphSpacers(normalized)
+    return normalizeParagraphBreaks(repairEscapedWhitespace(joined))
   }
 
   it('separates whole blocks with a visible paragraph gap, not a wall-of-text', () => {
@@ -167,32 +166,29 @@ describe('#2798 turn-flush block separation — real multi-block transcript shap
     expect(out).toContain('The `auth` handler looks correct')
     expect(out).toContain('Want me to open a PR')
     // The wall-of-text failure mode glues two blocks one '\n' apart. Assert the
-    // boundary carries a real paragraph break with the injected visible spacer
-    // line (#2692 rich-path spacer), and NOT a single-newline join.
-    expect(out).toContain(`\n\n${PARAGRAPH_SPACER}\n\n`)
+    // boundary carries a real paragraph break (plain `\n\n`, one blank line —
+    // no NBSP spacer), and NOT a single-newline join.
+    expect(out).toContain('flagged.\n\nThe `auth`')
     expect(out).not.toContain('flagged.\nThe `auth`')
-    // A spacer sits specifically between block 1 and block 2.
-    const b1 = out.indexOf('flagged.')
-    const b2 = out.indexOf('The `auth` handler')
-    expect(out.slice(b1, b2)).toContain(PARAGRAPH_SPACER)
+    // No U+00A0 anywhere.
+    expect(out).not.toContain(String.fromCharCode(0xa0))
   })
 
   it('collapses the untrimmed-trailing-newline stack — no 3+ newline run reaches the wire', () => {
     const out = renderLikeTurnFlush(realBlocks)
     // Block 2's trailing '\n' + the '\n\n' join = 3 newlines; normalize
-    // collapses 3+ runs to '\n\n' and addParagraphSpacers wedges exactly one
-    // spacer, so no doubled/stacked blank run survives.
+    // collapses 3+ runs to '\n\n', so no doubled/stacked blank run survives.
     expect(out).not.toMatch(/\n{3,}/)
-    // One spacer per block transition: 3 blocks → 2 gaps → 2 spacers.
-    const spacerCount = out.split(PARAGRAPH_SPACER).length - 1
-    expect(spacerCount).toBe(2)
+    // One blank-line gap per block transition: 3 blocks → 2 gaps.
+    const gapCount = (out.match(/\n\n/g) ?? []).length
+    expect(gapCount).toBe(2)
   })
 
   it('the whole separated answer stays in one rich chunk here (well under 32768)', () => {
     const out = renderLikeTurnFlush(realBlocks)
     const chunks = splitMarkdownChunks(out, RICH_MESSAGE_MAX_CHARS)
     expect(chunks.length).toBe(1)
-    expect(chunks[0]).toContain(PARAGRAPH_SPACER)
+    expect(chunks[0]).toContain('\n\n')
   })
 
   it('still SUPPRESSES a real transcript that deliberately terminates with a bare NO_REPLY (#2053 guard intact)', () => {
@@ -228,9 +224,9 @@ describe('#2798 turn-flush block separation — real multi-block transcript shap
 // runs (gateway executeReply):
 //   repairEscapedWhitespace -> normalizeParagraphBreaks -> redactOutboundText
 //   -> stripExcessBold(normalizePunctuation) -> scrubVoice
-//   -> addParagraphSpacers (send side)
+// (no send-side paragraph-spacer pass — removed in the #2669 follow-up).
 // The original #2798 change gave turn-flush the paragraph steps + redact +
-// scrub + spacers but OMITTED `stripExcessBold(normalizePunctuation(...))`.
+// scrub but OMITTED `stripExcessBold(normalizePunctuation(...))`.
 // This suite reconstructs the deterministic format chain of BOTH paths (the
 // runtime-only redact + voice-scrub steps are literally the same calls on both
 // paths and are out of scope here) and pins that turn-flush now matches reply
@@ -312,7 +308,7 @@ describe('#2798 turn-flush punctuation/bold parity with reply', () => {
   function formatChain(text: string): string {
     let t = normalizeParagraphBreaks(repairEscapedWhitespace(text))
     t = stripExcessBold(normalizePunctuation(t))
-    return addParagraphSpacers(t)
+    return t
   }
 
   const input =

package/telegram-plugin/turn-flush-safety.ts

@@ -197,9 +197,10 @@ export function decideTurnFlush(input: FlushDecisionInput): FlushDecision {
   // lone `\n` collapses adjacent blocks into one run — on the Bot API 10.1
   // rich-markdown path (#2669) a single newline is a soft break, so the blocks
   // render as an undifferentiated wall-of-text. `\n\n` is the GFM paragraph
-  // separator; the gateway send path then wedges visible spacers into those
-  // gaps via addParagraphSpacers (mirroring the reply path, #2692) so the
-  // paragraphs render with real separation.
+  // separator; the Bot API 10.1 rich renderer shows it as one visible blank
+  // line, so the paragraphs render with real separation on their own (the
+  // former NBSP spacer pass was removed in the #2669 follow-up — it added a
+  // spurious second blank line).
   //
   // The silent-marker guards below are unaffected by this change:
   // isSilentFlushMarker length-guards the whole joined string; the composite /