@brimveyn/aimux 1.13.0 → 1.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.6.0",
+    "@brimveyn/aimux-config": "0.6.3",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

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

@@ -10,7 +10,6 @@ import {
   getSnapshotTrees,
   toTerminalContentSize,
 } from '../state/layout-resize'
-import { getSnapshotScrollIntents } from '../state/session-persistence'
 
 export function resizeSnapshotPanes(
   snapshot: WorkspaceSnapshotV1 | undefined,
@@ -22,14 +21,13 @@ export function resizeSnapshotPanes(
   }
 
   const trees = getSnapshotTrees(snapshot)
-  const intents = getSnapshotScrollIntents(snapshot)
   const bounds = createTerminalBounds(
     layoutRef.current.terminalCols,
     layoutRef.current.terminalRows
   )
   forEachSplitPaneRect(trees, bounds, (tabId, rect) => {
     const size = toTerminalContentSize(rect)
-    backend.resizeTab(tabId, size.cols, size.rows, intents.get(tabId))
+    backend.resizeTab(tabId, size.cols, size.rows)
   })
 }
 
@@ -109,14 +107,14 @@ export function attachCurrentSession({
   attachRequestIdRef.current = attachRequestId
   let cancelled = false
 
-  void backend
-    .attach({
-      cols: layoutRef.current.terminalCols,
-      rows: layoutRef.current.terminalRows,
-      sessionId: currentSessionId,
-      workspaceSnapshot: currentSessionWorkspaceSnapshot,
-    })
-    .then((result) => {
+  void (async () => {
+    try {
+      const result = await backend.attach({
+        cols: layoutRef.current.terminalCols,
+        rows: layoutRef.current.terminalRows,
+        sessionId: currentSessionId,
+        workspaceSnapshot: currentSessionWorkspaceSnapshot,
+      })
       if (cancelled || attachRequestIdRef.current !== attachRequestId) {
         return
       }
@@ -134,8 +132,7 @@ export function attachCurrentSession({
         layoutRef,
         backend
       )
-    })
-    .catch((error) => {
+    } catch (error) {
       if (cancelled || attachRequestIdRef.current !== attachRequestId) {
         return
       }
@@ -151,7 +148,8 @@ export function attachCurrentSession({
         layoutRef,
         backend
       )
-    })
+    }
+  })()
 
   return () => {
     cancelled = true

package/src/app-runtime/multi-click-clipboard-guard.ts

@@ -1,21 +1,33 @@
 // On multi-click selection mouseUp opentui's finishSelection() fires the
 // 'selection' event *after* our handleTerminalMouseUp has already written
-// the clipboard from drag.capturedLines (anchored at click time). The event
-// handler would then call computeStreamSelectedText against the *current*
-// tab.viewport.lines and overwrite our write with a value that can diverge
-// by a few rows when output landed between mouseDown and mouseUp.
+// the clipboard from drag.capturedLines (anchored in absolute buffer rows).
+// The event handler would then call computeStreamSelectedText against the
+// *current* tab.viewport.lines and overwrite our write with a value that can
+// diverge by a few rows when output/auto-scroll moved the viewport between
+// mouseDown and mouseUp.
 //
-// To avoid that, handleTerminalMouseUp pings the guard right after it
-// copies; handleSelection consults the guard and skips its own copy for a
-// short window.
-
-const SUPPRESS_WINDOW_MS = 100
-let lastMultiClickWriteAt = 0
+// finishSelection() emits exactly one 'selection' event, so we suppress
+// exactly one — a consume-once flag rather than a time window (which could
+// either expire before the event arrived, letting a wrong value through, or
+// swallow an unrelated selection that happened to land in the window).
+//
+// A short guard window bounds the flag: if the expected event never arrives
+// (no finishSelection fired), the flag self-heals instead of silently eating
+// the user's next genuine selection.
+const ARM_WINDOW_MS = 250
+let armedAt = 0
 
 export function recordMultiClickClipboardWrite(): void {
-  lastMultiClickWriteAt = Date.now()
+  armedAt = Date.now()
 }
 
 export function shouldSuppressSelectionCopy(): boolean {
-  return Date.now() - lastMultiClickWriteAt < SUPPRESS_WINDOW_MS
+  if (armedAt === 0) {
+    return false
+  }
+  const withinWindow = Date.now() - armedAt < ARM_WINDOW_MS
+  // Consume the arm regardless: the one finishSelection event is now handled,
+  // and a stale arm must not suppress a later, unrelated selection.
+  armedAt = 0
+  return withinWindow
 }

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

@@ -1,5 +1,5 @@
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, TabSession } from '../state/types'
+import type { TabSession } from '../state/types'
 
 import { logInputDebug } from '../debug/input-log'
 import { buildPtyPastePayload } from '../input/paste'
@@ -18,7 +18,6 @@ export function writeToTab(
   tabId: string,
   tab: TabSession | undefined,
   input: string,
-  dispatch?: (action: AppAction) => void,
   options?: PtyWriteOptions
 ): void {
   logInputDebug('ptyWrite.writeToTab', {
@@ -28,8 +27,9 @@ export function writeToTab(
     tabId,
   })
   if ((options?.autoBottom ?? true) && tab && shouldScrollViewportToBottom(tab)) {
+    // Backend owns the scroll position; the snapshot it emits reflects the new
+    // bottom, so the frontend mirror updates without a separate dispatch.
     backend.scrollViewportToBottom(tabId)
-    dispatch?.({ intent: { kind: 'bottom' }, tabId, type: 'set-scroll-intent' })
   }
 
   backend.write(tabId, input)
@@ -39,11 +39,10 @@ export function writePasteToTab(
   backend: SessionBackend,
   tabId: string,
   tab: TabSession | undefined,
-  text: string,
-  dispatch?: (action: AppAction) => void
+  text: string
 ): void {
   const payload = buildPtyPastePayload(text, tab?.terminalModes.bracketedPasteMode ?? false)
-  writeToTab(backend, tabId, tab, payload, dispatch, { autoBottom: true })
+  writeToTab(backend, tabId, tab, payload, { autoBottom: true })
 }
 
 const DEL = '\x7f'
@@ -63,12 +62,10 @@ export function writeMacroExpansionToTab(
   tab: TabSession | undefined,
   eraseCount: number,
   expandedText: string,
-  cursorOffset: number,
-  dispatch?: (action: AppAction) => void
+  cursorOffset: number
 ): void {
   if (tab && shouldScrollViewportToBottom(tab)) {
     backend.scrollViewportToBottom(tabId)
-    dispatch?.({ intent: { kind: 'bottom' }, tabId, type: 'set-scroll-intent' })
   }
 
   const erase = eraseCount > 0 ? DEL.repeat(eraseCount) : ''

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

@@ -13,6 +13,7 @@ import { dirname, join as joinPath, resolve as resolvePath } from 'node:path'
 
 import type { SideEffect } from '../input/modes/types'
 import type { SessionBackend } from '../session-backend/types'
+import type { AppAction, AppState, AssistantId, TabSession, WorktreeRecord } from '../state/types'
 import type { ThemeId } from '../ui/themes'
 
 import { loadConfig, saveConfig } from '../config'
@@ -59,14 +60,6 @@ import { getActiveWorktree, getSessionProjectPath } from '../state/session-workt
 import { getSnippetsCatalogPath, isConfigSnippetId } from '../state/snippet-catalog'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
 import { toast } from '../state/toast-store'
-import {
-  type AppAction,
-  type AppState,
-  type AssistantId,
-  DEFAULT_SCROLL_INTENT,
-  type TabSession,
-  type WorktreeRecord,
-} from '../state/types'
 import { saveCurrentWorkspace } from '../state/workspace-save'
 import { filterThemeIds } from '../ui/filter-themes'
 import { scrollGitDiff } from '../ui/git-view-controls'
@@ -173,14 +166,14 @@ function pasteSnippetToActiveGroup(ctx: SideEffectContext): void {
   const groupId = getGroupIdForTab(state.tabGroupMap, state.activeTabId)
   const groupTree = groupId != null && groupId !== '' ? state.layoutTrees[groupId] : null
   if (!groupTree) {
-    pasteSnippetToTab(backend, state.activeTabId, activeTab, snippet, ctx.dispatch)
+    pasteSnippetToTab(backend, state.activeTabId, activeTab, snippet)
     return
   }
 
   for (const tabId of allLeafIds(groupTree)) {
     const tab = state.tabs.find((entry) => entry.id === tabId)
     if (tab) {
-      pasteSnippetToTab(backend, tabId, tab, snippet, ctx.dispatch)
+      pasteSnippetToTab(backend, tabId, tab, snippet)
     }
   }
 }
@@ -294,7 +287,6 @@ export function createTabSession(
     buffer: '',
     command: customCommand ?? option.command,
     id: createTabId(),
-    scrollIntent: DEFAULT_SCROLL_INTENT,
     status: 'starting',
     terminalModes: createDefaultTerminalModes(),
     title: option.label,
@@ -508,9 +500,21 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
         const worktreeName = state.modal.worktreeName
         const branchName = state.modal.branchName
         const sourceWorktreeId = getNewTabTargetWorktreeId(state)
-        void enqueueGitOp(async () =>
-          launchAssistantInNewWorktree(ctx, option.id, worktreeName, branchName, sourceWorktreeId)
-        ).catch((error) => toast.error(error instanceof Error ? error.message : String(error)))
+        void (async () => {
+          try {
+            await enqueueGitOp(async () =>
+              launchAssistantInNewWorktree(
+                ctx,
+                option.id,
+                worktreeName,
+                branchName,
+                sourceWorktreeId
+              )
+            )
+          } catch (error) {
+            toast.error(error instanceof Error ? error.message : String(error))
+          }
+        })()
         return
       }
       launchAssistant(ctx, option.id, getNewTabTargetWorktreeId(state))
@@ -534,44 +538,54 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       return
     }
     case 'delete-worktree': {
-      void enqueueGitOp(async () =>
-        runDeleteWorktree(
-          { ...ctx, state: ctx.getState() },
-          effect.sessionId,
-          effect.worktreeId,
-          !!(effect.force === true)
-        )
-      ).catch((error) => {
-        const message = error instanceof Error ? error.message : String(error)
-        const forceable = isForceableWorktreeDeleteError(message)
-        const latest = ctx.getState()
-        if (latest.modal.type === 'new-tab' && latest.modal.step === 'worktree') {
-          const session = latest.sessions.find((entry) => entry.id === effect.sessionId)
-          const selected = session?.worktrees?.[latest.modal.selectedIndex]
-          if (selected && selected.id !== effect.worktreeId) {
-            ctx.dispatch({ message, type: 'git-mode-set-message' })
-            return
+      void (async () => {
+        try {
+          await enqueueGitOp(async () =>
+            runDeleteWorktree(
+              { ...ctx, state: ctx.getState() },
+              effect.sessionId,
+              effect.worktreeId,
+              !!(effect.force === true)
+            )
+          )
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error)
+          const forceable = isForceableWorktreeDeleteError(message)
+          const latest = ctx.getState()
+          if (latest.modal.type === 'new-tab' && latest.modal.step === 'worktree') {
+            const session = latest.sessions.find((entry) => entry.id === effect.sessionId)
+            const selected = session?.worktrees?.[latest.modal.selectedIndex]
+            if (selected && selected.id !== effect.worktreeId) {
+              ctx.dispatch({ message, type: 'git-mode-set-message' })
+              return
+            }
           }
+          ctx.dispatch({
+            confirmWorktreeId: forceable ? effect.worktreeId : null,
+            message: forceable ? message : `Could not delete worktree: ${message}`,
+            type: 'set-new-tab-worktree-delete-state',
+          })
+          ctx.dispatch({ message, type: 'git-mode-set-message' })
         }
-        ctx.dispatch({
-          confirmWorktreeId: forceable ? effect.worktreeId : null,
-          message: forceable ? message : `Could not delete worktree: ${message}`,
-          type: 'set-new-tab-worktree-delete-state',
-        })
-        ctx.dispatch({ message, type: 'git-mode-set-message' })
-      })
+      })()
       return
     }
     case 'move-worktree': {
-      void enqueueGitOp(async () =>
-        runMoveWorktree(
-          { ...ctx, state: ctx.getState() },
-          effect.sessionId,
-          effect.sourceWorktreeId,
-          effect.targetWorktreeId,
-          effect.deleteSource === true
-        )
-      ).catch((error) => toast.error(error instanceof Error ? error.message : String(error)))
+      void (async () => {
+        try {
+          await enqueueGitOp(async () =>
+            runMoveWorktree(
+              { ...ctx, state: ctx.getState() },
+              effect.sessionId,
+              effect.sourceWorktreeId,
+              effect.targetWorktreeId,
+              effect.deleteSource === true
+            )
+          )
+        } catch (error) {
+          toast.error(error instanceof Error ? error.message : String(error))
+        }
+      })()
       return
     }
     case 'open-rename-selected-session': {
@@ -598,13 +612,7 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       )
       return
     case 'paste-selected-snippet': {
-      pasteSnippetToTab(
-        backend,
-        state.activeTabId,
-        ctx.activeTab,
-        getSelectedSnippet(state),
-        dispatch
-      )
+      pasteSnippetToTab(backend, state.activeTabId, ctx.activeTab, getSelectedSnippet(state))
       return
     }
     case 'paste-snippet-to-group': {
@@ -1364,14 +1372,15 @@ function runUpdateFromTui(ctx: SideEffectContext, latestVersion: string): void {
     stdin: 'inherit',
     stdout: 'inherit',
   })
-  void proc.exited.then((code) => {
+  void (async () => {
+    const code = await proc.exited
     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(

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

@@ -71,14 +71,13 @@ export function pasteSnippetToTab(
   backend: SessionBackend,
   activeTabId: string | null,
   activeTab: TabSession | undefined,
-  snippet: SnippetRecord | undefined,
-  dispatch?: (action: AppAction) => void
+  snippet: SnippetRecord | undefined
 ): void {
   if (!snippet || activeTabId == null || activeTabId === '' || !activeTab) {
     return
   }
 
-  writePasteToTab(backend, activeTabId, activeTab, snippet.content, dispatch)
+  writePasteToTab(backend, activeTabId, activeTab, snippet.content)
 }
 
 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, ScrollIntent } from '../state/types'
+import type { AppAction, LayoutState } from '../state/types'
 
 import { attachCurrentSession } from './backend-attach-runtime'
 import { bindBackendRuntimeEvents } from './backend-runtime-events'
@@ -11,7 +11,6 @@ interface BackendRuntimeOptions {
   backend: SessionBackend
   dispatch: (action: AppAction) => void
   activeTabId: string | null
-  activeTabScrollIntentRef: MutableRefObject<ScrollIntent | null>
   currentSessionId: string | null
   layoutRef: MutableRefObject<LayoutState>
   resizingRef: MutableRefObject<boolean>
@@ -27,7 +26,6 @@ export interface TabRuntimeControls {
 
 export function useBackendRuntime({
   activeTabId,
-  activeTabScrollIntentRef,
   backend,
   currentSessionId,
   currentSessionWorkspaceSnapshot,
@@ -61,11 +59,10 @@ export function useBackendRuntime({
       return
     }
 
+    // The backend owns each tab's scroll position; a backgrounded tab keeps it
+    // in its own emulator, so switching back needs no re-anchor from here.
     backend.setActiveTab(activeTabId)
-    if (activeTabId != null && activeTabId !== '' && activeTabScrollIntentRef.current) {
-      backend.reapplyScrollIntent(activeTabId, activeTabScrollIntentRef.current)
-    }
-  }, [activeTabId, activeTabScrollIntentRef, backend, currentSessionId])
+  }, [activeTabId, backend, currentSessionId])
 
   useEffect(() => {
     return bindBackendRuntimeEvents({

package/src/app-runtime/use-mouse-handlers.ts

@@ -60,6 +60,16 @@ interface MultiClickDragState {
   capturedLines: Map<number, TerminalLine>
   autoScrollTimer: ReturnType<typeof setInterval> | null
   autoScrollDir: -1 | 0 | 1
+  // A scroll command was sent to the backend and we are still waiting for the
+  // snapshot it produces. Gates the next auto-scroll tick so the backend's
+  // viewportY can never run ahead of the frontend mirror (which all the
+  // selection math reads) — the source of the copy-offset drift.
+  autoScrollPending: boolean
+  // The drag tab's viewport object last handled by the snapshot effect. Used
+  // to ignore snapshot churn from *other* tabs: updateTab keeps unchanged tabs
+  // by reference, so an unrelated tab's output must not clear autoScrollPending
+  // or re-extend the selection.
+  lastProcessedViewport: TabSession['viewport']
 }
 
 interface UseMouseHandlersOptions {
@@ -161,6 +171,7 @@ export function useMouseHandlers({
     }
     drag.autoScrollTimer = null
     drag.autoScrollDir = 0
+    drag.autoScrollPending = false
   }
 
   const canScroll = (tab: TabSession | undefined, dir: -1 | 1): boolean => {
@@ -174,14 +185,20 @@ export function useMouseHandlers({
     clearAutoScroll(drag)
     drag.autoScrollDir = dir
     drag.autoScrollTimer = setInterval(() => {
+      // Wait for the previous scroll's snapshot before issuing the next one, so
+      // the backend viewportY stays in lockstep with the frontend mirror.
+      if (drag.autoScrollPending) {
+        return
+      }
       const tab = stateRef.current.tabs.find((t: TabSession) => t.id === drag.tabId)
       if (!canScroll(tab, dir)) {
         clearAutoScroll(drag)
         return
       }
+      drag.autoScrollPending = true
       backend.scrollViewport(drag.tabId, dir)
       // The snapshot dispatch will trigger the viewport-change effect below,
-      // which recaptures lines and re-extends the selection focus.
+      // which clears autoScrollPending, recaptures lines, and re-extends focus.
     }, AUTO_SCROLL_INTERVAL_MS)
   }
 
@@ -216,6 +233,16 @@ export function useMouseHandlers({
     const tab = stateRef.current.tabs.find((t: TabSession) => t.id === drag.tabId)
     if (!tab?.viewport) return
 
+    // The effect fires on any tab's snapshot (state.tabs is a fresh array), but
+    // the drag tab's viewport object only changes when *its* snapshot lands.
+    // Ignore churn from other tabs so the auto-scroll lockstep below stays 1:1.
+    if (tab.viewport === drag.lastProcessedViewport) return
+    drag.lastProcessedViewport = tab.viewport
+
+    // A fresh snapshot for the drag tab landed: the backend has caught up, so
+    // the auto-scroll loop may issue its next step.
+    drag.autoScrollPending = false
+
     captureViewportLines(drag, tab)
 
     const viewportRows = tab.viewport.lines.length
@@ -425,6 +452,7 @@ export function useMouseHandlers({
         anchorEndCol: selection.endCol,
         anchorStartCol: selection.startCol,
         autoScrollDir: 0,
+        autoScrollPending: false,
         autoScrollTimer: null,
         baseX: anchor.baseX,
         baseY: anchor.baseY,
@@ -433,6 +461,7 @@ export function useMouseHandlers({
         focusCol: selection.endCol,
         lastEventScreenX: event.x,
         lastEventScreenY: event.y,
+        lastProcessedViewport: tab.viewport,
         mode: selection.mode,
         tabId: targetTabId,
         target: selection.target,

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

@@ -121,15 +121,7 @@ export function useRendererBindings({
           cwd,
           now,
         })
-        writeMacroExpansionToTab(
-          backend,
-          tabId,
-          tab,
-          match.triggerText.length,
-          text,
-          cursorOffset,
-          dispatch
-        )
+        writeMacroExpansionToTab(backend, tabId, tab, match.triggerText.length, text, cursorOffset)
         registerUndo(text, cursorOffset)
         return
       }
@@ -154,7 +146,7 @@ export function useRendererBindings({
             now,
           })
           // Trigger already erased above; eraseCount = 0 here.
-          writeMacroExpansionToTab(backend, tabId, tab, 0, text, cursorOffset, dispatch)
+          writeMacroExpansionToTab(backend, tabId, tab, 0, text, cursorOffset)
           registerUndo(text, cursorOffset)
         } finally {
           inFlightAsyncExpansionRef.current.delete(tabId)
@@ -194,7 +186,7 @@ export function useRendererBindings({
       resetTrigger: (tabId) => triggerDetectorsRef.current.get(tabId)?.reset(),
       tryConsumeMacroUndo,
       writeToPty: (tabId, data, options) =>
-        writeToTab(backend, tabId, activeTabRef.current, data, dispatch, options),
+        writeToTab(backend, tabId, activeTabRef.current, data, options),
     })
 
     const handlePasteEvent = (event: { bytes: Uint8Array; defaultPrevented?: boolean }) => {
@@ -230,7 +222,7 @@ export function useRendererBindings({
         return
       }
 
-      writePasteToTab(backend, tabId, tab, payload, dispatch)
+      writePasteToTab(backend, tabId, tab, payload)
     }
 
     const handleSelection = (selection: OtuiSelection) => {

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

@@ -10,7 +10,7 @@ import {
 
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, AppState, ScrollIntent } from '../state/types'
+import type { AppAction, AppState } from '../state/types'
 import type { MeasuredPaneRect } from './use-pane-size-report'
 
 import { getGitPaneWidthFromRatio } from '../state/git-pane-sizing'
@@ -44,7 +44,6 @@ function resizeSplitTabs(
   tabIds: string[],
   cols: number,
   rows: number,
-  intents: Map<string, ScrollIntent>,
   options?: { sync?: boolean }
 ): void {
   const bounds = getTerminalBounds(cols, rows)
@@ -52,13 +51,13 @@ function resizeSplitTabs(
 
   forEachSplitPaneRect(Object.values(layoutTrees), bounds, (tabId, rect) => {
     const size = toTerminalContentSize(rect)
-    backend.resizeTab(tabId, size.cols, size.rows, intents.get(tabId), options)
+    backend.resizeTab(tabId, size.cols, size.rows, options)
     resizedTabIds.add(tabId)
   })
 
   for (const id of tabIds) {
     if (!resizedTabIds.has(id)) {
-      backend.resizeTab(id, cols, rows, intents.get(id), options)
+      backend.resizeTab(id, cols, rows, options)
     }
   }
 }
@@ -81,7 +80,6 @@ interface RunResizeCascadeArgs {
   rows: number
   layoutTrees: AppState['layoutTrees']
   stableTabIds: string[]
-  intents: Map<string, ScrollIntent>
   sync: boolean
 }
 
@@ -89,7 +87,6 @@ function runResizeCascade({
   backend,
   cols,
   dispatch,
-  intents,
   layoutTrees,
   resizingRef,
   resizingTimerRef,
@@ -107,9 +104,9 @@ function runResizeCascade({
       clearTimeout(resizingTimerRef.current)
     }
     if (hasSplits) {
-      resizeSplitTabs(backend, layoutTrees, stableTabIds, cols, rows, intents, options)
+      resizeSplitTabs(backend, layoutTrees, stableTabIds, cols, rows, options)
     } else {
-      backend.resizeAll(cols, rows, intents, options)
+      backend.resizeAll(cols, rows, options)
     }
     resizingTimerRef.current = setTimeout(() => {
       resizingRef.current = false
@@ -133,7 +130,6 @@ 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 handledBySyncRef = useRef(false)
   const sidebarMountedRef = useRef(false)
 
@@ -146,12 +142,6 @@ 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 activeTabIdRef = useRef(state.activeTabId)
   activeTabIdRef.current = state.activeTabId
   // Last size we pushed to the backend per tab, used to dedupe the measurement
@@ -176,7 +166,7 @@ export function useTerminalResize({
         return
       }
       measuredRef.current.set(tabId, { cols, rows })
-      backend.resizeTab(tabId, cols, rows, intentsRef.current.get(tabId))
+      backend.resizeTab(tabId, cols, rows)
     },
     [backend, contentOriginRef]
   )
@@ -230,7 +220,6 @@ export function useTerminalResize({
       backend,
       cols: terminalSize.cols,
       dispatch,
-      intents: intentsRef.current,
       layoutTrees: state.layoutTrees,
       resizingRef,
       resizingTimerRef,
@@ -259,7 +248,6 @@ export function useTerminalResize({
       backend,
       cols: terminalSize.cols,
       dispatch,
-      intents: intentsRef.current,
       layoutTrees: state.layoutTrees,
       resizingRef,
       resizingTimerRef,