@brimveyn/aimux 1.6.1 → 1.7.0

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

@@ -5,6 +5,7 @@ import type { SessionBackend, SessionBackendEvents } from './types'
 
 import { SessionManager } from '../daemon/session-manager'
 import { logDebug } from '../debug/input-log'
+import { runStatusDetectionLoop } from '../pty/assistant-status-detection-loop'
 import {
   createTerminalBounds,
   forEachSplitPaneRect,
@@ -12,16 +13,13 @@ import {
   toTerminalContentSize,
 } from '../state/layout-resize'
 
-const SESSION_IDLE_TIMEOUT_MS = 2_000
-
 export class LocalSessionBackend
   extends EventEmitter<SessionBackendEvents>
   implements SessionBackend
 {
   private readonly sessionManager = new SessionManager()
   private currentSessionId: string | null = null
-  private readonly sessionIdleTimers = new Map<string, ReturnType<typeof setTimeout>>()
-  private readonly sessionBusy = new Map<string, boolean>()
+  private readonly statusLoop: ReturnType<typeof runStatusDetectionLoop>
 
   constructor() {
     super()
@@ -29,7 +27,6 @@ export class LocalSessionBackend
       if (sessionId === this.currentSessionId) {
         this.emit('render', tabId, viewport, terminalModes)
       }
-      this.markSessionBusy(sessionId)
     })
     this.sessionManager.on('exit', (sessionId, tabId, exitCode) => {
       if (sessionId === this.currentSessionId) {
@@ -41,23 +38,18 @@ export class LocalSessionBackend
         this.emit('error', tabId, message)
       }
     })
-  }
-
-  private markSessionBusy(sessionId: string): void {
-    if (this.sessionBusy.get(sessionId) !== true) {
-      this.sessionBusy.set(sessionId, true)
-      this.emit('sessionActivity', sessionId, true)
-    }
-    const existing = this.sessionIdleTimers.get(sessionId)
-    if (existing) clearTimeout(existing)
-    const timer = setTimeout(() => {
-      this.sessionIdleTimers.delete(sessionId)
-      if (this.sessionBusy.get(sessionId) === true) {
-        this.sessionBusy.set(sessionId, false)
-        this.emit('sessionActivity', sessionId, false)
-      }
-    }, SESSION_IDLE_TIMEOUT_MS)
-    this.sessionIdleTimers.set(sessionId, timer)
+    this.statusLoop = runStatusDetectionLoop({
+      listSessions: () => this.sessionManager.listSessionIds(),
+      listTabs: (sessionId) => this.sessionManager.listTabs(sessionId),
+      onSessionStatus: (sessionId, status) => {
+        this.emit('sessionActivity', sessionId, status)
+      },
+      onTabStatus: (tabId, status, sessionId) => {
+        if (sessionId === this.currentSessionId) {
+          this.emit('tabActivity', tabId, status)
+        }
+      },
+    })
   }
 
   async attach(options: {
@@ -84,7 +76,24 @@ export class LocalSessionBackend
     } else {
       this.sessionManager.resize(options.sessionId, options.cols, options.rows)
     }
-    return this.sessionManager.attachSession(options.sessionId, options.workspaceSnapshot)
+    const attachResult = this.sessionManager.attachSession(
+      options.sessionId,
+      options.workspaceSnapshot
+    )
+    // Run a synchronous classification pass so every tab's activity and the
+    // session-status snapshot are available to embed in the reply — mirrors
+    // the remote backend's behavior and keeps hydrate dispatches atomic on
+    // the client side.
+    this.statusLoop.classifyNow(options.sessionId, this.sessionManager.listTabs(options.sessionId))
+    const tabsWithActivity = attachResult.tabs.map((tab) => ({
+      ...tab,
+      activity: this.statusLoop.getTabStatus(tab.id) ?? tab.activity,
+    }))
+    return {
+      activeTabId: attachResult.activeTabId,
+      initialSessionStatuses: this.statusLoop.snapshotSessions(),
+      tabs: tabsWithActivity,
+    }
   }
 
   createSession(options: {
@@ -123,30 +132,22 @@ export class LocalSessionBackend
   }
 
   scrollViewport(tabId: string, deltaLines: number): void {
-    if (!this.currentSessionId) {
-      return
-    }
+    if (!this.currentSessionId) return
     this.sessionManager.scroll(this.currentSessionId, tabId, deltaLines)
   }
 
   scrollViewportToBottom(tabId: string): void {
-    if (!this.currentSessionId) {
-      return
-    }
+    if (!this.currentSessionId) return
     this.sessionManager.scrollToBottom(this.currentSessionId, tabId)
   }
 
   reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
-    if (!this.currentSessionId) {
-      return
-    }
+    if (!this.currentSessionId) return
     this.sessionManager.reapplyScrollIntent(this.currentSessionId, tabId, intent)
   }
 
   setActiveTab(tabId: string | null): void {
-    if (!this.currentSessionId) {
-      return
-    }
+    if (!this.currentSessionId) return
     logDebug('backend.local.setActiveTab', { sessionId: this.currentSessionId, tabId })
     this.sessionManager.setActiveTab(this.currentSessionId, tabId)
   }
@@ -157,9 +158,7 @@ export class LocalSessionBackend
     intents?: Map<string, ScrollIntent>,
     options?: { sync?: boolean }
   ): void {
-    if (!this.currentSessionId) {
-      return
-    }
+    if (!this.currentSessionId) return
     this.sessionManager.resize(this.currentSessionId, cols, rows, intents, options)
   }
 
@@ -170,40 +169,28 @@ export class LocalSessionBackend
     intent?: ScrollIntent,
     options?: { sync?: boolean }
   ): void {
-    if (!this.currentSessionId) {
-      return
-    }
+    if (!this.currentSessionId) return
     this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, intent, options)
   }
 
   disposeSession(tabId: string): void {
-    if (!this.currentSessionId) {
-      return
-    }
+    if (!this.currentSessionId) return
     logDebug('backend.local.disposeSession', { sessionId: this.currentSessionId, tabId })
     this.sessionManager.closeTab(this.currentSessionId, tabId)
   }
 
   disposeAll(): void {
-    if (!this.currentSessionId) {
-      return
-    }
+    if (!this.currentSessionId) return
     logDebug('backend.local.disposeAll', { sessionId: this.currentSessionId })
     this.sessionManager.disposeSession(this.currentSessionId)
   }
 
   destroy(keepSessions = true): void {
     logDebug('backend.local.destroy', { keepSessions, sessionId: this.currentSessionId })
-    if (!keepSessions) {
-      if (this.currentSessionId) {
-        this.sessionManager.disposeSession(this.currentSessionId)
-      }
-    }
-    for (const timer of this.sessionIdleTimers.values()) {
-      clearTimeout(timer)
+    if (!keepSessions && this.currentSessionId) {
+      this.sessionManager.disposeSession(this.currentSessionId)
     }
-    this.sessionIdleTimers.clear()
-    this.sessionBusy.clear()
+    this.statusLoop.stop()
     this.currentSessionId = null
   }
 }

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

@@ -161,6 +161,21 @@ export class RemoteSessionBackend
       case 'tabError':
         this.emit('error', message.payload.tabId, message.payload.message)
         break
+      case 'tabStatus':
+        logDebug('backend.remote.tabStatus', {
+          sessionId: message.payload.sessionId,
+          status: message.payload.status,
+          tabId: message.payload.tabId,
+        })
+        this.emit('tabActivity', message.payload.tabId, message.payload.status)
+        break
+      case 'sessionStatus':
+        logDebug('backend.remote.sessionStatus', {
+          sessionId: message.payload.sessionId,
+          status: message.payload.status,
+        })
+        this.emit('sessionActivity', message.payload.sessionId, message.payload.status)
+        break
     }
   }
 

package/src/session-backend/types.ts

@@ -2,6 +2,8 @@ import type { EventEmitter } from 'node:events'
 
 import type {
   ScrollIntent,
+  SessionStatus,
+  TabActivity,
   TabSession,
   TerminalModeState,
   TerminalSnapshot,
@@ -12,12 +14,19 @@ export type SessionBackendEvents = {
   render: [tabId: string, viewport: TerminalSnapshot, terminalModes: TerminalModeState]
   exit: [tabId: string, exitCode: number]
   error: [tabId: string, message: string]
-  sessionActivity: [sessionId: string, busy: boolean]
+  sessionActivity: [sessionId: string, status: SessionStatus]
+  tabActivity: [tabId: string, activity: TabActivity]
 }
 
 export interface BackendAttachResult {
   tabs: TabSession[]
   activeTabId: string | null
+  /**
+   * Per-session status snapshot taken at attach time and applied
+   * atomically with tab hydration to prevent an unknown-tab race on
+   * separate `sessionActivity` events.
+   */
+  initialSessionStatuses: Array<{ sessionId: string; status: SessionStatus }>
 }
 
 export interface SessionBackend extends EventEmitter<SessionBackendEvents> {

package/src/state/git-tree.ts

@@ -53,7 +53,8 @@ export function gitFolderKey(section: GitFileSection, folderPath: string): strin
 export function buildGitTreeRows(
   files: GitFileEntry[],
   collapsedFolders: Record<string, true>,
-  fileListMode: GitFileListMode = 'tree'
+  fileListMode: GitFileListMode = 'tree',
+  compact: boolean = false
 ): GitTreeRows {
   const sections = SECTION_ORDER.map((section) => {
     const sectionFiles = files.filter((file) => file.section === section)
@@ -68,7 +69,7 @@ export function buildGitTreeRows(
               kind: 'file' as const,
               section,
             }))
-          : flattenSectionRows(sectionFiles, collapsedFolders),
+          : flattenSectionRows(sectionFiles, collapsedFolders, compact),
       section,
     }
   })
@@ -81,10 +82,16 @@ export function getSelectedGitRow(
     collapsedFolders: Record<string, true>
     fileListMode: GitFileListMode
     selectedEntryKey: string | null
+    compact?: boolean
   }
 ): GitTreeRow | null {
   if (!options.selectedEntryKey) return null
-  const { visibleRows } = buildGitTreeRows(files, options.collapsedFolders, options.fileListMode)
+  const { visibleRows } = buildGitTreeRows(
+    files,
+    options.collapsedFolders,
+    options.fileListMode,
+    options.compact ?? false
+  )
   return visibleRows.find((row) => row.key === options.selectedEntryKey) ?? null
 }
 
@@ -94,6 +101,7 @@ export function getSelectedGitFile(
     collapsedFolders: Record<string, true>
     fileListMode: GitFileListMode
     selectedEntryKey: string | null
+    compact?: boolean
   }
 ): GitFileEntry | null {
   const row = getSelectedGitRow(files, options)
@@ -105,9 +113,10 @@ export function reconcileSelectedGitEntryKey(
   collapsedFolders: Record<string, true>,
   fileListMode: GitFileListMode,
   selectedEntryKey: string | null | undefined,
-  preferredKeys: string[] = []
+  preferredKeys: string[] = [],
+  compact: boolean = false
 ): string | null {
-  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode)
+  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode, compact)
   if (visibleRows.length === 0) return null
   const candidates = [...preferredKeys, selectedEntryKey ?? '']
   for (const key of candidates) {
@@ -122,9 +131,10 @@ export function moveGitSelection(
   collapsedFolders: Record<string, true>,
   fileListMode: GitFileListMode,
   selectedEntryKey: string | null,
-  delta: -1 | 1
+  delta: -1 | 1,
+  compact: boolean = false
 ): string | null {
-  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode)
+  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode, compact)
   const total = visibleRows.length
   if (total === 0) return null
   const current = visibleRows.findIndex((row) => row.key === selectedEntryKey)
@@ -137,9 +147,10 @@ export function moveGitFileSelection(
   collapsedFolders: Record<string, true>,
   fileListMode: GitFileListMode,
   selectedEntryKey: string | null,
-  delta: -1 | 1
+  delta: -1 | 1,
+  compact: boolean = false
 ): string | null {
-  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode)
+  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode, compact)
   const fileRows = visibleRows.filter((row) => row.kind === 'file')
   const total = fileRows.length
   if (total === 0) return null
@@ -153,13 +164,14 @@ export function moveGitFileSelection(
 
 function flattenSectionRows(
   files: GitFileEntry[],
-  collapsedFolders: Record<string, true>
+  collapsedFolders: Record<string, true>,
+  compact: boolean
 ): GitTreeRow[] {
   if (files.length === 0) return []
   const section = files[0]?.section
   if (!section) return []
   const root = buildSectionTree(files, section)
-  return flattenTreeNode(root, collapsedFolders, 0)
+  return flattenTreeNode(root, collapsedFolders, 0, undefined, compact)
 }
 
 function buildSectionTree(files: GitFileEntry[], section: GitFileSection): GitTreeNode {
@@ -187,16 +199,28 @@ function flattenTreeNode(
   node: GitTreeNode,
   collapsedFolders: Record<string, true>,
   depth: number,
-  parentKey?: string
+  parentKey: string | undefined,
+  compact: boolean
 ): GitTreeRow[] {
   const rows: GitTreeRow[] = []
   for (const child of node.folders.values()) {
-    const name = child.path.split('/').pop() ?? child.path
-    const key = gitFolderKey(node.section, child.path)
+    // Compaction: while a folder has exactly one child folder and no direct
+    // files, fold the chain into a single row ("src/keymap/keymap.ts" instead
+    // of three nested rows).
+    let current = child
+    const segments: string[] = [current.path.split('/').pop() ?? current.path]
+    while (compact && current.files.length === 0 && current.folders.size === 1) {
+      const next = current.folders.values().next().value
+      if (!next) break
+      segments.push(next.path.split('/').pop() ?? next.path)
+      current = next
+    }
+    const name = segments.join('/')
+    const key = gitFolderKey(node.section, current.path)
     const isCollapsed = key in collapsedFolders
     rows.push({
       depth,
-      folderPath: child.path,
+      folderPath: current.path,
       isCollapsed,
       key,
       kind: 'folder',
@@ -204,7 +228,9 @@ function flattenTreeNode(
       parentKey,
       section: node.section,
     })
-    if (!isCollapsed) rows.push(...flattenTreeNode(child, collapsedFolders, depth + 1, key))
+    if (!isCollapsed) {
+      rows.push(...flattenTreeNode(current, collapsedFolders, depth + 1, key, compact))
+    }
   }
   for (const file of node.files) {
     rows.push({

package/src/state/reducers/diff-cache.ts

@@ -0,0 +1,64 @@
+import type { AppState } from '../types'
+
+export function clearDiffCacheForPath(state: AppState, path: string): AppState {
+  return clearDiffCacheForPaths(state, new Set([path]))
+}
+
+// Drops every cache slice derived from the given file paths: diffs, folds,
+// loading flags, parsed patches, and per-theme highlight tokens. Called when
+// a file's on-disk content shifts or a file disappears from git status.
+export function clearDiffCacheForPaths(state: AppState, paths: Set<string>): AppState {
+  if (paths.size === 0) return state
+  const nextDiffs = { ...state.gitMode.diffs }
+  const nextFolds = { ...state.gitMode.folds }
+  const nextLoading = { ...state.gitMode.loading }
+  const nextParsed = { ...state.gitMode.parsedFiles }
+  const nextHighlights = { ...state.gitMode.highlights }
+  let changed = false
+  const keyMatches = (key: string): boolean => {
+    for (const path of paths) {
+      if (key.endsWith(`:${path}`) || key.startsWith(`${path}|`) || key.includes(`:${path}|`)) {
+        return true
+      }
+    }
+    return false
+  }
+  for (const key of Object.keys(nextDiffs)) {
+    const entry = nextDiffs[key]
+    if (!entry || !paths.has(entry.path)) continue
+    delete nextDiffs[key]
+    changed = true
+  }
+  for (const key of Object.keys(nextFolds)) {
+    if (!keyMatches(key)) continue
+    delete nextFolds[key]
+    changed = true
+  }
+  for (const key of Object.keys(nextLoading)) {
+    if (!keyMatches(key)) continue
+    delete nextLoading[key]
+    changed = true
+  }
+  for (const key of Object.keys(nextParsed)) {
+    if (!keyMatches(key)) continue
+    delete nextParsed[key]
+    changed = true
+  }
+  for (const key of Object.keys(nextHighlights)) {
+    if (!keyMatches(key)) continue
+    delete nextHighlights[key]
+    changed = true
+  }
+  if (!changed) return state
+  return {
+    ...state,
+    gitMode: {
+      ...state.gitMode,
+      diffs: nextDiffs,
+      folds: nextFolds,
+      highlights: nextHighlights,
+      loading: nextLoading,
+      parsedFiles: nextParsed,
+    },
+  }
+}