@brimveyn/aimux 1.21.0 → 1.22.2

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

@@ -1,187 +0,0 @@
-import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, AppState, SessionRecord, TabSession } from '../state/types'
-
-import { logInputDebug } from '../debug/input-log'
-import { createPrefixedId } from '../platform/id'
-import { saveSessionCatalog } from '../state/session-catalog'
-import { createEmptyWorkspaceSnapshot, serializeWorkspace } from '../state/session-persistence'
-import { createPrimaryWorktree, ensureSessionWorktrees } from '../state/session-worktrees'
-import { toast } from '../state/toast-store'
-import { buildSessionsWithCurrentSnapshot } from '../state/workspace-save'
-
-export function createSessionFromCurrentState(
-  state: AppState,
-  name: string,
-  projectPath?: string
-): { session: SessionRecord; sessions: SessionRecord[] } {
-  const now = new Date().toISOString()
-  const workspaceSnapshot =
-    (state.currentSessionId != null && state.currentSessionId !== '') || state.tabs.length === 0
-      ? createEmptyWorkspaceSnapshot()
-      : serializeWorkspace(state)
-  const session: SessionRecord = {
-    activeWorktreeId: undefined,
-    createdAt: now,
-    id: createPrefixedId('session'),
-    lastOpenedAt: now,
-    name,
-    projectPath,
-    updatedAt: now,
-    workspaceSnapshot,
-    worktrees: undefined,
-  }
-  if (projectPath != null && projectPath !== '') {
-    const worktree = createPrimaryWorktree(projectPath, now)
-    session.activeWorktreeId = worktree.id
-    session.worktrees = [worktree]
-  }
-
-  let updatedSessions = state.sessions
-  if (state.currentSessionId != null && state.currentSessionId !== '') {
-    const currentSnapshot = serializeWorkspace(state)
-    updatedSessions = state.sessions.map((entry) =>
-      entry.id === state.currentSessionId
-        ? { ...entry, updatedAt: now, workspaceSnapshot: currentSnapshot }
-        : entry
-    )
-  }
-
-  return {
-    session,
-    sessions: [...updatedSessions, ensureSessionWorktrees(session)],
-  }
-}
-
-export function renameSessionRecords(
-  sessions: SessionRecord[],
-  sessionId: string,
-  name: string
-): SessionRecord[] {
-  return sessions.map((session) =>
-    session.id === sessionId ? { ...session, name, updatedAt: new Date().toISOString() } : session
-  )
-}
-
-export function switchSessionRecords(state: AppState, session: SessionRecord): SessionRecord[] {
-  const sessionsWithSnapshot = buildSessionsWithCurrentSnapshot(
-    state.sessions,
-    state.currentSessionId,
-    state
-  )
-  return sessionsWithSnapshot.map((entry) =>
-    entry.id === session.id ? { ...entry, lastOpenedAt: new Date().toISOString() } : entry
-  )
-}
-
-export function deleteSessionRecords(
-  sessions: SessionRecord[],
-  sessionId: string
-): SessionRecord[] {
-  return sessions.filter((session) => session.id !== sessionId)
-}
-
-export function handleCreateSessionEffect(
-  state: AppState,
-  dispatch: (action: AppAction) => void,
-  name: string,
-  projectPath?: string
-): void {
-  const { session, sessions } = createSessionFromCurrentState(state, name, projectPath)
-  logInputDebug('app.session.create', {
-    fromCurrentWorkspace:
-      (state.currentSessionId == null || state.currentSessionId === '') && state.tabs.length > 0,
-    name,
-    sessionId: session.id,
-    tabCount: session.workspaceSnapshot?.tabs.length ?? 0,
-  })
-  saveSessionCatalog(sessions)
-  dispatch({ sessions, type: 'set-sessions' })
-  dispatch({
-    sessionId: session.id,
-    type: 'load-session',
-    workspaceSnapshot: session.workspaceSnapshot,
-  })
-}
-
-export function handleRenameSessionEffect(
-  sessions: SessionRecord[],
-  dispatch: (action: AppAction) => void,
-  sessionId: string,
-  name: string
-): void {
-  logInputDebug('app.session.rename', { name, sessionId })
-  const renamed = renameSessionRecords(sessions, sessionId, name)
-  saveSessionCatalog(renamed)
-  dispatch({ name, sessionId, type: 'rename-session-record' })
-}
-
-export function handleSwitchSessionEffect(
-  state: AppState,
-  backend: SessionBackend,
-  dispatch: (action: AppAction) => void,
-  session: SessionRecord
-): void {
-  logInputDebug('app.session.switch.start', {
-    currentTabCount: state.tabs.length,
-    fromSessionId: state.currentSessionId,
-    restoredTabCount: session.workspaceSnapshot?.tabs.length ?? 0,
-    toName: session.name,
-    toSessionId: session.id,
-  })
-  const sessions = switchSessionRecords(state, session)
-  saveSessionCatalog(sessions)
-  void backend.destroy(true)
-  dispatch({ sessions, type: 'set-sessions' })
-  dispatch({
-    sessionId: session.id,
-    type: 'load-session',
-    workspaceSnapshot: session.workspaceSnapshot,
-  })
-  logInputDebug('app.session.switch.dispatched', { toSessionId: session.id })
-}
-
-export function handleDeleteSessionEffect(
-  state: AppState,
-  backend: SessionBackend,
-  dispatch: (action: AppAction) => void,
-  sessionId: string,
-  options?: { openSessionPicker?: boolean }
-): void {
-  const name = state.sessions.find((entry) => entry.id === sessionId)?.name
-  const remaining = deleteSessionRecords(state.sessions, sessionId)
-  logInputDebug('app.session.delete', {
-    remainingCount: remaining.length,
-    sessionId,
-    wasCurrent: sessionId === state.currentSessionId,
-  })
-  saveSessionCatalog(remaining)
-  if (sessionId === state.currentSessionId) {
-    void backend.destroy(true)
-  }
-  dispatch({
-    openSessionPicker: options?.openSessionPicker,
-    sessionId,
-    type: 'delete-session-record',
-  })
-  toast.success(name != null && name !== '' ? `Deleted workspace "${name}"` : 'Workspace deleted')
-}
-
-export function restartTabSession(
-  backend: SessionBackend,
-  dispatch: (action: AppAction) => void,
-  clearIdleTimer: (tabId: string) => void,
-  clearStartupGrace: (tabId: string) => void,
-  startTabSession: (tab: TabSession) => void,
-  tab: TabSession
-): void {
-  logInputDebug('app.restartTab', {
-    command: tab.command,
-    status: tab.status,
-    tabId: tab.id,
-  })
-  clearIdleTimer(tab.id)
-  clearStartupGrace(tab.id)
-  backend.disposeSession(tab.id)
-  dispatch({ tabId: tab.id, type: 'reset-tab-session' })
-  startTabSession(tab)
-}

package/src/cli/client/workspace-resolver.ts

@@ -1,110 +0,0 @@
-import type { SessionRecord, WorktreeRecord } from '../../state/types'
-
-import { findMostRecentSession, loadSessionCatalog } from '../../state/session-catalog'
-
-/**
- * Where a command's target workspace came from. An orchestrator needs this to
- * tell "I asked for pragma-once" from "aimux guessed, and the UI had moved on":
- * `active` is the only origin that can silently follow the UI to another repo.
- */
-export type WorkspaceOrigin = 'flag' | 'env' | 'active'
-
-export interface ResolvedWorkspace {
-  origin: WorkspaceOrigin
-  record: SessionRecord
-}
-
-/** Env pin for headless orchestrators — `--workspace` still wins over it. */
-export const WORKSPACE_ENV_VAR = 'AIMUX_WORKSPACE'
-
-/** The workspace's primary (root) worktree, i.e. the repository it is about. */
-export function findPrimaryWorktree(session: SessionRecord): WorktreeRecord | undefined {
-  return session.worktrees?.find((worktree) => worktree.source === 'primary')
-}
-
-/**
- * The repo every fresh worktree for this workspace is cut from. Surfaced in
- * every worker envelope so an agent can see *which project* it just acted on
- * instead of inferring it from a worktree path hash.
- */
-export function workspaceRepoRoot(session: SessionRecord): string | null {
-  return findPrimaryWorktree(session)?.repoRoot ?? session.projectPath ?? null
-}
-
-/** Stable workspace identity block embedded in command output. */
-export function workspaceIdentity(session: SessionRecord): {
-  id: string
-  name: string
-  repoRoot: string | null
-} {
-  return { id: session.id, name: session.name, repoRoot: workspaceRepoRoot(session) }
-}
-
-/**
- * Resolve `--workspace W` to a session record from the catalog, reporting where
- * the choice came from. Precedence: the explicit flag, then `AIMUX_WORKSPACE`,
- * then the most recently opened session. Throws when the catalog is empty (no
- * session has ever been created) or when the explicit name/id doesn't match.
- *
- * Matching: exact id wins; otherwise exact name (case-sensitive); otherwise
- * unique case-insensitive name match.
- */
-export function resolveWorkspaceWithOrigin(name: string | undefined): ResolvedWorkspace {
-  const sessions = loadSessionCatalog()
-  if (sessions.length === 0) {
-    throw new Error(
-      'no sessions found — create one from the aimux UI first (or pass --workspace once created)'
-    )
-  }
-
-  const flag = name !== undefined && name !== '' ? name : undefined
-  const env = process.env[WORKSPACE_ENV_VAR]
-  const fromEnv = env != null && env !== '' ? env : undefined
-  const selector = flag ?? fromEnv
-  if (selector === undefined) {
-    const active = findMostRecentSession(sessions)
-    if (!active) {
-      throw new Error('no active workspace and the catalog is empty')
-    }
-    return { origin: 'active', record: active }
-  }
-
-  return {
-    origin: flag !== undefined ? 'flag' : 'env',
-    record: matchWorkspace(sessions, selector),
-  }
-}
-
-export function resolveWorkspace(name: string | undefined): SessionRecord {
-  return resolveWorkspaceWithOrigin(name).record
-}
-
-function matchWorkspace(sessions: SessionRecord[], name: string): SessionRecord {
-  const byId = sessions.find((session) => session.id === name)
-  if (byId) return byId
-
-  const exactNameMatches = sessions.filter((session) => session.name === name)
-  if (exactNameMatches.length > 1) {
-    throw new Error(
-      `workspace "${name}" matches multiple sessions: ${exactNameMatches.map((s) => s.id).join(', ')}`
-    )
-  }
-  const exactOnly = exactNameMatches[0]
-  if (exactOnly) return exactOnly
-
-  const lower = name.toLowerCase()
-  const ciMatches = sessions.filter((session) => session.name.toLowerCase() === lower)
-  if (ciMatches.length > 1) {
-    throw new Error(
-      `workspace "${name}" matches multiple sessions: ${ciMatches.map((s) => s.id).join(', ')}`
-    )
-  }
-  const ciOnly = ciMatches[0]
-  if (ciOnly) return ciOnly
-
-  throw new Error(`workspace not found: ${name}`)
-}
-
-export function listWorkspaces(): SessionRecord[] {
-  return loadSessionCatalog()
-}

package/src/cli/commands/workspace/close.ts

@@ -1,32 +0,0 @@
-import type { CliCommand } from '../../registry'
-
-import { IPC_CAPABILITY_WORKSPACE_LIFECYCLE } from '../../../ipc/protocol'
-import { resolveWorkspace } from '../../client/workspace-resolver'
-import { SHARED_FLAGS } from '../../flags'
-import { EXIT_OK, writeJson } from '../../output'
-
-export const workspaceClose: CliCommand = {
-  args: [{ complete: { kind: 'dynamic', source: 'workspace' }, name: 'workspace', required: true }],
-  flags: SHARED_FLAGS,
-  group: 'workspace',
-  run: async (ctx) => {
-    const target = ctx.args.positionals[0]
-    if (typeof target !== 'string' || target.length === 0) {
-      throw new Error('target workspace is required (id or name)')
-    }
-    const session = resolveWorkspace(target)
-
-    const daemon = await ctx.getDaemon()
-    if (!daemon.hasCapability(IPC_CAPABILITY_WORKSPACE_LIFECYCLE)) {
-      throw new Error(
-        'daemon predates workspaceLifecycle capability — restart aimux to pick up the new daemon'
-      )
-    }
-
-    await daemon.expectOk('closeWorkspace', { targetSessionId: session.id })
-    writeJson({ closedSessionId: session.id, name: session.name })
-    return EXIT_OK
-  },
-  summary: 'Close a workspace (via the UI when attached, otherwise the catalog)',
-  verb: 'close',
-}

package/src/cli/commands/workspace/show.ts

@@ -1,32 +0,0 @@
-import type { CliCommand } from '../../registry'
-
-import { SHARED_FLAGS } from '../../flags'
-import { EXIT_OK, writeJson } from '../../output'
-
-export const workspaceShow: CliCommand = {
-  args: [],
-  flags: SHARED_FLAGS,
-  group: 'workspace',
-  run: async (ctx) => {
-    const workspace = ctx.getWorkspace()
-    writeJson({
-      activeWorktreeId: workspace.activeWorktreeId,
-      createdAt: workspace.createdAt,
-      id: workspace.id,
-      lastOpenedAt: workspace.lastOpenedAt,
-      name: workspace.name,
-      projectPath: workspace.projectPath,
-      worktrees:
-        workspace.worktrees?.map((w) => ({
-          branch: w.branch,
-          id: w.id,
-          name: w.name,
-          path: w.path,
-          source: w.source,
-        })) ?? [],
-    })
-    return EXIT_OK
-  },
-  summary: 'Show the active workspace (or the one named via --workspace)',
-  verb: 'show',
-}

package/src/cli/commands/worktree/create.ts

@@ -1,55 +0,0 @@
-import type { CliCommand } from '../../registry'
-
-import { SHARED_FLAGS } from '../../flags'
-import { EXIT_OK, writeJson } from '../../output'
-import { createWorkspaceWorktree } from './create-core'
-
-export const worktreeCreate: CliCommand = {
-  args: [],
-  flags: [
-    ...SHARED_FLAGS,
-    {
-      complete: { kind: 'none' },
-      description: 'display name for the new worktree',
-      kind: 'string',
-      name: 'name',
-    },
-    {
-      complete: { kind: 'none' },
-      description: 'branch name (defaults to aimux/<name>)',
-      kind: 'string',
-      name: 'branch',
-    },
-    {
-      complete: { kind: 'dynamic', source: 'git-ref' },
-      description: 'base ref for the branch (defaults to HEAD)',
-      kind: 'string',
-      name: 'base',
-    },
-  ],
-  group: 'worktree',
-  run: async (ctx) => {
-    const name = ctx.args.flags.name
-    if (typeof name !== 'string' || name.length === 0) {
-      throw new Error('--name is required')
-    }
-    const branch =
-      typeof ctx.args.flags.branch === 'string' ? ctx.args.flags.branch : `aimux/${name}`
-    const base = typeof ctx.args.flags.base === 'string' ? ctx.args.flags.base : 'HEAD'
-
-    const workspace = ctx.getWorkspace()
-    const daemon = await ctx.getDaemon()
-    const record = await createWorkspaceWorktree({ base, branch, daemon, name, workspace })
-
-    writeJson({
-      branch: record.branch,
-      id: record.id,
-      name: record.name,
-      path: record.path,
-      repoRoot: record.repoRoot,
-    })
-    return EXIT_OK
-  },
-  summary: 'Create a new worktree in the active workspace',
-  verb: 'create',
-}

package/src/cli/commands/worktree/list.ts

@@ -1,68 +0,0 @@
-import type { CliCommand } from '../../registry'
-
-import { listGitWorktrees } from '../../../git/worktree'
-import { IPC_CAPABILITY_LIST_TABS } from '../../../ipc/protocol'
-import { SHARED_FLAGS } from '../../flags'
-import { EXIT_OK, writeJson } from '../../output'
-
-export const worktreeList: CliCommand = {
-  args: [],
-  flags: SHARED_FLAGS,
-  group: 'worktree',
-  run: async (ctx) => {
-    const workspace = ctx.getWorkspace()
-    const records = workspace.worktrees ?? []
-
-    // Count live tabs per worktree so an orchestrator can see co-location
-    // (several workers sharing one worktree) at a glance. Best-effort: `null`
-    // when the daemon is unreachable or predates the listTabs capability —
-    // `worktree list` otherwise reads purely from the catalog + git, so we don't
-    // want a down daemon to fail it.
-    const tabCounts = new Map<string, number>()
-    let tabCountsAvailable = false
-    try {
-      const daemon = await ctx.getDaemon()
-      if (daemon.hasCapability(IPC_CAPABILITY_LIST_TABS)) {
-        const { tabs } = await daemon.listTabs(workspace.id)
-        for (const tab of tabs) {
-          if (tab.worktreeId != null) {
-            tabCounts.set(tab.worktreeId, (tabCounts.get(tab.worktreeId) ?? 0) + 1)
-          }
-        }
-        tabCountsAvailable = true
-      }
-    } catch {
-      // daemon unreachable — leave tabCount null rather than failing the list.
-    }
-
-    // Cross-check against git so we can flag catalog entries that git no
-    // longer knows about (prunable / vanished) — otherwise the CLI would
-    // happily report worktrees that don't exist on disk.
-    const primary = records.find((w) => w.source === 'primary')
-    const gitPaths = new Set<string>()
-    if (primary) {
-      for (const w of await listGitWorktrees(primary.repoRoot)) {
-        if (w.prunable !== true) gitPaths.add(w.path)
-      }
-    }
-
-    writeJson({
-      activeWorktreeId: workspace.activeWorktreeId ?? null,
-      workspaceId: workspace.id,
-      worktrees: records.map((w) => ({
-        branch: w.branch,
-        createdByAimux: w.createdByAimux,
-        gitTracked: primary ? gitPaths.has(w.path) : null,
-        id: w.id,
-        name: w.name,
-        path: w.path,
-        repoRoot: w.repoRoot,
-        source: w.source,
-        tabCount: tabCountsAvailable ? (tabCounts.get(w.id) ?? 0) : null,
-      })),
-    })
-    return EXIT_OK
-  },
-  summary: 'List worktrees for a workspace',
-  verb: 'list',
-}

package/src/cli/commands/worktree/remove.ts

@@ -1,81 +0,0 @@
-import type { CliCommand } from '../../registry'
-
-import { removeGitWorktree } from '../../../git/worktree'
-import {
-  IPC_CAPABILITY_LIST_TABS,
-  IPC_CAPABILITY_WORKTREE_LIFECYCLE_EVENTS,
-} from '../../../ipc/protocol'
-import { pruneEmptyWorktreeParent } from '../../../platform/worktree-paths'
-import { SHARED_FLAGS } from '../../flags'
-import { EXIT_OK, writeJson } from '../../output'
-
-export const worktreeRemove: CliCommand = {
-  args: [{ complete: { kind: 'dynamic', source: 'worktree' }, name: 'worktree', required: true }],
-  flags: [
-    ...SHARED_FLAGS,
-    { description: 'pass --force to git worktree remove', kind: 'boolean', name: 'force' },
-  ],
-  group: 'worktree',
-  run: async (ctx) => {
-    const target = ctx.args.positionals[0]
-    if (typeof target !== 'string' || target.length === 0) {
-      throw new Error('worktree id or path is required')
-    }
-    const force = ctx.args.flags.force === true
-
-    const workspace = ctx.getWorkspace()
-    const worktree =
-      workspace.worktrees?.find((w) => w.id === target) ??
-      workspace.worktrees?.find((w) => w.path === target)
-    if (!worktree) {
-      const known = workspace.worktrees?.map((w) => w.id).join(', ') ?? '(none)'
-      throw new Error(`unknown worktree: ${target} (known: ${known})`)
-    }
-    if (worktree.source === 'primary') {
-      throw new Error('refusing to remove the primary worktree')
-    }
-
-    const primary = workspace.worktrees?.find((w) => w.source === 'primary')
-    if (!primary) {
-      throw new Error('workspace has no primary worktree — cannot resolve repoRoot for git remove')
-    }
-
-    const daemon = await ctx.getDaemon()
-    if (!daemon.hasCapability(IPC_CAPABILITY_WORKTREE_LIFECYCLE_EVENTS)) {
-      throw new Error(
-        'daemon predates worktreeLifecycleEvents capability — restart aimux to pick up the new daemon'
-      )
-    }
-    if (daemon.hasCapability(IPC_CAPABILITY_LIST_TABS)) {
-      const live = (await daemon.listTabs(workspace.id)).tabs.filter(
-        (tab) => tab.worktreeId === worktree.id
-      )
-      if (live.length > 0) {
-        throw new Error(
-          `refusing to remove worktree with live tabs: ${live.map((tab) => tab.id).join(', ')}`
-        )
-      }
-    }
-
-    // All capability and liveness checks happen before touching git. If git
-    // refuses a dirty worktree the catalog remains unchanged.
-    await removeGitWorktree({ force, repoPath: primary.repoRoot, targetPath: worktree.path })
-    await pruneEmptyWorktreeParent(worktree.path)
-    try {
-      await daemon.expectOk('removeWorktreeRecord', {
-        sessionId: workspace.id,
-        worktreeId: worktree.id,
-      })
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
-      throw new Error(
-        `worktree removed from git but catalog reconciliation failed for ${worktree.id}: ${message}`
-      )
-    }
-
-    writeJson({ id: worktree.id, name: worktree.name, path: worktree.path })
-    return EXIT_OK
-  },
-  summary: 'Remove a worktree from the active workspace',
-  verb: 'remove',
-}

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

@@ -1,54 +0,0 @@
-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/git/worktree-divergence-poller.ts

@@ -1,59 +0,0 @@
-import { useEffect } from 'react'
-
-import type { BranchDivergence } from '../state/types'
-
-import { useAppStore } from '../state/app-store'
-import { dispatchGlobal } from '../state/dispatch-ref'
-import { getBranchDivergence } from './divergence'
-
-const INTERVAL_MS = 4000
-
-// Polls per-worktree base divergence for the current session while enabled and
-// dispatches it into worktreeDivergence. Only worktrees that record a baseRef
-// (the aimux-created ones) are measured; the primary and externally-discovered
-// worktrees have no recorded base and are left out.
-export function useWorktreeDivergencePolling(enabled: boolean): void {
-  const currentSessionId = useAppStore((s) => s.currentSessionId)
-  const sessions = useAppStore((s) => s.sessions)
-
-  useEffect(() => {
-    if (!enabled) return
-    const session =
-      currentSessionId != null && currentSessionId !== ''
-        ? sessions.find((s) => s.id === currentSessionId)
-        : undefined
-    const targets = (session?.worktrees ?? []).filter(
-      (w) => w.baseRef != null && w.baseRef !== '' && w.branch != null && w.branch !== ''
-    )
-    if (targets.length === 0) return
-
-    let cancelled = false
-    let timer: ReturnType<typeof setTimeout> | null = null
-
-    const tick = async () => {
-      const entries = await Promise.all(
-        targets.map(async (worktree) => {
-          const base = worktree.baseRef
-          const branch = worktree.branch
-          if (base == null || branch == null) return null
-          const divergence = await getBranchDivergence(worktree.repoRoot, base, branch)
-          return divergence != null ? ([worktree.id, divergence] as const) : null
-        })
-      )
-      if (cancelled) return
-      const next: Record<string, BranchDivergence> = {}
-      for (const entry of entries) {
-        if (entry != null) next[entry[0]] = entry[1]
-      }
-      dispatchGlobal({ divergence: next, type: 'set-worktree-divergence' })
-      timer = setTimeout(() => void tick(), INTERVAL_MS)
-    }
-
-    void tick()
-
-    return () => {
-      cancelled = true
-      if (timer != null) clearTimeout(timer)
-    }
-  }, [enabled, currentSessionId, sessions])
-}