Paint the full retained transcript instead of a smaller window

CL-5551 already caps shell.streamLog at MAX_RETAINED_STREAM_ROWS with an
absolute streamLogBase, so a second, smaller paint window on top of that
cap was redundant: painting every retained row is what makes all of it
reachable by scrolling, and it composes with the retention cap instead
of duplicating it.

repaintTranscriptWindow now paints streamLog directly (no windowSlice or
collapse marker). paintAppendStreamRow adds one node per append and
removes only what trimRetainedLog evicted. replaceStreamRowAt's cheap
single-node retext is no longer gated off past 500 rows.

Evicted rows still get a notice above the oldest retained one, updated
in place rather than rebuilt, so the boundary reads as "dropped" and
not as the true start of history.

Deleted long-log.ts's windowing exports (LONG_LOG_WINDOW, windowSlice,
mustWindow, collapseMarker) and their dedicated test file: CL-5551 left
them with zero production callers once this landed.

Author: TheGreatAxios

src/tui-opentui/long-log.test.ts

@@ -1,120 +1,18 @@
 /**
- * Long-log window strategy — keep multi-thousand-line sessions interactive.
- * Pure slice math; shell paints only the window, not the full history.
- *
- * Budget (Wave 6 defaults; CL-5399 may refine):
- * - Painted window: last N rows (or pin around offset)
- * - Collapse threshold: when history exceeds this, older rows stay in the
- *   model but drop from the render tree until scrolled into the window
+ * Retention budget for a long-running transcript. The paint tree tracks
+ * `streamLog` 1:1 (see shell.ts's repaintTranscriptWindow/paintAppendStreamRow)
+ * so every retained row stays reachable by scrolling; this cap is what keeps
+ * that array — and so the paint tree — bounded over a long session.
  */
 
-import type { StreamRow } from "./stream.js"
-
-/** Rows kept in the paint tree under normal follow-tail. */
-export const LONG_LOG_WINDOW = 200
-
-/**
- * When total rows exceed this, append/scroll paths must use windowSlice
- * (never re-paint the full history).
- */
-export const LONG_LOG_COLLAPSE_THRESHOLD = 500
-
 /**
  * Retained tail of a stream log. Display-only state — the agent's own context
  * is kept separately — but an unbounded array still costs memory and O(n)
- * snapshot/diff work on every append over a long, tool-heavy session. Set
- * above the collapse threshold so eviction never fights the paint window.
+ * snapshot/diff work on every append over a long, tool-heavy session.
  */
 export const MAX_RETAINED_STREAM_ROWS = 600
 
 /** Rows to drop from the front of a log of this length to fit the cap. */
 export function retentionOverflow(length: number): number {
   return Math.max(0, length - MAX_RETAINED_STREAM_ROWS)
 }
-
-export type LongLogWindow = {
-  /** Inclusive start index into the full row log. */
-  readonly start: number
-  /** Exclusive end index. */
-  readonly end: number
-  /** Slice of rows to paint. */
-  readonly rows: readonly StreamRow[]
-  /** True when older rows exist above the window. */
-  readonly truncatedAbove: boolean
-  /** True when newer rows exist below the window (pinned). */
-  readonly truncatedBelow: boolean
-  /** Full log length. */
-  readonly total: number
-}
-
-export type WindowSliceOpts = {
-  /** Max rows to include (default LONG_LOG_WINDOW). */
-  readonly windowSize?: number
-  /**
-   * Pin the window so this index is visible (keep-active-visible style).
-   * When omitted, follow the tail (last windowSize rows).
-   */
-  readonly pinIndex?: number
-}
-
-/**
- * Compute which rows to paint for a long log.
- * Follow-tail by default; pinIndex keeps a historical row in view.
- */
-export function windowSlice(
-  log: readonly StreamRow[],
-  opts?: WindowSliceOpts,
-): LongLogWindow {
-  const total = log.length
-  const windowSize = Math.max(1, Math.floor(opts?.windowSize ?? LONG_LOG_WINDOW))
-
-  if (total === 0) {
-    return {
-      start: 0,
-      end: 0,
-      rows: [],
-      truncatedAbove: false,
-      truncatedBelow: false,
-      total: 0,
-    }
-  }
-
-  let end: number
-  let start: number
-
-  if (opts?.pinIndex !== undefined) {
-    const pin = Math.max(0, Math.min(total - 1, Math.floor(opts.pinIndex)))
-    // Center-ish: keep pin in window; prefer showing context after pin when possible.
-    start = Math.max(0, pin - Math.floor(windowSize / 2))
-    end = Math.min(total, start + windowSize)
-    start = Math.max(0, end - windowSize)
-  } else {
-    // Follow tail
-    end = total
-    start = Math.max(0, total - windowSize)
-  }
-
-  return {
-    start,
-    end,
-    rows: log.slice(start, end),
-    truncatedAbove: start > 0,
-    truncatedBelow: end < total,
-    total,
-  }
-}
-
-/** Whether the log is large enough that windowing is mandatory. */
-export function mustWindow(totalRows: number): boolean {
-  return totalRows > LONG_LOG_COLLAPSE_THRESHOLD
-}
-
-/**
- * Collapse marker line for the paint tree when truncatedAbove.
- * Pure string — shell styles it as system chrome.
- */
-export function collapseMarker(above: number): string {
-  const n = Math.max(0, Math.floor(above))
-  if (n <= 0) return ""
-  return `… ${n} earlier line${n === 1 ? "" : "s"} collapsed`
-}

src/tui-opentui/long-log.ts

@@ -110,13 +110,7 @@ import {
   visibleSlice,
   type ListViewportState,
 } from "./list-viewport.js"
-import {
-  LONG_LOG_WINDOW,
-  collapseMarker,
-  mustWindow,
-  retentionOverflow,
-  windowSlice,
-} from "./long-log.js"
+import { retentionOverflow } from "./long-log.js"
 import {
   DEFAULT_PALETTE_COMMANDS,
   filterPaletteCommands,
@@ -1985,34 +1979,70 @@ function labelBefore(shell: AppShell, index: number): string | null {
   return blockLabel(rowBefore(shell, index), row, transcriptRowLayout(shell))
 }
 
-/** Paint + push onto the visible streamLog (child while observing, parent otherwise). */
+/**
+ * Notice painted above the oldest retained row once the cap has evicted
+ * anything. Unlike the pre-CL-5551 collapse marker it replaces, scrolling
+ * never reveals more — these rows are gone, not merely out of the window.
+ */
+function evictedRowsNotice(evicted: number): string {
+  return ` … ${evicted} earlier row${evicted === 1 ? "" : "s"} dropped (past the retention limit)`
+}
+
+/**
+ * Paint + push onto the visible streamLog (child while observing, parent
+ * otherwise). The paint tree stays 1:1 with the (retention-capped) log —
+ * CL-5551 already bounds `streamLog` to `MAX_RETAINED_STREAM_ROWS`, so there
+ * is no separate, smaller window to maintain on top of it: every retained
+ * row gets a node, which is also what makes all of it reachable by
+ * scrolling (CL-5553). A trim past the cap costs one node removal here, not
+ * a rebuild.
+ */
 function paintAppendStreamRow(shell: AppShell, row: StreamRow): void {
   clearLandingMark(shell)
   const gainedVoice = noteAgentVoice(shell, row)
   shell.streamLog.push(row)
+  const baseBefore = shell.streamLogBase
   shell.streamLogBase = trimRetainedLog(shell.streamLog, shell.streamLogBase)
   shell.lineCount = shell.streamLog.length
 
-  // Under collapse threshold: append one paint node (cheap).
-  // Over threshold: rebuild the windowed paint tree only. The retention cap
-  // sits above the collapse threshold, so a trim never lands here — by the
-  // time eviction starts, appends are already windowed.
-  if (!gainedVoice && !mustWindow(shell.streamLog.length)) {
-    const index = shell.streamLog.length - 1
-    shell.transcript.add(
-      createStreamRowRenderable(
-        shell,
-        row,
-        gapBefore(shell, index),
-        labelBefore(shell, index),
-        shell.streamLogBase + index,
-      ),
-    )
+  if (gainedVoice) {
+    repaintTranscriptWindow(shell)
     paintChrome(shell)
     return
   }
 
-  repaintTranscriptWindow(shell)
+  const dropped = shell.streamLogBase - baseBefore
+  if (dropped > 0) {
+    const hadMarker = baseBefore > 0
+    const children = transcriptRowChildren(shell)
+    for (const evicted of children.slice(hadMarker ? 1 : 0, (hadMarker ? 1 : 0) + dropped)) {
+      shell.transcript.remove(evicted)
+      destroySubtree(evicted)
+    }
+    const marker = hadMarker ? transcriptRowChildren(shell)[0] : undefined
+    if (marker instanceof TextRenderable) {
+      marker.content = evictedRowsNotice(shell.streamLogBase)
+    } else {
+      shell.transcript.add(
+        new TextRenderable(shell.renderer as CliRenderer, {
+          content: evictedRowsNotice(shell.streamLogBase),
+          fg: UI.textDim,
+        }),
+        1,
+      )
+    }
+  }
+
+  const index = shell.streamLog.length - 1
+  shell.transcript.add(
+    createStreamRowRenderable(
+      shell,
+      row,
+      gapBefore(shell, index),
+      labelBefore(shell, index),
+      shell.streamLogBase + index,
+    ),
+  )
   paintChrome(shell)
 }
 
@@ -2104,8 +2134,8 @@ export function replaceStreamRowAt(
 
   const children = transcriptRowChildren(shell)
   // A raw appendTranscript line breaks the 1:1 node↔row mapping; fall back to
-  // the windowed rebuild, which derives every node from the log.
-  if (mustWindow(shell.streamLog.length) || children.length !== shell.streamLog.length) {
+  // a full repaint, which derives every node from the log.
+  if (children.length !== shell.streamLog.length) {
     repaintTranscriptWindow(shell)
     paintChrome(shell)
     return
@@ -2214,7 +2244,12 @@ function retextStreamRowBody(
   return true
 }
 
-/** Rebuild transcript paint tree from the long-log window (O(window), not O(total)). */
+/**
+ * Rebuild the transcript paint tree from `streamLog` — every retained row,
+ * not a smaller window of it. `streamLog` is already capped at
+ * `MAX_RETAINED_STREAM_ROWS`, so this is O(cap), and painting all of it is
+ * what makes the full retained history reachable by scrolling.
+ */
 export function repaintTranscriptWindow(shell: AppShell): void {
   clearLandingMark(shell)
   shell.agentVoices = new Set(agentVoicesIn(shell.streamLog))
@@ -2225,17 +2260,18 @@ export function repaintTranscriptWindow(shell: AppShell): void {
     destroySubtree(child)
   }
 
-  const win = windowSlice(shell.streamLog, { windowSize: LONG_LOG_WINDOW })
-  if (win.truncatedAbove) {
+  // Rows evicted by the retention cap are gone for good, not just scrolled
+  // past — say so, or the boundary reads as the true start of history.
+  if (shell.streamLogBase > 0) {
     shell.transcript.add(
       new TextRenderable(shell.renderer as CliRenderer, {
-        content: ` ${collapseMarker(win.start)}`,
+        content: evictedRowsNotice(shell.streamLogBase),
         fg: UI.textDim,
       }),
     )
   }
-  win.rows.forEach((row, offset) => {
-    const local = win.start + offset
+
+  shell.streamLog.forEach((row, local) => {
     shell.transcript.add(
       createStreamRowRenderable(
         shell,