feat(cli): scroll the transcript three lines per wheel notch

Closes #1268.

OpenTUI's ScrollBox multiplies each wheel event's notch delta by whatever
its ScrollAcceleration returns, and defaults to LinearScrollAccel, whose
tick() returns 1. A terminal reports one notch as a delta of 1, so the
transcript moves a single line per notch -- far slower than the three
lines terminals and desktop apps use.

ScrollBox already accepts a scrollAcceleration option, so this needs no
upstream change: the React reconciler spreads JSX props straight into the
renderable's constructor, which assigns the field the wheel handler reads.

Neither shipped accelerator gives a flat multiplier -- LinearScrollAccel
is fixed at 1, MacOSScrollAccel ramps with scroll velocity -- so this adds
a small stateless one. Being stateless, a single shared instance is enough,
which also keeps the prop's identity stable across renders.

Scoped to the chat transcript on purpose. The prompt editor's scrollbox is
a few rows tall, where three lines a notch would skip most of its content,
so it keeps the one-line default; a test pins that split.

Claude-Session: https://claude.ai/code/session_018vPhyqaaoKa8cgs7GEnyq5

Author: kavish-19

cli/src/chat.tsx

@@ -97,6 +97,7 @@ import {
 import { createPasteHandler } from './utils/strings'
 import { setTerminalTitle } from './utils/terminal-title'
 import { computeInputLayoutMetrics } from './utils/text-layout'
+import { wheelScrollAcceleration } from './utils/wheel-scroll-acceleration'
 
 import type { CommandResult } from './commands/command-registry'
 import type { MultilineInputHandle } from './components/multiline-input'
@@ -1664,6 +1665,7 @@ export const Chat = ({
         stickyScroll
         stickyStart="bottom"
         scrollX={false}
+        scrollAcceleration={wheelScrollAcceleration}
         scrollbarOptions={{ visible: false }}
         verticalScrollbarOptions={{
           visible: !isStreaming && !isWaitingForResponse && hasOverflow,

cli/src/utils/__tests__/wheel-scroll-acceleration.test.ts

@@ -0,0 +1,49 @@
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+import { describe, expect, test } from 'bun:test'
+
+import {
+  WHEEL_SCROLL_LINES,
+  wheelScrollAcceleration,
+} from '../wheel-scroll-acceleration'
+
+const repoRoot = join(import.meta.dir, '../../../..')
+const read = (relative: string) =>
+  readFileSync(join(repoRoot, relative), 'utf8')
+
+describe('wheel scroll acceleration', () => {
+  test('every notch moves the same three lines', () => {
+    expect(WHEEL_SCROLL_LINES).toBe(3)
+    expect(wheelScrollAcceleration.tick()).toBe(3)
+  })
+
+  test('the multiplier does not ramp with scroll speed', () => {
+    // OpenTUI calls tick() once per wheel event and multiplies the notch
+    // delta by the result. MacOSScrollAccel ramps here; this must not, or a
+    // fast flick overshoots by far more than the three lines asked for.
+    const now = Date.now()
+    const burst = [now, now + 1, now + 2, now + 3, now + 4].map((at) =>
+      wheelScrollAcceleration.tick(at),
+    )
+
+    expect(burst).toEqual([3, 3, 3, 3, 3])
+  })
+
+  test('reset leaves the multiplier where it was', () => {
+    wheelScrollAcceleration.tick()
+    wheelScrollAcceleration.reset()
+
+    expect(wheelScrollAcceleration.tick()).toBe(WHEEL_SCROLL_LINES)
+  })
+
+  test('only the chat transcript opts in', () => {
+    // Three lines per notch suits a long transcript. The prompt editor is a
+    // few rows tall, so the same jump would skip most of its content -- it
+    // keeps OpenTUI's one-line default deliberately.
+    expect(read('cli/src/chat.tsx')).toContain('wheelScrollAcceleration')
+    expect(read('cli/src/components/multiline-input.tsx')).not.toContain(
+      'wheelScrollAcceleration',
+    )
+  })
+})

cli/src/utils/wheel-scroll-acceleration.ts

@@ -0,0 +1,35 @@
+import type { ScrollAcceleration } from '@opentui/core'
+
+/**
+ * Lines the transcript moves per mouse wheel notch, matching what terminals
+ * and desktop apps do by default.
+ */
+export const WHEEL_SCROLL_LINES = 3
+
+/**
+ * OpenTUI's ScrollBox multiplies each wheel event's notch delta by whatever
+ * its ScrollAcceleration returns, and defaults to LinearScrollAccel, whose
+ * tick() returns 1. A terminal reports one notch as a delta of 1, so the
+ * transcript crawls a single line at a time (#1268).
+ *
+ * Neither shipped accelerator gives a flat multiplier: LinearScrollAccel is
+ * fixed at 1, and MacOSScrollAccel ramps with scroll velocity, which would
+ * make a fast flick jump much further than the three lines we want. Hence
+ * this one, which is stateless -- there is nothing to accumulate or reset,
+ * so a single shared instance serves every scrollbox that opts in.
+ */
+class ConstantScrollAccel implements ScrollAcceleration {
+  constructor(private readonly lines: number) {}
+
+  tick(_now?: number): number {
+    return this.lines
+  }
+
+  reset(): void {
+    // Stateless: nothing accumulates between notches.
+  }
+}
+
+export const wheelScrollAcceleration = new ConstantScrollAccel(
+  WHEEL_SCROLL_LINES,
+)