@phenx-inc/ctlsurf 0.8.0 → 0.10.0

package/src/main/agentState.ts

@@ -0,0 +1,329 @@
+/**
+ * Agent State Monitor
+ *
+ * Detects, in real time, whether a coding agent is BUSY (actively working) or
+ * AWAITING the user — either waiting for the next prompt (`awaiting_input`) or
+ * blocked on an approval/permission decision (`awaiting_decision`).
+ *
+ * This is the cross-platform "PTY backbone": it watches the raw terminal byte
+ * stream (which every agent produces regardless of OS) and infers state from
+ * the TUI's own affordances — the busy spinner (`esc to interrupt`) and
+ * approval prompts. It is deliberately independent of chat logging and of the
+ * ConversationBridge, whose transcript cleaner actively *discards* the spinner
+ * lines this monitor needs.
+ *
+ * Agents with native hooks (Claude Code, Codex) can deliver an authoritative
+ * state via `applyHookEvent()`, which overrides the heuristic for a short
+ * window. See agentHooks.ts.
+ */
+
+export type AgentState = 'idle' | 'busy' | 'awaiting_input' | 'awaiting_decision'
+
+export type AgentStateSink = (info: {
+  tabId: string
+  state: AgentState
+  /** True when any tracked tab is awaiting the user (drives the dock/taskbar). */
+  anyAwaiting: boolean
+}) => void
+
+// The spinner ticks roughly once per second; allow a couple of missed ticks
+// before we stop considering the agent busy.
+const BUSY_GRACE_MS = 2_500
+// Output must be quiet this long after the spinner stops before we declare the
+// agent is awaiting the user (avoids flagging mid-stream pauses).
+const SETTLE_MS = 1_200
+// How long a seen approval prompt keeps a tab in `awaiting_decision`.
+const DECISION_TTL_MS = 4_000
+// Evaluation cadence.
+const TICK_MS = 400
+// A hook-delivered state is authoritative for this long, suppressing the
+// heuristic for that tab.
+const HOOK_AUTHORITY_MS = 6_000
+// Only the trailing slice of each tab's output is kept, enough to catch a
+// marker split across two PTY chunks.
+const TAIL_KEEP_CHARS = 240
+
+// Claude Code's working spinner: a cycling star glyph followed by a gerund that
+// ends in an ellipsis, e.g. "✶ Tempering…" or "✳ Cogitating...". The completion
+// line ("✻ Worked for 2s") has the glyph but no ellipsis, so it doesn't match —
+// letting the agent settle to `awaiting_input`. Newer Claude builds (Opus 4.8)
+// don't always print "esc to interrupt" for fast turns, so this is the primary
+// Claude signal; the older hints are kept for other builds and Codex.
+const CLAUDE_SPINNER = /[✶✻✳✺✢✷✸✹❋][^\n]{0,60}(?:…|\.\.\.)/
+
+/** Busy markers — the spinner/working hints a TUI shows while actively working. */
+function hasBusyMarker(text: string): boolean {
+  return (
+    /esc to interrupt/i.test(text) ||
+    /\bWorking \(\d+s/i.test(text) ||
+    CLAUDE_SPINNER.test(text)
+  )
+}
+
+/**
+ * Approval / permission prompts. Conservative on purpose: a false positive only
+ * mislabels the sub-state (the dock fires on either awaiting state anyway), but
+ * we still avoid obviously-noisy matches.
+ */
+const APPROVAL_PATTERNS: RegExp[] = [
+  /\bDo you want to (proceed|continue|create|make this edit|run)\b/i, // Claude Code
+  /❯\s*\d+\.\s*Yes\b/i, // Claude numbered-choice prompt
+  /\bAllow command\b/i, // Codex
+  /\bRun this command\?/i, // Codex
+  /\bApprove\b[^\n]*\?/i,
+  /\(y\/n\)/i,
+  /\[y\/N\]/i,
+]
+
+function hasApprovalMarker(text: string): boolean {
+  return APPROVAL_PATTERNS.some((re) => re.test(text))
+}
+
+/** Strip CSI/OSC escape sequences so markers aren't hidden behind color codes. */
+function stripAnsi(str: string): string {
+  return str
+    // eslint-disable-next-line no-control-regex
+    .replace(/\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g, '')
+    // eslint-disable-next-line no-control-regex
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    // eslint-disable-next-line no-control-regex
+    .replace(/\x1b/g, '')
+}
+
+interface TabRecord {
+  /** Agent id (e.g. 'claude', 'codex'); reserved for future per-agent tuning. */
+  agentId: string
+  cwd: string
+  state: AgentState
+  /** True once a busy spinner has been seen since the last user input. */
+  everBusy: boolean
+  lastBusyAt: number
+  lastOutputAt: number
+  lastDecisionAt: number
+  /** Authoritative state from a hook, and when it was delivered. */
+  hookState: AgentState | null
+  hookAt: number
+  /** Trailing output slice, to catch markers split across PTY chunks. */
+  tail: string
+}
+
+export class AgentStateMonitor {
+  private readonly sink: AgentStateSink
+  private readonly now: () => number
+  private tabs = new Map<string, TabRecord>()
+  private timer: ReturnType<typeof setInterval> | null = null
+  private lastAnyAwaiting = false
+
+  constructor(sink: AgentStateSink, now: () => number = Date.now) {
+    this.sink = sink
+    this.now = now
+  }
+
+  start(): void {
+    if (this.timer) return
+    this.timer = setInterval(() => this.tick(), TICK_MS)
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer)
+      this.timer = null
+    }
+    this.tabs.clear()
+    this.lastAnyAwaiting = false
+  }
+
+  /** Register a tab so its raw PTY output can be classified. */
+  trackTab(tabId: string, agentId: string, cwd: string): void {
+    const now = this.now()
+    this.tabs.set(tabId, {
+      agentId,
+      cwd,
+      state: 'idle',
+      everBusy: false,
+      lastBusyAt: 0,
+      lastOutputAt: now,
+      lastDecisionAt: 0,
+      hookState: null,
+      hookAt: 0,
+      tail: '',
+    })
+  }
+
+  removeTab(tabId: string): void {
+    if (this.tabs.delete(tabId)) this.emitAggregate()
+  }
+
+  /** Feed a raw PTY output chunk for a tab. */
+  feed(tabId: string, data: string): void {
+    const rec = this.tabs.get(tabId)
+    if (!rec) return
+    const now = this.now()
+    rec.lastOutputAt = now
+
+    const text = rec.tail + stripAnsi(data)
+    rec.tail = text.length > TAIL_KEEP_CHARS ? text.slice(-TAIL_KEEP_CHARS) : text
+
+    if (hasBusyMarker(text)) {
+      rec.lastBusyAt = now
+      rec.everBusy = true
+    }
+    if (hasApprovalMarker(text)) {
+      rec.lastDecisionAt = now
+    }
+  }
+
+  /**
+   * Note input written to a tab's PTY. Only a *submit* (data containing a
+   * newline) counts as the user engaging — clearing any awaiting state and
+   * resetting the "has worked" flag so a leftover idle box doesn't re-flag.
+   *
+   * Individual keystrokes and, crucially, the terminal's own auto-responses
+   * (cursor-position / device-attribute replies that TUIs constantly trigger,
+   * which xterm.js writes straight back to the PTY) are ignored — otherwise
+   * the state would churn busy↔idle on every control-sequence handshake.
+   */
+  noteInput(tabId: string, data: string): void {
+    if (!/[\r\n]/.test(data)) return
+    const rec = this.tabs.get(tabId)
+    if (!rec) return
+    const now = this.now()
+    rec.everBusy = false
+    rec.lastBusyAt = now // a submit means work is coming → busy, not awaiting
+    rec.lastDecisionAt = 0
+    rec.hookState = null
+    this.setState(rec, tabId, 'busy')
+  }
+
+  /**
+   * Apply an authoritative state from an agent hook, addressed by cwd. Overrides
+   * the heuristic for HOOK_AUTHORITY_MS. `kind`:
+   *   'awaiting_input'    — turn done / idle prompt (Stop, idle_prompt, agent-turn-complete)
+   *   'awaiting_decision' — permission/approval prompt (PermissionRequest, permission_prompt)
+   *   'busy'              — user submitted a prompt (UserPromptSubmit)
+   */
+  applyHookEvent(cwd: string, kind: AgentState): void {
+    const target = stripTrailingSep(cwd)
+    const now = this.now()
+    for (const [tabId, rec] of this.tabs) {
+      if (stripTrailingSep(rec.cwd) !== target) continue
+      rec.hookState = kind
+      rec.hookAt = now
+      if (kind === 'busy') {
+        rec.everBusy = false
+        rec.lastBusyAt = now
+      }
+      this.setState(rec, tabId, kind)
+    }
+  }
+
+  private tick(): void {
+    const now = this.now()
+    for (const [tabId, rec] of this.tabs) {
+      // Hook state wins while fresh.
+      if (rec.hookState && now - rec.hookAt < HOOK_AUTHORITY_MS) {
+        this.setState(rec, tabId, rec.hookState)
+        continue
+      }
+
+      // `> 0` guards the "never seen" sentinel so a small/zero clock value
+      // doesn't read as recent activity.
+      const busyRecently = rec.lastBusyAt > 0 && now - rec.lastBusyAt < BUSY_GRACE_MS
+      const settled = now - rec.lastOutputAt >= SETTLE_MS
+      const decisionRecent = rec.lastDecisionAt > 0 && now - rec.lastDecisionAt < DECISION_TTL_MS
+
+      let next: AgentState | null = null
+      if (busyRecently) {
+        next = 'busy'
+      } else if (settled && rec.everBusy) {
+        // Awaiting the user. Keep the sub-state stable: once we're showing
+        // awaiting_decision it sticks (and awaiting_input may upgrade to it),
+        // but we never flap back down — the agent's screen repaints make an
+        // approval marker match only intermittently, which otherwise flickers
+        // the indicator between amber and red.
+        next = rec.state === 'awaiting_decision' || decisionRecent
+          ? 'awaiting_decision'
+          : 'awaiting_input'
+      } else if (settled && !rec.everBusy) {
+        next = 'idle'
+      }
+      // next === null → output still streaming after spinner stopped; hold the
+      // current state until it settles.
+      if (next) this.setState(rec, tabId, next)
+    }
+    this.emitAggregate()
+  }
+
+  private setState(rec: TabRecord, tabId: string, state: AgentState): void {
+    if (rec.state === state) return
+    rec.state = state
+    this.sink({ tabId, state, anyAwaiting: this.computeAnyAwaiting() })
+    this.lastAnyAwaiting = this.computeAnyAwaiting()
+  }
+
+  private emitAggregate(): void {
+    const anyAwaiting = this.computeAnyAwaiting()
+    if (anyAwaiting === this.lastAnyAwaiting) return
+    this.lastAnyAwaiting = anyAwaiting
+    // Re-emit with a representative tab so the dock/aggregate listener updates
+    // even when no single tab's state label changed this tick.
+    const tabId = this.firstAwaitingTabId() ?? ''
+    const state = tabId ? (this.tabs.get(tabId)!.state) : 'idle'
+    this.sink({ tabId, state, anyAwaiting })
+  }
+
+  private computeAnyAwaiting(): boolean {
+    for (const rec of this.tabs.values()) {
+      if (rec.state === 'awaiting_input' || rec.state === 'awaiting_decision') return true
+    }
+    return false
+  }
+
+  private firstAwaitingTabId(): string | null {
+    for (const [tabId, rec] of this.tabs) {
+      if (rec.state === 'awaiting_input' || rec.state === 'awaiting_decision') return tabId
+    }
+    return null
+  }
+}
+
+function stripTrailingSep(p: string): string {
+  return p.length > 1 ? p.replace(/[/\\]+$/, '') : p
+}
+
+/**
+ * Decides whether the dock/taskbar "awaiting input" attention (blink + bounce)
+ * should currently be active. Pure boolean logic, separated from the Electron
+ * bindings in index.ts so it can be tested without a window.
+ *
+ * Rules:
+ *  - Attention is active only while an agent is awaiting AND the window is
+ *    unfocused AND the current awaiting episode hasn't been acknowledged.
+ *  - Focusing the window during an episode acknowledges it; so does already
+ *    being focused at the moment the episode begins (you saw it happen).
+ *  - Acknowledgement lasts for the whole episode: blurring again does NOT
+ *    re-nag. A fresh episode (agent works, then waits again) starts unack'd.
+ */
+export class AttentionController {
+  private awaiting = false
+  private focused = false
+  private acknowledged = false
+
+  /** Update awaiting state; returns whether attention should be active. */
+  setAwaiting(on: boolean): boolean {
+    if (on && !this.awaiting) this.acknowledged = this.focused // new episode
+    this.awaiting = on
+    return this.active()
+  }
+
+  /** Update window focus; returns whether attention should be active. */
+  setFocused(focused: boolean): boolean {
+    this.focused = focused
+    if (focused && this.awaiting) this.acknowledged = true
+    return this.active()
+  }
+
+  private active(): boolean {
+    return this.awaiting && !this.focused && !this.acknowledged
+  }
+}

package/src/main/index.ts

@@ -24,6 +24,7 @@ function log(...args: unknown[]): void {
 import { AgentConfig, getDefaultAgent, getAvailableAgents } from './agents'
 import { getSettingsDir } from './settingsDir'
 import { Orchestrator } from './orchestrator'
+import { AttentionController } from './agentState'
 
 let mainWindow: BrowserWindow | null = null
 
@@ -50,43 +51,47 @@ function getProjectAbbrev(cwdPath: string): string {
   return word.slice(0, 2).toUpperCase()
 }
 
-function createOverlayIcon(text: string): Electron.NativeImage {
-  // Create a 32x32 overlay with text for Windows/Linux
+// Draw a 32x32 filled circle overlay. `red` switches between the project-badge
+// blue and the "awaiting input" red dot.
+function createDotOverlay(red: boolean): Electron.NativeImage {
   const size = 32
   const canvas = Buffer.alloc(size * size * 4, 0) // RGBA
-
-  // Fill with a semi-transparent dark background circle
+  const [r, g, b] = red ? [235, 64, 52] : [122, 162, 247]
   for (let y = 0; y < size; y++) {
     for (let x = 0; x < size; x++) {
       const cx = x - size / 2
       const cy = y - size / 2
-      const dist = Math.sqrt(cx * cx + cy * cy)
-      if (dist <= size / 2) {
+      if (Math.sqrt(cx * cx + cy * cy) <= size / 2) {
         const idx = (y * size + x) * 4
-        canvas[idx] = 122     // R (blue-ish)
-        canvas[idx + 1] = 162 // G
-        canvas[idx + 2] = 247 // B
-        canvas[idx + 3] = 220 // A
+        canvas[idx] = r
+        canvas[idx + 1] = g
+        canvas[idx + 2] = b
+        canvas[idx + 3] = 235
       }
     }
   }
-
   return nativeImage.createFromBuffer(canvas, { width: size, height: size })
 }
 
-function updateProjectBadge(cwdPath: string | null): void {
-  if (!cwdPath) return
-  const abbrev = getProjectAbbrev(cwdPath)
+// Last project abbreviation, so the steady badge can be restored after the
+// "awaiting input" indicator clears.
+let projectAbbrev = ''
 
-  // macOS: dock badge shows text directly
+function applySteadyBadge(): void {
   if (process.platform === 'darwin' && app.dock) {
-    app.dock.setBadge(abbrev)
+    app.dock.setBadge(projectAbbrev)
   }
-
-  // Windows: overlay icon on taskbar
   if (process.platform === 'win32' && mainWindow) {
-    mainWindow.setOverlayIcon(createOverlayIcon(abbrev), abbrev)
+    mainWindow.setOverlayIcon(projectAbbrev ? createDotOverlay(false) : null, projectAbbrev)
   }
+}
+
+function updateProjectBadge(cwdPath: string | null): void {
+  if (!cwdPath) return
+  projectAbbrev = getProjectAbbrev(cwdPath)
+
+  // Don't stomp the awaiting-input blink; it restores the steady badge itself.
+  if (!blinkTimer) applySteadyBadge()
 
   // All platforms: update window title
   if (mainWindow) {
@@ -95,6 +100,76 @@ function updateProjectBadge(cwdPath: string | null): void {
   }
 }
 
+// ─── "Awaiting input" attention indicator (cross-platform) ──────────
+//
+// The detection is OS-independent; only the visual differs:
+//   macOS   — blink a red dot in the dock badge + one bounce
+//   Windows — red overlay icon on the taskbar button + flash the button
+//   Linux   — badge count where supported + flash (window urgency hint)
+// While the window is focused the dock/taskbar nag is suppressed (the in-app
+// dot is enough); the renderer always gets `agent:state` regardless of OS.
+
+const attention = new AttentionController()
+let blinkTimer: ReturnType<typeof setInterval> | null = null
+let blinkOn = false
+let bounceId = -1
+
+function setAwaitingIndicator(on: boolean): void {
+  applyAttention(attention.setAwaiting(on))
+}
+
+function applyAttention(active: boolean): void {
+  if (active) startAttention()
+  else stopAttention()
+}
+
+function startAttention(): void {
+  if (blinkTimer) return
+  log('[agent-state] attention START (blink + bounce)')
+
+  if (process.platform === 'darwin' && app.dock) {
+    bounceId = app.dock.bounce('informational')
+  }
+  if (process.platform === 'win32' && mainWindow) {
+    mainWindow.setOverlayIcon(createDotOverlay(true), 'Awaiting input')
+    mainWindow.flashFrame(true)
+  }
+  if (process.platform === 'linux') {
+    if (typeof app.badgeCount === 'number') app.badgeCount = 1
+    mainWindow?.flashFrame(true)
+  }
+
+  // Blink the macOS dock badge — the whole red pill (project initials and all)
+  // toggles on/off, so the project letters are preserved on the "on" frames
+  // rather than being replaced by a dot.
+  blinkOn = true
+  blinkTimer = setInterval(() => {
+    blinkOn = !blinkOn
+    if (process.platform === 'darwin' && app.dock) {
+      app.dock.setBadge(blinkOn ? (projectAbbrev || '●') : '')
+    }
+  }, 600)
+}
+
+function stopAttention(): void {
+  if (blinkTimer) {
+    clearInterval(blinkTimer)
+    blinkTimer = null
+    log('[agent-state] attention STOP')
+  }
+  if (process.platform === 'darwin' && app.dock) {
+    if (bounceId >= 0) { app.dock.cancelBounce(bounceId); bounceId = -1 }
+  }
+  if (process.platform === 'win32' && mainWindow) {
+    mainWindow.flashFrame(false)
+  }
+  if (process.platform === 'linux') {
+    if (typeof app.badgeCount === 'number') app.badgeCount = 0
+    mainWindow?.flashFrame(false)
+  }
+  applySteadyBadge()
+}
+
 // ─── Orchestrator (shared logic) ──────────────────
 
 const orchestrator = new Orchestrator(
@@ -107,6 +182,11 @@ const orchestrator = new Orchestrator(
     onWorkerRegistered: (data) => mainWindow?.webContents.send('worker:registered', data),
     onProjectChanged: (name) => mainWindow?.webContents.send('app:projectChanged', name),
     onAgentMessage: (text) => mainWindow?.webContents.send('agent:message', text),
+    onAgentStateChange: (tabId, state, anyAwaiting) => {
+      log(`[agent-state] tab=${tabId} state=${state} anyAwaiting=${anyAwaiting}`)
+      mainWindow?.webContents.send('agent:state', tabId, state, anyAwaiting)
+      setAwaitingIndicator(anyAwaiting)
+    },
     onCwdChanged: () => {
       mainWindow?.webContents.send('app:cwdChanged')
       updateProjectBadge(orchestrator.cwd)
@@ -146,6 +226,12 @@ function createWindow(): void {
     mainWindow.loadFile(path.join(__dirname, '../renderer/index.html'))
   }
 
+  // Focusing the window means the user is here — drop the dock/taskbar nag (the
+  // in-app dot still shows the state). Re-arm it if the agent is still awaiting
+  // when focus is lost again.
+  mainWindow.on('focus', () => applyAttention(attention.setFocused(true)))
+  mainWindow.on('blur', () => applyAttention(attention.setFocused(false)))
+
   mainWindow.on('closed', () => {
     mainWindow = null
   })
@@ -420,6 +506,8 @@ ipcMain.handle('speak:set', (_event, enabled: boolean) => {
   orchestrator.setSpeakReplies(!!enabled)
   return { enabled: orchestrator.speakRepliesEnabled }
 })
+// Latest assistant reply from the active tab's transcript, for on-demand TTS.
+ipcMain.handle('agent:getLastReply', () => orchestrator.getLastReply())
 
 // ─── Tracking IPC ─────────────────────────────────
 

package/src/main/orchestrator.ts

@@ -6,7 +6,8 @@ import { PtyManager } from './pty'
 import { AgentConfig, isCodingAgent } from './agents'
 import { CtlsurfApi } from './ctlsurfApi'
 import { ConversationBridge } from './bridge'
-import { TranscriptTailer, supportsTranscriptLogging } from './transcripts'
+import { TranscriptTailer, supportsTranscriptLogging, readLatestAssistantReply } from './transcripts'
+import { AgentStateMonitor, type AgentState } from './agentState'
 import { WorkerWsClient, type WorkerWsStatus, type IncomingMessage } from './workerWs'
 import { TimeTracker } from './timeTracker'
 import { TicketStore, type TicketInput } from './ticketStore'
@@ -51,6 +52,10 @@ export interface OrchestratorEvents {
   // text-to-speech. Optional and wired only by the Electron entry — the
   // headless build leaves it unset, so replies are never spoken in a terminal.
   onAgentMessage?: (text: string) => void
+  // Real-time agent activity state (busy vs awaiting the user). `anyAwaiting`
+  // is true when any tab is waiting on the user, and drives the dock/taskbar
+  // attention indicator. Optional — only the Electron entry wires it.
+  onAgentStateChange?: (tabId: string, state: AgentState, anyAwaiting: boolean) => void
 }
 
 interface TabState {
@@ -102,11 +107,17 @@ export class Orchestrator {
   private noProjectPollCwd: string | null = null
   private currentProjectName: string | null = null
   private transcriptTailer: TranscriptTailer | null = null
+  private readonly stateMonitor: AgentStateMonitor
 
   constructor(settingsDir: string, events: OrchestratorEvents) {
     this.settingsDir = settingsDir
     this.events = events
 
+    this.stateMonitor = new AgentStateMonitor(({ tabId, state, anyAwaiting }) => {
+      this.events.onAgentStateChange?.(tabId, state, anyAwaiting)
+    })
+    this.stateMonitor.start()
+
     this.workerWs = new WorkerWsClient({
       onStatusChange: (status: WorkerWsStatus) => {
         log(`[worker-ws] Status: ${status}`)
@@ -119,9 +130,10 @@ export class Orchestrator {
 
         if (message.type === 'prompt' || message.type === 'task_dispatch') {
           const activeTab = this.activeTabId ? this.tabs.get(this.activeTabId) : null
-          if (activeTab) {
+          if (activeTab && this.activeTabId) {
             activeTab.ptyManager.write(message.content + '\r')
             this.bridge.feedInput(message.content + '\r')
+            this.stateMonitor.noteInput(this.activeTabId, message.content + '\r')
           }
         }
       },
@@ -159,6 +171,18 @@ export class Orchestrator {
     return !!this.settings.speakReplies
   }
 
+  // Latest assistant reply from a tab's transcript, for on-demand "read aloud".
+  // Defaults to the active tab. Returns null when the tab's agent has no native
+  // transcript (only Claude Code / Codex do) or nothing has been said yet. Reads
+  // the transcript directly, so it works regardless of the speakReplies setting.
+  getLastReply(tabId?: string): string | null {
+    const id = tabId || this.activeTabId
+    if (!id) return null
+    const tab = this.tabs.get(id)
+    if (!tab || !supportsTranscriptLogging(tab.agent.id)) return null
+    return readLatestAssistantReply({ agentId: tab.agent.id, cwd: tab.cwd })
+  }
+
   setLogChat(enabled: boolean): void {
     this.settings.logChat = enabled
     this.saveSettings()
@@ -451,10 +475,14 @@ export class Orchestrator {
     const ptyManager = new PtyManager(agent, cwd)
     const tab: TabState = { ptyManager, agent, cwd, termStreamBuffer: '', termStreamTimer: null }
     this.tabs.set(tabId, tab)
+    // Track all tabs (not just the active one): a background agent finishing is
+    // exactly when the dock indicator is most useful.
+    this.stateMonitor.trackTab(tabId, agent.id, cwd)
 
     ptyManager.onData((data: string) => {
       this.events.onPtyData(tabId, data)
       this.timeTracker.recordActivity(tabId)
+      this.stateMonitor.feed(tabId, data)
       if (tabId === this.activeTabId) {
         this.bridge.feedOutput(data)
         this.streamTerminalData(tabId, data)
@@ -473,6 +501,7 @@ export class Orchestrator {
       // Clean up tab state
       const t = this.tabs.get(tabId)
       if (t?.termStreamTimer) clearTimeout(t.termStreamTimer)
+      this.stateMonitor.removeTab(tabId)
     })
 
     this.startChatLogging(agent, cwd)
@@ -499,6 +528,7 @@ export class Orchestrator {
 
   writePty(tabId: string, data: string): void {
     this.tabs.get(tabId)?.ptyManager.write(data)
+    this.stateMonitor.noteInput(tabId, data)
     if (tabId === this.activeTabId) {
       this.bridge.feedInput(data)
     }
@@ -519,6 +549,7 @@ export class Orchestrator {
     await this.timeTracker.endSession(tabId)
     tab.ptyManager.kill()
     this.tabs.delete(tabId)
+    this.stateMonitor.removeTab(tabId)
     if (tabId === this.activeTabId) {
       this.stopChatLogging()
       if (isCodingAgent(tab.agent)) {
@@ -690,6 +721,7 @@ export class Orchestrator {
   async shutdown(): Promise<void> {
     this.stopNoProjectPolling()
     this.stopChatLogging()
+    this.stateMonitor.stop()
     await this.timeTracker.endAll()
     for (const [, tab] of this.tabs) {
       if (tab.termStreamTimer) clearTimeout(tab.termStreamTimer)