@brimveyn/aimux 1.9.0 → 1.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.5.1",
+    "@brimveyn/aimux-config": "0.5.2",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@xterm/headless": "^6.0.0",

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

@@ -605,7 +605,12 @@ function handleSwitchSessionByIndex(ctx: SideEffectContext, index: number): void
     logInputDebug('app.sessionBar.switchOutOfRange', { index, total: ordered.length })
     return
   }
-  if (target.id === state.currentSessionId) return
+  if (target.id === state.currentSessionId) {
+    if (state.focusMode === 'git') {
+      dispatch({ type: 'exit-git-mode' })
+    }
+    return
+  }
   handleSwitchSessionEffect(state, backend, dispatch, target)
 }
 
@@ -647,7 +652,11 @@ async function runGitAction(
   args: string[],
   pathToInvalidate?: string
 ): Promise<void> {
-  const cwd = ctx.getCurrentSessionProjectPath()
+  const fallback = ctx.getCurrentSessionProjectPath()
+  const repoPath = pathToInvalidate
+    ? ctx.state.gitPanel.files.find((f) => f.path === pathToInvalidate)?.repoPath
+    : undefined
+  const cwd = repoPath ?? fallback
   if (!cwd) return
   const result = await $`git -C ${cwd} ${args}`.quiet().nothrow()
   if (result.exitCode !== 0) {
@@ -662,7 +671,8 @@ async function runGitAction(
 }
 
 async function runGitRm(ctx: SideEffectContext, path: string): Promise<void> {
-  const cwd = ctx.getCurrentSessionProjectPath()
+  const repoPath = ctx.state.gitPanel.files.find((f) => f.path === path)?.repoPath
+  const cwd = repoPath ?? ctx.getCurrentSessionProjectPath()
   if (!cwd) return
   const absolute = `${cwd}/${path}`
   try {

package/src/app.tsx

@@ -1,14 +1,10 @@
-import { type ResolvedConfig, setAutoCommitEnabled } from '@brimveyn/aimux-config'
-import { useKeyboard, useRenderer, useTerminalDimensions } from '@opentui/react'
 import {
-  useCallback,
-  useEffect,
-  useLayoutEffect,
-  useMemo,
-  useReducer,
-  useRef,
-  useState,
-} from 'react'
+  type ResolvedConfig,
+  setAutoCommitEnabled,
+  setMultiRepoConfig,
+} from '@brimveyn/aimux-config'
+import { useKeyboard, useRenderer, useTerminalDimensions } from '@opentui/react'
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
 
 import type { KeyChord } from './input/keymap/key-chord'
 import type { TrieBinding } from './input/keymap/trie'
@@ -32,11 +28,11 @@ import { type TerminalContentOrigin } from './input/raw-input-handler'
 import { getProfileConfigDir, getProfileName } from './profile-paths'
 import { startAIUsageService } from './services/ai-usage/provider'
 import { aiUsageStore } from './state/ai-usage-store'
-import { appStore } from './state/app-store'
+import { appStore, useAppStore } from './state/app-store'
 import { setActiveDispatch, setActiveSideEffectRunner } from './state/dispatch-ref'
 import { loadSessionCatalog } from './state/session-catalog'
 import { loadSnippetCatalog } from './state/snippet-catalog'
-import { appReducer, createInitialState } from './state/store'
+import { createInitialState } from './state/store'
 import { KeymapContext } from './ui/keymap-context'
 import { RootView } from './ui/root'
 import { applyTheme, setTransparent } from './ui/theme'
@@ -59,6 +55,7 @@ export function App({
   // Publish the auto-commit enabled flag before any children render so
   // actions (which live outside React) can read it synchronously.
   setAutoCommitEnabled(resolvedConfig.autoCommit.enabled)
+  setMultiRepoConfig(resolvedConfig.multiRepo)
 
   const keymapHandlers = useMemo(
     () => {
@@ -81,7 +78,10 @@ export function App({
     setTransparent(config.themeTransparent ?? false)
     return initial
   })
-  const [state, dispatch] = useReducer(appReducer, undefined, () => {
+  // Initialize zustand store with computed initial state on first render. Using
+  // useState's lazy initializer guarantees this runs exactly once before any
+  // selector reads. We discard the value — the store is the source of truth.
+  useState(() => {
     const json = loadConfig()
     const sessionBarVisible =
       resolvedConfig.sessionBar?.initialVisible ?? json.sessionBarVisible ?? true
@@ -125,7 +125,7 @@ export function App({
       ...(userGitPane?.diffCount !== undefined ? { diffCount: userGitPane.diffCount } : {}),
     }
 
-    return createInitialState(
+    const initial = createInitialState(
       json.customCommands,
       loadSessionCatalog(),
       loadSnippetCatalog(),
@@ -137,11 +137,18 @@ export function App({
         sidebar: sidebarOverrides,
       }
     )
+    // Replace the module-level default with the fully-resolved initial state.
+    // Preserves the dispatch baked into the store by app-store.ts.
+    appStore.setState(initial)
+    return null
   })
 
-  useLayoutEffect(() => {
-    appStore.setState(state)
-  }, [state])
+  // Single source of truth: read state from zustand. The selector returns the
+  // entire store object, so this component re-renders on every dispatch (same
+  // cadence as the previous useReducer setup), but selectors elsewhere only
+  // re-render on the slices they actually subscribe to.
+  const state = useAppStore((s) => s)
+  const dispatch = state.dispatch
 
   useLayoutEffect(() => {
     setActiveDispatch(dispatch)
@@ -191,6 +198,8 @@ export function App({
     return () => {
       cancelled = true
     }
+    // dispatch is stable (same fn reference from the store) — safe to omit
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   const resizingRef = useRef(false)

package/src/git/git-poller.ts

@@ -1,7 +1,10 @@
 import { useEffect } from 'react'
 
+import type { DiscoveredRepo, GitFileEntry, GitRefreshPayload } from '../state/types'
+
+import { useAppStore } from '../state/app-store'
 import { dispatchGlobal } from '../state/dispatch-ref'
-import { collectGitStatus } from './git-status'
+import { collectGitStatus, type GitCollectResult } from './git-status'
 
 const BASE_INTERVAL_MS = 1000
 const MAX_INTERVAL_MS = 30_000
@@ -12,7 +15,54 @@ interface Options {
   headOffset: number
 }
 
+function tagFiles(files: GitFileEntry[], repoPath: string): GitFileEntry[] {
+  return files.map((f) => ({ ...f, repoPath }))
+}
+
+async function collectAggregated(
+  repos: DiscoveredRepo[],
+  fallbackCwd: string,
+  headOffset: number
+): Promise<GitCollectResult> {
+  // Historical walking (HEAD~N) is per-repo and doesn't compose; fall back to
+  // the root/fallback repo when offset > 0 to preserve existing behaviour.
+  if (headOffset > 0) return collectGitStatus(fallbackCwd, { headOffset })
+
+  const results = await Promise.all(repos.map((r) => collectGitStatus(r.path, { headOffset: 0 })))
+  const files: GitFileEntry[] = []
+  let branch: string | null = null
+  let ahead = 0
+  let behind = 0
+  let anyOk = false
+  for (let i = 0; i < repos.length; i++) {
+    const res = results[i]
+    const repo = repos[i]
+    if (res?.kind !== 'ok' || !repo) continue
+    anyOk = true
+    if (repo.isRoot) {
+      branch = res.payload.branch
+      ahead = res.payload.ahead
+      behind = res.payload.behind
+    }
+    files.push(...tagFiles(res.payload.files, repo.path))
+  }
+  if (!anyOk) return { error: 'not-a-repo', kind: 'error' }
+  // If there was no root repo, surface the first discovered repo's branch label.
+  if (branch === null) {
+    const firstOk = results.find(
+      (r): r is Extract<GitCollectResult, { kind: 'ok' }> => r?.kind === 'ok'
+    )
+    if (firstOk) branch = firstOk.payload.branch
+  }
+  const payload: GitRefreshPayload = { ahead, behind, branch, files }
+  return { kind: 'ok', payload }
+}
+
 export function useGitPanelPolling({ enabled, headOffset, projectPath }: Options): void {
+  // Read repos from the store imperatively — changes trigger a fresh effect run
+  // because the repos identity is stable across ticks until set-repos fires.
+  const repos = useAppStore((s) => s.multiRepo.repos)
+
   useEffect(() => {
     if (!enabled || !projectPath) return undefined
 
@@ -28,7 +78,10 @@ export function useGitPanelPolling({ enabled, headOffset, projectPath }: Options
     }
 
     const tick = async () => {
-      const result = await collectGitStatus(projectPath, { headOffset })
+      const result =
+        repos.length > 0
+          ? await collectAggregated(repos, projectPath, headOffset)
+          : await collectGitStatus(projectPath, { headOffset })
       if (cancelled) return
       if (result.kind === 'ok') {
         dispatchGlobal({ payload: result.payload, type: 'git-refresh-success' })
@@ -53,5 +106,5 @@ export function useGitPanelPolling({ enabled, headOffset, projectPath }: Options
       cancelled = true
       if (timer) clearTimeout(timer)
     }
-  }, [enabled, projectPath, headOffset])
+  }, [enabled, projectPath, headOffset, repos])
 }

package/src/git/repo-discovery.ts

@@ -0,0 +1,95 @@
+import type { Dirent } from 'node:fs'
+
+import { readdir, stat } from 'node:fs/promises'
+import { basename, join, relative } from 'node:path'
+
+import type { DiscoveredRepo } from '../state/types'
+
+const IGNORED_DIRS = new Set(['node_modules', 'target', 'dist', 'build', '.git'])
+
+async function isGitRepo(path: string): Promise<boolean> {
+  try {
+    const st = await stat(join(path, '.git'))
+    return st.isDirectory() || st.isFile()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Recursively scan `projectPath` down to `maxDepth` levels for directories
+ * that are themselves git repos. `maxDepth = 1` means only direct children.
+ *
+ * Internal recursion is breadth-limited: once a `.git` is found at a given
+ * path, we don't descend into it further (nested git repos-in-repos are rare
+ * and would duplicate status noise).
+ */
+async function scan(
+  root: string,
+  current: string,
+  depth: number,
+  maxDepth: number,
+  out: DiscoveredRepo[]
+): Promise<void> {
+  if (depth > maxDepth) return
+  let entries: Dirent[] = []
+  try {
+    entries = (await readdir(current, { withFileTypes: true })) as Dirent[]
+  } catch {
+    return
+  }
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (!entry.isDirectory()) return
+      if (entry.name.startsWith('.')) return
+      if (IGNORED_DIRS.has(entry.name)) return
+      const childPath = join(current, entry.name)
+      if (await isGitRepo(childPath)) {
+        const rel = relative(root, childPath)
+        out.push({ isRoot: false, name: rel || entry.name, path: childPath })
+        return
+      }
+      await scan(root, childPath, depth + 1, maxDepth, out)
+    })
+  )
+}
+
+async function discoverReposUncached(
+  projectPath: string,
+  maxDepth: number
+): Promise<DiscoveredRepo[]> {
+  const repos: DiscoveredRepo[] = []
+  if (await isGitRepo(projectPath)) {
+    repos.push({ isRoot: true, name: basename(projectPath), path: projectPath })
+  }
+  const children: DiscoveredRepo[] = []
+  await scan(projectPath, projectPath, 1, maxDepth, children)
+  children.sort((a, b) => a.name.localeCompare(b.name))
+  repos.push(...children)
+  return repos
+}
+
+interface CacheEntry {
+  maxDepth: number
+  repos: DiscoveredRepo[]
+}
+
+const cache = new Map<string, CacheEntry>()
+
+/**
+ * Cached variant. The cache key is `projectPath` + `maxDepth`: a depth change
+ * invalidates the entry. The cache persists until `invalidateRepoCache()` or
+ * process exit — discovery is one-shot per session per depth setting.
+ */
+export async function discoverRepos(projectPath: string, maxDepth = 1): Promise<DiscoveredRepo[]> {
+  const existing = cache.get(projectPath)
+  if (existing && existing.maxDepth === maxDepth) return existing.repos
+  const repos = await discoverReposUncached(projectPath, maxDepth)
+  cache.set(projectPath, { maxDepth, repos })
+  return repos
+}
+
+export function invalidateRepoCache(projectPath?: string): void {
+  if (projectPath === undefined) cache.clear()
+  else cache.delete(projectPath)
+}

package/src/git/use-repo-discovery.ts

@@ -0,0 +1,28 @@
+import { getMultiRepoConfig } from '@brimveyn/aimux-config'
+import { useEffect } from 'react'
+
+import { dispatchGlobal } from '../state/dispatch-ref'
+import { discoverRepos } from './repo-discovery'
+
+/**
+ * Discover nested git repos inside `projectPath` once per session and push
+ * the result into state. No-op when the multi-repo config flag is off.
+ */
+export function useRepoDiscovery(projectPath: string | undefined): void {
+  useEffect(() => {
+    const cfg = getMultiRepoConfig()
+    if (!cfg.enabled || !projectPath) {
+      dispatchGlobal({ type: 'multi-repo-clear' })
+      return
+    }
+    let cancelled = false
+    void (async () => {
+      const repos = await discoverRepos(projectPath, cfg.maxDepth)
+      if (cancelled) return
+      dispatchGlobal({ repos, type: 'multi-repo-set-repos' })
+    })()
+    return () => {
+      cancelled = true
+    }
+  }, [projectPath])
+}

package/src/input/keymap/describe-bindings.ts

@@ -1,4 +1,4 @@
-import type { ModeId, ResolvedKeymapConfig } from '@brimveyn/aimux-config'
+import type { Action, ModeId, ResolvedKeymapConfig } from '@brimveyn/aimux-config'
 
 import { parseKeyNotation } from './key-chord'
 import { formatNotationForDisplay } from './key-format'
@@ -18,6 +18,24 @@ export interface DescribedBindingGroup {
 interface DescribeOptions {
   withDescriptionOnly?: boolean
   dedupeByDescription?: boolean
+  mergeAlternativesByDescription?: boolean
+}
+
+const actionObjectIds = new WeakMap<object, number>()
+let nextActionObjectId = 0
+
+function getActionSignature(action: Action): string {
+  if (typeof action === 'function') {
+    let id = actionObjectIds.get(action)
+    if (id === undefined) {
+      id = nextActionObjectId
+      nextActionObjectId += 1
+      actionObjectIds.set(action, id)
+    }
+    return `fn:${id}`
+  }
+
+  return `json:${JSON.stringify(action)}`
 }
 
 export function describeBindings(
@@ -31,9 +49,52 @@ export function describeBindings(
   const leaderChord = parseKeyNotation(config.leader)[0]
   const seenDescriptions = new Set<string>()
   const result: DescribedBinding[] = []
+  const resultIndexByDescription = new Map<string, number>()
+  const resultIndexByAction = new Map<string, number>()
+  const seenKeysDisplayByIndex = new Map<number, Set<string>>()
 
   for (const binding of mode.bindings) {
+    const keysDisplay = formatNotationForDisplay(binding.keys, leaderChord)
+
+    if (options.mergeAlternativesByDescription) {
+      const actionSignature = getActionSignature(binding.result)
+      const existingIndex = binding.description
+        ? resultIndexByDescription.get(binding.description)
+        : resultIndexByAction.get(actionSignature)
+
+      if (existingIndex === undefined) {
+        if (options.withDescriptionOnly && !binding.description) continue
+        const nextIndex = result.length
+        if (binding.description) resultIndexByDescription.set(binding.description, nextIndex)
+        resultIndexByAction.set(actionSignature, nextIndex)
+        seenKeysDisplayByIndex.set(nextIndex, new Set([keysDisplay]))
+        result.push({
+          description: binding.description,
+          group: binding.group,
+          keys: binding.keys,
+          keysDisplay,
+        })
+        continue
+      }
+
+      const seenKeysDisplay = seenKeysDisplayByIndex.get(existingIndex)
+      if (!seenKeysDisplay || seenKeysDisplay.has(keysDisplay)) continue
+
+      seenKeysDisplay.add(keysDisplay)
+      const existing = result[existingIndex]
+      if (!existing) continue
+      if (!existing.description && binding.description) {
+        existing.description = binding.description
+        existing.group = binding.group
+        resultIndexByDescription.set(binding.description, existingIndex)
+      }
+      existing.keys = `${existing.keys} / ${binding.keys}`
+      existing.keysDisplay = `${existing.keysDisplay} / ${keysDisplay}`
+      continue
+    }
+
     if (options.withDescriptionOnly && !binding.description) continue
+
     if (options.dedupeByDescription && binding.description) {
       if (seenDescriptions.has(binding.description)) continue
       seenDescriptions.add(binding.description)
@@ -42,7 +103,7 @@ export function describeBindings(
       description: binding.description,
       group: binding.group,
       keys: binding.keys,
-      keysDisplay: formatNotationForDisplay(binding.keys, leaderChord),
+      keysDisplay,
     })
   }
 

package/src/pty/terminal-snapshot.ts

@@ -2,7 +2,7 @@ import type { Terminal } from '@xterm/headless'
 
 import type { TerminalLine, TerminalSnapshot, TerminalSpan } from '../state/types'
 
-import { getCurrentTheme } from '../ui/theme'
+import { getCurrentTokens } from '../ui/theme'
 
 const SNAPSHOT_TAIL_LINE_COUNT = 10
 
@@ -115,15 +115,17 @@ function buildLine(
     let bg = getColorHex(current.getBgColor(), bgMode)
 
     if (current.isInverse()) {
-      const resolvedFg = fg ?? getCurrentTheme().palette.ink
-      const resolvedBg = bg ?? getCurrentTheme().palette.neutral
+      const tokens = getCurrentTokens()
+      const resolvedFg = fg ?? tokens.palette.ink
+      const resolvedBg = bg ?? tokens.bg
       ;[fg, bg] = [resolvedBg, resolvedFg]
     }
 
     const isCursorCell = cursorVisible && cursorColumn === column
     if (isCursorCell) {
-      const resolvedFg = fg ?? getCurrentTheme().palette.ink
-      const resolvedBg = bg ?? getCurrentTheme().palette.neutral
+      const tokens = getCurrentTokens()
+      const resolvedFg = fg ?? tokens.palette.ink
+      const resolvedBg = bg ?? tokens.bg
       ;[fg, bg] = [resolvedBg, resolvedFg]
     }
 

package/src/state/reducers/git-mode-state.ts

@@ -274,6 +274,8 @@ export function reduceGitModeState(state: AppState, action: AppAction): AppState
       }
     }
     case 'git-mode-set-parsed': {
+      const prevParsed = state.gitMode.parsedFiles[action.key]
+      if (prevParsed && prevParsed.hash === action.hash) return state
       return {
         ...state,
         gitMode: {
@@ -303,6 +305,62 @@ export function reduceGitModeState(state: AppState, action: AppAction): AppState
         },
       }
     }
+    case 'git-mode-merge-highlights': {
+      const k = `${action.key}|${action.themeId}`
+      const existing = state.gitMode.highlights[k]
+      const sameContent = existing && existing.hash === action.hash
+      if (sameContent) {
+        const existingAdd = existing.add as unknown[]
+        const existingDel = existing.del as unknown[]
+        let changesAnything = false
+        outer: for (const patch of action.add) {
+          const tokens = patch.tokens as unknown[]
+          for (let i = 0; i < tokens.length; i++) {
+            if (existingAdd[patch.start + i] === undefined) {
+              changesAnything = true
+              break outer
+            }
+          }
+        }
+        if (!changesAnything) {
+          outer: for (const patch of action.del) {
+            const tokens = patch.tokens as unknown[]
+            for (let i = 0; i < tokens.length; i++) {
+              if (existingDel[patch.start + i] === undefined) {
+                changesAnything = true
+                break outer
+              }
+            }
+          }
+        }
+        if (!changesAnything) return state
+      }
+      const nextAdd = sameContent ? ([...(existing.add as unknown[])] as unknown[]) : []
+      const nextDel = sameContent ? ([...(existing.del as unknown[])] as unknown[]) : []
+      for (const patch of action.add) {
+        const tokens = patch.tokens as unknown[]
+        for (let i = 0; i < tokens.length; i++) nextAdd[patch.start + i] = tokens[i]
+      }
+      for (const patch of action.del) {
+        const tokens = patch.tokens as unknown[]
+        for (let i = 0; i < tokens.length; i++) nextDel[patch.start + i] = tokens[i]
+      }
+      return {
+        ...state,
+        gitMode: {
+          ...state.gitMode,
+          highlights: {
+            ...state.gitMode.highlights,
+            [k]: {
+              add: nextAdd,
+              del: nextDel,
+              hash: action.hash,
+              themeId: action.themeId,
+            },
+          },
+        },
+      }
+    }
     case 'git-mode-invalidate-diffs': {
       if (action.paths.length === 0) return state
       return clearDiffCacheForPaths(state, new Set(action.paths))

package/src/state/reducers/git-panel-state.ts

@@ -16,6 +16,9 @@ export function sortFilesBySection(files: GitFileEntry[]): GitFileEntry[] {
     const sa = SECTION_RANK[a.section]
     const sb = SECTION_RANK[b.section]
     if (sa !== sb) return sa - sb
+    const ra = a.repoPath ?? ''
+    const rb = b.repoPath ?? ''
+    if (ra !== rb) return ra.localeCompare(rb)
     return a.path.localeCompare(b.path)
   })
 }

package/src/state/reducers/multi-repo-state.ts

@@ -0,0 +1,60 @@
+import {
+  type AppAction,
+  type AppState,
+  type DiscoveredRepo,
+  EMPTY_MULTI_REPO_STATE,
+} from '../types'
+
+/**
+ * Compute the shortest distinguishing prefix for each non-root repo name.
+ *
+ * Rule: start at length 1, group by that prefix. Any group with a single name
+ * is done; groups with collisions retry at length+1 until distinct or the name
+ * is exhausted. Root repos receive an empty prefix (no tag needed).
+ */
+export function computeRepoPrefixes(repos: DiscoveredRepo[]): Record<string, string> {
+  const out: Record<string, string> = {}
+  const nonRoot = repos.filter((r) => !r.isRoot)
+  for (const r of repos.filter((r) => r.isRoot)) out[r.path] = ''
+
+  const assign = (group: DiscoveredRepo[], len: number): void => {
+    if (group.length === 0) return
+    if (group.length === 1) {
+      const only = group[0]
+      if (!only) return
+      out[only.path] = only.name.slice(0, Math.max(1, len))
+      return
+    }
+    const byKey = new Map<string, DiscoveredRepo[]>()
+    for (const repo of group) {
+      const key = repo.name.slice(0, len)
+      const bucket = byKey.get(key)
+      if (bucket) bucket.push(repo)
+      else byKey.set(key, [repo])
+    }
+    for (const [key, bucket] of byKey) {
+      if (bucket.length === 1 || bucket.every((r) => r.name.length < len)) {
+        for (const r of bucket) out[r.path] = key || r.name
+      } else {
+        assign(bucket, len + 1)
+      }
+    }
+  }
+  assign(nonRoot, 1)
+  return out
+}
+
+export function reduceMultiRepoState(state: AppState, action: AppAction): AppState | null {
+  switch (action.type) {
+    case 'multi-repo-set-repos': {
+      const prefixes = computeRepoPrefixes(action.repos)
+      return { ...state, multiRepo: { prefixes, repos: action.repos } }
+    }
+    case 'multi-repo-clear': {
+      if (state.multiRepo.repos.length === 0) return state
+      return { ...state, multiRepo: EMPTY_MULTI_REPO_STATE }
+    }
+    default:
+      return null
+  }
+}

package/src/state/store.ts

@@ -2,6 +2,7 @@ import { reduceAutoCommit } from './reducers/auto-commit-state'
 import { emptyGitMode, reduceGitModeState } from './reducers/git-mode-state'
 import { emptyGitPanel, reduceGitPanelState } from './reducers/git-panel-state'
 import { emptyModal, reduceModalState } from './reducers/modal-state'
+import { reduceMultiRepoState } from './reducers/multi-repo-state'
 import { reduceSessionState } from './reducers/session-state'
 import { reduceTabState } from './reducers/tab-state'
 import { reduceUIState } from './reducers/ui-state'
@@ -10,6 +11,7 @@ import {
   type AppAction,
   type AppState,
   EMPTY_AUTO_COMMIT_STATE,
+  EMPTY_MULTI_REPO_STATE,
   type GitModeState,
   type GitPaneMode,
   type GitPanePosition,
@@ -98,6 +100,7 @@ export function createInitialState(
           type: 'session-picker',
         }
       : emptyModal(),
+    multiRepo: EMPTY_MULTI_REPO_STATE,
     pendingChords: null,
     sessionBar: {
       position: overrides.sessionBarPosition ?? 'top',
@@ -139,6 +142,9 @@ export function appReducer(state: AppState, action: AppAction): AppState {
   const autoCommitState = reduceAutoCommit(state, action)
   if (autoCommitState) return autoCommitState
 
+  const multiRepoState = reduceMultiRepoState(state, action)
+  if (multiRepoState) return multiRepoState
+
   switch (action.type) {
     case 'set-snippets':
       return { ...state, snippets: action.snippets }