@brimveyn/aimux 1.6.1 → 1.7.0

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)
     })

package/src/git/diff-hash.ts

@@ -0,0 +1,10 @@
+// FNV-1a 32-bit hash. Fast, non-crypto, used to detect stale cached diff
+// artefacts (parsed file, syntax highlights) when the raw diff text changes.
+export function diffHash(input: string): string {
+  let h = 0x811c9dc5
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i)
+    h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0
+  }
+  return h.toString(16)
+}

package/src/index.tsx

@@ -12,6 +12,7 @@ import { runRestartDaemon } from './restart-daemon'
 import { runRestartTerminalManager } from './restart-terminal-manager'
 import { createSessionBackend } from './session-backend/bootstrap'
 import { runTerminalManager } from './terminal-manager/terminal-manager'
+import { BreakingUpdateScreen } from './ui/breaking-update-screen'
 import { runUpdate } from './update'
 
 const command = process.argv[2]
@@ -64,7 +65,14 @@ const renderer = await createCliRenderer({
   useMouse: true,
 })
 
-const backend = await createSessionBackend()
+const root = createRoot(renderer)
+
+const backend = await createSessionBackend({
+  onBreakingUpdateRequired: () =>
+    new Promise<void>((resolve) => {
+      root.render(<BreakingUpdateScreen onConfirm={resolve} />)
+    }),
+})
 logDebug('index.backendReady', { backend: backend.constructor.name, runtimeProfile })
 
 const resolvedConfig = await loadUserConfig()
@@ -73,4 +81,4 @@ logDebug('index.userConfigLoaded', {
   modeCount: resolvedConfig.keymaps.modes.size,
 })
 
-createRoot(renderer).render(<App backend={backend} resolvedConfig={resolvedConfig} />)
+root.render(<App backend={backend} resolvedConfig={resolvedConfig} />)

package/src/input/keymap/help-entries.ts

@@ -12,19 +12,19 @@ export const HELP_MODE_LABELS: { modeId: ModeId; label: string }[] = [
   { label: 'Terminal input', modeId: 'terminal-input' },
   { label: 'Git mode', modeId: 'git-mode' },
   { label: 'Git commit', modeId: 'modal.git-commit' },
-  { label: 'New tab', modeId: 'modal.new-tab' },
+  { label: 'New tab', modeId: 'modal.new-tab.command-edit' },
   { label: 'New tab — command', modeId: 'modal.new-tab.command-edit' },
-  { label: 'Session picker', modeId: 'modal.session-picker' },
+  { label: 'Session picker', modeId: 'modal.session-picker.filtering' },
   { label: 'Session picker — filter', modeId: 'modal.session-picker.filtering' },
   { label: 'Session name', modeId: 'modal.session-name' },
   { label: 'Create session', modeId: 'modal.create-session' },
   { label: 'Rename tab', modeId: 'modal.rename-tab' },
-  { label: 'Snippet picker', modeId: 'modal.snippet-picker' },
+  { label: 'Snippet picker', modeId: 'modal.snippet-picker.filtering' },
   { label: 'Snippet picker — filter', modeId: 'modal.snippet-picker.filtering' },
   { label: 'Snippet editor', modeId: 'modal.snippet-editor' },
-  { label: 'Theme picker', modeId: 'modal.theme-picker' },
+  { label: 'Theme picker', modeId: 'modal.theme-picker.filtering' },
   { label: 'Split picker', modeId: 'modal.split-picker' },
-  { label: 'Help', modeId: 'modal.help' },
+  { label: 'Help', modeId: 'modal.help.filtering' },
   { label: 'Help — filter', modeId: 'modal.help.filtering' },
   { label: 'Update available', modeId: 'modal.update-available' },
 ]

package/src/input/modes/bridge.ts

@@ -23,21 +23,15 @@ const COMMAND_EDIT_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
 }
 
 const MODAL_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
-  'help': 'modal.help',
-  'new-tab': 'modal.new-tab',
-  'session-picker': 'modal.session-picker',
-  'snippet-picker': 'modal.snippet-picker',
   'split-picker': 'modal.split-picker',
-  'theme-picker': 'modal.theme-picker',
   'update-available': 'modal.update-available',
 }
 
 export function deriveModeId(state: AppState): ModeId {
   // Help renders as an overlay on top of git/navigation without flipping
-  // focusMode, so it needs modal-first dispatch. Filter sub-mode is tracked
-  // by editBuffer presence, not focusMode.
+  // focusMode, so it needs modal-first dispatch. Always in filter mode.
   if (state.modal.type === 'help') {
-    return state.modal.editBuffer !== null ? 'modal.help.filtering' : 'modal.help'
+    return 'modal.help.filtering'
   }
 
   const directMode = DIRECT_FOCUS_MODE_IDS[state.focusMode]
@@ -46,6 +40,9 @@ export function deriveModeId(state: AppState): ModeId {
   }
 
   if (state.focusMode === 'command-edit') {
+    if (state.modal.type === 'new-tab' && state.modal.editingCommand !== null) {
+      return 'modal.new-tab.editing-command'
+    }
     const modalType = state.modal.type
     const commandEditMode = modalType ? COMMAND_EDIT_MODE_IDS[modalType] : undefined
     if (commandEditMode) {

package/src/input/modes/transitions.ts

@@ -2,35 +2,27 @@ import type { ModeId } from './types'
 
 const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
   'git-mode': ['navigation', 'modal.git-commit'],
-  'modal.create-session': ['navigation', 'modal.session-picker'],
+  'modal.create-session': ['navigation', 'modal.session-picker.filtering'],
   'modal.git-commit': ['git-mode'],
-  'modal.help': ['navigation', 'modal.help.filtering'],
-  'modal.help.filtering': ['modal.help'],
-  'modal.new-tab': ['navigation', 'modal.new-tab.command-edit'],
-  'modal.new-tab.command-edit': ['modal.new-tab'],
+  'modal.help.filtering': ['navigation'],
+  'modal.new-tab.command-edit': ['navigation', 'modal.new-tab.editing-command'],
+  'modal.new-tab.editing-command': ['navigation', 'modal.new-tab.command-edit'],
   'modal.rename-tab': ['navigation'],
-  'modal.session-name': ['modal.session-picker', 'navigation'],
-  'modal.session-picker': [
-    'navigation',
-    'modal.session-picker.filtering',
-    'modal.session-name',
-    'modal.create-session',
-  ],
-  'modal.session-picker.filtering': ['modal.session-picker'],
-  'modal.snippet-editor': ['navigation', 'modal.snippet-picker'],
-  'modal.snippet-picker': ['navigation', 'modal.snippet-picker.filtering', 'modal.snippet-editor'],
-  'modal.snippet-picker.filtering': ['modal.snippet-picker'],
+  'modal.session-name': ['modal.session-picker.filtering', 'navigation'],
+  'modal.session-picker.filtering': ['navigation', 'modal.session-name', 'modal.create-session'],
+  'modal.snippet-editor': ['navigation', 'modal.snippet-picker.filtering'],
+  'modal.snippet-picker.filtering': ['navigation', 'modal.snippet-editor'],
   'modal.split-picker': ['navigation', 'terminal-input'],
-  'modal.theme-picker': ['navigation', 'modal.theme-picker.filtering'],
-  'modal.theme-picker.filtering': ['modal.theme-picker'],
+  'modal.theme-picker.filtering': ['navigation'],
   'modal.update-available': ['navigation'],
   'navigation': [
     'terminal-input',
-    'modal.new-tab',
-    'modal.session-picker',
-    'modal.help',
-    'modal.snippet-picker',
-    'modal.theme-picker',
+    'modal.new-tab.command-edit',
+    'modal.new-tab.editing-command',
+    'modal.session-picker.filtering',
+    'modal.help.filtering',
+    'modal.snippet-picker.filtering',
+    'modal.theme-picker.filtering',
     'modal.rename-tab',
     'modal.update-available',
     'git-mode',

package/src/input/modes/types.ts

@@ -6,19 +6,15 @@ export type ModeId =
   | 'navigation'
   | 'terminal-input'
   | 'git-mode'
-  | 'modal.new-tab'
   | 'modal.new-tab.command-edit'
-  | 'modal.session-picker'
+  | 'modal.new-tab.editing-command'
   | 'modal.session-picker.filtering'
   | 'modal.session-name'
   | 'modal.create-session'
   | 'modal.rename-tab'
-  | 'modal.snippet-picker'
   | 'modal.snippet-picker.filtering'
   | 'modal.snippet-editor'
-  | 'modal.theme-picker'
   | 'modal.theme-picker.filtering'
-  | 'modal.help'
   | 'modal.help.filtering'
   | 'modal.split-picker'
   | 'modal.git-commit'
@@ -49,6 +45,7 @@ export type SideEffect =
   | { type: 'scroll-git-diff'; delta: number }
   | { type: 'persist-git-diff-mode-ratio'; ratio: number }
   | { type: 'persist-git-file-list-mode'; mode: GitFileListMode }
+  | { type: 'persist-git-tree-compaction'; enabled: boolean }
   | { type: 'git-stage'; path: string }
   | { type: 'git-unstage'; path: string }
   | { type: 'git-restore'; path: string }
@@ -57,6 +54,7 @@ export type SideEffect =
   | { type: 'git-push' }
   | { type: 'confirm-update-selection' }
   | { type: 'switch-session-by-index'; index: number }
+  | { type: 'toggle-transparent' }
 
 export interface KeyResult {
   actions: AppAction[]

package/src/ipc/protocol.ts

@@ -1,5 +1,7 @@
 import type {
   ScrollIntent,
+  SessionStatus,
+  TabActivity,
   TabSession,
   TerminalModeState,
   TerminalSnapshot,
@@ -8,8 +10,14 @@ import type {
 
 import { isWorkspaceSnapshotV1 } from '../state/validation'
 
-export const IPC_PROTOCOL_MIN_VERSION = 2
-export const IPC_PROTOCOL_VERSION = 2
+// v4 widens sessionStatus from a single status enum to independent
+// {working, waiting} flags so a chip can show both at once.
+// v5 folds initial tab activities and session statuses into attachResult so
+// the client applies them atomically with tab creation — previously they
+// arrived as separate events and could lose to the unknown-tab no-op in
+// the reducer.
+export const IPC_PROTOCOL_MIN_VERSION = 5
+export const IPC_PROTOCOL_VERSION = 5
 
 export interface ProtocolHelloRequest {
   minVersion: number
@@ -35,6 +43,13 @@ export interface AttachResult {
   protocolVersion: number
   tabs: TabSession[]
   activeTabId: string | null
+  /**
+   * Snapshot of every known session's status at attach time. Applied by
+   * the client atomically with `hydrate-workspace` so chips render the
+   * right state immediately, without the per-event race where a separate
+   * `sessionStatus` event could arrive before the session was in state.
+   */
+  initialSessionStatuses: Array<{ sessionId: string; status: SessionStatus }>
 }
 
 export type ClientRequest =
@@ -90,6 +105,8 @@ export type ServerEvent =
     }
   | { type: 'tabExit'; payload: { tabId: string; exitCode: number } }
   | { type: 'tabError'; payload: { tabId: string; message: string } }
+  | { type: 'tabStatus'; payload: { sessionId: string; tabId: string; status: TabActivity } }
+  | { type: 'sessionStatus'; payload: { sessionId: string; status: SessionStatus } }
 
 export type IpcMessage = ClientRequest | ServerResponse | ServerEvent
 
@@ -130,6 +147,18 @@ function isStringArray(value: unknown): value is string[] {
   return Array.isArray(value) && value.every(isString)
 }
 
+function isTabActivity(value: unknown): value is TabActivity {
+  return value === 'working' || value === 'waiting-input' || value === 'idle'
+}
+
+function isSessionStatus(value: unknown): value is SessionStatus {
+  return (
+    isObjectRecord(value) &&
+    typeof value.working === 'boolean' &&
+    typeof value.waiting === 'boolean'
+  )
+}
+
 function isTerminalSpan(value: unknown): boolean {
   return (
     isObjectRecord(value) &&
@@ -209,9 +238,11 @@ function isAttachResult(value: unknown): value is AttachResult {
         (tab.status === 'starting' ||
           tab.status === 'running' ||
           tab.status === 'disconnected' ||
-          tab.status === 'exited' ||
           tab.status === 'error') &&
-        (tab.activity === undefined || tab.activity === 'busy' || tab.activity === 'idle') &&
+        (tab.activity === undefined ||
+          tab.activity === 'working' ||
+          tab.activity === 'waiting-input' ||
+          tab.activity === 'idle') &&
         isString(tab.buffer) &&
         isTerminalModeState(tab.terminalModes) &&
         isString(tab.command) &&
@@ -219,7 +250,11 @@ function isAttachResult(value: unknown): value is AttachResult {
         (tab.errorMessage === undefined || isString(tab.errorMessage)) &&
         (tab.exitCode === undefined || isFiniteNumber(tab.exitCode))
     ) &&
-    isNullableString(value.activeTabId)
+    isNullableString(value.activeTabId) &&
+    Array.isArray(value.initialSessionStatuses) &&
+    value.initialSessionStatuses.every(
+      (entry) => isObjectRecord(entry) && isString(entry.sessionId) && isSessionStatus(entry.status)
+    )
   )
 }
 
@@ -375,6 +410,15 @@ export function parseServerMessage(value: unknown): ServerResponse | ServerEvent
       assert(isString(value.payload.tabId), 'tabError.tabId must be a string')
       assert(isString(value.payload.message), 'tabError.message must be a string')
       return value as ServerEvent
+    case 'tabStatus':
+      assert(isString(value.payload.sessionId), 'tabStatus.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'tabStatus.tabId must be a string')
+      assert(isTabActivity(value.payload.status), 'tabStatus.status is invalid')
+      return value as ServerEvent
+    case 'sessionStatus':
+      assert(isString(value.payload.sessionId), 'sessionStatus.sessionId must be a string')
+      assert(isSessionStatus(value.payload.status), 'sessionStatus.status is invalid')
+      return value as ServerEvent
     default:
       throw new IpcProtocolError(`Unknown IPC response type: ${String(value.type)}`)
   }