@brimveyn/aimux 1.4.0 → 1.5.0

package/src/pty/pty-manager.ts

@@ -79,8 +79,98 @@ function getTerminalModes(emulator: XTerm, alternateScrollMode: boolean): Termin
   }
 }
 
+function envInt(name: string, fallback: number): number {
+  const raw = process.env[name]
+  if (raw === undefined) return fallback
+  const parsed = Number(raw)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback
+}
+
+const RENDER_COALESCE_MS = 16
+const DATA_DEBOUNCE_MS = envInt('AIMUX_RENDER_DEBOUNCE_MS', 32)
+const BURST_MAX_MS = envInt('AIMUX_RENDER_BURST_MS', 500)
+
 export class PtyManager extends EventEmitter<PtyManagerEvents> {
   private sessions = new Map<string, SessionHandle>()
+  private pendingFlushes = new Map<string, ReturnType<typeof setTimeout>>()
+  private pendingBurstCaps = new Map<string, ReturnType<typeof setTimeout>>()
+
+  private clearTimers(tabId: string): void {
+    const flush = this.pendingFlushes.get(tabId)
+    if (flush) {
+      clearTimeout(flush)
+      this.pendingFlushes.delete(tabId)
+    }
+    const burst = this.pendingBurstCaps.get(tabId)
+    if (burst) {
+      clearTimeout(burst)
+      this.pendingBurstCaps.delete(tabId)
+    }
+  }
+
+  private scheduleRender(session: SessionHandle): void {
+    if (this.pendingFlushes.has(session.tabId)) {
+      return
+    }
+    const timer = setTimeout(() => {
+      this.pendingFlushes.delete(session.tabId)
+      if (this.sessions.get(session.tabId) !== session) {
+        return
+      }
+      const burst = this.pendingBurstCaps.get(session.tabId)
+      if (burst) {
+        clearTimeout(burst)
+        this.pendingBurstCaps.delete(session.tabId)
+      }
+      this.emitRenderIfChanged(session)
+    }, RENDER_COALESCE_MS)
+    this.pendingFlushes.set(session.tabId, timer)
+  }
+
+  private scheduleDataRender(session: SessionHandle): void {
+    const existingFlush = this.pendingFlushes.get(session.tabId)
+    if (existingFlush) {
+      clearTimeout(existingFlush)
+    }
+    const flushTimer = setTimeout(() => {
+      this.pendingFlushes.delete(session.tabId)
+      if (this.sessions.get(session.tabId) !== session) {
+        return
+      }
+      if (session.pendingWrites > 0) {
+        this.scheduleDataRender(session)
+        return
+      }
+      const burst = this.pendingBurstCaps.get(session.tabId)
+      if (burst) {
+        clearTimeout(burst)
+        this.pendingBurstCaps.delete(session.tabId)
+      }
+      this.emitRenderIfChanged(session)
+    }, DATA_DEBOUNCE_MS)
+    this.pendingFlushes.set(session.tabId, flushTimer)
+
+    if (!this.pendingBurstCaps.has(session.tabId)) {
+      const burstTimer = setTimeout(() => {
+        this.pendingBurstCaps.delete(session.tabId)
+        if (this.sessions.get(session.tabId) !== session) {
+          return
+        }
+        const flush = this.pendingFlushes.get(session.tabId)
+        if (flush) {
+          clearTimeout(flush)
+          this.pendingFlushes.delete(session.tabId)
+        }
+        this.emitRenderIfChanged(session)
+      }, BURST_MAX_MS)
+      this.pendingBurstCaps.set(session.tabId, burstTimer)
+    }
+  }
+
+  private flushRenderNow(session: SessionHandle): void {
+    this.clearTimers(session.tabId)
+    this.emitRenderIfChanged(session)
+  }
 
   private emitRenderIfChanged(session: SessionHandle): void {
     const nextSnapshot = snapshotTerminal(session.emulator, session.cursorVisible)
@@ -116,7 +206,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
 
     this.sessions.delete(session.tabId)
-    this.emitRenderIfChanged(session)
+    this.flushRenderNow(session)
     session.emulator.dispose()
     logDebug('ptyManager.finalize', { exitCode, tabId: session.tabId })
     this.emit('exit', session.tabId, exitCode)
@@ -188,9 +278,10 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
         session.cursorVisible = trackedModes.cursorVisible
         session.pendingModeSequence = trackedModes.pendingSequence
         session.pendingWrites += 1
+        this.scheduleDataRender(session)
         emulator.write(data, () => {
           session.pendingWrites -= 1
-          this.emitRenderIfChanged(session)
+          this.scheduleDataRender(session)
 
           if (session.pendingWrites === 0 && session.pendingExitCode !== null) {
             this.finalizeSession(session, session.pendingExitCode)
@@ -215,7 +306,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
 
       this.sessions.set(options.tabId, session)
       logDebug('ptyManager.create.success', { tabId: options.tabId })
-      this.emitRenderIfChanged(session)
+      this.scheduleRender(session)
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
       logDebug('ptyManager.create.error', { error: message, tabId: options.tabId })
@@ -224,7 +315,9 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
   }
 
   write(tabId: string, input: string): void {
-    this.sessions.get(tabId)?.pty.write(input)
+    const session = this.sessions.get(tabId)
+    if (!session) return
+    session.pty.write(input)
   }
 
   scrollViewport(tabId: string, deltaLines: number): void {
@@ -234,7 +327,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
 
     session.emulator.scrollLines(deltaLines)
-    this.emitRenderIfChanged(session)
+    this.scheduleRender(session)
   }
 
   scrollViewportToBottom(tabId: string): void {
@@ -244,7 +337,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
 
     session.emulator.scrollToBottom()
-    this.emitRenderIfChanged(session)
+    this.scheduleRender(session)
   }
 
   private applyScrollIntent(session: SessionHandle, intent: ScrollIntent | undefined): void {
@@ -262,7 +355,12 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     session.emulator.scrollToLine(Math.max(0, intent.absoluteLine))
   }
 
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void {
     const safeCols = Math.max(20, cols)
     const safeRows = Math.max(8, rows)
 
@@ -270,11 +368,21 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       session.pty.resize(safeCols, safeRows)
       session.emulator.resize(safeCols, safeRows)
       this.applyScrollIntent(session, intents?.get(session.tabId))
-      this.emitRenderIfChanged(session)
+      if (options?.sync) {
+        this.flushRenderNow(session)
+      } else {
+        this.scheduleRender(session)
+      }
     }
   }
 
-  resizeSession(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
+  resizeSession(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
+  ): void {
     const session = this.sessions.get(tabId)
     if (!session) {
       return
@@ -284,7 +392,11 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     session.pty.resize(safeCols, safeRows)
     session.emulator.resize(safeCols, safeRows)
     this.applyScrollIntent(session, intent)
-    this.emitRenderIfChanged(session)
+    if (options?.sync) {
+      this.flushRenderNow(session)
+    } else {
+      this.scheduleRender(session)
+    }
   }
 
   reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
@@ -293,7 +405,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       return
     }
     this.applyScrollIntent(session, intent)
-    this.emitRenderIfChanged(session)
+    this.scheduleRender(session)
   }
 
   disposeSession(tabId: string): void {
@@ -302,12 +414,16 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       return
     }
 
+    this.clearTimers(tabId)
     this.sessions.delete(tabId)
     session.pty.kill()
     session.emulator.dispose()
   }
 
   disposeAll(): void {
+    for (const tabId of this.sessions.keys()) {
+      this.clearTimers(tabId)
+    }
     for (const session of this.sessions.values()) {
       session.pty.kill()
       session.emulator.dispose()

package/src/restart-terminal-manager.ts

@@ -0,0 +1,44 @@
+import {
+  getTerminalManagerSocketPath,
+  removeTerminalManagerSocketIfExists,
+} from './daemon/runtime-paths'
+import {
+  findIpcDaemonPid,
+  findTerminalManagerPid,
+  killProcess,
+  spawnDetachedTerminalManager,
+} from './platform/daemon-control'
+
+export async function runRestartTerminalManager(): Promise<number> {
+  const socketPath = getTerminalManagerSocketPath()
+
+  const daemonPid = await findIpcDaemonPid()
+  if (daemonPid !== null) {
+    process.stdout.write(`Stopping IPC daemon (pid ${daemonPid})...\n`)
+    await killProcess(daemonPid)
+  }
+
+  const managerPid = await findTerminalManagerPid()
+  if (managerPid !== null) {
+    process.stdout.write(
+      `WARNING: killing terminal-manager (pid ${managerPid}) will kill live sessions.\n`
+    )
+    await killProcess(managerPid)
+    process.stdout.write('Terminal-manager stopped.\n')
+  } else {
+    process.stdout.write('No running terminal-manager found.\n')
+  }
+
+  removeTerminalManagerSocketIfExists()
+
+  process.stdout.write('Starting terminal-manager...\n')
+  const ok = await spawnDetachedTerminalManager()
+
+  if (ok) {
+    process.stdout.write(`Terminal-manager started on ${socketPath}.\n`)
+    return 0
+  }
+
+  process.stderr.write('Failed to start terminal-manager.\n')
+  return 1
+}

package/src/session-backend/local-session-backend.ts

@@ -151,18 +151,29 @@ export class LocalSessionBackend
     this.sessionManager.setActiveTab(this.currentSessionId, tabId)
   }
 
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void {
     if (!this.currentSessionId) {
       return
     }
-    this.sessionManager.resize(this.currentSessionId, cols, rows, intents)
+    this.sessionManager.resize(this.currentSessionId, cols, rows, intents, options)
   }
 
-  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
+  resizeTab(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
+  ): void {
     if (!this.currentSessionId) {
       return
     }
-    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, intent)
+    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, intent, options)
   }
 
   disposeSession(tabId: string): void {

package/src/session-backend/remote-session-backend.ts

@@ -398,7 +398,12 @@ export class RemoteSessionBackend
     }).catch((error) => this.reportCommandError('setActiveTab', error))
   }
 
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    _options?: { sync?: boolean }
+  ): void {
     if (!this.attached) {
       logDebug('backend.remote.skipResizeBeforeAttach', { cols, rows })
       return
@@ -412,7 +417,13 @@ export class RemoteSessionBackend
     }).catch((error) => this.reportCommandError('resizeClient', error))
   }
 
-  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
+  resizeTab(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    _options?: { sync?: boolean }
+  ): void {
     if (!this.attached) {
       return
     }

package/src/session-backend/types.ts

@@ -42,8 +42,19 @@ export interface SessionBackend extends EventEmitter<SessionBackendEvents> {
   scrollViewportToBottom(tabId: string): void
   reapplyScrollIntent(tabId: string, intent: ScrollIntent): void
   setActiveTab(tabId: string | null): void
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void
-  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void
+  resizeTab(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
+  ): void
   disposeSession(tabId: string): void
   disposeAll(): void
   destroy(keepSessions?: boolean): Promise<void> | void

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

@@ -49,18 +49,45 @@ function sameFiles(a: GitFileEntry[], b: GitFileEntry[]): boolean {
 
 export function reduceGitPanelState(state: AppState, action: AppAction): AppState | null {
   switch (action.type) {
-    case 'toggle-git-panel': {
-      const nextGitVisible = !state.sidebar.gitPanelVisible
-      const nextVisible = state.sidebar.visible || nextGitVisible
+    case 'toggle-git-pane': {
+      const nextVisible = !state.gitPane.visible
+      const sidebarMustShow = state.gitPane.mode === 'embedded' && nextVisible
       return {
         ...state,
-        sidebar: { ...state.sidebar, gitPanelVisible: nextGitVisible, visible: nextVisible },
+        gitPane: { ...state.gitPane, visible: nextVisible },
+        sidebar: sidebarMustShow ? { ...state.sidebar, visible: true } : state.sidebar,
       }
     }
-    case 'resize-git-panel': {
-      const nextRatio = clampRatio(state.sidebar.gitPanelRatio + action.delta)
-      if (nextRatio === state.sidebar.gitPanelRatio) return state
-      return { ...state, sidebar: { ...state.sidebar, gitPanelRatio: nextRatio } }
+    case 'resize-git-pane': {
+      const nextRatio = clampRatio(state.gitPane.ratio + action.delta)
+      if (nextRatio === state.gitPane.ratio) return state
+      return { ...state, gitPane: { ...state.gitPane, ratio: nextRatio } }
+    }
+    case 'set-git-pane-mode': {
+      if (state.gitPane.mode === action.mode) return state
+      const isEmbedded = action.mode === 'embedded'
+      const isValidEmbedded =
+        state.gitPane.position === 'top' || state.gitPane.position === 'bottom'
+      const isValidPane = state.gitPane.position === 'left' || state.gitPane.position === 'right'
+      let nextPosition: typeof state.gitPane.position
+      if (isEmbedded) {
+        nextPosition = isValidEmbedded ? state.gitPane.position : 'bottom'
+      } else {
+        nextPosition = isValidPane ? state.gitPane.position : 'left'
+      }
+      return {
+        ...state,
+        gitPane: { ...state.gitPane, mode: action.mode, position: nextPosition },
+      }
+    }
+    case 'set-git-pane-position': {
+      const validForMode =
+        state.gitPane.mode === 'embedded'
+          ? action.position === 'top' || action.position === 'bottom'
+          : action.position === 'left' || action.position === 'right'
+      if (!validForMode) return state
+      if (state.gitPane.position === action.position) return state
+      return { ...state, gitPane: { ...state.gitPane, position: action.position } }
     }
     case 'git-refresh-success': {
       const prev = state.gitPanel

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

@@ -2,6 +2,8 @@ import { basename } from 'node:path'
 
 import type { AppAction, AppState } from '../types'
 
+import { collectHelpEntries } from '../../input/keymap/help-entries'
+import { getActiveKeymap } from '../../input/keymap/keymap-ref'
 import { getAllAssistantOptions } from '../../pty/command-registry'
 import { THEME_IDS } from '../../ui/themes'
 import { filterSessions, filterSnippets } from '../selectors'
@@ -38,18 +40,22 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           type: 'new-tab',
         },
       }
-    case 'open-help-modal':
+    case 'open-help-modal': {
+      const keymap = getActiveKeymap()
+      const entryCount = keymap ? collectHelpEntries(keymap).length : 0
       return {
         ...state,
         focusMode: 'modal',
         modal: {
           cursorPos: 0,
           editBuffer: null,
+          entryCount,
           selectedIndex: 0,
           sessionTargetId: null,
           type: 'help',
         },
       }
+    }
     case 'open-split-picker':
       return {
         ...state,
@@ -200,12 +206,45 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         modal: { ...state.modal, cursorPos: buf.length, editBuffer: buf },
       }
     }
+    case 'set-help-entry-count': {
+      if (state.modal.type !== 'help') return state
+      if (state.modal.entryCount === action.count) {
+        // Still clamp selectedIndex in case the count shrank below it.
+        const clamped = Math.min(state.modal.selectedIndex, Math.max(0, action.count - 1))
+        if (clamped === state.modal.selectedIndex) return state
+        return { ...state, modal: { ...state.modal, selectedIndex: clamped } }
+      }
+      const clamped = Math.min(state.modal.selectedIndex, Math.max(0, action.count - 1))
+      return {
+        ...state,
+        modal: { ...state.modal, entryCount: action.count, selectedIndex: clamped },
+      }
+    }
+    case 'begin-help-filter': {
+      if (state.modal.type !== 'help') {
+        return state
+      }
+      const buf = state.modal.editBuffer ?? ''
+      return {
+        ...state,
+        focusMode: 'command-edit',
+        modal: { ...state.modal, cursorPos: buf.length, editBuffer: buf },
+      }
+    }
     case 'close-modal': {
       const nextFocus: AppState['focusMode'] =
         state.modal.type === 'git-commit' ? 'git' : 'navigation'
       return { ...state, focusMode: nextFocus, modal: emptyModal() }
     }
     case 'move-modal-selection': {
+      if (state.modal.type === 'help') {
+        const count = state.modal.entryCount
+        if (count <= 0) return state
+        const raw = state.modal.selectedIndex + action.delta
+        const nextIndex = ((raw % count) + count) % count
+        if (nextIndex === state.modal.selectedIndex) return state
+        return { ...state, modal: { ...state.modal, selectedIndex: nextIndex } }
+      }
       if (
         state.modal.type !== 'new-tab' &&
         state.modal.type !== 'session-picker' &&
@@ -293,7 +332,9 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         nextCursor = cursor + action.char.length
       }
       const resetIndex =
-        state.modal.type === 'session-picker' || state.modal.type === 'snippet-picker'
+        state.modal.type === 'session-picker' ||
+        state.modal.type === 'snippet-picker' ||
+        state.modal.type === 'help'
           ? 0
           : state.modal.selectedIndex
       return {
@@ -360,7 +401,11 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
       if (state.modal.type === 'create-session' || state.modal.type === 'snippet-editor') {
         return { ...state, focusMode: 'navigation', modal: emptyModal() }
       }
-      if (state.modal.type === 'session-picker' || state.modal.type === 'snippet-picker') {
+      if (
+        state.modal.type === 'session-picker' ||
+        state.modal.type === 'snippet-picker' ||
+        state.modal.type === 'help'
+      ) {
         return {
           ...state,
           focusMode: 'modal',

package/src/state/selectors.ts

@@ -1,4 +1,4 @@
-import type { AppState, SessionRecord, SnippetRecord, TabSession } from './types'
+import type { SessionRecord, SnippetRecord } from './types'
 
 export function filterSessions(sessions: SessionRecord[], filter: string | null): SessionRecord[] {
   if (!filter) {
@@ -24,7 +24,3 @@ export function filterSnippets(snippets: SnippetRecord[], filter: string | null)
       snippet.name.toLowerCase().includes(lower) || snippet.content.toLowerCase().includes(lower)
   )
 }
-
-export function getActiveTab(state: AppState): TabSession | undefined {
-  return state.activeTabId ? state.tabs.find((tab) => tab.id === state.activeTabId) : undefined
-}

package/src/state/session-persistence.ts

@@ -1,10 +1,4 @@
-import {
-  allLeafIds,
-  createGroupId,
-  createLeaf,
-  type LayoutNode,
-  pruneLayoutTree,
-} from './layout-tree'
+import { allLeafIds, createGroupId, type LayoutNode, pruneLayoutTree } from './layout-tree'
 import {
   type AppState,
   DEFAULT_SCROLL_INTENT,
@@ -83,19 +77,6 @@ export function restoreTabsFromWorkspace(snapshot: WorkspaceSnapshotV1 | undefin
   }))
 }
 
-export function restoreLayoutTree(
-  snapshot: WorkspaceSnapshotV1 | undefined,
-  tabs: TabSession[]
-): LayoutNode | null {
-  if (snapshot?.layoutTree) {
-    const validTabIds = new Set(tabs.map((t) => t.id))
-    const pruned = pruneLayoutTree(snapshot.layoutTree, validTabIds)
-    if (pruned) return pruned
-  }
-  // Fallback: single leaf for the first tab
-  return tabs[0] ? createLeaf(tabs[0].id) : null
-}
-
 export function restoreLayoutTrees(
   snapshot: WorkspaceSnapshotV1 | undefined,
   tabs: TabSession[]

package/src/state/store.ts

@@ -1,4 +1,13 @@
-import type { AppAction, AppState, SessionBarPosition, SessionRecord, SnippetRecord } from './types'
+import type {
+  AppAction,
+  AppState,
+  GitPaneMode,
+  GitPanePosition,
+  GitPaneState,
+  SessionBarPosition,
+  SessionRecord,
+  SnippetRecord,
+} from './types'
 
 import { emptyGitMode, reduceGitModeState } from './reducers/git-mode-state'
 import { emptyGitPanel, reduceGitPanelState } from './reducers/git-panel-state'
@@ -15,12 +24,27 @@ const DEFAULT_TERMINAL_COLS = 80
 const DEFAULT_TERMINAL_ROWS = 24
 
 export interface InitialStateOverrides {
-  gitPanelVisible?: boolean
-  gitPanelRatio?: number
+  gitPane?: Partial<GitPaneState>
   sessionBarVisible?: boolean
   sessionBarPosition?: SessionBarPosition
 }
 
+const DEFAULT_GIT_PANE: GitPaneState = {
+  diffCount: { enabled: true },
+  mode: 'embedded',
+  path: { enabled: true },
+  position: 'bottom',
+  ratio: 0.5,
+  visible: true,
+}
+
+function resolveGitPanePosition(mode: GitPaneMode, position: GitPanePosition): GitPanePosition {
+  if (mode === 'embedded') {
+    return position === 'top' || position === 'bottom' ? position : 'bottom'
+  }
+  return position === 'left' || position === 'right' ? position : 'left'
+}
+
 export function createInitialState(
   customCommands: Record<string, string> = {},
   sessions: SessionRecord[] = [],
@@ -28,12 +52,23 @@ export function createInitialState(
   showSessionPicker = false,
   overrides: InitialStateOverrides = {}
 ): AppState {
+  const gitPaneMode = overrides.gitPane?.mode ?? DEFAULT_GIT_PANE.mode
+  const gitPanePosition = resolveGitPanePosition(
+    gitPaneMode,
+    overrides.gitPane?.position ?? DEFAULT_GIT_PANE.position
+  )
   return {
     activeTabId: null,
     currentSessionId: null,
     customCommands,
     focusMode: showSessionPicker ? 'modal' : 'navigation',
     gitMode: emptyGitMode(),
+    gitPane: {
+      ...DEFAULT_GIT_PANE,
+      ...overrides.gitPane,
+      mode: gitPaneMode,
+      position: gitPanePosition,
+    },
     gitPanel: emptyGitPanel(),
     layout: {
       terminalCols: DEFAULT_TERMINAL_COLS,
@@ -51,8 +86,6 @@ export function createInitialState(
     sessions,
     sessionsBusy: {},
     sidebar: {
-      gitPanelRatio: overrides.gitPanelRatio ?? 0.5,
-      gitPanelVisible: overrides.gitPanelVisible ?? true,
       maxWidth: DEFAULT_SIDEBAR_MAX_WIDTH,
       minWidth: DEFAULT_SIDEBAR_MIN_WIDTH,
       visible: true,