fix(bridge): render agent markdown natively on Slack and Telegram

[obukhovaa]

Problem

Slack received agent prose through chat.postMessage's top-level text field, which Slack
parses as legacy mrkdwn — a different dialect from the GFM the LLM emits. Observed
symptoms:

• ## Heading rendered as literal ## Heading, not a heading
• **bold** rendered as literal asterisks, not bold
• - bullet list markers rendered as literal dashes, not a list
• [label](url) rendered as literal brackets/parens, not a hyperlink
• pipe tables rendered as literal |-delimited text
• only single-backtick inline code survived, since mrkdwn does understand that construct

Mattermost was unaffected because it parses Post.Message as real GFM.

Telegram had the mirror-image bug: Send set no ParseMode at all, so every markdown
character (headings, bold markers, list dashes, link syntax, code fences) rendered verbatim
as literal text with no interpretation whatsoever.

Solution

• Slack: outbound prose is now emitted as Block Kit markdown blocks
  (slack.NewMarkdownBlock, already available in the vendored slack-go v0.25.0 — no new
  dependency), which Slack renders as standard Markdown server-side. Text is chunked with a
  shared fence-aware splitter to Slack's documented 12,000-character cumulative budget across
  all markdown blocks per payload, capped at 50 blocks, with a visible truncation marker
  when content is dropped. The top-level text field is retained as the
  notification/accessibility fallback. Legacy mrkdwn <url|label> link syntax that agents
  sometimes emit is normalized to [label](url) first, leaving <@U123> mentions and
  non-URL angle-bracket text alone.
• Telegram: outbound prose is converted to Telegram HTML and sent with ParseModeHTML.
  Source markdown is chunked at 3,500 characters (not the raw 4,096 MaxTextLength) so both
  the raw chunk and its entity-expanded, post-conversion form stay inside Telegram's
  4,096-character sendMessage cap. Each chunk is a self-contained, independently valid
  markdown fragment — a code fence open at a chunk boundary is closed on the outgoing chunk
  and reopened with the same info string on the next.
• Shared package: internal/bridge/markdown (stdlib-only) holds the fence-aware chunker,
  Slack link normalization, and the GFM→Telegram-HTML converter, used by both adapters.
• Degradation, never data loss: Slack retries once as plain text via MsgOptionText on
  any block-related API error, and sets a sticky per-adapter latch only for the unambiguous
  subset of those errors (excluding invalid_arguments, which Slack also returns for
  unrelated reasons like a bad channel or timestamp — latching on it would permanently
  downgrade formatting based on an ambiguous signal). Telegram retries a chunk with no
  ParseMode on an entity-parse error, with no sticky latch (each message's chunks attempt
  HTML conversion fresh). Neither adapter can drop a message solely because richer rendering
  failed.

Dialect reference

• ## Heading — mrkdwn: literal text → Slack markdown block: real heading / Telegram: <b>Heading</b>
• **bold** — mrkdwn: literal asterisks → Slack markdown block: bold / Telegram: <b>bold</b>
• - bullet — mrkdwn: literal dash → Slack markdown block: real bulleted list / Telegram: •-prefixed line
• [label](url) — mrkdwn: literal brackets → Slack markdown block: clickable link / Telegram: <a href="url">label</a>
• `code` — mrkdwn: already renders as inline code (unchanged) → Telegram: <code>code</code>
• ```lang\n...\n``` fenced block — mrkdwn: literal backticks → Slack markdown block: syntax-highlighted code block / Telegram: <pre><code class="language-lang">...</code></pre>
• pipe tables — mrkdwn: literal | text → Slack markdown block: real table / Telegram: <pre>-wrapped, column-aligned text
• --- divider — mrkdwn: literal dashes → Slack markdown block: real divider / Telegram: literal dash rule
• <https://x|label> legacy mrkdwn link syntax some agents emit — normalized to [label](https://x) before Slack block construction; <@U123> mentions and non-URL angle brackets are left untouched

Out of scope

• RichRenderer tool-call cards (lists, tables, status blocks) — unchanged
• Mattermost adapter — unaffected, already parses real GFM
• Queued-ack helpers and the dispatcher — unchanged
• No file-upload-on-truncation fallback (a truncation marker is used instead)
• No .opencode.json config or schema surface change

Testing

• gofmt -l internal/bridge — clean
• go vet ./internal/bridge/... — clean
• go test -race ./internal/bridge/... — all 8 packages pass (internal/bridge,
  internal/bridge/external, internal/bridge/markdown, internal/bridge/mattermost,
  internal/bridge/service, internal/bridge/slack, internal/bridge/store,
  internal/bridge/telegram)
• go build ./... — clean
• make test — green (full suite, including the pre-commit hook run on this branch)
• ./scripts/check_hidden_chars.sh — flags only pre-existing files unrelated to this change

New test coverage added: Slack link normalization (<url|label> → [label](url), mentions
left alone), fence-aware chunking invariants (rune-boundary safety, no content loss across
chunk boundaries, truncation marker never landing inside an open code fence), GFM→Telegram-HTML
mapping including adversarial cases (unbalanced **/_ markers, code spans containing
markdown-look-alike characters), and both adapters' fallback/latch behavior (Slack: broad
retry vs. narrow latch predicate, including the invalid_arguments non-latching case;
Telegram: per-chunk entity-parse retry with no persistent state).

OpenSpec

Change folder: openspec/changes/bridge-slack-native-markdown/

openspec validate bridge-slack-native-markdown --strict passes:

Change 'bridge-slack-native-markdown' is valid