(perf): coalesce PTY outputBuffer to cut per-session memory overhead

[JeanBaptisteRenard]

Problem

Each PTY onData event calls session.outputBuffer.push(data), appending one string per event. Under heavy streaming (ink-style TUI redraws, fast model output) this produces thousands of array entries per session. Each entry carries V8 ArraySlot metadata + a separate String-object GC root. Audit Q8 estimated worst-case ~400 KB of per-session slot overhead beyond the actual byte content — about 2× the useful data for typical sessions.

Solution: coalesce-on-threshold

Extracted a pure appendToOutputBuffer(state, data, max) helper (output-buffer.js) with three ordered steps:

1. Whole-entry front-trim (original semantics, unchanged): shift() leading chunks while over the 256 KB budget, but never empty the array here (length > 1 guard).
2. Coalesce-on-threshold: when outputBuffer.length > 64, collapse the entire array into [outputBuffer.join('')]. This caps the per-session slot count to at most 65 entries (one coalesced spine + up to 64 new arrivals) while keeping the byte content identical.
3. Single-entry overflow trim (line-boundary-safe): if step 2 produces a single string still > MAX bytes, keep the last MAX bytes (newest content), then advance past the first \n so the retained string starts on a line boundary.

The for (const chunk of session.outputBuffer) reattach loop in main.js is unchanged — it iterates the same bytes in the same order regardless of how many entries the array has.

Replay-safety guarantee

• Steps 1 and 2 never split a chunk — only whole strings are dropped or joined.
• Step 3 trims from the front, then skips to the first newline boundary. ANSI/CSI escape sequences never span lines in practice, so starting at a \n boundary ensures no mid-escape or mid-UTF-8-codepoint replay corruption.
• Trade-off (same as original whole-chunk trim): terminal colour/cursor state from before the trim window is absent on reattach. Identical trade-off, now byte-accurate instead of chunk-accurate.

Estimated savings

Before: up to ~10 000 array slots per session (1 push per ~25-byte paint event over 256 KB → ~10 240 slots), each costing ≈40 bytes of V8 slot + String-object overhead → ~400 KB overhead per active session.
After: ≤65 slots regardless of event rate → overhead bounded to ~2.5 KB per session.

Practical sessions (lighter streaming): array stays under 64 entries so coalesce never fires, per-event cost is identical to baseline.

Tests

9 unit tests in test/output-buffer.test.js (pure Node, no Electron):

• Size cap: retained bytes ≤ MAX_BUFFER_SIZE at all times
• Array-length bound: ≤ 65 entries after 1 000 small pushes
• Tail-suffix ordering: retained bytes are always the newest N bytes of the stream
• Coalesce byte-equivalence: joined content matches un-coalesced concatenation
• Line-boundary trim: single oversized chunk result starts on a \n boundary
• Size accounting: outputBufferSize tracks actual byte count at every step
• Single/empty chunk edge cases

task check result in worktree: 256 pass, 30 fail — identical to the main branch baseline (the 30 failures are all pre-existing morphdom worktree false-negatives).