switchroom 0.16.38 → 0.16.47

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

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

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

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

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

@@ -0,0 +1,272 @@
+/**
+ * Parse-level formatting regression suite.
+ *
+ * GOAL: catch formatting regressions at the *parse* level, not the string
+ * level. For every torture-set fixture we run the raw intent through the SAME
+ * outbound transform pipeline the gateway uses, then assert TWO independent
+ * signals via `rich-markdown-oracle.ts` (an independent CommonMark/GFM
+ * validator — NOT the formatter echoing itself):
+ *
+ *   (a) PARSE-ACCEPT — every emitted chunk is well-formed enough that
+ *       Telegram's rich-message path would not 400 on it (balanced fences,
+ *       terminated code spans, closed links, complete table rows, balanced
+ *       emphasis). This is the signal that would have caught "we shipped
+ *       markdown Telegram rejects."
+ *
+ *   (b) STRUCTURE — the transformed body parses into the entity structure the
+ *       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.)
+ *
+ * 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
+ * would reject — a real regression, not a test to relax.
+ */
+
+import { describe, test, expect } from 'vitest'
+import {
+  repairEscapedWhitespace,
+  normalizeParagraphBreaks,
+  addParagraphSpacers,
+  splitMarkdownChunks,
+  RICH_MESSAGE_MAX_CHARS,
+} from '../format.js'
+import { normalizeDashes } from '../text-voice-scrub.js'
+import {
+  validateRichMarkdown,
+  isRichMarkdownValid,
+  parseRichEntities,
+  entitiesOfType,
+  scanFences,
+  type RichEntity,
+} from './rich-markdown-oracle.js'
+import { TORTURE_SET, type TortureFixture, type ExpectEntity } from './formatting-torture-set.js'
+
+/**
+ * The outbound transform, mirroring the gateway. `cardSurfaceScrub` prepends
+ * the voice-scrub pass (F1's surface). `cap` overrides the chunk cap so the
+ * F7 hard-slice path is reachable in a test without a 32k fixture.
+ */
+function transform(input: string, opts: { cardSurfaceScrub?: boolean; cap?: number } = {}): {
+  chunks: string[]
+  /** The full transformed body BEFORE chunking — used for structure assertions. */
+  body: string
+} {
+  let text = input
+  if (opts.cardSurfaceScrub) text = normalizeDashes(text)
+  text = normalizeParagraphBreaks(repairEscapedWhitespace(text))
+  const body = addParagraphSpacers(text)
+  const chunks = splitMarkdownChunks(body, opts.cap ?? RICH_MESSAGE_MAX_CHARS)
+  return { chunks, body }
+}
+
+/** Assert an expected entity is present among `got` (membership, not index). */
+function expectEntityPresent(got: ReadonlyArray<RichEntity>, want: ExpectEntity): void {
+  const match = got.find(
+    (e) =>
+      e.type === want.type &&
+      e.text === want.text &&
+      (want.url == null || e.url === want.url) &&
+      (want.lang == null || e.lang === want.lang),
+  )
+  expect(
+    match,
+    `expected a ${want.type} entity with text ${JSON.stringify(want.text)}` +
+      (want.url != null ? ` url ${want.url}` : '') +
+      (want.lang != null ? ` lang ${want.lang}` : '') +
+      `; got: ${JSON.stringify(got)}`,
+  ).toBeDefined()
+}
+
+// ---------------------------------------------------------------------------
+// Oracle self-tests — prove the oracle is a real, non-vacuous validator.
+// If the oracle accepted everything (signal a) or found nothing (signal b),
+// the whole suite would be a rubber stamp. These guard against that.
+// ---------------------------------------------------------------------------
+
+describe('rich-markdown-oracle — self-tests (guards against a vacuous oracle)', () => {
+  test('parse-accept: rejects an UNCLOSED fenced code block', () => {
+    const bad = 'intro\n```bash\necho hi\n' // no closing ```
+    const issues = validateRichMarkdown(bad)
+    expect(issues.some((i) => i.kind === 'unbalanced-fence')).toBe(true)
+  })
+
+  test('parse-accept: rejects an unterminated inline code span', () => {
+    const issues = validateRichMarkdown('here is `unclosed code')
+    expect(issues.some((i) => i.kind === 'unterminated-code-span')).toBe(true)
+  })
+
+  test('parse-accept: rejects an unclosed inline link destination', () => {
+    const issues = validateRichMarkdown('see [label](https://example.com/path')
+    expect(issues.some((i) => i.kind === 'malformed-link')).toBe(true)
+  })
+
+  test('parse-accept: rejects a bisected (half) table row', () => {
+    const issues = validateRichMarkdown('| a | b')
+    expect(issues.some((i) => i.kind === 'incomplete-table-row')).toBe(true)
+  })
+
+  test('parse-accept: rejects an unbalanced ** bold delimiter', () => {
+    const issues = validateRichMarkdown('this is **bold with no close')
+    expect(issues.some((i) => i.kind === 'unbalanced-emphasis')).toBe(true)
+  })
+
+  test('parse-accept: ACCEPTS well-formed markdown with mixed entities', () => {
+    const good =
+      'Intro **bold** and _italic_ and `code`.\n\n```js\nconst x = 1\n```\n\n| a | b |\n| --- | --- |\n| 1 | 2 |\n\nSee [x](https://e.com).'
+    expect(validateRichMarkdown(good)).toEqual([])
+  })
+
+  test('structure: extracts bold/italic/code/pre/link at the right text', () => {
+    const md = 'A **b** and _i_ and `c`.\n```py\nprint(1)\n```\n[lab](https://u.co)'
+    const ents = parseRichEntities(md)
+    expect(ents).toContainEqual({ type: 'bold', text: 'b' })
+    expect(ents).toContainEqual({ type: 'italic', text: 'i' })
+    expect(ents).toContainEqual({ type: 'code', text: 'c' })
+    expect(ents).toContainEqual({ type: 'pre', text: 'print(1)', lang: 'py' })
+    expect(ents).toContainEqual({ type: 'link', text: 'lab', url: 'https://u.co' })
+  })
+
+  test('inline code interior is verbatim — reserved chars do not leak as entities', () => {
+    // `*not bold*` inside code must NOT produce a bold/italic entity.
+    const ents = parseRichEntities('literal `*x*` here')
+    expect(ents.filter((e) => e.type === 'bold' || e.type === 'italic')).toEqual([])
+    expect(ents).toContainEqual({ type: 'code', text: '*x*' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// The torture set — signal (a) + (b) for every fixture.
+// ---------------------------------------------------------------------------
+
+describe('formatting torture-set — parse-accept + structure', () => {
+  // F7 is the deliberate degraded path: a >cap indivisible fenced block is
+  // hard-sliced, so its individual chunks are intentionally NOT balanced
+  // markdown. Handled separately below.
+  const standard = TORTURE_SET.filter((f) => f.name !== 'F7-over-cap-hard-slice')
+
+  for (const fx of standard) {
+    describe(fx.name, () => {
+      test(`(intent) ${fx.intent}`, () => {
+        // (a) PARSE-ACCEPT — every emitted chunk is well-formed.
+        const { chunks, body } = transform(fx.input, { cardSurfaceScrub: fx.cardSurfaceScrub })
+        for (const c of chunks) {
+          const issues = validateRichMarkdown(c)
+          expect(
+            issues,
+            `chunk failed parse-accept for fixture "${fx.name}":\n${c}\nissues: ${JSON.stringify(issues)}`,
+          ).toEqual([])
+        }
+
+        // (b) STRUCTURE — the transformed body parses into the intended shape.
+        const ents = parseRichEntities(body)
+        for (const want of fx.expect) expectEntityPresent(ents, want)
+      })
+    })
+  }
+
+  // ── F1 extra assertion: the em/en-dash glyph is actually gone. ────────────
+  test('F1: card-surface scrub removes the em/en-dash glyph before the wire', () => {
+    const fx = TORTURE_SET.find((f) => f.name === 'F1-card-surface-dash-scrub')!
+    const { body } = transform(fx.input, { cardSurfaceScrub: true })
+    expect(body).not.toContain('—') // em dash
+    expect(body).not.toContain('–') // en dash
+    // And the scrubbed body is still parse-accept clean.
+    expect(isRichMarkdownValid(body)).toBe(true)
+  })
+
+  // ── F2 extra assertion: the paragraph break survives (not collapsed). ─────
+  test('F2: a loose interior pipe does not swallow the following paragraph break', () => {
+    const fx = TORTURE_SET.find((f) => f.name === 'F2-stray-pipe-keeps-paragraph-spacing')!
+    const { body } = transform(fx.input)
+    // Both paragraphs are present and separated by a blank line (>= one \n\n).
+    expect(body).toContain('plan A | plan B')
+    expect(body).toContain('one pass')
+    expect(body).toMatch(/\n\s*\n/) // a real paragraph gap survived
+    // The loose pipe line must NOT have been turned into / read as a table
+    // row — the oracle would flag a half-row; it must be clean.
+    expect(isRichMarkdownValid(body)).toBe(true)
+  })
+
+  // ── F4 extra assertion: a blank line now separates the fence from prose. ──
+  test('F4: a blank line is inserted between a closed fence and the following prose', () => {
+    const fx = TORTURE_SET.find((f) => f.name === 'F4-blank-line-after-closed-fence')!
+    const { body } = transform(fx.input)
+    // The fence stays balanced (closed) and the trailing prose survives.
+    const { fences } = scanFences(body)
+    expect(fences.length).toBe(1)
+    expect(fences[0].closed).toBe(true)
+    expect(body).toContain('And it ships today.')
+    // The line immediately following the fence close is blank (the F4 fix).
+    const lines = body.split('\n')
+    const closeIdx = lines.findIndex((l, i) => i > 0 && /^```/.test(l.trim()) && lines[i - 1] !== '```')
+    // Find the LAST fence-close line then assert the next non-fence line has a
+    // blank between it and the fence.
+    const fenceCloseLine = lines.map((l) => l.trim()).lastIndexOf('```')
+    expect(fenceCloseLine).toBeGreaterThan(0)
+    expect(lines[fenceCloseLine + 1] ?? '').toBe('')
+    void closeIdx
+  })
+})
+
+// ---------------------------------------------------------------------------
+// F7 — over-cap indivisible block hard-slices (degraded-but-delivered).
+// Signal (a) does NOT apply per-chunk here by design (a hard slice can bisect
+// a fence). What MUST hold: no content is dropped and every chunk fits the cap.
+// ---------------------------------------------------------------------------
+
+describe('F7-over-cap-hard-slice', () => {
+  const fx = TORTURE_SET.find((f) => f.name === 'F7-over-cap-hard-slice')!
+  const CAP = 100
+
+  test('an oversized indivisible fenced block is sliced to <= cap chunks, losing no content', () => {
+    const { chunks } = transform(fx.input, { cap: CAP })
+    expect(chunks.length).toBeGreaterThan(1)
+    for (const c of chunks) expect(c.length).toBeLessThanOrEqual(CAP)
+    // No content dropped: the slices concatenate back to the original body.
+    // (The transform is a no-op on this fixture apart from chunking — it has no
+    // prose paragraphs to space, so body === input here.)
+    expect(chunks.join('')).toContain('x'.repeat(600))
+  })
+
+  test('the UN-chunked body is itself parse-accept valid (the fence is balanced)', () => {
+    // Sanity: the corruption F7 accepts is ONLY the intra-chunk fence bisection
+    // forced by the cap — the body as a whole is well-formed. This guards
+    // against F7 silently masking a genuine unbalanced-fence bug in the source.
+    const { body } = transform(fx.input, { cap: RICH_MESSAGE_MAX_CHARS })
+    expect(isRichMarkdownValid(body)).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Wiring-level: the fake bot API surfaces parsed entities on the rich path so
+// a test can assert structure at the send boundary (deliverable 3). This uses
+// the SAME independent oracle, keeping the check non-circular.
+// ---------------------------------------------------------------------------
+
+describe('wiring: sendRichMessage entity structure at the send boundary', () => {
+  test('a rich send of a torture body lands parse-valid with the intended entities', async () => {
+    const { createFakeBotApi } = await import('./fake-bot-api.js')
+    const bot = createFakeBotApi()
+    const fx = TORTURE_SET.find((f) => f.name === 'links')!
+    const { body } = transform(fx.input)
+
+    await bot.api.sendRichMessage('chat-1', { markdown: body })
+    const sent = bot.messagesIn('chat-1')
+    expect(sent).toHaveLength(1)
+    expect(sent[0].rich).toBe(true)
+
+    // Re-derive entities from what actually landed on the wire (sent[0].text is
+    // the rich markdown body) using the independent oracle.
+    const landed = sent[0].text
+    expect(isRichMarkdownValid(landed)).toBe(true)
+    for (const want of fx.expect) expectEntityPresent(parseRichEntities(landed), want)
+  })
+})
+
+// Keep a reference so unused-import lint never trips on entitiesOfType even if
+// a future edit drops its only direct use.
+void entitiesOfType