@brimveyn/aimux 1.20.4 → 1.22.0

package/src/state/workspace-save.ts

@@ -1,45 +0,0 @@
-import type { AppState, SessionRecord } from './types'
-
-import { loadConfig, saveConfig } from '../config'
-import { saveSessionCatalog } from './session-catalog'
-import { serializeWorkspace } from './session-persistence'
-
-export function buildSessionsWithCurrentSnapshot(
-  sessions: SessionRecord[],
-  currentSessionId: string | null,
-  state: AppState
-): SessionRecord[] {
-  return sessions.map((session) =>
-    session.id === currentSessionId
-      ? {
-          ...session,
-          updatedAt: new Date().toISOString(),
-          workspaceSnapshot: serializeWorkspace(state),
-        }
-      : session
-  )
-}
-
-export function saveCurrentWorkspace(state: AppState): void {
-  saveConfig({
-    ...loadConfig(),
-    customCommands: state.customCommands,
-    gitPane: {
-      diffModeRatio: state.gitPane.diffModeRatio,
-      embeddedRatio: state.gitPane.embeddedRatio,
-      fileListMode: state.gitPane.fileListMode,
-      mode: state.gitPane.mode,
-      paneRatio: state.gitPane.paneRatio,
-      position: state.gitPane.position,
-      visible: state.gitPane.visible,
-    },
-    sessionBarVisible: state.sessionBar.visible,
-    sidebar: {
-      visible: state.sidebar.visible,
-      width: state.sidebar.width,
-    },
-  })
-  saveSessionCatalog(
-    buildSessionsWithCurrentSnapshot(state.sessions, state.currentSessionId, state)
-  )
-}

package/src/ui/components/git/pane/git-pane-context-menu.ts

@@ -1,26 +0,0 @@
-import type { GitPaneMode, GitPanePosition, GitPaneState } from '../../../../state/types'
-import type { ContextMenuItem } from '../../../context-menu/controller'
-
-const GIT_PANE_MENU_OPTIONS: {
-  label: string
-  mode: GitPaneMode
-  position: GitPanePosition
-}[] = [
-  { label: 'Move to top', mode: 'embedded', position: 'top' },
-  { label: 'Move to bottom', mode: 'embedded', position: 'bottom' },
-  { label: 'Move to left', mode: 'pane', position: 'left' },
-  { label: 'Move to right', mode: 'pane', position: 'right' },
-]
-
-export function buildGitPaneContextMenu(
-  gitPane: Pick<GitPaneState, 'mode' | 'position'>,
-  onToggle: () => void,
-  onMove: (mode: GitPaneMode, position: GitPanePosition) => void
-): ContextMenuItem[] {
-  return [
-    ['Toggle', onToggle],
-    ...GIT_PANE_MENU_OPTIONS.filter(
-      ({ mode, position }) => !(gitPane.mode === mode && gitPane.position === position)
-    ).map(({ label, mode, position }) => [label, () => onMove(mode, position)] as ContextMenuItem),
-  ]
-}

package/src/ui/components/layout/sidebar/sidebar.tsx

@@ -1,163 +0,0 @@
-import type { BoxRenderable, MouseEvent as OtuiMouseEvent } from '@opentui/core'
-
-import { useCallback, useMemo, useRef } from 'react'
-
-import { useAppStore } from '../../../../state/app-store'
-import { dispatchGlobal } from '../../../../state/dispatch-ref'
-import { useTheme } from '../../../theme'
-import { buildGitPaneContextMenu } from '../../git/pane/git-pane-context-menu'
-import { GitPaneWidget } from '../../git/pane/git-pane-widget'
-import { ContextMenuBox } from '../../overlays/context-menu/context-menu-box'
-import { WorkspaceList } from './workspace-list'
-
-interface SidebarProps {
-  onResizeDrag?: (event: OtuiMouseEvent) => boolean
-  onResizeDragEnd?: () => void
-  onEmbeddedGitResizeStart?: (info: {
-    containerStart: number
-    position: 'top' | 'bottom'
-    totalSize: number
-  }) => void
-}
-
-const RESIZE_HANDLE = '─'
-
-export function Sidebar({ onEmbeddedGitResizeStart, onResizeDrag, onResizeDragEnd }: SidebarProps) {
-  const t = useTheme()
-  const sidebarBg = t.background
-  const sidebarVisible = useAppStore((s) => s.sidebar.visible)
-  const sidebarWidth = useAppStore((s) => s.sidebar.width)
-  const gitPane = useAppStore((s) => s.gitPane)
-  const focusMode = useAppStore((s) => s.focusMode)
-  const bodyRef = useRef<BoxRenderable | null>(null)
-
-  const handleSidebarMouseDown = useCallback(() => {
-    if (focusMode === 'terminal-input') {
-      dispatchGlobal({ focusMode: 'navigation', type: 'set-focus-mode' })
-    }
-  }, [focusMode])
-  const handleSidebarMouseDrag = useCallback(
-    (event: OtuiMouseEvent) => {
-      if (onResizeDrag?.(event) === true) {
-        event.preventDefault()
-        event.stopPropagation()
-      }
-    },
-    [onResizeDrag]
-  )
-  const handleSidebarMouseUp = useCallback(() => {
-    onResizeDragEnd?.()
-  }, [onResizeDragEnd])
-  const handleEmbeddedHandleMouseDown = useCallback(
-    (event: OtuiMouseEvent) => {
-      const body = bodyRef.current
-      if (!body) return
-      event.preventDefault()
-      event.stopPropagation()
-      onEmbeddedGitResizeStart?.({
-        containerStart: body.y,
-        position: gitPane.position === 'top' ? 'top' : 'bottom',
-        totalSize: Math.max(1, body.height),
-      })
-    },
-    [gitPane.position, onEmbeddedGitResizeStart]
-  )
-  const sidebarMenu = useMemo<[string, () => void][]>(
-    () => [
-      ['Hide sidebar', () => dispatchGlobal({ type: 'toggle-sidebar' })],
-      ['Toggle git pane', () => dispatchGlobal({ type: 'toggle-git-pane' })],
-      [
-        'Toggle diff mode',
-        () => {
-          dispatchGlobal({ type: 'enter-git-mode' })
-          dispatchGlobal({ type: 'git-mode-toggle-diff-view' })
-        },
-      ],
-    ],
-    []
-  )
-
-  if (!sidebarVisible) {
-    return null
-  }
-
-  const gitEmbedded = gitPane.mode === 'embedded' && gitPane.visible
-  const gitOnTop = gitEmbedded && gitPane.position === 'top'
-  const gitOnBottom = gitEmbedded && gitPane.position === 'bottom'
-  const contentWidth = Math.max(1, sidebarWidth - 1)
-  const gitPaneMenu = buildGitPaneContextMenu(
-    gitPane,
-    () => dispatchGlobal({ type: 'toggle-git-pane' }),
-    (mode, position) => {
-      dispatchGlobal({ mode, type: 'set-git-pane-mode' })
-      dispatchGlobal({ position, type: 'set-git-pane-position' })
-    }
-  )
-
-  // flex-grow scaled by 100 (integer preferred); workspace list gets (1-ratio), git gets ratio.
-  const listGrow = gitEmbedded ? Math.max(1, Math.round((1 - gitPane.embeddedRatio) * 100)) : 1
-  const gitGrow = gitEmbedded ? Math.max(1, Math.round(gitPane.embeddedRatio * 100)) : 0
-
-  const gitBody = gitEmbedded ? (
-    <ContextMenuBox
-      flexDirection="column"
-      flexGrow={gitGrow}
-      flexShrink={1}
-      flexBasis={0}
-      overflow="hidden"
-      rightClickMenu={gitPaneMenu}
-    >
-      <GitPaneWidget pollingEnabled={gitPane.visible} />
-    </ContextMenuBox>
-  ) : null
-  const embeddedHandle = gitEmbedded ? (
-    <box minHeight={1} flexShrink={0} onMouseDown={handleEmbeddedHandleMouseDown}>
-      <text fg={t.border} selectable={false}>
-        {RESIZE_HANDLE.repeat(Math.max(1, contentWidth))}
-      </text>
-    </box>
-  ) : null
-
-  return (
-    <ContextMenuBox
-      width={sidebarWidth}
-      padding={0}
-      flexDirection="column"
-      backgroundColor={sidebarBg}
-      gap={0}
-      overflow="hidden"
-      rightClickMenu={sidebarMenu}
-      onMouseDown={handleSidebarMouseDown}
-      onMouseDrag={handleSidebarMouseDrag}
-      onMouseUp={handleSidebarMouseUp}
-    >
-      <box flexDirection="row" width={sidebarWidth} flexGrow={1} overflow="hidden">
-        <box width={contentWidth} flexGrow={1} flexDirection="column" overflow="hidden">
-          <box ref={bodyRef} flexDirection="column" flexGrow={1} overflow="hidden">
-            {gitOnTop ? (
-              <>
-                {gitBody}
-                {embeddedHandle}
-              </>
-            ) : null}
-            <box
-              flexDirection="column"
-              flexGrow={listGrow}
-              flexShrink={1}
-              flexBasis={0}
-              overflow="hidden"
-            >
-              <WorkspaceList contentWidth={contentWidth} />
-            </box>
-            {gitOnBottom ? (
-              <>
-                {embeddedHandle}
-                {gitBody}
-              </>
-            ) : null}
-          </box>
-        </box>
-      </box>
-    </ContextMenuBox>
-  )
-}

package/src/ui/components/layout/sidebar/use-top-tab-bar-auto-scroll.ts

@@ -1,30 +0,0 @@
-import type { ScrollBoxRenderable } from '@opentui/core'
-
-import { useEffect } from 'react'
-
-interface Options {
-  scrollRef: React.RefObject<ScrollBoxRenderable | null>
-  visible: boolean
-  activeTabId: string | null
-  idPrefix: string
-}
-
-/**
- * Scroll the active tab into view whenever the active tab id changes (and on
- * first reveal). The top bar is a single horizontal row, so this is just a
- * thin wrapper around `scrollChildIntoView` — no wrap-around/edge heuristics.
- */
-export function useTopTabBarAutoScroll({
-  activeTabId,
-  idPrefix,
-  scrollRef,
-  visible,
-}: Options): void {
-  useEffect(() => {
-    if (!visible) return
-    if (activeTabId == null || activeTabId === '') return
-    const scrollbox = scrollRef.current
-    if (!scrollbox) return
-    scrollbox.scrollChildIntoView(`${idPrefix}${activeTabId}`)
-  }, [activeTabId, idPrefix, scrollRef, visible])
-}

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

@@ -1,418 +0,0 @@
-import type {
-  BoxRenderable,
-  MouseEvent as OtuiMouseEvent,
-  ScrollBoxRenderable,
-} from '@opentui/core'
-
-import { memo, type ReactNode, useCallback, useMemo, useRef, useState } from 'react'
-
-import type { SessionRecord, SessionStatus, WorktreeRecord } from '../../../../state/types'
-
-import { useAppStore } from '../../../../state/app-store'
-import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-ref'
-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'
-import { moveIdToIdPosition, orderSessionsForDisplay } from '../../../session-ordering'
-import { useBaseTheme, useTheme } from '../../../theme'
-import { FlashLabelBadge } from '../../flash/flash-label-badge'
-import { ContextMenuBox } from '../../overlays/context-menu/context-menu-box'
-import { useSidebarAutoScroll } from './use-sidebar-auto-scroll'
-import { WorktreeRow } from './worktree-row'
-
-interface WorkspaceListProps {
-  contentWidth: number
-}
-
-const COLUMN_CONTENT_OPTIONS = { flexDirection: 'column' as const, gap: 0 }
-
-function arraysEqual(a: string[], b: string[]): boolean {
-  if (a.length !== b.length) return false
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false
-  }
-  return true
-}
-
-function truncate(label: string, max: number): string {
-  if (max <= 0) return ''
-  if (label.length <= max) return label
-  if (max === 1) return '…'
-  return `${label.slice(0, max - 1)}…`
-}
-
-export function WorkspaceList({ contentWidth }: WorkspaceListProps) {
-  const t = useTheme()
-  const sessions = useAppStore((s) => s.sessions)
-  const currentSessionId = useAppStore((s) => s.currentSessionId)
-  const statusMap = useAppStore((s) => s.sessionStatuses)
-
-  const [draggingId, setDraggingId] = useState<string | null>(null)
-  const [dragOrder, setDragOrder] = useState<string[] | null>(null)
-  const lastSwapWithRef = useRef<string | null>(null)
-  const rowRefs = useRef(new Map<string, BoxRenderable>())
-  const scrollRef = useRef<ScrollBoxRenderable | null>(null)
-
-  const ordered = useMemo(() => orderSessionsForDisplay(sessions), [sessions])
-  const baselineOrder = useMemo(() => ordered.map((s) => s.id), [ordered])
-
-  const currentSession = useMemo(
-    () =>
-      currentSessionId != null && currentSessionId !== ''
-        ? sessions.find((s) => s.id === currentSessionId)
-        : undefined,
-    [currentSessionId, sessions]
-  )
-  // The active row can be either a worktree row OR the workspace row
-  // (when the primary worktree is active). Both must scroll into view —
-  // otherwise the cursor visually "disappears" off-screen when crossing
-  // a workspace boundary on a key press.
-  const currentWorktrees = currentSession?.worktrees ?? []
-  const currentPrimary = currentWorktrees.find((w) => w.source === 'primary') ?? currentWorktrees[0]
-  const rawActiveWorktreeId = currentSession?.activeWorktreeId
-  const activeOnNonPrimary =
-    rawActiveWorktreeId != null &&
-    rawActiveWorktreeId !== '' &&
-    rawActiveWorktreeId !== currentPrimary?.id
-  let activeRowId: string | null = null
-  if (activeOnNonPrimary) {
-    activeRowId = `sidebar-wt-${rawActiveWorktreeId}`
-  } else if (currentSessionId != null && currentSessionId !== '') {
-    activeRowId = `sidebar-ws-${currentSessionId}`
-  }
-
-  useSidebarAutoScroll({
-    activeRowId,
-    scrollRef,
-    visible: true,
-  })
-
-  const setRowRef = useCallback((id: string, ref: BoxRenderable | null): void => {
-    if (ref) rowRefs.current.set(id, ref)
-    else rowRefs.current.delete(id)
-  }, [])
-
-  const findRowAtY = useCallback((y: number): string | null => {
-    for (const [id, ref] of rowRefs.current) {
-      if (y >= ref.y && y < ref.y + ref.height) return id
-    }
-    return null
-  }, [])
-
-  const handleRowDragStart = useCallback(
-    (id: string) => {
-      setDraggingId(id)
-      setDragOrder(baselineOrder)
-      lastSwapWithRef.current = null
-    },
-    [baselineOrder]
-  )
-
-  const handleRowDrag = useCallback(
-    (event: OtuiMouseEvent) => {
-      if (!(draggingId != null && draggingId !== '')) return
-      const hit = findRowAtY(event.y)
-      if (hit === null) {
-        lastSwapWithRef.current = null
-        return
-      }
-      if (hit === draggingId) {
-        lastSwapWithRef.current = null
-        return
-      }
-      if (hit === lastSwapWithRef.current) return
-      setDragOrder((prev) => (prev ? moveIdToIdPosition(prev, draggingId, hit) : prev))
-      lastSwapWithRef.current = hit
-    },
-    [draggingId, findRowAtY]
-  )
-
-  const commitDrop = useCallback(() => {
-    const source = draggingId
-    const finalOrder = dragOrder
-    setDraggingId(null)
-    setDragOrder(null)
-    lastSwapWithRef.current = null
-
-    if (source == null || source === '' || !finalOrder) return
-
-    const changed = !arraysEqual(finalOrder, baselineOrder)
-    if (changed) {
-      dispatchGlobal({ orderedIds: finalOrder, type: 'reorder-sessions' })
-      return
-    }
-
-    const idx = baselineOrder.indexOf(source)
-    if (idx >= 0) {
-      // The workspace row visually anchors the session's primary worktree
-      // (its branch line shows the primary's branch). Clicking it should
-      // land on the primary — same semantics as j/k cycling onto a workspace
-      // item — instead of preserving whatever non-primary worktree happened
-      // to be active last time we left this session.
-      const sourceSession = ordered.find((s) => s.id === source)
-      const sourceWorktrees = sourceSession?.worktrees ?? []
-      const sourcePrimaryId = (
-        sourceWorktrees.find((w) => w.source === 'primary') ?? sourceWorktrees[0]
-      )?.id
-      runSideEffectGlobal({
-        index: idx + 1,
-        type: 'switch-session-by-index',
-        worktreeId: sourcePrimaryId,
-      })
-    }
-  }, [baselineOrder, dragOrder, draggingId, ordered])
-
-  const cancelDrag = useCallback(() => {
-    setDraggingId(null)
-    setDragOrder(null)
-    lastSwapWithRef.current = null
-  }, [])
-
-  const handleNewSession = useCallback((e: OtuiMouseEvent) => {
-    e.stopPropagation()
-    e.preventDefault()
-    dispatchGlobal({ returnToSessionPicker: false, type: 'open-create-session-modal' })
-  }, [])
-
-  const visibleSessions =
-    dragOrder !== null
-      ? dragOrder
-          .map((id) => ordered.find((s) => s.id === id))
-          .filter((s): s is SessionRecord => !!s)
-      : ordered
-
-  return (
-    <box flexDirection="column" flexGrow={1} flexShrink={1} overflow="hidden">
-      <scrollbox
-        ref={scrollRef}
-        scrollY
-        flexGrow={1}
-        flexShrink={1}
-        contentOptions={COLUMN_CONTENT_OPTIONS}
-      >
-        {(() => {
-          // Build a single flat list of items — workspace rows interleaved
-          // with their non-primary worktrees. One map, one React keypath per
-          // visible row; transitions are a single atomic reconciliation.
-          const rows: ReactNode[] = []
-          for (const [visibleIdx, session] of visibleSessions.entries()) {
-            const sessionIndex = baselineOrder.indexOf(session.id) + 1
-            const isCurrentSession = session.id === currentSessionId
-            const worktrees = session.worktrees ?? []
-            const primaryWorktree = worktrees.find((w) => w.source === 'primary') ?? worktrees[0]
-            const extraWorktrees = worktrees.filter((w) => w.id !== primaryWorktree?.id)
-            const workspaceIsActiveItem =
-              isCurrentSession &&
-              (session.activeWorktreeId == null ||
-                session.activeWorktreeId === '' ||
-                session.activeWorktreeId === primaryWorktree?.id)
-            rows.push(
-              <WorkspaceRow
-                key={`ws:${session.id}`}
-                session={session}
-                isActiveItem={workspaceIsActiveItem}
-                inCurrentGroup={isCurrentSession}
-                primaryWorktree={primaryWorktree}
-                hasExtraWorktrees={extraWorktrees.length > 0}
-                status={statusMap[session.id] ?? IDLE_SESSION_STATUS}
-                dragging={draggingId === session.id}
-                contentWidth={contentWidth}
-                marginTop={visibleIdx > 0 ? 1 : 0}
-                setRowRef={setRowRef}
-                onDragStart={handleRowDragStart}
-                onDrag={handleRowDrag}
-                onDrop={commitDrop}
-                onDragCancel={cancelDrag}
-              />
-            )
-            for (const [wtIdx, worktree] of extraWorktrees.entries()) {
-              rows.push(
-                <WorktreeRow
-                  key={`wt:${worktree.id}`}
-                  session={session}
-                  worktree={worktree}
-                  sessionIndex={sessionIndex}
-                  isActiveItem={isCurrentSession && worktree.id === session.activeWorktreeId}
-                  inCurrentGroup={isCurrentSession}
-                  isLast={wtIdx === extraWorktrees.length - 1}
-                />
-              )
-            }
-          }
-          return rows
-        })()}
-      </scrollbox>
-      <box
-        flexDirection="row"
-        flexShrink={0}
-        marginTop={1}
-        backgroundColor={t.backgroundPanel}
-        justifyContent="center"
-        onMouseDown={handleNewSession}
-      >
-        <text fg={t.text} selectable={false}>
-          + New workspace
-        </text>
-      </box>
-    </box>
-  )
-}
-
-interface WorkspaceRowProps {
-  session: SessionRecord
-  /** True when this row is the active cursor item (workspace's primary active). */
-  isActiveItem: boolean
-  /** True when this row belongs to the current workspace (selection scope). */
-  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
-  /** Vertical spacing above this row — used to separate workspace blocks. */
-  marginTop: number
-  setRowRef: (id: string, ref: BoxRenderable | null) => void
-  onDragStart: (id: string) => void
-  onDrag: (event: OtuiMouseEvent) => void
-  onDrop: () => void
-  onDragCancel: () => void
-}
-
-const WorkspaceRow = memo(function WorkspaceRow({
-  contentWidth,
-  dragging,
-  hasExtraWorktrees,
-  inCurrentGroup,
-  isActiveItem,
-  marginTop,
-  onDrag,
-  onDragCancel,
-  onDragStart,
-  onDrop,
-  primaryWorktree,
-  session,
-  setRowRef,
-  status,
-}: WorkspaceRowProps) {
-  const t = useTheme()
-  // Selection highlight must stay opaque in transparent mode — otherwise the
-  // cursor row visually disappears against the see-through chrome.
-  const base = useBaseTheme()
-  const showSpinner = status.working
-  const showWaiting = status.waiting
-  const spinner = useBusySpinner(showSpinner)
-  let bgColor: string | undefined
-  if (dragging || isActiveItem) {
-    bgColor = base.backgroundElement
-  } else if (inCurrentGroup) {
-    bgColor = base.backgroundPanel
-  }
-  const workingColor = t.primary
-  const waitingColor = t.warning
-  const divergence = useAppStore((s) =>
-    primaryWorktree ? s.worktreeDivergence[primaryWorktree.id] : undefined
-  )
-
-  const handleRef = useCallback(
-    (r: BoxRenderable | null) => setRowRef(session.id, r),
-    [setRowRef, session.id]
-  )
-  const handleMouseDown = useCallback(
-    (e: OtuiMouseEvent) => {
-      e.preventDefault()
-      e.stopPropagation()
-      onDragStart(session.id)
-    },
-    [onDragStart, session.id]
-  )
-  const handleMouseUp = useCallback(
-    (e: OtuiMouseEvent) => {
-      e.preventDefault()
-      onDrop()
-    },
-    [onDrop]
-  )
-  const rightClickMenu = useMemo<[string, () => void][]>(
-    () => [
-      [
-        'Rename workspace',
-        () =>
-          dispatchGlobal({
-            initialName: session.name,
-            returnToSessionPicker: false,
-            sessionTargetId: session.id,
-            type: 'open-session-name-modal',
-          }),
-      ],
-      [
-        'Delete workspace',
-        () => runSideEffectGlobal({ sessionId: session.id, type: 'delete-session' }),
-      ],
-    ],
-    [session.id, session.name]
-  )
-
-  // 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
-  } else if (showSpinner) {
-    leadingGlyph = spinner
-    leadingColor = workingColor
-  }
-
-  const branchText = primaryWorktree?.branch ?? ''
-  const divergenceText = formatDivergence(divergence)
-  const showBranch = branchText !== ''
-  const nameLabel = truncate(session.name, Math.max(0, contentWidth - 4))
-  const branchLabel = truncate(
-    branchText,
-    Math.max(0, contentWidth - 5 - (divergenceText.length + 1))
-  )
-
-  return (
-    <ContextMenuBox
-      ref={handleRef}
-      id={`sidebar-ws-${session.id}`}
-      flexDirection="column"
-      flexShrink={0}
-      marginTop={marginTop}
-      paddingLeft={1}
-      paddingRight={1}
-      backgroundColor={bgColor}
-      rightClickMenu={rightClickMenu}
-      onMouseDown={handleMouseDown}
-      onMouseDrag={onDrag}
-      onMouseUp={handleMouseUp}
-      onMouseDragEnd={onDragCancel}
-    >
-      <box flexDirection="row" alignItems="center">
-        <text fg={leadingColor} selectable={false} wrapMode="none">
-          {leadingGlyph}
-        </text>
-        <text fg={t.text} selectable={false} wrapMode="none">
-          {' '}
-        </text>
-        <FlashLabelBadge rowKey={`ws:${session.id}`} />
-        <text fg={t.text} selectable={false} wrapMode="none">
-          {nameLabel}
-        </text>
-      </box>
-      {showBranch ? (
-        <box flexDirection="row">
-          <text fg={t.textMuted} selectable={false} wrapMode="none">
-            {hasExtraWorktrees ? '│ ' : '  '}
-            {'\u{e702}'} {branchLabel}
-            {divergenceText !== '' ? ` ${divergenceText}` : ''}
-          </text>
-        </box>
-      ) : null}
-    </ContextMenuBox>
-  )
-})