@brimveyn/aimux 1.14.16 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.14.16",
+  "version": "1.15.0",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.6.10",
+    "@brimveyn/aimux-config": "0.6.11",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

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

@@ -19,7 +19,7 @@ import type { ThemeId } from '../ui/themes'
 import { loadConfig, saveConfig, type WorktreeTemplate, type WorktreeTemplatePane } from '../config'
 import { logInputDebug } from '../debug/input-log'
 import { enqueueGitOp } from '../git/command-queue'
-import { moveWorktree } from '../git/move-worktree'
+import { countDirtyFiles, moveWorktree } from '../git/move-worktree'
 import {
   createGitWorktree,
   deleteGitBranch,
@@ -784,7 +784,9 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
               effect.sessionId,
               effect.sourceWorktreeId,
               effect.targetWorktreeId,
-              effect.deleteSource === true
+              effect.deleteSource === true,
+              effect.stashTarget === true,
+              effect.keepConflicts === true
             )
           )
         } catch (error) {
@@ -793,6 +795,22 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       })()
       return
     }
+    case 'load-worktree-move-stats': {
+      void (async () => {
+        const session = state.sessions.find((entry) => entry.id === state.currentSessionId)
+        const worktrees = session?.worktrees ?? []
+        if (worktrees.length === 0) return
+        const counts = await Promise.all(
+          worktrees.map(async (worktree) => [worktree.id, await countDirtyFiles(worktree.path)])
+        )
+        if (ctx.getState().modal.type !== 'worktree-move') return
+        ctx.dispatch({
+          dirtyFiles: Object.fromEntries(counts),
+          type: 'set-worktree-move-stats',
+        })
+      })()
+      return
+    }
     case 'open-rename-selected-session': {
       openSelectedSessionRename(ctx)
       return
@@ -1648,7 +1666,9 @@ async function runMoveWorktree(
   sessionId: string,
   sourceWorktreeId: string,
   targetWorktreeId: string,
-  deleteSource: boolean
+  deleteSource: boolean,
+  stashTarget: boolean,
+  keepConflicts: boolean
 ): Promise<void> {
   const session = ctx.state.sessions.find((entry) => entry.id === sessionId)
   const source = session?.worktrees?.find((entry) => entry.id === sourceWorktreeId)
@@ -1666,20 +1686,38 @@ async function runMoveWorktree(
   const sourceLabel = source.branch ?? source.name
   const targetLabel = target.branch ?? target.name
   const result = await moveWorktree({
+    keepConflicts,
     sourceBranch: source.branch,
     sourcePath: source.path,
+    stashTarget,
     targetPath: target.path,
   })
 
-  // Toasts surface the outcome everywhere — the picker can be opened outside git
-  // mode (from a tab menu), where the git-pane message would never be seen.
-  if (result.kind === 'dirty-target') {
-    toast.warning(`Target ${targetLabel} has uncommitted changes — commit or stash it first`)
+  // Recoverable failures open a confirm dialog carrying retry params; both
+  // worktrees are already back in their original state, so confirming simply
+  // re-dispatches move-worktree with the matching flag.
+  if (result.kind === 'needs-stash' || result.kind === 'conflict') {
+    ctx.dispatch({
+      deleteSource,
+      files: result.files,
+      sessionId,
+      sourceLabel,
+      sourceWorktreeId,
+      targetLabel,
+      targetWorktreeId,
+      type: 'open-worktree-move-confirm',
+      variant: result.kind === 'needs-stash' ? 'stash-target' : 'keep-conflicts',
+    })
     return
   }
-  if (result.kind === 'conflict') {
+  if (result.kind === 'conflict-kept') {
+    // Never delete the source here — its work only landed half-resolved. The
+    // auto-commit driver is safe against this state: git refuses to commit
+    // with unmerged index entries, so it fails loudly instead of committing
+    // conflict markers.
+    handleSwitchWorktree({ ...ctx, state: ctx.getState() }, sessionId, targetWorktreeId)
     toast.warning(
-      `Move hit conflicts in ${result.files.length} file(s) — left ${sourceLabel} untouched`
+      `Left conflict markers in ${targetLabel} (${result.files.length} file(s)) — resolve & commit there; ${sourceLabel} kept`
     )
     return
   }
@@ -1702,8 +1740,11 @@ async function runMoveWorktree(
   } else {
     handleSwitchWorktree({ ...ctx, state: ctx.getState() }, sessionId, targetWorktreeId)
   }
+  const stashNote = result.stashedTarget
+    ? ` · target's previous changes stashed (recover with git stash pop)`
+    : ''
   toast.success(
-    `Moved ${sourceLabel} → ${targetLabel} · ${result.filesChanged} file(s) staged — review & commit`
+    `Moved ${sourceLabel} → ${targetLabel} · ${result.filesChanged} file(s) staged — review & commit${stashNote}`
   )
 }
 

package/src/git/move-worktree.ts

@@ -1,15 +1,36 @@
 import { $ } from 'bun'
 
+export interface MoveWorktreeOptions {
+  sourcePath: string
+  sourceBranch: string
+  targetPath: string
+  /** Stash the target's uncommitted (incl. untracked) changes before merging. The stash is kept. */
+  stashTarget?: boolean
+  /** On conflict, leave the conflicted squash state in the target for manual resolution. */
+  keepConflicts?: boolean
+}
+
 export type MoveWorktreeResult =
-  | { kind: 'ok'; filesChanged: number }
-  | { kind: 'dirty-target' }
+  | { kind: 'ok'; filesChanged: number; stashedTarget: boolean }
+  /** Target dirty/untracked files would be overwritten by the move; nothing was touched. */
+  | { kind: 'needs-stash'; files: string[] }
+  /** Conflict; target and source fully restored. */
   | { kind: 'conflict'; files: string[] }
+  /** Conflict markers left in the target on purpose; source restored. */
+  | { kind: 'conflict-kept'; files: string[] }
   | { kind: 'error'; message: string }
 
-async function workingTreeDirty(repoPath: string): Promise<boolean> {
+export async function countDirtyFiles(repoPath: string): Promise<number> {
   const result = await $`git -C ${repoPath} status --porcelain`.quiet().nothrow()
-  if (result.exitCode !== 0) return false
-  return result.text().trim() !== ''
+  if (result.exitCode !== 0) return 0
+  return result
+    .text()
+    .split('\n')
+    .filter((line) => line.trim() !== '').length
+}
+
+async function workingTreeDirty(repoPath: string): Promise<boolean> {
+  return (await countDirtyFiles(repoPath)) > 0
 }
 
 // Files left with conflict markers by a failed squash (unmerged index entries).
@@ -32,27 +53,63 @@ async function countStaged(repoPath: string): Promise<number> {
     .filter((line) => line.trim() !== '').length
 }
 
+// Git refuses a merge up front (working tree untouched) when local changes
+// overlap the incoming ones, listing the files tab-indented under either
+// "Your local changes to the following files would be overwritten by merge:"
+// or "The following untracked working tree files would be overwritten by merge:".
+function parseOverwrittenFiles(output: string): string[] {
+  const files: string[] = []
+  let collecting = false
+  for (const line of output.split('\n')) {
+    if (line.includes('would be overwritten by merge')) {
+      collecting = true
+      continue
+    }
+    if (!collecting) continue
+    if (line.startsWith('\t')) {
+      const file = line.trim()
+      if (file !== '') files.push(file)
+    } else {
+      collecting = false
+    }
+  }
+  return files
+}
+
 // Squashes everything a source worktree changed since its fork point into the
 // target worktree's working tree (staged, uncommitted) — committed work plus
 // any uncommitted/untracked changes. The source is left exactly as it was; the
-// caller decides whether to delete it. The target must be clean so two change
-// sets are never silently fused. On conflict nothing is kept: the target is
-// reset and the source restored.
-export async function moveWorktree(opts: {
-  sourcePath: string
-  sourceBranch: string
-  targetPath: string
-}): Promise<MoveWorktreeResult> {
+// caller decides whether to delete it. The target may be dirty as long as its
+// local changes don't overlap the incoming ones: on overlap the move stops
+// before touching anything (needs-stash) unless stashTarget is set. On
+// conflict nothing is kept — target reset, source restored — unless
+// keepConflicts is set, in which case the conflicted squash state is left in
+// the target for manual resolution.
+export async function moveWorktree(opts: MoveWorktreeOptions): Promise<MoveWorktreeResult> {
   const { sourceBranch, sourcePath, targetPath } = opts
   try {
-    if (await workingTreeDirty(targetPath)) return { kind: 'dirty-target' }
-
     const headResult = await $`git -C ${sourcePath} rev-parse HEAD`.quiet().nothrow()
     if (headResult.exitCode !== 0) {
       return { kind: 'error', message: 'could not resolve source HEAD' }
     }
     const sourceHead = headResult.text().trim()
 
+    let stashedTarget = false
+    if (opts.stashTarget === true && (await workingTreeDirty(targetPath))) {
+      const stashMessage = `aimux: backup before move from ${sourceBranch}`
+      const stash = await $`git -C ${targetPath} stash push --include-untracked -m ${stashMessage}`
+        .quiet()
+        .nothrow()
+      if (stash.exitCode !== 0) {
+        const message = stash.stderr.toString().trim()
+        return {
+          kind: 'error',
+          message: message !== '' ? message : 'failed to stash target changes',
+        }
+      }
+      stashedTarget = true
+    }
+
     // Capture uncommitted + untracked work in a throwaway commit so the squash
     // includes everything; undone again before we return.
     const tempCommitted = await workingTreeDirty(sourcePath)
@@ -79,8 +136,21 @@ export async function moveWorktree(opts: {
     const merge = await $`git -C ${targetPath} merge --squash ${sourceBranch}`.quiet().nothrow()
     const conflicts = await conflictedFiles(targetPath)
     if (merge.exitCode !== 0 || conflicts.length > 0) {
+      if (conflicts.length > 0 && opts.keepConflicts === true) {
+        await restoreSource()
+        return { files: conflicts, kind: 'conflict-kept' }
+      }
+      if (conflicts.length === 0) {
+        const overwritten = parseOverwrittenFiles(merge.stderr.toString() + merge.stdout.toString())
+        if (overwritten.length > 0) {
+          // Git refused up front — the target working tree was never touched.
+          await restoreSource()
+          return { files: overwritten, kind: 'needs-stash' }
+        }
+      }
       await $`git -C ${targetPath} merge --abort`.quiet().nothrow()
-      await $`git -C ${targetPath} reset --hard HEAD`.quiet().nothrow()
+      // --merge (not --hard): unrelated dirty files in the target must survive.
+      await $`git -C ${targetPath} reset --merge HEAD`.quiet().nothrow()
       await restoreSource()
       if (conflicts.length > 0) return { files: conflicts, kind: 'conflict' }
       const message = merge.stderr.toString().trim()
@@ -89,7 +159,7 @@ export async function moveWorktree(opts: {
 
     const filesChanged = await countStaged(targetPath)
     await restoreSource()
-    return { filesChanged, kind: 'ok' }
+    return { filesChanged, kind: 'ok', stashedTarget }
   } catch (error) {
     return { kind: 'error', message: error instanceof Error ? error.message : String(error) }
   }

package/src/input/modes/bridge.ts

@@ -28,6 +28,7 @@ const MODAL_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
   'update-available': 'modal.update-available',
   'worktree-delete-confirm': 'modal.worktree-delete-confirm',
   'worktree-move': 'modal.worktree-move',
+  'worktree-move-confirm': 'modal.worktree-move-confirm',
 }
 
 export function deriveModeId(state: AppState): ModeId {

package/src/input/modes/transitions.ts

@@ -25,6 +25,7 @@ const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
   'modal.update-available': ['navigation'],
   'modal.worktree-delete-confirm': ['navigation'],
   'modal.worktree-move': ['git-mode', 'navigation'],
+  'modal.worktree-move-confirm': ['navigation'],
   'navigation': [
     'terminal-input',
     'modal.new-tab.command-edit',
@@ -37,6 +38,7 @@ const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
     'modal.update-available',
     'modal.ai-usage',
     'modal.worktree-delete-confirm',
+    'modal.worktree-move-confirm',
     'git-mode',
   ],
   'terminal-input': ['navigation', 'modal.split-picker', 'modal.ai-usage'],

package/src/input/modes/types.ts

@@ -25,6 +25,7 @@ export type ModeId =
   | 'modal.git-commit.generating'
   | 'modal.update-available'
   | 'modal.worktree-move'
+  | 'modal.worktree-move-confirm'
   | 'modal.ai-usage'
 
 export type SideEffect =
@@ -92,7 +93,11 @@ export type SideEffect =
       sourceWorktreeId: string
       targetWorktreeId: string
       deleteSource?: boolean
+      // Retry flags set by the worktree-move-confirm dialog.
+      stashTarget?: boolean
+      keepConflicts?: boolean
     }
+  | { type: 'load-worktree-move-stats' }
   | { type: 'toggle-transparent' }
   | { type: 'toggle-mode' }
   | { type: 'open-file-in-editor'; path: string }

package/src/ipc/manager-protocol.ts

@@ -197,7 +197,15 @@ function isTerminalSnapshot(value: unknown): value is TerminalSnapshot {
     ) &&
     isFiniteNumber(value.viewportY) &&
     isFiniteNumber(value.baseY) &&
-    typeof value.cursorVisible === 'boolean'
+    typeof value.cursorVisible === 'boolean' &&
+    (value.cursorStyle === undefined ||
+      value.cursorStyle === 'block' ||
+      value.cursorStyle === 'underline' ||
+      value.cursorStyle === 'bar' ||
+      value.cursorStyle === 'default') &&
+    (value.cursorBlink === undefined || typeof value.cursorBlink === 'boolean') &&
+    (value.cursorRow === undefined || isFiniteNumber(value.cursorRow)) &&
+    (value.cursorCol === undefined || isFiniteNumber(value.cursorCol))
   )
 }
 

package/src/ipc/protocol.ts

@@ -175,7 +175,15 @@ function isTerminalSnapshot(value: unknown): value is TerminalSnapshot {
     ) &&
     isFiniteNumber(value.viewportY) &&
     isFiniteNumber(value.baseY) &&
-    typeof value.cursorVisible === 'boolean'
+    typeof value.cursorVisible === 'boolean' &&
+    (value.cursorStyle === undefined ||
+      value.cursorStyle === 'block' ||
+      value.cursorStyle === 'underline' ||
+      value.cursorStyle === 'bar' ||
+      value.cursorStyle === 'default') &&
+    (value.cursorBlink === undefined || typeof value.cursorBlink === 'boolean') &&
+    (value.cursorRow === undefined || isFiniteNumber(value.cursorRow)) &&
+    (value.cursorCol === undefined || isFiniteNumber(value.cursorCol))
   )
 }
 

package/src/pty/ghostty-shell-integration.ts

@@ -0,0 +1,34 @@
+import { existsSync } from 'node:fs'
+import { basename, join } from 'node:path'
+
+export type PtyEnv = Record<string, string>
+
+/**
+ * Replicate Ghostty's automatic shell-integration injection for the nested
+ * shells aimux spawns. Ghostty only performs it for shells it launches
+ * directly (by pointing ZDOTDIR at its integration dir, whose .zshenv
+ * restores the user's ZDOTDIR and then loads the integration), so aimux
+ * panes would otherwise miss the integration's zle hooks — notably the
+ * DECSCUSR cursor-shape reporting (bar at prompt, block in vicmd) that the
+ * hardware-cursor pass-through relies on for native-parity rendering.
+ */
+export function applyGhosttyShellIntegration(
+  env: PtyEnv,
+  command: string,
+  integrationFileExists: (path: string) => boolean = existsSync
+): PtyEnv {
+  const resourcesDir = env.GHOSTTY_RESOURCES_DIR
+  if (resourcesDir === undefined || resourcesDir === '') return env
+  // bash and fish use different bootstrap mechanisms; only zsh is supported.
+  if (basename(command) !== 'zsh') return env
+
+  const integrationDir = join(resourcesDir, 'shell-integration', 'zsh')
+  if (env.ZDOTDIR === integrationDir) return env
+  if (!integrationFileExists(join(integrationDir, '.zshenv'))) return env
+
+  const next: PtyEnv = { ...env, ZDOTDIR: integrationDir }
+  if (env.ZDOTDIR !== undefined && env.ZDOTDIR !== '') {
+    next.GHOSTTY_ZSH_ZDOTDIR = env.ZDOTDIR
+  }
+  return next
+}

package/src/pty/pty-manager.ts

@@ -2,9 +2,15 @@ import { Terminal as XTerm } from '@xterm/headless'
 import { type IPty, spawn } from 'bun-pty'
 import { EventEmitter } from 'node:events'
 
-import type { ScrollIntent, TerminalModeState, TerminalSnapshot } from '../state/types'
+import type {
+  ScrollIntent,
+  TerminalCursorStyle,
+  TerminalModeState,
+  TerminalSnapshot,
+} from '../state/types'
 
 import { logDebug } from '../debug/input-log'
+import { applyGhosttyShellIntegration } from './ghostty-shell-integration'
 import { areTerminalSnapshotsEqual, snapshotTerminal } from './terminal-snapshot'
 
 interface PtyManagerEvents {
@@ -21,6 +27,10 @@ interface SessionHandle {
   lastTerminalModes?: TerminalModeState
   alternateScrollMode: boolean
   cursorVisible: boolean
+  /** Last DECSCUSR shape; 'default' = the host terminal's configured cursor. */
+  cursorStyle: TerminalCursorStyle
+  /** Last DECSCUSR blink flag; undefined until an explicit DECSCUSR arrives. */
+  cursorBlink: boolean | undefined
   pendingModeSequence: string
   pendingWrites: number
   pendingExitCode: number | null
@@ -75,6 +85,28 @@ function trackPrivateModes(
   }
 }
 
+// DECSCUSR (CSI Ps SP q): 0 resets to the terminal's configured cursor,
+// odd values blink, 1/2 = block, 3/4 = underline, 5/6 = bar.
+const DECSCUSR_STYLES: readonly TerminalCursorStyle[] = [
+  'block',
+  'block',
+  'underline',
+  'underline',
+  'bar',
+  'bar',
+]
+
+function decscusrToCursorState(ps: number): {
+  cursorStyle: TerminalCursorStyle
+  cursorBlink: boolean | undefined
+} {
+  const style = DECSCUSR_STYLES[ps - 1]
+  if (ps === 0 || style === undefined) {
+    return { cursorBlink: undefined, cursorStyle: 'default' }
+  }
+  return { cursorBlink: ps % 2 === 1, cursorStyle: style }
+}
+
 function getTerminalModes(emulator: XTerm, alternateScrollMode: boolean): TerminalModeState {
   return {
     alternateScrollMode,
@@ -192,7 +224,11 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
 
   private emitRenderIfChanged(session: SessionHandle): void {
     if (!this.broadcastEnabled) return
-    const nextSnapshot = snapshotTerminal(session.emulator, session.cursorVisible)
+    const nextSnapshot = snapshotTerminal(session.emulator, {
+      cursorBlink: session.cursorBlink,
+      cursorStyle: session.cursorStyle,
+      cursorVisible: session.cursorVisible,
+    })
     const nextTerminalModes = getTerminalModes(session.emulator, session.alternateScrollMode)
     const snapshotChanged = !areTerminalSnapshotsEqual(session.lastSnapshot, nextSnapshot)
     const modesChanged =
@@ -259,21 +295,28 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
         scrollback: 1000,
       })
 
-      const pty = spawn(options.command, options.args ?? [], {
-        cols: options.cols,
-        cwd: options.cwd ?? process.cwd(),
-        env: {
+      const env = applyGhosttyShellIntegration(
+        {
           ...process.env,
           COLORTERM: 'truecolor',
           TERM: 'xterm-256color',
           ...options.env,
         },
+        options.command
+      )
+
+      const pty = spawn(options.command, options.args ?? [], {
+        cols: options.cols,
+        cwd: options.cwd ?? process.cwd(),
+        env,
         name: 'xterm-256color',
         rows: options.rows,
       })
 
       const session: SessionHandle = {
         alternateScrollMode: false,
+        cursorBlink: undefined,
+        cursorStyle: 'default',
         cursorVisible: true,
         emulator,
         lastScrollIntent: undefined,
@@ -287,6 +330,17 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
         tabId: options.tabId,
       }
 
+      // xterm parses DECSCUSR itself but keeps the result in private state;
+      // mirror it here so snapshots can carry the shape to the renderer.
+      // Returning false lets xterm's own handler still run.
+      emulator.parser.registerCsiHandler({ final: 'q', intermediates: ' ' }, (params) => {
+        const raw = params[0]
+        const tracked = decscusrToCursorState(typeof raw === 'number' ? raw : 0)
+        session.cursorStyle = tracked.cursorStyle
+        session.cursorBlink = tracked.cursorBlink
+        return false
+      })
+
       pty.onData((data) => {
         logDebug('ptyManager.data', {
           byteLength: Buffer.byteLength(data, 'utf8'),

package/src/pty/terminal-snapshot.ts

@@ -1,6 +1,11 @@
 import type { Terminal } from '@xterm/headless'
 
-import type { TerminalLine, TerminalSnapshot, TerminalSpan } from '../state/types'
+import type {
+  TerminalCursorStyle,
+  TerminalLine,
+  TerminalSnapshot,
+  TerminalSpan,
+} from '../state/types'
 
 import { getCurrentTheme } from '../ui/theme'
 
@@ -95,14 +100,10 @@ function buildLine(
       bg = resolvedFg
     }
 
+    // The cursor cell is only flagged here; how it renders (soft inverted
+    // block vs. the host terminal's hardware cursor) is a presentation
+    // decision made in the renderer process (terminal-pane.tsx).
     const isCursorCell = cursorVisible && cursorColumn === column
-    if (isCursorCell) {
-      const tokens = getCurrentTheme()
-      const resolvedFg: CellColor = fg ?? { hex: tokens.text, kind: 'rgb' }
-      const resolvedBg: CellColor = bg ?? { hex: tokens.background, kind: 'rgb' }
-      fg = resolvedBg
-      bg = resolvedFg
-    }
 
     const span: TerminalSpan = {
       bold: current.isBold() ? true : undefined,
@@ -143,11 +144,8 @@ function buildLine(
       if (leading > 0) {
         pushSpan(spans, { text: ' '.repeat(leading) })
       }
-      const tokens = getCurrentTheme()
       pushSpan(spans, {
-        bg: tokens.text,
         cursor: true,
-        fg: tokens.background,
         text: ' ',
       })
       if (trailing > 0) {
@@ -161,7 +159,17 @@ function buildLine(
   return { spans }
 }
 
-export function snapshotTerminal(terminal: Terminal, cursorVisible = true): TerminalSnapshot {
+export interface SnapshotCursorOptions {
+  cursorVisible: boolean
+  cursorStyle?: TerminalCursorStyle
+  cursorBlink?: boolean
+}
+
+export function snapshotTerminal(
+  terminal: Terminal,
+  cursorOptions: SnapshotCursorOptions = { cursorVisible: true }
+): TerminalSnapshot {
+  const { cursorBlink, cursorStyle, cursorVisible } = cursorOptions
   const buffer = terminal.buffer.active
   const startLine = buffer.viewportY
   const tailStartLine = Math.max(0, buffer.baseY + terminal.rows - SNAPSHOT_TAIL_LINE_COUNT)
@@ -201,6 +209,10 @@ export function snapshotTerminal(terminal: Terminal, cursorVisible = true): Term
 
   return {
     baseY: buffer.baseY,
+    cursorBlink,
+    cursorCol: cursorColumn,
+    cursorRow: cursorLine - buffer.viewportY,
+    cursorStyle,
     cursorVisible,
     lines,
     tailLines,
@@ -255,7 +267,11 @@ export function areTerminalSnapshotsEqual(
   if (
     left.viewportY !== right.viewportY ||
     left.baseY !== right.baseY ||
-    left.cursorVisible !== right.cursorVisible
+    left.cursorVisible !== right.cursorVisible ||
+    left.cursorStyle !== right.cursorStyle ||
+    left.cursorBlink !== right.cursorBlink ||
+    left.cursorRow !== right.cursorRow ||
+    left.cursorCol !== right.cursorCol
   ) {
     return false
   }

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

@@ -304,6 +304,7 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           selectedIndex: 0,
           sessionTargetId: null,
           sourceWorktreeId: action.sourceWorktreeId,
+          stats: { kind: 'loading' },
           type: 'worktree-move',
         },
       }
@@ -315,6 +316,33 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         modal: { ...state.modal, deleteSource: !state.modal.deleteSource },
       }
     }
+    case 'set-worktree-move-stats': {
+      if (state.modal.type !== 'worktree-move') return state
+      return {
+        ...state,
+        modal: { ...state.modal, stats: { dirtyFiles: action.dirtyFiles, kind: 'ready' } },
+      }
+    }
+    case 'open-worktree-move-confirm': {
+      return {
+        ...state,
+        focusMode: 'modal',
+        modal: {
+          deleteSource: action.deleteSource,
+          editBuffer: null,
+          files: action.files,
+          selectedIndex: 0,
+          sessionId: action.sessionId,
+          sessionTargetId: null,
+          sourceLabel: action.sourceLabel,
+          sourceWorktreeId: action.sourceWorktreeId,
+          targetLabel: action.targetLabel,
+          targetWorktreeId: action.targetWorktreeId,
+          type: 'worktree-move-confirm',
+          variant: action.variant,
+        },
+      }
+    }
     case 'open-worktree-delete-confirm': {
       return {
         ...state,

package/src/state/types.ts

@@ -47,6 +47,7 @@ export type ModalType =
   | 'update-available'
   | 'ai-usage'
   | 'worktree-move'
+  | 'worktree-move-confirm'
   | 'worktree-delete-confirm'
   | null
 
@@ -72,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
@@ -421,6 +432,26 @@ 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
 }
 
 /**
@@ -462,6 +493,7 @@ export type ModalState =
   | ModalUpdateAvailable
   | ModalAIUsage
   | ModalWorktreeMove
+  | ModalWorktreeMoveConfirm
   | ModalWorktreeDeleteConfirm
 
 export interface LayoutState {
@@ -576,6 +608,18 @@ 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

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

package/src/ui/components/modals/worktree/worktree-move-confirm-modal.tsx

@@ -0,0 +1,65 @@
+import { useTheme } from '../../../theme'
+import { uiTokens } from '../../../ui-tokens'
+import { Form } from '../shared/form'
+
+interface WorktreeMoveConfirmModalProps {
+  variant: 'stash-target' | 'keep-conflicts'
+  files: string[]
+  sourceLabel: string
+  targetLabel: string
+}
+
+const MAX_LISTED_FILES = 8
+
+/**
+ * Confirmation dialog after a recoverable move failure. Both worktrees are
+ * already back in their original state; confirming re-runs the move with the
+ * flag matching the variant (stash the target's changes / keep the conflict
+ * markers in the target).
+ */
+export function WorktreeMoveConfirmModal({
+  files,
+  sourceLabel,
+  targetLabel,
+  variant,
+}: WorktreeMoveConfirmModalProps) {
+  const t = useTheme()
+  const listed = files.slice(0, MAX_LISTED_FILES)
+  const remaining = files.length - listed.length
+  const isStash = variant === 'stash-target'
+  return (
+    <Form
+      title={isStash ? 'Target has conflicting changes' : 'Move hit conflicts'}
+      keybindsModeId="modal.worktree-move-confirm"
+      width={uiTokens.modalWidth.md}
+      footer={
+        <text fg={t.textMuted}>
+          {isStash
+            ? 'Enter / y to stash & move · Esc / n to cancel'
+            : 'Enter / y to keep markers · Esc / n to cancel'}
+        </text>
+      }
+    >
+      <box flexDirection="column" gap={1}>
+        <text fg={t.text}>
+          {isStash
+            ? `${targetLabel} has uncommitted changes that the move would overwrite:`
+            : `Merging ${sourceLabel} into ${targetLabel} conflicts in ${files.length} file(s):`}
+        </text>
+        <box flexDirection="column">
+          {listed.map((file) => (
+            <text key={file} fg={t.warning} wrapMode="none">
+              {file}
+            </text>
+          ))}
+          {remaining > 0 ? <text fg={t.textMuted}>+{remaining} more</text> : null}
+        </box>
+        <text fg={t.text}>
+          {isStash
+            ? 'Stash them and continue? The stash is kept — recover with git stash pop.'
+            : `Keep conflict markers in ${targetLabel} for manual resolution? ${sourceLabel} stays untouched either way.`}
+        </text>
+      </box>
+    </Form>
+  )
+}

package/src/ui/components/modals/worktree/worktree-move-modal.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useMemo } from 'react'
 
-import type { WorktreeRecord } from '../../../../state/types'
+import type { ModalWorktreeMove, WorktreeRecord } from '../../../../state/types'
 
 import { dispatchGlobal } from '../../../../state/dispatch-ref'
 import { formatDivergence } from '../../../../state/session-worktrees'
@@ -14,6 +14,7 @@ interface WorktreeMoveModalProps {
   divergence: Record<string, { ahead: number; behind: number }>
   selectedIndex: number
   sourceWorktreeId: string
+  stats: ModalWorktreeMove['stats']
   worktrees: WorktreeRecord[]
 }
 
@@ -29,6 +30,7 @@ export function WorktreeMoveModal({
   divergence,
   selectedIndex,
   sourceWorktreeId,
+  stats,
   worktrees,
 }: WorktreeMoveModalProps) {
   const t = useTheme()
@@ -42,6 +44,18 @@ export function WorktreeMoveModal({
   )
   const sourceLabel =
     source?.branch != null && source.branch !== '' ? source.branch : (source?.name ?? 'worktree')
+  // What the move would carry: commits ahead of the fork point (when known) plus
+  // uncommitted files, loaded async after the modal opens.
+  const sourcePreview = useMemo(() => {
+    const parts: string[] = []
+    const ahead = divergence[sourceWorktreeId]?.ahead ?? 0
+    if (ahead > 0) parts.push(`${ahead} commit(s)`)
+    if (stats.kind === 'ready') {
+      const dirty = stats.dirtyFiles[sourceWorktreeId] ?? 0
+      if (dirty > 0) parts.push(`${dirty} uncommitted file(s)`)
+    }
+    return parts.join(' · ')
+  }, [divergence, sourceWorktreeId, stats])
   const handleSelectIndex = useCallback(
     (index: number) => dispatchGlobal({ index, type: 'set-modal-selection-index' }),
     []
@@ -71,6 +85,7 @@ export function WorktreeMoveModal({
       }
     >
       <box flexDirection="column" marginTop={1}>
+        {sourcePreview !== '' ? <text fg={t.textMuted}>will move: {sourcePreview}</text> : null}
         {targets.length === 0 ? (
           <text fg={t.textMuted}>No other worktree to move into.</text>
         ) : (
@@ -79,6 +94,7 @@ export function WorktreeMoveModal({
             const label =
               worktree.branch != null && worktree.branch !== '' ? worktree.branch : worktree.name
             const ahead = formatDivergence(divergence[worktree.id])
+            const dirty = stats.kind === 'ready' && (stats.dirtyFiles[worktree.id] ?? 0) > 0
             return (
               <ListItem
                 key={worktree.id}
@@ -92,6 +108,7 @@ export function WorktreeMoveModal({
                     {label}
                     {worktree.source === 'primary' ? ' (primary)' : ''}
                     {ahead !== '' ? ` ${ahead}` : ''}
+                    {dirty ? <span fg={t.warning}> ●</span> : null}
                   </text>
                 }
               />

package/src/ui/root.tsx

@@ -39,6 +39,7 @@ import { SnippetEditorModal } from './components/modals/snippets/snippet-editor-
 import { SnippetPickerModal } from './components/modals/snippets/snippet-picker-modal'
 import { NewTabModal } from './components/modals/tabs/new-tab-modal'
 import { ThemePickerModal } from './components/modals/themes/theme-picker-modal'
+import { WorktreeMoveConfirmModal } from './components/modals/worktree/worktree-move-confirm-modal'
 import { WorktreeMoveModal } from './components/modals/worktree/worktree-move-modal'
 import { ContextMenuBox } from './components/overlays/context-menu/context-menu-box'
 import { ContextMenuOverlay } from './components/overlays/context-menu/context-menu-overlay'
@@ -214,10 +215,20 @@ function renderModal(
           divergence={options.worktreeDivergence}
           selectedIndex={modal.selectedIndex}
           sourceWorktreeId={modal.sourceWorktreeId}
+          stats={modal.stats}
           worktrees={session?.worktrees ?? EMPTY_WORKTREES}
         />
       )
     }
+    case 'worktree-move-confirm':
+      return (
+        <WorktreeMoveConfirmModal
+          variant={modal.variant}
+          files={modal.files}
+          sourceLabel={modal.sourceLabel}
+          targetLabel={modal.targetLabel}
+        />
+      )
     case 'help':
       return (
         <HelpModal

package/src/ui/status-bar-model.ts

@@ -133,6 +133,8 @@ function deriveModalModeId(modalType: AppState['modal']['type']): ModeId | null
       return 'modal.update-available'
     case 'worktree-move':
       return 'modal.worktree-move'
+    case 'worktree-move-confirm':
+      return 'modal.worktree-move-confirm'
     default:
       return null
   }