@brimveyn/aimux 1.9.9 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.9.9",
+  "version": "1.10.0",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.5.8",
+    "@brimveyn/aimux-config": "0.5.9",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@xterm/headless": "^6.0.0",

package/src/app-runtime/backend-runtime-events.ts

@@ -10,6 +10,7 @@ import type {
 } from '../state/types'
 
 import { logInputDebug } from '../debug/input-log'
+import { clearTabSyntaxState, highlightSnapshot } from '../integrations/claude-syntax-overlay'
 import { type TabRuntimeTimeouts } from './tab-runtime-timeouts'
 
 interface BindBackendRuntimeEventsOptions {
@@ -17,6 +18,7 @@ interface BindBackendRuntimeEventsOptions {
   dispatch: (action: AppAction) => void
   resizingRef: MutableRefObject<boolean>
   timeouts: Pick<TabRuntimeTimeouts, 'clearIdleTimer' | 'clearStartupGrace' | 'clearAllTimers'>
+  syntaxOverlayEnabled: () => boolean
 }
 
 function clearTabRuntimeState(
@@ -31,6 +33,7 @@ export function bindBackendRuntimeEvents({
   backend,
   dispatch,
   resizingRef,
+  syntaxOverlayEnabled,
   timeouts,
 }: BindBackendRuntimeEventsOptions): () => void {
   const handleRender = (
@@ -48,12 +51,14 @@ export function bindBackendRuntimeEvents({
       viewportY: viewport.viewportY,
     })
 
+    const transformed = syntaxOverlayEnabled() ? highlightSnapshot(viewport, tabId) : viewport
+
     dispatch({
       source: resizingRef.current ? 'resize' : 'data',
       tabId,
       terminalModes,
       type: 'replace-tab-viewport',
-      viewport,
+      viewport: transformed,
     })
     // Per-tab activity is driven by the backend's status-detection loop via
     // the `tabActivity` event — no client-side idle timer needed.
@@ -62,12 +67,14 @@ export function bindBackendRuntimeEvents({
   const handleExit = (tabId: string, exitCode: number) => {
     logInputDebug('app.backend.event.exit', { exitCode, tabId })
     clearTabRuntimeState(timeouts, tabId)
+    clearTabSyntaxState(tabId)
     dispatch({ tabId, type: 'close-tab' })
   }
 
   const handleError = (tabId: string, message: string) => {
     logInputDebug('app.backend.event.error', { message, tabId })
     clearTabRuntimeState(timeouts, tabId)
+    clearTabSyntaxState(tabId)
     dispatch({ message, tabId, type: 'set-tab-error' })
   }
 

package/src/app-runtime/side-effects.ts

@@ -37,7 +37,7 @@ import {
 import { saveCurrentWorkspace } from '../state/workspace-save'
 import { filterThemeIds } from '../ui/filter-themes'
 import { scrollGitDiff } from '../ui/git-view-controls'
-import { applyTheme, getTransparent, setTransparent } from '../ui/theme'
+import { applyTheme, getCurrentMode, getTransparent, setMode, setTransparent } from '../ui/theme'
 import { type ThemeId } from '../ui/themes'
 import { triggerAutoCommitNow } from './auto-commit-ref'
 import {
@@ -600,6 +600,12 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       saveConfig({ ...loadConfig(), themeTransparent: next })
       return
     }
+    case 'toggle-mode': {
+      const next = getCurrentMode() === 'dark' ? 'light' : 'dark'
+      setMode(next)
+      saveConfig({ ...loadConfig(), themeMode: next })
+      return
+    }
     default:
       effect satisfies never
   }

package/src/app-runtime/use-backend-runtime.ts

@@ -16,6 +16,7 @@ interface BackendRuntimeOptions {
   layoutRef: MutableRefObject<LayoutState>
   resizingRef: MutableRefObject<boolean>
   currentSessionWorkspaceSnapshot: Parameters<SessionBackend['attach']>[0]['workspaceSnapshot']
+  syntaxOverlayEnabled: () => boolean
 }
 
 export interface TabRuntimeControls {
@@ -33,6 +34,7 @@ export function useBackendRuntime({
   dispatch,
   layoutRef,
   resizingRef,
+  syntaxOverlayEnabled,
 }: BackendRuntimeOptions): TabRuntimeControls {
   const attachRequestIdRef = useRef(0)
   const timeouts = useTabRuntimeTimeouts(dispatch)
@@ -70,13 +72,22 @@ export function useBackendRuntime({
       backend,
       dispatch,
       resizingRef,
+      syntaxOverlayEnabled,
       timeouts: {
         clearAllTimers,
         clearIdleTimer,
         clearStartupGrace,
       },
     })
-  }, [backend, clearAllTimers, clearIdleTimer, clearStartupGrace, dispatch, resizingRef])
+  }, [
+    backend,
+    clearAllTimers,
+    clearIdleTimer,
+    clearStartupGrace,
+    dispatch,
+    resizingRef,
+    syntaxOverlayEnabled,
+  ])
 
   return {
     clearIdleTimer,

package/src/app.tsx

@@ -25,6 +25,8 @@ import { deriveModeId } from './input/modes/bridge'
 import { registerAllModes } from './input/modes/handlers'
 import { getHandler, transitionTo } from './input/modes/registry'
 import { type TerminalContentOrigin } from './input/raw-input-handler'
+import { highlightSnapshot, warmClaudeSyntaxOverlay } from './integrations/claude-syntax-overlay'
+import { ensureClaudeSettingsThemePref, syncClaudeTheme } from './integrations/claude-theme-sync'
 import { getProfileConfigDir, getProfileName } from './profile-paths'
 import { startAIUsageService } from './services/ai-usage/provider'
 import { aiUsageStore } from './state/ai-usage-store'
@@ -35,7 +37,14 @@ import { loadSnippetCatalog } from './state/snippet-catalog'
 import { createInitialState } from './state/store'
 import { KeymapContext } from './ui/keymap-context'
 import { RootView } from './ui/root'
-import { applyTheme, setMode, setTransparent } from './ui/theme'
+import {
+  applyTheme,
+  getCurrentMode,
+  getCurrentTheme,
+  setMode,
+  setTransparent,
+  subscribeThemeChanges,
+} from './ui/theme'
 import { isKnownThemeId, type ThemeId } from './ui/themes'
 import {
   fetchLatestNpmVersion,
@@ -74,6 +83,7 @@ export function App({
     const initial: ThemeId = persisted ?? resolvedConfig.theme?.initialId ?? 'aimux'
     applyTheme(initial)
     if (resolvedConfig.theme?.initialMode) setMode(resolvedConfig.theme.initialMode)
+    if (config.themeMode) setMode(config.themeMode)
     setTransparent(config.themeTransparent ?? false)
     return initial
   })
@@ -157,6 +167,15 @@ export function App({
     }
   }, [dispatch])
 
+  useEffect(() => {
+    if (!resolvedConfig.theme?.beta?.harmonizeClaudeTheme) return
+    ensureClaudeSettingsThemePref()
+    syncClaudeTheme(getCurrentTheme(), getCurrentMode())
+    return subscribeThemeChanges((resolved, mode) => {
+      syncClaudeTheme(resolved, mode)
+    })
+  }, [resolvedConfig.theme?.beta?.harmonizeClaudeTheme])
+
   useEffect(() => {
     const aiUsage = resolvedConfig.statusBar?.aiUsage
     if (!aiUsage?.enabled) {
@@ -232,6 +251,37 @@ export function App({
   const contentOriginRef = useRef<TerminalContentOrigin>({ cols: 0, rows: 0, x: 0, y: 0 })
   const currentSessionWorkspaceSnapshot = currentSession?.workspaceSnapshot
 
+  const syntaxOverlayFlag = resolvedConfig.theme?.beta?.experimentalSyntaxHighlight === true
+  const syntaxOverlayFlagRef = useRef(syntaxOverlayFlag)
+  syntaxOverlayFlagRef.current = syntaxOverlayFlag
+  const syntaxOverlayEnabled = useCallback(() => syntaxOverlayFlagRef.current, [])
+
+  useEffect(() => {
+    if (!syntaxOverlayFlag) return
+    let cancelled = false
+    void (async () => {
+      await warmClaudeSyntaxOverlay()
+      if (cancelled) return
+      // Re-apply the overlay to viewports that were dispatched before shiki
+      // finished loading, so colors appear without waiting for the next
+      // PTY data event.
+      const snapshot = appStore.getState()
+      for (const tab of snapshot.tabs) {
+        if (!tab.viewport) continue
+        dispatch({
+          source: 'data',
+          tabId: tab.id,
+          terminalModes: tab.terminalModes,
+          type: 'replace-tab-viewport',
+          viewport: highlightSnapshot(tab.viewport, tab.id),
+        })
+      }
+    })()
+    return () => {
+      cancelled = true
+    }
+  }, [dispatch, syntaxOverlayFlag])
+
   const { clearIdleTimer, clearStartupGrace, startStartupGrace } = useBackendRuntime({
     activeTabId: state.activeTabId,
     activeTabScrollIntentRef,
@@ -241,6 +291,7 @@ export function App({
     dispatch,
     layoutRef,
     resizingRef,
+    syntaxOverlayEnabled,
   })
 
   useWorkspaceAutosave(state, WORKSPACE_SAVE_DEBOUNCE_MS)

package/src/config.ts

@@ -5,7 +5,7 @@ import type { GitFileListMode, SessionBarPosition, WorkspaceSnapshotV1 } from '.
 import { logDebug } from './debug/input-log'
 import { getProfileConfigDir } from './profile-paths'
 import { isWorkspaceSnapshotV1 } from './state/validation'
-import { migrateThemeId as resolveLegacyThemeId, type ThemeId } from './ui/themes'
+import { migrateThemeId as resolveLegacyThemeId, type ThemeId, type ThemeMode } from './ui/themes'
 
 function migrateThemeId(value: unknown): ThemeId | undefined {
   if (typeof value !== 'string') return undefined
@@ -37,6 +37,7 @@ export interface AimuxConfig {
   customCommands: Record<string, string>
   themeId?: ThemeId
   themeTransparent?: boolean
+  themeMode?: ThemeMode
   gitPane?: PersistedGitPane
   sidebar?: PersistedSidebar
   sessionBarVisible?: boolean
@@ -154,6 +155,7 @@ export function loadConfigResult(): ConfigLoadResult {
       customCommands?: unknown
       themeId?: unknown
       themeTransparent?: unknown
+      themeMode?: unknown
       gitPane?: unknown
       sidebar?: unknown
       gitPanelVisible?: unknown
@@ -184,6 +186,12 @@ export function loadConfigResult(): ConfigLoadResult {
       issues.push('ignored invalid themeTransparent')
     }
 
+    const validThemeMode: ThemeMode | undefined =
+      parsed.themeMode === 'dark' || parsed.themeMode === 'light' ? parsed.themeMode : undefined
+    if (parsed.themeMode !== undefined && validThemeMode === undefined) {
+      issues.push('ignored invalid themeMode')
+    }
+
     let validGitPane = isPersistedGitPane(parsed.gitPane) ? parsed.gitPane : undefined
     if (parsed.gitPane !== undefined && validGitPane === undefined) {
       issues.push('ignored invalid gitPane')
@@ -261,6 +269,7 @@ export function loadConfigResult(): ConfigLoadResult {
         sidebar: validSidebar,
         skippedUpdateVersion: validSkippedUpdateVersion,
         themeId: migrateThemeId(parsed.themeId),
+        themeMode: validThemeMode,
         themeTransparent: validThemeTransparent,
         version: 2,
         workspaceSnapshot: isWorkspaceSnapshotV1(parsed.workspaceSnapshot)

package/src/daemon/daemon.ts

@@ -282,9 +282,33 @@ export async function runDaemon(): Promise<void> {
     },
   })
 
+  /**
+   * Tell the TM whether to bother snapshotting + broadcasting. Toggled on
+   * 0↔1 transitions of the client socket count: when no UI is watching, the
+   * TM can skip per-chunk viewport diff/projection work entirely. The TM
+   * flushes a fresh snapshot per session on re-enable, so reattaching gives
+   * the client a current viewport.
+   *
+   * Fire-and-forget: failure to send isn't fatal (TM will just keep its
+   * previous broadcast state, matching pre-fix behaviour).
+   */
+  const updateTmBroadcastForClientCount = (count: number): void => {
+    void manager.setBroadcastEnabled(count > 0).catch((error) => {
+      logDebug('daemon.setBroadcastEnabled.error', {
+        count,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    })
+  }
+
+  // Initial state: no clients yet, ask the TM to suspend broadcast.
+  updateTmBroadcastForClientCount(0)
+
   const server = createServer((socket) => {
     logDebug('daemon.client.connected')
+    const wasEmpty = sockets.size === 0
     sockets.add(socket)
+    if (wasEmpty) updateTmBroadcastForClientCount(sockets.size)
     const decoder = new MessageDecoder<ClientRequest>(parseClientRequest)
     // Serialize chunk processing per socket. Each async iteration crosses a
     // microtask boundary, so without chaining, concurrent `data` callbacks
@@ -540,12 +564,14 @@ export async function runDaemon(): Promise<void> {
       sockets.delete(socket)
       attachedSessions.delete(socket)
       negotiatedVersions.delete(socket)
+      if (sockets.size === 0) updateTmBroadcastForClientCount(0)
     })
     socket.on('error', () => {
       logDebug('daemon.client.error', { sessionId: attachedSessions.get(socket) ?? null })
       sockets.delete(socket)
       attachedSessions.delete(socket)
       negotiatedVersions.delete(socket)
+      if (sockets.size === 0) updateTmBroadcastForClientCount(0)
     })
   })
 

package/src/daemon/session-manager.ts

@@ -130,6 +130,19 @@ export class SessionManager extends EventEmitter<SessionManagerEvents> {
     this.registries.clear()
   }
 
+  setBroadcastEnabled(enabled: boolean): void {
+    for (const registry of this.registries.values()) {
+      registry.setBroadcastEnabled(enabled)
+    }
+  }
+
+  hasAnySessions(): boolean {
+    for (const registry of this.registries.values()) {
+      if (registry.hasSessions()) return true
+    }
+    return false
+  }
+
   listSessionIds(): string[] {
     return [...this.registries.keys()]
   }

package/src/daemon/session-registry.ts

@@ -208,6 +208,14 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
     }
   }
 
+  setBroadcastEnabled(enabled: boolean): void {
+    this.ptyManager.setBroadcastEnabled(enabled)
+  }
+
+  hasSessions(): boolean {
+    return this.ptyManager.hasSessions()
+  }
+
   closeTab(tabId: string): void {
     logDebug('daemon.registry.closeTab', { tabId })
     this.ptyManager.disposeSession(tabId)

package/src/index.tsx

@@ -67,6 +67,20 @@ const renderer = await createCliRenderer({
 
 const root = createRoot(renderer)
 
+const resolvedConfig = await loadUserConfig()
+logDebug('index.userConfigLoaded', {
+  leader: resolvedConfig.keymaps.leader,
+  modeCount: resolvedConfig.keymaps.modes.size,
+})
+
+// Beta — when experimental syntax highlight is on, ask Claude Code to emit
+// plain code so we can re-tokenize on the snapshot. Set on process.env
+// before backend bootstrap so the spawned daemon (and its child PTYs)
+// inherit it.
+if (resolvedConfig.theme?.beta?.experimentalSyntaxHighlight) {
+  process.env.CLAUDE_CODE_SYNTAX_HIGHLIGHT = 'false'
+}
+
 const backend = await createSessionBackend({
   onBreakingUpdateRequired: () =>
     new Promise<void>((resolve) => {
@@ -75,10 +89,4 @@ const backend = await createSessionBackend({
 })
 logDebug('index.backendReady', { backend: backend.constructor.name, runtimeProfile })
 
-const resolvedConfig = await loadUserConfig()
-logDebug('index.userConfigLoaded', {
-  leader: resolvedConfig.keymaps.leader,
-  modeCount: resolvedConfig.keymaps.modes.size,
-})
-
 root.render(<App backend={backend} resolvedConfig={resolvedConfig} />)

package/src/input/modes/types.ts

@@ -67,6 +67,7 @@ export type SideEffect =
   | { type: 'switch-session-by-index'; index: number }
   | { type: 'delete-session'; sessionId: string }
   | { type: 'toggle-transparent' }
+  | { type: 'toggle-mode' }
 
 export interface KeyResult {
   actions: AppAction[]

package/src/integrations/claude-syntax-overlay.ts

@@ -0,0 +1,460 @@
+// Beta POC — re-tokenize Claude's tool-output code lines with shiki using
+// the active aimux theme. Runs on the App side after each PTY snapshot
+// arrives; shiki + theme stay in the React process.
+//
+// Two structural signals drive detection:
+//   1. Tool header (e.g. `⏺ Update(src/foo.ts)`) → file path → language.
+//   2. Code lines always start with a number prefix (` 42  `, ` 42  + `,
+//      ` 42  - `). That prefix marks where to slice + how long the block runs.
+//
+// Per-tab state remembers the last seen language so blocks whose header
+// has scrolled off the viewport still get colored correctly.
+//
+// Limits: language inference relies on the header staying visible at least
+// once; languages outside the pre-loaded set fall back to plain text.
+
+import type { TerminalLine, TerminalSnapshot, TerminalSpan } from '../state/types'
+
+import { logDebug } from '../debug/input-log'
+import { ensureActiveShikiTheme, ensureShikiLang, getShikiHighlighter } from '../ui/shiki'
+import { getCurrentTheme } from '../ui/theme'
+
+const DEFAULT_LANG = 'typescript'
+
+const PRELOAD_LANGS = [
+  'typescript',
+  'tsx',
+  'javascript',
+  'jsx',
+  'python',
+  'go',
+  'rust',
+  'bash',
+  'shellscript',
+  'json',
+  'yaml',
+  'markdown',
+  'html',
+  'css',
+  'scss',
+  'java',
+  'c',
+  'cpp',
+  'ruby',
+  'php',
+  'sql',
+  'lua',
+  'swift',
+  'kotlin',
+  'toml',
+  'xml',
+] as const
+
+const EXT_TO_LANG: Record<string, string> = {
+  c: 'c',
+  cc: 'cpp',
+  cjs: 'javascript',
+  cpp: 'cpp',
+  cs: 'csharp',
+  css: 'css',
+  cxx: 'cpp',
+  go: 'go',
+  h: 'c',
+  hpp: 'cpp',
+  hs: 'haskell',
+  htm: 'html',
+  html: 'html',
+  java: 'java',
+  js: 'javascript',
+  json: 'json',
+  jsx: 'jsx',
+  kt: 'kotlin',
+  kts: 'kotlin',
+  lua: 'lua',
+  md: 'markdown',
+  mjs: 'javascript',
+  php: 'php',
+  py: 'python',
+  rb: 'ruby',
+  rs: 'rust',
+  scss: 'scss',
+  sh: 'bash',
+  sql: 'sql',
+  swift: 'swift',
+  toml: 'toml',
+  ts: 'typescript',
+  tsx: 'tsx',
+  xml: 'xml',
+  yaml: 'yaml',
+  yml: 'yaml',
+  zsh: 'bash',
+}
+
+let ready = false
+let activeThemeName: string | null = null
+let warmedHighlighter: Awaited<ReturnType<typeof getShikiHighlighter>> | null = null
+
+// Per-tab last seen language (header may have scrolled off the viewport).
+const tabLang = new Map<string, string>()
+
+export async function warmClaudeSyntaxOverlay(): Promise<void> {
+  try {
+    const h = await getShikiHighlighter()
+    warmedHighlighter = h
+    const themeName = await ensureActiveShikiTheme(h)
+    activeThemeName = themeName
+    await Promise.all(PRELOAD_LANGS.map((lang) => ensureShikiLang(h, lang)))
+    ready = true
+  } catch (err) {
+    logDebug('claude-syntax-overlay:warm-failed', { err: String(err) })
+  }
+}
+
+/** Free the per-tab language cache when a tab is closed. */
+export function clearTabSyntaxState(tabId: string): void {
+  tabLang.delete(tabId)
+}
+
+// `⏺ Update(path/to/file.ts)`, `⏺ Read(path)`, `Edit(path)`, `Write(path)`...
+// The leading bullet is sometimes a different glyph; we match a wider
+// keyword set and look for `<Verb>(<path>)` as the anchor.
+const TOOL_HEADER_RE = /\b(?:Read|Update|Edit|Write|MultiEdit|Create|NotebookEdit)\(([^)]+)\)/
+
+// Code-line prefix used by Claude in tool output: ` <n>  ` optionally
+// followed by `+ ` / `- ` for diff lines.
+//   Group 1 = leading whitespace before the number (kept on the outer
+//             dark bg so the diff strip starts at the line number).
+//   Group 2 = the digits + spaces + optional diff marker (the gutter that
+//             carries the diff bg for `+`/`-` lines).
+//   Group 3 = the diff marker itself, present only on `+`/`-` rows.
+const PREFIX_RE = /^(\s*)(\d+\s+([+-]\s+)?)/
+
+interface ShikiToken {
+  content: string
+  color?: string
+  fontStyle?: number
+}
+
+function inferLangFromPath(path: string): string | null {
+  const trimmed = path.trim()
+  const dot = trimmed.lastIndexOf('.')
+  if (dot <= 0) return null
+  const ext = trimmed.slice(dot + 1).toLowerCase()
+  return EXT_TO_LANG[ext] ?? null
+}
+
+function lineText(line: TerminalLine): string {
+  return line.spans.map((s) => s.text).join('')
+}
+
+function dominantBg(line: TerminalLine): string | undefined {
+  const counts = new Map<string, number>()
+  for (const span of line.spans) {
+    if (!span.bg) continue
+    if (span.text.trim().length === 0) continue
+    counts.set(span.bg, (counts.get(span.bg) ?? 0) + span.text.length)
+  }
+  let best: string | undefined
+  let bestCount = 0
+  for (const [bg, c] of counts) {
+    if (c > bestCount) {
+      best = bg
+      bestCount = c
+    }
+  }
+  return best
+}
+
+function tokenize(code: string, lang: string): ShikiToken[][] {
+  if (!ready || !activeThemeName || !warmedHighlighter) return []
+  try {
+    /* eslint-disable typescript-eslint/no-explicit-any */
+    return warmedHighlighter.codeToTokens(code, {
+      lang: lang as any,
+      theme: activeThemeName as any,
+    }).tokens as ShikiToken[][]
+    /* eslint-enable typescript-eslint/no-explicit-any */
+  } catch {
+    return []
+  }
+}
+
+// Calm palette: only color tokens that carry semantic weight (keywords,
+// strings, comments, numbers, types, function names). Operators /
+// punctuation / variables fall back to plain `text` so we don't end up
+// with a rainbow where every identifier and brace is its own color.
+function buildAccentSet(): Set<string> {
+  const t = getCurrentTheme()
+  return new Set(
+    [
+      t.syntaxKeyword,
+      t.syntaxString,
+      t.syntaxComment,
+      t.syntaxNumber,
+      t.syntaxType,
+      t.syntaxFunction,
+    ]
+      .filter((c): c is string => typeof c === 'string')
+      .map((c) => c.toLowerCase())
+  )
+}
+
+function buildSpans(
+  tokens: ShikiToken[],
+  bg: string | undefined,
+  fallbackFg: string,
+  accents: Set<string>
+): TerminalSpan[] {
+  const spans: TerminalSpan[] = []
+  for (const tok of tokens) {
+    if (!tok.content) continue
+    const fs = tok.fontStyle ?? 0
+    const tokColor = tok.color?.toLowerCase()
+    const fg = tokColor && accents.has(tokColor) ? tok.color : fallbackFg
+    spans.push({
+      bg,
+      bold: (fs & 2) !== 0 || undefined,
+      fg,
+      italic: (fs & 1) !== 0 || undefined,
+      text: tok.content,
+      underline: (fs & 4) !== 0 || undefined,
+    })
+  }
+  return spans
+}
+
+function rebuildLine(
+  line: TerminalLine,
+  leading: string,
+  gutter: string,
+  isDiff: boolean,
+  tokens: ShikiToken[],
+  fallbackFg: string,
+  codeBlockBg: string,
+  accents: Set<string>,
+  targetWidth: number
+): TerminalLine {
+  // Two zones per row:
+  //   - leading whitespace before the line number → outer code-block bg.
+  //   - gutter + code + right padding → strip bg (diff color for `+`/`-`
+  //     lines, code-block bg otherwise).
+  // For non-diff lines both zones use the same bg so the row reads as a
+  // single rectangle.
+  const stripBg = isDiff ? (dominantBg(line) ?? codeBlockBg) : codeBlockBg
+
+  const out: TerminalSpan[] = []
+  let consumed = 0
+  if (leading.length > 0) {
+    const leadingSpans = sliceLeading(line.spans, leading.length)
+    for (const span of leadingSpans) {
+      out.push({ ...span, bg: codeBlockBg })
+    }
+    consumed += leading.length
+  }
+  if (gutter.length > 0) {
+    const gutterSpans = sliceRange(line.spans, consumed, gutter.length)
+    for (const span of gutterSpans) {
+      // Preserve fg / bold / italic (line numbers + diff markers carry
+      // meaning); force bg to the strip color.
+      out.push({ ...span, bg: stripBg })
+    }
+    consumed += gutter.length
+  }
+  out.push(...buildSpans(tokens, stripBg, fallbackFg, accents))
+
+  // Pad the right edge with the strip bg out to `targetWidth`. We use the
+  // snapshot's max line width rather than this row's own span length:
+  // after a window grow, xterm hasn't yet filled the new columns on
+  // existing lines, so per-row width undershoots the viewport width.
+  const written = out.reduce((acc, span) => acc + span.text.length, 0)
+  if (targetWidth > written) {
+    out.push({ bg: stripBg, fg: fallbackFg, text: ' '.repeat(targetWidth - written) })
+  }
+
+  return { spans: out }
+}
+
+// Return a shallow copy of the spans covering [start, start+count) chars,
+// splitting boundary spans as needed.
+function sliceRange(spans: TerminalSpan[], start: number, count: number): TerminalSpan[] {
+  const out: TerminalSpan[] = []
+  let cursor = 0
+  let remaining = count
+  for (const span of spans) {
+    if (remaining <= 0) break
+    const next = cursor + span.text.length
+    if (next <= start) {
+      cursor = next
+      continue
+    }
+    const localStart = Math.max(0, start - cursor)
+    const available = span.text.length - localStart
+    const take = Math.min(available, remaining)
+    out.push({ ...span, text: span.text.slice(localStart, localStart + take) })
+    remaining -= take
+    cursor = next
+  }
+  return out
+}
+
+// Take spans from the start of `spans` totalling `count` characters,
+// splitting the boundary span if needed. Used to keep the gutter
+// (line number + diff marker) intact while we replace the code portion.
+function sliceLeading(spans: TerminalSpan[], count: number): TerminalSpan[] {
+  const out: TerminalSpan[] = []
+  let remaining = count
+  for (const span of spans) {
+    if (remaining <= 0) break
+    if (span.text.length <= remaining) {
+      out.push(span)
+      remaining -= span.text.length
+      continue
+    }
+    out.push({ ...span, text: span.text.slice(0, remaining) })
+    remaining = 0
+  }
+  return out
+}
+
+interface BlockContext {
+  lang: string
+  startIndex: number
+  leadings: string[]
+  gutters: string[]
+  isDiff: boolean[]
+  codes: string[]
+  lineRefs: TerminalLine[]
+}
+
+function flushBlock(
+  block: BlockContext,
+  lines: TerminalLine[],
+  fallbackFg: string,
+  codeBlockBg: string,
+  accents: Set<string>,
+  targetWidth: number
+): void {
+  if (block.codes.length === 0) return
+  const joined = block.codes.join('\n')
+  const tokenLines = tokenize(joined, block.lang)
+  if (tokenLines.length === 0) return
+  for (let i = 0; i < block.lineRefs.length; i += 1) {
+    const tokens = tokenLines[i]
+    if (!tokens) continue
+    const lineRef = block.lineRefs[i]
+    const leading = block.leadings[i]
+    const gutter = block.gutters[i]
+    const isDiff = block.isDiff[i]
+    if (!lineRef || leading === undefined || gutter === undefined || isDiff === undefined) {
+      continue
+    }
+    const newLine = rebuildLine(
+      lineRef,
+      leading,
+      gutter,
+      isDiff,
+      tokens,
+      fallbackFg,
+      codeBlockBg,
+      accents,
+      targetWidth
+    )
+    lines[block.startIndex + i] = newLine
+  }
+}
+
+function maxLineWidth(lines: TerminalLine[]): number {
+  let max = 0
+  for (const line of lines) {
+    let w = 0
+    for (const span of line.spans) w += span.text.length
+    if (w > max) max = w
+  }
+  return max
+}
+
+function processLines(
+  lines: TerminalLine[],
+  tabId: string,
+  fallbackFg: string,
+  codeBlockBg: string,
+  accents: Set<string>,
+  targetWidth: number
+): TerminalLine[] {
+  const out = lines.slice()
+  let block: BlockContext | null = null
+
+  for (let i = 0; i < out.length; i += 1) {
+    const line = out[i]
+    if (!line) continue
+    const text = lineText(line)
+
+    // Update per-tab language whenever a tool header appears.
+    const headerMatch = text.match(TOOL_HEADER_RE)
+    if (headerMatch) {
+      const lang = inferLangFromPath(headerMatch[1] ?? '')
+      if (lang) tabLang.set(tabId, lang)
+    }
+
+    const prefixMatch = text.match(PREFIX_RE)
+    if (prefixMatch) {
+      const leading = prefixMatch[1] ?? ''
+      const gutter = prefixMatch[2] ?? ''
+      const diffMarker = prefixMatch[3] ?? ''
+      const code = text.slice(leading.length + gutter.length)
+      if (!block) {
+        block = {
+          codes: [],
+          gutters: [],
+          isDiff: [],
+          lang: tabLang.get(tabId) ?? DEFAULT_LANG,
+          leadings: [],
+          lineRefs: [],
+          startIndex: i,
+        }
+      }
+      block.leadings.push(leading)
+      block.gutters.push(gutter)
+      block.isDiff.push(diffMarker.length > 0)
+      block.codes.push(code)
+      block.lineRefs.push(line)
+      continue
+    }
+
+    if (block) {
+      flushBlock(block, out, fallbackFg, codeBlockBg, accents, targetWidth)
+      block = null
+    }
+  }
+
+  if (block) flushBlock(block, out, fallbackFg, codeBlockBg, accents, targetWidth)
+  return out
+}
+
+export function highlightSnapshot(snapshot: TerminalSnapshot, tabId: string): TerminalSnapshot {
+  if (!ready || !warmedHighlighter) return snapshot
+
+  const theme = getCurrentTheme()
+  const fallbackFg = theme.text
+  const codeBlockBg = theme.backgroundElement
+  const accents = buildAccentSet()
+
+  // Use the longest non-empty row in the snapshot as the target width.
+  // Falls back to a sensible minimum if no row is wide enough yet (very
+  // early in render).
+  const targetWidth = Math.max(maxLineWidth(snapshot.lines), maxLineWidth(snapshot.tailLines ?? []))
+  if (targetWidth === 0) return snapshot
+
+  const nextLines = processLines(
+    snapshot.lines,
+    tabId,
+    fallbackFg,
+    codeBlockBg,
+    accents,
+    targetWidth
+  )
+  const nextTail = snapshot.tailLines
+    ? processLines(snapshot.tailLines, tabId, fallbackFg, codeBlockBg, accents, targetWidth)
+    : snapshot.tailLines
+  return { ...snapshot, lines: nextLines, tailLines: nextTail }
+}

package/src/integrations/claude-theme-sync.ts

@@ -0,0 +1,118 @@
+// Beta — bridge the active aimux theme into Claude Code by writing a
+// custom theme JSON to ~/.claude/themes/aimux.json and selecting it via
+// `theme: "custom:aimux"` in ~/.claude/settings.json. Claude Code watches
+// the themes dir, so writes propagate live without restarting the CLI.
+//
+// Spec: https://code.claude.com/docs/en/terminal-config#create-a-custom-theme
+
+import {
+  type ClaudeThemeFile,
+  resolveClaudeTheme,
+  type ResolvedTuiTheme,
+  type ThemeMode,
+} from '@brimveyn/aimux-config'
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { logDebug } from '../debug/input-log'
+
+const THEME_SLUG = 'aimux'
+const THEME_PREF_VALUE = `custom:${THEME_SLUG}`
+
+function claudeDir(): string {
+  return join(homedir(), '.claude')
+}
+
+function themeFilePath(): string {
+  return join(claudeDir(), 'themes', `${THEME_SLUG}.json`)
+}
+
+function settingsFilePath(): string {
+  return join(claudeDir(), 'settings.json')
+}
+
+function writeAtomic(target: string, contents: string): void {
+  const tmp = `${target}.aimux.tmp`
+  writeFileSync(tmp, contents, 'utf8')
+  try {
+    renameSync(tmp, target)
+  } catch (err) {
+    try {
+      unlinkSync(tmp)
+    } catch {
+      /* ignore */
+    }
+    throw err
+  }
+}
+
+function logSyncWarn(reason: string, details?: Record<string, unknown>): void {
+  logDebug('claude-theme-sync:warn', { reason, ...details })
+}
+
+/**
+ * Write `~/.claude/themes/aimux.json` from the active aimux theme.
+ * Idempotent — overwriting the same content is a no-op for Claude's watcher.
+ * Errors are swallowed (logged) so a failed sync never crashes aimux.
+ */
+export function syncClaudeTheme(resolved: ResolvedTuiTheme, mode: ThemeMode): void {
+  let theme: ClaudeThemeFile
+  try {
+    theme = resolveClaudeTheme(resolved, mode)
+  } catch (err) {
+    logSyncWarn('resolve-failed', { err: String(err) })
+    return
+  }
+
+  const target = themeFilePath()
+  try {
+    mkdirSync(join(claudeDir(), 'themes'), { recursive: true })
+    writeAtomic(target, `${JSON.stringify(theme, null, 2)}\n`)
+  } catch (err) {
+    logSyncWarn('write-failed', { err: String(err), path: target })
+  }
+}
+
+/**
+ * Patch `~/.claude/settings.json` once so Claude picks up the synced theme.
+ * Preserves all other fields. No-op if the preference already matches.
+ */
+export function ensureClaudeSettingsThemePref(): void {
+  const target = settingsFilePath()
+
+  let parsed: Record<string, unknown> = {}
+  if (existsSync(target)) {
+    let raw: string
+    try {
+      raw = readFileSync(target, 'utf8')
+    } catch (err) {
+      logSyncWarn('settings-read-failed', { err: String(err), path: target })
+      return
+    }
+    if (raw.trim().length > 0) {
+      try {
+        const json = JSON.parse(raw) as unknown
+        if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+          logSyncWarn('settings-not-object', { path: target })
+          return
+        }
+        parsed = json as Record<string, unknown>
+      } catch (err) {
+        logSyncWarn('settings-parse-failed', { err: String(err), path: target })
+        return
+      }
+    }
+  }
+
+  if (parsed.theme === THEME_PREF_VALUE) return
+
+  parsed.theme = THEME_PREF_VALUE
+
+  try {
+    mkdirSync(claudeDir(), { recursive: true })
+    writeAtomic(target, `${JSON.stringify(parsed, null, 2)}\n`)
+  } catch (err) {
+    logSyncWarn('settings-write-failed', { err: String(err), path: target })
+  }
+}

package/src/ipc/manager-protocol.ts

@@ -15,7 +15,13 @@ import {
 } from './protocol'
 
 export const MANAGER_PROTOCOL_MIN_VERSION = 3
-export const MANAGER_PROTOCOL_VERSION = 3
+export const MANAGER_PROTOCOL_VERSION = 4
+/**
+ * Minimum version required to send `setBroadcastEnabled`. Older TMs (v3) will
+ * not understand the message; the daemon must check the negotiated version
+ * before sending and fall back to always-on broadcast.
+ */
+export const MANAGER_PROTOCOL_BROADCAST_GATE_VERSION = 4
 
 export interface ManagerHelloRequest {
   minVersion: number
@@ -102,6 +108,7 @@ export type ManagerRequest =
   | { id: string; type: 'closeTab'; payload: { sessionId: string; tabId: string } }
   | { id: string; type: 'disposeSession'; payload: { sessionId: string } }
   | { id: string; type: 'ping'; payload: Record<string, never> }
+  | { id: string; type: 'setBroadcastEnabled'; payload: { enabled: boolean } }
 
 export type ManagerResponse =
   | { id: string; type: 'helloResult'; payload: ManagerHelloResult }
@@ -341,6 +348,12 @@ export function parseManagerRequest(value: unknown): ManagerRequest {
       return value as ManagerRequest
     case 'ping':
       return value as ManagerRequest
+    case 'setBroadcastEnabled':
+      assert(
+        typeof value.payload.enabled === 'boolean',
+        'setBroadcastEnabled.enabled must be a boolean'
+      )
+      return value as ManagerRequest
     default:
       throw new IpcProtocolError(`Unknown IPC request type: ${String(value.type)}`)
   }

package/src/pty/pty-manager.ts

@@ -87,11 +87,44 @@ function envInt(name: string, fallback: number): number {
 }
 
 const RENDER_COALESCE_MS = 16
-const DATA_DEBOUNCE_MS = envInt('AIMUX_RENDER_DEBOUNCE_MS', 0)
+const DATA_DEBOUNCE_MS = envInt('AIMUX_RENDER_DEBOUNCE_MS', 8)
 
 export class PtyManager extends EventEmitter<PtyManagerEvents> {
   private sessions = new Map<string, SessionHandle>()
   private pendingFlushes = new Map<string, ReturnType<typeof setTimeout>>()
+  /**
+   * When false, snapshot+emit work is suppressed because no UI client is
+   * watching. xterm.write still runs (the buffer must stay correct) — only
+   * the projection cost is gated. Re-enable triggers a full flush per session.
+   */
+  private broadcastEnabled = true
+
+  setBroadcastEnabled(enabled: boolean): void {
+    if (enabled === this.broadcastEnabled) return
+    this.broadcastEnabled = enabled
+    logDebug('ptyManager.setBroadcastEnabled', { enabled, sessions: this.sessions.size })
+    if (enabled) {
+      // Force-flush every session: lastSnapshot is stale (or unset) so the
+      // change check inside emitRenderIfChanged will fire and the daemon
+      // gets the current viewport for each tab on resume.
+      for (const session of this.sessions.values()) {
+        this.flushRenderNow(session)
+      }
+    } else {
+      // Drop pending timers — they would do snapshot work nobody is watching.
+      // Iterate values() first then clear; Map deletion during iteration is
+      // defined behaviour but capturing the timers up-front keeps it obvious.
+      for (const timer of this.pendingFlushes.values()) {
+        clearTimeout(timer)
+      }
+      this.pendingFlushes.clear()
+    }
+  }
+
+  /** True iff there's at least one live PTY session. Used by lifecycle gates. */
+  hasSessions(): boolean {
+    return this.sessions.size > 0
+  }
 
   private clearTimers(tabId: string): void {
     const flush = this.pendingFlushes.get(tabId)
@@ -102,6 +135,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
   }
 
   private scheduleRender(session: SessionHandle): void {
+    if (!this.broadcastEnabled) return
     if (this.pendingFlushes.has(session.tabId)) {
       return
     }
@@ -116,6 +150,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
   }
 
   private scheduleDataRender(session: SessionHandle): void {
+    if (!this.broadcastEnabled) return
     if (this.pendingFlushes.has(session.tabId)) {
       return
     }
@@ -139,6 +174,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
   }
 
   private emitRenderIfChanged(session: SessionHandle): void {
+    if (!this.broadcastEnabled) return
     const nextSnapshot = snapshotTerminal(session.emulator, session.cursorVisible)
     const nextTerminalModes = getTerminalModes(session.emulator, session.alternateScrollMode)
     const snapshotChanged = !areTerminalSnapshotsEqual(session.lastSnapshot, nextSnapshot)

package/src/terminal-manager/manager-client.ts

@@ -12,6 +12,7 @@ import { getTerminalManagerSocketPath } from '../daemon/runtime-paths'
 import { logDebug } from '../debug/input-log'
 import {
   encodeManagerMessage,
+  MANAGER_PROTOCOL_BROADCAST_GATE_VERSION,
   MANAGER_PROTOCOL_MIN_VERSION,
   MANAGER_PROTOCOL_VERSION,
   type ManagerAttachResult,
@@ -378,6 +379,30 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
+  /**
+   * Tell the TM whether to bother snapshotting and broadcasting renders.
+   * No-ops on TMs that negotiated a protocol version without the feature
+   * (older builds): the worst case is the daemon keeps receiving renders it
+   * doesn't strictly need, which matches the pre-fix behaviour.
+   */
+  async setBroadcastEnabled(enabled: boolean): Promise<void> {
+    if (
+      this.selectedProtocolVersion === null ||
+      this.selectedProtocolVersion < MANAGER_PROTOCOL_BROADCAST_GATE_VERSION
+    ) {
+      logDebug('managerClient.setBroadcastEnabled.skipped', {
+        enabled,
+        selectedVersion: this.selectedProtocolVersion,
+      })
+      return
+    }
+    await this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { enabled },
+      type: 'setBroadcastEnabled',
+    })
+  }
+
   destroy(): void {
     this.resetConnection('Terminal manager client destroyed')
   }

package/src/terminal-manager/terminal-manager.ts

@@ -52,6 +52,49 @@ export async function runTerminalManager(): Promise<void> {
   const sockets = new Set<Socket>()
   const negotiatedVersions = new Map<Socket, number>()
 
+  /**
+   * Auto-exit when fully idle: no clients connected AND no live PTY sessions.
+   * Prevents the "zombie TM" pattern where a stale terminal-manager from an
+   * older install keeps consuming CPU after the user has closed everything.
+   * The grace window allows brief reconnects (e.g. daemon restart during
+   * `aimux update`) without killing the process.
+   *
+   * Set AIMUX_TM_IDLE_EXIT_MS=0 to disable.
+   */
+  const idleExitMs = (() => {
+    const raw = process.env.AIMUX_TM_IDLE_EXIT_MS
+    if (raw === undefined) return 60_000
+    const parsed = Number(raw)
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 60_000
+  })()
+  let idleExitTimer: ReturnType<typeof setTimeout> | null = null
+  const scheduleIdleExitIfApplicable = (): void => {
+    if (idleExitMs === 0) return
+    if (idleExitTimer !== null) return
+    if (sockets.size > 0) return
+    if (sessionManager.hasAnySessions()) return
+    logDebug('terminalManager.idleExit.schedule', { idleExitMs })
+    idleExitTimer = setTimeout(() => {
+      idleExitTimer = null
+      if (sockets.size > 0 || sessionManager.hasAnySessions()) {
+        logDebug('terminalManager.idleExit.cancelled')
+        return
+      }
+      logDebug('terminalManager.idleExit.fire')
+      sessionManager.disposeAll()
+      // Graceful: drop the listening socket so the file is unlinked, matching
+      // SIGTERM/SIGINT shutdown. Bail-out timer guards against close() hanging
+      // on a bad socket.
+      server.close(() => process.exit(0))
+      setTimeout(() => process.exit(0), 1_000).unref?.()
+    }, idleExitMs)
+    idleExitTimer.unref?.()
+  }
+
+  // A session can exit naturally (PTY child finishes) while no client is
+  // attached — re-evaluate idle state in that case too.
+  sessionManager.on('exit', () => scheduleIdleExitIfApplicable())
+
   sessionManager.on('render', (sessionId, tabId, viewport, terminalModes) => {
     const event: ManagerEvent = {
       payload: { sessionId, tabId, terminalModes, viewport },
@@ -233,6 +276,11 @@ export async function runTerminalManager(): Promise<void> {
               case 'ping':
                 sendOk(socket, message.id)
                 break
+              case 'setBroadcastEnabled':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                sessionManager.setBroadcastEnabled(message.payload.enabled)
+                sendOk(socket, message.id)
+                break
             }
           } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error)
@@ -256,11 +304,13 @@ export async function runTerminalManager(): Promise<void> {
       logDebug('terminalManager.client.close')
       sockets.delete(socket)
       negotiatedVersions.delete(socket)
+      scheduleIdleExitIfApplicable()
     })
     socket.on('error', () => {
       logDebug('terminalManager.client.error')
       sockets.delete(socket)
       negotiatedVersions.delete(socket)
+      scheduleIdleExitIfApplicable()
     })
   })
 
@@ -270,8 +320,12 @@ export async function runTerminalManager(): Promise<void> {
   })
   tightenSocketPermissions(socketPath)
 
+  // First idle eval: if no client connects within idleExitMs of startup, exit.
+  scheduleIdleExitIfApplicable()
+
   const gracefulShutdown = (signal: string) => {
     logDebug(`terminalManager.${signal}`)
+    if (idleExitTimer) clearTimeout(idleExitTimer)
     sessionManager.disposeAll()
     server.close()
     process.exit(0)

package/src/ui/components/layout/terminal-pane.tsx

@@ -47,9 +47,10 @@ function getTitle(
   return `${tab.title} · ${tab.status}`
 }
 
-function getBorderColor(isActive: boolean, _focusMode: TerminalPaneProps['focusMode']): string {
+function getBorderColor(isActive: boolean, focusMode: TerminalPaneProps['focusMode']): string {
   const t = getCurrentTheme()
-  return isActive ? t.borderActive : t.border
+  if (!isActive) return t.border
+  return focusMode === 'terminal-input' ? t.accent : t.primary
 }
 
 function renderSpan(span: TerminalSpan, key: string): ReactNode {

package/src/ui/components/modals/themes/theme-picker-modal.tsx

@@ -4,7 +4,7 @@ import type { ThemeId } from '../../../themes'
 
 import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-ref'
 import { filterThemeIds, themeDisplayName } from '../../../filter-themes'
-import { useTheme, useTransparent } from '../../../theme'
+import { useMode, useTheme, useTransparent } from '../../../theme'
 import { uiTokens } from '../../../ui-tokens'
 import { Picker, type PickerItem } from '../shared/picker'
 
@@ -28,6 +28,7 @@ export function ThemePickerModal({
 }: ThemePickerModalProps) {
   const t = useTheme()
   const transparent = useTransparent()
+  const mode = useMode()
   const filtered = useMemo(() => filterThemeIds(filter), [filter])
 
   useLayoutEffect(() => {
@@ -63,6 +64,7 @@ export function ThemePickerModal({
             {filtered.length === 0 ? '' : ` ${effectiveIndex + 1} / ${filtered.length}`}
           </text>
           <text fg={t.textMuted}>{` transparent: ${transparent ? 'on' : 'off'} (ctrl-t)`}</text>
+          <text fg={t.textMuted}>{` mode: ${mode} (ctrl-l)`}</text>
         </box>
       }
       items={items}

package/src/ui/theme-store.ts

@@ -73,6 +73,10 @@ export function useTransparent(): boolean {
   return useStore(themeStore, (s) => s.transparent)
 }
 
+export function useMode(): ThemeMode {
+  return useStore(themeStore, (s) => s.mode)
+}
+
 export function getTransparent(): boolean {
   return themeStore.getState().transparent
 }
@@ -81,3 +85,17 @@ export function setTransparent(value: boolean): void {
   if (themeStore.getState().transparent === value) return
   themeStore.setState({ transparent: value })
 }
+
+/** Subscribe to theme id/mode changes for non-React side-effects. */
+export function subscribeThemeChanges(
+  listener: (resolved: ResolvedTuiTheme, mode: ThemeMode) => void
+): () => void {
+  let lastId: ThemeId | null = null
+  let lastMode: ThemeMode | null = null
+  return themeStore.subscribe((s) => {
+    if (s.id === lastId && s.mode === lastMode) return
+    lastId = s.id
+    lastMode = s.mode
+    listener(derive(s.id, s.mode), s.mode)
+  })
+}

package/src/ui/theme.ts

@@ -11,6 +11,8 @@ export {
   getTransparent,
   setMode,
   setTransparent,
+  subscribeThemeChanges,
+  useMode,
   useTheme,
   useTransparent,
 } from './theme-store'

package/src/update.ts

@@ -1,5 +1,5 @@
 import { getDaemonSocketPath } from './daemon/runtime-paths'
-import { findIpcDaemonPid } from './platform/daemon-control'
+import { findIpcDaemonPid, findTerminalManagerPid } from './platform/daemon-control'
 import { runRestartDaemon } from './restart-daemon'
 
 const REPO = 'BrimVeyn/aimux'
@@ -59,5 +59,25 @@ export async function runUpdate(): Promise<number> {
     await runRestartDaemon()
   }
 
+  // The terminal-manager is intentionally NOT restarted here: doing so kills
+  // live AI sessions. The flip side: the running TM keeps executing the
+  // previous version's code path, so any TM-side fix (perf, lifecycle) only
+  // takes effect after a manual restart. Surface that explicitly so users
+  // aren't silently stuck on stale behaviour.
+  const tmPid = await findTerminalManagerPid()
+  if (tmPid !== null) {
+    process.stdout.write(
+      [
+        '',
+        `Note: terminal-manager (pid ${tmPid}) is still running the previous version.`,
+        'TM-side fixes in this update apply to new TMs only — the running one',
+        'keeps its old behaviour until restarted.',
+        'Run `aimux restart-terminal-manager` when you can afford to lose your',
+        'current PTY sessions to upgrade it.',
+        '',
+      ].join('\n')
+    )
+  }
+
   return 0
 }