@brimveyn/aimux 1.6.2 → 1.7.1

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'
@@ -58,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/manager-protocol.ts

@@ -14,8 +14,8 @@ import {
   negotiateProtocolVersion,
 } from './protocol'
 
-export const MANAGER_PROTOCOL_MIN_VERSION = 1
-export const MANAGER_PROTOCOL_VERSION = 1
+export const MANAGER_PROTOCOL_MIN_VERSION = 2
+export const MANAGER_PROTOCOL_VERSION = 2
 
 export interface ManagerHelloRequest {
   minVersion: number

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 = 6
+export const IPC_PROTOCOL_VERSION = 6
 
 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)}`)
   }

package/src/platform/project-search.ts

@@ -7,15 +7,18 @@ import type { DirectoryResult } from '../state/types'
 
 import { logDebug } from '../debug/input-log'
 
-export async function searchProjectDirectories(query: string): Promise<DirectoryResult[]> {
-  if (!query.trim()) {
-    return []
-  }
+interface DirectoryCache {
+  repoPaths: string[]
+  workspaceSet: Set<string>
+  cachedAt: number
+}
 
-  const home = homedir()
+const CACHE_TTL_MS = 60_000
+let directoryCache: DirectoryCache | null = null
 
+async function buildCache(): Promise<DirectoryCache> {
+  const home = homedir()
   try {
-    // Step 1: Find all git repos (nothrow: find exits 1 on macOS permission errors)
     const gitResult =
       await $`find ${home} -maxdepth 4 -name .git -not -path '*/node_modules/*' -not -path '*/target/*' -not -path '*/dist/*' 2>/dev/null`
         .quiet()
@@ -27,7 +30,6 @@ export async function searchProjectDirectories(query: string): Promise<Directory
       .filter((line) => line.length > 0)
       .map((p) => p.replace(/\/\.git$/, ''))
 
-    // Step 2: Find workspace parents (dirs with 2+ child repos that aren't repos themselves)
     const repoSet = new Set(repoPaths)
     const parentCount = new Map<string, number>()
     for (const repo of repoPaths) {
@@ -39,10 +41,37 @@ export async function searchProjectDirectories(query: string): Promise<Directory
     const workspacePaths = [...parentCount.entries()]
       .filter(([, count]) => count >= 2)
       .map(([p]) => p)
-    const workspaceSet = new Set(workspacePaths)
 
-    // Step 3: Combine and fuzzy filter
-    const allPaths = [...repoPaths, ...workspacePaths].join('\n')
+    return { cachedAt: Date.now(), repoPaths, workspaceSet: new Set(workspacePaths) }
+  } catch (error) {
+    logDebug('platform.projectSearch.buildCache.error', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return { cachedAt: Date.now(), repoPaths: [], workspaceSet: new Set() }
+  }
+}
+
+async function getOrBuildCache(): Promise<DirectoryCache> {
+  if (directoryCache && Date.now() - directoryCache.cachedAt < CACHE_TTL_MS) {
+    return directoryCache
+  }
+  directoryCache = await buildCache()
+  return directoryCache
+}
+
+export async function warmDirectoryCache(): Promise<void> {
+  await getOrBuildCache()
+}
+
+export async function searchProjectDirectories(query: string): Promise<DirectoryResult[]> {
+  if (!query.trim()) {
+    return []
+  }
+
+  try {
+    const cache = await getOrBuildCache()
+    const allPaths = [...cache.repoPaths, ...cache.workspaceSet].join('\n')
+
     const filtered =
       await $`printf '%s' ${allPaths} | fzf --filter=${query} --no-sort | head -50`.quiet()
     const resultPaths = filtered
@@ -51,12 +80,16 @@ export async function searchProjectDirectories(query: string): Promise<Directory
       .split('\n')
       .filter((line) => line.length > 0)
 
-    // Step 4: Classify each result (shortest paths first, limit to 10)
     resultPaths.sort((a, b) => a.length - b.length)
     resultPaths.splice(10)
+
+    if (resultPaths.length === 0 && query.trim().startsWith('/')) {
+      return [{ path: query.trim(), type: 'git-repo' }]
+    }
+
     return Promise.all(
       resultPaths.map(async (path) => {
-        if (workspaceSet.has(path)) {
+        if (cache.workspaceSet.has(path)) {
           return { path, type: 'workspace' as const }
         }
         const gitPath = join(path, '.git')

package/src/pty/assistant-status-detection-loop.ts

@@ -0,0 +1,192 @@
+/**
+ * Continuous status detection loop.
+ *
+ * Backends drive this loop to monitor every known terminal at a fixed cadence:
+ * every tick we pull each tab's current viewport, run the detector on the last
+ * ~10 non-blank lines, and report per-tab + per-session statuses to the
+ * backend's transport. The loop is the single source of truth so that idle
+ * tabs can't erase a sibling's waiting-input, and so that clients receive
+ * status for every session the backend owns, not just the attached one.
+ *
+ * Per-session status is a pair of independent booleans:
+ *   - `working`: at least one tab is working.
+ *   - `waiting`: at least one tab is waiting for user input.
+ * Both can be true at the same time — the chip renders one glyph per flag.
+ */
+import type { AssistantId, SessionStatus, TabActivity, TerminalSnapshot } from '../state/types'
+
+import { logDebug } from '../debug/input-log'
+import { getLineText } from '../input/terminal-text-extraction'
+import { AssistantStatusDetector } from './assistant-status-detector'
+
+function tailPreview(viewport: TerminalSnapshot | undefined): string {
+  if (!viewport) return '<no-viewport>'
+  const lines = viewport.lines
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]
+    if (!line) continue
+    const text = getLineText(line).trim()
+    if (text.length > 0) return text.slice(0, 80)
+  }
+  return '<blank>'
+}
+
+/** Default polling interval. Cheap — detector is a handful of substring checks. */
+const DEFAULT_TICK_MS = 500
+
+export interface LoopTabView {
+  id: string
+  assistant: AssistantId
+  command: string
+  viewport?: TerminalSnapshot
+}
+
+export interface StatusDetectionLoopOptions {
+  listSessions: () => string[]
+  listTabs: (sessionId: string) => LoopTabView[]
+  /** Emitted when a tab's status changes. */
+  onTabStatus: (tabId: string, status: TabActivity, sessionId: string) => void
+  /** Emitted when either flag on a session changes. */
+  onSessionStatus: (sessionId: string, status: SessionStatus) => void
+  tickMs?: number
+}
+
+export interface StatusDetectionLoopHandle {
+  stop: () => void
+  /** Last classified status for a tab, for on-attach replay. */
+  getTabStatus: (tabId: string) => TabActivity | undefined
+  /** Last session flags, for on-attach replay. */
+  getSessionStatus: (sessionId: string) => SessionStatus | undefined
+  /** Snapshot of every known session's flags. */
+  snapshotSessions: () => Array<{ sessionId: string; status: SessionStatus }>
+  /** Snapshot of every known tab's status plus its session. */
+  snapshotTabs: () => Array<{ tabId: string; sessionId: string; status: TabActivity }>
+  /**
+   * Synchronously run classification for a single session. Used on client
+   * attach so the replay snapshot is populated *before* the client reads it,
+   * rather than relying on the next scheduled tick.
+   */
+  classifyNow: (sessionId: string, tabs: LoopTabView[]) => void
+}
+
+export function runStatusDetectionLoop(
+  options: StatusDetectionLoopOptions
+): StatusDetectionLoopHandle {
+  const tickMs = options.tickMs ?? DEFAULT_TICK_MS
+  const detector = new AssistantStatusDetector()
+  const lastTabStatus = new Map<string, { status: TabActivity; sessionId: string }>()
+  const lastSessionStatus = new Map<string, SessionStatus>()
+
+  const timer = setInterval(() => {
+    try {
+      tick()
+    } catch (error) {
+      logDebug('statusLoop.tickError', {
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }, tickMs)
+  timer.unref?.()
+
+  function classifySession(
+    sessionId: string,
+    tabs: LoopTabView[],
+    now: number,
+    source: 'tick' | 'classifyNow',
+    seenTabs?: Set<string>
+  ): void {
+    let working = false
+    let waiting = false
+    for (const tab of tabs) {
+      seenTabs?.add(tab.id)
+      const status = detector.classify({
+        assistant: tab.assistant,
+        command: tab.command,
+        now,
+        tabId: tab.id,
+        viewport: tab.viewport,
+      })
+      if (status === 'working') working = true
+      if (status === 'waiting-input') waiting = true
+      const prev = lastTabStatus.get(tab.id)
+      const changed = !prev || prev.status !== status || prev.sessionId !== sessionId
+      logDebug('statusLoop.classify', {
+        assistant: tab.assistant,
+        changed,
+        prevSessionId: prev?.sessionId,
+        prevStatus: prev?.status,
+        sessionId,
+        source,
+        status,
+        tabId: tab.id,
+        tailPreview: tailPreview(tab.viewport),
+      })
+      if (changed) {
+        lastTabStatus.set(tab.id, { sessionId, status })
+        options.onTabStatus(tab.id, status, sessionId)
+      }
+    }
+    const next: SessionStatus = { waiting, working }
+    const prevSession = lastSessionStatus.get(sessionId)
+    const sessionChanged =
+      !prevSession || prevSession.working !== working || prevSession.waiting !== waiting
+    logDebug('statusLoop.classifySession', {
+      prev: prevSession,
+      sessionChanged,
+      sessionId,
+      source,
+      status: next,
+      tabCount: tabs.length,
+    })
+    if (sessionChanged) {
+      lastSessionStatus.set(sessionId, next)
+      options.onSessionStatus(sessionId, next)
+    }
+  }
+
+  function tick(): void {
+    const now = Date.now()
+    const sessionIds = options.listSessions()
+    const seenSessions = new Set<string>()
+    const seenTabs = new Set<string>()
+
+    for (const sessionId of sessionIds) {
+      seenSessions.add(sessionId)
+      classifySession(sessionId, options.listTabs(sessionId), now, 'tick', seenTabs)
+    }
+
+    for (const tabId of lastTabStatus.keys()) {
+      if (!seenTabs.has(tabId)) {
+        detector.forget(tabId)
+        lastTabStatus.delete(tabId)
+      }
+    }
+    for (const sessionId of lastSessionStatus.keys()) {
+      if (!seenSessions.has(sessionId)) {
+        lastSessionStatus.delete(sessionId)
+      }
+    }
+  }
+
+  return {
+    classifyNow: (sessionId, tabs) => {
+      classifySession(sessionId, tabs, Date.now(), 'classifyNow')
+    },
+    getSessionStatus: (sessionId) => lastSessionStatus.get(sessionId),
+    getTabStatus: (tabId) => lastTabStatus.get(tabId)?.status,
+    snapshotSessions: () =>
+      [...lastSessionStatus.entries()].map(([sessionId, status]) => ({ sessionId, status })),
+    snapshotTabs: () =>
+      [...lastTabStatus.entries()].map(([tabId, entry]) => ({
+        sessionId: entry.sessionId,
+        status: entry.status,
+        tabId,
+      })),
+    stop: () => {
+      clearInterval(timer)
+      detector.clear()
+      lastTabStatus.clear()
+      lastSessionStatus.clear()
+    },
+  }
+}