@brimveyn/aimux 1.6.1 → 1.7.0

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()
+    },
+  }
+}

package/src/pty/assistant-status-detector.ts

@@ -0,0 +1,226 @@
+/**
+ * Assistant status detection.
+ *
+ * Per-CLI content heuristics are adapted from herdr by @ogulcancelik
+ * (https://github.com/ogulcancelik/herdr, MIT). Rule tables trace back to
+ * `src/detect.rs` in that repo.
+ *
+ * The detector classifies a terminal session as `working`, `waiting-input`,
+ * or `idle`. Built-in CLIs (claude, codex, opencode) use per-CLI substring
+ * tables. Custom CLIs fall back to a generic heuristic that (a) recognises
+ * common shells as always-idle and (b) uses pane-tail change velocity plus
+ * generic y/n / confirm prompt patterns.
+ */
+import type { AssistantId, TabActivity, TerminalSnapshot } from '../state/types'
+
+import { getLineText } from '../input/terminal-text-extraction'
+
+const TAIL_LINE_COUNT = 10
+const ACTIVE_CHANGE_WINDOW_MS = 600
+
+/** Spinner glyphs used by claude code's status lines. */
+const CLAUDE_SPINNER_GLYPHS = '·✱✲✳✴✵✶✷✸✹✺✻✼✽✾✿❀❁❂❃❇❈❉❊❋✢✣✤✥✦✧✨⊛⊕⊙◉◎◍⁂⁕※⍟☼★☆'
+
+const SHELL_COMMAND_PATTERN =
+  /(^|\/)(bash|zsh|fish|sh|dash|ash|ksh|tcsh|csh|nu|pwsh|powershell|elvish|xonsh)(\.exe)?$/i
+
+interface DetectorEntry {
+  tail: string
+  changedAt: number
+  status: TabActivity
+}
+
+export interface DetectStatusInput {
+  tabId: string
+  assistant: AssistantId
+  /** The raw command string (first token matters for shell detection). */
+  command?: string
+  viewport: TerminalSnapshot | undefined
+  /** Override the clock for tests. Defaults to Date.now. */
+  now?: number
+}
+
+export class AssistantStatusDetector {
+  private readonly entries = new Map<string, DetectorEntry>()
+
+  classify(input: DetectStatusInput): TabActivity {
+    const { assistant, command, tabId, viewport } = input
+    const now = input.now ?? Date.now()
+
+    if (!viewport) return this.remember(tabId, '', now, 'idle')
+
+    const tail = extractTailText(viewport, TAIL_LINE_COUNT)
+    const prev = this.entries.get(tabId)
+    const changedAt = prev && prev.tail === tail ? prev.changedAt : now
+    const haystack = tail.toLowerCase()
+
+    if (assistant === 'terminal' || isShellCommand(command)) {
+      return this.remember(tabId, tail, changedAt, 'idle')
+    }
+
+    const perCli = classifyBuiltin(assistant, haystack, tail)
+    if (perCli) return this.remember(tabId, tail, changedAt, perCli)
+
+    const generic = classifyGeneric(haystack, changedAt, now)
+    return this.remember(tabId, tail, changedAt, generic)
+  }
+
+  forget(tabId: string): void {
+    this.entries.delete(tabId)
+  }
+
+  clear(): void {
+    this.entries.clear()
+  }
+
+  private remember(
+    tabId: string,
+    tail: string,
+    changedAt: number,
+    status: TabActivity
+  ): TabActivity {
+    this.entries.set(tabId, { changedAt, status, tail })
+    return status
+  }
+}
+
+function extractTailText(viewport: TerminalSnapshot, lineCount: number): string {
+  // Full-screen TUIs (claude, opencode) paint in the alternate buffer and
+  // often leave the last rows blank, putting their status bar higher up.
+  // Skip trailing blank rows before taking the last `lineCount`.
+  const lines = viewport.lines
+  let end = lines.length
+  while (end > 0) {
+    const line = lines[end - 1]
+    if (!line) {
+      end--
+      continue
+    }
+    const text = getLineText(line).trim()
+    if (text.length === 0) {
+      end--
+      continue
+    }
+    break
+  }
+  const start = Math.max(0, end - lineCount)
+  const parts: string[] = []
+  for (let i = start; i < end; i++) {
+    const line = lines[i]
+    if (!line) continue
+    parts.push(getLineText(line).replace(/\s+$/u, ''))
+  }
+  return parts.join('\n')
+}
+
+function classifyBuiltin(
+  assistant: AssistantId,
+  haystack: string,
+  rawTail: string
+): TabActivity | null {
+  switch (assistant) {
+    case 'claude':
+      return classifyClaude(haystack, rawTail)
+    case 'codex':
+      return classifyCodex(haystack)
+    case 'opencode':
+      return classifyOpencode(haystack)
+    default:
+      return null
+  }
+}
+
+function classifyClaude(haystack: string, rawTail: string): TabActivity {
+  if (
+    haystack.includes('do you want') ||
+    haystack.includes('would you like') ||
+    haystack.includes('tab to amend') ||
+    haystack.includes('enter to select') ||
+    (haystack.includes('esc to cancel') && haystack.includes('to navigate'))
+  ) {
+    return 'waiting-input'
+  }
+  if (
+    haystack.includes('esc/ctrl+c to interrupt') ||
+    haystack.includes('esc to interrupt') ||
+    haystack.includes('ctrl+c to interrupt') ||
+    haystack.includes('esc interrupt')
+  ) {
+    return 'working'
+  }
+  if (hasClaudeSpinner(rawTail)) return 'working'
+  return 'idle'
+}
+
+function hasClaudeSpinner(rawTail: string): boolean {
+  if (!rawTail.includes('…') && !rawTail.includes('...')) return false
+  for (const ch of CLAUDE_SPINNER_GLYPHS) {
+    if (rawTail.includes(ch)) return true
+  }
+  return false
+}
+
+function classifyCodex(haystack: string): TabActivity {
+  if (
+    haystack.includes('press enter to confirm') ||
+    haystack.includes('[y/n]') ||
+    haystack.includes('enter to submit answer')
+  ) {
+    return 'waiting-input'
+  }
+  if (haystack.includes('esc to interrupt') || haystack.includes('• working (')) {
+    return 'working'
+  }
+  return 'idle'
+}
+
+function classifyOpencode(haystack: string): TabActivity {
+  if (
+    haystack.includes('permission required') ||
+    haystack.includes('△ permission') ||
+    (haystack.includes('enter submit') && haystack.includes('esc dismiss'))
+  ) {
+    return 'waiting-input'
+  }
+  if (
+    haystack.includes('esc interrupt') ||
+    haystack.includes('esc to interrupt') ||
+    haystack.includes('esc again to interrupt')
+  ) {
+    return 'working'
+  }
+  return 'idle'
+}
+
+const GENERIC_WAITING_PATTERNS: string[] = [
+  '[y/n]',
+  '(y/n)',
+  'yes/no',
+  'y/n?',
+  'confirm?',
+  'continue?',
+  'proceed?',
+  'press enter to continue',
+  'press any key',
+  'allow?',
+  'approve?',
+  'do you want',
+  'would you like',
+  'permission required',
+  'enter to select',
+]
+
+function classifyGeneric(haystack: string, changedAt: number, now: number): TabActivity {
+  for (const pattern of GENERIC_WAITING_PATTERNS) {
+    if (haystack.includes(pattern)) return 'waiting-input'
+  }
+  if (now - changedAt < ACTIVE_CHANGE_WINDOW_MS) return 'working'
+  return 'idle'
+}
+
+export function isShellCommand(command: string | undefined): boolean {
+  if (!command) return false
+  const first = command.trim().split(/\s+/u)[0]
+  if (!first) return false
+  return SHELL_COMMAND_PATTERN.test(first)
+}

package/src/pty/pty-manager.ts

@@ -87,13 +87,11 @@ function envInt(name: string, fallback: number): number {
 }
 
 const RENDER_COALESCE_MS = 16
-const DATA_DEBOUNCE_MS = envInt('AIMUX_RENDER_DEBOUNCE_MS', 32)
-const BURST_MAX_MS = envInt('AIMUX_RENDER_BURST_MS', 500)
+const DATA_DEBOUNCE_MS = envInt('AIMUX_RENDER_DEBOUNCE_MS', 0)
 
 export class PtyManager extends EventEmitter<PtyManagerEvents> {
   private sessions = new Map<string, SessionHandle>()
   private pendingFlushes = new Map<string, ReturnType<typeof setTimeout>>()
-  private pendingBurstCaps = new Map<string, ReturnType<typeof setTimeout>>()
 
   private clearTimers(tabId: string): void {
     const flush = this.pendingFlushes.get(tabId)
@@ -101,11 +99,6 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       clearTimeout(flush)
       this.pendingFlushes.delete(tabId)
     }
-    const burst = this.pendingBurstCaps.get(tabId)
-    if (burst) {
-      clearTimeout(burst)
-      this.pendingBurstCaps.delete(tabId)
-    }
   }
 
   private scheduleRender(session: SessionHandle): void {
@@ -117,20 +110,14 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       if (this.sessions.get(session.tabId) !== session) {
         return
       }
-      const burst = this.pendingBurstCaps.get(session.tabId)
-      if (burst) {
-        clearTimeout(burst)
-        this.pendingBurstCaps.delete(session.tabId)
-      }
       this.emitRenderIfChanged(session)
     }, RENDER_COALESCE_MS)
     this.pendingFlushes.set(session.tabId, timer)
   }
 
   private scheduleDataRender(session: SessionHandle): void {
-    const existingFlush = this.pendingFlushes.get(session.tabId)
-    if (existingFlush) {
-      clearTimeout(existingFlush)
+    if (this.pendingFlushes.has(session.tabId)) {
+      return
     }
     const flushTimer = setTimeout(() => {
       this.pendingFlushes.delete(session.tabId)
@@ -141,30 +128,9 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
         this.scheduleDataRender(session)
         return
       }
-      const burst = this.pendingBurstCaps.get(session.tabId)
-      if (burst) {
-        clearTimeout(burst)
-        this.pendingBurstCaps.delete(session.tabId)
-      }
       this.emitRenderIfChanged(session)
     }, DATA_DEBOUNCE_MS)
     this.pendingFlushes.set(session.tabId, flushTimer)
-
-    if (!this.pendingBurstCaps.has(session.tabId)) {
-      const burstTimer = setTimeout(() => {
-        this.pendingBurstCaps.delete(session.tabId)
-        if (this.sessions.get(session.tabId) !== session) {
-          return
-        }
-        const flush = this.pendingFlushes.get(session.tabId)
-        if (flush) {
-          clearTimeout(flush)
-          this.pendingFlushes.delete(session.tabId)
-        }
-        this.emitRenderIfChanged(session)
-      }, BURST_MAX_MS)
-      this.pendingBurstCaps.set(session.tabId, burstTimer)
-    }
   }
 
   private flushRenderNow(session: SessionHandle): void {

package/src/session-backend/bootstrap.ts

@@ -204,7 +204,9 @@ async function restartDaemon(socketPath: string): Promise<void> {
   await spawnDaemon()
 }
 
-export async function createSessionBackend(): Promise<SessionBackend> {
+export async function createSessionBackend(opts?: {
+  onBreakingUpdateRequired?: () => Promise<void>
+}): Promise<SessionBackend> {
   if (process.env.AIMUX_LOCAL_BACKEND === '1') {
     logDebug('backend.create.localExplicit')
     return new LocalSessionBackend()
@@ -237,6 +239,7 @@ export async function createSessionBackend(): Promise<SessionBackend> {
       error: handshake.error ?? 'incompatible daemon handshake',
       socketPath,
     })
+    await opts?.onBreakingUpdateRequired?.()
     await restartDaemon(socketPath)
     const retriedHandshake = await probeDaemonProtocolCompatibility(socketPath)
     logDebug('backend.create.handshakeAfterRestart', {