@brimveyn/aimux 1.4.0 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -52,12 +52,13 @@
     "demo:splits": "vhs assets/splits.tape",
     "demo:themes": "vhs assets/themes.tape",
     "restart-daemon": "AIMUX_PROFILE=dev bun run src/index.tsx restart-daemon",
+    "restart-terminal-manager": "AIMUX_PROFILE=dev bun run src/index.tsx restart-terminal-manager",
     "lint": "oxlint .",
     "format": "oxfmt --write .",
     "format:check": "oxfmt --check ."
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.3.0",
+    "@brimveyn/aimux-config": "0.3.1",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@xterm/headless": "^6.0.0",

package/src/app-runtime/use-terminal-resize.ts

@@ -1,4 +1,4 @@
-import { type MutableRefObject, useEffect, useMemo, useRef } from 'react'
+import { type MutableRefObject, useEffect, useLayoutEffect, useMemo, useRef } from 'react'
 
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { SessionBackend } from '../session-backend/types'
@@ -28,20 +28,21 @@ function resizeSplitTabs(
   tabIds: string[],
   cols: number,
   rows: number,
-  intents: Map<string, ScrollIntent>
+  intents: Map<string, ScrollIntent>,
+  options?: { sync?: boolean }
 ): void {
   const bounds = getTerminalBounds(cols, rows)
   const resizedTabIds = new Set<string>()
 
   forEachSplitPaneRect(Object.values(layoutTrees), bounds, (tabId, rect) => {
     const size = toTerminalContentSize(rect)
-    backend.resizeTab(tabId, size.cols, size.rows, intents.get(tabId))
+    backend.resizeTab(tabId, size.cols, size.rows, intents.get(tabId), options)
     resizedTabIds.add(tabId)
   })
 
   for (const id of tabIds) {
     if (!resizedTabIds.has(id)) {
-      backend.resizeTab(id, cols, rows, intents.get(id))
+      backend.resizeTab(id, cols, rows, intents.get(id), options)
     }
   }
 }
@@ -55,6 +56,50 @@ interface UseTerminalResizeOptions {
   resizingRef: MutableRefObject<boolean>
 }
 
+interface RunResizeCascadeArgs {
+  backend: SessionBackend
+  dispatch: (action: AppAction) => void
+  resizingRef: MutableRefObject<boolean>
+  resizingTimerRef: MutableRefObject<ReturnType<typeof setTimeout> | null>
+  cols: number
+  rows: number
+  layoutTrees: AppState['layoutTrees']
+  stableTabIds: string[]
+  intents: Map<string, ScrollIntent>
+  sync: boolean
+}
+
+function runResizeCascade({
+  backend,
+  cols,
+  dispatch,
+  intents,
+  layoutTrees,
+  resizingRef,
+  resizingTimerRef,
+  rows,
+  stableTabIds,
+  sync,
+}: RunResizeCascadeArgs): void {
+  dispatch({ cols, rows, type: 'set-terminal-size' })
+  resizingRef.current = true
+  if (resizingTimerRef.current) {
+    clearTimeout(resizingTimerRef.current)
+  }
+  const trees = Object.values(layoutTrees)
+  const hasSplits = trees.some((t) => t.type === 'split')
+  const options = sync ? { sync: true } : undefined
+  if (hasSplits) {
+    resizeSplitTabs(backend, layoutTrees, stableTabIds, cols, rows, intents, options)
+  } else {
+    backend.resizeAll(cols, rows, intents, options)
+  }
+  resizingTimerRef.current = setTimeout(() => {
+    resizingRef.current = false
+    resizingTimerRef.current = null
+  }, RESIZE_ACTIVITY_SETTLE_MS)
+}
+
 export function useTerminalResize({
   backend,
   contentOriginRef,
@@ -66,6 +111,8 @@ export function useTerminalResize({
   const resizingTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   const tabIdsRef = useRef<string[]>([])
   const intentsRef = useRef<Map<string, ScrollIntent>>(new Map())
+  const handledBySyncRef = useRef(false)
+  const sidebarMountedRef = useRef(false)
 
   const currentTabIds = state.tabs.map((t) => t.id)
   const tabIdsChanged =
@@ -84,8 +131,14 @@ export function useTerminalResize({
 
   const terminalSize = useMemo(() => {
     const sidebarWidth = state.sidebar.visible ? state.sidebar.width + 1 : 0
+    const sessionBarRows = state.sessionBar.visible ? 1 : 0
+    const sessionBarTopOffset =
+      state.sessionBar.visible && state.sessionBar.position === 'top' ? 1 : 0
     const reservedRows =
-      MAIN_AREA_VERTICAL_PADDING + STATUS_BAR_HEIGHT + TERMINAL_PANE_VERTICAL_CHROME
+      MAIN_AREA_VERTICAL_PADDING +
+      STATUS_BAR_HEIGHT +
+      TERMINAL_PANE_VERTICAL_CHROME +
+      sessionBarRows
     const cols = Math.max(
       MIN_TERMINAL_COLS,
       Math.floor(dimensions.width - sidebarWidth - MAIN_AREA_HORIZONTAL_CHROME)
@@ -96,7 +149,7 @@ export function useTerminalResize({
       cols,
       rows,
       x: sidebarWidth + 1,
-      y: 1,
+      y: 1 + sessionBarTopOffset,
     }
 
     return { cols, rows }
@@ -106,36 +159,53 @@ export function useTerminalResize({
     dimensions.width,
     state.sidebar.visible,
     state.sidebar.width,
+    state.sessionBar.visible,
+    state.sessionBar.position,
   ])
 
-  useEffect(() => {
-    dispatch({
+  useLayoutEffect(() => {
+    if (!sidebarMountedRef.current) {
+      sidebarMountedRef.current = true
+      return
+    }
+    runResizeCascade({
+      backend,
       cols: terminalSize.cols,
+      dispatch,
+      intents: intentsRef.current,
+      layoutTrees: state.layoutTrees,
+      resizingRef,
+      resizingTimerRef,
       rows: terminalSize.rows,
-      type: 'set-terminal-size',
+      stableTabIds,
+      sync: true,
     })
-    resizingRef.current = true
-    if (resizingTimerRef.current) {
-      clearTimeout(resizingTimerRef.current)
-    }
-    const trees = Object.values(state.layoutTrees)
-    const hasSplits = trees.some((t) => t.type === 'split')
-    if (hasSplits) {
-      resizeSplitTabs(
-        backend,
-        state.layoutTrees,
-        stableTabIds,
-        terminalSize.cols,
-        terminalSize.rows,
-        intentsRef.current
-      )
-    } else {
-      backend.resizeAll(terminalSize.cols, terminalSize.rows, intentsRef.current)
+    handledBySyncRef.current = true
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [
+    state.sidebar.visible,
+    state.sidebar.width,
+    state.sessionBar.visible,
+    state.sessionBar.position,
+  ])
+
+  useEffect(() => {
+    if (handledBySyncRef.current) {
+      handledBySyncRef.current = false
+      return
     }
-    resizingTimerRef.current = setTimeout(() => {
-      resizingRef.current = false
-      resizingTimerRef.current = null
-    }, RESIZE_ACTIVITY_SETTLE_MS)
+    runResizeCascade({
+      backend,
+      cols: terminalSize.cols,
+      dispatch,
+      intents: intentsRef.current,
+      layoutTrees: state.layoutTrees,
+      resizingRef,
+      resizingTimerRef,
+      rows: terminalSize.rows,
+      stableTabIds,
+      sync: false,
+    })
   }, [
     backend,
     dispatch,

package/src/daemon/session-manager.ts

@@ -67,8 +67,14 @@ export class SessionManager extends EventEmitter<SessionManagerEvents> {
     this.getOrCreateRegistry(sessionId).write(tabId, data)
   }
 
-  resize(sessionId: string, cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
-    this.getOrCreateRegistry(sessionId).resizeAll(cols, rows, intents)
+  resize(
+    sessionId: string,
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void {
+    this.getOrCreateRegistry(sessionId).resizeAll(cols, rows, intents, options)
   }
 
   resizeTab(
@@ -76,9 +82,10 @@ export class SessionManager extends EventEmitter<SessionManagerEvents> {
     tabId: string,
     cols: number,
     rows: number,
-    intent?: ScrollIntent
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
   ): void {
-    this.getOrCreateRegistry(sessionId).resizeTab(tabId, cols, rows, intent)
+    this.getOrCreateRegistry(sessionId).resizeTab(tabId, cols, rows, intent, options)
   }
 
   scroll(sessionId: string, tabId: string, deltaLines: number): void {

package/src/daemon/session-registry.ts

@@ -165,12 +165,23 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
     this.ptyManager.write(tabId, data)
   }
 
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
-    this.ptyManager.resizeAll(cols, rows, intents)
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void {
+    this.ptyManager.resizeAll(cols, rows, intents, options)
   }
 
-  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
-    this.ptyManager.resizeSession(tabId, cols, rows, intent)
+  resizeTab(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
+  ): void {
+    this.ptyManager.resizeSession(tabId, cols, rows, intent, options)
   }
 
   scrollViewport(tabId: string, deltaLines: number): void {

package/src/index.tsx

@@ -9,6 +9,7 @@ import { getRuntimeProfile } from './daemon/runtime-paths'
 import { logDebug } from './debug/input-log'
 import { runDoctor } from './doctor'
 import { runRestartDaemon } from './restart-daemon'
+import { runRestartTerminalManager } from './restart-terminal-manager'
 import { createSessionBackend } from './session-backend/bootstrap'
 import { runTerminalManager } from './terminal-manager/terminal-manager'
 import { runUpdate } from './update'
@@ -30,6 +31,10 @@ if (command === 'restart-daemon') {
   process.exit(await runRestartDaemon())
 }
 
+if (command === 'restart-terminal-manager') {
+  process.exit(await runRestartTerminalManager())
+}
+
 if (command === 'update') {
   process.exit(await runUpdate())
 }
@@ -46,7 +51,7 @@ if (command === 'terminal-manager') {
 
 if (command === '--help' || command === '-h') {
   process.stdout.write(
-    'aimux -- terminal multiplexer for AI CLIs\n\nUsage:\n  aimux                  Start aimux\n  aimux update           Update to latest version\n  aimux doctor           Diagnose setup issues\n  aimux restart-daemon   Restart IPC daemon\n\n'
+    'aimux -- terminal multiplexer for AI CLIs\n\nUsage:\n  aimux                           Start aimux\n  aimux update                    Update to latest version\n  aimux doctor                    Diagnose setup issues\n  aimux restart-daemon            Restart IPC daemon\n  aimux restart-terminal-manager  Restart terminal-manager (kills live sessions)\n\n'
   )
   process.exit(0)
 }

package/src/pty/pty-manager.ts

@@ -79,8 +79,98 @@ function getTerminalModes(emulator: XTerm, alternateScrollMode: boolean): Termin
   }
 }
 
+function envInt(name: string, fallback: number): number {
+  const raw = process.env[name]
+  if (raw === undefined) return fallback
+  const parsed = Number(raw)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback
+}
+
+const RENDER_COALESCE_MS = 16
+const DATA_DEBOUNCE_MS = envInt('AIMUX_RENDER_DEBOUNCE_MS', 32)
+const BURST_MAX_MS = envInt('AIMUX_RENDER_BURST_MS', 500)
+
 export class PtyManager extends EventEmitter<PtyManagerEvents> {
   private sessions = new Map<string, SessionHandle>()
+  private pendingFlushes = new Map<string, ReturnType<typeof setTimeout>>()
+  private pendingBurstCaps = new Map<string, ReturnType<typeof setTimeout>>()
+
+  private clearTimers(tabId: string): void {
+    const flush = this.pendingFlushes.get(tabId)
+    if (flush) {
+      clearTimeout(flush)
+      this.pendingFlushes.delete(tabId)
+    }
+    const burst = this.pendingBurstCaps.get(tabId)
+    if (burst) {
+      clearTimeout(burst)
+      this.pendingBurstCaps.delete(tabId)
+    }
+  }
+
+  private scheduleRender(session: SessionHandle): void {
+    if (this.pendingFlushes.has(session.tabId)) {
+      return
+    }
+    const timer = setTimeout(() => {
+      this.pendingFlushes.delete(session.tabId)
+      if (this.sessions.get(session.tabId) !== session) {
+        return
+      }
+      const burst = this.pendingBurstCaps.get(session.tabId)
+      if (burst) {
+        clearTimeout(burst)
+        this.pendingBurstCaps.delete(session.tabId)
+      }
+      this.emitRenderIfChanged(session)
+    }, RENDER_COALESCE_MS)
+    this.pendingFlushes.set(session.tabId, timer)
+  }
+
+  private scheduleDataRender(session: SessionHandle): void {
+    const existingFlush = this.pendingFlushes.get(session.tabId)
+    if (existingFlush) {
+      clearTimeout(existingFlush)
+    }
+    const flushTimer = setTimeout(() => {
+      this.pendingFlushes.delete(session.tabId)
+      if (this.sessions.get(session.tabId) !== session) {
+        return
+      }
+      if (session.pendingWrites > 0) {
+        this.scheduleDataRender(session)
+        return
+      }
+      const burst = this.pendingBurstCaps.get(session.tabId)
+      if (burst) {
+        clearTimeout(burst)
+        this.pendingBurstCaps.delete(session.tabId)
+      }
+      this.emitRenderIfChanged(session)
+    }, DATA_DEBOUNCE_MS)
+    this.pendingFlushes.set(session.tabId, flushTimer)
+
+    if (!this.pendingBurstCaps.has(session.tabId)) {
+      const burstTimer = setTimeout(() => {
+        this.pendingBurstCaps.delete(session.tabId)
+        if (this.sessions.get(session.tabId) !== session) {
+          return
+        }
+        const flush = this.pendingFlushes.get(session.tabId)
+        if (flush) {
+          clearTimeout(flush)
+          this.pendingFlushes.delete(session.tabId)
+        }
+        this.emitRenderIfChanged(session)
+      }, BURST_MAX_MS)
+      this.pendingBurstCaps.set(session.tabId, burstTimer)
+    }
+  }
+
+  private flushRenderNow(session: SessionHandle): void {
+    this.clearTimers(session.tabId)
+    this.emitRenderIfChanged(session)
+  }
 
   private emitRenderIfChanged(session: SessionHandle): void {
     const nextSnapshot = snapshotTerminal(session.emulator, session.cursorVisible)
@@ -116,7 +206,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
 
     this.sessions.delete(session.tabId)
-    this.emitRenderIfChanged(session)
+    this.flushRenderNow(session)
     session.emulator.dispose()
     logDebug('ptyManager.finalize', { exitCode, tabId: session.tabId })
     this.emit('exit', session.tabId, exitCode)
@@ -188,9 +278,10 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
         session.cursorVisible = trackedModes.cursorVisible
         session.pendingModeSequence = trackedModes.pendingSequence
         session.pendingWrites += 1
+        this.scheduleDataRender(session)
         emulator.write(data, () => {
           session.pendingWrites -= 1
-          this.emitRenderIfChanged(session)
+          this.scheduleDataRender(session)
 
           if (session.pendingWrites === 0 && session.pendingExitCode !== null) {
             this.finalizeSession(session, session.pendingExitCode)
@@ -215,7 +306,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
 
       this.sessions.set(options.tabId, session)
       logDebug('ptyManager.create.success', { tabId: options.tabId })
-      this.emitRenderIfChanged(session)
+      this.scheduleRender(session)
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
       logDebug('ptyManager.create.error', { error: message, tabId: options.tabId })
@@ -224,7 +315,9 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
   }
 
   write(tabId: string, input: string): void {
-    this.sessions.get(tabId)?.pty.write(input)
+    const session = this.sessions.get(tabId)
+    if (!session) return
+    session.pty.write(input)
   }
 
   scrollViewport(tabId: string, deltaLines: number): void {
@@ -234,7 +327,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
 
     session.emulator.scrollLines(deltaLines)
-    this.emitRenderIfChanged(session)
+    this.scheduleRender(session)
   }
 
   scrollViewportToBottom(tabId: string): void {
@@ -244,7 +337,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
 
     session.emulator.scrollToBottom()
-    this.emitRenderIfChanged(session)
+    this.scheduleRender(session)
   }
 
   private applyScrollIntent(session: SessionHandle, intent: ScrollIntent | undefined): void {
@@ -262,7 +355,12 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     session.emulator.scrollToLine(Math.max(0, intent.absoluteLine))
   }
 
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void {
     const safeCols = Math.max(20, cols)
     const safeRows = Math.max(8, rows)
 
@@ -270,11 +368,21 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       session.pty.resize(safeCols, safeRows)
       session.emulator.resize(safeCols, safeRows)
       this.applyScrollIntent(session, intents?.get(session.tabId))
-      this.emitRenderIfChanged(session)
+      if (options?.sync) {
+        this.flushRenderNow(session)
+      } else {
+        this.scheduleRender(session)
+      }
     }
   }
 
-  resizeSession(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
+  resizeSession(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
+  ): void {
     const session = this.sessions.get(tabId)
     if (!session) {
       return
@@ -284,7 +392,11 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     session.pty.resize(safeCols, safeRows)
     session.emulator.resize(safeCols, safeRows)
     this.applyScrollIntent(session, intent)
-    this.emitRenderIfChanged(session)
+    if (options?.sync) {
+      this.flushRenderNow(session)
+    } else {
+      this.scheduleRender(session)
+    }
   }
 
   reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
@@ -293,7 +405,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       return
     }
     this.applyScrollIntent(session, intent)
-    this.emitRenderIfChanged(session)
+    this.scheduleRender(session)
   }
 
   disposeSession(tabId: string): void {
@@ -302,12 +414,16 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       return
     }
 
+    this.clearTimers(tabId)
     this.sessions.delete(tabId)
     session.pty.kill()
     session.emulator.dispose()
   }
 
   disposeAll(): void {
+    for (const tabId of this.sessions.keys()) {
+      this.clearTimers(tabId)
+    }
     for (const session of this.sessions.values()) {
       session.pty.kill()
       session.emulator.dispose()

package/src/restart-terminal-manager.ts

@@ -0,0 +1,44 @@
+import {
+  getTerminalManagerSocketPath,
+  removeTerminalManagerSocketIfExists,
+} from './daemon/runtime-paths'
+import {
+  findIpcDaemonPid,
+  findTerminalManagerPid,
+  killProcess,
+  spawnDetachedTerminalManager,
+} from './platform/daemon-control'
+
+export async function runRestartTerminalManager(): Promise<number> {
+  const socketPath = getTerminalManagerSocketPath()
+
+  const daemonPid = await findIpcDaemonPid()
+  if (daemonPid !== null) {
+    process.stdout.write(`Stopping IPC daemon (pid ${daemonPid})...\n`)
+    await killProcess(daemonPid)
+  }
+
+  const managerPid = await findTerminalManagerPid()
+  if (managerPid !== null) {
+    process.stdout.write(
+      `WARNING: killing terminal-manager (pid ${managerPid}) will kill live sessions.\n`
+    )
+    await killProcess(managerPid)
+    process.stdout.write('Terminal-manager stopped.\n')
+  } else {
+    process.stdout.write('No running terminal-manager found.\n')
+  }
+
+  removeTerminalManagerSocketIfExists()
+
+  process.stdout.write('Starting terminal-manager...\n')
+  const ok = await spawnDetachedTerminalManager()
+
+  if (ok) {
+    process.stdout.write(`Terminal-manager started on ${socketPath}.\n`)
+    return 0
+  }
+
+  process.stderr.write('Failed to start terminal-manager.\n')
+  return 1
+}

package/src/session-backend/local-session-backend.ts

@@ -151,18 +151,29 @@ export class LocalSessionBackend
     this.sessionManager.setActiveTab(this.currentSessionId, tabId)
   }
 
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void {
     if (!this.currentSessionId) {
       return
     }
-    this.sessionManager.resize(this.currentSessionId, cols, rows, intents)
+    this.sessionManager.resize(this.currentSessionId, cols, rows, intents, options)
   }
 
-  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
+  resizeTab(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
+  ): void {
     if (!this.currentSessionId) {
       return
     }
-    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, intent)
+    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, intent, options)
   }
 
   disposeSession(tabId: string): void {

package/src/session-backend/remote-session-backend.ts

@@ -398,7 +398,12 @@ export class RemoteSessionBackend
     }).catch((error) => this.reportCommandError('setActiveTab', error))
   }
 
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    _options?: { sync?: boolean }
+  ): void {
     if (!this.attached) {
       logDebug('backend.remote.skipResizeBeforeAttach', { cols, rows })
       return
@@ -412,7 +417,13 @@ export class RemoteSessionBackend
     }).catch((error) => this.reportCommandError('resizeClient', error))
   }
 
-  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
+  resizeTab(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    _options?: { sync?: boolean }
+  ): void {
     if (!this.attached) {
       return
     }

package/src/session-backend/types.ts

@@ -42,8 +42,19 @@ export interface SessionBackend extends EventEmitter<SessionBackendEvents> {
   scrollViewportToBottom(tabId: string): void
   reapplyScrollIntent(tabId: string, intent: ScrollIntent): void
   setActiveTab(tabId: string | null): void
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void
-  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void
+  resizeTab(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
+  ): void
   disposeSession(tabId: string): void
   disposeAll(): void
   destroy(keepSessions?: boolean): Promise<void> | void

package/src/ui/components/terminal-pane.tsx

@@ -1,8 +1,9 @@
 import type { MouseEvent as OtuiMouseEvent } from '@opentui/core'
-import type { ReactNode } from 'react'
+
+import { memo, type ReactNode } from 'react'
 
 import type { TerminalContentOrigin } from '../../input/raw-input-handler'
-import type { TabSession, TerminalSpan } from '../../state/types'
+import type { TabSession, TerminalSnapshot, TerminalSpan } from '../../state/types'
 
 import { logInputDebug } from '../../debug/input-log'
 import { theme } from '../theme'
@@ -77,9 +78,17 @@ function renderSpan(span: TerminalSpan, key: string): ReactNode {
   )
 }
 
-function renderViewport(tab: TabSession): ReactNode {
-  if (tab.viewport && tab.viewport.lines.length > 0) {
-    const lines = tab.viewport.lines
+interface TerminalViewportProps {
+  viewport: TerminalSnapshot | undefined
+  buffer: string
+}
+
+const TerminalViewport = memo(function TerminalViewport({
+  buffer,
+  viewport,
+}: TerminalViewportProps) {
+  if (viewport && viewport.lines.length > 0) {
+    const lines = viewport.lines
     return (
       <text fg={theme.text}>
         {lines.map((line, lineIndex) => (
@@ -92,12 +101,8 @@ function renderViewport(tab: TabSession): ReactNode {
     )
   }
 
-  return (
-    <text fg={theme.text}>
-      {tab.buffer.length > 0 ? tab.buffer : 'Waiting for session output...'}
-    </text>
-  )
-}
+  return <text fg={theme.text}>{buffer.length > 0 ? buffer : 'Waiting for session output...'}</text>
+})
 
 export function TerminalPane({
   contentOrigin,
@@ -199,7 +204,7 @@ export function TerminalPane({
             onMouseDrag={forwardMouseEvent}
             onMouseScroll={forwardScrollEvent}
           >
-            {renderViewport(tab)}
+            <TerminalViewport viewport={tab.viewport} buffer={tab.buffer} />
           </box>
         )}
       </box>