@brimveyn/aimux 1.3.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.3.0",
+  "version": "1.3.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",
@@ -57,7 +57,7 @@
     "format:check": "oxfmt --check ."
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.1.0",
+    "@brimveyn/aimux-config": "0.2.6",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@xterm/headless": "^6.0.0",

package/src/app-runtime/backend-runtime-events.ts

@@ -51,7 +51,13 @@ export function bindBackendRuntimeEvents({
       viewportY: viewport.viewportY,
     })
 
-    dispatch({ tabId, terminalModes, type: 'replace-tab-viewport', viewport })
+    dispatch({
+      source: resizingRef.current ? 'resize' : 'data',
+      tabId,
+      terminalModes,
+      type: 'replace-tab-viewport',
+      viewport,
+    })
     if (timeouts.isStartupGraceActive(tabId) || resizingRef.current) {
       return
     }

package/src/app-runtime/pty-write.ts

@@ -1,5 +1,5 @@
 import type { SessionBackend } from '../session-backend/types'
-import type { TabSession } from '../state/types'
+import type { AppAction, TabSession } from '../state/types'
 
 import { buildPtyPastePayload } from '../input/paste'
 
@@ -12,10 +12,12 @@ export function writeToTab(
   backend: SessionBackend,
   tabId: string,
   tab: TabSession | undefined,
-  input: string
+  input: string,
+  dispatch?: (action: AppAction) => void
 ): void {
   if (tab && shouldScrollViewportToBottom(tab)) {
     backend.scrollViewportToBottom(tabId)
+    dispatch?.({ intent: { kind: 'bottom' }, tabId, type: 'set-scroll-intent' })
   }
 
   backend.write(tabId, input)
@@ -25,8 +27,9 @@ export function writePasteToTab(
   backend: SessionBackend,
   tabId: string,
   tab: TabSession | undefined,
-  text: string
+  text: string,
+  dispatch?: (action: AppAction) => void
 ): void {
   const payload = buildPtyPastePayload(text, tab?.terminalModes.bracketedPasteMode ?? false)
-  writeToTab(backend, tabId, tab, payload)
+  writeToTab(backend, tabId, tab, payload, dispatch)
 }

package/src/app-runtime/side-effects.ts

@@ -2,7 +2,6 @@ import { $ } from 'bun'
 
 import type { SideEffect } from '../input/modes/types'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, AppState, AssistantId, TabSession } from '../state/types'
 
 import { loadConfig, saveConfig } from '../config'
 import { logInputDebug } from '../debug/input-log'
@@ -27,6 +26,13 @@ import {
 } from '../state/layout-tree'
 import { filterSessions, filterSnippets } from '../state/selectors'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
+import {
+  type AppAction,
+  type AppState,
+  type AssistantId,
+  DEFAULT_SCROLL_INTENT,
+  type TabSession,
+} from '../state/types'
 import { saveCurrentWorkspace } from '../state/workspace-save'
 import { scrollGitDiff } from '../ui/git-view-controls'
 import { applyTheme } from '../ui/theme'
@@ -124,14 +130,14 @@ function pasteSnippetToActiveGroup(ctx: SideEffectContext): void {
   const groupId = getGroupIdForTab(state.tabGroupMap, state.activeTabId)
   const groupTree = groupId ? state.layoutTrees[groupId] : null
   if (!groupTree) {
-    pasteSnippetToTab(backend, state.activeTabId, activeTab, snippet)
+    pasteSnippetToTab(backend, state.activeTabId, activeTab, snippet, ctx.dispatch)
     return
   }
 
   for (const tabId of allLeafIds(groupTree)) {
     const tab = state.tabs.find((entry) => entry.id === tabId)
     if (tab) {
-      pasteSnippetToTab(backend, tabId, tab, snippet)
+      pasteSnippetToTab(backend, tabId, tab, snippet, ctx.dispatch)
     }
   }
 }
@@ -229,6 +235,7 @@ export function createTabSession(
     buffer: '',
     command: customCommand ?? option.command,
     id: createTabId(),
+    scrollIntent: DEFAULT_SCROLL_INTENT,
     status: 'starting',
     terminalModes: createDefaultTerminalModes(),
     title: option.label,
@@ -393,7 +400,13 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       )
       return
     case 'paste-selected-snippet': {
-      pasteSnippetToTab(backend, state.activeTabId, ctx.activeTab, getSelectedSnippet(state))
+      pasteSnippetToTab(
+        backend,
+        state.activeTabId,
+        ctx.activeTab,
+        getSelectedSnippet(state),
+        dispatch
+      )
       return
     }
     case 'paste-snippet-to-group': {
@@ -471,11 +484,48 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       void enqueueGitOp(() => runGitPush(ctx))
       return
     }
+    case 'confirm-update-selection': {
+      handleConfirmUpdateSelection(ctx)
+      return
+    }
     default:
       effect satisfies never
   }
 }
 
+function handleConfirmUpdateSelection(ctx: SideEffectContext): void {
+  const { state } = ctx
+  if (state.modal.type !== 'update-available') {
+    return
+  }
+  const latest = state.modal.latestVersion
+  if (state.modal.selectedIndex === 0) {
+    runUpdateFromTui(ctx, latest)
+    return
+  }
+  saveConfig({ ...loadConfig(), skippedUpdateVersion: latest })
+}
+
+function runUpdateFromTui(ctx: SideEffectContext, latestVersion: string): void {
+  saveCurrentWorkspace(ctx.state)
+  void ctx.backend.destroy(true)
+  ctx.renderer.destroy()
+  process.stdout.write(`\nUpdating aimux to ${latestVersion}...\n`)
+  const proc = Bun.spawn(['bun', 'update', '-g', '@brimveyn/aimux', '@brimveyn/aimux-config'], {
+    stderr: 'inherit',
+    stdin: 'inherit',
+    stdout: 'inherit',
+  })
+  void proc.exited.then((code) => {
+    if (code === 0) {
+      process.stdout.write(`\nUpdated. Run \`aimux\` to start the new version.\n`)
+    } else {
+      process.stderr.write(`\nUpdate failed (exit code ${code}).\n`)
+    }
+    process.exit(code ?? 1)
+  })
+}
+
 async function runGitAction(
   ctx: SideEffectContext,
   args: string[],

package/src/app-runtime/snippet-actions.ts

@@ -57,13 +57,14 @@ export function pasteSnippetToTab(
   backend: SessionBackend,
   activeTabId: string | null,
   activeTab: TabSession | undefined,
-  snippet: SnippetRecord | undefined
+  snippet: SnippetRecord | undefined,
+  dispatch?: (action: AppAction) => void
 ): void {
   if (!snippet || !activeTabId || !activeTab) {
     return
   }
 
-  writePasteToTab(backend, activeTabId, activeTab, snippet.content)
+  writePasteToTab(backend, activeTabId, activeTab, snippet.content, dispatch)
 }
 
 export function handleDeleteSnippetEffect(

package/src/app-runtime/use-backend-runtime.ts

@@ -1,7 +1,7 @@
 import { type MutableRefObject, useEffect, useRef } from 'react'
 
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, LayoutState } from '../state/types'
+import type { AppAction, LayoutState, ScrollIntent } from '../state/types'
 
 import { attachCurrentSession } from './backend-attach-runtime'
 import { bindBackendRuntimeEvents } from './backend-runtime-events'
@@ -11,6 +11,7 @@ interface BackendRuntimeOptions {
   backend: SessionBackend
   dispatch: (action: AppAction) => void
   activeTabId: string | null
+  activeTabScrollIntentRef: MutableRefObject<ScrollIntent | null>
   currentSessionId: string | null
   layoutRef: MutableRefObject<LayoutState>
   resizingRef: MutableRefObject<boolean>
@@ -25,6 +26,7 @@ export interface TabRuntimeControls {
 
 export function useBackendRuntime({
   activeTabId,
+  activeTabScrollIntentRef,
   backend,
   currentSessionId,
   currentSessionWorkspaceSnapshot,
@@ -65,7 +67,10 @@ export function useBackendRuntime({
     }
 
     backend.setActiveTab(activeTabId)
-  }, [activeTabId, backend, currentSessionId])
+    if (activeTabId && activeTabScrollIntentRef.current) {
+      backend.reapplyScrollIntent(activeTabId, activeTabScrollIntentRef.current)
+    }
+  }, [activeTabId, activeTabScrollIntentRef, backend, currentSessionId])
 
   useEffect(() => {
     return bindBackendRuntimeEvents({

package/src/app-runtime/use-renderer-bindings.ts

@@ -60,7 +60,7 @@ export function useRendererBindings({
         activeTabRef.current?.terminalModes.bracketedPasteMode ?? false,
       getFocusMode: () => focusModeRef.current,
       handleTerminalShortcut,
-      writeToPty: (tabId, data) => writeToTab(backend, tabId, activeTabRef.current, data),
+      writeToPty: (tabId, data) => writeToTab(backend, tabId, activeTabRef.current, data, dispatch),
     })
 
     const handlePasteEvent = (event: { bytes: Uint8Array; defaultPrevented?: boolean }) => {
@@ -96,7 +96,7 @@ export function useRendererBindings({
         return
       }
 
-      writePasteToTab(backend, tabId, tab, payload)
+      writePasteToTab(backend, tabId, tab, payload, dispatch)
     }
 
     const handleSelection = (selection: OtuiSelection) => {

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

@@ -2,7 +2,7 @@ import { type MutableRefObject, useEffect, useMemo, useRef } from 'react'
 
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, AppState } from '../state/types'
+import type { AppAction, AppState, ScrollIntent } from '../state/types'
 
 import {
   createTerminalBounds,
@@ -27,20 +27,21 @@ function resizeSplitTabs(
   layoutTrees: AppState['layoutTrees'],
   tabIds: string[],
   cols: number,
-  rows: number
+  rows: number,
+  intents: Map<string, ScrollIntent>
 ): 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)
+    backend.resizeTab(tabId, size.cols, size.rows, intents.get(tabId))
     resizedTabIds.add(tabId)
   })
 
   for (const id of tabIds) {
     if (!resizedTabIds.has(id)) {
-      backend.resizeTab(id, cols, rows)
+      backend.resizeTab(id, cols, rows, intents.get(id))
     }
   }
 }
@@ -64,6 +65,7 @@ export function useTerminalResize({
 }: UseTerminalResizeOptions) {
   const resizingTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   const tabIdsRef = useRef<string[]>([])
+  const intentsRef = useRef<Map<string, ScrollIntent>>(new Map())
 
   const currentTabIds = state.tabs.map((t) => t.id)
   const tabIdsChanged =
@@ -74,6 +76,12 @@ export function useTerminalResize({
   }
   const stableTabIds = tabIdsRef.current
 
+  intentsRef.current = new Map(
+    state.tabs
+      .filter((t): t is typeof t & { scrollIntent: ScrollIntent } => t.scrollIntent !== undefined)
+      .map((t) => [t.id, t.scrollIntent])
+  )
+
   const terminalSize = useMemo(() => {
     const sidebarWidth = state.sidebar.visible ? state.sidebar.width + 1 : 0
     const reservedRows =
@@ -118,10 +126,11 @@ export function useTerminalResize({
         state.layoutTrees,
         stableTabIds,
         terminalSize.cols,
-        terminalSize.rows
+        terminalSize.rows,
+        intentsRef.current
       )
     } else {
-      backend.resizeAll(terminalSize.cols, terminalSize.rows)
+      backend.resizeAll(terminalSize.cols, terminalSize.rows, intentsRef.current)
     }
     resizingTimerRef.current = setTimeout(() => {
       resizingRef.current = false

package/src/app.tsx

@@ -1,6 +1,15 @@
-import { getDefaultKeymapConfig } from '@brimveyn/aimux-config'
+import type { ResolvedConfig } from '@brimveyn/aimux-config'
+
 import { useKeyboard, useRenderer, useTerminalDimensions } from '@opentui/react'
-import { useCallback, useLayoutEffect, useMemo, useReducer, useRef, useState } from 'react'
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+} from 'react'
 
 import type { KeyChord } from './input/keymap/key-chord'
 import type { TrieBinding } from './input/keymap/trie'
@@ -20,19 +29,36 @@ import { deriveModeId } from './input/modes/bridge'
 import { registerAllModes } from './input/modes/handlers'
 import { getHandler, transitionTo } from './input/modes/registry'
 import { type TerminalContentOrigin } from './input/raw-input-handler'
+import { getProfileName } from './profile-paths'
 import { appStore } from './state/app-store'
 import { setActiveDispatch } from './state/dispatch-ref'
 import { loadSessionCatalog } from './state/session-catalog'
 import { loadSnippetCatalog } from './state/snippet-catalog'
 import { appReducer, createInitialState } from './state/store'
+import { KeymapContext } from './ui/keymap-context'
 import { RootView } from './ui/root'
 import { applyTheme } from './ui/theme'
-
-const keymapHandlers = registerAllModes(getDefaultKeymapConfig())
+import {
+  fetchLatestNpmVersion,
+  getCurrentPackageVersion,
+  isNewerVersion,
+} from './update/version-check'
 
 const WORKSPACE_SAVE_DEBOUNCE_MS = 250
 
-export function App({ backend }: { backend: SessionBackend }) {
+export function App({
+  backend,
+  resolvedConfig,
+}: {
+  backend: SessionBackend
+  resolvedConfig: ResolvedConfig
+}) {
+  const keymapHandlers = useMemo(
+    () => registerAllModes(resolvedConfig.keymaps),
+    // Registration has side effects in a global mode registry — run once per app instance.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  )
   const renderer = useRenderer()
   const dimensions = useTerminalDimensions()
   const [themeId, setThemeId] = useState<ThemeId>(() => {
@@ -59,6 +85,31 @@ export function App({ backend }: { backend: SessionBackend }) {
     return () => setActiveDispatch(null)
   }, [dispatch])
 
+  useEffect(() => {
+    if (process.env.AIMUX_DISABLE_UPDATE_CHECK === '1') return
+    if (getProfileName() === 'dev') return
+
+    let cancelled = false
+    void (async () => {
+      const [current, latest] = await Promise.all([
+        getCurrentPackageVersion(),
+        fetchLatestNpmVersion('@brimveyn/aimux'),
+      ])
+      if (cancelled || !latest) return
+      if (!isNewerVersion(latest, current)) return
+      if (loadConfig().skippedUpdateVersion === latest) return
+      dispatch({
+        currentVersion: current,
+        latestVersion: latest,
+        type: 'open-update-available-modal',
+      })
+    })()
+
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
   const resizingRef = useRef(false)
   const layoutRef = useRef(state.layout)
   layoutRef.current = state.layout
@@ -81,6 +132,8 @@ export function App({ backend }: { backend: SessionBackend }) {
   activeTabIdRef.current = state.activeTabId
   const activeTabRef = useRef(activeTab)
   activeTabRef.current = activeTab
+  const activeTabScrollIntentRef = useRef(activeTab?.scrollIntent ?? null)
+  activeTabScrollIntentRef.current = activeTab?.scrollIntent ?? null
 
   const stateRef = useRef(state)
   stateRef.current = state
@@ -90,6 +143,7 @@ export function App({ backend }: { backend: SessionBackend }) {
 
   const { clearIdleTimer, clearStartupGrace, startStartupGrace } = useBackendRuntime({
     activeTabId: state.activeTabId,
+    activeTabScrollIntentRef,
     backend,
     currentSessionId: state.currentSessionId,
     currentSessionWorkspaceSnapshot,
@@ -132,15 +186,18 @@ export function App({ backend }: { backend: SessionBackend }) {
   // Allows handleTerminalShortcut (a stable callback) to reach the latest closure.
   const processKeyResultRef = useRef<(result: KeyResult, modeId: ModeId) => void>(() => {})
 
-  const handleTerminalShortcut = useCallback((chord: KeyChord): boolean => {
-    const terminalHandler = keymapHandlers.find((h) => h.id === 'terminal-input')
-    if (!terminalHandler) return false
-    const ctx: ModeContext = { state: stateRef.current }
-    const result = terminalHandler.handleChord(chord, ctx)
-    if (!result) return false
-    processKeyResultRef.current(result, 'terminal-input')
-    return true
-  }, [])
+  const handleTerminalShortcut = useCallback(
+    (chord: KeyChord): boolean => {
+      const terminalHandler = keymapHandlers.find((h) => h.id === 'terminal-input')
+      if (!terminalHandler) return false
+      const ctx: ModeContext = { state: stateRef.current }
+      const result = terminalHandler.handleChord(chord, ctx)
+      if (!result) return false
+      processKeyResultRef.current(result, 'terminal-input')
+      return true
+    },
+    [keymapHandlers]
+  )
 
   useRendererBindings({
     activeTabId: state.activeTabId,
@@ -233,21 +290,23 @@ export function App({ backend }: { backend: SessionBackend }) {
   })
 
   return (
-    <RootView
-      themeId={themeId}
-      contentOrigin={contentOriginRef.current}
-      mouseForwardingEnabled={activeMouseForwardingEnabled}
-      localScrollbackEnabled={activeLocalScrollbackEnabled}
-      onTerminalMouseEvent={handleTerminalMouseEvent}
-      onTerminalScrollEvent={handleTerminalScrollEvent}
-      onTerminalClick={handleTerminalClick}
-      onPaneActivate={handlePaneActivate}
-      onSplitResize={handleSplitResize}
-      onSeparatorDragStart={handleSeparatorDragStart}
-      onSeparatorDrag={handleSeparatorDrag}
-      onSeparatorDragEnd={handleSeparatorDragEnd}
-      terminalCols={terminalSize.cols}
-      terminalRows={terminalSize.rows}
-    />
+    <KeymapContext.Provider value={resolvedConfig.keymaps}>
+      <RootView
+        themeId={themeId}
+        contentOrigin={contentOriginRef.current}
+        mouseForwardingEnabled={activeMouseForwardingEnabled}
+        localScrollbackEnabled={activeLocalScrollbackEnabled}
+        onTerminalMouseEvent={handleTerminalMouseEvent}
+        onTerminalScrollEvent={handleTerminalScrollEvent}
+        onTerminalClick={handleTerminalClick}
+        onPaneActivate={handlePaneActivate}
+        onSplitResize={handleSplitResize}
+        onSeparatorDragStart={handleSeparatorDragStart}
+        onSeparatorDrag={handleSeparatorDrag}
+        onSeparatorDragEnd={handleSeparatorDragEnd}
+        terminalCols={terminalSize.cols}
+        terminalRows={terminalSize.rows}
+      />
+    </KeymapContext.Provider>
   )
 }

package/src/config.ts

@@ -16,6 +16,7 @@ export interface AimuxConfig {
   gitPanelVisible?: boolean
   gitPanelRatio?: number
   workspaceSnapshot?: WorkspaceSnapshotV1
+  skippedUpdateVersion?: string
 }
 
 const DEFAULT_CONFIG: AimuxConfig = {
@@ -58,6 +59,7 @@ export function loadConfigResult(): ConfigLoadResult {
       gitPanelVisible?: unknown
       gitPanelRatio?: unknown
       workspaceSnapshot?: unknown
+      skippedUpdateVersion?: unknown
     }
 
     const issues: string[] = []
@@ -98,6 +100,14 @@ export function loadConfigResult(): ConfigLoadResult {
       issues.push('ignored invalid workspaceSnapshot')
     }
 
+    const validSkippedUpdateVersion =
+      typeof parsed.skippedUpdateVersion === 'string' && parsed.skippedUpdateVersion.length > 0
+        ? parsed.skippedUpdateVersion
+        : undefined
+    if (parsed.skippedUpdateVersion !== undefined && validSkippedUpdateVersion === undefined) {
+      issues.push('ignored invalid skippedUpdateVersion')
+    }
+
     if (issues.length > 0) {
       logDebug('config.load.validationIssue', { issues, path: CONFIG_PATH })
     }
@@ -107,6 +117,7 @@ export function loadConfigResult(): ConfigLoadResult {
         customCommands: isCustomCommandsRecord(parsed.customCommands) ? parsed.customCommands : {},
         gitPanelRatio: validGitPanelRatio,
         gitPanelVisible: validGitPanelVisible,
+        skippedUpdateVersion: validSkippedUpdateVersion,
         themeId: isThemeId(parsed.themeId) ? parsed.themeId : undefined,
         version: 2,
         workspaceSnapshot: isWorkspaceSnapshotV1(parsed.workspaceSnapshot)

package/src/daemon/daemon.ts

@@ -256,7 +256,12 @@ export async function runDaemon(): Promise<void> {
                 case 'resizeClient': {
                   const sessionId = requireSession(socket, attachedSessions)
                   requireNegotiatedVersion(socket, negotiatedVersions)
-                  await manager.resize(sessionId, message.payload.cols, message.payload.rows)
+                  await manager.resize(
+                    sessionId,
+                    message.payload.cols,
+                    message.payload.rows,
+                    message.payload.intents
+                  )
                   sendOk(socket, message.id)
                   break
                 }
@@ -267,7 +272,8 @@ export async function runDaemon(): Promise<void> {
                     sessionId,
                     message.payload.tabId,
                     message.payload.cols,
-                    message.payload.rows
+                    message.payload.rows,
+                    message.payload.intent
                   )
                   sendOk(socket, message.id)
                   break
@@ -286,6 +292,17 @@ export async function runDaemon(): Promise<void> {
                   sendOk(socket, message.id)
                   break
                 }
+                case 'reapplyScrollIntent': {
+                  const sessionId = requireSession(socket, attachedSessions)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  await manager.reapplyScrollIntent(
+                    sessionId,
+                    message.payload.tabId,
+                    message.payload.intent
+                  )
+                  sendOk(socket, message.id)
+                  break
+                }
                 case 'setActiveTab': {
                   const sessionId = requireSession(socket, attachedSessions)
                   requireNegotiatedVersion(socket, negotiatedVersions)

package/src/daemon/session-manager.ts

@@ -1,6 +1,11 @@
 import { EventEmitter } from 'node:events'
 
-import type { TerminalModeState, TerminalSnapshot, WorkspaceSnapshotV1 } from '../state/types'
+import type {
+  ScrollIntent,
+  TerminalModeState,
+  TerminalSnapshot,
+  WorkspaceSnapshotV1,
+} from '../state/types'
 
 import { logDebug } from '../debug/input-log'
 import { SessionRegistry } from './session-registry'
@@ -62,12 +67,18 @@ export class SessionManager extends EventEmitter<SessionManagerEvents> {
     this.getOrCreateRegistry(sessionId).write(tabId, data)
   }
 
-  resize(sessionId: string, cols: number, rows: number): void {
-    this.getOrCreateRegistry(sessionId).resizeAll(cols, rows)
+  resize(sessionId: string, cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+    this.getOrCreateRegistry(sessionId).resizeAll(cols, rows, intents)
   }
 
-  resizeTab(sessionId: string, tabId: string, cols: number, rows: number): void {
-    this.getOrCreateRegistry(sessionId).resizeTab(tabId, cols, rows)
+  resizeTab(
+    sessionId: string,
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent
+  ): void {
+    this.getOrCreateRegistry(sessionId).resizeTab(tabId, cols, rows, intent)
   }
 
   scroll(sessionId: string, tabId: string, deltaLines: number): void {
@@ -78,6 +89,10 @@ export class SessionManager extends EventEmitter<SessionManagerEvents> {
     this.getOrCreateRegistry(sessionId).scrollViewportToBottom(tabId)
   }
 
+  reapplyScrollIntent(sessionId: string, tabId: string, intent: ScrollIntent): void {
+    this.getOrCreateRegistry(sessionId).reapplyScrollIntent(tabId, intent)
+  }
+
   setActiveTab(sessionId: string, tabId: string | null): void {
     this.getOrCreateRegistry(sessionId).setActiveTab(tabId)
   }