@brimveyn/aimux 1.9.9 → 1.10.1

package/src/app-runtime/use-mouse-handlers.ts

@@ -1,18 +1,22 @@
 import type { MouseEvent as OtuiMouseEvent } from '@opentui/core'
 
-import { useRef } from 'react'
+import { useEffect, useRef } from 'react'
 
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { SessionBackend } from '../session-backend/types'
 import type { SplitDirection } from '../state/layout-tree'
-import type { AppAction, AppState, TabSession } from '../state/types'
+import type { AppAction, AppState, TabSession, TerminalLine } from '../state/types'
 
 import { logInputDebug } from '../debug/input-log'
 import { MultiClickDetector } from '../input/multi-click-detector'
+import { extractStreamText, getLineText } from '../input/terminal-text-extraction'
 import { copyToSystemClipboard } from '../platform/clipboard'
 import {
   type ClickSelectionResult,
+  computeRangeFromLineText,
+  getViewportAnchor,
   isPositionedNode,
+  type MultiClickMode,
   resolveClickSelection,
 } from './click-selection-resolver'
 import { requestRenderUpTree } from './render-invalidation'
@@ -32,6 +36,31 @@ type ResizeDragState =
   | ({ initialWidth: number; kind: 'git-pane'; side: 'left' | 'right' } & AxisDragState)
   | ({ kind: 'embedded-git'; position: 'top' | 'bottom' } & AnchoredRatioDragState)
 
+interface MultiClickDragState {
+  mode: MultiClickMode
+  tabId: string
+  target: unknown
+  baseX: number
+  baseY: number
+  // Absolute buffer rows (viewportY + viewportRow). Stable across scroll so
+  // auto-scroll can move the viewport without losing the anchor.
+  anchorAbsRow: number
+  anchorStartCol: number
+  anchorEndCol: number
+  focusAbsRow: number
+  focusCol: number
+  // Last raw screen position so the viewport-change effect can re-extend the
+  // selection even when no drag event has fired (mouse held still at the edge).
+  lastEventScreenY: number
+  lastEventScreenX: number
+  // Cache of every viewport row seen during the drag, indexed by absolute row.
+  // Source of truth for clipboard text when the selection spans rows that have
+  // scrolled out of view.
+  capturedLines: Map<number, TerminalLine>
+  autoScrollTimer: ReturnType<typeof setInterval> | null
+  autoScrollDir: -1 | 0 | 1
+}
+
 interface UseMouseHandlersOptions {
   state: AppState
   dispatch: (action: AppAction) => void
@@ -47,6 +76,7 @@ interface UseMouseHandlersOptions {
 }
 
 const MIN_MULTI_CLICK_SELECTION_COUNT = 2
+const AUTO_SCROLL_INTERVAL_MS = 40
 
 function getTargetTerminalTabId(
   focusMode: AppState['focusMode'],
@@ -60,14 +90,49 @@ function getTargetTerminalTabId(
   return activeTabId
 }
 
-function applyResolvedSelection(
+function captureViewportLines(drag: MultiClickDragState, tab: TabSession): void {
+  if (!tab.viewport) return
+  const startAbs = tab.viewport.viewportY
+  for (let i = 0; i < tab.viewport.lines.length; i++) {
+    const line = tab.viewport.lines[i]
+    if (line) drag.capturedLines.set(startAbs + i, line)
+  }
+}
+
+function isForwardSelection(drag: MultiClickDragState): boolean {
+  return (
+    drag.focusAbsRow > drag.anchorAbsRow ||
+    (drag.focusAbsRow === drag.anchorAbsRow && drag.focusCol >= drag.anchorEndCol)
+  )
+}
+
+function renderMultiClickSelection(
+  renderer: UseMouseHandlersOptions['renderer'],
+  drag: MultiClickDragState,
+  viewportY: number,
+  finishDragging: boolean
+): void {
+  const forward = isForwardSelection(drag)
+  const anchorCol = forward ? drag.anchorStartCol : drag.anchorEndCol
+  const anchorScreenY = drag.baseY + (drag.anchorAbsRow - viewportY)
+  const focusScreenY = drag.baseY + (drag.focusAbsRow - viewportY)
+  renderer.startSelection(drag.target, drag.baseX + anchorCol, anchorScreenY)
+  renderer.updateSelection(drag.target, drag.baseX + drag.focusCol, focusScreenY, {
+    finishDragging,
+  })
+  requestRenderUpTree(drag.target)
+}
+
+function applyMultiClickInitialSelection(
   renderer: UseMouseHandlersOptions['renderer'],
   selection: ClickSelectionResult
 ): void {
   renderer.clearSelection()
   renderer.startSelection(selection.target, selection.baseX + selection.startCol, selection.eventY)
+  // finishDragging:false keeps the renderer in drag mode so subsequent
+  // mouse-drag events can extend the selection through our drag handler.
   renderer.updateSelection(selection.target, selection.baseX + selection.endCol, selection.eventY, {
-    finishDragging: true,
+    finishDragging: false,
   })
   requestRenderUpTree(selection.target)
   copyToSystemClipboard(selection.selectedText)
@@ -83,6 +148,98 @@ export function useMouseHandlers({
 }: UseMouseHandlersOptions) {
   const separatorDragRef = useRef<ResizeDragState | null>(null)
   const multiClickRef = useRef(new MultiClickDetector())
+  const multiClickDragRef = useRef<MultiClickDragState | null>(null)
+  // State is captured by reference in the React closure; we need a ref so
+  // drag/up handlers and the auto-scroll timer see the freshest tab viewport.
+  const stateRef = useRef(state)
+  stateRef.current = state
+
+  const clearAutoScroll = (drag: MultiClickDragState) => {
+    if (drag.autoScrollTimer) {
+      clearInterval(drag.autoScrollTimer)
+    }
+    drag.autoScrollTimer = null
+    drag.autoScrollDir = 0
+  }
+
+  const canScroll = (tab: TabSession | undefined, dir: -1 | 1): boolean => {
+    if (!tab?.viewport) return false
+    if (dir < 0) return tab.viewport.viewportY > 0
+    return tab.viewport.viewportY < tab.viewport.baseY
+  }
+
+  const startAutoScroll = (drag: MultiClickDragState, dir: -1 | 1) => {
+    if (drag.autoScrollDir === dir && drag.autoScrollTimer) return
+    clearAutoScroll(drag)
+    drag.autoScrollDir = dir
+    drag.autoScrollTimer = setInterval(() => {
+      const tab = stateRef.current.tabs.find((t: TabSession) => t.id === drag.tabId)
+      if (!canScroll(tab, dir)) {
+        clearAutoScroll(drag)
+        return
+      }
+      backend.scrollViewport(drag.tabId, dir)
+      // The snapshot dispatch will trigger the viewport-change effect below,
+      // which recaptures lines and re-extends the selection focus.
+    }, AUTO_SCROLL_INTERVAL_MS)
+  }
+
+  // Unmount safety: never leave a setInterval running past the hook's life.
+  useEffect(
+    () => () => {
+      const drag = multiClickDragRef.current
+      if (drag) clearAutoScroll(drag)
+      multiClickDragRef.current = null
+    },
+    []
+  )
+
+  // Abort the drag (and its auto-scroll loop) when the user switches to a
+  // different tab mid-drag: the original tab is no longer visible and we'd
+  // otherwise keep pumping scroll commands into a background buffer.
+  useEffect(() => {
+    const drag = multiClickDragRef.current
+    if (!drag) return
+    if (drag.tabId !== state.activeTabId) {
+      clearAutoScroll(drag)
+      multiClickDragRef.current = null
+    }
+  }, [state.activeTabId])
+
+  // Re-extend selection and recapture viewport lines on every snapshot change
+  // while a multi-click drag is in progress. This is what lets auto-scroll
+  // grow the selection even when the mouse hasn't moved.
+  useEffect(() => {
+    const drag = multiClickDragRef.current
+    if (!drag) return
+    const tab = stateRef.current.tabs.find((t: TabSession) => t.id === drag.tabId)
+    if (!tab?.viewport) return
+
+    captureViewportLines(drag, tab)
+
+    const viewportRows = tab.viewport.lines.length
+    if (viewportRows === 0) return
+
+    const dragViewportRow = Math.max(
+      0,
+      Math.min(viewportRows - 1, drag.lastEventScreenY - drag.baseY)
+    )
+    const newFocusAbs = tab.viewport.viewportY + dragViewportRow
+    const focusLine = drag.capturedLines.get(newFocusAbs)
+    const focusLineText = focusLine ? getLineText(focusLine) : ''
+    const focusDragCol = drag.lastEventScreenX - drag.baseX
+    const range = computeRangeFromLineText(focusLineText, focusDragCol, drag.mode)
+    const focusStart = range?.startCol ?? Math.max(0, focusDragCol)
+    const focusEnd = range?.endCol ?? Math.max(0, focusDragCol)
+
+    drag.focusAbsRow = newFocusAbs
+    const forward =
+      newFocusAbs > drag.anchorAbsRow ||
+      (newFocusAbs === drag.anchorAbsRow && focusEnd >= drag.anchorEndCol)
+    drag.focusCol = forward ? focusEnd : focusStart
+
+    renderMultiClickSelection(renderer, drag, tab.viewport.viewportY, false)
+  }, [state.tabs, renderer])
 
   const handleTerminalMouseEvent = (event: OtuiMouseEvent, origin: TerminalContentOrigin) => {
     const targetTabId = getTargetTerminalTabId(
@@ -237,24 +394,158 @@ export function useMouseHandlers({
 
     const clickCount = multiClickRef.current.track(event.x, event.y)
     if (clickCount < MIN_MULTI_CLICK_SELECTION_COUNT) {
+      // Single-click: clear any stale multi-click drag state so a fresh
+      // char-level drag from opentui's default handler isn't extended by us.
+      const stale = multiClickDragRef.current
+      if (stale) clearAutoScroll(stale)
+      multiClickDragRef.current = null
       return
     }
 
     const tab = state.tabs.find((t: TabSession) => t.id === targetTabId)
     const selection = resolveClickSelection(event, targetTabId, tab, clickCount)
-    if (!selection) {
+    if (!selection || !tab?.viewport) {
       return
     }
 
     event.preventDefault()
-    applyResolvedSelection(renderer, selection)
+    applyMultiClickInitialSelection(renderer, selection)
+
+    const anchor = getViewportAnchor(event)
+    if (anchor) {
+      const anchorAbsRow = tab.viewport.viewportY + selection.row
+      const drag: MultiClickDragState = {
+        anchorAbsRow,
+        anchorEndCol: selection.endCol,
+        anchorStartCol: selection.startCol,
+        autoScrollDir: 0,
+        autoScrollTimer: null,
+        baseX: anchor.baseX,
+        baseY: anchor.baseY,
+        capturedLines: new Map(),
+        focusAbsRow: anchorAbsRow,
+        focusCol: selection.endCol,
+        lastEventScreenX: event.x,
+        lastEventScreenY: event.y,
+        mode: selection.mode,
+        tabId: targetTabId,
+        target: selection.target,
+      }
+      captureViewportLines(drag, tab)
+      multiClickDragRef.current = drag
+    }
 
     logInputDebug('click.done', {
       hasSelection: !!renderer.hasSelection,
+      mode: selection.mode,
       targetSelectable: isPositionedNode(event.target) ? !!event.target.selectable : false,
     })
   }
 
+  const handleTerminalDrag = (
+    event: OtuiMouseEvent,
+    _origin: TerminalContentOrigin,
+    _tabId?: string
+  ): boolean => {
+    const drag = multiClickDragRef.current
+    if (!drag) return false
+
+    const tab = stateRef.current.tabs.find((t: TabSession) => t.id === drag.tabId)
+    if (!tab?.viewport) return true
+
+    drag.lastEventScreenX = event.x
+    drag.lastEventScreenY = event.y
+    captureViewportLines(drag, tab)
+
+    const viewportRows = tab.viewport.lines.length
+    if (viewportRows === 0) return true
+
+    const rawRow = event.y - drag.baseY
+    const dragViewportRow = Math.max(0, Math.min(viewportRows - 1, rawRow))
+    const dragAbsRow = tab.viewport.viewportY + dragViewportRow
+    const dragCol = event.x - drag.baseX
+
+    const focusLine = drag.capturedLines.get(dragAbsRow)
+    const focusLineText = focusLine ? getLineText(focusLine) : ''
+    const range = computeRangeFromLineText(focusLineText, dragCol, drag.mode)
+    const focusStart = range?.startCol ?? Math.max(0, dragCol)
+    const focusEnd = range?.endCol ?? Math.max(0, dragCol)
+
+    drag.focusAbsRow = dragAbsRow
+    const forward =
+      dragAbsRow > drag.anchorAbsRow ||
+      (dragAbsRow === drag.anchorAbsRow && focusEnd >= drag.anchorEndCol)
+    drag.focusCol = forward ? focusEnd : focusStart
+
+    renderMultiClickSelection(renderer, drag, tab.viewport.viewportY, false)
+
+    // Edge detection: trigger auto-scroll when the pointer sits at (or beyond)
+    // the top/bottom row of the viewport.
+    let dir: -1 | 0 | 1 = 0
+    if (rawRow <= 0) dir = -1
+    else if (rawRow >= viewportRows - 1) dir = 1
+
+    if (dir === 0) {
+      clearAutoScroll(drag)
+    } else if (canScroll(tab, dir)) {
+      startAutoScroll(drag, dir)
+    } else {
+      clearAutoScroll(drag)
+    }
+
+    return true
+  }
+
+  const handleTerminalMouseUp = (_event: OtuiMouseEvent): boolean => {
+    const drag = multiClickDragRef.current
+    if (!drag) return false
+
+    clearAutoScroll(drag)
+
+    const tab = stateRef.current.tabs.find((t: TabSession) => t.id === drag.tabId)
+    if (tab?.viewport) {
+      captureViewportLines(drag, tab)
+      renderMultiClickSelection(renderer, drag, tab.viewport.viewportY, true)
+    }
+
+    const forward = isForwardSelection(drag)
+    const anchorCol = forward ? drag.anchorStartCol : drag.anchorEndCol
+
+    const startAbs = Math.min(drag.anchorAbsRow, drag.focusAbsRow)
+    const endAbs = Math.max(drag.anchorAbsRow, drag.focusAbsRow)
+    const lines: TerminalLine[] = []
+    let missingRows = 0
+    for (let abs = startAbs; abs <= endAbs; abs++) {
+      const line = drag.capturedLines.get(abs)
+      if (line) {
+        lines.push(line)
+      } else {
+        missingRows += 1
+        lines.push({ spans: [] })
+      }
+    }
+    if (missingRows > 0) {
+      // Snapshot coalescing (remote backend, fast scroll bursts) can let the
+      // selection cover rows we never captured. The output gets blank lines
+      // here — surface it for debugging instead of silently corrupting paste.
+      logInputDebug('multiclick.clipboardGap', {
+        endAbs,
+        missingRows,
+        startAbs,
+        totalRows: endAbs - startAbs + 1,
+      })
+    }
+    const anchorIdx = drag.anchorAbsRow - startAbs
+    const focusIdx = drag.focusAbsRow - startAbs
+    const text = extractStreamText(lines, anchorIdx, anchorCol, focusIdx, drag.focusCol)
+    if (text.length > 0) {
+      copyToSystemClipboard(text)
+    }
+
+    multiClickDragRef.current = null
+    return true
+  }
+
   return {
     handleEmbeddedGitResizeStart,
     handleGitPaneResizeStart,
@@ -265,7 +556,9 @@ export function useMouseHandlers({
     handleSidebarResizeStart,
     handleSplitResize,
     handleTerminalClick,
+    handleTerminalDrag,
     handleTerminalMouseEvent,
+    handleTerminalMouseUp,
     handleTerminalScrollEvent,
   }
 }

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)
@@ -272,7 +323,9 @@ export function App({
     handleSidebarResizeStart,
     handleSplitResize,
     handleTerminalClick,
+    handleTerminalDrag,
     handleTerminalMouseEvent,
+    handleTerminalMouseUp,
     handleTerminalScrollEvent,
   } = useMouseHandlers({
     activeLocalScrollbackEnabled,
@@ -404,6 +457,8 @@ export function App({
         onTerminalMouseEvent={handleTerminalMouseEvent}
         onTerminalScrollEvent={handleTerminalScrollEvent}
         onTerminalClick={handleTerminalClick}
+        onTerminalDrag={handleTerminalDrag}
+        onTerminalMouseUp={handleTerminalMouseUp}
         onPaneActivate={handlePaneActivate}
         onSplitResize={handleSplitResize}
         onEmbeddedGitResizeStart={handleEmbeddedGitResizeStart}

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[]