@brimveyn/aimux 1.21.0 → 1.22.2

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

@@ -1,262 +0,0 @@
-import type { AppAction, AppState } from '../types'
-
-import { moveIdToIdPosition, orderSessionsForDisplay } from '../../ui/session-ordering'
-import { filterSessions } from '../selectors'
-import { restoreWorkspaceState } from '../session-persistence'
-import { filterTabsForActiveWorktree, withActiveWorktree } from '../session-worktrees'
-
-const CLOSED_MODAL = {
-  editBuffer: null,
-  selectedIndex: 0,
-  sessionTargetId: null,
-  type: null,
-} as const
-
-export function reduceSessionState(state: AppState, action: AppAction): AppState | null {
-  switch (action.type) {
-    case 'load-session': {
-      const snapshot =
-        action.workspaceSnapshot ??
-        state.sessions.find((entry) => entry.id === action.sessionId)?.workspaceSnapshot
-      // 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 loadedWorktrees = loadedSession?.worktrees ?? []
-      const restored = restoreWorkspaceState(state, snapshot, {
-        forceDisconnected: action.forceDisconnected ?? true,
-        // Drop tabs bound to worktrees this session no longer owns so a stale
-        // id can't be caught by a later worktree delete (closing "another
-        // worktree's" tabs) and so corrupted catalogs self-heal on load. Only
-        // prune once the session has worktrees — an empty list means it hasn't
-        // been initialized yet, and pruning then would wrongly drop bound tabs.
-        validWorktreeIds:
-          loadedWorktrees.length > 0 ? new Set(loadedWorktrees.map((w) => w.id)) : undefined,
-      })
-      const visible = filterTabsForActiveWorktree(restored.tabs, loadedSession)
-      // Prefer the snapshot's tab; if it isn't visible under the active
-      // worktree (e.g. a multi-worktree session restored onto a different
-      // worktree), fall back to the last tab we viewed in that worktree,
-      // then to the first visible tab.
-      const rememberedForWorktree =
-        loadedSession?.activeWorktreeId != null && loadedSession.activeWorktreeId !== ''
-          ? state.lastActiveTabByWorktree[loadedSession.activeWorktreeId]
-          : undefined
-      const snapshotTabVisible =
-        restored.activeTabId != null &&
-        restored.activeTabId !== '' &&
-        visible.some((t) => t.id === restored.activeTabId)
-      const rememberedTabVisible =
-        rememberedForWorktree != null &&
-        rememberedForWorktree !== '' &&
-        visible.some((t) => t.id === rememberedForWorktree)
-      const fallbackTabId = rememberedTabVisible ? rememberedForWorktree : (visible[0]?.id ?? null)
-      const activeTabId = snapshotTabVisible ? restored.activeTabId : fallbackTabId
-      return {
-        ...state,
-        ...restored,
-        activeTabId,
-        currentSessionId: action.sessionId,
-        focusMode: 'navigation',
-        modal: CLOSED_MODAL,
-        sessions: state.sessions.map((entry) =>
-          entry.id === action.sessionId
-            ? {
-                ...entry,
-                lastOpenedAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-              }
-            : entry
-        ),
-      }
-    }
-    case 'set-sessions':
-      return { ...state, sessions: action.sessions }
-    case 'create-session-record':
-      return {
-        ...state,
-        currentSessionId: action.session.id,
-        focusMode: 'navigation',
-        modal: CLOSED_MODAL,
-        sessions: [...state.sessions, action.session],
-      }
-    case 'rename-session-record':
-      return {
-        ...state,
-        sessions: state.sessions.map((session) =>
-          session.id === action.sessionId
-            ? { ...session, name: action.name, updatedAt: new Date().toISOString() }
-            : session
-        ),
-      }
-    case 'delete-session-record': {
-      const deletingCurrent = action.sessionId === state.currentSessionId
-      const newSessions = state.sessions.filter((session) => session.id !== action.sessionId)
-      const nextStatuses = { ...state.sessionStatuses }
-      delete nextStatuses[action.sessionId]
-      if (action.openSessionPicker === true) {
-        const filteredNew = filterSessions(newSessions, state.modal.editBuffer)
-        const maxIndex = filteredNew.length
-        const clampedIndex = Math.min(state.modal.selectedIndex, maxIndex)
-        return {
-          ...state,
-          activeTabId: deletingCurrent ? null : state.activeTabId,
-          currentSessionId: deletingCurrent ? null : state.currentSessionId,
-          focusMode: 'modal',
-          modal: {
-            editBuffer: null,
-            selectedIndex: clampedIndex,
-            sessionTargetId: null,
-            type: 'session-picker',
-          },
-          sessions: newSessions,
-          sessionStatuses: nextStatuses,
-          tabs: deletingCurrent ? [] : state.tabs,
-        }
-      }
-      return {
-        ...state,
-        activeTabId: deletingCurrent ? null : state.activeTabId,
-        currentSessionId: deletingCurrent ? null : state.currentSessionId,
-        focusMode: deletingCurrent ? 'navigation' : state.focusMode,
-        modal: deletingCurrent ? CLOSED_MODAL : state.modal,
-        sessions: newSessions,
-        sessionStatuses: nextStatuses,
-        tabs: deletingCurrent ? [] : state.tabs,
-      }
-    }
-    case 'reorder-sessions': {
-      const byId = new Map(state.sessions.map((s) => [s.id, s]))
-      const ordered: typeof state.sessions = []
-      let idx = 0
-      for (const id of action.orderedIds) {
-        const s = byId.get(id)
-        if (s) {
-          ordered.push({ ...s, order: idx })
-          byId.delete(id)
-        }
-        idx++
-      }
-      let nextOrder = ordered.length
-      for (const s of byId.values()) {
-        ordered.push({ ...s, order: nextOrder++ })
-      }
-      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 (
-        prev !== undefined &&
-        prev.working === action.status.working &&
-        prev.waiting === action.status.waiting
-      ) {
-        return state
-      }
-      return {
-        ...state,
-        sessionStatuses: { ...state.sessionStatuses, [action.sessionId]: action.status },
-      }
-    }
-    case 'add-worktree-record':
-      return {
-        ...state,
-        sessions: state.sessions.map((session) => {
-          if (session.id !== action.sessionId) return session
-          const next = {
-            ...session,
-            activeWorktreeId:
-              action.activate === true ? action.worktree.id : session.activeWorktreeId,
-            projectPath: action.activate === true ? action.worktree.path : session.projectPath,
-            updatedAt: new Date().toISOString(),
-            worktrees: [...(session.worktrees ?? []), action.worktree],
-          }
-          return next.activeWorktreeId != null && next.activeWorktreeId !== ''
-            ? next
-            : withActiveWorktree(next, action.worktree.id)
-        }),
-      }
-    case 'set-active-worktree': {
-      const sessions = state.sessions.map((session) =>
-        session.id === action.sessionId ? withActiveWorktree(session, action.worktreeId) : session
-      )
-      // Remember the tab we're leaving so coming back to this worktree later
-      // restores it instead of snapping to the first tab. Keyed by the
-      // worktree we're departing (the current session's active one).
-      const leavingSession = state.sessions.find((s) => s.id === action.sessionId)
-      const leavingWorktreeId = leavingSession?.activeWorktreeId
-      const lastActiveTabByWorktree =
-        action.sessionId === state.currentSessionId &&
-        leavingWorktreeId != null &&
-        leavingWorktreeId !== '' &&
-        state.activeTabId != null &&
-        state.activeTabId !== ''
-          ? { ...state.lastActiveTabByWorktree, [leavingWorktreeId]: state.activeTabId }
-          : state.lastActiveTabByWorktree
-      // 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, lastActiveTabByWorktree, sessions }
-      }
-      // For the current session: if the existing activeTabId belongs to
-      // the new worktree, keep it. Otherwise restore the last tab we viewed
-      // in that worktree, falling back to the first visible tab (or clearing
-      // 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, lastActiveTabByWorktree, sessions }
-      }
-      const remembered = lastActiveTabByWorktree[action.worktreeId]
-      const nextActiveTabId =
-        remembered != null && remembered !== '' && visible.some((t) => t.id === remembered)
-          ? remembered
-          : (visible[0]?.id ?? null)
-      return { ...state, activeTabId: nextActiveTabId, lastActiveTabByWorktree, sessions }
-    }
-    case 'update-worktree-record':
-      return {
-        ...state,
-        sessions: state.sessions.map((session) =>
-          session.id === action.sessionId
-            ? {
-                ...session,
-                updatedAt: new Date().toISOString(),
-                worktrees: session.worktrees?.map((worktree) =>
-                  worktree.id === action.worktreeId
-                    ? { ...worktree, ...action.patch, updatedAt: new Date().toISOString() }
-                    : worktree
-                ),
-              }
-            : session
-        ),
-      }
-    default:
-      return null
-  }
-}

package/src/state/session-catalog.ts

@@ -1,143 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-import type { SessionRecord } from './types'
-
-import { loadConfig, saveConfig } from '../config'
-import { logDebug } from '../debug/input-log'
-import { getProfileConfigDir } from '../profile-paths'
-import { ensureSessionWorktrees } from './session-worktrees'
-import { toast } from './toast-store'
-import { isSessionRecord } from './validation'
-
-interface SessionCatalogFile {
-  version: 1
-  sessions: SessionRecord[]
-}
-
-const SESSIONS_PATH = join(getProfileConfigDir(), 'aimux-sessions.json')
-
-function readCatalogFile(): { file: SessionCatalogFile | null; issue?: string } {
-  try {
-    if (!existsSync(SESSIONS_PATH)) {
-      return { file: null }
-    }
-
-    const parsed = JSON.parse(readFileSync(SESSIONS_PATH, 'utf8')) as {
-      version?: unknown
-      sessions?: unknown
-    }
-    if (parsed.version !== 1 || !Array.isArray(parsed.sessions)) {
-      return { file: null, issue: 'invalid session catalog header' }
-    }
-
-    if (!parsed.sessions.every(isSessionRecord)) {
-      return { file: null, issue: 'invalid session catalog entries' }
-    }
-
-    return { file: { sessions: parsed.sessions, version: 1 } }
-  } catch (error) {
-    return {
-      file: null,
-      issue: `failed to load session catalog: ${error instanceof Error ? error.message : String(error)}`,
-    }
-  }
-}
-
-export function loadSessionCatalog(): SessionRecord[] {
-  const { file, issue } = readCatalogFile()
-  if (file) {
-    logDebug('sessions.catalog.load', { sessionCount: file.sessions.length })
-    const normalized = normalizeSessions(file.sessions)
-    if (JSON.stringify(normalized) !== JSON.stringify(file.sessions)) {
-      saveSessionCatalog(normalized)
-    }
-    return normalized
-  }
-
-  if (issue != null && issue !== '') {
-    logDebug('sessions.catalog.loadIssue', { issue, path: SESSIONS_PATH })
-  }
-
-  const config = loadConfig()
-  if (!config.workspaceSnapshot) {
-    logDebug('sessions.catalog.load', { sessionCount: 0 })
-    return []
-  }
-
-  const now = new Date().toISOString()
-  const migrated: SessionRecord = {
-    createdAt: now,
-    id: `session-${Date.now()}`,
-    lastOpenedAt: now,
-    name: 'Last workspace',
-    updatedAt: now,
-    workspaceSnapshot: config.workspaceSnapshot,
-  }
-
-  const normalized = normalizeSessions([migrated])
-  saveSessionCatalog(normalized)
-  saveConfig({ ...config, workspaceSnapshot: undefined })
-  logDebug('sessions.catalog.migrateLegacyWorkspace', {
-    migratedSessionId: migrated.id,
-    tabCount: migrated.workspaceSnapshot?.tabs.length ?? 0,
-  })
-  return normalized
-}
-
-export function saveSessionCatalog(sessions: SessionRecord[]): void {
-  try {
-    mkdirSync(getProfileConfigDir(), { recursive: true })
-    writeFileSync(SESSIONS_PATH, `${JSON.stringify({ sessions, version: 1 }, null, 2)}\n`)
-    logDebug('sessions.catalog.save', { sessionCount: sessions.length })
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    logDebug('sessions.catalog.saveError', {
-      error: message,
-      path: SESSIONS_PATH,
-      sessionCount: sessions.length,
-    })
-    // Persisting the catalog underpins workspace/worktree state — a silent
-    // failure means the user loses sessions on restart. Surface it.
-    toast.error(`Failed to save sessions: ${message}`)
-  }
-}
-
-export function getSessionCatalogPath(): string {
-  return SESSIONS_PATH
-}
-
-export function findMostRecentSession(sessions: SessionRecord[]): SessionRecord | undefined {
-  let best: SessionRecord | undefined
-  for (const candidate of sessions) {
-    if (!best || candidate.lastOpenedAt.localeCompare(best.lastOpenedAt) > 0) {
-      best = candidate
-    }
-  }
-  return best
-}
-
-/**
- * Assign a stable `order` to every session. Records with an existing numeric
- * `order` keep their slot (sorted ascending); the rest are appended by
- * createdAt ascending so older sessions come first.
- */
-function normalizeOrder(sessions: SessionRecord[]): SessionRecord[] {
-  const withOrder: SessionRecord[] = []
-  const withoutOrder: SessionRecord[] = []
-  for (const s of sessions) {
-    if (typeof s.order === 'number' && Number.isFinite(s.order)) {
-      withOrder.push(s)
-    } else {
-      withoutOrder.push(s)
-    }
-  }
-  withOrder.sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
-  withoutOrder.sort((a, b) => a.createdAt.localeCompare(b.createdAt))
-  const merged = [...withOrder, ...withoutOrder]
-  return merged.map((s, i) => (s.order === i ? s : { ...s, order: i }))
-}
-
-function normalizeSessions(sessions: SessionRecord[]): SessionRecord[] {
-  return normalizeOrder(sessions).map((session) => ensureSessionWorktrees(session))
-}

package/src/state/session-worktrees.ts

@@ -1,260 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import { createHash } from 'node:crypto'
-import { existsSync } from 'node:fs'
-import { basename } from 'node:path'
-
-import type { BranchDivergence, SessionRecord, TabSession, WorktreeRecord } from './types'
-
-import { createPrefixedId } from '../platform/id'
-import { isInsideAimuxWorktreeRoot } from '../platform/worktree-paths'
-
-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 createPrimaryWorktree(projectPath: string, now: string): WorktreeRecord {
-  const id = createPrefixedId('worktree')
-  return {
-    createdAt: now,
-    createdByAimux: false,
-    id,
-    name: basename(projectPath) || projectPath,
-    path: projectPath,
-    repoRoot: projectPath,
-    source: 'primary',
-    updatedAt: now,
-  }
-}
-
-export function ensureSessionWorktrees(
-  session: SessionRecord,
-  now = new Date().toISOString()
-): SessionRecord {
-  if (session.worktrees?.length != null && session.worktrees?.length !== 0) {
-    const worktrees = mergeExistingGitWorktrees(
-      pruneMissingAimuxTempWorktrees(session.worktrees),
-      now
-    )
-    if (worktrees.length === 0 && session.projectPath != null && session.projectPath !== '') {
-      const worktree = createPrimaryWorktree(session.projectPath, now)
-      return { ...session, activeWorktreeId: worktree.id, worktrees: [worktree] }
-    }
-    const activeWorktreeId = worktrees.some((w) => w.id === session.activeWorktreeId)
-      ? session.activeWorktreeId
-      : worktrees[0]?.id
-    const active = worktrees.find((w) => w.id === activeWorktreeId)
-    return {
-      ...session,
-      activeWorktreeId,
-      projectPath: active?.path ?? session.projectPath,
-      worktrees,
-    }
-  }
-
-  if (!(session.projectPath != null && session.projectPath !== '')) {
-    return session
-  }
-
-  const worktree = createPrimaryWorktree(session.projectPath, now)
-  const worktrees = mergeExistingGitWorktrees([worktree], now)
-  return {
-    ...session,
-    activeWorktreeId:
-      worktrees.find((entry) => entry.path === session.projectPath)?.id ?? worktree.id,
-    worktrees,
-  }
-}
-
-function stableWorktreeId(path: string): string {
-  return `worktree-${createHash('sha1').update(path).digest('hex').slice(0, 10)}`
-}
-
-function mergeExistingGitWorktrees(worktrees: WorktreeRecord[], now: string): WorktreeRecord[] {
-  const anchor = worktrees.find((worktree) => existsSync(worktree.path)) ?? worktrees[0]
-  if (!anchor) return worktrees
-  const discovered = listGitWorktreesSync(anchor.path)
-  if (discovered.length === 0) return worktrees
-
-  // Git keeps admin entries for worktrees whose directory is gone (e.g. a temp
-  // dir cleared on reboot). Drop that stale state so the entries stop
-  // resurfacing in `git worktree list`, and ignore them while reconciling.
-  if (discovered.some((entry) => entry.prunable === true)) {
-    pruneGitWorktreesSync(anchor.path)
-  }
-  const live = discovered.filter((entry) => entry.prunable !== true)
-
-  const byPath = new Map(worktrees.map((worktree) => [worktree.path, worktree]))
-  // `git worktree list` reports the main worktree first; prefer the primary
-  // record's repoRoot when it still exists, then git's main worktree.
-  const primaryRepoRoot = worktrees.find((worktree) => worktree.source === 'primary')?.repoRoot
-  const repoRoot =
-    primaryRepoRoot !== undefined && existsSync(primaryRepoRoot)
-      ? primaryRepoRoot
-      : (live[0]?.path ?? anchor.repoRoot)
-  for (const entry of live) {
-    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,
-      commitSha: entry.head,
-      createdAt: now,
-      createdByAimux: false,
-      id: stableWorktreeId(entry.path),
-      name: basename(entry.path) || entry.path,
-      path: entry.path,
-      repoRoot,
-      source: 'external',
-      updatedAt: now,
-    }
-    byPath.set(entry.path, worktree)
-  }
-  return (
-    [...byPath.values()]
-      // Drop records whose directory no longer exists (a deleted external
-      // worktree that git already pruned) so they don't reappear on restart.
-      .filter((worktree) => worktree.source === 'primary' || existsSync(worktree.path))
-      // Heal records whose repoRoot points at a since-deleted sibling worktree
-      // so later git operations (e.g. `git -C repoRoot`) don't fail.
-      .map((worktree) =>
-        existsSync(worktree.repoRoot) ? worktree : { ...worktree, repoRoot, updatedAt: now }
-      )
-  )
-}
-
-interface DiscoveredWorktree {
-  path: string
-  head?: string
-  branch?: string
-  prunable?: boolean
-}
-
-function listGitWorktreesSync(cwd: string): DiscoveredWorktree[] {
-  const result = spawnSync('git', ['-C', cwd, 'worktree', 'list', '--porcelain'], {
-    encoding: 'utf8',
-  })
-  if (result.status !== 0 || !result.stdout) return []
-  const worktrees: DiscoveredWorktree[] = []
-  let current: DiscoveredWorktree | null = null
-  for (const line of result.stdout.split('\n')) {
-    if (line.startsWith('worktree ')) {
-      if (current) worktrees.push(current)
-      current = { path: line.slice('worktree '.length) }
-    } else if (current && line.startsWith('HEAD ')) {
-      current.head = line.slice('HEAD '.length)
-    } else if (current && line.startsWith('branch ')) {
-      current.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '')
-    } else if (current && line.startsWith('prunable')) {
-      current.prunable = true
-    }
-  }
-  if (current) worktrees.push(current)
-  return worktrees
-}
-
-function pruneGitWorktreesSync(cwd: string): void {
-  spawnSync('git', ['-C', cwd, 'worktree', 'prune'], { encoding: 'utf8' })
-}
-
-function pruneMissingAimuxTempWorktrees(worktrees: WorktreeRecord[]): WorktreeRecord[] {
-  return worktrees.filter((worktree) => {
-    if (
-      worktree.source !== 'aimux-temp' ||
-      !worktree.createdByAimux ||
-      !isInsideAimuxWorktreeRoot(worktree.path)
-    ) {
-      return true
-    }
-    return existsSync(worktree.path)
-  })
-}
-
-export function getActiveWorktree(session: SessionRecord | undefined): WorktreeRecord | undefined {
-  if (!(session?.worktrees?.length != null && session?.worktrees?.length !== 0)) return undefined
-  return (
-    session.worktrees.find((worktree) => worktree.id === session.activeWorktreeId) ??
-    session.worktrees[0]
-  )
-}
-
-export function getSessionProjectPath(session: SessionRecord | undefined): string | undefined {
-  return getActiveWorktree(session)?.path ?? session?.projectPath
-}
-
-export function withActiveWorktree(session: SessionRecord, worktreeId: string): SessionRecord {
-  const worktree = session.worktrees?.find((entry) => entry.id === worktreeId)
-  if (!worktree) return session
-  return {
-    ...session,
-    activeWorktreeId: worktreeId,
-    projectPath: worktree.path,
-    updatedAt: new Date().toISOString(),
-  }
-}
-
-export function getRenderedTabWorktreeId(
-  tab: { worktreeId?: string },
-  worktrees: { id: string }[]
-): string {
-  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
-): TabSession[] {
-  const worktrees = session?.worktrees ?? []
-  const order = new Map<string, number>()
-  for (const [index, worktree] of worktrees.entries()) {
-    order.set(worktree.id, index)
-  }
-  order.set('__main__', order.size)
-
-  return tabs
-    .map((tab, index) => ({ index, tab }))
-    .sort((a, b) => {
-      const aw = order.get(getRenderedTabWorktreeId(a.tab, worktrees)) ?? Number.MAX_SAFE_INTEGER
-      const bw = order.get(getRenderedTabWorktreeId(b.tab, worktrees)) ?? Number.MAX_SAFE_INTEGER
-      if (aw !== bw) return aw - bw
-      return a.index - b.index
-    })
-    .map((entry) => entry.tab)
-}