@brimveyn/aimux 1.6.2 → 1.7.0

package/README.md

@@ -202,6 +202,9 @@ not collide with a globally installed `aimux` instance.
   and focusing on the first change rather than the top of the file.
 - [shiki](https://shiki.style) — syntax highlighting for the git diff view
   and the source of the bundled theme catalog.
+- [herdr](https://github.com/ogulcancelik/herdr) by @ogulcancelik — the
+  per-CLI assistant status heuristics (working / waiting-input / idle)
+  used in the session bar are adapted from herdr's `detect.rs` rule tables.
 
 ## License
 

package/package.json

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

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

@@ -48,6 +48,12 @@ function hydrateAttachedSession(
       tabs: result.tabs,
       type: 'hydrate-workspace',
     })
+    // Dispatch the session-status snapshot *after* hydrate-workspace so
+    // sidebar chips reflect per-session state on attach without waiting
+    // for the next daemon-side status transition.
+    for (const entry of result.initialSessionStatuses) {
+      dispatch({ sessionId: entry.sessionId, status: entry.status, type: 'set-session-status' })
+    }
     resizeSnapshotPanes(workspaceSnapshot, layoutRef, backend)
     return
   }

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

@@ -1,25 +1,22 @@
 import type { MutableRefObject } from 'react'
 
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, TabSession, TerminalModeState } from '../state/types'
+import type {
+  AppAction,
+  SessionStatus,
+  TabActivity,
+  TabSession,
+  TerminalModeState,
+} from '../state/types'
 
 import { logInputDebug } from '../debug/input-log'
 import { type TabRuntimeTimeouts } from './tab-runtime-timeouts'
 
-const IDLE_ACTIVITY_TIMEOUT_MS = 2_000
-
 interface BindBackendRuntimeEventsOptions {
   backend: SessionBackend
   dispatch: (action: AppAction) => void
   resizingRef: MutableRefObject<boolean>
-  timeouts: Pick<
-    TabRuntimeTimeouts,
-    | 'clearIdleTimer'
-    | 'clearStartupGrace'
-    | 'isStartupGraceActive'
-    | 'scheduleIdle'
-    | 'clearAllTimers'
-  >
+  timeouts: Pick<TabRuntimeTimeouts, 'clearIdleTimer' | 'clearStartupGrace' | 'clearAllTimers'>
 }
 
 function clearTabRuntimeState(
@@ -58,19 +55,14 @@ export function bindBackendRuntimeEvents({
       type: 'replace-tab-viewport',
       viewport,
     })
-    if (timeouts.isStartupGraceActive(tabId) || resizingRef.current) {
-      return
-    }
-
-    dispatch({ activity: 'busy', tabId, type: 'set-tab-activity' })
-    timeouts.scheduleIdle(tabId, IDLE_ACTIVITY_TIMEOUT_MS)
+    // Per-tab activity is driven by the backend's status-detection loop via
+    // the `tabActivity` event — no client-side idle timer needed.
   }
 
   const handleExit = (tabId: string, exitCode: number) => {
     logInputDebug('app.backend.event.exit', { exitCode, tabId })
     clearTabRuntimeState(timeouts, tabId)
-    dispatch({ exitCode, status: 'exited', tabId, type: 'set-tab-status' })
-    dispatch({ activity: undefined, tabId, type: 'set-tab-activity' })
+    dispatch({ tabId, type: 'close-tab' })
   }
 
   const handleError = (tabId: string, message: string) => {
@@ -79,14 +71,21 @@ export function bindBackendRuntimeEvents({
     dispatch({ message, tabId, type: 'set-tab-error' })
   }
 
-  const handleSessionActivity = (sessionId: string, busy: boolean) => {
-    dispatch({ busy, sessionId, type: 'set-session-busy' })
+  const handleSessionActivity = (sessionId: string, status: SessionStatus) => {
+    logInputDebug('app.backend.event.sessionActivity', { sessionId, status })
+    dispatch({ sessionId, status, type: 'set-session-status' })
+  }
+
+  const handleTabActivity = (tabId: string, activity: TabActivity) => {
+    logInputDebug('app.backend.event.tabActivity', { activity, tabId })
+    dispatch({ activity, tabId, type: 'set-tab-activity' })
   }
 
   backend.on('render', handleRender)
   backend.on('exit', handleExit)
   backend.on('error', handleError)
   backend.on('sessionActivity', handleSessionActivity)
+  backend.on('tabActivity', handleTabActivity)
 
   return () => {
     timeouts.clearAllTimers()
@@ -94,6 +93,7 @@ export function bindBackendRuntimeEvents({
     backend.off('exit', handleExit)
     backend.off('error', handleError)
     backend.off('sessionActivity', handleSessionActivity)
+    backend.off('tabActivity', handleTabActivity)
     void backend.destroy(true)
   }
 }

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

@@ -24,7 +24,7 @@ import {
   type SplitDirection,
   splitNode,
 } from '../state/layout-tree'
-import { filterSessions, filterSnippets } from '../state/selectors'
+import { filterAssistants, filterSessions, filterSnippets } from '../state/selectors'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
 import {
   type AppAction,
@@ -36,7 +36,7 @@ import {
 import { saveCurrentWorkspace } from '../state/workspace-save'
 import { filterThemeIds } from '../ui/filter-themes'
 import { scrollGitDiff } from '../ui/git-view-controls'
-import { applyTheme } from '../ui/theme'
+import { applyTheme, getTransparent, setTransparent } from '../ui/theme'
 import { type ThemeId } from '../ui/themes'
 import {
   handleCreateSessionEffect,
@@ -68,9 +68,10 @@ export interface SideEffectContext {
 }
 
 function getSelectedAssistantOption(state: AppState) {
-  return (
-    getAllAssistantOptions(state.customCommands)[state.modal.selectedIndex] ?? getAssistantOption(0)
-  )
+  const all = getAllAssistantOptions(state.customCommands)
+  const filter = state.modal.type === 'new-tab' ? state.modal.editBuffer : null
+  const list = filterAssistants(all, filter)
+  return list[state.modal.selectedIndex] ?? list[0] ?? getAssistantOption(0)
 }
 
 function handleSessionSelection(ctx: SideEffectContext): void {
@@ -87,7 +88,7 @@ function handleSessionSelection(ctx: SideEffectContext): void {
     return
   }
 
-  dispatch({ type: 'open-create-session-modal' })
+  dispatch({ returnToSessionPicker: true, type: 'open-create-session-modal' })
 }
 
 function handleSelectedSessionDelete(ctx: SideEffectContext): void {
@@ -143,24 +144,28 @@ function pasteSnippetToActiveGroup(ctx: SideEffectContext): void {
   }
 }
 
-function saveCustomCommandSelection(state: AppState): void {
-  const option = getAllAssistantOptions(state.customCommands)[state.modal.selectedIndex]
-  if (!option || state.modal.editBuffer === null) {
+function saveCustomCommandSelection(ctx: SideEffectContext): void {
+  const { dispatch, state } = ctx
+  if (state.modal.type !== 'new-tab' || state.modal.editingCommand === null) {
     return
   }
+  const assistantId = state.modal.editingCommand
+  if (state.modal.editBuffer === null) return
 
   const trimmed = state.modal.editBuffer.trim()
   const newCustomCommands = { ...state.customCommands }
   if (trimmed) {
-    newCustomCommands[option.id] = trimmed
+    newCustomCommands[assistantId] = trimmed
   } else {
-    delete newCustomCommands[option.id]
+    delete newCustomCommands[assistantId]
   }
 
   saveConfig({
     ...loadConfig(),
     customCommands: newCustomCommands,
   })
+  dispatch({ customCommands: newCustomCommands, type: 'set-custom-commands' })
+  dispatch({ type: 'cancel-command-edit' })
 }
 
 function applyThemeEffect(
@@ -299,6 +304,7 @@ function launchAssistant(ctx: SideEffectContext, assistant: AssistantId): void {
     tabId: tab.id,
   })
   dispatch({ tab, type: 'add-tab' })
+  dispatch({ focusMode: 'terminal-input', type: 'set-focus-mode' })
   startTabSession(
     backend,
     dispatch,
@@ -435,7 +441,7 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       return
     }
     case 'save-custom-command': {
-      saveCustomCommandSelection(state)
+      saveCustomCommandSelection(ctx)
       return
     }
     case 'apply-theme': {
@@ -546,6 +552,12 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       handleSwitchSessionByIndex(ctx, effect.index)
       return
     }
+    case 'toggle-transparent': {
+      const next = !getTransparent()
+      setTransparent(next)
+      saveConfig({ ...loadConfig(), themeTransparent: next })
+      return
+    }
     default:
       effect satisfies never
   }

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

@@ -36,14 +36,7 @@ export function useBackendRuntime({
 }: BackendRuntimeOptions): TabRuntimeControls {
   const attachRequestIdRef = useRef(0)
   const timeouts = useTabRuntimeTimeouts(dispatch)
-  const {
-    clearAllTimers,
-    clearIdleTimer,
-    clearStartupGrace,
-    isStartupGraceActive,
-    scheduleIdle,
-    startStartupGrace,
-  } = timeouts
+  const { clearAllTimers, clearIdleTimer, clearStartupGrace, startStartupGrace } = timeouts
 
   useEffect(() => {
     if (!currentSessionId) {
@@ -81,20 +74,9 @@ export function useBackendRuntime({
         clearAllTimers,
         clearIdleTimer,
         clearStartupGrace,
-        isStartupGraceActive,
-        scheduleIdle,
       },
     })
-  }, [
-    backend,
-    clearAllTimers,
-    clearIdleTimer,
-    clearStartupGrace,
-    dispatch,
-    isStartupGraceActive,
-    resizingRef,
-    scheduleIdle,
-  ])
+  }, [backend, clearAllTimers, clearIdleTimer, clearStartupGrace, dispatch, resizingRef])
 
   return {
     clearIdleTimer,

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

@@ -2,7 +2,7 @@ import { useEffect } from 'react'
 
 import type { AppAction, ModalState } from '../state/types'
 
-import { searchProjectDirectories } from '../platform/project-search'
+import { searchProjectDirectories, warmDirectoryCache } from '../platform/project-search'
 
 const DEFAULT_DIRECTORY_SEARCH_DEBOUNCE_MS = 200
 
@@ -25,6 +25,11 @@ export function useDirectorySearch(
 ): void {
   const directoryQuery = getDirectoryQuery(modal)
 
+  useEffect(() => {
+    if (modal.type !== 'create-session') return
+    void warmDirectoryCache()
+  }, [modal.type])
+
   useEffect(() => {
     if (modal.type !== 'create-session') {
       return

package/src/app.tsx

@@ -37,7 +37,7 @@ import { loadSnippetCatalog } from './state/snippet-catalog'
 import { appReducer, createInitialState } from './state/store'
 import { KeymapContext } from './ui/keymap-context'
 import { RootView } from './ui/root'
-import { applyTheme } from './ui/theme'
+import { applyTheme, setTransparent } from './ui/theme'
 import { isKnownThemeId, registerUserThemes, type ThemeId } from './ui/themes'
 import {
   fetchLatestNpmVersion,
@@ -75,6 +75,7 @@ export function App({
         : undefined
     const initial = persisted ?? fromConfig ?? 'aimux'
     applyTheme(initial)
+    setTransparent(config.themeTransparent ?? false)
     return initial
   })
   const [state, dispatch] = useReducer(appReducer, undefined, () => {

package/src/config.ts

@@ -37,6 +37,7 @@ export interface AimuxConfig {
   version: 2
   customCommands: Record<string, string>
   themeId?: ThemeId
+  themeTransparent?: boolean
   gitPane?: PersistedGitPane
   sessionBarVisible?: boolean
   sessionBarPosition?: SessionBarPosition
@@ -126,6 +127,7 @@ export function loadConfigResult(): ConfigLoadResult {
       version?: number
       customCommands?: unknown
       themeId?: unknown
+      themeTransparent?: unknown
       gitPane?: unknown
       gitPanelVisible?: unknown
       gitPanelRatio?: unknown
@@ -149,6 +151,12 @@ export function loadConfigResult(): ConfigLoadResult {
       issues.push('ignored invalid themeId')
     }
 
+    const validThemeTransparent =
+      typeof parsed.themeTransparent === 'boolean' ? parsed.themeTransparent : undefined
+    if (parsed.themeTransparent !== undefined && validThemeTransparent === undefined) {
+      issues.push('ignored invalid themeTransparent')
+    }
+
     let validGitPane = isPersistedGitPane(parsed.gitPane) ? parsed.gitPane : undefined
     if (parsed.gitPane !== undefined && validGitPane === undefined) {
       issues.push('ignored invalid gitPane')
@@ -218,6 +226,7 @@ export function loadConfigResult(): ConfigLoadResult {
         sessionBarVisible: validSessionBarVisible,
         skippedUpdateVersion: validSkippedUpdateVersion,
         themeId: migrateThemeId(parsed.themeId),
+        themeTransparent: validThemeTransparent,
         version: 2,
         workspaceSnapshot: isWorkspaceSnapshotV1(parsed.workspaceSnapshot)
           ? parsed.workspaceSnapshot

package/src/daemon/daemon.ts

@@ -1,5 +1,7 @@
 import { connect, createServer, type Socket } from 'node:net'
 
+import type { AssistantId, TerminalSnapshot } from '../state/types'
+
 import { logDebug } from '../debug/input-log'
 import {
   type ClientRequest,
@@ -14,6 +16,7 @@ import {
   type ServerResponse,
 } from '../ipc/protocol'
 import { findSocketProcessPid, spawnDetachedTerminalManager } from '../platform/daemon-control'
+import { type LoopTabView, runStatusDetectionLoop } from '../pty/assistant-status-detection-loop'
 import { TerminalManagerClient } from '../terminal-manager/manager-client'
 import {
   getIpcDaemonSocketPath,
@@ -24,6 +27,53 @@ import {
   tightenSocketPermissions,
 } from './runtime-paths'
 
+export interface DaemonTabEntry {
+  sessionId: string
+  assistant: AssistantId
+  command: string
+  viewport: TerminalSnapshot | undefined
+  /**
+   * Monotonic viewport sequence. Incremented on every render-event write so
+   * stale writers (e.g. `attach` returning a pre-await snapshot) can refuse
+   * to clobber a fresher viewport that arrived via `render` while the
+   * `attachSession` call was still in flight.
+   */
+  viewportSeq: number
+}
+
+/**
+ * Merges an attach-time tab view into the registry without clobbering a
+ * viewport that arrived via a render event during the `attachSession` await.
+ *
+ * Returns the updated entry (also written into `registry`). `seq` is a
+ * monotonic counter scoped to the registry; pass the same counter into every
+ * call so the new entry slot gets a stable ordinal when we first observe it.
+ *
+ * Exported for unit tests — the attach path in `runDaemon` uses the same
+ * helper through a closure that threads the counter.
+ */
+export function mergeTabRegistryEntry(
+  registry: Map<string, DaemonTabEntry>,
+  sessionId: string,
+  tabId: string,
+  assistant: AssistantId,
+  command: string,
+  initialViewport: TerminalSnapshot | undefined,
+  allocateSeq: () => number
+): DaemonTabEntry {
+  const existing = registry.get(tabId)
+  const viewport = existing?.viewport ?? initialViewport
+  const entry: DaemonTabEntry = {
+    assistant,
+    command,
+    sessionId,
+    viewport,
+    viewportSeq: existing?.viewportSeq ?? (viewport ? allocateSeq() : 0),
+  }
+  registry.set(tabId, entry)
+  return entry
+}
+
 function send(socket: Socket, message: ServerResponse | ServerEvent): void {
   socket.write(encodeMessage(message))
 }
@@ -115,37 +165,121 @@ export async function runDaemon(): Promise<void> {
   const attachedSessions = new Map<Socket, string>()
   const negotiatedVersions = new Map<Socket, number>()
 
-  manager.on('render', (sessionId, tabId, viewport, terminalModes) => {
-    logDebug('daemon.manager.render', {
-      attachedSocketCount: sockets.size,
+  // Per-tab registry so the status-detection loop can poll every terminal
+  // continuously, not just the one the UI is currently attached to.
+  const tabRegistry = new Map<string, DaemonTabEntry>()
+  let nextViewportSeq = 1
+
+  const allocateSeq = (): number => nextViewportSeq++
+  const rememberTab = (
+    sessionId: string,
+    tabId: string,
+    assistant: AssistantId,
+    command: string,
+    initialViewport?: TerminalSnapshot
+  ): void => {
+    const before = tabRegistry.get(tabId)
+    const entry = mergeTabRegistryEntry(
+      tabRegistry,
+      sessionId,
+      tabId,
+      assistant,
+      command,
+      initialViewport,
+      allocateSeq
+    )
+    logDebug('daemon.rememberTab', {
+      hadExistingEntry: before !== undefined,
+      hadExistingViewport: before?.viewport !== undefined,
+      initialViewportProvided: initialViewport !== undefined,
+      preservedExistingViewport:
+        before?.viewport !== undefined && entry.viewport === before.viewport,
+      resultSeq: entry.viewportSeq,
       sessionId,
       tabId,
-      viewportLines: viewport.lines.length,
     })
-    const event: ServerEvent = { payload: { tabId, terminalModes, viewport }, type: 'tabRender' }
+  }
+
+  const broadcastAll = (event: ServerEvent): void => {
+    for (const socket of sockets) {
+      send(socket, event)
+    }
+  }
+
+  const broadcastForSession = (sessionId: string, event: ServerEvent): void => {
     for (const socket of sockets) {
       if (attachedSessions.get(socket) === sessionId) {
         send(socket, event)
       }
     }
+  }
+
+  manager.on('render', (sessionId, tabId, viewport, terminalModes) => {
+    const existing = tabRegistry.get(tabId)
+    let newSeq: number | null = null
+    if (existing) {
+      existing.viewport = viewport
+      existing.viewportSeq = nextViewportSeq++
+      existing.sessionId = sessionId
+      newSeq = existing.viewportSeq
+    }
+    logDebug('daemon.manager.render', {
+      attachedSocketCount: sockets.size,
+      hadRegistryEntry: existing !== undefined,
+      newSeq,
+      sessionId,
+      tabId,
+      viewportLines: viewport.lines.length,
+    })
+    const event: ServerEvent = { payload: { tabId, terminalModes, viewport }, type: 'tabRender' }
+    broadcastForSession(sessionId, event)
   })
   manager.on('exit', (sessionId, tabId, exitCode) => {
     logDebug('daemon.manager.exit', { exitCode, sessionId, tabId })
+    tabRegistry.delete(tabId)
     const event: ServerEvent = { payload: { exitCode, tabId }, type: 'tabExit' }
-    for (const socket of sockets) {
-      if (attachedSessions.get(socket) === sessionId) {
-        send(socket, event)
-      }
-    }
+    broadcastForSession(sessionId, event)
   })
   manager.on('error', (sessionId, tabId, message) => {
     logDebug('daemon.manager.error', { message, sessionId, tabId })
     const event: ServerEvent = { payload: { message, tabId }, type: 'tabError' }
-    for (const socket of sockets) {
-      if (attachedSessions.get(socket) === sessionId) {
-        send(socket, event)
-      }
+    broadcastForSession(sessionId, event)
+  })
+
+  const listTabsForSession = (sessionId: string): LoopTabView[] => {
+    const result: LoopTabView[] = []
+    for (const [tabId, entry] of tabRegistry) {
+      if (entry.sessionId !== sessionId) continue
+      result.push({
+        assistant: entry.assistant,
+        command: entry.command,
+        id: tabId,
+        viewport: entry.viewport,
+      })
     }
+    return result
+  }
+
+  const statusLoop = runStatusDetectionLoop({
+    listSessions: () => {
+      const seen = new Set<string>()
+      for (const entry of tabRegistry.values()) seen.add(entry.sessionId)
+      return [...seen]
+    },
+    listTabs: listTabsForSession,
+    onSessionStatus: (sessionId, status) => {
+      logDebug('daemon.status.session', { sessionId, status })
+      broadcastAll({ payload: { sessionId, status }, type: 'sessionStatus' })
+    },
+    onTabStatus: (tabId, status, sessionId) => {
+      logDebug('daemon.status.tab', { sessionId, status, tabId })
+      // Broadcast to every client. Clients silently ignore events for tabIds
+      // they don't know about, so there's no UI impact — this costs one
+      // extra socket write per tab per change, which is trivial, and
+      // removes a race where in-flight tab events could be dropped when a
+      // client tears down its socket to switch sessions.
+      broadcastAll({ payload: { sessionId, status, tabId }, type: 'tabStatus' })
+    },
   })
 
   const server = createServer((socket) => {
@@ -213,12 +347,49 @@ export async function runDaemon(): Promise<void> {
                     sessionId: message.payload.sessionId,
                     workspaceSnapshot: message.payload.workspaceSnapshot,
                   })
+                  for (const tab of attachResult.tabs) {
+                    rememberTab(
+                      message.payload.sessionId,
+                      tab.id,
+                      tab.assistant,
+                      tab.command,
+                      tab.viewport
+                    )
+                  }
+                  // Classify synchronously BEFORE sending attachResult so
+                  // each tab's activity and the full session-status snapshot
+                  // are available to embed in the reply. This makes the
+                  // client apply them atomically with `hydrate-workspace`
+                  // and closes the race where separate `tabStatus` events
+                  // landed before the tab existed in client state.
+                  const tabsForLoop = listTabsForSession(message.payload.sessionId)
+                  logDebug('daemon.attach.preClassify', {
+                    sessionId: message.payload.sessionId,
+                    tabs: tabsForLoop.map((t) => ({
+                      assistant: t.assistant,
+                      hasViewport: t.viewport !== undefined,
+                      id: t.id,
+                      seq: tabRegistry.get(t.id)?.viewportSeq ?? null,
+                    })),
+                  })
+                  statusLoop.classifyNow(message.payload.sessionId, tabsForLoop)
+                  const tabsWithActivity = attachResult.tabs.map((tab) => ({
+                    ...tab,
+                    activity: statusLoop.getTabStatus(tab.id) ?? tab.activity,
+                  }))
+                  const initialSessionStatuses = statusLoop.snapshotSessions()
+                  logDebug('daemon.attach.replay', {
+                    sessionId: message.payload.sessionId,
+                    sessions: initialSessionStatuses,
+                    tabs: tabsWithActivity.map((t) => ({ activity: t.activity, id: t.id })),
+                  })
                   send(socket, {
                     id: message.id,
                     payload: {
                       activeTabId: attachResult.activeTabId,
+                      initialSessionStatuses,
                       protocolVersion: negotiatedVersion,
-                      tabs: attachResult.tabs,
+                      tabs: tabsWithActivity,
                     },
                     type: 'attachResult',
                   })
@@ -238,6 +409,12 @@ export async function runDaemon(): Promise<void> {
                     tabId: message.payload.tabId,
                     title: message.payload.title,
                   })
+                  rememberTab(
+                    sessionId,
+                    message.payload.tabId,
+                    message.payload.assistant,
+                    [message.payload.command, ...(message.payload.args ?? [])].join(' ')
+                  )
                   await manager.createTab({ ...message.payload, sessionId })
                   sendOk(socket, message.id)
                   logDebug('daemon.request.createTab.success', {
@@ -313,6 +490,7 @@ export async function runDaemon(): Promise<void> {
                 case 'closeTab': {
                   const sessionId = requireSession(socket, attachedSessions)
                   requireNegotiatedVersion(socket, negotiatedVersions)
+                  tabRegistry.delete(message.payload.tabId)
                   await manager.closeTab(sessionId, message.payload.tabId)
                   sendOk(socket, message.id)
                   break
@@ -321,6 +499,9 @@ export async function runDaemon(): Promise<void> {
                   const sessionId = attachedSessions.get(socket)
                   requireNegotiatedVersion(socket, negotiatedVersions)
                   if (sessionId) {
+                    for (const [tabId, entry] of tabRegistry) {
+                      if (entry.sessionId === sessionId) tabRegistry.delete(tabId)
+                    }
                     await manager.disposeSession(sessionId)
                   }
                   sendOk(socket, message.id)
@@ -371,6 +552,7 @@ export async function runDaemon(): Promise<void> {
 
   const gracefulShutdown = (signal: string) => {
     logDebug(`daemon.${signal}`)
+    statusLoop.stop()
     manager.destroy()
     server.close()
     process.exit(0)

package/src/daemon/session-manager.ts

@@ -2,6 +2,7 @@ import { EventEmitter } from 'node:events'
 
 import type {
   ScrollIntent,
+  TabSession,
   TerminalModeState,
   TerminalSnapshot,
   WorkspaceSnapshotV1,
@@ -128,4 +129,12 @@ export class SessionManager extends EventEmitter<SessionManagerEvents> {
     }
     this.registries.clear()
   }
+
+  listSessionIds(): string[] {
+    return [...this.registries.keys()]
+  }
+
+  listTabs(sessionId: string): TabSession[] {
+    return this.registries.get(sessionId)?.listTabs() ?? []
+  }
 }

package/src/daemon/session-registry.ts

@@ -44,13 +44,13 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
       this.emit('render', tabId, viewport, terminalModes)
     })
     this.ptyManager.on('exit', (tabId, exitCode) => {
-      const tab = this.tabs.get(tabId)
-      if (!tab) {
+      if (!this.tabs.has(tabId)) {
         return
       }
-      tab.status = 'exited'
-      tab.exitCode = exitCode
-      tab.activity = undefined
+      this.tabs.delete(tabId)
+      if (this.activeTabId === tabId) {
+        this.activeTabId = this.listTabs()[0]?.id ?? null
+      }
       logDebug('daemon.registry.exit', { exitCode, tabId })
       this.emit('exit', tabId, exitCode)
     })