switchroom 0.18.17 → 0.18.19

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

@@ -1,27 +1,25 @@
 /**
  * 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.
+ *   1. paragraph gap spacing — a plain `\n\n` (one blank line) at EVERY block
+ *      transition (paragraph→list, list→paragraph, heading→anything,
+ *      blockquote/table boundaries), never a double blank line and never an
+ *      NBSP spacer (the old spacer pass was removed in the #2669 follow-up).
  *   2. normalizePunctuation — em/en dashes → comma/hyphen, leading `•`/`·`
- *      list markers → `- `, on code-masked text, idempotent.
+ *      list markers → `- `, on code-masked text, idempotent; link hrefs are
+ *      protected from dash rewriting.
  *   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,
   hardenCardBreaks,
-  PARAGRAPH_SPACER,
 } from '../format.js'
 
-const SP = PARAGRAPH_SPACER // U+00A0
-
 describe('hardenCardBreaks — deterministic card line-break hardener', () => {
   test('promotes lone field breaks to GFM hard breaks (the blob fix)', () => {
     const out = hardenCardBreaks('Agent: assistant\nAuth: Max\nStatus: running')
@@ -100,74 +98,60 @@ describe('hardenCardBreaks — deterministic card line-break hardener', () => {
   })
 })
 
-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.`)
-  })
+describe('paragraph gap spacing — plain single blank line, no NBSP', () => {
+  const NBSP = String.fromCharCode(0xa0)
 
-  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('prose→prose gap is one blank line, no NBSP', () => {
+    const out = normalizeParagraphBreaks('Alpha.\n\nBravo.')
+    expect(out).toBe('Alpha.\n\nBravo.')
+    expect(out).not.toContain(NBSP)
   })
 
-  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('paragraph→list transition is a single `\\n\\n` boundary', () => {
+    expect(normalizeParagraphBreaks('Intro.\n\n- one\n- two')).toBe('Intro.\n\n- one\n- two')
   })
 
-  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('list→paragraph transition is a single `\\n\\n` boundary', () => {
+    expect(normalizeParagraphBreaks('- one\n- two\n\nOutro.')).toBe('- one\n- two\n\nOutro.')
   })
 
-  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('heading→anything is a single `\\n\\n` boundary', () => {
+    expect(normalizeParagraphBreaks('# Title\n\nBody.')).toBe('# Title\n\nBody.')
+    expect(normalizeParagraphBreaks('# Title\n\n- a\n- b')).toBe('# Title\n\n- a\n- b')
   })
 
-  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('blockquote and table boundaries are single `\\n\\n`', () => {
+    expect(normalizeParagraphBreaks('> quoted\n\nProse.')).toBe('> quoted\n\nProse.')
+    const table = '| a | b |\n| --- | --- |\n| 1 | 2 |'
+    expect(normalizeParagraphBreaks(`Prose.\n\n${table}`)).toBe(`Prose.\n\n${table}`)
+    expect(normalizeParagraphBreaks(`${table}\n\nProse.`)).toBe(`${table}\n\nProse.`)
   })
 
   test('never touches code fences', () => {
     const input = '```\nA\n\nB\n```\n\n```\nC\n```'
-    expect(addParagraphSpacers(input)).toBe(input)
+    expect(normalizeParagraphBreaks(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('full pipeline: mixed prose+list message gets single-blank-line gaps, no NBSP, no double gap', () => {
+    const raw = 'Summary line.\n\n- item one\n- item two\n\nClosing prose.'
+    const out = normalizeParagraphBreaks(raw)
+    expect(out).toBe('Summary line.\n\n- item one\n- item two\n\nClosing prose.')
+    expect(out).not.toContain(NBSP)
+    expect(out).not.toMatch(/\n\n\n/)
   })
 
-  test('chunk-boundary interaction: a cut in a spacer gap strips the spacer', () => {
+  test('chunk-boundary interaction: a cut in a `\\n\\n` gap leaves clean chunks (no stray blank lines)', () => {
     const a = 'A'.repeat(60)
     const b = 'B'.repeat(60)
-    const text = `${a}\n\n${SP}\n\n${b}`
+    const text = `${a}\n\n${b}`
     const chunks = splitMarkdownChunks(text, 80)
     expect(chunks.length).toBe(2)
     expect(chunks[0]).toBe(a)
     expect(chunks[1]).toBe(b)
+    // Neither chunk opens or ends with a stray blank line.
+    for (const c of chunks) {
+      expect(c).toBe(c.replace(/^\n+|\n+$/g, ''))
+    }
   })
 })
 
@@ -210,6 +194,37 @@ describe('normalizePunctuation', () => {
     expect(normalizePunctuation(input)).toBe(input)
   })
 
+  test('does NOT rewrite a dash inside a markdown link href (#finding-2)', () => {
+    // An en-dash in a URL path must survive verbatim — rewriting it to `-`
+    // silently points at a different URL.
+    expect(normalizePunctuation('[a](https://x.com/foo–bar)')).toBe(
+      '[a](https://x.com/foo–bar)',
+    )
+    // An em-dash in a URL must NOT become `, ` — the injected space would
+    // TERMINATE the markdown link and leak the trailing text as prose.
+    expect(normalizePunctuation('[a](https://x.com/foo—bar)')).toBe(
+      '[a](https://x.com/foo—bar)',
+    )
+    // The visible LABEL still normalizes (dashes in label text are prose).
+    expect(normalizePunctuation('[foo—bar](https://x.com/path)')).toBe(
+      '[foo, bar](https://x.com/path)',
+    )
+  })
+
+  test('does NOT rewrite a dash inside a `<scheme:…>` autolink (#finding-2 sibling)', () => {
+    // An en-dash in an angle-bracket autolink URL must survive verbatim.
+    expect(normalizePunctuation('<https://x.com/foo–bar>')).toBe('<https://x.com/foo–bar>')
+    // An em-dash in an autolink must NOT become `, `.
+    expect(normalizePunctuation('<https://x.com/foo—bar>')).toBe('<https://x.com/foo—bar>')
+    // Autolink mid-prose: the surrounding prose still normalizes, the URL does not.
+    expect(normalizePunctuation('see <https://x.com/a–b> now — go')).toBe(
+      'see <https://x.com/a–b> now, go',
+    )
+    // Arbitrary `<…>` prose (no scheme) is NOT treated as an autolink: a dash
+    // inside it still normalizes like ordinary text.
+    expect(normalizePunctuation('<not—a—url>')).toBe('<not, a, url>')
+  })
+
   test('idempotent', () => {
     const once = normalizePunctuation('a — b\n• c\nd—e\n1–2')
     expect(normalizePunctuation(once)).toBe(once)

package/telegram-plugin/tests/formatting-parse-regression.test.ts

@@ -17,9 +17,10 @@
  *       fixture intended (bold/italic/code/pre/link at the right inner text).
  *
  * The pipeline mirrors `telegram-plugin/gateway/gateway.ts`:
- *   repairEscapedWhitespace -> normalizeParagraphBreaks -> addParagraphSpacers
- *   -> splitMarkdownChunks. (Card-surface fixtures also apply `normalizeDashes`
- *   first — that is where F1's voice scrub lives.)
+ *   repairEscapedWhitespace -> normalizeParagraphBreaks -> splitMarkdownChunks.
+ *   (No paragraph-spacer pass — the NBSP spacer was removed in the #2669
+ *   follow-up; gaps are plain `\n\n`. Card-surface fixtures also apply
+ *   `normalizeDashes` first — that is where F1's voice scrub lives.)
  *
  * This suite is TEST-ONLY. It changes no production formatting behaviour. If a
  * fixture ever fails signal (a), it means the formatter emits markdown Telegram
@@ -30,7 +31,6 @@ import { describe, test, expect } from 'vitest'
 import {
   repairEscapedWhitespace,
   normalizeParagraphBreaks,
-  addParagraphSpacers,
   splitMarkdownChunks,
   RICH_MESSAGE_MAX_CHARS,
 } from '../format.js'
@@ -57,8 +57,7 @@ function transform(input: string, opts: { cardSurfaceScrub?: boolean; cap?: numb
 } {
   let text = input
   if (opts.cardSurfaceScrub) text = normalizeDashes(text)
-  text = normalizeParagraphBreaks(repairEscapedWhitespace(text))
-  const body = addParagraphSpacers(text)
+  const body = normalizeParagraphBreaks(repairEscapedWhitespace(text))
   const chunks = splitMarkdownChunks(body, opts.cap ?? RICH_MESSAGE_MAX_CHARS)
   return { chunks, body }
 }

package/telegram-plugin/tests/formatting-torture-set.ts

@@ -7,7 +7,7 @@
  * The `input` is the raw text as a model/card surface would author it — the
  * regression test runs it through the SAME outbound transform pipeline the
  * gateway uses (repairEscapedWhitespace -> normalizeParagraphBreaks ->
- * addParagraphSpacers -> splitMarkdownChunks) and then asserts:
+ * splitMarkdownChunks) and then asserts:
  *
  *   (a) every emitted chunk is parse-accept valid (no rich-path 400), and
  *   (b) the concatenated output parses into `expect` (entity structure).

package/telegram-plugin/tests/gateway-outbound-redact.test.ts

@@ -134,6 +134,32 @@ describe('gateway outbound secret-scrub — structural wiring', () => {
     expect(streamIdx).toBeGreaterThan(redactIdx) // mask BEFORE the stream
   })
 
+  it('operator_event: scrubs event.detail at the top of emitGatewayOperatorEvent, BEFORE render/send', () => {
+    // #llm-error-surfacing FIX 2 — operator-event cards are sent via a raw
+    // bot.api.sendRichMessage that BYPASSES the normal outbound chokepoint, so a
+    // secret in an error `detail` (credentials-expired / credit-exhausted /
+    // unknown-4xx) could reach the card verbatim. The detail is redacted ONCE at
+    // the top of the function, through the shared redactOutboundText, and MUST
+    // run before the renderers escapeMarkdown it (redacting the already-escaped
+    // text lets url-query-param secrets slip past url-redact) and before the
+    // send. This is the sole regression guard for that wiring line — deleting it
+    // must turn this red.
+    const start = src.indexOf('function emitGatewayOperatorEvent(')
+    const redactIdx = src.indexOf(
+      `event = { ...event, detail: redactOutboundText(event.detail, 'operator_event') }`,
+      start,
+    )
+    // The two render surfaces + the wire send this must precede.
+    const renderOpIdx = src.indexOf('renderOperatorEvent(event)', start)
+    const renderLlmIdx = src.indexOf('renderLlmErrorSafe(parsed', start)
+    const sendIdx = src.indexOf('bot.api.sendRichMessage(chat_id, richMessage(renderedText)', start)
+    expect(start).toBeGreaterThan(0)
+    expect(redactIdx).toBeGreaterThan(start)
+    expect(renderOpIdx).toBeGreaterThan(redactIdx) // mask BEFORE the escapeMarkdown render
+    expect(renderLlmIdx).toBeGreaterThan(redactIdx) // mask BEFORE the humanized render
+    expect(sendIdx).toBeGreaterThan(redactIdx) // mask BEFORE the card hits the wire
+  })
+
   it('does not log the secret value when a mask fires', () => {
     const idx = src.indexOf('function redactOutboundText(')
     const body = src.slice(idx, idx + 400)

package/telegram-plugin/tests/linear-create-issue.test.ts

@@ -155,9 +155,14 @@ describe('createLinearIssue — behaviour (#2312)', () => {
     expect(r.content[0].text).toMatch(/default_team_id/)
   })
 
-  it('short-circuits to "Already filed" on a dedup hit', async () => {
+  it('short-circuits to "Already filed" only on an EXACT marker match, skipping unrelated top hits', async () => {
     const { fetchImpl, calls } = routingFetch({
-      searchIssues: () => ({ searchIssues: { nodes: [{ id: 'old', url: 'https://linear.app/acme/issue/ENG-7', title: 'prior' }] } }),
+      searchIssues: () => ({ searchIssues: { nodes: [
+        // relevance-ranked top hit that merely shares tokens — must be ignored.
+        { id: 'noise', url: 'https://linear.app/acme/issue/ENG-99', title: 'unrelated', description: 'no capture marker here' },
+        // the real prior capture, carrying the exact marker for this key.
+        { id: 'old', url: 'https://linear.app/acme/issue/ENG-7', title: 'prior', description: `Y${captureDedupMarker('chat:99')}` },
+      ] } }),
       teams: oneTeam,
       issueCreate: issueOk,
     })
@@ -165,12 +170,35 @@ describe('createLinearIssue — behaviour (#2312)', () => {
       { title: 'X', body: 'Y', dedup_key: 'chat:99' },
       { resolveToken: okToken('t'), fetchImpl, log: () => {} },
     )
+    // matched the marker-bearing node, not the higher-ranked noise node.
     expect(r.content[0].text).toBe('Already filed: https://linear.app/acme/issue/ENG-7')
     // only the search ran — no team resolve, no create.
     expect(calls).toHaveLength(1)
     expect(calls[0].query).toMatch(/searchIssues/)
   })
 
+  it('does NOT dedup when the search returns only unrelated hits (fuzzy false-positive regression)', async () => {
+    // Regression for the searchIssues fuzzy-match bug: a novel dedup_key
+    // returned an unrelated relevance-ranked hit and wrongly suppressed
+    // creation. No node carries this key's marker, so the tool must create.
+    const { fetchImpl, calls } = routingFetch({
+      searchIssues: () => ({ searchIssues: { nodes: [
+        { id: 'x', url: 'https://linear.app/acme/issue/ENG-56', title: 'ProductOS Job Spec', description: 'shares tokens, but no capture marker' },
+      ] } }),
+      teams: oneTeam,
+      issueCreate: issueOk,
+    })
+    const r = await createLinearIssue(
+      { title: 'Series QA tracker', body: 'Y', dedup_key: 'productos-qa-2026-07-13' },
+      { resolveToken: okToken('t'), fetchImpl, log: () => {} },
+    )
+    expect(r.content[0].text).toMatch(/Filed:/)
+    // fell through past the search to team resolve + create, embedding the marker.
+    const create = calls.find((c) => c.query.includes('issueCreate'))!
+    expect(create).toBeTruthy()
+    expect((create.variables.input as Record<string, unknown>).description).toContain(captureDedupMarker('productos-qa-2026-07-13'))
+  })
+
   it('falls through to create when the dedup search misses, and embeds the marker', async () => {
     const { fetchImpl, calls } = routingFetch({
       searchIssues: () => ({ searchIssues: { nodes: [] } }),