[liuedcson]

What this fixes

Rendering a long streamed assistant message pinned one CPU core on the CLI. Profiling a reported turn put most of the CPU inside Markdown.render, and the cost tracked the length of the message being streamed rather than the session size.

The cause was not one slow regex but the shape of the work: every delta re-lexed, re-rendered and re-wrapped the whole document, so rendering an N-character reply cost O(N²) in total. Two smaller contributors sat on top of that — the LaTeX block tokenizer is a Marked block-level extension, so its start() re-scanned the unconsumed remainder at every paragraph boundary (O(paragraphs × remaining length)), and the product path rebuilt the Markdown component for every delta, so no instance-level state could ever survive.

What changed

1. Certified-prefix incremental rendering (packages/tui/src/components/markdown.ts, markdown-stream.ts)

Markdown now keeps the rows of blocks that are provably final and re-renders only the mutable tail. A cut is certified only when it can be shown that restarting a fresh Lexer there equals rendering the whole document:

• the cut sits directly after a top-level space token, which Marked emits only for a real blank line;
• the following token starts a new top-level block at column 0 with a finished first line. Lists, quotes, tables, fences and indented code are rejected because they absorb what follows a blank line and would rewrite the tokens before the cut;
• document-wide parse facts are carried, not guessed: a block-math opener or a reference definition makes the document unsafe to split at all, and an open reference label or inline <a> / <pre|code|kbd|script> depth stops the prefix where the tail would otherwise parse differently;
• the existing document-wide no-wrap rule is preserved: code rows seed the tail, and a later code row that collides with an already wrapped prose row re-renders the frame instead of keeping rows that should have been clipped.

renderDirtyStart reports the first row that may differ, so Container and the screen diff work on the tail, and arrays already handed to callers are never mutated.

2. One predicate for block math (findBlockMathStart)

The tokenizer hint and the streaming hazard scan share a single definition of "a block-math opener starts at a line start after at most three spaces", so the literals and the pattern cannot drift apart. Documents without an opener skip the pattern entirely.

3. Instance reuse in the product path (apps/cli/.../assistant-message.ts)

AssistantMessageComponent keeps one Markdown per content run, matched by kind, and only re-points it at the new text. Padding changes rebuild the slots; the transform reads the streaming flag and the transformer list at call time so the final frame still renders in settled mode.

Correctness

Equivalence is the acceptance bar, and it is asserted, not argued:

• test/markdown-stream-prefix.test.ts — every prefix of 35 adversarial fixtures at three widths, sampled repository documents, and 200 seeded block combinations, compared byte for byte against a freshly constructed instance. The fixtures are the constructs that break a naive "freeze everything but the last block" cache: setext underlines reaching back across blocks, lists merging across blank lines, ordered lists renumbering, tables gaining a row and widening a column, reference definitions that appear later (including labels spanning blank lines), block HTML, unbalanced inline anchors, indented code continuing across a blank line, partial and unclosed fences, and code rows that collide with an earlier prose row. Plus delivery-shape coverage (1/2/7/120-character deltas), replacement, width change, invalidate(), and the renderDirtyStart contract.
• test/markdown-stream-finality.test.ts — the certification rules themselves, including the cases that must be rejected (1 that can still become a list marker, an indented witness, a table/fence/quote witness) and the guards (sticky block math, open reference label, unbalanced anchor, escaped bracket, tag text inside a fence, repeated definition that Marked drops).
• test/markdown-stream-work.test.ts — deterministic work counters instead of wall clock, so a loaded runner cannot fail a real optimization or pass a regression: a 60 KB mixed document hands the lexer about twice the document length in total (a per-frame full lex would be ~250 passes), doubling the document multiplies lex/render/wrap by less than 2.5, and each fallback (block math, reference definition, no certifiable cut, code-row collision) asserts "never reuses a prefix" and still matches a cold render.

Results

Measured through the component path, 120 columns, 120 B/delta, cumulative time including the full pipeline:

Input	Before	After
60 KB prose	1 437 ms	18 ms
60 KB mixed with a table	2 095 ms	52 ms
60 KB, 50% code	462 ms	13 ms
146 KB mixed (1 246 frames)	12 340 ms	275 ms
60 KB single unbounded paragraph	403 ms	411 ms (no cut, unchanged)

Known limits (documented in docs/tui-rendering-pipeline.md §4.2)

• A document that contains block math or a reference definition renders whole on every frame. These are sticky by design: a pending latexBlock can re-clip the paragraph in front of it, and a definition is visible to every block.
• No certifiable cut means no reuse: one unbounded paragraph, one unbounded code block, or a table that keeps growing. The output stays exact; the cost stays what it was.
• Assembling the flat string[] each frame is still a pointer copy proportional to the transcript, and the screen diff is unchanged. Both are accounted separately and do not disappear with this change.
• Step presentation's wrapper (renderNativeRun: hideCompleteFences, blank-row collapsing, trimOuterRows) still scans every native row per frame. That cost is independent and needs its own change.

Tests

• packages/tui: node --test test/*.test.ts — 1046 pass, 0 fail
• apps/cli: assistant-message, step-message, mermaid, acceptance snapshots/interactions — 74 pass, 0 fail
• pnpm run check subset relevant to this change (Biome, tsgo, ts-imports, layer/ui/workspace/pinned-deps/tui-no-ai/public-boundary/no-observability) — pass
• git diff --check — clean