switchroom 0.16.29 → 0.16.46

package/telegram-plugin/format.ts

@@ -53,6 +53,24 @@ export function escapeMarkdown(text: string): string {
   return text.replace(/([\\`*_~=\[\]|])/g, '\\$1')
 }
 
+/**
+ * Make a string safe to interpolate INSIDE a `code span`.
+ *
+ * Inside a GFM code span the content is LITERAL — backslash escaping does
+ * NOT apply, so `escapeMarkdown` is exactly wrong there: it emits visible
+ * backslashes (e.g. `openai\_key` for an identifier containing `_`). The
+ * only character that can prematurely CLOSE the span is a backtick, so the
+ * sole transform needed is to defuse embedded backticks. We insert a
+ * zero-width space after each backtick so the raw ``` ` ``` can no longer
+ * terminate the surrounding span while remaining visually identical.
+ *
+ * This is the canonical home for the helper (#2695 regression fix); other
+ * modules re-export from here so there's one implementation.
+ */
+export function codeSpanSafe(s: string): string {
+  return s.replace(/`/g, '`​')
+}
+
 /**
  * Repair LLM-side JSON escape bungles.
  *
@@ -190,16 +208,93 @@ function maskCodeRegions(text: string, nonce: string): MaskedCode {
  * Code fences and inline code are masked out before any of this runs, so their
  * interior `\n`s are never touched.
  */
+/**
+ * Split a collapsed inline bullet list onto separate lines.
+ *
+ * Agents sometimes emit an entire bullet list on ONE line using interior
+ * `•`/`·` separators, e.g.:
+ *
+ *   • Master Bath 1, clean • <b>Master Bath 2</b>, 33% loss • Cabinet, clean
+ *
+ * which renders as a single run-on line instead of stacked bullets (the GFM
+ * rich path treats `•`/`·` as ordinary text, not list syntax, so nothing
+ * stacks). This deterministically inserts a newline before each interior
+ * unicode-bullet separator so each bullet lands on its own line.
+ *
+ * Conservative by construction:
+ *  - Only a line that STARTS (after optional leading whitespace) with a bullet
+ *    marker (`•`, `·`, `-`, or `*` followed by a space) is eligible — prose
+ *    with a mid-sentence `•` is left untouched.
+ *  - Only the unicode bullets `•`/`·` are split on (an interior whitespace +
+ *    `•`/`·` + whitespace). `-`/`*` are NEVER used as interior split points —
+ *    too many false positives (hyphens, ranges, "a * b" multiplication).
+ *    They are only accepted as the LEADING marker.
+ *  - The bullet glyphs are left as-is; we only insert `\n` before each split
+ *    bullet and normalize the inter-bullet whitespace to a single space.
+ *  - Idempotent: once split, each bullet begins its own line, so the
+ *    interior-separator pattern (whitespace + bullet + whitespace) no longer
+ *    matches anywhere on those lines.
+ *
+ * Runs on already-code-masked text, so a `•` inside a code span/fence is safe.
+ */
+export function splitCollapsedInlineBullets(text: string): string {
+  if (!/[•·]/.test(text)) return text
+  // Leading marker: optional indent, then • · - or * followed by a space.
+  // Interior separator to split on: whitespace + • or · + whitespace.
+  const interiorSep = /[ \t]+([•·])[ \t]+/g
+  return text
+    .split('\n')
+    .map((line) => {
+      if (!/^[ \t]*[•·*-] /.test(line)) return line
+      if (!/[ \t][•·][ \t]/.test(line)) return line
+      return line.replace(interiorSep, '\n$1 ')
+    })
+    .join('\n')
+}
+
 export function normalizeParagraphBreaks(text: string): string {
-  if (!text.includes('\n')) return text
+  // A text with no newline still needs the inline-bullet split (a collapsed
+  // bullet list is a SINGLE line). Only bail early when there is neither a
+  // newline nor a unicode bullet to potentially split.
+  if (!text.includes('\n') && !/[•·]/.test(text)) return text
 
   const nonce = Math.random().toString(36).slice(2)
-  const { masked, restore, placeholder } = maskCodeRegions(text, nonce)
+  const { masked: maskedRaw, restore, placeholder } = maskCodeRegions(text, nonce)
 
-  // Step 1: collapse 3+ newlines to exactly two. This also normalizes runs that
-  // contain interleaved spaces only between the newlines is NOT done here —
-  // we only touch pure newline runs so we never eat meaningful whitespace.
-  let out = masked.replace(/\n{3,}/g, '\n\n')
+  // Step 0: split a collapsed inline bullet list onto separate lines. Done on
+  // the code-masked text so a `•` inside a fenced block or inline code span is
+  // never touched. See splitCollapsedInlineBullets for the exact rule.
+  const masked = splitCollapsedInlineBullets(maskedRaw)
+
+  // Step 1: collapse blank-line runs to exactly ONE clean blank line (`\n\n`),
+  // never leaving a whitespace-only line between two paragraphs.
+  //
+  //   (a) Pure newline runs of 3+ → `\n\n`.
+  //   (b) A blank-line run whose interior lines are ASCII-whitespace-only
+  //       (spaces / tabs / CR) → `\n\n`. A model (or an upstream transform)
+  //       that authors `A\n\n \n\nB` leaves a lone-space line between the
+  //       paragraphs; CommonMark discards it (so it buys no gap) but it reads
+  //       as an oversized / ragged gap in the raw text and in some clients, and
+  //       it was the "stray blank line" seen in real replies. Collapse it.
+  //
+  // Deliberately ASCII-only: a line whose only content is U+00A0 is the
+  // INTENTIONAL, non-collapsible paragraph spacer added later by
+  // addParagraphSpacers (#2692) to force a visible gap on the rich-message
+  // path. This step runs BEFORE that spacer pass and must never eat a U+00A0
+  // line, so the `[ \t\r]` character class here excludes U+00A0 by
+  // construction. Runs on code-masked text, so a blank-ish line inside a
+  // fenced block is parked and never touched.
+  let out = masked
+    // Collapse any run of newlines interleaved with ASCII whitespace-only
+    // interior lines down to a single clean `\n\n`. Requires at least one
+    // whitespace char between the first two newlines OR 3+ newlines, so it
+    // fires on both `A\n \nB` (one space-only blank line) and `A\n\n \n\nB`
+    // (a space-only line inside a multi-blank run) but never rewrites a clean
+    // `A\n\nB` (no interior whitespace) — that already-correct gap is left to
+    // the `\n{3,}` pass below, which collapses any surviving run of 3+
+    // newlines (including pure `A\n\n\n\nB`) down to a single `\n\n`.
+    .replace(/\n[ \t\r]+\n(?:[ \t\r]*\n)*/g, '\n\n')
+    .replace(/\n{3,}/g, '\n\n')
 
   // Step 2: walk lines and promote lone prose breaks. We rebuild the string by
   // joining lines with the right separator. A separator is "hard" (`  \n`) only
@@ -236,8 +331,10 @@ export function normalizeParagraphBreaks(text: string): string {
   // Step 3: guarantee a blank line (`\n\n`) at BLOCK BOUNDARIES. The
   // prose-promotion above keeps lists/tables tight by leaving their single
   // `\n` separators alone — but GFM's rich renderer needs a blank line to
-  // START a new block, so a block that is glued to the previous line by a
-  // single `\n` fails to render (a table prints as literal pipe text, prose
+  // START a new block. A properly block-separated table DOES render as a
+  // real table (Bot API 10.1 rich messages); the failure mode this pass
+  // fixes is the *glued* case — a block joined to the previous line by a
+  // single `\n` (an un-separated table degrades to literal pipe text, prose
   // after a list is absorbed as a lazy list continuation). This pass inserts
   // the missing blank line at those transitions only, on the same masked text,
   // never touching code interiors, never collapsing/expanding existing `\n\n`,
@@ -247,6 +344,334 @@ export function normalizeParagraphBreaks(text: string): string {
   return restore(out)
 }
 
+// ---------------------------------------------------------------------------
+// Paragraph spacers — restore a VISIBLE blank line between prose paragraphs
+// ---------------------------------------------------------------------------
+
+/**
+ * The non-collapsible spacer paragraph injected between two prose paragraphs.
+ *
+ * Telegram's Bot API 10.1 rich-message renderer (the GFM/CommonMark engine
+ * behind `sendRichMessage` / `editMessageText({ markdown })`) renders a `\n\n`
+ * paragraph break TIGHT — the two paragraphs sit on adjacent lines with no
+ * visible empty line between them. The legacy markdown→HTML path (removed in
+ * #2669) sent `\n\n` literally with `parse_mode:"HTML"`, where two newlines
+ * render as a real blank line. That regression is the operator-confirmed
+ * "paragraphs jammed together" symptom.
+ *
+ * CommonMark discards blank lines made of ASCII whitespace, but a line whose
+ * only content is a NON-breaking space (U+00A0) is a genuine, non-empty
+ * paragraph — it renders as a visible empty line. So `A\n\n \n\nB`
+ * renders as three paragraphs: A, a blank-looking line, then B — the visible
+ * gap the HTML path used to produce.
+ */
+export const PARAGRAPH_SPACER = ' '
+
+/**
+ * Insert a visible blank-line spacer into each genuine `\n\n` paragraph gap so
+ * the rich GFM renderer shows a real empty line between paragraphs (matching
+ * the pre-#2669 HTML behaviour). See PARAGRAPH_SPACER for why a U+00A0 line is
+ * the reliable trick.
+ *
+ * Uniform-block-spacing contract: a spacer is inserted into EVERY `\n\n` gap
+ * that separates two DISTINCT blocks — prose→prose, paragraph→list,
+ * list→paragraph, heading→anything, blockquote/table/fence boundaries — so a
+ * mixed message renders with one identical visible blank line between blocks.
+ * The one exception is a gap INSIDE a block of the same structural kind (two
+ * items of a loose list, consecutive table rows/quotes/fences): those stay
+ * tight so the block's contiguity survives. Interiors joined by a single `\n`
+ * are never gaps at all and are untouched by construction.
+ *
+ * Runs on code-masked text (so a blank line inside a fenced block is never
+ * touched) and is idempotent — a gap that already contains a U+00A0 spacer
+ * paragraph is recognised and never doubled.
+ *
+ * Intended to run in the outbound send path AFTER normalizeParagraphBreaks,
+ * which has already collapsed 3+ newline runs to `\n\n`, promoted lone prose
+ * breaks, and guaranteed block-boundary blank lines. normalizeParagraphBreaks
+ * itself deliberately does NOT do this so its (well-tested) `\n\n`-preserving
+ * contract is unchanged.
+ */
+export function addParagraphSpacers(text: string): string {
+  if (!text.includes('\n\n')) return text
+
+  const nonce = Math.random().toString(36).slice(2)
+  const { masked, restore, placeholder } = maskCodeRegions(text, nonce)
+
+  if (!masked.includes('\n\n')) return restore(masked)
+
+  // The line we inject for a spacer paragraph (its only content is U+00A0).
+  const spacerLine = PARAGRAPH_SPACER
+
+  // CRITICAL: `String.prototype.trim()` strips U+00A0, so a spacer line would
+  // read as "blank" and the pass would lose idempotency (re-spacing an
+  // already-spaced gap). Detect blank-ness with an ASCII-whitespace-only test
+  // so the U+00A0 spacer line is correctly seen as NON-blank.
+  const isBlankLine = (line: string): boolean => /^[ \t\r\f\v]*$/.test(line)
+  // Trim ASCII-only (preserve U+00A0) so the spacer line is recognisable.
+  const asciiTrim = (line: string): string => line.replace(/^[ \t\r\f\v]+|[ \t\r\f\v]+$/g, '')
+
+  // Classify the block kind of a facing line so the spacer decision can be
+  // made per BLOCK TRANSITION (#uniform-block-spacing). A spacer is inserted
+  // at every `\n\n` gap between two DIFFERENT block kinds (paragraph→list,
+  // list→paragraph, heading→anything, blockquote/table boundaries) and
+  // between two prose paragraphs — but NEVER inside a single block's interior
+  // (between two items of the same loose list, two rows of a table, two
+  // quote lines, two fenced blocks). One visible blank line between distinct
+  // blocks, identical everywhere; list/table interiors stay tight.
+  type BlockKind = 'spacer' | 'list' | 'table' | 'quote' | 'heading' | 'fence' | 'divider' | 'prose'
+  const blockKind = (line: string): BlockKind => {
+    if (asciiTrim(line) === spacerLine) return 'spacer'
+    if (isFenceOpenLine(line, placeholder)) return 'fence'
+    if (isListItemLine(line)) return 'list'
+    if (isTableRowLine(line) || isTableDelimiterLine(line)) return 'table'
+    if (isBlockquoteLine(line)) return 'quote'
+    if (isHeadingLine(line)) return 'heading'
+    if (/^(-{3,}|\*{3,}|_{3,})\s*$/.test(line.trimStart())) return 'divider'
+    return 'prose'
+  }
+
+  // Same-kind structural pairs whose `\n\n` gap is a block INTERIOR (a loose
+  // list's item gap, consecutive tables/quotes/fences) — no spacer there.
+  const SAME_KIND_TIGHT: ReadonlySet<BlockKind> = new Set([
+    'list',
+    'table',
+    'quote',
+    'fence',
+    'divider',
+  ])
+
+  const shouldSpaceGap = (above: string, below: string): boolean => {
+    const a = blockKind(above)
+    const b = blockKind(below)
+    // A facing spacer line means the gap is already spaced (idempotency —
+    // also guarded by alreadySpaced at the call site).
+    if (a === 'spacer' || b === 'spacer') return false
+    if (a === b && SAME_KIND_TIGHT.has(a)) return false
+    // Everything else is a genuine block transition (incl. prose→prose,
+    // heading→anything, list↔paragraph, table/quote boundaries) — space it.
+    return true
+  }
+
+  // Split into blank-line-delimited segments, then re-join inserting a spacer
+  // paragraph between two adjacent NON-blank segments whose facing lines are
+  // both prose and which are not already separated by a spacer.
+  // A `\n\n` paragraph gap is a SINGLE blank entry between two content lines
+  // (`"A\n\nB".split('\n')` → `["A", "", "B"]`). normalizeParagraphBreaks has
+  // already collapsed 3+ newline runs to exactly `\n\n`, so we only ever see a
+  // one-blank gap here; a multi-blank run is handled defensively the same way
+  // (the FIRST blank of the run carries the spacer decision).
+  const lines = masked.split('\n')
+  const out: string[] = []
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const isBlank = isBlankLine(line)
+    // The spacer decision is made at the FIRST blank of a gap, i.e. when the
+    // previously emitted line is non-blank prose. Inject the spacer BEFORE the
+    // blank so the result is `above \n\n   \n\n below`.
+    if (isBlank) {
+      const prevEmitted = out.length > 0 ? out[out.length - 1] : null
+      const prevIsBlank = prevEmitted != null && isBlankLine(prevEmitted)
+      if (!prevIsBlank) {
+        const above = lastNonBlank(out, isBlankLine)
+        const below = nextNonBlank(lines, i + 1, isBlankLine)
+        const alreadySpaced =
+          (above != null && asciiTrim(above) === spacerLine) ||
+          (below != null && asciiTrim(below) === spacerLine)
+        if (
+          !alreadySpaced &&
+          above != null &&
+          below != null &&
+          shouldSpaceGap(above, below)
+        ) {
+          // Emit: blank, spacer paragraph, blank — a U+00A0 paragraph wedged
+          // between two real blank lines so CommonMark renders it as a visible
+          // empty line between the two prose paragraphs.
+          out.push('')
+          out.push(spacerLine)
+          out.push('')
+          continue
+        }
+      }
+    }
+    out.push(line)
+  }
+
+  return restore(out.join('\n'))
+}
+
+/**
+ * Last non-blank entry already emitted into `arr`, or null. `isBlank` is the
+ * caller's blank test (ASCII-only, so a U+00A0 spacer line counts as
+ * non-blank — `String.trim()` would wrongly strip it).
+ */
+function lastNonBlank(arr: string[], isBlank: (s: string) => boolean): string | null {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (!isBlank(arr[i])) return arr[i]
+  }
+  return null
+}
+
+/** First non-blank line at or after index `from` in `lines`, or null. */
+function nextNonBlank(
+  lines: string[],
+  from: number,
+  isBlank: (s: string) => boolean,
+): string | null {
+  for (let i = from; i < lines.length; i++) {
+    if (!isBlank(lines[i])) return lines[i]
+  }
+  return null
+}
+
+// ---------------------------------------------------------------------------
+// Punctuation / bullet normalization — fleet-wide consistent typography
+// ---------------------------------------------------------------------------
+
+/**
+ * Deterministic punctuation + bullet normalization for outbound messages
+ * (fleet-wide consistent Telegram formatting). Runs in the send path AFTER
+ * normalizeParagraphBreaks, on code-masked text (reuses maskCodeRegions), so
+ * code spans and fenced blocks are never touched.
+ *
+ * Transforms:
+ *   1. Space-flanked em/en dash (` — ` / ` – `) → `, ` — except a
+ *      digit-flanked spaced dash (a numeric range `3 – 5`), which becomes a
+ *      plain hyphen range (`3-5`).
+ *   2. Bare em-dash between word characters (`word—word`) → `, `; a
+ *      digit-flanked one (`3—5`) → hyphen.
+ *   3. Bare en-dash between word characters → ASCII hyphen (`2019–2024` →
+ *      `2019-2024`).
+ *   4. Leading unicode bullets (`•` / `·`) as list markers → `- ` so every
+ *      list renders as a real GFM list (indent preserved).
+ *
+ * Idempotent: the output contains no em/en dashes or leading unicode bullets
+ * outside code regions, so a second pass is a no-op.
+ */
+export function normalizePunctuation(text: string): string {
+  if (!/[—–•·]/.test(text)) return text
+
+  const nonce = Math.random().toString(36).slice(2)
+  const { masked, restore } = maskCodeRegions(text, nonce)
+
+  let out = masked
+    // 1. Space-flanked em/en dash. Numeric range keeps a hyphen. The right
+    //    flank is a LOOKAHEAD (captured, not consumed) so consecutive spaced
+    //    dashes ("a — b — c") all normalize in one pass — a consumed \S would
+    //    swallow the char that anchors the next match.
+    .replace(/(\S)[ \t][—–][ \t](?=(\S))/g, (_m, a: string, b: string) =>
+      /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `,
+    )
+    // 2. Bare em-dash between word chars. Numeric range keeps a hyphen.
+    //    Right flank is a lookahead for the same consecutive-match reason.
+    .replace(/(\w)—(?=(\w))/g, (_m, a: string, b: string) =>
+      /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `,
+    )
+    // 3. Bare en-dash between word chars → hyphen (ranges: 2019–2024).
+    .replace(/(\w)–(?=\w)/g, '$1-')
+
+  // 4. Leading unicode bullet markers → GFM `- ` (per line, indent kept).
+  out = out
+    .split('\n')
+    .map((line) => line.replace(/^([ \t]*)[•·][ \t]+/, '$1- '))
+    .join('\n')
+
+  return restore(out)
+}
+
+// ---------------------------------------------------------------------------
+// Over-bold tripwire — strip bold when a message is clearly over-bolded
+// ---------------------------------------------------------------------------
+
+/** A line's content once a leading list marker (`- ` / `1. `) is removed. */
+function listItemContent(line: string): string {
+  return line.trimStart().replace(/^(?:[-*+]|\d+[.)])\s+/, '')
+}
+
+/** True when a text fragment is one single fully-bolded span (`**…**`). */
+function isFullyBolded(fragment: string): boolean {
+  return /^\*\*[^*]+\*\*[.,:;!?]?$/.test(fragment.trim())
+}
+
+/** Strip `**bold**` markers from a fragment, keeping the text. */
+function unbold(fragment: string): string {
+  return fragment.replace(/\*\*([^*]+)\*\*/g, '$1')
+}
+
+/**
+ * Over-bold tripwire (fleet-wide consistent Telegram formatting). If a
+ * message is clearly over-bolded, strip the `**` markers and keep the text:
+ *
+ *   - GLOBAL: when >30% of the message's non-code characters sit inside
+ *     `**bold**` spans, ALL bold markers are stripped.
+ *   - PER-BLOCK: an entire multi-line paragraph fully bolded, or a list whose
+ *     EVERY item is fully bolded, has that block's bold stripped.
+ *
+ * Deliberately conservative:
+ *   - Messages under 100 non-code characters are exempt (a short reply whose
+ *     one key fact is bolded is exactly the house style).
+ *   - A single-line fully-bolded paragraph of ≤48 chars is treated as a
+ *     pseudo-heading (the "**Section**" label the fleet style encourages) and
+ *     is NOT stripped by the per-block rule (it still counts toward the
+ *     global ratio).
+ *   - A list with any non-fully-bolded item is left alone.
+ *
+ * Code spans/fences are masked (maskCodeRegions) and never counted or
+ * modified. Idempotent: stripped output has no `**` spans left to trip on.
+ */
+export function stripExcessBold(text: string): string {
+  if (!text.includes('**')) return text
+
+  const nonce = Math.random().toString(36).slice(2)
+  const { masked, restore, placeholder } = maskCodeRegions(text, nonce)
+
+  // Non-code character budget: masked text with the placeholders removed.
+  const placeholderRe = new RegExp(
+    `${placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\d+\x00`,
+    'g',
+  )
+  const visible = masked.replace(placeholderRe, '')
+  if (visible.length < 100) return restore(masked)
+
+  let boldChars = 0
+  for (const m of visible.matchAll(/\*\*([^*]+)\*\*/g)) boldChars += m[1].length
+
+  if (boldChars / visible.length > 0.3) {
+    // Clearly over-bolded — strip every bold span, keep the text.
+    return restore(unbold(masked))
+  }
+
+  // Per-block check on blank-line-delimited blocks of the masked text.
+  const blocks = masked.split(/\n{2,}/)
+  const rebuilt = blocks.map((block) => {
+    const lines = block.split('\n').filter((l) => l.trim() !== '')
+    if (lines.length === 0 || !block.includes('**')) return block
+
+    const listLines = lines.filter((l) => isListItemLine(l))
+    if (listLines.length >= 2 && listLines.length === lines.length) {
+      // A list block: strip only when EVERY item is fully bolded.
+      if (lines.every((l) => isFullyBolded(listItemContent(l)))) return unbold(block)
+      return block
+    }
+
+    // A prose paragraph (no structural marker lines): strip when every line
+    // is one fully-bolded span — except the single-short-line pseudo-heading.
+    const isProseBlock = lines.every((l) => !isMarkerLine(l, placeholder))
+    if (!isProseBlock) return block
+    if (!lines.every((l) => isFullyBolded(l))) return block
+    if (lines.length === 1 && lines[0].trim().length <= 48) return block
+    return unbold(block)
+  })
+
+  // Rejoin with the original gap shapes: split() lost them, so re-split the
+  // masked text capturing the separators and interleave.
+  const seps = masked.match(/\n{2,}/g) ?? []
+  let out = rebuilt[0] ?? ''
+  for (let i = 1; i < rebuilt.length; i++) out += (seps[i - 1] ?? '\n\n') + rebuilt[i]
+
+  return restore(out)
+}
+
 // ---------------------------------------------------------------------------
 // Block-boundary blank-line guarantee (Step 3 of normalizeParagraphBreaks)
 // ---------------------------------------------------------------------------
@@ -336,8 +761,34 @@ function ensureBlockBoundaries(text: string, placeholder?: string): string {
       const startsFence = isFenceOpenLine(line, placeholder) && !isFenceOpenLine(prev, placeholder)
       const startsQuote = isBlockquoteLine(line) && !isBlockquoteLine(prev)
       const startsHeading = isHeadingLine(line) && !isHeadingLine(prev)
+      // List start glued to prose above by a single `\n` (uniform-block-
+      // spacing): a `- ` line already interrupts a paragraph in CommonMark,
+      // so the blank line is render-safe — it only lets the spacer pass see
+      // the transition. Never fires between two list items (prev is a list
+      // item) so list interiors stay tight.
+      const startsList = isListItemLine(line) && !isListItemLine(prev)
 
-      if (startsTableHere || startsFence || startsQuote || startsHeading) {
+      if (startsTableHere || startsFence || startsQuote || startsHeading || startsList) {
+        result.push('')
+      }
+    }
+
+    // ---- Rule A2: blank line AFTER a closed code fence, before prose ----
+    // Prose glued directly onto a fence's close (single `\n`) can be swallowed
+    // or mis-parsed; a blank line after a closed fence is always CommonMark-safe.
+    // Masked blocks collapse to a single placeholder-leading line, so a fence
+    // "close" is a prev line that opens a fence (masked placeholder or literal
+    // ``` fence). Only fire when the current line is non-blank prose that is NOT
+    // itself a new block start (those are handled by Rule A above).
+    if (prevNonBlank && !curBlank && isFenceOpenLine(prev, placeholder)) {
+      const alreadySeparated = result.length > 0 && result[result.length - 1].trim() === ''
+      const curIsBlockStart =
+        isFenceOpenLine(line, placeholder) ||
+        isBlockquoteLine(line) ||
+        isHeadingLine(line) ||
+        isTableRowLine(line) ||
+        isTableDelimiterLine(line)
+      if (!alreadySeparated && !curIsBlockStart) {
         result.push('')
       }
     }
@@ -382,9 +833,13 @@ function isMarkerLine(line: string, placeholder?: string): boolean {
     t.startsWith('>') ||
     // ATX heading.
     /^#{1,6}\s/.test(t) ||
-    // Table row (leading pipe) or table-ish line (interior ` | `).
-    t.startsWith('|') ||
-    line.includes(' | ') ||
+    // Table row (leading pipe) or a table delimiter row. A loose interior
+    // ` | ` substring misclassifies prose like `choose A | B` as a table row
+    // and suppresses paragraph spacing — require a real GFM table row/delimiter
+    // instead. (A header row lacking a leading pipe is still recognised as
+    // structural when its delimiter row follows, via ensureBlockBoundaries.)
+    isTableRowLine(line) ||
+    isTableDelimiterLine(line) ||
     // Fenced code delimiter (defensive — fences are masked, but a lone/odd
     // fence line can survive masking).
     t.startsWith('```') ||
@@ -411,7 +866,41 @@ function shouldPromoteBreak(prev: string, next: string, placeholder?: string): b
   // terminator (e.g. `He said "go."` or `(done.)`).
   const unwrapped = prevTrimmed.replace(/[)"'’”\]]+$/, '')
   const terminator = unwrapped.slice(-1)
-  return terminator === '.' || terminator === '!' || terminator === '?' || terminator === ':'
+  if (terminator === '.' || terminator === '!' || terminator === '?' || terminator === ':') {
+    return true
+  }
+  // Stat-card / key-value promotion (#2750). A vertical card like
+  // `Calories: 1800 / Protein: 120g / Carbs: 200g` (or the fleet's HOUSE style
+  // `**Calories:** 1800 / **Protein:** 120g`) has lines ending in digits/
+  // letters, so the terminator rule above never fires and the whole card
+  // collapses into one wall of text. Promote a lone `\n` when the prev line
+  // reads as a standalone `label: value` stat line.
+  //
+  // The discriminator that separates a stat line from a mid-sentence soft wrap
+  // that merely contains a colon (`The deal has one catch: the buyer wants it
+  // and\nToronto lawyers sign off`) is two-fold:
+  //   1. The LABEL (text before the colon) is SHORT — a stat label is a term
+  //      of a few words, a wrapped prose clause is a long run of words. We cap
+  //      the label at 3 words / 24 chars.
+  //   2. The next line is NOT a lowercase-started mid-sentence continuation.
+  //      A genuine wrapped sentence continues in lowercase; a stat/label line
+  //      is followed by another label or capitalised prose.
+  // Markdown emphasis (`*` `_` `` ` ``) is stripped first so bold labels like
+  // `**Calories:**` are recognised. A prev with no colon never matches, so a
+  // plain soft-wrapped sentence is untouched.
+  const statStripped = prevTrimmed.replace(/[*_`]/g, '')
+  const colonIdx = statStripped.indexOf(':')
+  if (colonIdx > 0) {
+    const label = statStripped.slice(0, colonIdx).trim()
+    const value = statStripped.slice(colonIdx + 1)
+    const labelWords = label.length === 0 ? 0 : label.split(/\s+/).length
+    const isStatLine =
+      /^[ \t]+\S/.test(value) && labelWords >= 1 && labelWords <= 3 && label.length <= 24
+    if (isStatLine && !/^[a-z]/.test(nextTrimmed)) {
+      return true
+    }
+  }
+  return false
 }
 
 /**
@@ -489,17 +978,59 @@ export function splitMarkdownChunks(text: string, maxLen = RICH_MESSAGE_MAX_CHAR
 
     if (cut <= 0) {
       // Could not find a safe boundary below maxLen — the region is one
-      // indivisible block (e.g. a single huge fenced block). Emit the
-      // whole remainder rather than loop forever.
-      chunks.push(rest)
-      break
+      // indivisible block (e.g. a single huge fenced block or an unbreakable
+      // token run). Emitting the oversized remainder whole makes Telegram
+      // reject it (RICH_MESSAGE_TEXT_TOO_LONG) and drops the whole answer, so
+      // fall back to a raw character slice: every piece is guaranteed <= maxLen
+      // (a degraded-but-delivered message beats a hard reject). hardSliceToCap
+      // returns the head chunk plus the rest; keep looping on the remainder so
+      // any trailing splittable region still gets normal boundary treatment.
+      const sliced = hardSliceToCap(rest, maxLen)
+      chunks.push(stripBoundarySpacers(sliced[0], 'trailing'))
+      rest = stripBoundarySpacers(sliced.slice(1).join(''), 'leading')
+      continue
     }
 
-    chunks.push(rest.slice(0, cut))
-    rest = rest.slice(cut).replace(/^\n+/, '')
+    chunks.push(stripBoundarySpacers(rest.slice(0, cut), 'trailing'))
+    rest = stripBoundarySpacers(rest.slice(cut), 'leading')
   }
 
-  return chunks
+  return chunks.map((c) => stripBoundarySpacers(c, 'trailing'))
+}
+
+/**
+ * Strip stray paragraph-spacer / blank lines off a chunk boundary so a cut that
+ * lands inside an injected spacer gap (`\n\n${PARAGRAPH_SPACER}\n\n`, see
+ * addParagraphSpacers) never leaves a continuation chunk that OPENS with a bare
+ * U+00A0 spacer line, nor a prior chunk that ENDS with one.
+ *
+ * A "boundary blank run" is any sequence of newlines and spacer-only lines (a
+ * line whose only content is the U+00A0 spacer, optionally surrounded by ASCII
+ * spaces/tabs) in ANY interleaving — `\n \n`, ` \n\n`, `\n\n \n`, etc. The
+ * legacy behaviour (strip leading ASCII `\n+` only) is a strict subset, so a
+ * boundary with NO spacer is unaffected. Idempotent: a chunk already trimmed
+ * has nothing left to strip.
+ *
+ *  - `'leading'`  → strip the run from the START (the continuation chunk).
+ *  - `'trailing'` → strip the run from the END (the just-emitted prior chunk).
+ */
+function stripBoundarySpacers(chunk: string, side: 'leading' | 'trailing'): string {
+  // One blank-or-spacer line: optional ASCII ws, optional one U+00A0, optional
+  // ASCII ws — i.e. a line that renders empty. A run of these (joined by \n,
+  // with leading/trailing \n) is what we peel off the boundary.
+  const sp = PARAGRAPH_SPACER
+  if (side === 'leading') {
+    // Leading: one-or-more newlines, optionally with spacer-only lines mixed in.
+    return chunk.replace(
+      new RegExp(`^(?:[ \\t]*${sp}?[ \\t]*\\n+)+`),
+      '',
+    )
+  }
+  // Trailing: a newline run, optionally with spacer-only lines, at the very end.
+  return chunk.replace(
+    new RegExp(`(?:\\n+[ \\t]*${sp}?[ \\t]*)+$`),
+    '',
+  )
 }
 
 /**