@brimveyn/aimux 1.21.0 → 1.22.2

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

@@ -1,5 +1,6 @@
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, AppState, SnippetRecord, TabSession } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { AppState, SnippetRecord, TabSession } from '../state/types'
 
 import { createPrefixedId } from '../platform/id'
 import { isConfigSnippetId, saveSnippetCatalog } from '../state/snippet-catalog'
@@ -40,7 +41,7 @@ export function saveSnippetEditorState(state: AppState): SnippetRecord[] | null
     return null
   }
 
-  const snippetId = state.modal.sessionTargetId
+  const snippetId = state.modal.projectTargetId
   // Config-pinned snippets are sticky and read-only in the UI.
   if (snippetId != null && snippetId !== '' && isConfigSnippetId(snippetId)) {
     return null

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

@@ -0,0 +1,218 @@
+import type { AssistantId, TabSession } from '../state/types'
+import type { SideEffectContext } from './side-effect-context'
+
+import { logInputDebug } from '../debug/input-log'
+import { createPrefixedId } from '../platform/id'
+import {
+  getAllAssistantOptions,
+  getAssistantOption,
+  isCommandAvailable,
+  parseCommand,
+} from '../pty/command-registry'
+import { createTerminalBounds } from '../state/layout-resize'
+import {
+  computePaneRects,
+  createLeaf,
+  getTreeForTab,
+  PANE_BORDER,
+  type SplitDirection,
+  splitNode,
+} from '../state/layout-tree'
+import { getActiveWorkspace, getCurrentProject } from '../state/project-workspaces'
+import { createDefaultTerminalModes } from '../state/terminal-modes'
+import { getSelectedAssistantOption } from './selection'
+
+/**
+ * How long a freshly spawned assistant is given to draw something before the
+ * tab stops being treated as "still starting up".
+ */
+const STARTUP_GRACE_MS = 5_000
+
+export function confirmSplitSelection(ctx: SideEffectContext): void {
+  const { dispatch, state } = ctx
+  const option = getSelectedAssistantOption(state)
+  const direction = state.modal.type === 'split-picker' ? state.modal.splitDirection : 'vertical'
+  const customCommand = state.customCommands[option.id]
+  const tab = createTabSession(
+    option.id,
+    customCommand,
+    state.customCommands,
+    getActiveWorkspace(getCurrentProject(state))?.id
+  )
+  dispatch({ type: 'close-modal' })
+  executeSplitPane(ctx, direction, tab)
+  dispatch({ focusMode: 'terminal-input', type: 'set-focus-mode' })
+}
+
+function createTabId(): string {
+  return createPrefixedId('tab')
+}
+
+export function createTabSession(
+  assistant: AssistantId,
+  customCommand?: string,
+  customCommands?: Record<string, string>,
+  workspaceId?: string
+): TabSession {
+  const allOptions = getAllAssistantOptions(customCommands ?? {})
+  const option = allOptions.find((o) => o.id === assistant) ?? getAssistantOption(0)
+
+  return {
+    activity: 'idle',
+    assistant,
+    buffer: '',
+    command: customCommand ?? option.command,
+    id: createTabId(),
+    status: 'starting',
+    terminalModes: createDefaultTerminalModes(),
+    title: option.label,
+    workspaceId,
+  }
+}
+
+/** Everything `startTabSession` needs from the side-effect context. */
+type StartTabSessionContext = Pick<
+  SideEffectContext,
+  'backend' | 'clearStartupGrace' | 'dispatch' | 'startStartupGrace'
+>
+
+export interface StartTabSessionOptions {
+  cols: number
+  rows: number
+  cwd?: string
+  /** Default true: only a tab the user did not just ask for opts out. */
+  autoRenameCandidate?: boolean
+  /**
+   * Appended after the command's own args. Kept out of `tab.command` on purpose:
+   * an initial prompt is up to a few thousand characters, and `command` is what
+   * the UI shows, what the snapshot persists, and what the custom-command editor
+   * round-trips.
+   */
+  extraArgs?: string[]
+}
+
+export function startTabSession(
+  ctx: StartTabSessionContext,
+  tab: Pick<TabSession, 'id' | 'assistant' | 'title' | 'command' | 'workspaceId'>,
+  { autoRenameCandidate = true, cols, cwd, extraArgs, rows }: StartTabSessionOptions
+): void {
+  const { backend, clearStartupGrace, dispatch } = ctx
+  logInputDebug('app.tab.start.request', {
+    cols,
+    command: tab.command,
+    cwd: cwd ?? null,
+    rows,
+    tabId: tab.id,
+    title: tab.title,
+    workspaceId: tab.workspaceId ?? null,
+  })
+  ctx.startStartupGrace(tab.id, STARTUP_GRACE_MS)
+
+  const { args, executable } = parseCommand(tab.command)
+
+  if (!isCommandAvailable(executable)) {
+    clearStartupGrace(tab.id)
+    dispatch({
+      message: `[command not found] ${executable} is not available in PATH.`,
+      tabId: tab.id,
+      type: 'set-tab-error',
+    })
+    return
+  }
+
+  backend.createSession({
+    args: extraArgs ? [...args, ...extraArgs] : args,
+    assistant: tab.assistant,
+    autoRenameCandidate,
+    cols,
+    command: executable,
+    cwd,
+    rows,
+    tabId: tab.id,
+    title: tab.title,
+    workspaceId: tab.workspaceId,
+  })
+}
+
+/**
+ * Returns the id of the tab it created, so a caller can write into it.
+ *
+ * `initialPromptArgs` hands the prompt to the CLI at spawn — see
+ * `assistantAcceptsPromptArg`. Callers pass it only for assistants that support
+ * it, and fall back to `injectPromptWhenReady` otherwise.
+ */
+export function launchAssistant(
+  ctx: SideEffectContext,
+  assistant: AssistantId,
+  workspaceId?: string,
+  initialPromptArgs?: string[]
+): string {
+  const { dispatch, state } = ctx
+  const customCommand = state.customCommands[assistant]
+  const tab = createTabSession(
+    assistant,
+    customCommand,
+    state.customCommands,
+    workspaceId ?? getActiveWorkspace(getCurrentProject(state))?.id
+  )
+  logInputDebug('app.launchAssistant', {
+    assistant,
+    command: tab.command,
+    tabId: tab.id,
+  })
+  dispatch({ tab, type: 'add-tab' })
+  dispatch({ focusMode: 'terminal-input', type: 'set-focus-mode' })
+  startTabSession(ctx, tab, {
+    cols: state.layout.terminalCols,
+    cwd: getTabProjectPath(ctx, tab),
+    extraArgs: initialPromptArgs,
+    rows: state.layout.terminalRows,
+  })
+  return tab.id
+}
+
+export function getTabProjectPath(
+  ctx: SideEffectContext,
+  tab: Pick<TabSession, 'workspaceId'>
+): string | undefined {
+  // Scoped to the current project on purpose: a tab pinned to a workspace of
+  // some other project gets the current project's path, not that project's.
+  const project = getCurrentProject(ctx.state)
+  const workspace = project?.workspaces?.find((entry) => entry.id === tab.workspaceId)
+  if (workspace) return workspace.path
+  return ctx.getCurrentProjectProjectPath()
+}
+
+export function startExistingTab(ctx: SideEffectContext, tab: TabSession): void {
+  startTabSession(ctx, tab, {
+    autoRenameCandidate: false,
+    cols: ctx.state.layout.terminalCols,
+    cwd: getTabProjectPath(ctx, tab),
+    rows: ctx.state.layout.terminalRows,
+  })
+}
+
+export function executeSplitPane(
+  ctx: SideEffectContext,
+  direction: SplitDirection,
+  tab: TabSession
+): void {
+  const { dispatch, state } = ctx
+  const activeTabId = state.activeTabId
+  if (!(activeTabId != null && activeTabId !== '')) {
+    return
+  }
+
+  const existingTree = getTreeForTab(state.layoutTrees, state.tabGroupMap, activeTabId)
+  const baseTree = existingTree ?? createLeaf(activeTabId)
+  const newTree = splitNode(baseTree, activeTabId, direction, tab.id)
+  const bounds = createTerminalBounds(state.layout.terminalCols, state.layout.terminalRows)
+  const paneRect = computePaneRects(newTree, bounds).get(tab.id)
+
+  dispatch({ direction, newTab: tab, type: 'split-pane' })
+  startTabSession(ctx, tab, {
+    cols: Math.max(1, (paneRect?.cols ?? state.layout.terminalCols) - PANE_BORDER * 2),
+    cwd: getTabProjectPath(ctx, tab),
+    rows: Math.max(1, (paneRect?.rows ?? state.layout.terminalRows) - PANE_BORDER * 2),
+  })
+}

package/src/app-runtime/tab-runtime-timeouts.ts

@@ -1,6 +1,6 @@
 import { useCallback, useRef } from 'react'
 
-import type { AppAction } from '../state/types'
+import type { AppAction } from '../state/actions'
 
 export interface TabRuntimeTimeouts {
   clearIdleTimer: (tabId: string) => void

package/src/app-runtime/use-auto-commit-driver.ts

@@ -1,6 +1,7 @@
 import { type MutableRefObject, useEffect, useRef } from 'react'
 
-import type { AppAction, AppState, GitRefreshPayload, TabActivity } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { AppState, GitRefreshPayload, TabActivity } from '../state/types'
 
 import {
   type AutoCommitConfigSnapshot,
@@ -61,7 +62,7 @@ export function useAutoCommitDriver({
   const prevActivityRef = useRef<Map<string, TabActivity | undefined>>(new Map())
 
   useEffect(() => {
-    // Always refresh the activity map so re-enabling mid-session doesn't fire
+    // Always refresh the activity map so re-enabling mid-project doesn't fire
     // a stale "became idle" transition. Skip only the dispatch work.
     const prev = prevActivityRef.current
     const next = new Map<string, TabActivity | undefined>()
@@ -73,15 +74,15 @@ export function useAutoCommitDriver({
       const becameIdle =
         (before === 'working' || before === 'waiting-input') && tab.activity === 'idle'
       if (becameIdle) {
-        const sessionId = state.currentSessionId
-        if (!(sessionId != null && sessionId !== '')) continue
-        const session = state.sessions.find((s) => s.id === sessionId)
+        const projectId = state.currentProjectId
+        if (!(projectId != null && projectId !== '')) continue
+        const project = state.projects.find((s) => s.id === projectId)
         const git = gitPayloadFromState(state)
         void onActivityTransition(depsRef.current, {
           assistant: tab.assistant,
           git,
-          projectPath: session?.projectPath,
-          sessionId,
+          projectId,
+          projectPath: project?.projectPath,
           tabId: tab.id,
         })
       }
@@ -94,14 +95,14 @@ export function useAutoCommitDriver({
 
   useEffect(() => {
     if (!configRef.current.enabled) return
-    const sessionId = state.currentSessionId
-    if (!(sessionId != null && sessionId !== '')) return
+    const projectId = state.currentProjectId
+    if (!(projectId != null && projectId !== '')) return
     const payload = gitPayloadFromState(state)
     if (!payload) return
     const cacheKey = JSON.stringify(payload)
     if (lastGitHashRef.current === cacheKey) return
     lastGitHashRef.current = cacheKey
-    onGitRefresh(depsRef.current, sessionId, payload)
+    onGitRefresh(depsRef.current, projectId, payload)
 
     // Debounced trigger: when the working tree stays stable for
     // GIT_STABILIZATION_DEBOUNCE_MS, try to start generation. Covers cases
@@ -114,14 +115,14 @@ export function useAutoCommitDriver({
         ? state.tabs.find((tab) => tab.id === activeTabId)
         : undefined
     if (!activeTab) return
-    const session = state.sessions.find((s) => s.id === sessionId)
+    const project = state.projects.find((s) => s.id === projectId)
     gitStabilizeTimerRef.current = setTimeout(() => {
       gitStabilizeTimerRef.current = null
       void onActivityTransition(depsRef.current, {
         assistant: activeTab.assistant,
         git: payload,
-        projectPath: session?.projectPath,
-        sessionId,
+        projectId,
+        projectPath: project?.projectPath,
         tabId: activeTab.id,
       })
     }, GIT_STABILIZATION_DEBOUNCE_MS)

package/src/app-runtime/use-backend-runtime.ts

@@ -1,7 +1,8 @@
 import { type MutableRefObject, useEffect, useRef } from 'react'
 
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, LayoutState } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { LayoutState } from '../state/types'
 
 import { attachCurrentSession } from './backend-attach-runtime'
 import { bindBackendRuntimeEvents } from './backend-runtime-events'
@@ -11,10 +12,10 @@ interface BackendRuntimeOptions {
   backend: SessionBackend
   dispatch: (action: AppAction) => void
   activeTabId: string | null
-  currentSessionId: string | null
+  currentProjectId: string | null
   layoutRef: MutableRefObject<LayoutState>
   resizingRef: MutableRefObject<boolean>
-  currentSessionWorkspaceSnapshot: Parameters<SessionBackend['attach']>[0]['workspaceSnapshot']
+  currentProjectProjectSnapshot: Parameters<SessionBackend['attach']>[0]['projectSnapshot']
   syntaxOverlayEnabled: () => boolean
 }
 
@@ -27,8 +28,8 @@ export interface TabRuntimeControls {
 export function useBackendRuntime({
   activeTabId,
   backend,
-  currentSessionId,
-  currentSessionWorkspaceSnapshot,
+  currentProjectId,
+  currentProjectProjectSnapshot,
   dispatch,
   layoutRef,
   resizingRef,
@@ -39,7 +40,7 @@ export function useBackendRuntime({
   const { clearAllTimers, clearIdleTimer, clearStartupGrace, startStartupGrace } = timeouts
 
   useEffect(() => {
-    if (!(currentSessionId != null && currentSessionId !== '')) {
+    if (!(currentProjectId != null && currentProjectId !== '')) {
       attachRequestIdRef.current += 1
       return
     }
@@ -47,22 +48,22 @@ export function useBackendRuntime({
     return attachCurrentSession({
       attachRequestIdRef,
       backend,
-      currentSessionId,
-      currentSessionWorkspaceSnapshot,
+      currentProjectId,
+      currentProjectProjectSnapshot,
       dispatch,
       layoutRef,
     })
-  }, [backend, currentSessionId, currentSessionWorkspaceSnapshot, dispatch, layoutRef])
+  }, [backend, currentProjectId, currentProjectProjectSnapshot, dispatch, layoutRef])
 
   useEffect(() => {
-    if (!(currentSessionId != null && currentSessionId !== '')) {
+    if (!(currentProjectId != null && currentProjectId !== '')) {
       return
     }
 
     // The backend owns each tab's scroll position; a backgrounded tab keeps it
     // in its own emulator, so switching back needs no re-anchor from here.
     backend.setActiveTab(activeTabId)
-  }, [activeTabId, backend, currentSessionId])
+  }, [activeTabId, backend, currentProjectId])
 
   useEffect(() => {
     return bindBackendRuntimeEvents({

package/src/app-runtime/use-directory-search.ts

@@ -1,13 +1,14 @@
 import { useEffect } from 'react'
 
-import type { AppAction, ModalState } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { ModalState } from '../state/types'
 
 import { searchProjectDirectories, warmDirectoryCache } from '../platform/project-search'
 
 const DEFAULT_DIRECTORY_SEARCH_DEBOUNCE_MS = 200
 
 function getDirectoryQuery(modal: ModalState): string {
-  if (modal.type !== 'create-session') {
+  if (modal.type !== 'create-project') {
     return ''
   }
 
@@ -26,12 +27,12 @@ export function useDirectorySearch(
   const directoryQuery = getDirectoryQuery(modal)
 
   useEffect(() => {
-    if (modal.type !== 'create-session') return
+    if (modal.type !== 'create-project') return
     void warmDirectoryCache()
   }, [modal.type])
 
   useEffect(() => {
-    if (modal.type !== 'create-session') {
+    if (modal.type !== 'create-project') {
       return
     }
 

package/src/app-runtime/use-mouse-handlers.ts

@@ -4,8 +4,9 @@ import { useEffect, useRef } from 'react'
 
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { SessionBackend } from '../session-backend/types'
+import type { AppAction } from '../state/actions'
 import type { SplitDirection } from '../state/layout-tree'
-import type { AppAction, AppState, BarSide, TabSession, TerminalLine } from '../state/types'
+import type { AppState, BarSide, TabSession, TerminalLine } from '../state/types'
 
 import { logInputDebug } from '../debug/input-log'
 import { MultiClickDetector } from '../input/multi-click-detector'

package/src/app-runtime/{use-workspace-autosave.ts → use-project-autosave.ts}

@@ -2,9 +2,9 @@ import { useEffect, useRef } from 'react'
 
 import type { AppState } from '../state/types'
 
-import { saveCurrentWorkspace } from '../state/workspace-save'
+import { saveCurrentProject } from '../state/project-save'
 
-export function useWorkspaceAutosave(state: AppState, debounceMs: number): void {
+export function useProjectAutosave(state: AppState, debounceMs: number): void {
   const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   const latestStateRef = useRef(state)
   latestStateRef.current = state
@@ -15,7 +15,7 @@ export function useWorkspaceAutosave(state: AppState, debounceMs: number): void
     }
 
     timeoutRef.current = setTimeout(() => {
-      saveCurrentWorkspace(latestStateRef.current)
+      saveCurrentProject(latestStateRef.current)
       timeoutRef.current = null
     }, debounceMs)
 
@@ -33,7 +33,7 @@ export function useWorkspaceAutosave(state: AppState, debounceMs: number): void
         clearTimeout(timeoutRef.current)
         timeoutRef.current = null
       }
-      saveCurrentWorkspace(latestStateRef.current)
+      saveCurrentProject(latestStateRef.current)
     }
   }, [])
 }

package/src/app-runtime/use-renderer-bindings.ts

@@ -4,7 +4,8 @@ import { type MutableRefObject, useEffect, useRef } from 'react'
 
 import type { KeyChord } from '../input/keymap/key-chord'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, FocusMode, SnippetRecord, TabSession } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { FocusMode, SnippetRecord, TabSession } from '../state/types'
 
 import { INPUT_DEBUG_LOG_PATH, logInputDebug } from '../debug/input-log'
 import { createRawInputHandler } from '../input/raw-input-handler'

package/src/app-runtime/use-setup-runner.ts

@@ -0,0 +1,96 @@
+import { useEffect, useRef } from 'react'
+
+import type { AppState, ProjectRecord, TabSession, WorkspaceRecord } from '../state/types'
+import type { SideEffectContext } from './side-effect-context'
+
+import { hasSetupScript } from '../state/project-data'
+import { findSetupTab, runSetup } from './setup-actions'
+
+export interface SetupCandidate {
+  projectId: string
+  workspace: WorkspaceRecord
+}
+
+/**
+ * Which workspaces should have their setup script run right now.
+ *
+ * The trigger is "a workspace id this session has not seen before", not "a
+ * workspace became active". Activation is the wrong signal: `j`/`k` cycles
+ * workspaces, so an activation-based rule would fire the script in every
+ * workspace the user scrolls past. Watching the id set also means one rule
+ * covers both creation paths — the TUI's `<C-p>` and `aimux workspace create`
+ * arriving over the daemon — instead of a hook per call site, which is how the
+ * CLI path ends up silently skipping setup.
+ *
+ * Mutates `seenByProject`: every id examined is marked seen, so a workspace is
+ * only ever a candidate once.
+ */
+export function collectSetupCandidates(
+  projects: ProjectRecord[],
+  tabs: TabSession[],
+  seenByProject: Map<string, Set<string>>,
+  hasScript: (projectId: string) => boolean
+): SetupCandidate[] {
+  const candidates: SetupCandidate[] = []
+
+  for (const project of projects) {
+    const seen = seenByProject.get(project.id)
+    const workspaces = project.workspaces ?? []
+
+    // First sight of a project: record what it already has and run nothing.
+    // Without this, switching to a project surfaces N pre-existing workspaces
+    // at once and would fire N setups.
+    if (!seen) {
+      seenByProject.set(project.id, new Set(workspaces.map((w) => w.id)))
+      continue
+    }
+
+    for (const workspace of workspaces) {
+      if (seen.has(workspace.id)) continue
+      seen.add(workspace.id)
+
+      // The primary workspace *is* the user's real repo checkout. Running a
+      // script that does `cp .env.example .env` over it would clobber their
+      // actual .env.
+      if (workspace.source === 'primary') continue
+      if (!hasScript(project.id)) continue
+      if (findSetupTab(tabs, workspace.id)) continue
+
+      candidates.push({ projectId: project.id, workspace })
+    }
+  }
+
+  return candidates
+}
+
+/**
+ * Runs a project's setup script once per newly created workspace.
+ *
+ * ponytail: a workspace created by the CLI while the app is closed is seeded as
+ * pre-existing on the next boot and never auto-runs. The widget's Run button
+ * covers it; compare createdAt against setupRanAt if that turns out to matter.
+ *
+ * The outcome is recorded by `recordSetupExitIfHidden`, called from the
+ * backend's exit event, which already carries the exit code.
+ */
+export function useSetupRunner(state: AppState, ctx: SideEffectContext): void {
+  const seenByProject = useRef(new Map<string, Set<string>>())
+  const ctxRef = useRef(ctx)
+  ctxRef.current = ctx
+
+  useEffect(() => {
+    // Tabs are read fresh rather than taken as a dependency: their array
+    // identity changes on every viewport frame, which would re-run this at the
+    // rate the PTYs print. The store is also the more correct source — the
+    // render snapshot can lag a setup tab that was just added.
+    const candidates = collectSetupCandidates(
+      state.projects,
+      ctxRef.current.getState().tabs,
+      seenByProject.current,
+      hasSetupScript
+    )
+    for (const { projectId, workspace } of candidates) {
+      runSetup(ctxRef.current, projectId, workspace)
+    }
+  }, [state.projects])
+}

package/src/app-runtime/use-terminal-resize.ts

@@ -10,7 +10,8 @@ import {
 
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, AppState } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { AppState } from '../state/types'
 import type { MeasuredPaneRect } from './use-pane-size-report'
 
 import { getBarWidth } from '../state/bars'
@@ -151,7 +152,10 @@ export function useTerminalResize({
   const handledBySyncRef = useRef(false)
   const sidebarMountedRef = useRef(false)
 
-  const currentTabIds = state.tabs.map((t) => t.id)
+  // Hidden tabs are excluded from the open-loop cascade: their host (the setup
+  // widget) measures its own box, and the cascade would overwrite that with the
+  // main terminal area's size on every terminal or bar resize.
+  const currentTabIds = state.tabs.filter((t) => t.hidden !== true).map((t) => t.id)
   const tabIdsChanged =
     currentTabIds.length !== tabIdsRef.current.length ||
     currentTabIds.some((id, i) => id !== tabIdsRef.current[i])
@@ -179,15 +183,15 @@ export function useTerminalResize({
   // loop so an unchanged box never re-triggers a resize.
   const measuredRef = useRef(new Map<string, { cols: number; rows: number }>())
 
-  // Drop the dedupe cache when the workspace changes. attach() re-gates every
+  // Drop the dedupe cache when the project changes. attach() re-gates every
   // restored tab's paneReady to false; if a tabId carries the same dimensions
-  // across workspaces, handleMeasure's prev-match would short-circuit and
+  // across projects, handleMeasure's prev-match would short-circuit and
   // never call resizeTab({confirmedFromMeasurement:true}), leaving the gate
   // closed forever — the new pane then paints a stale buffered snapshot from
-  // the old workspace, which is the 2–3 row offset users see.
-  const lastSessionIdRef = useRef(state.currentSessionId)
-  if (lastSessionIdRef.current !== state.currentSessionId) {
-    lastSessionIdRef.current = state.currentSessionId
+  // the old project, which is the 2–3 row offset users see.
+  const lastProjectIdRef = useRef(state.currentProjectId)
+  if (lastProjectIdRef.current !== state.currentProjectId) {
+    lastProjectIdRef.current = state.currentProjectId
     measuredRef.current.clear()
   }
 
@@ -229,13 +233,13 @@ export function useTerminalResize({
   const leftBarWidth = getBarWidth(state.bars.left)
   const rightBarWidth = getBarWidth(state.bars.right)
   const terminalSize = useMemo(() => {
-    const sessionBarRows = state.sessionBar.visible ? 1 : 0
-    const sessionBarTopOffset = sessionBarRows
+    const projectBarRows = state.projectBar.visible ? 1 : 0
+    const projectBarTopOffset = projectBarRows
     const reservedRows =
       MAIN_AREA_VERTICAL_PADDING +
       STATUS_BAR_HEIGHT +
       TERMINAL_PANE_VERTICAL_CHROME +
-      sessionBarRows
+      projectBarRows
     const cols = Math.max(
       MIN_TERMINAL_COLS,
       Math.floor(dimensions.width - leftBarWidth - rightBarWidth - MAIN_AREA_HORIZONTAL_CHROME)
@@ -246,7 +250,7 @@ export function useTerminalResize({
       cols,
       rows,
       x: leftBarWidth + 1,
-      y: 1 + sessionBarTopOffset,
+      y: 1 + projectBarTopOffset,
     }
 
     return { cols, rows }
@@ -256,7 +260,7 @@ export function useTerminalResize({
     dimensions.width,
     leftBarWidth,
     rightBarWidth,
-    state.sessionBar.visible,
+    state.projectBar.visible,
   ])
 
   useLayoutEffect(() => {
@@ -278,7 +282,7 @@ export function useTerminalResize({
     })
     handledBySyncRef.current = true
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [leftBarWidth, rightBarWidth, state.sessionBar.visible])
+  }, [leftBarWidth, rightBarWidth, state.projectBar.visible])
 
   useEffect(() => {
     if (handledBySyncRef.current) {