@brimveyn/aimux 1.13.2 → 1.14.1

package/src/pty/pty-manager.ts

@@ -85,6 +85,17 @@ function getTerminalModes(emulator: XTerm, alternateScrollMode: boolean): Termin
   }
 }
 
+// Read the scroll position straight from the emulator that owns it. This is the
+// single source of truth for re-anchoring across a resize: deriving it here
+// (zero latency) instead of accepting a frontend-supplied intent avoids the
+// stale-mirror drift that desynced selection/copy from the rendered viewport.
+function deriveEmulatorScrollIntent(emulator: XTerm): ScrollIntent {
+  const buffer = emulator.buffer.active
+  return buffer.viewportY >= buffer.baseY
+    ? { kind: 'bottom' }
+    : { absoluteLine: buffer.viewportY, kind: 'anchor' }
+}
+
 function envInt(name: string, fallback: number): number {
   const raw = process.env[name]
   if (raw === undefined) return fallback
@@ -374,13 +385,11 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     session.emulator.scrollToLine(Math.max(0, intent.absoluteLine))
   }
 
-  private applyResize(
-    session: SessionHandle,
-    cols: number,
-    rows: number,
-    intent: ScrollIntent | undefined,
-    sync: boolean
-  ): void {
+  private applyResize(session: SessionHandle, cols: number, rows: number, sync: boolean): void {
+    // Capture the scroll position from the emulator *before* reflow, so the
+    // re-anchor restores where the user actually was. The frontend no longer
+    // supplies an intent — the backend owns scroll position end to end.
+    const intent = deriveEmulatorScrollIntent(session.emulator)
     const safeCols = Math.max(20, cols)
     const safeRows = Math.max(8, rows)
     session.pty.resize(safeCols, safeRows)
@@ -406,38 +415,18 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
   }
 
-  resizeAll(
-    cols: number,
-    rows: number,
-    intents?: Map<string, ScrollIntent>,
-    options?: { sync?: boolean }
-  ): void {
+  resizeAll(cols: number, rows: number, options?: { sync?: boolean }): void {
     for (const session of this.sessions.values()) {
-      this.applyResize(session, cols, rows, intents?.get(session.tabId), options?.sync ?? false)
-    }
-  }
-
-  resizeSession(
-    tabId: string,
-    cols: number,
-    rows: number,
-    intent?: ScrollIntent,
-    options?: { sync?: boolean }
-  ): void {
-    const session = this.sessions.get(tabId)
-    if (!session) {
-      return
+      this.applyResize(session, cols, rows, options?.sync ?? false)
     }
-    this.applyResize(session, cols, rows, intent, options?.sync ?? false)
   }
 
-  reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
+  resizeSession(tabId: string, cols: number, rows: number, options?: { sync?: boolean }): void {
     const session = this.sessions.get(tabId)
     if (!session) {
       return
     }
-    this.applyScrollIntent(session, intent)
-    this.scheduleRender(session)
+    this.applyResize(session, cols, rows, options?.sync ?? false)
   }
 
   disposeSession(tabId: string): void {

package/src/pty/terminal-snapshot.ts

@@ -100,6 +100,7 @@ function buildLine(
 
   const cell = terminal.buffer.active.getNullCell()
   const spans: TerminalSpan[] = []
+  let visualColumns = 0
 
   for (let column = 0; column < terminal.cols; column += 1) {
     const current = line.getCell(column, cell)
@@ -138,6 +139,48 @@ function buildLine(
       text,
       underline: current.isUnderline() ? true : undefined,
     })
+
+    visualColumns += current.getWidth()
+  }
+
+  // Pad the row to the full terminal width so opentui overwrites every cell.
+  // Without padding, cells past the last written character retain content
+  // from the previous frame (opentui's `blendCells` preserves the existing
+  // char when an overlay space lands on it — see modal-shell.tsx for the
+  // same class of bug solved differently for transparent modals).
+  if (visualColumns < terminal.cols) {
+    const padCount = terminal.cols - visualColumns
+    const cursorInPad =
+      cursorVisible &&
+      cursorColumn !== null &&
+      cursorColumn >= visualColumns &&
+      cursorColumn < terminal.cols
+
+    if (cursorInPad && cursorColumn !== null) {
+      // cursorColumn is a buffer column while visualColumns is a sum of cell
+      // widths; they diverge when wide glyphs precede the gap. Clamp the offset
+      // into the pad so leading + cursor + trailing always equals padCount and
+      // the row never over/undershoots terminal.cols (cursor may be a column
+      // off in pathological wide-char rows, but the row width stays correct).
+      const cursorOffset = Math.min(cursorColumn - visualColumns, padCount - 1)
+      const leading = cursorOffset
+      const trailing = padCount - cursorOffset - 1
+      if (leading > 0) {
+        pushSpan(spans, { text: ' '.repeat(leading) })
+      }
+      const tokens = getCurrentTheme()
+      pushSpan(spans, {
+        bg: tokens.text,
+        cursor: true,
+        fg: tokens.background,
+        text: ' ',
+      })
+      if (trailing > 0) {
+        pushSpan(spans, { text: ' '.repeat(trailing) })
+      }
+    } else {
+      pushSpan(spans, { text: ' '.repeat(padCount) })
+    }
   }
 
   return { spans }

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

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events'
 
-import type { AssistantId, ScrollIntent, WorkspaceSnapshotV1 } from '../state/types'
+import type { AssistantId, WorkspaceSnapshotV1 } from '../state/types'
 import type { SessionBackend, SessionBackendEvents } from './types'
 
 import { SessionManager } from '../daemon/session-manager'
@@ -12,7 +12,6 @@ import {
   getSnapshotTrees,
   toTerminalContentSize,
 } from '../state/layout-resize'
-import { getSnapshotScrollIntents } from '../state/session-persistence'
 
 export class LocalSessionBackend
   extends EventEmitter<SessionBackendEvents>
@@ -67,22 +66,15 @@ export class LocalSessionBackend
     })
     this.currentSessionId = options.sessionId
     const trees = getSnapshotTrees(options.workspaceSnapshot)
-    const intents = getSnapshotScrollIntents(options.workspaceSnapshot)
     const splitTrees = trees.filter((t) => t.type === 'split')
     if (splitTrees.length > 0) {
       const bounds = createTerminalBounds(options.cols, options.rows)
       forEachSplitPaneRect(splitTrees, bounds, (tabId, rect) => {
         const size = toTerminalContentSize(rect)
-        this.sessionManager.resizeTab(
-          options.sessionId,
-          tabId,
-          size.cols,
-          size.rows,
-          intents.get(tabId)
-        )
+        this.sessionManager.resizeTab(options.sessionId, tabId, size.cols, size.rows)
       })
     } else {
-      this.sessionManager.resize(options.sessionId, options.cols, options.rows, intents)
+      this.sessionManager.resize(options.sessionId, options.cols, options.rows)
     }
     const attachResult = this.sessionManager.attachSession(
       options.sessionId,
@@ -149,36 +141,20 @@ export class LocalSessionBackend
     this.sessionManager.scrollToBottom(this.currentSessionId, tabId)
   }
 
-  reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    this.sessionManager.reapplyScrollIntent(this.currentSessionId, tabId, intent)
-  }
-
   setActiveTab(tabId: string | null): void {
     if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
     logDebug('backend.local.setActiveTab', { sessionId: this.currentSessionId, tabId })
     this.sessionManager.setActiveTab(this.currentSessionId, tabId)
   }
 
-  resizeAll(
-    cols: number,
-    rows: number,
-    intents?: Map<string, ScrollIntent>,
-    options?: { sync?: boolean }
-  ): void {
+  resizeAll(cols: number, rows: number, options?: { sync?: boolean }): void {
     if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    this.sessionManager.resize(this.currentSessionId, cols, rows, intents, options)
+    this.sessionManager.resize(this.currentSessionId, cols, rows, options)
   }
 
-  resizeTab(
-    tabId: string,
-    cols: number,
-    rows: number,
-    intent?: ScrollIntent,
-    options?: { sync?: boolean }
-  ): void {
+  resizeTab(tabId: string, cols: number, rows: number, options?: { sync?: boolean }): void {
     if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, intent, options)
+    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, options)
   }
 
   disposeSession(tabId: string): void {

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

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events'
 import { connect, type Socket } from 'node:net'
 
-import type { AssistantId, ScrollIntent, WorkspaceSnapshotV1 } from '../state/types'
+import type { AssistantId, WorkspaceSnapshotV1 } from '../state/types'
 import type { SessionBackend, SessionBackendEvents } from './types'
 
 import { getIpcDaemonSocketPath } from '../daemon/runtime-paths'
@@ -404,17 +404,6 @@ export class RemoteSessionBackend
     )
   }
 
-  reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
-    if (!this.attached) {
-      return
-    }
-    this.dispatchCommand(
-      { id: crypto.randomUUID(), payload: { intent, tabId }, type: 'reapplyScrollIntent' },
-      'reapplyScrollIntent',
-      tabId
-    )
-  }
-
   setActiveTab(tabId: string | null): void {
     if (!this.attached) {
       return
@@ -425,40 +414,24 @@ export class RemoteSessionBackend
     )
   }
 
-  resizeAll(
-    cols: number,
-    rows: number,
-    intents?: Map<string, ScrollIntent>,
-    _options?: { sync?: boolean }
-  ): void {
+  resizeAll(cols: number, rows: number, _options?: { sync?: boolean }): void {
     if (!this.attached) {
       logDebug('backend.remote.skipResizeBeforeAttach', { cols, rows })
       return
     }
     logDebug('backend.remote.resize', { cols, rows, sessionId: this.currentSessionId })
-    const intentsRecord = intents ? Object.fromEntries(intents.entries()) : undefined
     this.dispatchCommand(
-      {
-        id: crypto.randomUUID(),
-        payload: { cols, intents: intentsRecord, rows },
-        type: 'resizeClient',
-      },
+      { id: crypto.randomUUID(), payload: { cols, rows }, type: 'resizeClient' },
       'resizeClient'
     )
   }
 
-  resizeTab(
-    tabId: string,
-    cols: number,
-    rows: number,
-    intent?: ScrollIntent,
-    _options?: { sync?: boolean }
-  ): void {
+  resizeTab(tabId: string, cols: number, rows: number, _options?: { sync?: boolean }): void {
     if (!this.attached) {
       return
     }
     this.dispatchCommand(
-      { id: crypto.randomUUID(), payload: { cols, intent, rows, tabId }, type: 'resizeTab' },
+      { id: crypto.randomUUID(), payload: { cols, rows, tabId }, type: 'resizeTab' },
       'resizeTab',
       tabId
     )

package/src/session-backend/types.ts

@@ -1,7 +1,6 @@
 import type { EventEmitter } from 'node:events'
 
 import type {
-  ScrollIntent,
   SessionStatus,
   TabActivity,
   TabSession,
@@ -49,21 +48,9 @@ export interface SessionBackend extends EventEmitter<SessionBackendEvents> {
   write(tabId: string, input: string): void
   scrollViewport(tabId: string, deltaLines: number): void
   scrollViewportToBottom(tabId: string): void
-  reapplyScrollIntent(tabId: string, intent: ScrollIntent): void
   setActiveTab(tabId: string | null): 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
+  resizeAll(cols: number, rows: number, options?: { sync?: boolean }): void
+  resizeTab(tabId: string, cols: number, rows: number, options?: { sync?: boolean }): void
   disposeSession(tabId: string): void
   disposeAll(): void
   destroy(keepSessions?: boolean): Promise<void> | void

package/src/state/layout-tree.ts

@@ -124,6 +124,116 @@ export function allLeafIds(tree: LayoutNode): string[] {
   return [...allLeafIds(tree.first), ...allLeafIds(tree.second)]
 }
 
+export type BoundarySide = 'left' | 'right' | 'top' | 'bottom'
+
+export function getBoundaryLeafIds(node: LayoutNode, side: BoundarySide): string[] {
+  if (node.type === 'leaf') {
+    return [node.tabId]
+  }
+
+  const axisOfSide = side === 'left' || side === 'right' ? 'vertical' : 'horizontal'
+
+  if (node.direction === axisOfSide) {
+    // Split direction matches the side's axis: only one child touches `side`.
+    const child = side === 'left' || side === 'top' ? node.first : node.second
+    return getBoundaryLeafIds(child, side)
+  }
+
+  // Perpendicular split: both children touch `side`.
+  return [...getBoundaryLeafIds(node.first, side), ...getBoundaryLeafIds(node.second, side)]
+}
+
+export interface JunctionEdgeInfo {
+  tabId: string
+  direction: SplitDirection
+  screenStart: number
+  totalSize: number
+}
+
+export interface JunctionEdges {
+  left?: JunctionEdgeInfo
+  right?: JunctionEdgeInfo
+  top?: JunctionEdgeInfo
+  bottom?: JunctionEdgeInfo
+}
+
+function firstLeafIdOf(node: LayoutNode): string {
+  return node.type === 'leaf' ? node.tabId : firstLeafIdOf(node.first)
+}
+
+export function computeJunctionEdges(
+  tree: LayoutNode,
+  bounds: PaneRect,
+  origin: { x: number; y: number }
+): Map<string, JunctionEdges> {
+  const result = new Map<string, JunctionEdges>()
+  walk(tree, bounds)
+  return result
+
+  function ensure(tabId: string): JunctionEdges {
+    let entry = result.get(tabId)
+    if (!entry) {
+      entry = {}
+      result.set(tabId, entry)
+    }
+    return entry
+  }
+
+  function walk(node: LayoutNode, nodeBounds: PaneRect): void {
+    if (node.type === 'leaf') {
+      ensure(node.tabId)
+      return
+    }
+
+    const info: JunctionEdgeInfo = {
+      direction: node.direction,
+      screenStart:
+        node.direction === 'vertical' ? origin.x + nodeBounds.x : origin.y + nodeBounds.y,
+      tabId: firstLeafIdOf(node.first),
+      totalSize: node.direction === 'vertical' ? nodeBounds.cols : nodeBounds.rows,
+    }
+
+    if (node.direction === 'vertical') {
+      for (const leafId of getBoundaryLeafIds(node.first, 'right')) {
+        ensure(leafId).right = info
+      }
+      for (const leafId of getBoundaryLeafIds(node.second, 'left')) {
+        ensure(leafId).left = info
+      }
+    } else {
+      for (const leafId of getBoundaryLeafIds(node.first, 'bottom')) {
+        ensure(leafId).bottom = info
+      }
+      for (const leafId of getBoundaryLeafIds(node.second, 'top')) {
+        ensure(leafId).top = info
+      }
+    }
+
+    // Recurse with bounds math matching computePaneRects (now without separator gap).
+    if (node.direction === 'vertical') {
+      const firstCols = Math.max(1, Math.floor(nodeBounds.cols * node.ratio))
+      const secondCols = Math.max(1, nodeBounds.cols - firstCols)
+      walk(node.first, { cols: firstCols, rows: nodeBounds.rows, x: nodeBounds.x, y: nodeBounds.y })
+      walk(node.second, {
+        cols: secondCols,
+        rows: nodeBounds.rows,
+        x: nodeBounds.x + firstCols,
+        y: nodeBounds.y,
+      })
+    } else {
+      const firstRows = Math.max(1, Math.floor(nodeBounds.rows * node.ratio))
+      const secondRows = Math.max(1, nodeBounds.rows - firstRows)
+      walk(node.first, { cols: nodeBounds.cols, rows: firstRows, x: nodeBounds.x, y: nodeBounds.y })
+      walk(node.second, {
+        cols: nodeBounds.cols,
+        rows: secondRows,
+        x: nodeBounds.x,
+        y: nodeBounds.y + firstRows,
+      })
+    }
+  }
+}
+
 export function pruneLayoutTree(tree: LayoutNode, validTabIds: Set<string>): LayoutNode | null {
   if (tree.type === 'leaf') {
     return validTabIds.has(tree.tabId) ? tree : null
@@ -227,13 +337,13 @@ export function computePaneRects(tree: LayoutNode, bounds: PaneRect): Map<string
   if (tree.direction === 'vertical') {
     // Split left/right
     const firstCols = Math.max(1, Math.floor(bounds.cols * tree.ratio))
-    const secondCols = Math.max(1, bounds.cols - firstCols - 1) // -1 for separator
+    const secondCols = Math.max(1, bounds.cols - firstCols)
 
     const firstBounds: PaneRect = { cols: firstCols, rows: bounds.rows, x: bounds.x, y: bounds.y }
     const secondBounds: PaneRect = {
       cols: secondCols,
       rows: bounds.rows,
-      x: bounds.x + firstCols + 1,
+      x: bounds.x + firstCols,
       y: bounds.y,
     }
 
@@ -246,14 +356,14 @@ export function computePaneRects(tree: LayoutNode, bounds: PaneRect): Map<string
   } else {
     // Split top/bottom
     const firstRows = Math.max(1, Math.floor(bounds.rows * tree.ratio))
-    const secondRows = Math.max(1, bounds.rows - firstRows - 1) // -1 for separator
+    const secondRows = Math.max(1, bounds.rows - firstRows)
 
     const firstBounds: PaneRect = { cols: bounds.cols, rows: firstRows, x: bounds.x, y: bounds.y }
     const secondBounds: PaneRect = {
       cols: bounds.cols,
       rows: secondRows,
       x: bounds.x,
-      y: bounds.y + firstRows + 1,
+      y: bounds.y + firstRows,
     }
 
     for (const [id, rect] of computePaneRects(tree.first, firstBounds)) {

package/src/state/reducers/session-state.ts

@@ -1,5 +1,6 @@
 import type { AppAction, AppState } from '../types'
 
+import { moveIdToIdPosition, orderSessionsForDisplay } from '../../ui/session-ordering'
 import { filterSessions } from '../selectors'
 import { restoreWorkspaceState } from '../session-persistence'
 import { withActiveWorktree } from '../session-worktrees'
@@ -107,6 +108,25 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
       }
       return { ...state, sessions: ordered }
     }
+    case 'reorder-active-session': {
+      const currentId = state.currentSessionId
+      if (currentId == null || currentId === '') return state
+      const ids = orderSessionsForDisplay(state.sessions).map((s) => s.id)
+      const from = ids.indexOf(currentId)
+      if (from < 0) return state
+      const to = from + action.delta
+      const targetId = ids[to]
+      if (targetId == null) return state
+      const nextIds = moveIdToIdPosition(ids, currentId, targetId)
+      const byId = new Map(state.sessions.map((s) => [s.id, s]))
+      const nextSessions = nextIds.map((id, idx) => {
+        const s = byId.get(id)
+        return s ? { ...s, order: idx } : s
+      })
+      const filtered = nextSessions.filter((s): s is NonNullable<typeof s> => s != null)
+      if (filtered.length !== state.sessions.length) return state
+      return { ...state, sessions: filtered }
+    }
     case 'set-session-status': {
       const prev = state.sessionStatuses[action.sessionId]
       if (

package/src/state/reducers/tab-state.ts

@@ -1,3 +1,5 @@
+import type { AppAction, AppState, TabSession } from '../types'
+
 import {
   allLeafIds,
   createGroupId,
@@ -15,13 +17,6 @@ import {
 import { normalizeGroupedTabOrder } from '../session-persistence'
 import { orderTabsByWorktree, withActiveWorktree } from '../session-worktrees'
 import { createDefaultTerminalModes } from '../terminal-modes'
-import {
-  type AppAction,
-  type AppState,
-  DEFAULT_SCROLL_INTENT,
-  deriveScrollIntent,
-  type TabSession,
-} from '../types'
 
 const MAX_BUFFER_LENGTH = 50_000
 
@@ -204,7 +199,11 @@ function getCurrentSession(state: AppState) {
     : undefined
 }
 
-function withActiveTabWorktree(state: AppState, tabId: string | null): AppState {
+function withActiveTabWorktree(
+  state: AppState,
+  tabId: string | null,
+  opts?: { onlyIfMissing?: boolean }
+): AppState {
   if (
     tabId == null ||
     tabId === '' ||
@@ -214,6 +213,19 @@ function withActiveTabWorktree(state: AppState, tabId: string | null): AppState
   const tab = state.tabs.find((entry) => entry.id === tabId)
   if (!(tab?.worktreeId != null && tab?.worktreeId !== '')) return state
   const worktreeId = tab.worktreeId
+  // When `onlyIfMissing` is set, we leave the session's worktree alone if it
+  // already points at a known worktree. Used by `hydrate-workspace` so that
+  // a backend re-attach after a user-initiated worktree switch (j/k cycling)
+  // doesn't clobber the freshly chosen worktree by re-syncing from the
+  // restored active tab.
+  if (opts?.onlyIfMissing === true) {
+    const session = state.sessions.find((entry) => entry.id === state.currentSessionId)
+    const hasValidWorktree =
+      session?.activeWorktreeId != null &&
+      session.activeWorktreeId !== '' &&
+      (session.worktrees?.some((w) => w.id === session.activeWorktreeId) ?? false)
+    if (hasValidWorktree) return state
+  }
   return {
     ...state,
     sessions: state.sessions.map((session) =>
@@ -350,7 +362,8 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
           tabGroupMap: hydratedGroupMap,
           tabs: normalizeGroupedTabOrder(action.tabs, hydratedTrees, hydratedGroupMap),
         },
-        hydratedActiveTabId
+        hydratedActiveTabId,
+        { onlyIfMissing: true }
       )
     }
     case 'close-tab':
@@ -448,7 +461,6 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
             buffer: '',
             errorMessage: undefined,
             exitCode: undefined,
-            scrollIntent: DEFAULT_SCROLL_INTENT,
             status: 'starting',
             terminalModes: createDefaultTerminalModes(),
             viewport: undefined,
@@ -470,23 +482,11 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         ...state,
         tabs: updateTab(state.tabs, action.tabId, (tab) => ({
           ...tab,
-          scrollIntent:
-            action.source === 'resize' || action.source === 'switch'
-              ? (tab.scrollIntent ?? DEFAULT_SCROLL_INTENT)
-              : deriveScrollIntent(action.viewport),
           status: tab.status === 'starting' ? 'running' : tab.status,
           terminalModes: action.terminalModes,
           viewport: action.viewport,
         })),
       }
-    case 'set-scroll-intent':
-      return {
-        ...state,
-        tabs: updateTab(state.tabs, action.tabId, (tab) => ({
-          ...tab,
-          scrollIntent: action.intent,
-        })),
-      }
     case 'set-tab-activity':
       return {
         ...state,

package/src/state/reducers/ui-state.ts

@@ -34,9 +34,6 @@ export function reduceUIState(state: AppState, action: AppAction): AppState | nu
         ...state,
         sessionBar: { ...state.sessionBar, visible: !state.sessionBar.visible },
       }
-    case 'set-session-bar-position':
-      if (state.sessionBar.position === action.position) return state
-      return { ...state, sessionBar: { ...state.sessionBar, position: action.position } }
     default:
       return null
   }

package/src/state/session-persistence.ts

@@ -1,12 +1,6 @@
+import type { AppState, TabSession, TabStatus, WorkspaceSnapshotV1 } from './types'
+
 import { allLeafIds, createGroupId, type LayoutNode, pruneLayoutTree } from './layout-tree'
-import {
-  type AppState,
-  DEFAULT_SCROLL_INTENT,
-  type ScrollIntent,
-  type TabSession,
-  type TabStatus,
-  type WorkspaceSnapshotV1,
-} from './types'
 
 export function createEmptyWorkspaceSnapshot(): WorkspaceSnapshotV1 {
   return {
@@ -47,7 +41,6 @@ export function serializeWorkspace(state: AppState): WorkspaceSnapshotV1 {
       errorMessage: tab.errorMessage,
       exitCode: tab.exitCode,
       id: tab.id,
-      scrollIntent: tab.scrollIntent,
       status: tab.status === 'disconnected' ? 'running' : tab.status,
       terminalModes: tab.terminalModes,
       title: tab.title,
@@ -76,7 +69,6 @@ export function restoreTabsFromWorkspace(snapshot: WorkspaceSnapshotV1 | undefin
       errorMessage: tab.errorMessage,
       exitCode: tab.exitCode,
       id: tab.id,
-      scrollIntent: tab.scrollIntent ?? DEFAULT_SCROLL_INTENT,
       status: getDisconnectedStatus(tab.status),
       terminalModes: tab.terminalModes,
       title: tab.title,
@@ -85,18 +77,6 @@ export function restoreTabsFromWorkspace(snapshot: WorkspaceSnapshotV1 | undefin
     }))
 }
 
-export function getSnapshotScrollIntents(
-  snapshot: WorkspaceSnapshotV1 | undefined
-): Map<string, ScrollIntent> {
-  if (!snapshot || snapshot.version !== 1) {
-    return new Map()
-  }
-
-  return new Map(
-    snapshot.tabs.map((tab) => [tab.id, tab.scrollIntent ?? DEFAULT_SCROLL_INTENT] as const)
-  )
-}
-
 export function restoreLayoutTrees(
   snapshot: WorkspaceSnapshotV1 | undefined,
   tabs: TabSession[]