@brimveyn/aimux 1.12.1 → 1.12.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.12.1",
+  "version": "1.12.6",
   "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.17",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

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

@@ -45,3 +45,55 @@ export function writePasteToTab(
   const payload = buildPtyPastePayload(text, tab?.terminalModes.bracketedPasteMode ?? false)
   writeToTab(backend, tabId, tab, payload, dispatch, { autoBottom: true })
 }
+
+const DEL = '\x7f'
+const CURSOR_LEFT = '\x1b[D'
+const RAW_INLINE_MAX_LEN = 200
+
+/**
+ * Write a macro expansion to a PTY:
+ *  1. Erase `eraseCount` previously echoed characters via DEL (readline-compatible).
+ *  2. Inject `expandedText` (raw if short single-line; bracketed-paste payload otherwise).
+ *  3. Move cursor left to `cursorOffset` via ANSI left-arrow sequences (outside any
+ *     bracketed-paste wrapper so the application interprets them as keys, not text).
+ */
+export function writeMacroExpansionToTab(
+  backend: SessionBackend,
+  tabId: string,
+  tab: TabSession | undefined,
+  eraseCount: number,
+  expandedText: string,
+  cursorOffset: number,
+  dispatch?: (action: AppAction) => void
+): void {
+  if (tab && shouldScrollViewportToBottom(tab)) {
+    backend.scrollViewportToBottom(tabId)
+    dispatch?.({ intent: { kind: 'bottom' }, tabId, type: 'set-scroll-intent' })
+  }
+
+  const erase = eraseCount > 0 ? DEL.repeat(eraseCount) : ''
+  const isShortInline = expandedText.length <= RAW_INLINE_MAX_LEN && !expandedText.includes('\n')
+  const bracketed = tab?.terminalModes.bracketedPasteMode ?? false
+
+  const body = isShortInline ? expandedText : buildPtyPastePayload(expandedText, bracketed)
+  const leftArrowCount = Math.max(0, expandedText.length - cursorOffset)
+  const leftArrows = leftArrowCount > 0 ? CURSOR_LEFT.repeat(leftArrowCount) : ''
+
+  logInputDebug('ptyWrite.macroExpansion', {
+    bodyLength: body.length,
+    cursorOffset,
+    eraseCount,
+    expandedTextLength: expandedText.length,
+    leftArrowCount,
+    tabId,
+  })
+
+  if (isShortInline) {
+    backend.write(tabId, `${erase}${body}${leftArrows}`)
+    return
+  }
+
+  if (erase) backend.write(tabId, erase)
+  backend.write(tabId, body)
+  if (leftArrows) backend.write(tabId, leftArrows)
+}

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

@@ -6,7 +6,8 @@ import {
 } from '@brimveyn/aimux-config'
 import { type CliRenderer } from '@opentui/core'
 import { $ } from 'bun'
-import { resolve as resolvePath } from 'node:path'
+import { existsSync } from 'node:fs'
+import { join as joinPath, resolve as resolvePath } from 'node:path'
 
 import type { SideEffect } from '../input/modes/types'
 import type { SessionBackend } from '../session-backend/types'
@@ -15,6 +16,7 @@ import { loadConfig, saveConfig } from '../config'
 import { logInputDebug } from '../debug/input-log'
 import { enqueueGitOp } from '../git/command-queue'
 import { createPrefixedId } from '../platform/id'
+import { getProfileConfigDir } from '../profile-paths'
 import {
   getAllAssistantOptions,
   getAssistantOption,
@@ -33,6 +35,7 @@ import {
   splitNode,
 } from '../state/layout-tree'
 import { filterAssistants, filterSessions, filterSnippets } from '../state/selectors'
+import { getSnippetsCatalogPath, isConfigSnippetId } from '../state/snippet-catalog'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
 import {
   type AppAction,
@@ -388,6 +391,11 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       launchAssistant(ctx, option.id)
       return
     }
+    case 'edit-selected-assistant': {
+      const option = getSelectedAssistantOption(state)
+      dispatch({ assistantId: option.id, type: 'open-edit-custom-command' })
+      return
+    }
     case 'confirm-selected-session': {
       handleSessionSelection(ctx)
       return
@@ -617,22 +625,45 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       openFileInEditor(ctx, effect.path)
       return
     }
+    case 'open-selected-snippet-source-in-editor': {
+      openSelectedSnippetSourceInEditor(ctx)
+      return
+    }
     default:
       effect satisfies never
   }
 }
 
-function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
-  const config = getExternalEditorConfig()
-  const rawCommand = config.command ?? process.env.VISUAL ?? process.env.EDITOR
-  if (!rawCommand || rawCommand.trim() === '') {
-    ctx.dispatch({
-      message: 'no $EDITOR/$VISUAL set — configure externalEditor in aimux.config.ts',
-      type: 'git-mode-set-message',
-    })
-    return
+/**
+ * Open the file backing the currently selected snippet in the user's editor.
+ * Config-pinned snippets (id starts with `config:`) live in `aimux.config.ts`
+ * (or `.js`); user-edited snippets live in `aimux-snippets.json`.
+ *
+ * On error (no editor, editor not in PATH) the failure is silent: there is no
+ * snippet-picker status line. The user can check the debug log.
+ */
+function openSelectedSnippetSourceInEditor(ctx: SideEffectContext): void {
+  const snippet = getSelectedSnippet(ctx.state)
+  if (!snippet) return
+
+  const configDir = getProfileConfigDir()
+  let absolutePath: string
+
+  if (isConfigSnippetId(snippet.id)) {
+    const tsPath = joinPath(configDir, 'aimux.config.ts')
+    const jsPath = joinPath(configDir, 'aimux.config.js')
+    absolutePath = existsSync(jsPath) && !existsSync(tsPath) ? jsPath : tsPath
+  } else {
+    absolutePath = getSnippetsCatalogPath()
   }
 
+  launchEditorOnFile(ctx, absolutePath, configDir, (message) => {
+    logInputDebug('snippets.openInEditor.error', { message, path: absolutePath })
+    ctx.dispatch({ message, type: 'snippet-picker-set-message' })
+  })
+}
+
+function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
   const fileEntry = ctx.state.gitPanel.files.find((f) => f.path === relPath)
   const cwd = fileEntry?.repoPath ?? ctx.getCurrentSessionProjectPath()
   if (!cwd) {
@@ -640,11 +671,28 @@ function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
     return
   }
   const absolutePath = resolvePath(cwd, relPath)
+  launchEditorOnFile(ctx, absolutePath, cwd, (message) =>
+    ctx.dispatch({ message, type: 'git-mode-set-message' })
+  )
+}
+
+function launchEditorOnFile(
+  ctx: SideEffectContext,
+  absolutePath: string,
+  cwd: string,
+  onError: (message: string) => void
+): void {
+  const config = getExternalEditorConfig()
+  const rawCommand = config.command ?? process.env.VISUAL ?? process.env.EDITOR
+  if (!rawCommand || rawCommand.trim() === '') {
+    onError('no $EDITOR/$VISUAL set — configure externalEditor in aimux.config.ts')
+    return
+  }
 
   const cmdParts = shellSplit(rawCommand)
   const executable = cmdParts[0]
   if (!executable) {
-    ctx.dispatch({ message: 'invalid editor command', type: 'git-mode-set-message' })
+    onError('invalid editor command')
     return
   }
   const baseName = executable.split('/').pop() ?? executable
@@ -653,16 +701,12 @@ function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
   const kind: 'gui' | 'tui' = config.kind ?? (KNOWN_GUI_EDITORS.has(baseName) ? 'gui' : 'tui')
 
   const templateArgs = config.args ?? DEFAULT_EDITOR_ARGS[baseName] ?? ['{file}']
-  // git mode does not track a cursor line within the diff yet, so pass undefined
-  // and let the substitution strip `{line}` placeholders cleanly — preserves
-  // editor-side "restore last cursor position" behavior (e.g. vscode).
+  // No line target — let substitution strip `{line}` placeholders so we don't
+  // defeat the editor's "restore last cursor position" feature.
   const resolvedArgs = [...extraCmdArgs, ...substituteEditorArgs(templateArgs, absolutePath)]
 
   if (!isCommandAvailable(executable)) {
-    ctx.dispatch({
-      message: `editor not found in PATH: ${executable}`,
-      type: 'git-mode-set-message',
-    })
+    onError(`editor not found in PATH: ${executable}`)
     return
   }
 
@@ -671,9 +715,6 @@ function openFileInEditor(ctx: SideEffectContext, relPath: string): void {
     return
   }
 
-  // TUI editor — if the user explicitly configured `terminal`, spawn a new
-  // terminal window with their template. Otherwise default to inline shellout:
-  // suspend the renderer, hand the TTY to the editor, resume on exit.
   if (config.terminal && config.terminal.length > 0) {
     const shellCmd = buildShellCmd(cwd, executable, resolvedArgs)
     const argv = config.terminal.map((a) =>

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

@@ -2,25 +2,31 @@ import type { SessionBackend } from '../session-backend/types'
 import type { AppAction, AppState, SnippetRecord, TabSession } from '../state/types'
 
 import { createPrefixedId } from '../platform/id'
-import { saveSnippetCatalog } from '../state/snippet-catalog'
+import { isConfigSnippetId, saveSnippetCatalog } from '../state/snippet-catalog'
 import { writePasteToTab } from './pty-write'
 
 function createSnippetId(): string {
   return createPrefixedId('snip')
 }
 
-export function getSnippetEditorValue(state: AppState): { name: string; content: string } | null {
+export interface SnippetEditorValue {
+  name: string
+  trigger: string
+  content: string
+}
+
+export function getSnippetEditorValue(state: AppState): SnippetEditorValue | null {
   if (state.modal.type !== 'snippet-editor') {
     return null
   }
 
   const { modal } = state
-  const name =
-    modal.activeField === 'name' ? (modal.editBuffer ?? '').trim() : modal.contentBuffer.trim()
-  const content =
-    modal.activeField === 'content' ? (modal.editBuffer ?? '').trim() : modal.contentBuffer.trim()
+  const editValue = (modal.editBuffer ?? '').trim()
+  const name = modal.activeField === 'name' ? editValue : modal.nameBuffer.trim()
+  const trigger = modal.activeField === 'trigger' ? editValue : modal.triggerBuffer.trim()
+  const content = modal.activeField === 'content' ? editValue : modal.contentBuffer.trim()
 
-  return { content, name }
+  return { content, name, trigger }
 }
 
 export function saveSnippetEditorState(state: AppState): SnippetRecord[] | null {
@@ -35,21 +41,29 @@ export function saveSnippetEditorState(state: AppState): SnippetRecord[] | null
   }
 
   const snippetId = state.modal.sessionTargetId
+  // Config-pinned snippets are sticky and read-only in the UI.
+  if (snippetId && isConfigSnippetId(snippetId)) {
+    return null
+  }
+
+  const trigger = editorValue.trigger.length > 0 ? editorValue.trigger : undefined
+
   if (snippetId) {
     return state.snippets.map((snippet) =>
       snippet.id === snippetId
-        ? { ...snippet, content: editorValue.content, name: editorValue.name }
+        ? { ...snippet, content: editorValue.content, name: editorValue.name, trigger }
         : snippet
     )
   }
 
   return [
     ...state.snippets,
-    { content: editorValue.content, id: createSnippetId(), name: editorValue.name },
+    { content: editorValue.content, id: createSnippetId(), name: editorValue.name, trigger },
   ]
 }
 
 export function deleteSnippetState(snippets: SnippetRecord[], snippetId: string): SnippetRecord[] {
+  if (isConfigSnippetId(snippetId)) return snippets
   return snippets.filter((snippet) => snippet.id !== snippetId)
 }
 

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

@@ -3,13 +3,24 @@ import { type MutableRefObject, useEffect, useRef } from 'react'
 
 import type { KeyChord } from '../input/keymap/key-chord'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, FocusMode, TabSession } from '../state/types'
+import type { AppAction, FocusMode, SnippetRecord, 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 { copyToSystemClipboard, readFromSystemClipboard } from '../platform/clipboard'
+import {
+  expandSnippet,
+  expandSnippetSync,
+  requiresAsyncExpansion,
+} from '../snippets/expand-variables'
+import { runShellVar } from '../snippets/run-shell-var'
+import {
+  createTriggerDetector,
+  type TriggerDetector,
+  type TriggerMatch,
+} from '../snippets/trigger-detector'
 import { shouldSuppressSelectionCopy } from './multi-click-clipboard-guard'
-import { writePasteToTab, writeToTab } from './pty-write'
+import { writeMacroExpansionToTab, writePasteToTab, writeToTab } from './pty-write'
 import { type OtuiSelection, resolveSelectionClipboardText } from './selection-clipboard'
 import { applyViewportObservation, type ViewportObservation } from './selection-scroll'
 
@@ -28,6 +39,9 @@ interface UseRendererBindingsOptions {
   focusModeRef: MutableRefObject<FocusMode>
   activeTabIdRef: MutableRefObject<string | null>
   activeTabRef: MutableRefObject<TabSession | undefined>
+  snippetsRef: MutableRefObject<readonly SnippetRecord[]>
+  branchRef: MutableRefObject<string | null>
+  triggerCharRef: MutableRefObject<string>
   handleTerminalShortcut: (chord: KeyChord) => boolean
 }
 
@@ -41,13 +55,27 @@ export function useRendererBindings({
   activeTabRef,
   activeTabViewportY,
   backend,
+  branchRef,
   dispatch,
   focusMode,
   focusModeRef,
   handleTerminalShortcut,
   renderer,
+  snippetsRef,
+  triggerCharRef,
 }: UseRendererBindingsOptions): void {
   const lastViewportRef = useRef<ViewportObservation | null>(null)
+  const triggerDetectorsRef = useRef<Map<string, TriggerDetector>>(new Map())
+  const pendingMacroUndoRef = useRef<Map<string, { fullLength: number; suffixLength: number }>>(
+    new Map()
+  )
+  /**
+   * Tabs currently waiting on an async expansion (shell vars or {{clipboard}}).
+   * While a tab is in this set, new trigger detections on that tab are
+   * suppressed — without this, a second trigger typed during the await would
+   * race with the in-flight expansion and corrupt PTY state + undo bookkeeping.
+   */
+  const inFlightAsyncExpansionRef = useRef<Set<string>>(new Set())
 
   useEffect(() => {
     renderer.useMouse = true
@@ -55,12 +83,115 @@ export function useRendererBindings({
     renderer.console.hide()
     renderer.console.show = () => {}
 
+    const getOrCreateDetector = (tabId: string): TriggerDetector => {
+      let detector = triggerDetectorsRef.current.get(tabId)
+      if (!detector) {
+        detector = createTriggerDetector({
+          getSnippets: () => snippetsRef.current,
+          getTriggerChar: () => triggerCharRef.current,
+        })
+        triggerDetectorsRef.current.set(tabId, detector)
+      }
+      return detector
+    }
+
+    const expandMacroForTab = (tabId: string, match: TriggerMatch): void => {
+      const tab = activeTabRef.current
+      const snippet = match.snippet
+      const branch = branchRef.current
+      const cwd = process.cwd()
+      const now = new Date()
+
+      const registerUndo = (text: string, cursorOffset: number) => {
+        // Undo window: only meaningful for short inline expansions where
+        // cursor positions stay predictable in raw mode.
+        if (!text.includes('\n')) {
+          pendingMacroUndoRef.current.set(tabId, {
+            fullLength: text.length,
+            suffixLength: text.length - cursorOffset,
+          })
+        }
+      }
+
+      if (!requiresAsyncExpansion(snippet)) {
+        const { cursorOffset, text } = expandSnippetSync(snippet.content, {
+          branch,
+          customVars: new Map(),
+          cwd,
+          now,
+        })
+        writeMacroExpansionToTab(
+          backend,
+          tabId,
+          tab,
+          match.triggerText.length,
+          text,
+          cursorOffset,
+          dispatch
+        )
+        registerUndo(text, cursorOffset)
+        return
+      }
+
+      // Eager erase: drop the typed trigger from the PTY immediately so the
+      // user doesn't stare at `:prfull ` while shell vars resolve.
+      backend.write(tabId, '\x7f'.repeat(match.triggerText.length))
+      inFlightAsyncExpansionRef.current.add(tabId)
+
+      void (async () => {
+        try {
+          const varEntries = Object.entries(snippet.vars ?? {})
+          const resolved = await Promise.all(
+            varEntries.map(async ([name, v]) => [name, await runShellVar(name, v)] as const)
+          )
+          const customVars = new Map(resolved)
+          const { cursorOffset, text } = await expandSnippet(snippet.content, {
+            branch,
+            clipboard: readFromSystemClipboard,
+            customVars,
+            cwd,
+            now,
+          })
+          // Trigger already erased above; eraseCount = 0 here.
+          writeMacroExpansionToTab(backend, tabId, tab, 0, text, cursorOffset, dispatch)
+          registerUndo(text, cursorOffset)
+        } finally {
+          inFlightAsyncExpansionRef.current.delete(tabId)
+        }
+      })()
+    }
+
+    const tryConsumeMacroUndo = (tabId: string, sequence: string): boolean => {
+      const entry = pendingMacroUndoRef.current.get(tabId)
+      if (!entry) return false
+      pendingMacroUndoRef.current.delete(tabId)
+      const isBackspace = sequence === '\x7f' || sequence === '\b'
+      if (!isBackspace) return false
+      const rightArrows = '\x1b[C'.repeat(entry.suffixLength)
+      const dels = '\x7f'.repeat(entry.fullLength)
+      backend.write(tabId, `${rightArrows}${dels}`)
+      return true
+    }
+
     const handler = createRawInputHandler({
+      expandMacro: expandMacroForTab,
+      feedTrigger: (tabId, char) => {
+        // Drop new detections while an async expansion is in flight for this
+        // tab — otherwise the second match races with the awaited write.
+        if (inFlightAsyncExpansionRef.current.has(tabId)) {
+          triggerDetectorsRef.current.get(tabId)?.reset()
+          return null
+        }
+        return getOrCreateDetector(tabId).feed(char)
+      },
       getActiveTabId: () => activeTabIdRef.current,
       getBracketedPasteModeEnabled: () =>
         activeTabRef.current?.terminalModes.bracketedPasteMode ?? false,
       getFocusMode: () => focusModeRef.current,
+      getIsAlternateBuffer: () => activeTabRef.current?.terminalModes.isAlternateBuffer ?? false,
       handleTerminalShortcut,
+      resetTrigger: (tabId) => triggerDetectorsRef.current.get(tabId)?.reset(),
+      tryConsumeMacroUndo,
       writeToPty: (tabId, data, options) =>
         writeToTab(backend, tabId, activeTabRef.current, data, dispatch, options),
     })
@@ -146,10 +277,13 @@ export function useRendererBindings({
     activeTabIdRef,
     activeTabRef,
     backend,
+    branchRef,
     dispatch,
     focusModeRef,
     handleTerminalShortcut,
     renderer,
+    snippetsRef,
+    triggerCharRef,
   ])
 
   useEffect(() => {

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 }
 }