switchroom 0.16.38 → 0.16.47

package/telegram-plugin/dist/server.js

@@ -17253,6 +17253,23 @@ function projectAssistantTextBlocks(content, make) {
   });
   return out;
 }
+function assistantLineCarriesAnswerSurface(content) {
+  if (!Array.isArray(content))
+    return false;
+  for (const c of content) {
+    const ct = c?.type ?? "";
+    if (ct === "text") {
+      const t = c.text;
+      if (typeof t === "string" && t.trim().length > 0)
+        return true;
+    } else if (ct === "tool_use") {
+      const name = c.name ?? "";
+      if (name !== "Agent" && name !== "Task")
+        return true;
+    }
+  }
+  return false;
+}
 function projectTranscriptLine(line) {
   if (line.length > MAX_JSONL_LINE_BYTES)
     return [];
@@ -17414,7 +17431,7 @@ function projectSubagentLine(line, agentId, state) {
       }
     });
     const stopReason = message?.stop_reason;
-    if (stopReason === "end_turn") {
+    if (stopReason === "end_turn" && assistantLineCarriesAnswerSurface(content)) {
       events.push({ kind: "sub_agent_turn_end", agentId });
     }
     return events;
@@ -24677,7 +24694,8 @@ var init_bridge = __esm(async () => {
           chat_id: { type: "string", description: "Chat to render the approval card in (use the chat_id of the user message that triggered the workflow)." },
           key: { type: "string", description: "Vault key the agent wants access to (matches the key shown in the VAULT-BROKER-DENIED error, e.g. `fatsecret/credentials`)." },
           scope: { type: "string", enum: ["read", "write"], description: 'Access scope: "read" (default) for `vault:<key>` references; "write" if the agent needs to put new values.' },
-          reason: { type: "string", description: `REQUIRED in practice \u2014 short human-readable rationale rendered on the card (e.g. "to look up today's food log entries"). The approval card now renders "why: not provided" when this is omitted, which signals to the operator that the agent skipped its explanation \u2014 they will usually Deny. Always supply a one-line rationale.` },
+          reason: { type: "string", description: 'REQUIRED in practice \u2014 short human-readable rationale rendered on the card (e.g. "to look up today\'s food log entries"). The approval card now renders "why: not provided" when this is omitted, which signals to the operator that the agent skipped its explanation \u2014 they will usually Deny. Always supply a one-line rationale. `why` is accepted as an alias (matching `vault_request_save`).' },
+          why: { type: "string", description: "Alias for `reason` (matches the sibling tool `vault_request_save`). If both are supplied, `reason` wins." },
           duration: { type: "string", description: 'Requested grant TTL, like "30d" or "12h". Default 30d, capped at 90d. Beyond 90d the operator should use the host CLI explicitly.' },
           message_thread_id: { type: "string", description: "Forum topic thread ID. Auto-applied from the last inbound message if not specified." }
         },

package/telegram-plugin/format.ts

@@ -266,10 +266,35 @@ export function normalizeParagraphBreaks(text: string): string {
   // never touched. See splitCollapsedInlineBullets for the exact rule.
   const masked = splitCollapsedInlineBullets(maskedRaw)
 
-  // 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 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
@@ -348,13 +373,14 @@ export const PARAGRAPH_SPACER = ' '
  * the pre-#2669 HTML behaviour). See PARAGRAPH_SPACER for why a U+00A0 line is
  * the reliable trick.
  *
- * Conservative by construction — a spacer is inserted into a `\n\n` gap ONLY
- * when BOTH the block ENDING above the gap and the block STARTING below it are
- * ordinary prose. A gap adjacent to a structural block (list item, table row,
- * fenced code, blockquote, heading, indented code) is left exactly as it was:
- * those blocks already carry their own vertical rhythm, and a spacer paragraph
- * wedged against a tight list / table would either re-introduce the cramped
- * look from the other side or break the block's contiguity.
+ * 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
@@ -385,15 +411,45 @@ export function addParagraphSpacers(text: string): string {
   // 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, '')
 
-  // A line is "prose" for spacing purposes when it is non-blank, not a
-  // structural block marker, not the spacer line itself. Only a gap with prose
-  // on BOTH sides earns a visible spacer.
-  const isProseLine = (line: string): boolean => {
-    if (isBlankLine(line)) return false
-    if (asciiTrim(line) === spacerLine) return false
-    if (isMarkerLine(line, placeholder)) return false
-    // A standalone masked fenced block line is structural.
-    if (isFenceOpenLine(line, placeholder)) return false
+  // 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
   }
 
@@ -426,8 +482,7 @@ export function addParagraphSpacers(text: string): string {
           !alreadySpaced &&
           above != null &&
           below != null &&
-          isProseLine(above) &&
-          isProseLine(below)
+          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
@@ -469,6 +524,154 @@ function nextNonBlank(
   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)
 // ---------------------------------------------------------------------------
@@ -558,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 || startsList) {
+        result.push('')
+      }
+    }
 
-      if (startsTableHere || startsFence || startsQuote || startsHeading) {
+    // ---- 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('')
       }
     }
@@ -604,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('```') ||
@@ -633,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
 }
 
 /**
@@ -711,10 +978,17 @@ 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(stripBoundarySpacers(rest.slice(0, cut), 'trailing'))