@brimveyn/aimux 1.10.0 → 1.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.10.0",
+  "version": "1.10.2",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",

package/src/app-runtime/click-selection-resolver.ts

@@ -13,6 +13,8 @@ interface PositionedNode {
   y: number
 }
 
+export type MultiClickMode = 'word' | 'line'
+
 export interface ClickSelectionResult {
   selectedText: string
   startCol: number
@@ -20,6 +22,22 @@ export interface ClickSelectionResult {
   baseX: number
   eventY: number
   target: unknown
+  row: number
+  mode: MultiClickMode
+}
+
+export interface ViewportAnchor {
+  target: PositionedNode
+  baseX: number
+  baseY: number
+  col: number
+  row: number
+}
+
+export interface MultiClickRange {
+  startCol: number
+  endCol: number
+  lineLength: number
 }
 
 export function isPositionedNode(value: unknown): value is PositionedNode {
@@ -31,100 +49,116 @@ export function isPositionedNode(value: unknown): value is PositionedNode {
   )
 }
 
+export function getViewportAnchor(event: OtuiMouseEvent): ViewportAnchor | null {
+  if (!event.target || !isPositionedNode(event.target)) return null
+  const baseX = event.target.x
+  const baseY = event.target.y
+  return {
+    baseX,
+    baseY,
+    col: event.x - baseX,
+    row: event.y - baseY,
+    target: event.target,
+  }
+}
+
+export function computeRangeFromLineText(
+  lineText: string,
+  col: number,
+  mode: MultiClickMode
+): MultiClickRange | null {
+  if (mode === 'line') {
+    return { endCol: lineText.length, lineLength: lineText.length, startCol: 0 }
+  }
+  const word = getWordAtColumn(lineText, col)
+  if (word.text.length === 0) return null
+  return { endCol: word.endCol, lineLength: lineText.length, startCol: word.startCol }
+}
+
+export function computeMultiClickRange(
+  tab: TabSession | undefined,
+  row: number,
+  col: number,
+  mode: MultiClickMode
+): MultiClickRange | null {
+  const line = tab?.viewport?.lines[row]
+  if (!line) return null
+  return computeRangeFromLineText(getLineText(line), col, mode)
+}
+
 export function resolveClickSelection(
   event: OtuiMouseEvent,
   targetTabId: string,
   tab: TabSession | undefined,
   clickCount: number
 ): ClickSelectionResult | null {
-  if (!event.target) {
-    return null
-  }
-
-  const viewportText = event.target
-  if (!isPositionedNode(viewportText)) {
-    return null
-  }
+  const anchor = getViewportAnchor(event)
+  if (!anchor) return null
 
-  const col = event.x - viewportText.x
-  const row = event.y - viewportText.y
-  const baseX = viewportText.x
+  const mode: MultiClickMode = clickCount === 2 ? 'word' : 'line'
 
   logInputDebug('click.detect', {
     clickCount,
-    col,
+    col: anchor.col,
     eventX: event.x,
     eventY: event.y,
-    row,
-    targetId: event.target.id,
-    viewportX: viewportText.x,
-    viewportY: viewportText.y,
+    row: anchor.row,
+    targetId: anchor.target.id,
+    viewportX: anchor.baseX,
+    viewportY: anchor.baseY,
   })
 
-  if (!tab?.viewport?.lines[row]) {
+  if (!tab?.viewport?.lines[anchor.row]) {
     logInputDebug('click.noViewportLine', {
       hasViewport: !!tab?.viewport,
       lineCount: tab?.viewport?.lines.length ?? 0,
-      row,
+      row: anchor.row,
       tabFound: !!tab,
       targetTabId,
     })
     return null
   }
 
-  const line = tab.viewport.lines[row]
-  const lineText = getLineText(line)
-
-  let selectedText: string
-  let startCol: number
-  let endCol: number
-
-  if (clickCount === 2) {
-    const word = getWordAtColumn(lineText, col)
-    if (word.text.length === 0) {
+  const range = computeMultiClickRange(tab, anchor.row, anchor.col, mode)
+  if (!range) {
+    if (mode === 'word') {
+      const line = tab.viewport.lines[anchor.row]
+      const lineText = line ? getLineText(line) : ''
       logInputDebug('click.emptyWord', {
-        charAtCol: lineText[col] ?? 'OOB',
-        col,
+        charAtCol: lineText[anchor.col] ?? 'OOB',
+        col: anchor.col,
         lineText,
-        row,
+        row: anchor.row,
       })
-      return null
     }
-
-    selectedText = word.text
-    startCol = word.startCol
-    endCol = word.endCol
-  } else {
-    selectedText = lineText
-    startCol = 0
-    endCol = lineText.length
+    return null
   }
 
+  const line = tab.viewport.lines[anchor.row]
+  const lineText = line ? getLineText(line) : ''
+  const selectedText = lineText.slice(range.startCol, range.endCol)
+
   logInputDebug('click.selection', {
-    baseX,
+    baseX: anchor.baseX,
     clickCount,
-    endCol,
-    endX: baseX + endCol,
+    endCol: range.endCol,
+    endX: anchor.baseX + range.endCol,
     lineText,
+    mode,
     selectedText,
-    spanCount: line.spans.length,
-    spanStyles: line.spans.map((span) => ({
-      bold: span.bold,
-      italic: span.italic,
-      underline: span.underline,
-    })),
-    spanTexts: line.spans.map((span) => span.text),
-    startCol,
-    startX: baseX + startCol,
+    startCol: range.startCol,
+    startX: anchor.baseX + range.startCol,
     y: event.y,
   })
 
   return {
-    baseX,
-    endCol,
+    baseX: anchor.baseX,
+    endCol: range.endCol,
     eventY: event.y,
+    mode,
+    row: anchor.row,
     selectedText,
-    startCol,
-    target: event.target,
+    startCol: range.startCol,
+    target: anchor.target,
   }
 }

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

@@ -1,18 +1,22 @@
 import type { MouseEvent as OtuiMouseEvent } from '@opentui/core'
 
-import { useRef } from 'react'
+import { useEffect, useRef } from 'react'
 
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { SessionBackend } from '../session-backend/types'
 import type { SplitDirection } from '../state/layout-tree'
-import type { AppAction, AppState, TabSession } from '../state/types'
+import type { AppAction, AppState, TabSession, TerminalLine } from '../state/types'
 
 import { logInputDebug } from '../debug/input-log'
 import { MultiClickDetector } from '../input/multi-click-detector'
+import { extractStreamText, getLineText } from '../input/terminal-text-extraction'
 import { copyToSystemClipboard } from '../platform/clipboard'
 import {
   type ClickSelectionResult,
+  computeRangeFromLineText,
+  getViewportAnchor,
   isPositionedNode,
+  type MultiClickMode,
   resolveClickSelection,
 } from './click-selection-resolver'
 import { requestRenderUpTree } from './render-invalidation'
@@ -32,6 +36,31 @@ type ResizeDragState =
   | ({ initialWidth: number; kind: 'git-pane'; side: 'left' | 'right' } & AxisDragState)
   | ({ kind: 'embedded-git'; position: 'top' | 'bottom' } & AnchoredRatioDragState)
 
+interface MultiClickDragState {
+  mode: MultiClickMode
+  tabId: string
+  target: unknown
+  baseX: number
+  baseY: number
+  // Absolute buffer rows (viewportY + viewportRow). Stable across scroll so
+  // auto-scroll can move the viewport without losing the anchor.
+  anchorAbsRow: number
+  anchorStartCol: number
+  anchorEndCol: number
+  focusAbsRow: number
+  focusCol: number
+  // Last raw screen position so the viewport-change effect can re-extend the
+  // selection even when no drag event has fired (mouse held still at the edge).
+  lastEventScreenY: number
+  lastEventScreenX: number
+  // Cache of every viewport row seen during the drag, indexed by absolute row.
+  // Source of truth for clipboard text when the selection spans rows that have
+  // scrolled out of view.
+  capturedLines: Map<number, TerminalLine>
+  autoScrollTimer: ReturnType<typeof setInterval> | null
+  autoScrollDir: -1 | 0 | 1
+}
+
 interface UseMouseHandlersOptions {
   state: AppState
   dispatch: (action: AppAction) => void
@@ -47,6 +76,7 @@ interface UseMouseHandlersOptions {
 }
 
 const MIN_MULTI_CLICK_SELECTION_COUNT = 2
+const AUTO_SCROLL_INTERVAL_MS = 40
 
 function getTargetTerminalTabId(
   focusMode: AppState['focusMode'],
@@ -60,14 +90,49 @@ function getTargetTerminalTabId(
   return activeTabId
 }
 
-function applyResolvedSelection(
+function captureViewportLines(drag: MultiClickDragState, tab: TabSession): void {
+  if (!tab.viewport) return
+  const startAbs = tab.viewport.viewportY
+  for (let i = 0; i < tab.viewport.lines.length; i++) {
+    const line = tab.viewport.lines[i]
+    if (line) drag.capturedLines.set(startAbs + i, line)
+  }
+}
+
+function isForwardSelection(drag: MultiClickDragState): boolean {
+  return (
+    drag.focusAbsRow > drag.anchorAbsRow ||
+    (drag.focusAbsRow === drag.anchorAbsRow && drag.focusCol >= drag.anchorEndCol)
+  )
+}
+
+function renderMultiClickSelection(
+  renderer: UseMouseHandlersOptions['renderer'],
+  drag: MultiClickDragState,
+  viewportY: number,
+  finishDragging: boolean
+): void {
+  const forward = isForwardSelection(drag)
+  const anchorCol = forward ? drag.anchorStartCol : drag.anchorEndCol
+  const anchorScreenY = drag.baseY + (drag.anchorAbsRow - viewportY)
+  const focusScreenY = drag.baseY + (drag.focusAbsRow - viewportY)
+  renderer.startSelection(drag.target, drag.baseX + anchorCol, anchorScreenY)
+  renderer.updateSelection(drag.target, drag.baseX + drag.focusCol, focusScreenY, {
+    finishDragging,
+  })
+  requestRenderUpTree(drag.target)
+}
+
+function applyMultiClickInitialSelection(
   renderer: UseMouseHandlersOptions['renderer'],
   selection: ClickSelectionResult
 ): void {
   renderer.clearSelection()
   renderer.startSelection(selection.target, selection.baseX + selection.startCol, selection.eventY)
+  // finishDragging:false keeps the renderer in drag mode so subsequent
+  // mouse-drag events can extend the selection through our drag handler.
   renderer.updateSelection(selection.target, selection.baseX + selection.endCol, selection.eventY, {
-    finishDragging: true,
+    finishDragging: false,
   })
   requestRenderUpTree(selection.target)
   copyToSystemClipboard(selection.selectedText)
@@ -83,6 +148,98 @@ export function useMouseHandlers({
 }: UseMouseHandlersOptions) {
   const separatorDragRef = useRef<ResizeDragState | null>(null)
   const multiClickRef = useRef(new MultiClickDetector())
+  const multiClickDragRef = useRef<MultiClickDragState | null>(null)
+  // State is captured by reference in the React closure; we need a ref so
+  // drag/up handlers and the auto-scroll timer see the freshest tab viewport.
+  const stateRef = useRef(state)
+  stateRef.current = state
+
+  const clearAutoScroll = (drag: MultiClickDragState) => {
+    if (drag.autoScrollTimer) {
+      clearInterval(drag.autoScrollTimer)
+    }
+    drag.autoScrollTimer = null
+    drag.autoScrollDir = 0
+  }
+
+  const canScroll = (tab: TabSession | undefined, dir: -1 | 1): boolean => {
+    if (!tab?.viewport) return false
+    if (dir < 0) return tab.viewport.viewportY > 0
+    return tab.viewport.viewportY < tab.viewport.baseY
+  }
+
+  const startAutoScroll = (drag: MultiClickDragState, dir: -1 | 1) => {
+    if (drag.autoScrollDir === dir && drag.autoScrollTimer) return
+    clearAutoScroll(drag)
+    drag.autoScrollDir = dir
+    drag.autoScrollTimer = setInterval(() => {
+      const tab = stateRef.current.tabs.find((t: TabSession) => t.id === drag.tabId)
+      if (!canScroll(tab, dir)) {
+        clearAutoScroll(drag)
+        return
+      }
+      backend.scrollViewport(drag.tabId, dir)
+      // The snapshot dispatch will trigger the viewport-change effect below,
+      // which recaptures lines and re-extends the selection focus.
+    }, AUTO_SCROLL_INTERVAL_MS)
+  }
+
+  // Unmount safety: never leave a setInterval running past the hook's life.
+  useEffect(
+    () => () => {
+      const drag = multiClickDragRef.current
+      if (drag) clearAutoScroll(drag)
+      multiClickDragRef.current = null
+    },
+    []
+  )
+
+  // Abort the drag (and its auto-scroll loop) when the user switches to a
+  // different tab mid-drag: the original tab is no longer visible and we'd
+  // otherwise keep pumping scroll commands into a background buffer.
+  useEffect(() => {
+    const drag = multiClickDragRef.current
+    if (!drag) return
+    if (drag.tabId !== state.activeTabId) {
+      clearAutoScroll(drag)
+      multiClickDragRef.current = null
+    }
+  }, [state.activeTabId])
+
+  // Re-extend selection and recapture viewport lines on every snapshot change
+  // while a multi-click drag is in progress. This is what lets auto-scroll
+  // grow the selection even when the mouse hasn't moved.
+  useEffect(() => {
+    const drag = multiClickDragRef.current
+    if (!drag) return
+    const tab = stateRef.current.tabs.find((t: TabSession) => t.id === drag.tabId)
+    if (!tab?.viewport) return
+
+    captureViewportLines(drag, tab)
+
+    const viewportRows = tab.viewport.lines.length
+    if (viewportRows === 0) return
+
+    const dragViewportRow = Math.max(
+      0,
+      Math.min(viewportRows - 1, drag.lastEventScreenY - drag.baseY)
+    )
+    const newFocusAbs = tab.viewport.viewportY + dragViewportRow
+    const focusLine = drag.capturedLines.get(newFocusAbs)
+    const focusLineText = focusLine ? getLineText(focusLine) : ''
+    const focusDragCol = drag.lastEventScreenX - drag.baseX
+    const range = computeRangeFromLineText(focusLineText, focusDragCol, drag.mode)
+    const focusStart = range?.startCol ?? Math.max(0, focusDragCol)
+    const focusEnd = range?.endCol ?? Math.max(0, focusDragCol)
+
+    drag.focusAbsRow = newFocusAbs
+    const forward =
+      newFocusAbs > drag.anchorAbsRow ||
+      (newFocusAbs === drag.anchorAbsRow && focusEnd >= drag.anchorEndCol)
+    drag.focusCol = forward ? focusEnd : focusStart
+
+    renderMultiClickSelection(renderer, drag, tab.viewport.viewportY, false)
+  }, [state.tabs, renderer])
 
   const handleTerminalMouseEvent = (event: OtuiMouseEvent, origin: TerminalContentOrigin) => {
     const targetTabId = getTargetTerminalTabId(
@@ -237,24 +394,158 @@ export function useMouseHandlers({
 
     const clickCount = multiClickRef.current.track(event.x, event.y)
     if (clickCount < MIN_MULTI_CLICK_SELECTION_COUNT) {
+      // Single-click: clear any stale multi-click drag state so a fresh
+      // char-level drag from opentui's default handler isn't extended by us.
+      const stale = multiClickDragRef.current
+      if (stale) clearAutoScroll(stale)
+      multiClickDragRef.current = null
       return
     }
 
     const tab = state.tabs.find((t: TabSession) => t.id === targetTabId)
     const selection = resolveClickSelection(event, targetTabId, tab, clickCount)
-    if (!selection) {
+    if (!selection || !tab?.viewport) {
       return
     }
 
     event.preventDefault()
-    applyResolvedSelection(renderer, selection)
+    applyMultiClickInitialSelection(renderer, selection)
+
+    const anchor = getViewportAnchor(event)
+    if (anchor) {
+      const anchorAbsRow = tab.viewport.viewportY + selection.row
+      const drag: MultiClickDragState = {
+        anchorAbsRow,
+        anchorEndCol: selection.endCol,
+        anchorStartCol: selection.startCol,
+        autoScrollDir: 0,
+        autoScrollTimer: null,
+        baseX: anchor.baseX,
+        baseY: anchor.baseY,
+        capturedLines: new Map(),
+        focusAbsRow: anchorAbsRow,
+        focusCol: selection.endCol,
+        lastEventScreenX: event.x,
+        lastEventScreenY: event.y,
+        mode: selection.mode,
+        tabId: targetTabId,
+        target: selection.target,
+      }
+      captureViewportLines(drag, tab)
+      multiClickDragRef.current = drag
+    }
 
     logInputDebug('click.done', {
       hasSelection: !!renderer.hasSelection,
+      mode: selection.mode,
       targetSelectable: isPositionedNode(event.target) ? !!event.target.selectable : false,
     })
   }
 
+  const handleTerminalDrag = (
+    event: OtuiMouseEvent,
+    _origin: TerminalContentOrigin,
+    _tabId?: string
+  ): boolean => {
+    const drag = multiClickDragRef.current
+    if (!drag) return false
+
+    const tab = stateRef.current.tabs.find((t: TabSession) => t.id === drag.tabId)
+    if (!tab?.viewport) return true
+
+    drag.lastEventScreenX = event.x
+    drag.lastEventScreenY = event.y
+    captureViewportLines(drag, tab)
+
+    const viewportRows = tab.viewport.lines.length
+    if (viewportRows === 0) return true
+
+    const rawRow = event.y - drag.baseY
+    const dragViewportRow = Math.max(0, Math.min(viewportRows - 1, rawRow))
+    const dragAbsRow = tab.viewport.viewportY + dragViewportRow
+    const dragCol = event.x - drag.baseX
+
+    const focusLine = drag.capturedLines.get(dragAbsRow)
+    const focusLineText = focusLine ? getLineText(focusLine) : ''
+    const range = computeRangeFromLineText(focusLineText, dragCol, drag.mode)
+    const focusStart = range?.startCol ?? Math.max(0, dragCol)
+    const focusEnd = range?.endCol ?? Math.max(0, dragCol)
+
+    drag.focusAbsRow = dragAbsRow
+    const forward =
+      dragAbsRow > drag.anchorAbsRow ||
+      (dragAbsRow === drag.anchorAbsRow && focusEnd >= drag.anchorEndCol)
+    drag.focusCol = forward ? focusEnd : focusStart
+
+    renderMultiClickSelection(renderer, drag, tab.viewport.viewportY, false)
+
+    // Edge detection: trigger auto-scroll when the pointer sits at (or beyond)
+    // the top/bottom row of the viewport.
+    let dir: -1 | 0 | 1 = 0
+    if (rawRow <= 0) dir = -1
+    else if (rawRow >= viewportRows - 1) dir = 1
+
+    if (dir === 0) {
+      clearAutoScroll(drag)
+    } else if (canScroll(tab, dir)) {
+      startAutoScroll(drag, dir)
+    } else {
+      clearAutoScroll(drag)
+    }
+
+    return true
+  }
+
+  const handleTerminalMouseUp = (_event: OtuiMouseEvent): boolean => {
+    const drag = multiClickDragRef.current
+    if (!drag) return false
+
+    clearAutoScroll(drag)
+
+    const tab = stateRef.current.tabs.find((t: TabSession) => t.id === drag.tabId)
+    if (tab?.viewport) {
+      captureViewportLines(drag, tab)
+      renderMultiClickSelection(renderer, drag, tab.viewport.viewportY, true)
+    }
+
+    const forward = isForwardSelection(drag)
+    const anchorCol = forward ? drag.anchorStartCol : drag.anchorEndCol
+
+    const startAbs = Math.min(drag.anchorAbsRow, drag.focusAbsRow)
+    const endAbs = Math.max(drag.anchorAbsRow, drag.focusAbsRow)
+    const lines: TerminalLine[] = []
+    let missingRows = 0
+    for (let abs = startAbs; abs <= endAbs; abs++) {
+      const line = drag.capturedLines.get(abs)
+      if (line) {
+        lines.push(line)
+      } else {
+        missingRows += 1
+        lines.push({ spans: [] })
+      }
+    }
+    if (missingRows > 0) {
+      // Snapshot coalescing (remote backend, fast scroll bursts) can let the
+      // selection cover rows we never captured. The output gets blank lines
+      // here — surface it for debugging instead of silently corrupting paste.
+      logInputDebug('multiclick.clipboardGap', {
+        endAbs,
+        missingRows,
+        startAbs,
+        totalRows: endAbs - startAbs + 1,
+      })
+    }
+    const anchorIdx = drag.anchorAbsRow - startAbs
+    const focusIdx = drag.focusAbsRow - startAbs
+    const text = extractStreamText(lines, anchorIdx, anchorCol, focusIdx, drag.focusCol)
+    if (text.length > 0) {
+      copyToSystemClipboard(text)
+    }
+
+    multiClickDragRef.current = null
+    return true
+  }
+
   return {
     handleEmbeddedGitResizeStart,
     handleGitPaneResizeStart,
@@ -265,7 +556,9 @@ export function useMouseHandlers({
     handleSidebarResizeStart,
     handleSplitResize,
     handleTerminalClick,
+    handleTerminalDrag,
     handleTerminalMouseEvent,
+    handleTerminalMouseUp,
     handleTerminalScrollEvent,
   }
 }

package/src/app.tsx

@@ -32,7 +32,7 @@ import { startAIUsageService } from './services/ai-usage/provider'
 import { aiUsageStore } from './state/ai-usage-store'
 import { appStore, useAppStore } from './state/app-store'
 import { setActiveDispatch, setActiveSideEffectRunner } from './state/dispatch-ref'
-import { loadSessionCatalog } from './state/session-catalog'
+import { findMostRecentSession, loadSessionCatalog } from './state/session-catalog'
 import { loadSnippetCatalog } from './state/snippet-catalog'
 import { createInitialState } from './state/store'
 import { KeymapContext } from './ui/keymap-context'
@@ -134,11 +134,12 @@ export function App({
       ...(userGitPane?.diffCount !== undefined ? { diffCount: userGitPane.diffCount } : {}),
     }
 
+    const sessionCatalog = loadSessionCatalog()
     const initial = createInitialState(
       json.customCommands,
-      loadSessionCatalog(),
+      sessionCatalog,
       loadSnippetCatalog(),
-      true,
+      sessionCatalog.length === 0,
       {
         gitPane: gitPaneOverrides,
         sessionBarPosition,
@@ -149,6 +150,14 @@ export function App({
     // Replace the module-level default with the fully-resolved initial state.
     // Preserves the dispatch baked into the store by app-store.ts.
     appStore.setState(initial)
+    const mostRecent = findMostRecentSession(sessionCatalog)
+    if (mostRecent) {
+      appStore.getState().dispatch({
+        sessionId: mostRecent.id,
+        type: 'load-session',
+        workspaceSnapshot: mostRecent.workspaceSnapshot,
+      })
+    }
     return null
   })
 
@@ -323,7 +332,9 @@ export function App({
     handleSidebarResizeStart,
     handleSplitResize,
     handleTerminalClick,
+    handleTerminalDrag,
     handleTerminalMouseEvent,
+    handleTerminalMouseUp,
     handleTerminalScrollEvent,
   } = useMouseHandlers({
     activeLocalScrollbackEnabled,
@@ -455,6 +466,8 @@ export function App({
         onTerminalMouseEvent={handleTerminalMouseEvent}
         onTerminalScrollEvent={handleTerminalScrollEvent}
         onTerminalClick={handleTerminalClick}
+        onTerminalDrag={handleTerminalDrag}
+        onTerminalMouseUp={handleTerminalMouseUp}
         onPaneActivate={handlePaneActivate}
         onSplitResize={handleSplitResize}
         onEmbeddedGitResizeStart={handleEmbeddedGitResizeStart}

package/src/state/session-catalog.ts

@@ -96,6 +96,16 @@ export function getSessionCatalogPath(): string {
   return SESSIONS_PATH
 }
 
+export function findMostRecentSession(sessions: SessionRecord[]): SessionRecord | undefined {
+  let best: SessionRecord | undefined
+  for (const candidate of sessions) {
+    if (!best || candidate.lastOpenedAt.localeCompare(best.lastOpenedAt) > 0) {
+      best = candidate
+    }
+  }
+  return best
+}
+
 /**
  * Assign a stable `order` to every session. Records with an existing numeric
  * `order` keep their slot (sorted ascending); the rest are appended by

package/src/ui/components/layout/split-layout.tsx

@@ -26,6 +26,8 @@ interface SplitLayoutProps {
   onTerminalMouseEvent: (event: OtuiMouseEvent, origin: TerminalContentOrigin) => void
   onTerminalScrollEvent: (event: OtuiMouseEvent) => void
   onTerminalClick?: (event: OtuiMouseEvent, origin: TerminalContentOrigin, tabId?: string) => void
+  onTerminalDrag?: (event: OtuiMouseEvent, origin: TerminalContentOrigin, tabId?: string) => boolean
+  onTerminalMouseUp?: (event: OtuiMouseEvent) => boolean
   onPaneActivate?: (tabId: string) => void
   onSplitResize?: (tabId: string, ratio: number, axis: SplitDirection) => void
   onSeparatorDragStart?: (info: {
@@ -54,7 +56,9 @@ export function SplitLayout({
   onSeparatorDragStart,
   onSplitResize,
   onTerminalClick,
+  onTerminalDrag,
   onTerminalMouseEvent,
+  onTerminalMouseUp,
   onTerminalScrollEvent,
   tabs,
 }: SplitLayoutProps) {
@@ -92,6 +96,8 @@ export function SplitLayout({
         onTerminalMouseEvent={onTerminalMouseEvent}
         onTerminalScrollEvent={onTerminalScrollEvent}
         onTerminalClick={onTerminalClick}
+        onTerminalDrag={onTerminalDrag}
+        onTerminalMouseUp={onTerminalMouseUp}
         onPaneActivate={onPaneActivate}
         onSeparatorDrag={onSeparatorDrag}
         onSeparatorDragEnd={onSeparatorDragEnd}
@@ -123,6 +129,8 @@ export function SplitLayout({
           onTerminalMouseEvent={onTerminalMouseEvent}
           onTerminalScrollEvent={onTerminalScrollEvent}
           onTerminalClick={onTerminalClick}
+          onTerminalDrag={onTerminalDrag}
+          onTerminalMouseUp={onTerminalMouseUp}
           onPaneActivate={onPaneActivate}
           onSplitResize={onSplitResize}
           onSeparatorDragStart={onSeparatorDragStart}
@@ -163,6 +171,8 @@ export function SplitLayout({
           onTerminalMouseEvent={onTerminalMouseEvent}
           onTerminalScrollEvent={onTerminalScrollEvent}
           onTerminalClick={onTerminalClick}
+          onTerminalDrag={onTerminalDrag}
+          onTerminalMouseUp={onTerminalMouseUp}
           onPaneActivate={onPaneActivate}
           onSplitResize={onSplitResize}
           onSeparatorDragStart={onSeparatorDragStart}

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

@@ -22,6 +22,8 @@ interface TerminalPaneProps {
   onTerminalMouseEvent: (event: OtuiMouseEvent, origin: TerminalContentOrigin) => void
   onTerminalScrollEvent: (event: OtuiMouseEvent) => void
   onTerminalClick?: (event: OtuiMouseEvent, origin: TerminalContentOrigin, tabId?: string) => void
+  onTerminalDrag?: (event: OtuiMouseEvent, origin: TerminalContentOrigin, tabId?: string) => boolean
+  onTerminalMouseUp?: (event: OtuiMouseEvent) => boolean
   onPaneActivate?: (tabId: string) => void
   onSeparatorDrag?: (event: OtuiMouseEvent) => boolean
   onSeparatorDragEnd?: () => void
@@ -112,7 +114,9 @@ export function TerminalPane({
   onSeparatorDrag,
   onSeparatorDragEnd,
   onTerminalClick,
+  onTerminalDrag,
   onTerminalMouseEvent,
+  onTerminalMouseUp,
   onTerminalScrollEvent,
   tab,
   tabId,
@@ -169,11 +173,20 @@ export function TerminalPane({
         y: event.y,
       })
     }
-    if (event.type === 'drag' && onSeparatorDrag?.(event)) {
-      event.preventDefault()
-      return
+    if (event.type === 'drag') {
+      if (onTerminalDrag?.(event, contentOrigin, tabId)) {
+        event.preventDefault()
+        return
+      }
+      if (onSeparatorDrag?.(event)) {
+        event.preventDefault()
+        return
+      }
     }
     if (event.type === 'up') {
+      if (onTerminalMouseUp?.(event)) {
+        event.preventDefault()
+      }
       onSeparatorDragEnd?.()
     }
     if (tabId && onPaneActivate && event.type === 'down') {

package/src/ui/root.tsx

@@ -206,6 +206,8 @@ interface RootViewProps {
   onTerminalMouseEvent: (event: MouseEvent, origin: TerminalContentOrigin) => void
   onTerminalScrollEvent: (event: MouseEvent) => void
   onTerminalClick?: (event: MouseEvent, origin: TerminalContentOrigin, tabId?: string) => void
+  onTerminalDrag?: (event: MouseEvent, origin: TerminalContentOrigin, tabId?: string) => boolean
+  onTerminalMouseUp?: (event: MouseEvent) => boolean
   onPaneActivate?: (tabId: string) => void
   onSplitResize?: (tabId: string, ratio: number, axis: SplitDirection) => void
   onSidebarResizeStart?: (info: { initialWidth: number; screenStart: number }) => void
@@ -244,7 +246,9 @@ export function RootView({
   onSidebarResizeStart,
   onSplitResize,
   onTerminalClick,
+  onTerminalDrag,
   onTerminalMouseEvent,
+  onTerminalMouseUp,
   onTerminalScrollEvent,
   terminalCols,
   terminalRows,
@@ -312,7 +316,11 @@ export function RootView({
           event.stopPropagation()
         }
       }}
-      onMouseUp={() => {
+      onMouseUp={(event) => {
+        // Catch releases that land outside any TerminalPane (sidebar, gap,
+        // status bar, …) so an in-flight multi-click drag — and its
+        // auto-scroll interval — is always finalised.
+        onTerminalMouseUp?.(event)
         onSeparatorDragEnd?.()
       }}
     >
@@ -349,6 +357,8 @@ export function RootView({
             onTerminalMouseEvent={onTerminalMouseEvent}
             onTerminalScrollEvent={onTerminalScrollEvent}
             onTerminalClick={onTerminalClick}
+            onTerminalDrag={onTerminalDrag}
+            onTerminalMouseUp={onTerminalMouseUp}
             onPaneActivate={onPaneActivate}
             onSplitResize={onSplitResize}
             onSeparatorDragStart={onSeparatorDragStart}
@@ -373,6 +383,8 @@ export function RootView({
             onTerminalMouseEvent={onTerminalMouseEvent}
             onTerminalScrollEvent={onTerminalScrollEvent}
             onTerminalClick={onTerminalClick}
+            onTerminalDrag={onTerminalDrag}
+            onTerminalMouseUp={onTerminalMouseUp}
             onPaneActivate={onPaneActivate}
           />
         )}