@brimveyn/aimux 1.12.0 → 1.12.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.12.0",
+  "version": "1.12.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",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.5.12",
+    "@brimveyn/aimux-config": "0.5.13",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

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

@@ -0,0 +1,21 @@
+// 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.
+//
+// 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
+
+export function recordMultiClickClipboardWrite(): void {
+  lastMultiClickWriteAt = Date.now()
+}
+
+export function shouldSuppressSelectionCopy(): boolean {
+  return Date.now() - lastMultiClickWriteAt < SUPPRESS_WINDOW_MS
+}

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

@@ -19,6 +19,7 @@ import {
   type MultiClickMode,
   resolveClickSelection,
 } from './click-selection-resolver'
+import { recordMultiClickClipboardWrite } from './multi-click-clipboard-guard'
 import { requestRenderUpTree } from './render-invalidation'
 import {
   type AnchoredRatioDragState,
@@ -540,6 +541,7 @@ export function useMouseHandlers({
     const text = extractStreamText(lines, anchorIdx, anchorCol, focusIdx, drag.focusCol)
     if (text.length > 0) {
       copyToSystemClipboard(text)
+      recordMultiClickClipboardWrite()
     }
 
     multiClickDragRef.current = null

package/src/app-runtime/use-pane-size-report.ts

@@ -0,0 +1,95 @@
+import type { BoxRenderable } from '@opentui/core'
+
+import { useCallback, useEffect, useRef } from 'react'
+
+/** Geometry of the rendered terminal content box, in absolute screen cells. */
+export interface MeasuredPaneRect {
+  /** 0-based screen column of the first content cell */
+  x: number
+  /** 0-based screen row of the first content cell */
+  y: number
+  /** content width in cells == required PTY/xterm cols */
+  cols: number
+  /** content height in cells == required PTY/xterm rows */
+  rows: number
+}
+
+// opentui recomputes layout on its own render tick after React commits
+// (resetAfterCommit → requestRender). Re-reading the renderable two frames
+// later guarantees we observe the settled layout even when the terminal is
+// otherwise idle (a sidebar toggle on a static shell would not produce
+// another React commit on its own). overflow:hidden on the content box keeps
+// the box size independent of terminal content, so this loop provably
+// converges and cannot oscillate.
+const SETTLE_DELAY_MS = 32
+
+/**
+ * Closed measurement loop: observes the *actual* rendered terminal content
+ * box and reports its geometry whenever it changes. The reported size is the
+ * single source of truth for sizing the PTY + xterm emulator, replacing the
+ * open-loop "terminal height minus a hardcoded chrome model" estimate that
+ * drifted (status-bar wrap, disconnected/error line, split chrome) and left
+ * dead rows / shifted content.
+ *
+ * Returns a ref callback to attach to the content box renderable.
+ */
+export function usePaneSizeReport(
+  tabId: string | undefined,
+  enabled: boolean,
+  onMeasure: ((tabId: string, rect: MeasuredPaneRect) => void) | undefined
+): (node: BoxRenderable | null) => void {
+  const boxRef = useRef<BoxRenderable | null>(null)
+  const lastRef = useRef<MeasuredPaneRect | null>(null)
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+  const measure = useCallback(() => {
+    const box = boxRef.current
+    if (!box || !tabId || !enabled || !onMeasure) {
+      return
+    }
+    const cols = Math.round(box.width)
+    const rows = Math.round(box.height)
+    const x = Math.round(box.x)
+    const y = Math.round(box.y)
+    if (cols < 1 || rows < 1) {
+      return
+    }
+    const prev = lastRef.current
+    if (prev && prev.cols === cols && prev.rows === rows && prev.x === x && prev.y === y) {
+      return
+    }
+    const next: MeasuredPaneRect = { cols, rows, x, y }
+    lastRef.current = next
+    onMeasure(tabId, next)
+  }, [enabled, onMeasure, tabId])
+
+  // Runs after every commit: measure now (covers the steady-state case where
+  // layout was already settled on a prior frame) and once more after
+  // opentui's render/layout tick.
+  useEffect(() => {
+    measure()
+    if (timerRef.current) {
+      clearTimeout(timerRef.current)
+    }
+    timerRef.current = setTimeout(() => {
+      timerRef.current = null
+      measure()
+    }, SETTLE_DELAY_MS)
+    return () => {
+      if (timerRef.current) {
+        clearTimeout(timerRef.current)
+        timerRef.current = null
+      }
+    }
+  })
+
+  return useCallback(
+    (node: BoxRenderable | null) => {
+      boxRef.current = node
+      if (node) {
+        measure()
+      }
+    },
+    [measure]
+  )
+}

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

@@ -8,6 +8,7 @@ import type { AppAction, FocusMode, TabSession } from '../state/types'
 import { INPUT_DEBUG_LOG_PATH, logInputDebug } from '../debug/input-log'
 import { createRawInputHandler } from '../input/raw-input-handler'
 import { copyToSystemClipboard } from '../platform/clipboard'
+import { shouldSuppressSelectionCopy } from './multi-click-clipboard-guard'
 import { writePasteToTab, writeToTab } from './pty-write'
 import { type OtuiSelection, resolveSelectionClipboardText } from './selection-clipboard'
 import { applyViewportObservation, type ViewportObservation } from './selection-scroll'
@@ -118,6 +119,16 @@ export function useRendererBindings({
         return
       }
 
+      // After a multi-click drag, handleTerminalMouseUp has just copied the
+      // authoritative text built from drag.capturedLines (anchored at click
+      // time). opentui's finishSelection() then re-fires this 'selection'
+      // event, but the recomputed text can drift by a few rows when output
+      // landed between mouseDown and mouseUp. Skip the redundant write.
+      if (shouldSuppressSelectionCopy()) {
+        logInputDebug('app.selection.suppressed', { textLength: selectedText.length })
+        return
+      }
+
       renderer.copyToClipboardOSC52(selectedText)
       copyToSystemClipboard(selectedText)
     }

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

@@ -1,9 +1,17 @@
 import { flushSync } from '@opentui/react'
-import { type MutableRefObject, useEffect, useLayoutEffect, useMemo, useRef } from 'react'
+import {
+  type MutableRefObject,
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+} from 'react'
 
 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 { MeasuredPaneRect } from './use-pane-size-report'
 
 import { getGitPaneWidthFromRatio } from '../state/git-pane-sizing'
 import {
@@ -20,6 +28,12 @@ const MIN_TERMINAL_ROWS = 1
 const MIN_TERMINAL_COLS = 20
 const RESIZE_ACTIVITY_SETTLE_MS = 500
 
+// Must match the clamps PtyManager applies in resizeSession/resizeAll, so the
+// size we record as "applied" is the size the PTY/xterm actually adopt — a
+// mismatch here would make the dedupe never settle and resize every frame.
+const PTY_MIN_COLS = 20
+const PTY_MIN_ROWS = 8
+
 function getTerminalBounds(cols: number, rows: number) {
   return createTerminalBounds(cols, rows)
 }
@@ -138,6 +152,35 @@ export function useTerminalResize({
       .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
+  // loop so an unchanged box never re-triggers a resize.
+  const measuredRef = useRef(new Map<string, { cols: number; rows: number }>())
+
+  // Closed measurement loop: the rendered terminal content box reports its
+  // real geometry; that — not the hardcoded chrome model below — is the
+  // authority for the PTY/xterm size and the mouse-mapping origin. The model
+  // cascade still runs for bootstrap and for tabs whose pane isn't mounted yet;
+  // this corrects any residual divergence (status-bar wrap, split rounding, …).
+  const handleMeasure = useCallback(
+    (tabId: string, rect: MeasuredPaneRect): void => {
+      const cols = Math.max(PTY_MIN_COLS, rect.cols)
+      const rows = Math.max(PTY_MIN_ROWS, rect.rows)
+      const isActive = tabId === activeTabIdRef.current
+      if (isActive) {
+        contentOriginRef.current = { cols, rows, x: rect.x, y: rect.y }
+      }
+      const prev = measuredRef.current.get(tabId)
+      if (prev && prev.cols === cols && prev.rows === rows) {
+        return
+      }
+      measuredRef.current.set(tabId, { cols, rows })
+      backend.resizeTab(tabId, cols, rows, intentsRef.current.get(tabId))
+    },
+    [backend, contentOriginRef]
+  )
+
   const gitPaneInPaneMode = state.gitPane.mode === 'pane' && state.gitPane.visible
   const terminalSize = useMemo(() => {
     const sidebarWidth = state.sidebar.visible ? state.sidebar.width : 0
@@ -234,5 +277,5 @@ export function useTerminalResize({
     stableTabIds,
   ])
 
-  return terminalSize
+  return { cols: terminalSize.cols, onMeasure: handleMeasure, rows: terminalSize.rows }
 }

package/src/app.tsx

@@ -478,6 +478,7 @@ export function App({
         onSeparatorDrag={handleSeparatorDrag}
         onSeparatorDragEnd={handleSeparatorDragEnd}
         onSidebarResizeStart={handleSidebarResizeStart}
+        onMeasure={terminalSize.onMeasure}
         terminalCols={terminalSize.cols}
         terminalRows={terminalSize.rows}
       />

package/src/pty/pty-manager.ts

@@ -24,6 +24,12 @@ interface SessionHandle {
   pendingModeSequence: string
   pendingWrites: number
   pendingExitCode: number | null
+  /** Scroll intent from the most recent resize, re-applied after the
+   *  parser drains the data that was queued across the resize. */
+  lastScrollIntent: ScrollIntent | undefined
+  /** Set when a resize landed while writes were in flight; the viewport is
+   *  re-anchored once pendingWrites reaches 0. */
+  reanchorAfterDrain: boolean
 }
 
 const ESC = '\x1b'
@@ -255,12 +261,14 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
         alternateScrollMode: false,
         cursorVisible: true,
         emulator,
+        lastScrollIntent: undefined,
         lastSnapshot: undefined,
         lastTerminalModes: undefined,
         pendingExitCode: null,
         pendingModeSequence: '',
         pendingWrites: 0,
         pty,
+        reanchorAfterDrain: false,
         tabId: options.tabId,
       }
 
@@ -283,6 +291,15 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
         this.scheduleDataRender(session)
         emulator.write(data, () => {
           session.pendingWrites -= 1
+
+          if (session.pendingWrites === 0 && session.reanchorAfterDrain) {
+            // The data queued across a resize has now been parsed into the
+            // reflowed buffer. Re-anchor the viewport before it is snapshotted
+            // so the active screen — not stale scrollback — is what renders.
+            session.reanchorAfterDrain = false
+            this.applyScrollIntent(session, session.lastScrollIntent)
+          }
+
           this.scheduleDataRender(session)
 
           if (session.pendingWrites === 0 && session.pendingExitCode !== null) {
@@ -357,24 +374,46 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     session.emulator.scrollToLine(Math.max(0, intent.absoluteLine))
   }
 
-  resizeAll(
+  private applyResize(
+    session: SessionHandle,
     cols: number,
     rows: number,
-    intents?: Map<string, ScrollIntent>,
-    options?: { sync?: boolean }
+    intent: ScrollIntent | undefined,
+    sync: boolean
   ): void {
     const safeCols = Math.max(20, cols)
     const safeRows = Math.max(8, rows)
+    session.pty.resize(safeCols, safeRows)
+    session.emulator.resize(safeCols, safeRows)
+    session.lastScrollIntent = intent
+    this.applyScrollIntent(session, intent)
+
+    if (session.pendingWrites > 0) {
+      // Output produced by the child for the pre-resize size is still queued
+      // in the xterm parser. Snapshotting now would capture a torn buffer
+      // (reflowed but not yet redrawn); a plain shell never issues a full
+      // repaint, so the shifted content + dead rows would stick. Defer the
+      // snapshot to the drain path, which re-anchors the viewport first.
+      session.reanchorAfterDrain = true
+      this.scheduleDataRender(session)
+      return
+    }
+
+    if (sync) {
+      this.flushRenderNow(session)
+    } else {
+      this.scheduleRender(session)
+    }
+  }
 
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void {
     for (const session of this.sessions.values()) {
-      session.pty.resize(safeCols, safeRows)
-      session.emulator.resize(safeCols, safeRows)
-      this.applyScrollIntent(session, intents?.get(session.tabId))
-      if (options?.sync) {
-        this.flushRenderNow(session)
-      } else {
-        this.scheduleRender(session)
-      }
+      this.applyResize(session, cols, rows, intents?.get(session.tabId), options?.sync ?? false)
     }
   }
 
@@ -389,16 +428,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     if (!session) {
       return
     }
-    const safeCols = Math.max(20, cols)
-    const safeRows = Math.max(8, rows)
-    session.pty.resize(safeCols, safeRows)
-    session.emulator.resize(safeCols, safeRows)
-    this.applyScrollIntent(session, intent)
-    if (options?.sync) {
-      this.flushRenderNow(session)
-    } else {
-      this.scheduleRender(session)
-    }
+    this.applyResize(session, cols, rows, intent, options?.sync ?? false)
   }
 
   reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {

package/src/pty/terminal-snapshot.ts

@@ -152,9 +152,16 @@ export function snapshotTerminal(terminal: Terminal, cursorVisible = true): Term
   const lines: TerminalLine[] = []
   const tailLines: TerminalLine[] = []
 
+  // The window starts at viewportY, but cursorY is relative to baseY. The
+  // cursor belongs on a rendered row only when its absolute buffer line
+  // (baseY + cursorY) equals that row's buffer line (startLine + row).
+  // Comparing row === cursorY was correct only while scrolled to the bottom
+  // (viewportY === baseY) and misplaced the cursor otherwise.
+  const cursorLine = buffer.baseY + cursorRow
   for (let row = 0; row < terminal.rows; row += 1) {
+    const lineIndex = startLine + row
     lines.push(
-      buildLine(terminal, startLine + row, row === cursorRow ? cursorColumn : null, cursorVisible)
+      buildLine(terminal, lineIndex, lineIndex === cursorLine ? cursorColumn : null, cursorVisible)
     )
   }
 

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

@@ -1,5 +1,6 @@
 import type { MouseEvent as OtuiMouseEvent } from '@opentui/core'
 
+import type { MeasuredPaneRect } from '../../../app-runtime/use-pane-size-report'
 import type { TerminalContentOrigin } from '../../../input/raw-input-handler'
 import type { FocusMode, TabSession } from '../../../state/types'
 
@@ -39,6 +40,7 @@ interface SplitLayoutProps {
   onSeparatorDrag?: (event: OtuiMouseEvent) => boolean
   onSeparatorDragEnd?: () => void
   onLeftEdgeMouseDown?: (event: OtuiMouseEvent) => boolean
+  onMeasure?: (tabId: string, rect: MeasuredPaneRect) => void
   contentOrigin: TerminalContentOrigin
   bounds: PaneRect
 }
@@ -52,6 +54,7 @@ export function SplitLayout({
   mouseForwardingEnabled,
   node,
   onLeftEdgeMouseDown,
+  onMeasure,
   onPaneActivate,
   onSeparatorDrag,
   onSeparatorDragEnd,
@@ -104,6 +107,7 @@ export function SplitLayout({
         onSeparatorDrag={onSeparatorDrag}
         onSeparatorDragEnd={onSeparatorDragEnd}
         onLeftEdgeMouseDown={onLeftEdgeMouseDown}
+        onMeasure={onMeasure}
       />
     )
   }
@@ -144,6 +148,7 @@ export function SplitLayout({
           onSeparatorDrag={onSeparatorDrag}
           onSeparatorDragEnd={onSeparatorDragEnd}
           onLeftEdgeMouseDown={onLeftEdgeMouseDown}
+          onMeasure={onMeasure}
           contentOrigin={contentOrigin}
           bounds={firstBounds}
         />
@@ -187,6 +192,7 @@ export function SplitLayout({
           onSeparatorDrag={onSeparatorDrag}
           onSeparatorDragEnd={onSeparatorDragEnd}
           onLeftEdgeMouseDown={secondLeftEdgeMouseDown}
+          onMeasure={onMeasure}
           contentOrigin={contentOrigin}
           bounds={secondBounds}
         />

package/src/ui/components/layout/status-bar.tsx

@@ -49,7 +49,9 @@ export function StatusBar() {
 
   return (
     <box
-      minHeight={2}
+      height={2}
+      flexShrink={0}
+      overflow="hidden"
       paddingLeft={1}
       paddingRight={1}
       paddingTop={0}

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

@@ -5,6 +5,7 @@ import { memo, type ReactNode } from 'react'
 import type { TerminalContentOrigin } from '../../../input/raw-input-handler'
 import type { TabSession, TerminalSnapshot, TerminalSpan } from '../../../state/types'
 
+import { type MeasuredPaneRect, usePaneSizeReport } from '../../../app-runtime/use-pane-size-report'
 import { logInputDebug } from '../../../debug/input-log'
 import { dispatchGlobal, runSideEffectGlobal } from '../../../state/dispatch-ref'
 import { type ContextMenuItem, openContextMenu } from '../../context-menu/controller'
@@ -28,6 +29,7 @@ interface TerminalPaneProps {
   onSeparatorDrag?: (event: OtuiMouseEvent) => boolean
   onSeparatorDragEnd?: () => void
   onLeftEdgeMouseDown?: (event: OtuiMouseEvent) => boolean
+  onMeasure?: (tabId: string, rect: MeasuredPaneRect) => void
 }
 
 function getTitle(
@@ -112,6 +114,7 @@ export function TerminalPane({
   localScrollbackEnabled,
   mouseForwardingEnabled,
   onLeftEdgeMouseDown,
+  onMeasure,
   onPaneActivate,
   onSeparatorDrag,
   onSeparatorDragEnd,
@@ -124,6 +127,7 @@ export function TerminalPane({
   tabId,
 }: TerminalPaneProps) {
   const t = useTheme()
+  const setContentBox = usePaneSizeReport(tabId, !!tab, onMeasure)
   const editorBg = t.background
   const paneIsActive = isActive ?? true
   const canForwardMouse = focusMode === 'terminal-input' && !!tab && mouseForwardingEnabled
@@ -287,9 +291,11 @@ export function TerminalPane({
           </box>
         ) : (
           <box
+            ref={setContentBox}
             flexDirection="column"
             flexGrow={1}
             width="100%"
+            overflow="hidden"
             onMouseDown={(e) => {
               e.stopPropagation()
               forwardMouseEvent(e)
@@ -302,10 +308,18 @@ export function TerminalPane({
           </box>
         )}
       </ContextMenuBox>
-      {tab?.status === 'disconnected' ? (
-        <text fg={t.warning}>Restored snapshot. Press Ctrl+r to restart this workspace.</text>
+      {tab?.status === 'disconnected' || tab?.errorMessage ? (
+        // Absolutely positioned so it overlays the bordered box instead of
+        // consuming a flex row. If it took a row, the rendered terminal area
+        // would be one line shorter than the size sent to the PTY/xterm,
+        // re-introducing the shifted-content / dead-row bug.
+        <box position="absolute" bottom={0} left={0} backgroundColor={editorBg}>
+          {tab?.status === 'disconnected' ? (
+            <text fg={t.warning}>Restored snapshot. Press Ctrl+r to restart this workspace.</text>
+          ) : null}
+          {tab?.errorMessage ? <text fg={t.error}>{tab.errorMessage}</text> : null}
+        </box>
       ) : null}
-      {tab?.errorMessage ? <text fg={t.error}>{tab.errorMessage}</text> : null}
     </box>
   )
 }

package/src/ui/root.tsx

@@ -1,5 +1,6 @@
 import type { MouseEvent } from '@opentui/core'
 
+import type { MeasuredPaneRect } from '../app-runtime/use-pane-size-report'
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { FocusMode, ModalState, SessionRecord, SnippetRecord } from '../state/types'
 import type { ThemeId } from './themes'
@@ -229,6 +230,7 @@ interface RootViewProps {
   }) => void
   onSeparatorDrag?: (event: MouseEvent) => boolean
   onSeparatorDragEnd?: () => void
+  onMeasure?: (tabId: string, rect: MeasuredPaneRect) => void
   terminalCols: number
   terminalRows: number
 }
@@ -239,6 +241,7 @@ export function RootView({
   mouseForwardingEnabled,
   onEmbeddedGitResizeStart,
   onGitPaneResizeStart,
+  onMeasure,
   onPaneActivate,
   onSeparatorDrag,
   onSeparatorDragEnd,
@@ -375,6 +378,7 @@ export function RootView({
             onSeparatorDrag={onSeparatorDrag}
             onSeparatorDragEnd={onSeparatorDragEnd}
             onLeftEdgeMouseDown={handleTerminalLeftEdgeMouseDown}
+            onMeasure={onMeasure}
             bounds={{
               cols: terminalCols + splitChrome,
               rows: terminalRows + splitChrome,
@@ -398,6 +402,7 @@ export function RootView({
             onTerminalMouseUp={onTerminalMouseUp}
             onPaneActivate={onPaneActivate}
             onLeftEdgeMouseDown={handleTerminalLeftEdgeMouseDown}
+            onMeasure={onMeasure}
           />
         )}
         {gitPaneMode === 'pane' && gitPaneVisible && gitPanePosition === 'right' ? (