@brimveyn/aimux 1.14.3 → 1.14.5

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

@@ -3,7 +3,7 @@ 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'
+import { filterTabsForActiveWorktree, withActiveWorktree } from '../session-worktrees'
 
 const CLOSED_MODAL = {
   editBuffer: null,
@@ -18,9 +18,24 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
       const snapshot =
         action.workspaceSnapshot ??
         state.sessions.find((entry) => entry.id === action.sessionId)?.workspaceSnapshot
+      const restored = restoreWorkspaceState(state, snapshot)
+      // The session's activeWorktreeId may have been patched right before
+      // this load (e.g. the cross-workspace branch of handleCycleSidebarItem
+      // sets it to the worktree the user just clicked). The snapshot's
+      // activeTabId still reflects the *last* worktree they were on, so
+      // honor the patched worktree by filtering the restored tab list.
+      const loadedSession = state.sessions.find((entry) => entry.id === action.sessionId)
+      const visible = filterTabsForActiveWorktree(restored.tabs, loadedSession)
+      const activeTabId =
+        restored.activeTabId != null &&
+        restored.activeTabId !== '' &&
+        visible.some((t) => t.id === restored.activeTabId)
+          ? restored.activeTabId
+          : (visible[0]?.id ?? null)
       return {
         ...state,
-        ...restoreWorkspaceState(state, snapshot),
+        ...restored,
+        activeTabId,
         currentSessionId: action.sessionId,
         focusMode: 'navigation',
         modal: CLOSED_MODAL,
@@ -175,13 +190,30 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
           )
         }),
       }
-    case 'set-active-worktree':
-      return {
-        ...state,
-        sessions: state.sessions.map((session) =>
-          session.id === action.sessionId ? withActiveWorktree(session, action.worktreeId) : session
-        ),
+    case 'set-active-worktree': {
+      const sessions = state.sessions.map((session) =>
+        session.id === action.sessionId ? withActiveWorktree(session, action.worktreeId) : session
+      )
+      // Changing the worktree of a non-current session has no effect on
+      // which tab the user is looking at — leave activeTabId alone.
+      if (action.sessionId !== state.currentSessionId) {
+        return { ...state, sessions }
+      }
+      // For the current session: if the existing activeTabId belongs to
+      // the new worktree, keep it. Otherwise hop to the first tab visible
+      // under that worktree (or clear it if the worktree is empty — the
+      // pane then renders the "this worktree has no tabs" placeholder).
+      const updated = sessions.find((s) => s.id === action.sessionId)
+      const visible = filterTabsForActiveWorktree(state.tabs, updated)
+      const currentStillVisible =
+        state.activeTabId != null &&
+        state.activeTabId !== '' &&
+        visible.some((t) => t.id === state.activeTabId)
+      if (currentStillVisible) {
+        return { ...state, sessions }
       }
+      return { ...state, activeTabId: visible[0]?.id ?? null, sessions }
+    }
     case 'update-worktree-record':
       return {
         ...state,

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

@@ -15,7 +15,11 @@ import {
   splitNode,
 } from '../layout-tree'
 import { normalizeGroupedTabOrder } from '../session-persistence'
-import { orderTabsByWorktree, withActiveWorktree } from '../session-worktrees'
+import {
+  filterTabsForActiveWorktree,
+  orderTabsByWorktree,
+  withActiveWorktree,
+} from '../session-worktrees'
 import { createDefaultTerminalModes } from '../terminal-modes'
 
 const MAX_BUFFER_LENGTH = 50_000
@@ -317,12 +321,23 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       )
     }
     case 'hydrate-workspace': {
+      // The session's activeWorktreeId may have just been switched by the
+      // user (j/k cycle, sidebar click) before the backend attached. Honor
+      // that choice by only considering tabs visible in that worktree —
+      // otherwise we'd land the active tab on whatever the backend picked
+      // (typically the worktree we *last* persisted, not the current one).
+      const currentSession =
+        state.currentSessionId != null && state.currentSessionId !== ''
+          ? state.sessions.find((s) => s.id === state.currentSessionId)
+          : undefined
+      const visibleForWorktree = filterTabsForActiveWorktree(action.tabs, currentSession)
+      const visibleIds = new Set(visibleForWorktree.map((t) => t.id))
       const hydratedActiveTabId =
         action.activeTabId != null &&
         action.activeTabId !== '' &&
-        action.tabs.some((tab) => tab.id === action.activeTabId)
+        visibleIds.has(action.activeTabId)
           ? action.activeTabId
-          : (action.tabs[0]?.id ?? null)
+          : (visibleForWorktree[0]?.id ?? null)
       const tabIds = new Set(action.tabs.map((t) => t.id))
 
       // Restore from new multi-tree format or migrate from legacy single tree

package/src/state/session-worktrees.ts

@@ -8,8 +8,6 @@ import type { BranchDivergence, SessionRecord, TabSession, WorktreeRecord } from
 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[] = []
@@ -18,14 +16,6 @@ export function formatDivergence(divergence: BranchDivergence | undefined): stri
   return parts.join(' ')
 }
 
-export function getWorktreeColor(worktreeId: string): string {
-  let hash = 0
-  for (let i = 0; i < worktreeId.length; i++) {
-    hash = (hash * 31 + worktreeId.charCodeAt(i)) >>> 0
-  }
-  return WORKTREE_COLORS[hash % WORKTREE_COLORS.length] ?? '#7dd3fc'
-}
-
 export function createPrimaryWorktree(projectPath: string, now: string): WorktreeRecord {
   const id = createPrefixedId('worktree')
   return {

package/src/state/types.ts

@@ -50,8 +50,16 @@ export type ModalType =
 
 export interface TerminalSpan {
   text: string
+  /** Hex color for RGB cells, or undefined for the "default" foreground. */
   fg?: string
+  /** Hex color for RGB cells, or undefined for the "default" background. */
   bg?: string
+  /** ANSI palette index (0-255) when the cell emitted an indexed color.
+   *  Resolved client-side against the host terminal's queried palette so
+   *  user themes (Ghostty, iTerm2, …) show through. Wins over `fg` if set. */
+  fgPalette?: number
+  /** ANSI palette index (0-255). Resolved client-side. Wins over `bg`. */
+  bgPalette?: number
   bold?: boolean
   italic?: boolean
   underline?: boolean

package/src/ui/components/git/pane/git-pane-header.tsx

@@ -76,7 +76,7 @@ export const GitPaneHeader = memo(function GitPaneHeader({
             </box>
           ) : null}
           {showToggle ? (
-            <box flexDirection="row" gap={1} onMouseDown={toggleListMode}>
+            <box flexDirection="row" gap={1} paddingLeft={1} onMouseDown={toggleListMode}>
               <text
                 selectable={false}
                 fg={fileListMode === 'tree' ? t.primary : t.textMuted}

package/src/ui/components/layout/sidebar/workspace-list.tsx

@@ -10,7 +10,7 @@ import type { SessionRecord, SessionStatus, WorktreeRecord } from '../../../../s
 
 import { useAppStore } from '../../../../state/app-store'
 import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-ref'
-import { formatDivergence, getWorktreeColor } from '../../../../state/session-worktrees'
+import { formatDivergence } from '../../../../state/session-worktrees'
 // eslint-disable-next-line no-duplicate-imports
 import { IDLE_SESSION_STATUS } from '../../../../state/types'
 import { useBusySpinner } from '../../../hooks/use-busy-spinner'
@@ -199,6 +199,7 @@ export function WorkspaceList({ contentWidth }: WorkspaceListProps) {
                 isActiveItem={workspaceIsActiveItem}
                 inCurrentGroup={isCurrentSession}
                 primaryWorktree={primaryWorktree}
+                hasExtraWorktrees={extraWorktrees.length > 0}
                 status={statusMap[session.id] ?? IDLE_SESSION_STATUS}
                 dragging={draggingId === session.id}
                 contentWidth={contentWidth}
@@ -210,7 +211,7 @@ export function WorkspaceList({ contentWidth }: WorkspaceListProps) {
                 onDragCancel={cancelDrag}
               />
             )
-            for (const worktree of extraWorktrees) {
+            for (const [wtIdx, worktree] of extraWorktrees.entries()) {
               rows.push(
                 <WorktreeRow
                   key={`wt:${worktree.id}`}
@@ -219,6 +220,7 @@ export function WorkspaceList({ contentWidth }: WorkspaceListProps) {
                   sessionIndex={sessionIndex}
                   isActiveItem={isCurrentSession && worktree.id === session.activeWorktreeId}
                   inCurrentGroup={isCurrentSession}
+                  isLast={wtIdx === extraWorktrees.length - 1}
                 />
               )
             }
@@ -250,6 +252,8 @@ interface WorkspaceRowProps {
   inCurrentGroup: boolean
   /** The session's primary worktree — its git branch is shown as the workspace's anchor identity. */
   primaryWorktree: WorktreeRecord | undefined
+  /** True when at least one non-primary worktree follows — used to draw the tree continuator. */
+  hasExtraWorktrees: boolean
   status: SessionStatus
   dragging: boolean
   contentWidth: number
@@ -265,6 +269,7 @@ interface WorkspaceRowProps {
 const WorkspaceRow = memo(function WorkspaceRow({
   contentWidth,
   dragging,
+  hasExtraWorktrees,
   inCurrentGroup,
   isActiveItem,
   marginTop,
@@ -332,16 +337,10 @@ const WorkspaceRow = memo(function WorkspaceRow({
     [session.id, session.name]
   )
 
-  // Color of the left vertical bar — the workspace's stable accent (derived
-  // from its primary worktree id). Falls back to a tint for unhydrated sessions.
-  const barColor =
-    primaryWorktree != null
-      ? (primaryWorktree.color ?? getWorktreeColor(primaryWorktree.id))
-      : t.textMuted
-  // Working/waiting indicator overrides the colored bar — the user needs to
-  // see assistant activity from across the room.
-  let leadingGlyph = '▍'
-  let leadingColor = barColor
+  // Neutral muted marker; working/waiting overrides it. Keeping a glyph
+  // in the slot avoids name shifts when state indicators come and go.
+  let leadingGlyph = '•'
+  let leadingColor = t.textMuted
   if (showWaiting) {
     leadingGlyph = '?'
     leadingColor = waitingColor
@@ -379,7 +378,7 @@ const WorkspaceRow = memo(function WorkspaceRow({
         <text fg={leadingColor} selectable={false} wrapMode="none">
           {leadingGlyph}
         </text>
-        <text fg={isActiveItem ? t.text : t.textMuted} selectable={false} wrapMode="none">
+        <text fg={t.text} selectable={false} wrapMode="none">
           {' '}
           {nameLabel}
         </text>
@@ -387,7 +386,7 @@ const WorkspaceRow = memo(function WorkspaceRow({
       {showBranch ? (
         <box flexDirection="row">
           <text fg={t.textMuted} selectable={false} wrapMode="none">
-            {'  '}
+            {hasExtraWorktrees ? '│ ' : '  '}
             {'\u{e702}'} {branchLabel}
             {divergenceText !== '' ? ` ${divergenceText}` : ''}
           </text>

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

@@ -6,6 +6,7 @@ import type { SessionRecord, WorktreeRecord } from '../../../../state/types'
 
 import { useAppStore } from '../../../../state/app-store'
 import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-ref'
+import { formatDivergence } from '../../../../state/session-worktrees'
 import { useTheme } from '../../../theme'
 import { ContextMenuBox } from '../../overlays/context-menu/context-menu-box'
 
@@ -18,11 +19,14 @@ interface WorktreeRowProps {
   isActiveItem: boolean
   /** True when this row's workspace is the current session (selection scope). */
   inCurrentGroup: boolean
+  /** True when this is the last non-primary worktree of its workspace. Drives └─ vs ├─. */
+  isLast: boolean
 }
 
 export const WorktreeRow = memo(function WorktreeRow({
   inCurrentGroup,
   isActiveItem,
+  isLast,
   session,
   sessionIndex,
   worktree,
@@ -30,6 +34,7 @@ export const WorktreeRow = memo(function WorktreeRow({
   const t = useTheme()
   const currentSessionId = useAppStore((s) => s.currentSessionId)
   const isCurrentSession = session.id === currentSessionId
+  const divergence = useAppStore((s) => s.worktreeDivergence[worktree.id])
 
   const handleMouseDown = useCallback(
     (event: OtuiMouseEvent) => {
@@ -70,23 +75,40 @@ export const WorktreeRow = memo(function WorktreeRow({
     bgColor = t.backgroundPanel
   }
 
+  const connector = isLast ? '└─' : '├─'
+  const branchCont = isLast ? '   ' : '│  '
+  const branchText = worktree.branch ?? ''
+  const showBranch = branchText !== ''
+  const divergenceText = formatDivergence(divergence)
+
   return (
     <ContextMenuBox
       id={`sidebar-wt-${worktree.id}`}
-      flexDirection="row"
+      flexDirection="column"
+      flexShrink={0}
       paddingLeft={1}
       paddingRight={1}
-      alignItems="center"
       backgroundColor={bgColor}
       rightClickMenu={rightClickMenu}
       onMouseDown={handleMouseDown}
     >
-      <text fg={t.textMuted} selectable={false} wrapMode="none">
-        {'  > '}
-      </text>
-      <text fg={isActiveItem ? t.text : t.textMuted} selectable={false} wrapMode="none">
-        {worktree.name}
-      </text>
+      <box flexDirection="row" alignItems="center">
+        <text fg={t.textMuted} selectable={false} wrapMode="none">
+          {connector}{' '}
+        </text>
+        <text fg={t.text} selectable={false} wrapMode="none">
+          {worktree.name}
+        </text>
+      </box>
+      {showBranch ? (
+        <box flexDirection="row">
+          <text fg={t.textMuted} selectable={false} wrapMode="none">
+            {branchCont}
+            {'\u{e702}'} {branchText}
+            {divergenceText !== '' ? ` ${divergenceText}` : ''}
+          </text>
+        </box>
+      ) : null}
     </ContextMenuBox>
   )
 })

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

@@ -8,8 +8,10 @@ import type { FocusMode, TabSession, TerminalSnapshot, TerminalSpan } from '../.
 
 import { type MeasuredPaneRect, usePaneSizeReport } from '../../../app-runtime/use-pane-size-report'
 import { logInputDebug } from '../../../debug/input-log'
+import { useAppStore } from '../../../state/app-store'
 import { dispatchGlobal, runSideEffectGlobal } from '../../../state/dispatch-ref'
 import { type ContextMenuItem, openContextMenu } from '../../context-menu/controller'
+import { resolvePaletteIndex } from '../../host-palette'
 import { getCurrentTheme, useTheme } from '../../theme'
 import { ContextMenuBox } from '../overlays/context-menu/context-menu-box'
 
@@ -38,10 +40,16 @@ interface TerminalPaneProps {
 function getTitle(
   tab: TabSession | undefined,
   isActive: boolean,
-  focusMode: TerminalPaneProps['focusMode']
+  focusMode: TerminalPaneProps['focusMode'],
+  emptyContext: { workspaceName: string; worktreeName: string }
 ): string {
   if (!tab) {
-    return 'No active workspace'
+    const { workspaceName, worktreeName } = emptyContext
+    if (workspaceName === '' && worktreeName === '') return 'No active workspace'
+    if (worktreeName === '' || worktreeName === workspaceName) {
+      return `${workspaceName} · no tabs`
+    }
+    return `${workspaceName} / ${worktreeName} · no tabs`
   }
 
   if (isActive && focusMode === 'terminal-input') {
@@ -76,8 +84,16 @@ function renderSpan(span: TerminalSpan, key: string): ReactNode {
     node = <strong>{node}</strong>
   }
 
+  // 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 =
+    span.fgPalette !== undefined
+      ? resolvePaletteIndex(span.fgPalette)
+      : (span.fg ?? getCurrentTheme().text)
+  const bg = span.bgPalette !== undefined ? resolvePaletteIndex(span.bgPalette) : span.bg
+
   return (
-    <span key={key} fg={span.fg ?? getCurrentTheme().text} bg={span.bg}>
+    <span key={key} fg={fg} bg={bg}>
       {node}
     </span>
   )
@@ -137,6 +153,26 @@ export function TerminalPane({
   const setContentBox = usePaneSizeReport(tabId, !!tab, onMeasure)
   const editorBg = t.background
   const paneIsActive = isActive ?? true
+  // 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.
+  const emptyWorkspaceName = useAppStore((s) => {
+    const id = s.currentSessionId
+    if (id == null || id === '') return ''
+    return s.sessions.find((sess) => sess.id === id)?.name ?? ''
+  })
+  const emptyWorktreeName = useAppStore((s) => {
+    const id = s.currentSessionId
+    if (id == null || id === '') return ''
+    const session = s.sessions.find((sess) => sess.id === id)
+    if (!session) return ''
+    const activeId =
+      session.activeWorktreeId != null && session.activeWorktreeId !== ''
+        ? session.activeWorktreeId
+        : session.worktrees?.[0]?.id
+    if (activeId == null || activeId === '') return ''
+    return session.worktrees?.find((w) => w.id === activeId)?.name ?? ''
+  })
   const canForwardMouse = focusMode === 'terminal-input' && !!tab && mouseForwardingEnabled
   const canUseLocalScrollback = focusMode === 'terminal-input' && !!tab && localScrollbackEnabled
   const rightClickMenu = useMemo<ContextMenuItem[] | undefined>(
@@ -332,7 +368,10 @@ export function TerminalPane({
       <ContextMenuBox
         border
         borderColor={getBorderColor(paneIsActive, focusMode)}
-        title={getTitle(tab, paneIsActive, focusMode)}
+        title={getTitle(tab, paneIsActive, focusMode, {
+          workspaceName: emptyWorkspaceName,
+          worktreeName: emptyWorktreeName,
+        })}
         padding={0}
         flexDirection="column"
         flexGrow={1}
@@ -347,6 +386,19 @@ export function TerminalPane({
           <box flexGrow={1} justifyContent="center" alignItems="center" flexDirection="column">
             <text fg={t.textMuted}>· · ·</text>
             <text fg={t.textMuted}> </text>
+            {emptyWorkspaceName !== '' ? (
+              <box flexDirection="row">
+                <text fg={t.text}>{emptyWorkspaceName}</text>
+                {emptyWorktreeName !== '' && emptyWorktreeName !== emptyWorkspaceName ? (
+                  <>
+                    <text fg={t.textMuted}> / </text>
+                    <text fg={t.text}>{emptyWorktreeName}</text>
+                  </>
+                ) : null}
+              </box>
+            ) : null}
+            <text fg={t.textMuted}>has no tabs</text>
+            <text fg={t.textMuted}> </text>
             <box flexDirection="row">
               <text fg={t.textMuted}>Press </text>
               <text fg={t.primary}>Ctrl+n</text>

package/src/ui/components/layout/top-tab-bar.tsx

@@ -220,7 +220,9 @@ export function TopTabBar({ forceVisible = false }: TopTabBarProps) {
   }, [])
 
   if (!bar.visible && !forceVisible) return null
-  if (entries.length === 0) return null
+  // Keep the bar visible even with zero entries — when the active worktree
+  // has no tabs, the lone "+" affordance is what tells the user "you're in
+  // an empty worktree, click here to start one".
 
   const isFocused = focusMode === 'terminal-input' || focusMode === 'navigation'
 

package/src/ui/host-palette.ts

@@ -0,0 +1,75 @@
+// Resolves ANSI palette indices (0-255) to hex strings using the host
+// terminal's actual palette, queried via OSC 4 at startup (see index.tsx).
+//
+// Before detection completes — or when the host terminal doesn't respond —
+// FALLBACK_PALETTE (xterm defaults) is used. Indices ≥16 fall back to the
+// universal 6×6×6 cube + grayscale ramp, which every terminal agrees on.
+
+const FALLBACK_PALETTE: readonly string[] = [
+  '#000000',
+  '#cd0000',
+  '#00cd00',
+  '#cdcd00',
+  '#0000ee',
+  '#cd00cd',
+  '#00cdcd',
+  '#e5e5e5',
+  '#7f7f7f',
+  '#ff0000',
+  '#00ff00',
+  '#ffff00',
+  '#5c5cff',
+  '#ff00ff',
+  '#00ffff',
+  '#ffffff',
+]
+
+const CUBE_CHANNELS = [0, 95, 135, 175, 215, 255] as const
+
+const hostPalette: string[] = [...FALLBACK_PALETTE]
+
+function toHex(value: number): string {
+  return `#${value.toString(16).padStart(6, '0')}`
+}
+
+function paletteFromFormula(index: number): string {
+  if (index >= 232) {
+    const shade = 8 + (index - 232) * 10
+    return toHex((shade << 16) | (shade << 8) | shade)
+  }
+
+  const normalized = index - 16
+  const r = Math.floor(normalized / 36)
+  const g = Math.floor((normalized % 36) / 6)
+  const b = normalized % 6
+  return toHex(
+    ((CUBE_CHANNELS[r] ?? 0) << 16) | ((CUBE_CHANNELS[g] ?? 0) << 8) | (CUBE_CHANNELS[b] ?? 0)
+  )
+}
+
+/** Replace entries 0..N-1 of the resolver with values queried from the host
+ *  terminal. Null entries keep the existing fallback (terminal didn't respond
+ *  for that index). Safe to call before any snapshots have been rendered. */
+export function setHostPalette(palette: readonly (string | null)[]): void {
+  for (let index = 0; index < palette.length; index += 1) {
+    const value = palette[index]
+    if (typeof value === 'string' && value.length > 0) {
+      hostPalette[index] = value
+    }
+  }
+}
+
+/** Resolve an ANSI palette index (0-255) to a hex color. Indices 0-15 use
+ *  the host-queried palette (or xterm fallback); 16-255 use the universal
+ *  cube/grayscale formula unless the host explicitly customized them. */
+const BLACK = '#000000'
+const WHITE = '#ffffff'
+
+export function resolvePaletteIndex(index: number): string {
+  if (index < 0) return BLACK
+  const override = hostPalette[index]
+  if (typeof override === 'string' && override.length > 0) return override
+  if (index < 16) return FALLBACK_PALETTE.at(index) ?? BLACK
+  if (index > 255) return WHITE
+  return paletteFromFormula(index)
+}