@brimveyn/aimux 1.3.0 → 1.4.0

package/README.md

@@ -11,6 +11,7 @@ A terminal multiplexer for AI CLIs. Manage multiple AI assistant sessions (Claud
 ## Features
 
 - **Multi-tab sessions** — Run Claude, Codex, and OpenCode in parallel with instant tab switching
+- **Session bar** — Numbered session chips at the top (or bottom) of the screen. Click to switch, drag to reorder, busy spinner for non-focused sessions with live PTY output. Toggle with `<leader>b`; jump with `<leader>1..9`. Position persists via `aimux.config.ts` or `aimux.json`.
 - **Split panes** — Split vertically (`|`) or horizontally (`-`) to view multiple assistants at once
 - **Draggable separators** — Resize split panes by dragging with the mouse
 - **Click-to-focus** — Click any pane or sidebar tab to focus it instantly
@@ -134,6 +135,8 @@ Press `?` in navigation mode for the full, live keybinding list (reflects your c
 | `Ctrl+S`              | Snippet picker       |
 | `Ctrl+T`              | Theme picker         |
 | `G`                   | Toggle git panel     |
+| `<leader>b`           | Toggle session bar   |
+| `<leader>1..9`        | Switch to session N  |
 | `?`                   | Show help            |
 | `Ctrl+C`              | Quit                 |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.3.0",
+  "version": "1.4.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",
@@ -57,7 +57,7 @@
     "format:check": "oxfmt --check ."
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.1.0",
+    "@brimveyn/aimux-config": "0.3.0",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@xterm/headless": "^6.0.0",

package/src/app-runtime/backend-runtime-events.ts

@@ -51,7 +51,13 @@ export function bindBackendRuntimeEvents({
       viewportY: viewport.viewportY,
     })
 
-    dispatch({ tabId, terminalModes, type: 'replace-tab-viewport', viewport })
+    dispatch({
+      source: resizingRef.current ? 'resize' : 'data',
+      tabId,
+      terminalModes,
+      type: 'replace-tab-viewport',
+      viewport,
+    })
     if (timeouts.isStartupGraceActive(tabId) || resizingRef.current) {
       return
     }
@@ -73,15 +79,21 @@ export function bindBackendRuntimeEvents({
     dispatch({ message, tabId, type: 'set-tab-error' })
   }
 
+  const handleSessionActivity = (sessionId: string, busy: boolean) => {
+    dispatch({ busy, sessionId, type: 'set-session-busy' })
+  }
+
   backend.on('render', handleRender)
   backend.on('exit', handleExit)
   backend.on('error', handleError)
+  backend.on('sessionActivity', handleSessionActivity)
 
   return () => {
     timeouts.clearAllTimers()
     backend.off('render', handleRender)
     backend.off('exit', handleExit)
     backend.off('error', handleError)
+    backend.off('sessionActivity', handleSessionActivity)
     void backend.destroy(true)
   }
 }

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

@@ -1,5 +1,5 @@
 import type { SessionBackend } from '../session-backend/types'
-import type { TabSession } from '../state/types'
+import type { AppAction, TabSession } from '../state/types'
 
 import { buildPtyPastePayload } from '../input/paste'
 
@@ -12,10 +12,12 @@ export function writeToTab(
   backend: SessionBackend,
   tabId: string,
   tab: TabSession | undefined,
-  input: string
+  input: string,
+  dispatch?: (action: AppAction) => void
 ): void {
   if (tab && shouldScrollViewportToBottom(tab)) {
     backend.scrollViewportToBottom(tabId)
+    dispatch?.({ intent: { kind: 'bottom' }, tabId, type: 'set-scroll-intent' })
   }
 
   backend.write(tabId, input)
@@ -25,8 +27,9 @@ export function writePasteToTab(
   backend: SessionBackend,
   tabId: string,
   tab: TabSession | undefined,
-  text: string
+  text: string,
+  dispatch?: (action: AppAction) => void
 ): void {
   const payload = buildPtyPastePayload(text, tab?.terminalModes.bracketedPasteMode ?? false)
-  writeToTab(backend, tabId, tab, payload)
+  writeToTab(backend, tabId, tab, payload, dispatch)
 }

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

@@ -2,7 +2,6 @@ import { $ } from 'bun'
 
 import type { SideEffect } from '../input/modes/types'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, AppState, AssistantId, TabSession } from '../state/types'
 
 import { loadConfig, saveConfig } from '../config'
 import { logInputDebug } from '../debug/input-log'
@@ -27,6 +26,13 @@ import {
 } from '../state/layout-tree'
 import { filterSessions, filterSnippets } from '../state/selectors'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
+import {
+  type AppAction,
+  type AppState,
+  type AssistantId,
+  DEFAULT_SCROLL_INTENT,
+  type TabSession,
+} from '../state/types'
 import { saveCurrentWorkspace } from '../state/workspace-save'
 import { scrollGitDiff } from '../ui/git-view-controls'
 import { applyTheme } from '../ui/theme'
@@ -124,14 +130,14 @@ function pasteSnippetToActiveGroup(ctx: SideEffectContext): void {
   const groupId = getGroupIdForTab(state.tabGroupMap, state.activeTabId)
   const groupTree = groupId ? state.layoutTrees[groupId] : null
   if (!groupTree) {
-    pasteSnippetToTab(backend, state.activeTabId, activeTab, snippet)
+    pasteSnippetToTab(backend, state.activeTabId, activeTab, snippet, ctx.dispatch)
     return
   }
 
   for (const tabId of allLeafIds(groupTree)) {
     const tab = state.tabs.find((entry) => entry.id === tabId)
     if (tab) {
-      pasteSnippetToTab(backend, tabId, tab, snippet)
+      pasteSnippetToTab(backend, tabId, tab, snippet, ctx.dispatch)
     }
   }
 }
@@ -229,6 +235,7 @@ export function createTabSession(
     buffer: '',
     command: customCommand ?? option.command,
     id: createTabId(),
+    scrollIntent: DEFAULT_SCROLL_INTENT,
     status: 'starting',
     terminalModes: createDefaultTerminalModes(),
     title: option.label,
@@ -393,7 +400,13 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       )
       return
     case 'paste-selected-snippet': {
-      pasteSnippetToTab(backend, state.activeTabId, ctx.activeTab, getSelectedSnippet(state))
+      pasteSnippetToTab(
+        backend,
+        state.activeTabId,
+        ctx.activeTab,
+        getSelectedSnippet(state),
+        dispatch
+      )
       return
     }
     case 'paste-snippet-to-group': {
@@ -471,11 +484,66 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       void enqueueGitOp(() => runGitPush(ctx))
       return
     }
+    case 'confirm-update-selection': {
+      handleConfirmUpdateSelection(ctx)
+      return
+    }
+    case 'switch-session-by-index': {
+      handleSwitchSessionByIndex(ctx, effect.index)
+      return
+    }
     default:
       effect satisfies never
   }
 }
 
+function handleSwitchSessionByIndex(ctx: SideEffectContext, index: number): void {
+  const { backend, dispatch, state } = ctx
+  const ordered = state.sessions
+    .slice()
+    .sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER))
+  const target = ordered[index - 1]
+  if (!target) {
+    logInputDebug('app.sessionBar.switchOutOfRange', { index, total: ordered.length })
+    return
+  }
+  if (target.id === state.currentSessionId) return
+  handleSwitchSessionEffect(state, backend, dispatch, target)
+}
+
+function handleConfirmUpdateSelection(ctx: SideEffectContext): void {
+  const { state } = ctx
+  if (state.modal.type !== 'update-available') {
+    return
+  }
+  const latest = state.modal.latestVersion
+  if (state.modal.selectedIndex === 0) {
+    runUpdateFromTui(ctx, latest)
+    return
+  }
+  saveConfig({ ...loadConfig(), skippedUpdateVersion: latest })
+}
+
+function runUpdateFromTui(ctx: SideEffectContext, latestVersion: string): void {
+  saveCurrentWorkspace(ctx.state)
+  void ctx.backend.destroy(true)
+  ctx.renderer.destroy()
+  process.stdout.write(`\nUpdating aimux to ${latestVersion}...\n`)
+  const proc = Bun.spawn(['bun', 'update', '-g', '@brimveyn/aimux', '@brimveyn/aimux-config'], {
+    stderr: 'inherit',
+    stdin: 'inherit',
+    stdout: 'inherit',
+  })
+  void proc.exited.then((code) => {
+    if (code === 0) {
+      process.stdout.write(`\nUpdated. Run \`aimux\` to start the new version.\n`)
+    } else {
+      process.stderr.write(`\nUpdate failed (exit code ${code}).\n`)
+    }
+    process.exit(code ?? 1)
+  })
+}
+
 async function runGitAction(
   ctx: SideEffectContext,
   args: string[],

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

@@ -57,13 +57,14 @@ export function pasteSnippetToTab(
   backend: SessionBackend,
   activeTabId: string | null,
   activeTab: TabSession | undefined,
-  snippet: SnippetRecord | undefined
+  snippet: SnippetRecord | undefined,
+  dispatch?: (action: AppAction) => void
 ): void {
   if (!snippet || !activeTabId || !activeTab) {
     return
   }
 
-  writePasteToTab(backend, activeTabId, activeTab, snippet.content)
+  writePasteToTab(backend, activeTabId, activeTab, snippet.content, dispatch)
 }
 
 export function handleDeleteSnippetEffect(

package/src/app-runtime/use-backend-runtime.ts

@@ -1,7 +1,7 @@
 import { type MutableRefObject, useEffect, useRef } from 'react'
 
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, LayoutState } from '../state/types'
+import type { AppAction, LayoutState, ScrollIntent } from '../state/types'
 
 import { attachCurrentSession } from './backend-attach-runtime'
 import { bindBackendRuntimeEvents } from './backend-runtime-events'
@@ -11,6 +11,7 @@ interface BackendRuntimeOptions {
   backend: SessionBackend
   dispatch: (action: AppAction) => void
   activeTabId: string | null
+  activeTabScrollIntentRef: MutableRefObject<ScrollIntent | null>
   currentSessionId: string | null
   layoutRef: MutableRefObject<LayoutState>
   resizingRef: MutableRefObject<boolean>
@@ -25,6 +26,7 @@ export interface TabRuntimeControls {
 
 export function useBackendRuntime({
   activeTabId,
+  activeTabScrollIntentRef,
   backend,
   currentSessionId,
   currentSessionWorkspaceSnapshot,
@@ -65,7 +67,10 @@ export function useBackendRuntime({
     }
 
     backend.setActiveTab(activeTabId)
-  }, [activeTabId, backend, currentSessionId])
+    if (activeTabId && activeTabScrollIntentRef.current) {
+      backend.reapplyScrollIntent(activeTabId, activeTabScrollIntentRef.current)
+    }
+  }, [activeTabId, activeTabScrollIntentRef, backend, currentSessionId])
 
   useEffect(() => {
     return bindBackendRuntimeEvents({

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

@@ -60,7 +60,7 @@ export function useRendererBindings({
         activeTabRef.current?.terminalModes.bracketedPasteMode ?? false,
       getFocusMode: () => focusModeRef.current,
       handleTerminalShortcut,
-      writeToPty: (tabId, data) => writeToTab(backend, tabId, activeTabRef.current, data),
+      writeToPty: (tabId, data) => writeToTab(backend, tabId, activeTabRef.current, data, dispatch),
     })
 
     const handlePasteEvent = (event: { bytes: Uint8Array; defaultPrevented?: boolean }) => {
@@ -96,7 +96,7 @@ export function useRendererBindings({
         return
       }
 
-      writePasteToTab(backend, tabId, tab, payload)
+      writePasteToTab(backend, tabId, tab, payload, dispatch)
     }
 
     const handleSelection = (selection: OtuiSelection) => {

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

@@ -2,7 +2,7 @@ import { type MutableRefObject, useEffect, useMemo, useRef } from 'react'
 
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, AppState } from '../state/types'
+import type { AppAction, AppState, ScrollIntent } from '../state/types'
 
 import {
   createTerminalBounds,
@@ -27,20 +27,21 @@ function resizeSplitTabs(
   layoutTrees: AppState['layoutTrees'],
   tabIds: string[],
   cols: number,
-  rows: number
+  rows: number,
+  intents: Map<string, ScrollIntent>
 ): void {
   const bounds = getTerminalBounds(cols, rows)
   const resizedTabIds = new Set<string>()
 
   forEachSplitPaneRect(Object.values(layoutTrees), bounds, (tabId, rect) => {
     const size = toTerminalContentSize(rect)
-    backend.resizeTab(tabId, size.cols, size.rows)
+    backend.resizeTab(tabId, size.cols, size.rows, intents.get(tabId))
     resizedTabIds.add(tabId)
   })
 
   for (const id of tabIds) {
     if (!resizedTabIds.has(id)) {
-      backend.resizeTab(id, cols, rows)
+      backend.resizeTab(id, cols, rows, intents.get(id))
     }
   }
 }
@@ -64,6 +65,7 @@ export function useTerminalResize({
 }: UseTerminalResizeOptions) {
   const resizingTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   const tabIdsRef = useRef<string[]>([])
+  const intentsRef = useRef<Map<string, ScrollIntent>>(new Map())
 
   const currentTabIds = state.tabs.map((t) => t.id)
   const tabIdsChanged =
@@ -74,6 +76,12 @@ export function useTerminalResize({
   }
   const stableTabIds = tabIdsRef.current
 
+  intentsRef.current = new Map(
+    state.tabs
+      .filter((t): t is typeof t & { scrollIntent: ScrollIntent } => t.scrollIntent !== undefined)
+      .map((t) => [t.id, t.scrollIntent])
+  )
+
   const terminalSize = useMemo(() => {
     const sidebarWidth = state.sidebar.visible ? state.sidebar.width + 1 : 0
     const reservedRows =
@@ -118,10 +126,11 @@ export function useTerminalResize({
         state.layoutTrees,
         stableTabIds,
         terminalSize.cols,
-        terminalSize.rows
+        terminalSize.rows,
+        intentsRef.current
       )
     } else {
-      backend.resizeAll(terminalSize.cols, terminalSize.rows)
+      backend.resizeAll(terminalSize.cols, terminalSize.rows, intentsRef.current)
     }
     resizingTimerRef.current = setTimeout(() => {
       resizingRef.current = false

package/src/app.tsx

@@ -1,6 +1,15 @@
-import { getDefaultKeymapConfig } from '@brimveyn/aimux-config'
+import type { ResolvedConfig } from '@brimveyn/aimux-config'
+
 import { useKeyboard, useRenderer, useTerminalDimensions } from '@opentui/react'
-import { useCallback, useLayoutEffect, useMemo, useReducer, useRef, useState } from 'react'
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+} from 'react'
 
 import type { KeyChord } from './input/keymap/key-chord'
 import type { TrieBinding } from './input/keymap/trie'
@@ -20,19 +29,36 @@ import { deriveModeId } from './input/modes/bridge'
 import { registerAllModes } from './input/modes/handlers'
 import { getHandler, transitionTo } from './input/modes/registry'
 import { type TerminalContentOrigin } from './input/raw-input-handler'
+import { getProfileName } from './profile-paths'
 import { appStore } from './state/app-store'
-import { setActiveDispatch } from './state/dispatch-ref'
+import { setActiveDispatch, setActiveSideEffectRunner } from './state/dispatch-ref'
 import { loadSessionCatalog } from './state/session-catalog'
 import { loadSnippetCatalog } from './state/snippet-catalog'
 import { appReducer, createInitialState } from './state/store'
+import { KeymapContext } from './ui/keymap-context'
 import { RootView } from './ui/root'
 import { applyTheme } from './ui/theme'
-
-const keymapHandlers = registerAllModes(getDefaultKeymapConfig())
+import {
+  fetchLatestNpmVersion,
+  getCurrentPackageVersion,
+  isNewerVersion,
+} from './update/version-check'
 
 const WORKSPACE_SAVE_DEBOUNCE_MS = 250
 
-export function App({ backend }: { backend: SessionBackend }) {
+export function App({
+  backend,
+  resolvedConfig,
+}: {
+  backend: SessionBackend
+  resolvedConfig: ResolvedConfig
+}) {
+  const keymapHandlers = useMemo(
+    () => registerAllModes(resolvedConfig.keymaps),
+    // Registration has side effects in a global mode registry — run once per app instance.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  )
   const renderer = useRenderer()
   const dimensions = useTerminalDimensions()
   const [themeId, setThemeId] = useState<ThemeId>(() => {
@@ -43,11 +69,22 @@ export function App({ backend }: { backend: SessionBackend }) {
     return config.themeId ?? 'aimux'
   })
   const [state, dispatch] = useReducer(appReducer, undefined, () => {
-    const { customCommands, gitPanelRatio, gitPanelVisible } = loadConfig()
-    return createInitialState(customCommands, loadSessionCatalog(), loadSnippetCatalog(), true, {
-      gitPanelRatio,
-      gitPanelVisible,
-    })
+    const json = loadConfig()
+    const sessionBarVisible = resolvedConfig.sessionBar?.visible ?? json.sessionBarVisible ?? true
+    const sessionBarPosition =
+      resolvedConfig.sessionBar?.position ?? json.sessionBarPosition ?? 'top'
+    return createInitialState(
+      json.customCommands,
+      loadSessionCatalog(),
+      loadSnippetCatalog(),
+      true,
+      {
+        gitPanelRatio: json.gitPanelRatio,
+        gitPanelVisible: json.gitPanelVisible,
+        sessionBarPosition,
+        sessionBarVisible,
+      }
+    )
   })
 
   useLayoutEffect(() => {
@@ -56,9 +93,37 @@ export function App({ backend }: { backend: SessionBackend }) {
 
   useLayoutEffect(() => {
     setActiveDispatch(dispatch)
-    return () => setActiveDispatch(null)
+    return () => {
+      setActiveDispatch(null)
+      setActiveSideEffectRunner(null)
+    }
   }, [dispatch])
 
+  useEffect(() => {
+    if (process.env.AIMUX_DISABLE_UPDATE_CHECK === '1') return
+    if (getProfileName() === 'dev') return
+
+    let cancelled = false
+    void (async () => {
+      const [current, latest] = await Promise.all([
+        getCurrentPackageVersion(),
+        fetchLatestNpmVersion('@brimveyn/aimux'),
+      ])
+      if (cancelled || !latest) return
+      if (!isNewerVersion(latest, current)) return
+      if (loadConfig().skippedUpdateVersion === latest) return
+      dispatch({
+        currentVersion: current,
+        latestVersion: latest,
+        type: 'open-update-available-modal',
+      })
+    })()
+
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
   const resizingRef = useRef(false)
   const layoutRef = useRef(state.layout)
   layoutRef.current = state.layout
@@ -81,6 +146,8 @@ export function App({ backend }: { backend: SessionBackend }) {
   activeTabIdRef.current = state.activeTabId
   const activeTabRef = useRef(activeTab)
   activeTabRef.current = activeTab
+  const activeTabScrollIntentRef = useRef(activeTab?.scrollIntent ?? null)
+  activeTabScrollIntentRef.current = activeTab?.scrollIntent ?? null
 
   const stateRef = useRef(state)
   stateRef.current = state
@@ -90,6 +157,7 @@ export function App({ backend }: { backend: SessionBackend }) {
 
   const { clearIdleTimer, clearStartupGrace, startStartupGrace } = useBackendRuntime({
     activeTabId: state.activeTabId,
+    activeTabScrollIntentRef,
     backend,
     currentSessionId: state.currentSessionId,
     currentSessionWorkspaceSnapshot,
@@ -132,15 +200,18 @@ export function App({ backend }: { backend: SessionBackend }) {
   // Allows handleTerminalShortcut (a stable callback) to reach the latest closure.
   const processKeyResultRef = useRef<(result: KeyResult, modeId: ModeId) => void>(() => {})
 
-  const handleTerminalShortcut = useCallback((chord: KeyChord): boolean => {
-    const terminalHandler = keymapHandlers.find((h) => h.id === 'terminal-input')
-    if (!terminalHandler) return false
-    const ctx: ModeContext = { state: stateRef.current }
-    const result = terminalHandler.handleChord(chord, ctx)
-    if (!result) return false
-    processKeyResultRef.current(result, 'terminal-input')
-    return true
-  }, [])
+  const handleTerminalShortcut = useCallback(
+    (chord: KeyChord): boolean => {
+      const terminalHandler = keymapHandlers.find((h) => h.id === 'terminal-input')
+      if (!terminalHandler) return false
+      const ctx: ModeContext = { state: stateRef.current }
+      const result = terminalHandler.handleChord(chord, ctx)
+      if (!result) return false
+      processKeyResultRef.current(result, 'terminal-input')
+      return true
+    },
+    [keymapHandlers]
+  )
 
   useRendererBindings({
     activeTabId: state.activeTabId,
@@ -194,6 +265,9 @@ export function App({ backend }: { backend: SessionBackend }) {
 
   // Keep the ref pointing at the latest closure so stable callbacks can invoke it
   processKeyResultRef.current = processKeyResult
+  // Expose the side-effect runner so non-keyboard call sites (mouse, IPC) can
+  // invoke the same effect pipeline with the current context.
+  setActiveSideEffectRunner((effect) => executeSideEffect(effect, sideEffectCtx))
 
   useLayoutEffect(() => {
     for (const handler of keymapHandlers) {
@@ -233,21 +307,23 @@ export function App({ backend }: { backend: SessionBackend }) {
   })
 
   return (
-    <RootView
-      themeId={themeId}
-      contentOrigin={contentOriginRef.current}
-      mouseForwardingEnabled={activeMouseForwardingEnabled}
-      localScrollbackEnabled={activeLocalScrollbackEnabled}
-      onTerminalMouseEvent={handleTerminalMouseEvent}
-      onTerminalScrollEvent={handleTerminalScrollEvent}
-      onTerminalClick={handleTerminalClick}
-      onPaneActivate={handlePaneActivate}
-      onSplitResize={handleSplitResize}
-      onSeparatorDragStart={handleSeparatorDragStart}
-      onSeparatorDrag={handleSeparatorDrag}
-      onSeparatorDragEnd={handleSeparatorDragEnd}
-      terminalCols={terminalSize.cols}
-      terminalRows={terminalSize.rows}
-    />
+    <KeymapContext.Provider value={resolvedConfig.keymaps}>
+      <RootView
+        themeId={themeId}
+        contentOrigin={contentOriginRef.current}
+        mouseForwardingEnabled={activeMouseForwardingEnabled}
+        localScrollbackEnabled={activeLocalScrollbackEnabled}
+        onTerminalMouseEvent={handleTerminalMouseEvent}
+        onTerminalScrollEvent={handleTerminalScrollEvent}
+        onTerminalClick={handleTerminalClick}
+        onPaneActivate={handlePaneActivate}
+        onSplitResize={handleSplitResize}
+        onSeparatorDragStart={handleSeparatorDragStart}
+        onSeparatorDrag={handleSeparatorDrag}
+        onSeparatorDragEnd={handleSeparatorDragEnd}
+        terminalCols={terminalSize.cols}
+        terminalRows={terminalSize.rows}
+      />
+    </KeymapContext.Provider>
   )
 }

package/src/config.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 
-import type { WorkspaceSnapshotV1 } from './state/types'
+import type { SessionBarPosition, WorkspaceSnapshotV1 } from './state/types'
 
 import { logDebug } from './debug/input-log'
 import { getProfileConfigDir } from './profile-paths'
@@ -15,7 +15,10 @@ export interface AimuxConfig {
   themeId?: ThemeId
   gitPanelVisible?: boolean
   gitPanelRatio?: number
+  sessionBarVisible?: boolean
+  sessionBarPosition?: SessionBarPosition
   workspaceSnapshot?: WorkspaceSnapshotV1
+  skippedUpdateVersion?: string
 }
 
 const DEFAULT_CONFIG: AimuxConfig = {
@@ -57,7 +60,10 @@ export function loadConfigResult(): ConfigLoadResult {
       themeId?: unknown
       gitPanelVisible?: unknown
       gitPanelRatio?: unknown
+      sessionBarVisible?: unknown
+      sessionBarPosition?: unknown
       workspaceSnapshot?: unknown
+      skippedUpdateVersion?: unknown
     }
 
     const issues: string[] = []
@@ -91,6 +97,20 @@ export function loadConfigResult(): ConfigLoadResult {
       issues.push('ignored invalid gitPanelRatio')
     }
 
+    const validSessionBarVisible =
+      typeof parsed.sessionBarVisible === 'boolean' ? parsed.sessionBarVisible : undefined
+    if (parsed.sessionBarVisible !== undefined && validSessionBarVisible === undefined) {
+      issues.push('ignored invalid sessionBarVisible')
+    }
+
+    const validSessionBarPosition =
+      parsed.sessionBarPosition === 'top' || parsed.sessionBarPosition === 'bottom'
+        ? parsed.sessionBarPosition
+        : undefined
+    if (parsed.sessionBarPosition !== undefined && validSessionBarPosition === undefined) {
+      issues.push('ignored invalid sessionBarPosition')
+    }
+
     if (
       parsed.workspaceSnapshot !== undefined &&
       !isWorkspaceSnapshotV1(parsed.workspaceSnapshot)
@@ -98,6 +118,14 @@ export function loadConfigResult(): ConfigLoadResult {
       issues.push('ignored invalid workspaceSnapshot')
     }
 
+    const validSkippedUpdateVersion =
+      typeof parsed.skippedUpdateVersion === 'string' && parsed.skippedUpdateVersion.length > 0
+        ? parsed.skippedUpdateVersion
+        : undefined
+    if (parsed.skippedUpdateVersion !== undefined && validSkippedUpdateVersion === undefined) {
+      issues.push('ignored invalid skippedUpdateVersion')
+    }
+
     if (issues.length > 0) {
       logDebug('config.load.validationIssue', { issues, path: CONFIG_PATH })
     }
@@ -107,6 +135,9 @@ export function loadConfigResult(): ConfigLoadResult {
         customCommands: isCustomCommandsRecord(parsed.customCommands) ? parsed.customCommands : {},
         gitPanelRatio: validGitPanelRatio,
         gitPanelVisible: validGitPanelVisible,
+        sessionBarPosition: validSessionBarPosition,
+        sessionBarVisible: validSessionBarVisible,
+        skippedUpdateVersion: validSkippedUpdateVersion,
         themeId: isThemeId(parsed.themeId) ? parsed.themeId : undefined,
         version: 2,
         workspaceSnapshot: isWorkspaceSnapshotV1(parsed.workspaceSnapshot)