@brimveyn/aimux 1.14.0 → 1.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.14.0",
+  "version": "1.14.1",
   "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.3",
+    "@brimveyn/aimux-config": "0.6.4",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

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

@@ -43,6 +43,7 @@ import {
   isCommandAvailable,
   parseCommand,
 } from '../pty/command-registry'
+import { appStore } from '../state/app-store'
 import { createTerminalBounds } from '../state/layout-resize'
 import {
   allLeafIds,
@@ -56,8 +57,15 @@ import {
 } from '../state/layout-tree'
 import { filterAssistants, filterSessions, filterSnippets } from '../state/selectors'
 import { saveSessionCatalog } from '../state/session-catalog'
-import { getActiveWorktree, getSessionProjectPath } from '../state/session-worktrees'
+import {
+  filterTabsForActiveWorktree,
+  getActiveWorktree,
+  getSessionProjectPath,
+  withActiveWorktree,
+} from '../state/session-worktrees'
 import { getSnippetsCatalogPath, isConfigSnippetId } from '../state/snippet-catalog'
+import { appReducer } from '../state/store'
+import { buildTabEntries } from '../state/tab-entries'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
 import { toast } from '../state/toast-store'
 import { saveCurrentWorkspace } from '../state/workspace-save'
@@ -71,6 +79,7 @@ import {
   handleRenameSessionEffect,
   handleSwitchSessionEffect,
   restartTabSession,
+  switchSessionRecords,
 } from './session-actions'
 import {
   handleDeleteSnippetEffect,
@@ -789,6 +798,14 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       handleSwitchSessionByIndex(ctx, effect.index)
       return
     }
+    case 'cycle-sidebar-item': {
+      handleCycleSidebarItem(ctx, effect.direction)
+      return
+    }
+    case 'switch-tab-by-index': {
+      handleSwitchTabByIndex(ctx, effect.index)
+      return
+    }
     case 'toggle-transparent': {
       const next = !getTransparent()
       setTransparent(next)
@@ -1060,6 +1077,133 @@ function handleSwitchSessionByIndex(ctx: SideEffectContext, index: number): void
   handleSwitchSessionEffect(state, backend, dispatch, target)
 }
 
+interface SidebarItem {
+  sessionId: string
+  worktreeId: string | null
+}
+
+function buildSidebarItems(state: AppState): SidebarItem[] {
+  const ordered = [...state.sessions].sort(
+    (a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER)
+  )
+  const items: SidebarItem[] = []
+  for (const session of ordered) {
+    items.push({ sessionId: session.id, worktreeId: null })
+    const worktrees = session.worktrees ?? []
+    const primary = worktrees.find((w) => w.source === 'primary') ?? worktrees[0]
+    for (const wt of worktrees) {
+      if (wt.id === primary?.id) continue
+      items.push({ sessionId: session.id, worktreeId: wt.id })
+    }
+  }
+  return items
+}
+
+function findCurrentSidebarItem(state: AppState, items: SidebarItem[]): number {
+  const sessionId = state.currentSessionId
+  if (sessionId == null || sessionId === '') return -1
+  const session = state.sessions.find((s) => s.id === sessionId)
+  const worktrees = session?.worktrees ?? []
+  const primary = worktrees.find((w) => w.source === 'primary') ?? worktrees[0]
+  const activeWtId = session?.activeWorktreeId ?? null
+  // The workspace row IS the primary worktree (no separate row), so an active
+  // primary or undefined active maps to the workspace-item.
+  const targetWorktreeId = activeWtId == null || activeWtId === primary?.id ? null : activeWtId
+  return items.findIndex(
+    (item) => item.sessionId === sessionId && item.worktreeId === targetWorktreeId
+  )
+}
+
+function handleCycleSidebarItem(ctx: SideEffectContext, direction: 1 | -1): void {
+  const { backend, dispatch } = ctx
+  // Read fresh from the store, not ctx.state (which is a per-render
+  // snapshot). Rapid key presses fire before React re-renders, so ctx.state
+  // can lag the actual store.
+  const state = appStore.getState()
+  const items = buildSidebarItems(state)
+  if (items.length === 0) return
+  const currentIdx = findCurrentSidebarItem(state, items)
+  // If we don't know the current, jump to first/last depending on direction.
+  let startIdx: number
+  if (currentIdx >= 0) {
+    startIdx = currentIdx
+  } else {
+    startIdx = direction === 1 ? -1 : 0
+  }
+  const len = items.length
+  const target = items[(((startIdx + direction) % len) + len) % len]
+  if (!target) return
+
+  const session = state.sessions.find((s) => s.id === target.sessionId)
+  if (!session) return
+
+  // Determine the worktree to activate. For workspace-items, that's the
+  // primary; for worktree-items, the specific worktree.
+  const worktrees = session.worktrees ?? []
+  const primary = worktrees.find((w) => w.source === 'primary') ?? worktrees[0]
+  const targetWorktreeId = target.worktreeId ?? primary?.id
+
+  const isCrossWorkspace = session.id !== state.currentSessionId
+  const needsWorktreeChange =
+    targetWorktreeId != null && targetWorktreeId !== session.activeWorktreeId
+
+  if (isCrossWorkspace) {
+    // Bundle the worktree change into the session record AND fold the
+    // session switch's two dispatches (set-sessions + load-session) into a
+    // SINGLE Zustand setState call — otherwise each dispatch fires a
+    // separate subscription notification and the @opentui/react reconciler
+    // paints an intermediate frame where the new session is current but
+    // the old activeWorktreeId still holds, producing the visible flicker.
+    const patchedSession = needsWorktreeChange
+      ? withActiveWorktree(session, targetWorktreeId)
+      : session
+    const patchedState: AppState = needsWorktreeChange
+      ? {
+          ...state,
+          sessions: state.sessions.map((s) => (s.id === patchedSession.id ? patchedSession : s)),
+        }
+      : state
+    const sessions = switchSessionRecords(patchedState, patchedSession)
+    saveSessionCatalog(sessions)
+    void backend.destroy(true)
+    appStore.setState((current) => {
+      const afterSet = appReducer(current, { sessions, type: 'set-sessions' })
+      return appReducer(afterSet, {
+        sessionId: patchedSession.id,
+        type: 'load-session',
+        workspaceSnapshot: patchedSession.workspaceSnapshot,
+      })
+    })
+    return
+  }
+
+  if (needsWorktreeChange) {
+    dispatch({
+      sessionId: session.id,
+      type: 'set-active-worktree',
+      worktreeId: targetWorktreeId,
+    })
+  }
+}
+
+function handleSwitchTabByIndex(ctx: SideEffectContext, index: number): void {
+  const { dispatch, state } = ctx
+  const currentSession =
+    state.currentSessionId != null && state.currentSessionId !== ''
+      ? state.sessions.find((s) => s.id === state.currentSessionId)
+      : undefined
+  const visible = filterTabsForActiveWorktree(state.tabs, currentSession)
+  const entries = buildTabEntries(visible, state.layoutTrees, state.tabGroupMap, state.activeTabId)
+  const target = entries[index - 1]
+  if (!target) {
+    logInputDebug('app.tabBar.switchOutOfRange', { index, total: entries.length })
+    return
+  }
+  const targetTabId = target.kind === 'single' ? target.tab.id : target.activeLeafId
+  if (targetTabId === state.activeTabId) return
+  dispatch({ tabId: targetTabId, type: 'set-active-tab' })
+}
+
 function replaceSession(
   state: AppState,
   sessionId: string,

package/src/app-runtime/split-drag-controller.ts

@@ -29,7 +29,9 @@ function getScreenPosition(event: OtuiMouseEvent, axis: ScreenAxis): number {
 
 export function getSplitRatioFromDrag(event: OtuiMouseEvent, drag: SplitDragState): number {
   const position = getScreenPosition(event, drag.direction === 'vertical' ? 'x' : 'y')
-  return (position - drag.screenStart) / drag.totalSize
+  const total = Math.max(1, drag.totalSize)
+  const cells = Math.round(position - drag.screenStart)
+  return cells / total
 }
 
 export function getAxisDeltaFromDrag(event: OtuiMouseEvent, drag: AxisDragState): number {

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

@@ -175,8 +175,7 @@ export function useTerminalResize({
   const terminalSize = useMemo(() => {
     const sidebarWidth = state.sidebar.visible ? state.sidebar.width : 0
     const sessionBarRows = state.sessionBar.visible ? 1 : 0
-    const sessionBarTopOffset =
-      state.sessionBar.visible && state.sessionBar.position === 'top' ? 1 : 0
+    const sessionBarTopOffset = sessionBarRows
     const reservedRows =
       MAIN_AREA_VERTICAL_PADDING +
       STATUS_BAR_HEIGHT +
@@ -205,7 +204,6 @@ export function useTerminalResize({
     state.sidebar.visible,
     state.sidebar.width,
     state.sessionBar.visible,
-    state.sessionBar.position,
     gitPaneInPaneMode,
     state.gitPane.position,
     state.gitPane.paneRatio,
@@ -233,7 +231,6 @@ export function useTerminalResize({
     state.sidebar.visible,
     state.sidebar.width,
     state.sessionBar.visible,
-    state.sessionBar.position,
     gitPaneInPaneMode,
     state.gitPane.position,
     state.gitPane.paneRatio,

package/src/app.tsx

@@ -100,8 +100,6 @@ export function App({
     const json = loadConfig()
     const sessionBarVisible =
       resolvedConfig.sessionBar?.initialVisible ?? json.sessionBarVisible ?? true
-    const sessionBarPosition =
-      resolvedConfig.sessionBar?.initialPosition ?? json.sessionBarPosition ?? 'top'
     const sidebarOverrides = json.sidebar
 
     // Merge config-file gitPane (persisted prefs) with user's resolved gitPane
@@ -149,7 +147,6 @@ export function App({
       sessionCatalog.length === 0,
       {
         gitPane: gitPaneOverrides,
-        sessionBarPosition,
         sessionBarVisible,
         sidebar: sidebarOverrides,
       }

package/src/config.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 
-import type { GitFileListMode, SessionBarPosition, WorkspaceSnapshotV1 } from './state/types'
+import type { GitFileListMode, WorkspaceSnapshotV1 } from './state/types'
 
 import { logDebug } from './debug/input-log'
 import { getProfileConfigDir } from './profile-paths'
@@ -41,7 +41,6 @@ export interface AimuxConfig {
   gitPane?: PersistedGitPane
   sidebar?: PersistedSidebar
   sessionBarVisible?: boolean
-  sessionBarPosition?: SessionBarPosition
   workspaceSnapshot?: WorkspaceSnapshotV1
   skippedUpdateVersion?: string
 }
@@ -161,7 +160,6 @@ export function loadConfigResult(): ConfigLoadResult {
       gitPanelVisible?: unknown
       gitPanelRatio?: unknown
       sessionBarVisible?: unknown
-      sessionBarPosition?: unknown
       workspaceSnapshot?: unknown
       skippedUpdateVersion?: unknown
     }
@@ -233,14 +231,6 @@ export function loadConfigResult(): ConfigLoadResult {
       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)
@@ -264,7 +254,6 @@ export function loadConfigResult(): ConfigLoadResult {
       config: {
         customCommands: isCustomCommandsRecord(parsed.customCommands) ? parsed.customCommands : {},
         gitPane: validGitPane,
-        sessionBarPosition: validSessionBarPosition,
         sessionBarVisible: validSessionBarVisible,
         sidebar: validSidebar,
         skippedUpdateVersion: validSkippedUpdateVersion,

package/src/git/worktree-branch-poller.ts

@@ -0,0 +1,54 @@
+import { useEffect } from 'react'
+
+import { appStore } from '../state/app-store'
+import { dispatchGlobal } from '../state/dispatch-ref'
+import { getCurrentBranch } from '../ui/git-branch'
+
+const INTERVAL_MS = 4000
+
+// Single source of truth for "what git branch is each worktree on right now".
+// Polls every known worktree's path and dispatches update-worktree-record
+// when the live branch differs from the stored one. Components read
+// `worktree.branch` from state — no per-component polling, no flickers.
+//
+// Runs once when enabled; reads sessions from the store on each tick so
+// session updates do NOT re-create the effect (which would otherwise feedback
+// off our own dispatches).
+export function useWorktreeBranchPolling(enabled: boolean): void {
+  useEffect(() => {
+    if (!enabled) return
+
+    let cancelled = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+
+    const tick = async () => {
+      const sessions = appStore.getState().sessions
+      await Promise.all(
+        sessions.flatMap((session) =>
+          (session.worktrees ?? []).map(async (worktree) => {
+            if (worktree.path == null || worktree.path === '') return
+            const branch = await getCurrentBranch(worktree.path)
+            if (cancelled) return
+            if (branch != null && branch !== worktree.branch) {
+              dispatchGlobal({
+                patch: { branch },
+                sessionId: session.id,
+                type: 'update-worktree-record',
+                worktreeId: worktree.id,
+              })
+            }
+          })
+        )
+      )
+      if (cancelled) return
+      timer = setTimeout(() => void tick(), INTERVAL_MS)
+    }
+
+    void tick()
+
+    return () => {
+      cancelled = true
+      if (timer != null) clearTimeout(timer)
+    }
+  }, [enabled])
+}

package/src/input/modes/types.ts

@@ -68,6 +68,8 @@ export type SideEffect =
   | { type: 'git-push' }
   | { type: 'confirm-update-selection' }
   | { type: 'switch-session-by-index'; index: number }
+  | { type: 'cycle-sidebar-item'; direction: 1 | -1 }
+  | { type: 'switch-tab-by-index'; index: number }
   | { type: 'delete-session'; sessionId: string }
   | { type: 'delete-worktree'; sessionId: string; worktreeId: string; force?: boolean }
   | {

package/src/state/layout-tree.ts

@@ -124,6 +124,116 @@ export function allLeafIds(tree: LayoutNode): string[] {
   return [...allLeafIds(tree.first), ...allLeafIds(tree.second)]
 }
 
+export type BoundarySide = 'left' | 'right' | 'top' | 'bottom'
+
+export function getBoundaryLeafIds(node: LayoutNode, side: BoundarySide): string[] {
+  if (node.type === 'leaf') {
+    return [node.tabId]
+  }
+
+  const axisOfSide = side === 'left' || side === 'right' ? 'vertical' : 'horizontal'
+
+  if (node.direction === axisOfSide) {
+    // Split direction matches the side's axis: only one child touches `side`.
+    const child = side === 'left' || side === 'top' ? node.first : node.second
+    return getBoundaryLeafIds(child, side)
+  }
+
+  // Perpendicular split: both children touch `side`.
+  return [...getBoundaryLeafIds(node.first, side), ...getBoundaryLeafIds(node.second, side)]
+}
+
+export interface JunctionEdgeInfo {
+  tabId: string
+  direction: SplitDirection
+  screenStart: number
+  totalSize: number
+}
+
+export interface JunctionEdges {
+  left?: JunctionEdgeInfo
+  right?: JunctionEdgeInfo
+  top?: JunctionEdgeInfo
+  bottom?: JunctionEdgeInfo
+}
+
+function firstLeafIdOf(node: LayoutNode): string {
+  return node.type === 'leaf' ? node.tabId : firstLeafIdOf(node.first)
+}
+
+export function computeJunctionEdges(
+  tree: LayoutNode,
+  bounds: PaneRect,
+  origin: { x: number; y: number }
+): Map<string, JunctionEdges> {
+  const result = new Map<string, JunctionEdges>()
+  walk(tree, bounds)
+  return result
+
+  function ensure(tabId: string): JunctionEdges {
+    let entry = result.get(tabId)
+    if (!entry) {
+      entry = {}
+      result.set(tabId, entry)
+    }
+    return entry
+  }
+
+  function walk(node: LayoutNode, nodeBounds: PaneRect): void {
+    if (node.type === 'leaf') {
+      ensure(node.tabId)
+      return
+    }
+
+    const info: JunctionEdgeInfo = {
+      direction: node.direction,
+      screenStart:
+        node.direction === 'vertical' ? origin.x + nodeBounds.x : origin.y + nodeBounds.y,
+      tabId: firstLeafIdOf(node.first),
+      totalSize: node.direction === 'vertical' ? nodeBounds.cols : nodeBounds.rows,
+    }
+
+    if (node.direction === 'vertical') {
+      for (const leafId of getBoundaryLeafIds(node.first, 'right')) {
+        ensure(leafId).right = info
+      }
+      for (const leafId of getBoundaryLeafIds(node.second, 'left')) {
+        ensure(leafId).left = info
+      }
+    } else {
+      for (const leafId of getBoundaryLeafIds(node.first, 'bottom')) {
+        ensure(leafId).bottom = info
+      }
+      for (const leafId of getBoundaryLeafIds(node.second, 'top')) {
+        ensure(leafId).top = info
+      }
+    }
+
+    // Recurse with bounds math matching computePaneRects (now without separator gap).
+    if (node.direction === 'vertical') {
+      const firstCols = Math.max(1, Math.floor(nodeBounds.cols * node.ratio))
+      const secondCols = Math.max(1, nodeBounds.cols - firstCols)
+      walk(node.first, { cols: firstCols, rows: nodeBounds.rows, x: nodeBounds.x, y: nodeBounds.y })
+      walk(node.second, {
+        cols: secondCols,
+        rows: nodeBounds.rows,
+        x: nodeBounds.x + firstCols,
+        y: nodeBounds.y,
+      })
+    } else {
+      const firstRows = Math.max(1, Math.floor(nodeBounds.rows * node.ratio))
+      const secondRows = Math.max(1, nodeBounds.rows - firstRows)
+      walk(node.first, { cols: nodeBounds.cols, rows: firstRows, x: nodeBounds.x, y: nodeBounds.y })
+      walk(node.second, {
+        cols: nodeBounds.cols,
+        rows: secondRows,
+        x: nodeBounds.x,
+        y: nodeBounds.y + firstRows,
+      })
+    }
+  }
+}
+
 export function pruneLayoutTree(tree: LayoutNode, validTabIds: Set<string>): LayoutNode | null {
   if (tree.type === 'leaf') {
     return validTabIds.has(tree.tabId) ? tree : null
@@ -227,13 +337,13 @@ export function computePaneRects(tree: LayoutNode, bounds: PaneRect): Map<string
   if (tree.direction === 'vertical') {
     // Split left/right
     const firstCols = Math.max(1, Math.floor(bounds.cols * tree.ratio))
-    const secondCols = Math.max(1, bounds.cols - firstCols - 1) // -1 for separator
+    const secondCols = Math.max(1, bounds.cols - firstCols)
 
     const firstBounds: PaneRect = { cols: firstCols, rows: bounds.rows, x: bounds.x, y: bounds.y }
     const secondBounds: PaneRect = {
       cols: secondCols,
       rows: bounds.rows,
-      x: bounds.x + firstCols + 1,
+      x: bounds.x + firstCols,
       y: bounds.y,
     }
 
@@ -246,14 +356,14 @@ export function computePaneRects(tree: LayoutNode, bounds: PaneRect): Map<string
   } else {
     // Split top/bottom
     const firstRows = Math.max(1, Math.floor(bounds.rows * tree.ratio))
-    const secondRows = Math.max(1, bounds.rows - firstRows - 1) // -1 for separator
+    const secondRows = Math.max(1, bounds.rows - firstRows)
 
     const firstBounds: PaneRect = { cols: bounds.cols, rows: firstRows, x: bounds.x, y: bounds.y }
     const secondBounds: PaneRect = {
       cols: bounds.cols,
       rows: secondRows,
       x: bounds.x,
-      y: bounds.y + firstRows + 1,
+      y: bounds.y + firstRows,
     }
 
     for (const [id, rect] of computePaneRects(tree.first, firstBounds)) {

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

@@ -1,5 +1,6 @@
 import type { AppAction, AppState } from '../types'
 
+import { moveIdToIdPosition, orderSessionsForDisplay } from '../../ui/session-ordering'
 import { filterSessions } from '../selectors'
 import { restoreWorkspaceState } from '../session-persistence'
 import { withActiveWorktree } from '../session-worktrees'
@@ -107,6 +108,25 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
       }
       return { ...state, sessions: ordered }
     }
+    case 'reorder-active-session': {
+      const currentId = state.currentSessionId
+      if (currentId == null || currentId === '') return state
+      const ids = orderSessionsForDisplay(state.sessions).map((s) => s.id)
+      const from = ids.indexOf(currentId)
+      if (from < 0) return state
+      const to = from + action.delta
+      const targetId = ids[to]
+      if (targetId == null) return state
+      const nextIds = moveIdToIdPosition(ids, currentId, targetId)
+      const byId = new Map(state.sessions.map((s) => [s.id, s]))
+      const nextSessions = nextIds.map((id, idx) => {
+        const s = byId.get(id)
+        return s ? { ...s, order: idx } : s
+      })
+      const filtered = nextSessions.filter((s): s is NonNullable<typeof s> => s != null)
+      if (filtered.length !== state.sessions.length) return state
+      return { ...state, sessions: filtered }
+    }
     case 'set-session-status': {
       const prev = state.sessionStatuses[action.sessionId]
       if (

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

@@ -199,7 +199,11 @@ function getCurrentSession(state: AppState) {
     : undefined
 }
 
-function withActiveTabWorktree(state: AppState, tabId: string | null): AppState {
+function withActiveTabWorktree(
+  state: AppState,
+  tabId: string | null,
+  opts?: { onlyIfMissing?: boolean }
+): AppState {
   if (
     tabId == null ||
     tabId === '' ||
@@ -209,6 +213,19 @@ function withActiveTabWorktree(state: AppState, tabId: string | null): AppState
   const tab = state.tabs.find((entry) => entry.id === tabId)
   if (!(tab?.worktreeId != null && tab?.worktreeId !== '')) return state
   const worktreeId = tab.worktreeId
+  // When `onlyIfMissing` is set, we leave the session's worktree alone if it
+  // already points at a known worktree. Used by `hydrate-workspace` so that
+  // a backend re-attach after a user-initiated worktree switch (j/k cycling)
+  // doesn't clobber the freshly chosen worktree by re-syncing from the
+  // restored active tab.
+  if (opts?.onlyIfMissing === true) {
+    const session = state.sessions.find((entry) => entry.id === state.currentSessionId)
+    const hasValidWorktree =
+      session?.activeWorktreeId != null &&
+      session.activeWorktreeId !== '' &&
+      (session.worktrees?.some((w) => w.id === session.activeWorktreeId) ?? false)
+    if (hasValidWorktree) return state
+  }
   return {
     ...state,
     sessions: state.sessions.map((session) =>
@@ -345,7 +362,8 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
           tabGroupMap: hydratedGroupMap,
           tabs: normalizeGroupedTabOrder(action.tabs, hydratedTrees, hydratedGroupMap),
         },
-        hydratedActiveTabId
+        hydratedActiveTabId,
+        { onlyIfMissing: true }
       )
     }
     case 'close-tab':

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

@@ -34,9 +34,6 @@ export function reduceUIState(state: AppState, action: AppAction): AppState | nu
         ...state,
         sessionBar: { ...state.sessionBar, visible: !state.sessionBar.visible },
       }
-    case 'set-session-bar-position':
-      if (state.sessionBar.position === action.position) return state
-      return { ...state, sessionBar: { ...state.sessionBar, position: action.position } }
     default:
       return null
   }

package/src/state/session-worktrees.ts

@@ -3,13 +3,21 @@ import { createHash } from 'node:crypto'
 import { existsSync } from 'node:fs'
 import { basename } from 'node:path'
 
-import type { SessionRecord, TabSession, WorktreeRecord } from './types'
+import type { BranchDivergence, SessionRecord, TabSession, WorktreeRecord } from './types'
 
 import { createPrefixedId } from '../platform/id'
 import { isInsideAimuxWorktreeRoot } from '../platform/worktree-paths'
 
 const WORKTREE_COLORS = ['#7dd3fc', '#86efac', '#facc15', '#f0abfc', '#fb7185', '#c4b5fd']
 
+export function formatDivergence(divergence: BranchDivergence | undefined): string {
+  if (divergence == null) return ''
+  const parts: string[] = []
+  if (divergence.ahead > 0) parts.push(`↑${divergence.ahead}`)
+  if (divergence.behind > 0) parts.push(`↓${divergence.behind}`)
+  return parts.join(' ')
+}
+
 export function getWorktreeColor(worktreeId: string): string {
   let hash = 0
   for (let i = 0; i < worktreeId.length; i++) {
@@ -98,7 +106,24 @@ function mergeExistingGitWorktrees(worktrees: WorktreeRecord[], now: string): Wo
       ? primaryRepoRoot
       : (live[0]?.path ?? anchor.repoRoot)
   for (const entry of live) {
-    if (byPath.has(entry.path)) continue
+    const existing = byPath.get(entry.path)
+    if (existing) {
+      // Patch branch / commitSha from git for entries we already track —
+      // notably the primary worktree, whose `branch` is never set at creation
+      // time (createPrimaryWorktree doesn't run `git`). Without this, the UI
+      // and the divergence poller have no branch for primary worktrees.
+      const patchedBranch = entry.branch ?? existing.branch
+      const patchedSha = entry.head ?? existing.commitSha
+      if (patchedBranch !== existing.branch || patchedSha !== existing.commitSha) {
+        byPath.set(entry.path, {
+          ...existing,
+          branch: patchedBranch,
+          commitSha: patchedSha,
+          updatedAt: now,
+        })
+      }
+      continue
+    }
     if (isInsideAimuxWorktreeRoot(entry.path)) continue
     const worktree: WorktreeRecord = {
       branch: entry.branch,
@@ -204,6 +229,24 @@ export function getRenderedTabWorktreeId(
   return tab.worktreeId ?? worktrees[0]?.id ?? '__main__'
 }
 
+export function filterTabsForActiveWorktree(
+  tabs: TabSession[],
+  session: SessionRecord | undefined
+): TabSession[] {
+  if (!session) return tabs
+  const activeWorktreeId = session.activeWorktreeId
+  if (activeWorktreeId == null || activeWorktreeId === '') return tabs
+  const worktrees = session.worktrees ?? []
+  const primaryId = worktrees[0]?.id
+  const activeIsPrimary = primaryId != null && primaryId === activeWorktreeId
+  return tabs.filter((tab) => {
+    const owned = tab.worktreeId != null && tab.worktreeId !== ''
+    if (owned) return tab.worktreeId === activeWorktreeId
+    // Unbound (legacy) tabs surface only under the primary worktree.
+    return activeIsPrimary
+  })
+}
+
 export function orderTabsByWorktree(
   tabs: TabSession[],
   session: SessionRecord | undefined