@brimveyn/aimux 1.6.2 → 1.7.1

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

@@ -6,6 +6,7 @@ import {
   getIpcDaemonSocketPath,
   getSocketSecurityIssue,
   removeDaemonSocketIfExists,
+  removeTerminalManagerSocketIfExists,
 } from '../daemon/runtime-paths'
 import { logDebug } from '../debug/input-log'
 import {
@@ -15,7 +16,12 @@ import {
   MessageDecoder,
   parseServerMessage,
 } from '../ipc/protocol'
-import { findIpcDaemonPid, killProcess, spawnDetachedIpcDaemon } from '../platform/daemon-control'
+import {
+  findIpcDaemonPid,
+  findTerminalManagerPid,
+  killProcess,
+  spawnDetachedIpcDaemon,
+} from '../platform/daemon-control'
 import { LocalSessionBackend } from './local-session-backend'
 import { RemoteSessionBackend } from './remote-session-backend'
 
@@ -204,7 +210,22 @@ async function restartDaemon(socketPath: string): Promise<void> {
   await spawnDaemon()
 }
 
-export async function createSessionBackend(): Promise<SessionBackend> {
+// Kill the terminal-manager and clear its socket so the restarted daemon
+// spawns a fresh one via ensureTerminalManagerReady. Without this, the new
+// daemon reconnects to the still-running old terminal-manager and the
+// breaking protocol mismatch persists.
+async function stopTerminalManager(): Promise<void> {
+  const pid = await findTerminalManagerPid()
+  if (pid !== null) {
+    logDebug('backend.stopTerminalManager.killing', { pid })
+    await killProcess(pid)
+  }
+  removeTerminalManagerSocketIfExists()
+}
+
+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 +258,8 @@ export async function createSessionBackend(): Promise<SessionBackend> {
       error: handshake.error ?? 'incompatible daemon handshake',
       socketPath,
     })
+    await opts?.onBreakingUpdateRequired?.()
+    await stopTerminalManager()
     await restartDaemon(socketPath)
     const retriedHandshake = await probeDaemonProtocolCompatibility(socketPath)
     logDebug('backend.create.handshakeAfterRestart', {

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> {