@brimveyn/aimux 1.13.2 → 1.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.13.2",
+  "version": "1.14.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",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.6.2",
+    "@brimveyn/aimux-config": "0.6.4",
     "@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)
   })
 }
 

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'
@@ -42,6 +43,7 @@ import {
   isCommandAvailable,
   parseCommand,
 } from '../pty/command-registry'
+import { appStore } from '../state/app-store'
 import { createTerminalBounds } from '../state/layout-resize'
 import {
   allLeafIds,
@@ -55,18 +57,17 @@ import {
 } from '../state/layout-tree'
 import { filterAssistants, filterSessions, filterSnippets } from '../state/selectors'
 import { saveSessionCatalog } from '../state/session-catalog'
-import { getActiveWorktree, getSessionProjectPath } from '../state/session-worktrees'
+import {
+  filterTabsForActiveWorktree,
+  getActiveWorktree,
+  getSessionProjectPath,
+  withActiveWorktree,
+} from '../state/session-worktrees'
 import { getSnippetsCatalogPath, isConfigSnippetId } from '../state/snippet-catalog'
+import { appReducer } from '../state/store'
+import { buildTabEntries } from '../state/tab-entries'
 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'
@@ -78,6 +79,7 @@ import {
   handleRenameSessionEffect,
   handleSwitchSessionEffect,
   restartTabSession,
+  switchSessionRecords,
 } from './session-actions'
 import {
   handleDeleteSnippetEffect,
@@ -173,14 +175,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 +296,6 @@ export function createTabSession(
     buffer: '',
     command: customCommand ?? option.command,
     id: createTabId(),
-    scrollIntent: DEFAULT_SCROLL_INTENT,
     status: 'starting',
     terminalModes: createDefaultTerminalModes(),
     title: option.label,
@@ -620,13 +621,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': {
@@ -803,6 +798,14 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       handleSwitchSessionByIndex(ctx, effect.index)
       return
     }
+    case 'cycle-sidebar-item': {
+      handleCycleSidebarItem(ctx, effect.direction)
+      return
+    }
+    case 'switch-tab-by-index': {
+      handleSwitchTabByIndex(ctx, effect.index)
+      return
+    }
     case 'toggle-transparent': {
       const next = !getTransparent()
       setTransparent(next)
@@ -1074,6 +1077,133 @@ function handleSwitchSessionByIndex(ctx: SideEffectContext, index: number): void
   handleSwitchSessionEffect(state, backend, dispatch, target)
 }
 
+interface SidebarItem {
+  sessionId: string
+  worktreeId: string | null
+}
+
+function buildSidebarItems(state: AppState): SidebarItem[] {
+  const ordered = [...state.sessions].sort(
+    (a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER)
+  )
+  const items: SidebarItem[] = []
+  for (const session of ordered) {
+    items.push({ sessionId: session.id, worktreeId: null })
+    const worktrees = session.worktrees ?? []
+    const primary = worktrees.find((w) => w.source === 'primary') ?? worktrees[0]
+    for (const wt of worktrees) {
+      if (wt.id === primary?.id) continue
+      items.push({ sessionId: session.id, worktreeId: wt.id })
+    }
+  }
+  return items
+}
+
+function findCurrentSidebarItem(state: AppState, items: SidebarItem[]): number {
+  const sessionId = state.currentSessionId
+  if (sessionId == null || sessionId === '') return -1
+  const session = state.sessions.find((s) => s.id === sessionId)
+  const worktrees = session?.worktrees ?? []
+  const primary = worktrees.find((w) => w.source === 'primary') ?? worktrees[0]
+  const activeWtId = session?.activeWorktreeId ?? null
+  // The workspace row IS the primary worktree (no separate row), so an active
+  // primary or undefined active maps to the workspace-item.
+  const targetWorktreeId = activeWtId == null || activeWtId === primary?.id ? null : activeWtId
+  return items.findIndex(
+    (item) => item.sessionId === sessionId && item.worktreeId === targetWorktreeId
+  )
+}
+
+function handleCycleSidebarItem(ctx: SideEffectContext, direction: 1 | -1): void {
+  const { backend, dispatch } = ctx
+  // Read fresh from the store, not ctx.state (which is a per-render
+  // snapshot). Rapid key presses fire before React re-renders, so ctx.state
+  // can lag the actual store.
+  const state = appStore.getState()
+  const items = buildSidebarItems(state)
+  if (items.length === 0) return
+  const currentIdx = findCurrentSidebarItem(state, items)
+  // If we don't know the current, jump to first/last depending on direction.
+  let startIdx: number
+  if (currentIdx >= 0) {
+    startIdx = currentIdx
+  } else {
+    startIdx = direction === 1 ? -1 : 0
+  }
+  const len = items.length
+  const target = items[(((startIdx + direction) % len) + len) % len]
+  if (!target) return
+
+  const session = state.sessions.find((s) => s.id === target.sessionId)
+  if (!session) return
+
+  // Determine the worktree to activate. For workspace-items, that's the
+  // primary; for worktree-items, the specific worktree.
+  const worktrees = session.worktrees ?? []
+  const primary = worktrees.find((w) => w.source === 'primary') ?? worktrees[0]
+  const targetWorktreeId = target.worktreeId ?? primary?.id
+
+  const isCrossWorkspace = session.id !== state.currentSessionId
+  const needsWorktreeChange =
+    targetWorktreeId != null && targetWorktreeId !== session.activeWorktreeId
+
+  if (isCrossWorkspace) {
+    // Bundle the worktree change into the session record AND fold the
+    // session switch's two dispatches (set-sessions + load-session) into a
+    // SINGLE Zustand setState call — otherwise each dispatch fires a
+    // separate subscription notification and the @opentui/react reconciler
+    // paints an intermediate frame where the new session is current but
+    // the old activeWorktreeId still holds, producing the visible flicker.
+    const patchedSession = needsWorktreeChange
+      ? withActiveWorktree(session, targetWorktreeId)
+      : session
+    const patchedState: AppState = needsWorktreeChange
+      ? {
+          ...state,
+          sessions: state.sessions.map((s) => (s.id === patchedSession.id ? patchedSession : s)),
+        }
+      : state
+    const sessions = switchSessionRecords(patchedState, patchedSession)
+    saveSessionCatalog(sessions)
+    void backend.destroy(true)
+    appStore.setState((current) => {
+      const afterSet = appReducer(current, { sessions, type: 'set-sessions' })
+      return appReducer(afterSet, {
+        sessionId: patchedSession.id,
+        type: 'load-session',
+        workspaceSnapshot: patchedSession.workspaceSnapshot,
+      })
+    })
+    return
+  }
+
+  if (needsWorktreeChange) {
+    dispatch({
+      sessionId: session.id,
+      type: 'set-active-worktree',
+      worktreeId: targetWorktreeId,
+    })
+  }
+}
+
+function handleSwitchTabByIndex(ctx: SideEffectContext, index: number): void {
+  const { dispatch, state } = ctx
+  const currentSession =
+    state.currentSessionId != null && state.currentSessionId !== ''
+      ? state.sessions.find((s) => s.id === state.currentSessionId)
+      : undefined
+  const visible = filterTabsForActiveWorktree(state.tabs, currentSession)
+  const entries = buildTabEntries(visible, state.layoutTrees, state.tabGroupMap, state.activeTabId)
+  const target = entries[index - 1]
+  if (!target) {
+    logInputDebug('app.tabBar.switchOutOfRange', { index, total: entries.length })
+    return
+  }
+  const targetTabId = target.kind === 'single' ? target.tab.id : target.activeLeafId
+  if (targetTabId === state.activeTabId) return
+  dispatch({ tabId: targetTabId, type: 'set-active-tab' })
+}
+
 function replaceSession(
   state: AppState,
   sessionId: string,

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/split-drag-controller.ts

@@ -29,7 +29,9 @@ function getScreenPosition(event: OtuiMouseEvent, axis: ScreenAxis): number {
 
 export function getSplitRatioFromDrag(event: OtuiMouseEvent, drag: SplitDragState): number {
   const position = getScreenPosition(event, drag.direction === 'vertical' ? 'x' : 'y')
-  return (position - drag.screenStart) / drag.totalSize
+  const total = Math.max(1, drag.totalSize)
+  const cells = Math.round(position - drag.screenStart)
+  return cells / total
 }
 
 export function getAxisDeltaFromDrag(event: OtuiMouseEvent, drag: AxisDragState): number {

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) => {