@brimveyn/aimux 1.23.6 → 1.24.0

package/package.json

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

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

@@ -10,6 +10,7 @@ import {
   getAssistantOption,
   isCommandAvailable,
   parseCommand,
+  stripInjectedSessionArgs,
 } from '../pty/command-registry'
 import { createTerminalBounds } from '../state/layout-resize'
 import {
@@ -116,6 +117,11 @@ export function startTabSession(
   ctx.startStartupGrace(tab.id, STARTUP_GRACE_MS)
 
   const { args, executable } = parseCommand(tab.command)
+  // `tab.command` is not always the string this client wrote: a hydrate from the
+  // daemon (or a snapshot taken after one) hands back the whole argv of the last
+  // spawn, session flags included. Strip ours back out before adding this
+  // spawn's, or claude exits on the duplicate and takes the tab with it.
+  const baseArgs = stripInjectedSessionArgs(tab.assistant, ctx.state.customCommands, args)
   // Ahead of `extraArgs` because that is where an initial prompt goes, and the
   // prompt is positional — a flag after it would be read as part of it.
   const sessionArgs =
@@ -134,7 +140,7 @@ export function startTabSession(
   }
 
   backend.createSession({
-    args: [...args, ...sessionArgs, ...(extraArgs ?? [])],
+    args: [...baseArgs, ...sessionArgs, ...(extraArgs ?? [])],
     assistant: tab.assistant,
     autoRenameCandidate,
     cols,

package/src/input/keymap/key-chord.ts

@@ -11,8 +11,11 @@ export type KeyChord = string
 const SPECIAL_NAMES: Record<string, string> = {
   BS: 'backspace',
   CR: 'return',
+  Del: 'delete',
   Down: 'down',
+  End: 'end',
   Esc: 'escape',
+  Home: 'home',
   Left: 'left',
   Right: 'right',
   Space: 'space',
@@ -38,6 +41,12 @@ export function keyInputToChord(key: KeyInput): KeyChord {
   let prefix = ''
   if (ctrl) prefix += 'C-'
   if (meta) prefix += 'M-'
+  // Only for named keys. On a single character shift is already in the character
+  // itself (handled above), so an `S-` there would be a chord nothing produces.
+  // Whether Shift+Enter arrives at all is the terminal's call — it needs the
+  // kitty keyboard protocol or modifyOtherThanKeys to report the modifier, and
+  // where it does not the Ctrl+Enter binding beside it still fires.
+  if (shift && baseName.length > 1) prefix += 'S-'
 
   return `${prefix}${baseName}`
 }
@@ -136,6 +145,7 @@ function parseAngleBracketToken(inner: string): KeyChord {
   let prefix = ''
   if (ctrl) prefix += 'C-'
   if (meta) prefix += 'M-'
+  if (shift && keyName.length > 1) prefix += 'S-'
 
   return `${prefix}${keyName}`
 }

package/src/input/keymap/key-format.ts

@@ -2,8 +2,11 @@ import { type KeyChord, parseKeyNotation } from './key-chord'
 
 const SPECIAL_DISPLAY: Record<string, string> = {
   backspace: 'Backspace',
+  delete: 'Del',
   down: '↓',
+  end: 'End',
   escape: 'Esc',
+  home: 'Home',
   left: '←',
   return: 'Enter',
   right: '→',
@@ -25,6 +28,10 @@ export function formatChord(chord: KeyChord, leader?: KeyChord): string {
 
   let ctrl = false
   let meta = false
+  // Shift rides as an `S-` prefix on named keys (`S-return`), and as an
+  // uppercase letter on the rest. Both end up as "Shift+…" here; without this
+  // the help overlay printed the raw chord.
+  let shift = false
   let rest = chord
 
   while (true) {
@@ -38,10 +45,15 @@ export function formatChord(chord: KeyChord, leader?: KeyChord): string {
       rest = rest.slice(2)
       continue
     }
+    if (rest.startsWith('S-')) {
+      shift = true
+      rest = rest.slice(2)
+      continue
+    }
     break
   }
 
-  if (!ctrl && !meta) {
+  if (!ctrl && !meta && !shift) {
     if (rest.length === 1 && /^[A-Z]$/.test(rest)) {
       return `Shift+${rest}`
     }
@@ -51,6 +63,7 @@ export function formatChord(chord: KeyChord, leader?: KeyChord): string {
   const parts: string[] = []
   if (ctrl) parts.push('Ctrl')
   if (meta) parts.push('Alt')
+  if (shift) parts.push('Shift')
   parts.push(formatModifierKey(rest))
   return parts.join('+')
 }

package/src/input/modes/handlers/shared.ts

@@ -40,11 +40,59 @@ export function handleModalSelectionKeys(
   return null
 }
 
+/**
+ * Cursor motion for a key no binding claimed.
+ *
+ * Every modal that accepts typing is a `passthrough()` mode, and this is the one
+ * function they all fall through to — so a motion added here reaches every text
+ * field in the app at once, without a binding per modal. The modals that do bind
+ * an arrow (the update prompt's row of buttons, the git and settings screens)
+ * resolve it before it ever gets here.
+ */
+function handleCursorMotion(key: KeyInput): KeyResult | null {
+  const word = key.ctrl || key.meta
+  switch (key.name) {
+    case 'left':
+      return result([
+        word
+          ? { to: 'word-left', type: 'move-modal-cursor' }
+          : { delta: -1, type: 'move-modal-cursor' },
+      ])
+    case 'right':
+      return result([
+        word
+          ? { to: 'word-right', type: 'move-modal-cursor' }
+          : { delta: 1, type: 'move-modal-cursor' },
+      ])
+    case 'home':
+      return result([{ to: 'home', type: 'move-modal-cursor' }])
+    case 'end':
+      return result([{ to: 'end', type: 'move-modal-cursor' }])
+    // Only reached in a modal that leaves Up/Down unbound — the ones that drive a
+    // list with them hand their own action a `moveModalCursorInField` fallback.
+    case 'up':
+      return result([{ to: 'line-up', type: 'move-modal-cursor' }])
+    case 'down':
+      return result([{ to: 'line-down', type: 'move-modal-cursor' }])
+    default:
+      return null
+  }
+}
+
 export function handleTextInput(key: KeyInput): KeyResult | null {
+  const motion = handleCursorMotion(key)
+  if (motion) return motion
+
   if (key.name === 'backspace') {
     return result([{ char: '\b', type: 'update-command-edit' }])
   }
 
+  // DEL, the counterpart to backspace: both are commands rather than text
+  // because neither can arrive as a typed character.
+  if (key.name === 'delete') {
+    return result([{ char: '\x7f', type: 'update-command-edit' }])
+  }
+
   if (key.name === 'space') {
     return result([{ char: ' ', type: 'update-command-edit' }])
   }

package/src/pty/command-registry.ts

@@ -251,6 +251,41 @@ export function buildAssistantSessionArgs(
     : option.session.buildSessionArgs(sessionId)
 }
 
+const SESSION_FLAG = /^(?:-r|--resume|--session-id)$/
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+/**
+ * Drop the session flags an earlier spawn left inside `tab.command`.
+ *
+ * The daemon stores its tabs as `[command, ...args].join(' ')`, so a client that
+ * hydrated from it — or a snapshot written by one — carries this tab's own
+ * `--session-id <uuid>` in the string the next spawn parses. Re-spawning that
+ * verbatim is `Error: Session ID … is already in use`, and an exiting PTY takes
+ * the tab with it.
+ *
+ * Only a uuid-shaped value is ours, and only when the user's own custom command
+ * does not declare that flag — a `--resume` they wrote themselves is theirs to
+ * keep, and `buildAssistantSessionArgs` already stands aside for it.
+ */
+export function stripInjectedSessionArgs(
+  assistant: AssistantId,
+  customCommands: Record<string, string>,
+  args: string[]
+): string[] {
+  const custom = customCommands[assistant] ?? ''
+  if (/(^|\s)(-r|--resume|--session-id|--continue|-c)(\s|$)/.test(custom)) return args
+  const kept: string[] = []
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i] as string
+    if (SESSION_FLAG.test(arg) && UUID.test(args[i + 1] ?? '')) {
+      i++
+      continue
+    }
+    kept.push(arg)
+  }
+  return kept
+}
+
 export function isCommandAvailable(command: string): boolean {
   return Bun.which(command) !== null
 }

package/src/state/actions.ts

@@ -7,6 +7,7 @@
 import type { ModeId } from '@brimveyn/aimux-config'
 
 import type { LayoutNode, SplitDirection } from './layout-tree'
+import type { CursorTarget } from './text-cursor'
 import type {
   AssistantId,
   BarSide,
@@ -32,7 +33,7 @@ import type {
 } from './types'
 
 export type ModalAction =
-  | { type: 'move-modal-cursor'; delta?: number; to?: 'home' | 'end' }
+  | { type: 'move-modal-cursor'; delta?: number; to?: CursorTarget }
   | {
       type: 'open-new-tab-modal'
       pendingWorkspace?: PendingWorkspaceLaunch

package/src/state/project-persistence.ts

@@ -106,6 +106,21 @@ function pruneOrphanedTabs(
   )
 }
 
+/**
+ * Recover a session id a snapshot lost. Until the client stopped adopting the
+ * daemon's tabs wholesale, `sessionId` was wiped on every attach while the
+ * daemon's argv echo left the uuid sitting in `command` — so the conversation
+ * these tabs own is still recoverable from the very string that broke them.
+ *
+ * ponytail: a migration, not a mechanism. Delete it once no snapshot in the
+ * wild predates the fix.
+ */
+function recoverSessionId(command: string): string | undefined {
+  return /(?:^|\s)(?:-r|--resume|--session-id)\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:\s|$)/i.exec(
+    command
+  )?.[1]
+}
+
 export function restoreTabsFromProject(
   snapshot: ProjectSnapshotV1 | undefined,
   options: RestoreOptions = {}
@@ -130,7 +145,7 @@ export function restoreTabsFromProject(
       errorMessage: tab.errorMessage,
       exitCode: tab.exitCode,
       id: tab.id,
-      sessionId: tab.sessionId,
+      sessionId: tab.sessionId ?? recoverSessionId(tab.command),
       status: forceDisconnected ? getDisconnectedStatus(tab.status) : tab.status,
       terminalModes: tab.terminalModes,
       title: tab.title,

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

@@ -16,6 +16,7 @@ import {
   filterSnippets,
   getNewTabAssistantOptions,
 } from '../selectors'
+import { applyEdit, moveCursor } from '../text-cursor'
 import { reduceGitCommitModalState } from './git-commit-modal-state'
 
 function emptyModal() {
@@ -106,6 +107,19 @@ function getCreateWorkspaceFieldValue(
   return field === 'prompt' ? modal.prompt : modal.baseQuery
 }
 
+/**
+ * The buffer a cursor motion applies to. Every modal but one keeps the field it
+ * is editing in `editBuffer` — the multi-field ones (snippet editor, commit
+ * message) swap it on Tab — so that is the default. Create-workspace is the
+ * exception: its two fields are named, and neither is `editBuffer`.
+ */
+function getModalCursorText(state: AppState): string | null {
+  if (state.modal.type === 'create-workspace') {
+    return getCreateWorkspaceFieldValue(state.modal, state.modal.activeField)
+  }
+  return state.modal.editBuffer
+}
+
 export function reduceModalState(state: AppState, action: AppAction): AppState | null {
   // The one modal with a stage machine of its own, in its own file.
   const gitCommit = reduceGitCommitModalState(state, action)
@@ -604,14 +618,10 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
       return { ...state, modal: { ...state.modal, selectedIndex: clamped } }
     }
     case 'move-modal-cursor': {
-      if (state.modal.editBuffer === null) return state
-      const len = state.modal.editBuffer.length
-      const current = state.modal.cursorPos ?? len
-      let next = current
-      if (action.to === 'home') next = 0
-      else if (action.to === 'end') next = len
-      else if (typeof action.delta === 'number') next = current + action.delta
-      next = clampCursor(next, len)
+      const text = getModalCursorText(state)
+      if (text === null) return state
+      const current = clampCursor(state.modal.cursorPos ?? text.length, text.length)
+      const next = moveCursor(text, current, action)
       if (next === current) return state
       return { ...state, modal: { ...state.modal, cursorPos: next } }
     }
@@ -656,16 +666,9 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         const field = state.modal.activeField
         const current = getCreateWorkspaceFieldValue(state.modal, field)
         const at = clampCursor(state.modal.cursorPos ?? current.length, current.length)
-        let text: string
-        let pos: number
-        if (action.char === '\b') {
-          if (at === 0) return state
-          text = current.slice(0, at - 1) + current.slice(at)
-          pos = at - 1
-        } else {
-          text = current.slice(0, at) + action.char + current.slice(at)
-          pos = at + action.char.length
-        }
+        const edit = applyEdit(current, at, action.char)
+        if (edit === null) return state
+        const { pos, text } = edit
         if (field === 'prompt') {
           return {
             ...state,
@@ -690,16 +693,9 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
       }
       const buffer = state.modal.editBuffer
       const cursor = clampCursor(state.modal.cursorPos ?? buffer.length, buffer.length)
-      let nextBuffer: string
-      let nextCursor: number
-      if (action.char === '\b') {
-        if (cursor === 0) return state
-        nextBuffer = buffer.slice(0, cursor - 1) + buffer.slice(cursor)
-        nextCursor = cursor - 1
-      } else {
-        nextBuffer = buffer.slice(0, cursor) + action.char + buffer.slice(cursor)
-        nextCursor = cursor + action.char.length
-      }
+      const edit = applyEdit(buffer, cursor, action.char)
+      if (edit === null) return state
+      const { pos: nextCursor, text: nextBuffer } = edit
       const isNewTabEditing = state.modal.type === 'new-tab' && state.modal.editingCommand !== null
       const resetIndex =
         !isNewTabEditing &&

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

@@ -357,7 +357,18 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         state.currentProjectId != null && state.currentProjectId !== ''
           ? state.projects.find((s) => s.id === state.currentProjectId)
           : undefined
-      const visibleForWorkspace = filterTabsForActiveWorkspace(action.tabs, currentProject)
+      // The daemon rebuilds `command` as `[command, ...args].join(' ')` and has
+      // no `sessionId` on the wire at all. Adopting its tabs wholesale bakes this
+      // spawn's `--session-id <uuid>` into the string the *next* spawn parses —
+      // claude exits on "Session ID … is already in use" and takes the tab with
+      // it — and drops the id the resume depends on. Both fields belong to the
+      // client, so keep what it already holds for the tabs it knows.
+      const ownedById = new Map(state.tabs.map((entry) => [entry.id, entry]))
+      const hydratedTabs = action.tabs.map((entry) => {
+        const owned = ownedById.get(entry.id)
+        return owned ? { ...entry, command: owned.command, sessionId: owned.sessionId } : entry
+      })
+      const visibleForWorkspace = filterTabsForActiveWorkspace(hydratedTabs, currentProject)
       const visibleIds = new Set(visibleForWorkspace.map((t) => t.id))
       const hydratedActiveTabId =
         action.activeTabId != null &&
@@ -365,7 +376,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         visibleIds.has(action.activeTabId)
           ? action.activeTabId
           : (visibleForWorkspace[0]?.id ?? null)
-      const tabIds = new Set(action.tabs.map((t) => t.id))
+      const tabIds = new Set(hydratedTabs.map((t) => t.id))
 
       // Restore from new multi-tree format or migrate from legacy single tree
       const hydratedTrees: Record<string, LayoutNode> = {}
@@ -402,7 +413,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
           focusMode: 'navigation',
           layoutTrees: hydratedTrees,
           tabGroupMap: hydratedGroupMap,
-          tabs: normalizeGroupedTabOrder(action.tabs, hydratedTrees, hydratedGroupMap),
+          tabs: normalizeGroupedTabOrder(hydratedTabs, hydratedTrees, hydratedGroupMap),
         },
         hydratedActiveTabId,
         { onlyIfMissing: true }

package/src/state/text-cursor.ts

@@ -0,0 +1,117 @@
+/**
+ * Cursor motion inside a modal's text buffer.
+ *
+ * Pure string maths, kept out of the reducer so it can be read and tested on its
+ * own — the reducer only decides *which* buffer a motion applies to.
+ *
+ * ponytail: lines are `\n`-delimited, not visually wrapped. A paragraph that the
+ * input box soft-wraps over three rows is one line here, so Up/Down step over
+ * the whole paragraph. Fixing that means the motion needs the box's width, which
+ * lives in the renderer, not the store — worth doing only if the wrapped fields
+ * ever get long enough for it to bite.
+ */
+
+/** Where a motion wants to go. `home`/`end` are line-wise, so they do the right thing in a one-line field too. */
+export type CursorTarget = 'end' | 'home' | 'line-down' | 'line-up' | 'word-left' | 'word-right'
+
+function clamp(value: number, max: number): number {
+  return Math.max(0, Math.min(max, value))
+}
+
+/**
+ * The `[start, end)` of the line `at` sits on. `end` is the newline's index (or
+ * the buffer's length on the last line), so it is where `End` parks.
+ */
+function lineBounds(text: string, at: number): { end: number; start: number } {
+  // `lastIndexOf` clamps a negative `fromIndex` to 0, which would find a leading
+  // newline and put the start one past it — so column 0 is answered directly.
+  const start = at === 0 ? 0 : text.lastIndexOf('\n', at - 1) + 1
+  const newline = text.indexOf('\n', at)
+  return { end: newline === -1 ? text.length : newline, start }
+}
+
+const isWordChar = (ch: string | undefined): boolean => ch !== undefined && /\S/.test(ch)
+
+/** Left edge of the word before the cursor: skip the gap, then the word. */
+function wordLeft(text: string, at: number): number {
+  let i = at
+  while (i > 0 && !isWordChar(text[i - 1])) i--
+  while (i > 0 && isWordChar(text[i - 1])) i--
+  return i
+}
+
+/** Right edge of the word after the cursor, by the same rule. */
+function wordRight(text: string, at: number): number {
+  let i = at
+  while (i < text.length && !isWordChar(text[i])) i++
+  while (i < text.length && isWordChar(text[i])) i++
+  return i
+}
+
+/** The same column on the line above, or as near to it as that line reaches. */
+function lineUp(text: string, at: number): number {
+  const { start } = lineBounds(text, at)
+  // Already on the first line: Up parks at its start rather than doing nothing,
+  // which is what every editor does with it.
+  if (start === 0) return 0
+  const previous = lineBounds(text, start - 1)
+  return Math.min(previous.start + (at - start), previous.end)
+}
+
+/** The same column on the line below. */
+function lineDown(text: string, at: number): number {
+  const { end, start } = lineBounds(text, at)
+  if (end === text.length) return text.length
+  const next = lineBounds(text, end + 1)
+  return Math.min(next.start + (at - start), next.end)
+}
+
+/** Resolve one motion against `text`, clamped to it. */
+export function moveCursor(
+  text: string,
+  at: number,
+  motion: { delta?: number; to?: CursorTarget }
+): number {
+  const from = clamp(at, text.length)
+  if (motion.to === undefined) {
+    return clamp(from + (motion.delta ?? 0), text.length)
+  }
+  switch (motion.to) {
+    case 'home':
+      return lineBounds(text, from).start
+    case 'end':
+      return lineBounds(text, from).end
+    case 'word-left':
+      return wordLeft(text, from)
+    case 'word-right':
+      return wordRight(text, from)
+    case 'line-up':
+      return lineUp(text, from)
+    case 'line-down':
+      return lineDown(text, from)
+    default:
+      motion.to satisfies never
+      return from
+  }
+}
+
+/**
+ * Apply one edit at the cursor. `\b` deletes behind it, `\x7f` in front of it —
+ * neither can arrive as typed text, which is why they double as the two commands.
+ */
+export function applyEdit(
+  text: string,
+  at: number,
+  char: string
+): { pos: number; text: string } | null {
+  const from = clamp(at, text.length)
+  if (char === '\b') {
+    if (from === 0) return null
+    return { pos: from - 1, text: text.slice(0, from - 1) + text.slice(from) }
+  }
+  if (char === '\x7f') {
+    if (from === text.length) return null
+    return { pos: from, text: text.slice(0, from) + text.slice(from + 1) }
+  }
+  return { pos: from + char.length, text: text.slice(0, from) + char + text.slice(from) }
+}

package/src/ui/breaking-update-screen.tsx

@@ -2,6 +2,7 @@ import { useKeyboard } from '@opentui/react'
 
 import { ModalShell } from './components/modals/shared/modal-shell'
 import { ListItem } from './components/primitives/list-item'
+import { useSelectionInk } from './selection-ink'
 import { uiTokens } from './ui-tokens'
 
 interface BreakingUpdateScreenProps {
@@ -9,6 +10,7 @@ interface BreakingUpdateScreenProps {
 }
 
 export function BreakingUpdateScreen({ onConfirm }: BreakingUpdateScreenProps) {
+  const ink = useSelectionInk()
   useKeyboard((key) => {
     if (key.name === 'return') {
       key.preventDefault()
@@ -24,7 +26,11 @@ export function BreakingUpdateScreen({ onConfirm }: BreakingUpdateScreenProps) {
           <text>The terminal manager must be restarted.</text>
           <text>You will lose your current terminal states.</text>
         </box>
-        <ListItem active direction="row" title={<text>OK — Restart terminal manager</text>} />
+        <ListItem
+          active
+          direction="row"
+          title={<text fg={ink}>OK — Restart terminal manager</text>}
+        />
       </box>
     </ModalShell>
   )

package/src/ui/components/git/pane/pr-checks-panel.tsx

@@ -291,9 +291,14 @@ export const PrChecksPanel = memo(function PrChecksPanel({
               No checks
             </text>
           ) : (
-            checks.map((check) => (
+            // GitHub can list the same workflow/name twice (a job that ran on
+            // both `push` and `pull_request`), so the pair is not a unique key
+            // and the duplicate crashes the reconciler. The rows hold no state
+            // and the list is the API's own order, so the index is the key.
+            checks.map((check, i) => (
               <CheckRow
-                key={`${check.workflow}/${check.name}`}
+                // oxlint-disable-next-line no-array-index-key
+                key={`${i}:${check.workflow}/${check.name}`}
                 bg={bg}
                 check={check}
                 showWorkflow={innerWidth >= WORKFLOW_MIN_WIDTH}

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

@@ -53,11 +53,9 @@ export function BarFooter({ contentWidth }: { contentWidth: number }) {
 
   return (
     <box flexDirection="column" flexShrink={0}>
-      <box flexShrink={0}>
-        <text fg={t.border} selectable={false} wrapMode="none">
-          {'─'.repeat(Math.max(1, contentWidth))}
-        </text>
-      </box>
+      {/* A blank row, not a rule: the footer is set off from the last widget by
+          the gap alone. */}
+      <box height={1} flexShrink={0} />
       {/* Each entry is its own <text>, with a spacer box between them: one string
           holding both would make the whole footer a single click target. */}
       <box flexDirection="row" flexShrink={0} paddingLeft={1} paddingRight={1}>