@brimveyn/aimux 1.14.15 → 1.15.0

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

@@ -18,15 +18,23 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
       const snapshot =
         action.workspaceSnapshot ??
         state.sessions.find((entry) => entry.id === action.sessionId)?.workspaceSnapshot
-      const restored = restoreWorkspaceState(state, snapshot, {
-        forceDisconnected: action.forceDisconnected ?? true,
-      })
       // The session's activeWorktreeId may have been patched right before
       // this load (e.g. the cross-workspace branch of handleCycleSidebarItem
       // sets it to the worktree the user just clicked). The snapshot's
       // activeTabId still reflects the *last* worktree they were on, so
       // honor the patched worktree by filtering the restored tab list.
       const loadedSession = state.sessions.find((entry) => entry.id === action.sessionId)
+      const loadedWorktrees = loadedSession?.worktrees ?? []
+      const restored = restoreWorkspaceState(state, snapshot, {
+        forceDisconnected: action.forceDisconnected ?? true,
+        // Drop tabs bound to worktrees this session no longer owns so a stale
+        // id can't be caught by a later worktree delete (closing "another
+        // worktree's" tabs) and so corrupted catalogs self-heal on load. Only
+        // prune once the session has worktrees — an empty list means it hasn't
+        // been initialized yet, and pruning then would wrongly drop bound tabs.
+        validWorktreeIds:
+          loadedWorktrees.length > 0 ? new Set(loadedWorktrees.map((w) => w.id)) : undefined,
+      })
       const visible = filterTabsForActiveWorktree(restored.tabs, loadedSession)
       // Prefer the snapshot's tab; if it isn't visible under the active
       // worktree (e.g. a multi-worktree session restored onto a different
@@ -188,22 +196,6 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
             : withActiveWorktree(next, action.worktree.id)
         }),
       }
-    case 'remove-worktree-record':
-      return {
-        ...state,
-        sessions: state.sessions.map((session) => {
-          if (session.id !== action.sessionId) return session
-          const remaining = (session.worktrees ?? []).filter((w) => w.id !== action.worktreeId)
-          if (remaining.length === 0) return session
-          if (session.activeWorktreeId !== action.worktreeId) {
-            return { ...session, updatedAt: new Date().toISOString(), worktrees: remaining }
-          }
-          return withActiveWorktree(
-            { ...session, activeWorktreeId: remaining[0]?.id, worktrees: remaining },
-            remaining[0]?.id ?? ''
-          )
-        }),
-      }
     case 'set-active-worktree': {
       const sessions = state.sessions.map((session) =>
         session.id === action.sessionId ? withActiveWorktree(session, action.worktreeId) : session

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

@@ -469,6 +469,23 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       }
       return { ...state, tabs }
     }
+    case 'reorder-tabs': {
+      // Drag-and-drop reorder of the visible tab strip. `orderedTabIds` is the
+      // flattened new order of the currently-visible tabs (group members already
+      // expanded into contiguous runs). We only rewrite the slots those tabs
+      // occupy in `state.tabs`, leaving tabs from other worktrees anchored in
+      // place. Because group members arrive contiguous, splits stay intact.
+      const visibleSet = new Set(action.orderedTabIds)
+      const byId = new Map(state.tabs.map((tab) => [tab.id, tab]))
+      let cursor = 0
+      const tabs = state.tabs.map((tab) => {
+        if (!visibleSet.has(tab.id)) return tab
+        const nextId = action.orderedTabIds[cursor]
+        cursor++
+        return (nextId != null ? byId.get(nextId) : undefined) ?? tab
+      })
+      return { ...state, tabs }
+    }
     case 'reset-tab-session':
       return withActiveTabWorktree(
         {

package/src/state/selectors.ts

@@ -1,5 +1,49 @@
 import type { AssistantOption } from '../pty/command-registry'
-import type { AssistantId, SessionRecord, SnippetRecord } from './types'
+import type { AssistantId, SessionRecord, SnippetRecord, WorktreeRecord } from './types'
+
+export interface BaseRefOption {
+  /** Git ref the new worktree is forked from. */
+  ref: string
+  label: string
+  kind: 'worktree' | 'branch'
+  /** Worktree name, for the 'worktree' kind. */
+  detail?: string
+}
+
+/**
+ * Ordered, filtered base-ref candidates for the worktree-create "Base" picker:
+ * branches checked out in the session's worktrees first (labelled with the
+ * worktree name), then the remaining local branches. A branch already surfaced
+ * via a worktree is not repeated. Throwaway `aimux/` branches are skipped unless
+ * a live worktree is on them — `git worktree remove` leaves the branch behind,
+ * so deleted temp worktrees would otherwise haunt the list as orphan branches.
+ */
+export function buildBaseRefOptions(
+  worktrees: WorktreeRecord[],
+  localBranches: string[],
+  query: string
+): BaseRefOption[] {
+  const seen = new Set<string>()
+  const options: BaseRefOption[] = []
+  for (const worktree of worktrees) {
+    if (worktree.branch == null || worktree.branch === '' || seen.has(worktree.branch)) continue
+    seen.add(worktree.branch)
+    options.push({
+      detail: worktree.name,
+      kind: 'worktree',
+      label: worktree.branch,
+      ref: worktree.branch,
+    })
+  }
+  for (const branch of localBranches) {
+    if (seen.has(branch) || branch.startsWith('aimux/')) continue
+    seen.add(branch)
+    options.push({ kind: 'branch', label: branch, ref: branch })
+  }
+  const trimmed = query.trim().toLowerCase()
+  if (trimmed === '') return options
+  return options.filter((option) => option.label.toLowerCase().includes(trimmed))
+}
 
 /**
  * 0 when the template picker should NOT show the "None" fallback (no assistant

package/src/state/session-persistence.ts

@@ -72,6 +72,27 @@ export interface RestoreOptions {
   // will overwrite the status with daemon truth — leaving the flag on would
   // briefly flash the "Restored snapshot" hint on every j/k cycle.
   forceDisconnected?: boolean
+  // When provided, drop tabs pinned to a worktree id that the session no
+  // longer owns. Some delete paths (notably the sidebar's "Remove worktree")
+  // historically removed the worktree record without closing its tabs, leaving
+  // orphans bound to a vanished id. Those orphans are invisible (filtered out
+  // by the active-worktree filter) yet keep a worktree id that a *future*
+  // delete can collide with — exactly what closes "another worktree's" tabs.
+  // Pruning them on restore both repairs corrupted catalogs and prevents the
+  // collision. Tabs with no worktree id (legacy/unbound) are always kept.
+  validWorktreeIds?: ReadonlySet<string>
+}
+
+// Drop tabs bound to a worktree id the session no longer owns. Unbound tabs
+// (no worktreeId) are kept — they surface under the primary worktree.
+function pruneOrphanedTabs(
+  tabs: TabSession[],
+  validWorktreeIds: ReadonlySet<string> | undefined
+): TabSession[] {
+  if (!validWorktreeIds) return tabs
+  return tabs.filter(
+    (tab) => tab.worktreeId == null || tab.worktreeId === '' || validWorktreeIds.has(tab.worktreeId)
+  )
 }
 
 export function restoreTabsFromWorkspace(
@@ -84,7 +105,7 @@ export function restoreTabsFromWorkspace(
 
   const forceDisconnected = options.forceDisconnected ?? true
 
-  return snapshot.tabs
+  const restored: TabSession[] = snapshot.tabs
     .filter(
       (tab): tab is typeof tab & { status: Exclude<typeof tab.status, 'exited'> } =>
         tab.status !== 'exited'
@@ -103,6 +124,7 @@ export function restoreTabsFromWorkspace(
       viewport: tab.viewport,
       worktreeId: tab.worktreeId,
     }))
+  return pruneOrphanedTabs(restored, options.validWorktreeIds)
 }
 
 export function restoreLayoutTrees(

package/src/state/types.ts

@@ -47,6 +47,8 @@ export type ModalType =
   | 'update-available'
   | 'ai-usage'
   | 'worktree-move'
+  | 'worktree-move-confirm'
+  | 'worktree-delete-confirm'
   | null
 
 export interface TerminalSpan {
@@ -71,12 +73,22 @@ export interface TerminalLine {
   spans: TerminalSpan[]
 }
 
+/** DECSCUSR cursor shape; 'default' restores the host terminal's configured cursor. */
+export type TerminalCursorStyle = 'block' | 'underline' | 'bar' | 'default'
+
 export interface TerminalSnapshot {
   lines: TerminalLine[]
   tailLines?: TerminalLine[]
   viewportY: number
   baseY: number
   cursorVisible: boolean
+  cursorStyle?: TerminalCursorStyle
+  /** Blink flag from DECSCUSR; undefined means "host terminal's default". */
+  cursorBlink?: boolean
+  /** Cursor row relative to the rendered viewport; outside [0, rows) when
+   *  the user scrolled the viewport away from the active screen. */
+  cursorRow?: number
+  cursorCol?: number
 }
 
 // The scroll position is owned end-to-end by the backend emulator; this type
@@ -323,16 +335,21 @@ export interface ModalClosed extends ModalBase {
 export interface ModalNewTab extends ModalBase {
   type: 'new-tab'
   editingCommand: AssistantId | null
-  activeField: 'assistant' | 'branch-name' | 'target-worktree' | 'worktree-name'
+  activeField: 'assistant' | 'branch-name' | 'target-worktree' | 'worktree-name' | 'base'
   branchError: string | null
   branchName: string
   createWorktree: boolean
   selectedAssistantId: AssistantId | null
   step: 'assistant' | 'worktree' | 'worktree-create' | 'template'
   targetWorktreeIndex: number
-  worktreeDeleteConfirmId: string | null
-  worktreeDeleteMessage: string | null
+  worktreeDeletePrompt: { worktreeId: string; reason: string } | null
   worktreeName: string
+  /** Filter text typed into the "Base" picker on the worktree-create step. */
+  baseQuery: string
+  /** Resolved base ref the new worktree is forked from (branch of a worktree or a local branch). */
+  baseRef: string
+  /** Local branches available as base refs, loaded when the create step opens. */
+  baseBranches: string[]
 }
 
 export interface ModalSessionPicker extends ModalBase {
@@ -415,6 +432,42 @@ export interface ModalWorktreeMove extends ModalBase {
   /** The worktree being moved (may differ from the active one, e.g. a tab menu). */
   sourceWorktreeId: string
   deleteSource: boolean
+  /** Per-worktree dirty file counts, loaded async when the modal opens. */
+  stats: { kind: 'loading' } | { kind: 'ready'; dirtyFiles: Record<string, number> }
+}
+
+/**
+ * Confirmation for a recoverable move failure: the target's dirty files
+ * overlap the incoming changes (stash-target) or the squash conflicts
+ * (keep-conflicts). Both worktrees are already restored; confirming re-runs
+ * move-worktree with the matching flag.
+ */
+export interface ModalWorktreeMoveConfirm extends ModalBase {
+  type: 'worktree-move-confirm'
+  variant: 'stash-target' | 'keep-conflicts'
+  files: string[]
+  sessionId: string
+  sourceWorktreeId: string
+  targetWorktreeId: string
+  deleteSource: boolean
+  sourceLabel: string
+  targetLabel: string
+}
+
+/**
+ * Standalone confirmation for a recoverable worktree delete failure triggered
+ * outside the new-tab picker (e.g. the sidebar's "Remove worktree"). Carries the
+ * params needed to re-run the delete with force once confirmed.
+ */
+export interface ModalWorktreeDeleteConfirm extends ModalBase {
+  type: 'worktree-delete-confirm'
+  sessionId: string
+  worktreeId: string
+  worktreeLabel: string
+  reason: string
+  closeTabs: boolean
+  /** Whether confirming force-deletes — true only after a recoverable failure. */
+  force: boolean
 }
 
 export type DirectoryResultType = 'git-repo' | 'worktree' | 'workspace'
@@ -440,6 +493,8 @@ export type ModalState =
   | ModalUpdateAvailable
   | ModalAIUsage
   | ModalWorktreeMove
+  | ModalWorktreeMoveConfirm
+  | ModalWorktreeDeleteConfirm
 
 export interface LayoutState {
   terminalCols: number
@@ -515,10 +570,10 @@ export type ModalAction =
   | { type: 'open-new-tab-modal' }
   | { type: 'set-new-tab-branch-error'; message: string | null }
   | {
-      type: 'set-new-tab-worktree-delete-state'
-      confirmWorktreeId?: string | null
-      message: string | null
+      type: 'set-new-tab-worktree-delete-prompt'
+      prompt: { worktreeId: string; reason: string } | null
     }
+  | { type: 'set-new-tab-base-branches'; branches: string[] }
   | { type: 'enter-new-tab-worktree-create' }
   | { type: 'enter-new-tab-template-pick' }
   | { type: 'enter-new-tab-template-shortcut' }
@@ -553,6 +608,27 @@ export type ModalAction =
   | { type: 'open-ai-usage-modal' }
   | { type: 'open-worktree-move-modal'; sourceWorktreeId: string }
   | { type: 'toggle-worktree-move-delete' }
+  | { type: 'set-worktree-move-stats'; dirtyFiles: Record<string, number> }
+  | {
+      type: 'open-worktree-move-confirm'
+      variant: 'stash-target' | 'keep-conflicts'
+      files: string[]
+      sessionId: string
+      sourceWorktreeId: string
+      targetWorktreeId: string
+      deleteSource: boolean
+      sourceLabel: string
+      targetLabel: string
+    }
+  | {
+      type: 'open-worktree-delete-confirm'
+      sessionId: string
+      worktreeId: string
+      worktreeLabel: string
+      reason: string
+      closeTabs: boolean
+      force: boolean
+    }
 
 // -- Session actions --
 export type SessionAction =
@@ -570,7 +646,6 @@ export type SessionAction =
   | { type: 'reorder-active-session'; delta: number }
   | { type: 'set-session-status'; sessionId: string; status: SessionStatus }
   | { type: 'add-worktree-record'; sessionId: string; worktree: WorktreeRecord; activate?: boolean }
-  | { type: 'remove-worktree-record'; sessionId: string; worktreeId: string }
   | { type: 'set-active-worktree'; sessionId: string; worktreeId: string }
   | {
       type: 'update-worktree-record'
@@ -595,6 +670,7 @@ export type TabAction =
   | { type: 'set-active-tab'; tabId: string }
   | { type: 'move-active-tab'; delta: number }
   | { type: 'reorder-active-tab'; delta: number }
+  | { type: 'reorder-tabs'; orderedTabIds: string[] }
   | { type: 'reset-tab-session'; tabId: string }
   | { type: 'rename-tab'; tabId: string; title: string }
   | { type: 'append-tab-buffer'; tabId: string; chunk: string }

package/src/state/validation.ts

@@ -45,6 +45,10 @@ function isTerminalLine(value: unknown): value is TerminalLine {
   })
 }
 
+function isTerminalCursorStyle(value: unknown): boolean {
+  return value === 'block' || value === 'underline' || value === 'bar' || value === 'default'
+}
+
 function isTerminalSnapshot(value: unknown): value is TerminalSnapshot {
   return (
     isObjectRecord(value) &&
@@ -52,7 +56,11 @@ function isTerminalSnapshot(value: unknown): value is TerminalSnapshot {
     value.lines.every(isTerminalLine) &&
     isFiniteNumber(value.viewportY) &&
     isFiniteNumber(value.baseY) &&
-    isBoolean(value.cursorVisible)
+    isBoolean(value.cursorVisible) &&
+    (value.cursorStyle === undefined || isTerminalCursorStyle(value.cursorStyle)) &&
+    (value.cursorBlink === undefined || isBoolean(value.cursorBlink)) &&
+    (value.cursorRow === undefined || isFiniteNumber(value.cursorRow)) &&
+    (value.cursorCol === undefined || isFiniteNumber(value.cursorCol))
   )
 }
 

package/src/ui/components/layout/sidebar/tab-item.tsx

@@ -170,11 +170,13 @@ export function TabItem({
         ? [
             [
               'Move worktree',
-              () =>
+              () => {
                 dispatchGlobal({
                   sourceWorktreeId: moveWorktreeId,
                   type: 'open-worktree-move-modal',
-                }),
+                })
+                runSideEffectGlobal({ type: 'load-worktree-move-stats' })
+              },
             ] as [string, () => void],
           ]
         : []),

package/src/ui/components/layout/sidebar/worktree-row.tsx

@@ -68,14 +68,24 @@ export const WorktreeRow = memo(function WorktreeRow({
       [
         'Remove worktree',
         () =>
+          // Always confirm first. Confirming routes through the full delete side
+          // effect (closes the worktree's tabs, disposes their PTYs, prunes the
+          // snapshot, removes the git worktree). closeTabs (not force) cleans up
+          // the tabs while keeping the non-force `git worktree remove`, so
+          // uncommitted work in a temp worktree is still protected — a dirty
+          // worktree re-prompts for an explicit force-delete.
           dispatchGlobal({
+            closeTabs: true,
+            force: false,
+            reason: 'Its assistant tabs will be closed and the worktree removed.',
             sessionId: session.id,
-            type: 'remove-worktree-record',
+            type: 'open-worktree-delete-confirm',
             worktreeId: worktree.id,
+            worktreeLabel: worktree.branch ?? worktree.name,
           }),
       ],
     ]
-  }, [session.id, worktree.id, worktree.source])
+  }, [session.id, worktree.branch, worktree.id, worktree.name, worktree.source])
 
   let bgColor: string | undefined
   if (isActiveItem) {

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

@@ -1,10 +1,17 @@
-import type { MouseEvent as OtuiMouseEvent, TextRenderable } from '@opentui/core'
+import type { CursorStyle, MouseEvent as OtuiMouseEvent, TextRenderable } from '@opentui/core'
 
-import { memo, type ReactNode, useCallback, useMemo } from 'react'
+import { useRenderer } from '@opentui/react'
+import { memo, type ReactNode, useCallback, useEffect, useMemo } from 'react'
 
 import type { TerminalContentOrigin } from '../../../input/raw-input-handler'
 import type { JunctionEdgeInfo, JunctionEdges } from '../../../state/layout-tree'
-import type { FocusMode, TabSession, TerminalSnapshot, TerminalSpan } from '../../../state/types'
+import type {
+  FocusMode,
+  TabSession,
+  TerminalCursorStyle,
+  TerminalSnapshot,
+  TerminalSpan,
+} from '../../../state/types'
 
 import { type MeasuredPaneRect, usePaneSizeReport } from '../../../app-runtime/use-pane-size-report'
 import { logInputDebug } from '../../../debug/input-log'
@@ -69,7 +76,7 @@ function getBorderColor(isActive: boolean, focusMode: TerminalPaneProps['focusMo
   return focusMode === 'terminal-input' ? t.accent : t.primary
 }
 
-function renderSpan(span: TerminalSpan, key: string): ReactNode {
+function renderSpan(span: TerminalSpan, key: string, softCursor: boolean): ReactNode {
   let node: ReactNode = span.text
 
   if (span.underline === true) {
@@ -86,11 +93,20 @@ function renderSpan(span: TerminalSpan, key: string): ReactNode {
 
   // Palette indices are resolved here (not in the daemon) so they pick up
   // the host terminal's actual ANSI palette queried at startup.
-  const fg =
+  let fg =
     span.fgPalette !== undefined
       ? resolvePaletteIndex(span.fgPalette)
       : (span.fg ?? getCurrentTheme().text)
-  const bg = span.bgPalette !== undefined ? resolvePaletteIndex(span.bgPalette) : span.bg
+  let bg = span.bgPalette !== undefined ? resolvePaletteIndex(span.bgPalette) : span.bg
+
+  // Soft cursor: inverted block drawn in the cell grid. Used only when the
+  // host terminal's hardware cursor is not parked on this pane (inactive
+  // pane, navigation mode) — otherwise both would show at once.
+  if (span.cursor === true && softCursor) {
+    const resolvedBg = bg ?? getCurrentTheme().background
+    bg = fg
+    fg = resolvedBg
+  }
 
   return (
     <span key={key} fg={fg} bg={bg}>
@@ -102,6 +118,80 @@ function renderSpan(span: TerminalSpan, key: string): ReactNode {
 interface TerminalViewportProps {
   viewport: TerminalSnapshot | undefined
   buffer: string
+  softCursor: boolean
+}
+
+const OPENTUI_CURSOR_STYLES: Record<TerminalCursorStyle, CursorStyle> = {
+  bar: 'line',
+  block: 'block',
+  default: 'default',
+  underline: 'underline',
+}
+
+/**
+ * Parks the host terminal's hardware cursor on this pane's cursor cell so the
+ * shape requested by the running program via DECSCUSR (nvim's insert bar, the
+ * shell's configured cursor, blinking) shows through, instead of the soft
+ * inverted block. Returns whether the hardware cursor is currently shown.
+ */
+function useHardwareCursor(
+  viewport: TerminalSnapshot | undefined,
+  contentOrigin: TerminalContentOrigin,
+  active: boolean
+): boolean {
+  const renderer = useRenderer()
+  const rows = viewport?.lines.length ?? 0
+  const cursorRow = viewport?.cursorRow
+  const cursorCol = viewport?.cursorCol
+  // cursorRow leaves [0, rows) when the user scrolls the viewport away from
+  // the active screen — the hardware cursor must vanish with the cell. The
+  // contentOrigin bound matters separately: right after a resize the snapshot
+  // can be larger than the pane box, and a cursor parked past the border
+  // would render as a stray glyph over neighbouring UI.
+  const show =
+    active &&
+    viewport !== undefined &&
+    viewport.cursorVisible &&
+    cursorRow !== undefined &&
+    cursorRow >= 0 &&
+    cursorRow < rows &&
+    cursorRow < contentOrigin.rows &&
+    cursorCol !== undefined &&
+    cursorCol < contentOrigin.cols
+
+  useEffect(() => {
+    if (!show || viewport === undefined || cursorRow === undefined || cursorCol === undefined) {
+      return
+    }
+    // Native cursor coordinates are 1-indexed (same convention as opentui's
+    // editor renderable). `viewport` is a dependency on purpose: every new
+    // snapshot re-asserts the position, so a modal input blurring (which
+    // hides the cursor) can never leave it lost for long.
+    renderer.setCursorPosition(
+      contentOrigin.x + cursorCol + 1,
+      contentOrigin.y + cursorRow + 1,
+      true
+    )
+    renderer.setCursorStyle({
+      blinking: viewport.cursorBlink,
+      style: OPENTUI_CURSOR_STYLES[viewport.cursorStyle ?? 'default'],
+    })
+    // Cursor state only reaches the terminal with the next rendered frame
+    // (same reason opentui's editor calls requestRender() in focus/blur).
+    // Without it, a hide issued while the UI is static — e.g. switching to
+    // a workspace with no live PTY — never flushes and the host cursor
+    // stays stranded at its old position.
+    renderer.requestRender()
+    // React runs all cleanups in a commit before all effects, so when focus
+    // moves between panes the releasing pane always hides before the gaining
+    // pane shows — no stomp regardless of tree order.
+    return () => {
+      renderer.setCursorPosition(0, 0, false)
+      renderer.requestRender()
+    }
+  }, [contentOrigin, cursorCol, cursorRow, renderer, show, viewport])
+
+  return show
 }
 
 const NOOP = (): void => {}
@@ -127,6 +217,7 @@ const pinTerminalScroll = (node: TextRenderable | null): void => {
 
 const TerminalViewport = memo(function TerminalViewport({
   buffer,
+  softCursor,
   viewport,
 }: TerminalViewportProps) {
   const t = useTheme()
@@ -138,7 +229,7 @@ const TerminalViewport = memo(function TerminalViewport({
           // Terminal rows are a fixed positional grid; the row index is the identity.
           // eslint-disable-next-line react/no-array-index-key
           <span key={`line-${lineIndex}`}>
-            {line.spans.map((span, spanIndex) => renderSpan(span, `s-${spanIndex}`))}
+            {line.spans.map((span, spanIndex) => renderSpan(span, `s-${spanIndex}`, softCursor))}
             {lineIndex < lines.length - 1 ? '\n' : ''}
           </span>
         ))}
@@ -178,6 +269,15 @@ export function TerminalPane({
   const setContentBox = usePaneSizeReport(tabId, !!tab, onMeasure)
   const editorBg = t.background
   const paneIsActive = isActive ?? true
+  // Restored/disconnected tabs carry a frozen snapshot whose persisted
+  // cursorVisible/cursorRow/cursorCol never update again — parking the
+  // hardware cursor there would leave a stray blinking cursor at a stale
+  // position. Only live PTYs get the hardware cursor.
+  const showHardwareCursor = useHardwareCursor(
+    tab?.viewport,
+    contentOrigin,
+    paneIsActive && focusMode === 'terminal-input' && tab?.status === 'running'
+  )
   // These are only used when this pane is rendered without a tab (the
   // top-level pane on a worktree with zero tabs). Selectors return plain
   // strings so re-renders are cheap and bounded to actual name changes.
@@ -483,7 +583,11 @@ export function TerminalPane({
             onMouseDrag={forwardMouseEvent}
             onMouseScroll={forwardScrollEvent}
           >
-            <TerminalViewport viewport={tab.viewport} buffer={tab.buffer} />
+            <TerminalViewport
+              viewport={tab.viewport}
+              buffer={tab.buffer}
+              softCursor={!showHardwareCursor}
+            />
           </box>
         )}
       </ContextMenuBox>