perf(terminal): add output flow control / back-pressure for heavy streams (#1090)

fetchSuggestions ran the full completion pipeline (history scan, fig specs, remote path lookups) on the main thread even when both the popup and ghost text were disabled — the results were then discarded. Add a shouldQueryCompletions(settings) gate and bail out early (clearing any stale state) when neither display mode is on.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

application/state/useTerminalBackend.ts

@@ -73,6 +73,11 @@ export const useTerminalBackend = () => {
     bridge?.resizeSession?.(sessionId, cols, rows);
   }, []);
 
+  const setSessionFlowPaused = useCallback((sessionId: string, paused: boolean) => {
+    const bridge = netcattyBridge.get();
+    bridge?.setSessionFlowPaused?.(sessionId, paused);
+  }, []);
+
   const closeSession = useCallback((sessionId: string) => {
     const bridge = netcattyBridge.get();
     bridge?.closeSession?.(sessionId);
@@ -208,6 +213,7 @@ export const useTerminalBackend = () => {
       getServerStats,
       writeToSession,
       resizeSession,
+      setSessionFlowPaused,
       closeSession,
       setSessionEncoding,
       onSessionData,
@@ -240,6 +246,7 @@ export const useTerminalBackend = () => {
       getServerStats,
       writeToSession,
       resizeSession,
+      setSessionFlowPaused,
       closeSession,
       setSessionEncoding,
       onSessionData,

components/Terminal.tsx

@@ -5,7 +5,6 @@ import { SearchAddon } from "@xterm/addon-search";
 import "@xterm/xterm/css/xterm.css";
 import { Cpu, Copy, HardDrive, Maximize2, MemoryStick, Radio, ArrowDownToLine, ArrowUpFromLine } from "lucide-react";
 import React, { memo, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
-import ReactDOM from "react-dom";
 import { useI18n } from "../application/i18n/I18nProvider";
 import { logger } from "../lib/logger";
 import { cn, normalizeLineEndings, wrapBracketedPaste } from "../lib/utils";
@@ -52,6 +51,7 @@ import { TerminalSearchBar } from "./terminal/TerminalSearchBar";
 import { ZmodemOverwriteDialog } from "./terminal/ZmodemOverwriteDialog";
 import { ZmodemProgressIndicator } from "./terminal/ZmodemProgressIndicator";
 import { createReplaySafeTerminalLogSanitizer } from "./terminal/replaySafeTerminalLog";
+import { createConnectionLogBuffer } from "./terminal/connectionLogBuffer";
 import { useZmodemTransfer } from "./terminal/hooks/useZmodemTransfer";
 import { createTerminalSessionStarters, type PendingAuth } from "./terminal/runtime/createTerminalSessionStarters";
 import { createXTermRuntime, primaryFontFamily, type XTermRuntime } from "./terminal/runtime/createXTermRuntime";
@@ -70,7 +70,7 @@ import { useTerminalContextActions } from "./terminal/hooks/useTerminalContextAc
 import { useTerminalAuthState } from "./terminal/hooks/useTerminalAuthState";
 import { useServerStats } from "./terminal/hooks/useServerStats";
 import { extractDropEntries, getPathForFile, DropEntry } from "../lib/sftpFileUtils";
-import { useTerminalAutocomplete, AutocompletePopup } from "./terminal/autocomplete";
+import { TerminalAutocomplete } from "./terminal/TerminalAutocomplete";
 import { createTerminalCwdTracker, resolvePreferredTerminalCwd } from "./terminal/sftpCwd";
 
 const MAX_CONNECTION_LOG_DATA_CHARS = 1_000_000;
@@ -299,7 +299,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   // cancelled retry can't fire a startNewSession after the fact.
   const retryTokenRef = useRef<symbol | null>(null);
   const terminalDataCapturedRef = useRef(false);
-  const terminalLogDataRef = useRef("");
+  const connectionLogBufferRef = useRef(createConnectionLogBuffer(MAX_CONNECTION_LOG_DATA_CHARS));
   const terminalLogSanitizerRef = useRef(createReplaySafeTerminalLogSanitizer());
   const onTerminalDataCaptureRef = useRef(onTerminalDataCapture);
   const commandBufferRef = useRef<string>("");
@@ -320,21 +320,15 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   const captureTerminalLogData = useCallback((data: string) => {
     const replaySafeData = terminalLogSanitizerRef.current.append(data);
     if (!replaySafeData) return;
-    terminalLogDataRef.current += replaySafeData;
-    if (terminalLogDataRef.current.length > MAX_CONNECTION_LOG_DATA_CHARS) {
-      terminalLogDataRef.current = terminalLogDataRef.current.slice(-MAX_CONNECTION_LOG_DATA_CHARS);
-    }
+    connectionLogBufferRef.current.append(replaySafeData);
   }, []);
 
   const finalizeTerminalLogData = useCallback(() => {
     const replaySafeData = terminalLogSanitizerRef.current.finish();
     if (replaySafeData) {
-      terminalLogDataRef.current += replaySafeData;
-      if (terminalLogDataRef.current.length > MAX_CONNECTION_LOG_DATA_CHARS) {
-        terminalLogDataRef.current = terminalLogDataRef.current.slice(-MAX_CONNECTION_LOG_DATA_CHARS);
-      }
+      connectionLogBufferRef.current.append(replaySafeData);
     }
-    return terminalLogDataRef.current;
+    return connectionLogBufferRef.current.toString();
   }, []);
 
   const writeLocalTerminalData = useCallback((data: string) => {
@@ -389,10 +383,13 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   const snippetsRef = useRef(snippets);
   snippetsRef.current = snippets;
 
-  // Autocomplete handler refs (set after hook initialization)
+  // Autocomplete handler refs — populated by <TerminalAutocomplete> so the
+  // xterm runtime (and a few effects here) can drive the hook without making
+  // Terminal re-render on every suggestion update.
   const autocompleteKeyEventRef = useRef<((e: KeyboardEvent) => boolean) | undefined>(undefined);
   const autocompleteInputRef = useRef<((data: string) => void) | undefined>(undefined);
   const autocompleteRepositionRef = useRef<(() => void) | undefined>(undefined);
+  const autocompleteCloseRef = useRef<(() => void) | undefined>(undefined);
 
   const terminalBackend = useTerminalBackend();
   const { resizeSession, setSessionEncoding } = terminalBackend;
@@ -541,31 +538,19 @@ const TerminalComponent: React.FC<TerminalProps> = ({
     }
   };
 
-  const autocomplete = useTerminalAutocomplete({
-    termRef,
-    sessionId,
-    hostId: host.id,
-    hostOs: host.os || (host.protocol === "local"
-      ? (navigator.platform?.startsWith("Win") ? "windows" : navigator.platform?.startsWith("Mac") ? "macos" : "linux")
-      : "linux"),
-    settings: terminalSettings ? {
-      enabled: terminalSettings.autocompleteEnabled ?? true,
-      showGhostText: terminalSettings.autocompleteGhostText ?? true,
-      showPopupMenu: terminalSettings.autocompletePopupMenu ?? true,
-      debounceMs: terminalSettings.autocompleteDebounceMs ?? 100,
-      minChars: terminalSettings.autocompleteMinChars ?? 1,
-      maxSuggestions: terminalSettings.autocompleteMaxSuggestions ?? 8,
-    } : undefined,
-    onAcceptText: (text) => autocompleteAcceptTextRef.current?.(text),
-    protocol: host.protocol,
-    getCwd: () => terminalCwdTracker.getRendererCwd() ?? knownCwdRef.current,
-  });
-
-  // Wire up autocomplete handler refs so createXTermRuntime can use them
-  autocompleteKeyEventRef.current = autocomplete.handleKeyEvent;
-  autocompleteInputRef.current = autocomplete.handleInput;
-  autocompleteRepositionRef.current = autocomplete.repositionPopup;
-  const autocompleteClosePopup = autocomplete.closePopup;
+  // Autocomplete config — the hook itself lives in <TerminalAutocomplete> so
+  // its state updates don't re-render this component (see render below).
+  const autocompleteHostOs: "linux" | "windows" | "macos" = host.os || (host.protocol === "local"
+    ? (navigator.platform?.startsWith("Win") ? "windows" : navigator.platform?.startsWith("Mac") ? "macos" : "linux")
+    : "linux");
+  const autocompleteSettings = terminalSettings ? {
+    enabled: terminalSettings.autocompleteEnabled ?? true,
+    showGhostText: terminalSettings.autocompleteGhostText ?? true,
+    showPopupMenu: terminalSettings.autocompletePopupMenu ?? true,
+    debounceMs: terminalSettings.autocompleteDebounceMs ?? 100,
+    minChars: terminalSettings.autocompleteMinChars ?? 1,
+    maxSuggestions: terminalSettings.autocompleteMaxSuggestions ?? 8,
+  } : undefined;
 
   const resolveSftpInitialPath = useCallback(async (): Promise<string | undefined> => {
     const cwd = await resolvePreferredTerminalCwd({
@@ -640,9 +625,9 @@ const TerminalComponent: React.FC<TerminalProps> = ({
 
   useEffect(() => {
     if (!isVisible) {
-      autocompleteClosePopup();
+      autocompleteCloseRef.current?.();
     }
-  }, [isVisible, autocompleteClosePopup]);
+  }, [isVisible]);
 
   // Check if this is a local or serial connection (doesn't need connection dialog during connecting)
   const isLocalConnection = host.protocol === "local";
@@ -940,7 +925,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   useEffect(() => {
     let disposed = false;
     terminalDataCapturedRef.current = false;
-    terminalLogDataRef.current = "";
+    connectionLogBufferRef.current.reset();
     terminalLogSanitizerRef.current = createReplaySafeTerminalLogSanitizer();
     setError(null);
     hasConnectedRef.current = false;
@@ -2384,29 +2369,27 @@ const TerminalComponent: React.FC<TerminalProps> = ({
             }}
           />
 
-          {/* Autocomplete popup — rendered via Portal to escape overflow:hidden */}
-          {isVisible && autocomplete.state.popupVisible && autocomplete.state.suggestions.length > 0 &&
-            ReactDOM.createPortal(
-              <AutocompletePopup
-                suggestions={autocomplete.state.suggestions}
-                selectedIndex={autocomplete.state.selectedIndex}
-                position={autocomplete.state.popupPosition}
-                cursorLineTop={autocomplete.state.popupCursorLineTop}
-                cursorLineBottom={autocomplete.state.popupCursorLineBottom}
-                visible={autocomplete.state.popupVisible}
-                expandUpward={autocomplete.state.expandUpward}
-                themeColors={effectiveTheme.colors}
-                onSelect={autocomplete.selectSuggestion}
-                subDirPanels={autocomplete.state.subDirPanels}
-                subDirFocusLevel={autocomplete.state.subDirFocusLevel}
-                containerRef={containerRef}
-                onRequestReposition={autocomplete.repositionPopup}
-                searchBarOffset={isSearchOpen ? 64 : 30}
-                onDismiss={autocompleteClosePopup}
-              />,
-              document.body,
-            )
-          }
+          {/* Autocomplete — owns the hook + popup in its own component so
+              suggestion/selection updates don't re-render Terminal. Mounted
+              unconditionally; it gates the popup on `visible` internally. */}
+          <TerminalAutocomplete
+            termRef={termRef}
+            sessionId={sessionId}
+            hostId={host.id}
+            hostOs={autocompleteHostOs}
+            settings={autocompleteSettings}
+            protocol={host.protocol}
+            getCwd={() => terminalCwdTracker.getRendererCwd() ?? knownCwdRef.current}
+            onAcceptText={(text) => autocompleteAcceptTextRef.current?.(text)}
+            visible={isVisible}
+            themeColors={effectiveTheme.colors}
+            containerRef={containerRef}
+            searchBarOffset={isSearchOpen ? 64 : 30}
+            keyEventRef={autocompleteKeyEventRef}
+            inputRef={autocompleteInputRef}
+            repositionRef={autocompleteRepositionRef}
+            closeRef={autocompleteCloseRef}
+          />
 
           {/* OSC-52 clipboard read prompt */}
           {osc52ReadPromptVisible && (

components/terminal/TerminalAutocomplete.tsx

@@ -0,0 +1,111 @@
+import ReactDOM from "react-dom";
+import type { ComponentProps, RefObject } from "react";
+import type { Terminal as XTerm } from "@xterm/xterm";
+import {
+  useTerminalAutocomplete,
+  AutocompletePopup,
+  type AutocompleteSettings,
+} from "./autocomplete";
+
+type PopupProps = ComponentProps<typeof AutocompletePopup>;
+
+/** A mutable handler ref Terminal hands down for the xterm runtime to call. */
+type HandlerRef<T> = { current: T | undefined };
+
+interface TerminalAutocompleteProps {
+  termRef: RefObject<XTerm | null>;
+  sessionId: string;
+  hostId: string;
+  hostOs: "linux" | "windows" | "macos";
+  settings?: Partial<AutocompleteSettings>;
+  protocol?: string;
+  getCwd?: () => string | undefined;
+  onAcceptText: (text: string) => void;
+  /** Whether this terminal tab is the visible one. */
+  visible: boolean;
+  themeColors: PopupProps["themeColors"];
+  containerRef: PopupProps["containerRef"];
+  searchBarOffset: number;
+  // Handlers exposed back to Terminal so createXTermRuntime can drive them.
+  keyEventRef: HandlerRef<(e: KeyboardEvent) => boolean>;
+  inputRef: HandlerRef<(data: string) => void>;
+  repositionRef: HandlerRef<() => void>;
+  closeRef: HandlerRef<() => void>;
+}
+
+/**
+ * Owns the terminal autocomplete hook and renders its popup.
+ *
+ * Kept as its own component so the frequent autocomplete state updates
+ * (suggestions, selection, live-preview navigation) re-render only this small
+ * subtree rather than the whole Terminal component. The hook's handlers are
+ * surfaced back to Terminal through refs so the xterm runtime can call them.
+ *
+ * Must be mounted unconditionally for the terminal session's lifetime: the hook
+ * records command history on Enter and intercepts completion keys even while no
+ * popup is visible. Visibility only gates the rendered popup, not the hook.
+ */
+export function TerminalAutocomplete({
+  termRef,
+  sessionId,
+  hostId,
+  hostOs,
+  settings,
+  protocol,
+  getCwd,
+  onAcceptText,
+  visible,
+  themeColors,
+  containerRef,
+  searchBarOffset,
+  keyEventRef,
+  inputRef,
+  repositionRef,
+  closeRef,
+}: TerminalAutocompleteProps) {
+  const autocomplete = useTerminalAutocomplete({
+    termRef,
+    sessionId,
+    hostId,
+    hostOs,
+    settings,
+    onAcceptText,
+    protocol,
+    getCwd,
+  });
+
+  // Surface the handlers for runtime wiring. They have stable identities
+  // (useCallback over refs), so assigning during render is cheap and mirrors
+  // the wiring Terminal did inline before this was extracted.
+  keyEventRef.current = autocomplete.handleKeyEvent;
+  inputRef.current = autocomplete.handleInput;
+  repositionRef.current = autocomplete.repositionPopup;
+  closeRef.current = autocomplete.closePopup;
+
+  const { state } = autocomplete;
+  if (!visible || !state.popupVisible || state.suggestions.length === 0) {
+    return null;
+  }
+
+  // Portal to body so the popup escapes the terminal container's overflow.
+  return ReactDOM.createPortal(
+    <AutocompletePopup
+      suggestions={state.suggestions}
+      selectedIndex={state.selectedIndex}
+      position={state.popupPosition}
+      cursorLineTop={state.popupCursorLineTop}
+      cursorLineBottom={state.popupCursorLineBottom}
+      visible={state.popupVisible}
+      expandUpward={state.expandUpward}
+      themeColors={themeColors}
+      onSelect={autocomplete.selectSuggestion}
+      subDirPanels={state.subDirPanels}
+      subDirFocusLevel={state.subDirFocusLevel}
+      containerRef={containerRef}
+      onRequestReposition={autocomplete.repositionPopup}
+      searchBarOffset={searchBarOffset}
+      onDismiss={autocomplete.closePopup}
+    />,
+    document.body,
+  );
+}

components/terminal/autocomplete/useTerminalAutocomplete.ts

@@ -47,6 +47,18 @@ export const DEFAULT_AUTOCOMPLETE_SETTINGS: AutocompleteSettings = {
   fastTypingThresholdMs: 40,
 };
 
+/**
+ * Whether completion work is worth doing — i.e. whether anything would
+ * actually be rendered. With both the popup and ghost text disabled, querying
+ * completions only to discard the result is pure main-thread waste, so callers
+ * skip it entirely.
+ */
+export function shouldQueryCompletions(
+  settings: Pick<AutocompleteSettings, "showPopupMenu" | "showGhostText">,
+): boolean {
+  return settings.showPopupMenu || settings.showGhostText;
+}
+
 /** Shared empty state to avoid creating new objects on every reset */
 const EMPTY_STATE: AutocompleteState = Object.freeze({
   suggestions: [],
@@ -640,6 +652,15 @@ export function useTerminalAutocomplete(
       return;
     }
 
+    // Nothing will be rendered when both the popup and ghost text are off, so
+    // don't run the (potentially expensive) completion query just to throw the
+    // result away. Clear any stale state and bail before touching history,
+    // fig specs, or remote path lookups.
+    if (!shouldQueryCompletions(settingsRef.current)) {
+      clearState();
+      return;
+    }
+
     // Capture version at start — if it changes during async work, discard results
     const version = ++fetchVersionRef.current;
 

components/terminal/completionGate.test.ts

@@ -0,0 +1,25 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { shouldQueryCompletions } from "./autocomplete/useTerminalAutocomplete.ts";
+
+test("queries completions when the popup menu is enabled", () => {
+  assert.equal(
+    shouldQueryCompletions({ showPopupMenu: true, showGhostText: false }),
+    true,
+  );
+});
+
+test("queries completions when ghost text is enabled", () => {
+  assert.equal(
+    shouldQueryCompletions({ showPopupMenu: false, showGhostText: true }),
+    true,
+  );
+});
+
+test("skips completion work when both popup and ghost text are off", () => {
+  assert.equal(
+    shouldQueryCompletions({ showPopupMenu: false, showGhostText: false }),
+    false,
+  );
+});

components/terminal/connectionLogBuffer.test.ts

@@ -0,0 +1,98 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createConnectionLogBuffer } from "./connectionLogBuffer.ts";
+
+test("concatenates appended chunks while under the cap", () => {
+  const buf = createConnectionLogBuffer(100);
+  buf.append("foo");
+  buf.append("bar");
+  buf.append("baz");
+  assert.equal(buf.toString(), "foobarbaz");
+});
+
+test("keeps only the last maxChars, matching slice(-max) semantics", () => {
+  const max = 10;
+  const buf = createConnectionLogBuffer(max);
+  const chunks = ["abcd", "efgh", "ijkl", "mnop"]; // 16 chars total
+  let naive = "";
+  for (const c of chunks) {
+    buf.append(c);
+    naive += c;
+  }
+  assert.equal(buf.toString(), naive.slice(-max));
+  assert.equal(buf.toString().length, max);
+});
+
+test("trims a single chunk larger than the cap to its last maxChars", () => {
+  const buf = createConnectionLogBuffer(5);
+  buf.append("0123456789");
+  assert.equal(buf.toString(), "56789");
+});
+
+test("partial-trims the boundary chunk to keep exactly maxChars", () => {
+  const buf = createConnectionLogBuffer(6);
+  buf.append("abcde"); // 5
+  buf.append("fghij"); // total 10 -> keep last 6 => "efghij"
+  assert.equal(buf.toString(), "efghij");
+});
+
+test("stays correct across many small appends (ring semantics)", () => {
+  const max = 50;
+  const buf = createConnectionLogBuffer(max);
+  let naive = "";
+  for (let i = 0; i < 500; i++) {
+    const chunk = `x${i}-`;
+    buf.append(chunk);
+    naive += chunk;
+  }
+  assert.equal(buf.toString(), naive.slice(-max));
+});
+
+test("reset clears the buffer", () => {
+  const buf = createConnectionLogBuffer(100);
+  buf.append("hello");
+  buf.reset();
+  assert.equal(buf.toString(), "");
+  buf.append("world");
+  assert.equal(buf.toString(), "world");
+});
+
+test("ignores empty appends", () => {
+  const buf = createConnectionLogBuffer(100);
+  buf.append("a");
+  buf.append("");
+  buf.append("b");
+  assert.equal(buf.toString(), "ab");
+});
+
+test("keeps the segment count bounded across many tiny appends", () => {
+  // The whole point of the rewrite: trimming must not walk one array entry
+  // per append. With a blockSize of 10 and a 100-char cap, the buffer should
+  // never hold more than ~ceil(cap/blockSize)+1 segments no matter how many
+  // single-char appends arrive once it's at capacity.
+  const maxChars = 100;
+  const blockSize = 10;
+  const buf = createConnectionLogBuffer(maxChars, blockSize);
+  let naive = "";
+  for (let i = 0; i < 10000; i++) {
+    buf.append("x");
+    naive += "x";
+  }
+  assert.ok(
+    buf.segmentCount() <= Math.ceil(maxChars / blockSize) + 1,
+    `segmentCount ${buf.segmentCount()} exceeded the bound`,
+  );
+  assert.equal(buf.toString(), naive.slice(-maxChars));
+});
+
+test("seals and trims whole blocks with a small blockSize", () => {
+  const buf = createConnectionLogBuffer(10, 4);
+  const chunks = ["abcd", "efgh", "ijkl"]; // 12 chars total
+  let naive = "";
+  for (const c of chunks) {
+    buf.append(c);
+    naive += c;
+  }
+  assert.equal(buf.toString(), naive.slice(-10)); // "cdefghijkl"
+});

components/terminal/connectionLogBuffer.ts

@@ -0,0 +1,94 @@
+/**
+ * A bounded, append-only text buffer that retains only the last `maxChars`
+ * characters — the connection log used for diagnostics/replay.
+ *
+ * The naive implementation (`log += chunk; if (log.length > max) log =
+ * log.slice(-max)`) flattens a ~max-length string on *every* append once the
+ * cap is reached — on the render thread, for every output chunk including each
+ * echoed keystroke.
+ *
+ * Instead, data is coalesced into a small, bounded number of fixed-size blocks
+ * (~`maxChars / blockSize`, e.g. ~16 for the 1 MB cap). New data accumulates in
+ * an open `tail`; once it reaches `blockSize` it is sealed into a block. Trimming
+ * the oldest data therefore only ever drops/slices a handful of blocks — never
+ * one array element per append, which would make trim O(number of appends) and
+ * defeat the purpose. Append is amortized O(chunk); the full string is
+ * materialized only on `toString()` (called rarely, on finalize).
+ */
+export interface ConnectionLogBuffer {
+  append(chunk: string): void;
+  toString(): string;
+  reset(): void;
+  /**
+   * Number of internal string segments currently retained. Exposed for tests
+   * to assert the bounded-memory / bounded-trim property.
+   */
+  segmentCount(): number;
+}
+
+const DEFAULT_BLOCK_SIZE = 64 * 1024;
+
+export function createConnectionLogBuffer(
+  maxChars: number,
+  blockSize: number = DEFAULT_BLOCK_SIZE,
+): ConnectionLogBuffer {
+  let blocks: string[] = []; // sealed blocks, oldest first, each up to ~blockSize
+  let tail = ""; // open block currently being filled (newest data)
+  let total = 0; // total retained length across blocks + tail
+
+  const trim = () => {
+    let overflow = total - maxChars;
+    if (overflow <= 0) return;
+    // Drop/slice whole blocks from the front. `blocks.length` is bounded by
+    // ~maxChars/blockSize, so this shift is O(small constant), not O(appends).
+    while (overflow > 0 && blocks.length > 0) {
+      const head = blocks[0];
+      if (head.length <= overflow) {
+        blocks.shift();
+        total -= head.length;
+        overflow -= head.length;
+      } else {
+        blocks[0] = head.slice(overflow);
+        total -= overflow;
+        overflow = 0;
+      }
+    }
+    // Only reachable when the tail alone exceeds the cap (e.g. blockSize >=
+    // maxChars); keep its last `maxChars` characters.
+    if (overflow > 0) {
+      tail = tail.slice(overflow);
+      total -= overflow;
+    }
+  };
+
+  return {
+    append(chunk: string): void {
+      if (!chunk) return;
+      // A single chunk at/over the cap can only contribute its own tail.
+      if (chunk.length >= maxChars) {
+        blocks = [];
+        tail = chunk.slice(chunk.length - maxChars);
+        total = tail.length;
+        return;
+      }
+      tail += chunk;
+      total += chunk.length;
+      if (tail.length >= blockSize) {
+        blocks.push(tail);
+        tail = "";
+      }
+      if (total > maxChars) trim();
+    },
+    toString(): string {
+      return blocks.length > 0 ? blocks.join("") + tail : tail;
+    },
+    reset(): void {
+      blocks = [];
+      tail = "";
+      total = 0;
+    },
+    segmentCount(): number {
+      return blocks.length + (tail.length > 0 ? 1 : 0);
+    },
+  };
+}

components/terminal/runtime/createTerminalSessionStarters.ts

@@ -27,6 +27,7 @@ import {
   syncPromptLineBreakState,
   type PromptLineBreakState,
 } from "./promptLineBreak";
+import { createOutputFlowController, type OutputFlowController } from "./outputFlowController";
 
 /**
  * Per-connection token for stale-timer detection. The renderer reuses the
@@ -97,6 +98,8 @@ type TerminalBackendApi = {
   ) => (() => void) | undefined;
   writeToSession: (sessionId: string, data: string, options?: { automated?: boolean }) => void;
   resizeSession: (sessionId: string, cols: number, rows: number) => void;
+  /** Pause/resume the source stream for output back-pressure (optional). */
+  setSessionFlowPaused?: (sessionId: string, paused: boolean) => void;
 };
 
 export type PendingAuth = {
@@ -251,6 +254,38 @@ const enqueueTerminalWrite = (
   }
 };
 
+// Output back-pressure. Without this the renderer can't slow a flooding source,
+// so a busy stream grows the write queue and xterm's buffer unbounded. The
+// controller tracks bytes received-but-not-yet-rendered and asks the main
+// process to pause/resume the session's source stream at these watermarks.
+const FLOW_HIGH_WATER_MARK = 256 * 1024; // pause the source above ~256KB backlog
+const FLOW_LOW_WATER_MARK = 64 * 1024; // resume once drained to ~64KB
+
+const terminalFlowControllers = new WeakMap<XTerm, OutputFlowController>();
+
+const getFlowController = (
+  ctx: TerminalSessionStartersContext,
+  term: XTerm,
+): OutputFlowController => {
+  let controller = terminalFlowControllers.get(term);
+  if (!controller) {
+    controller = createOutputFlowController({
+      highWaterMark: FLOW_HIGH_WATER_MARK,
+      lowWaterMark: FLOW_LOW_WATER_MARK,
+      onPause: () => {
+        const id = ctx.sessionRef.current;
+        if (id) ctx.terminalBackend.setSessionFlowPaused?.(id, true);
+      },
+      onResume: () => {
+        const id = ctx.sessionRef.current;
+        if (id) ctx.terminalBackend.setSessionFlowPaused?.(id, false);
+      },
+    });
+    terminalFlowControllers.set(term, controller);
+  }
+  return controller;
+};
+
 const writeTerminalLine = (
   ctx: TerminalSessionStartersContext,
   term: XTerm,
@@ -268,6 +303,8 @@ const writeSessionData = (
   term: XTerm,
   data: string,
 ) => {
+  const flow = getFlowController(ctx, term);
+  flow.received(data.length);
   enqueueTerminalWrite(term, (done) => {
     const settings = ctx.terminalSettingsRef?.current ?? ctx.terminalSettings;
     const forcePromptNewLine = settings?.forcePromptNewLine ?? false;
@@ -301,6 +338,8 @@ const writeSessionData = (
         handleTerminalOutputAutoScroll(ctx, term);
       }
       done();
+      // Acknowledge the chunk so back-pressure can ease once xterm catches up.
+      flow.written(data.length);
     };
 
     term.write(displayData, afterWrite);
@@ -320,6 +359,8 @@ const attachSessionToTerminal = (
   },
 ) => {
   ctx.sessionRef.current = id;
+  // Clear any stale back-pressure accounting from a prior session on this term.
+  getFlowController(ctx, term).reset();
   ctx.onSessionAttached?.(id);
 
   ctx.disposeDataRef.current = ctx.terminalBackend.onSessionData(id, (chunk) => {
@@ -1204,6 +1245,7 @@ export const createTerminalSessionStarters = (ctx: TerminalSessionStartersContex
       });
 
       ctx.sessionRef.current = id;
+      getFlowController(ctx, term).reset();
       ctx.disposeDataRef.current = ctx.terminalBackend.onSessionData(id, (chunk) => {
         writeSessionData(ctx, term, chunk);
         if (!ctx.hasConnectedRef.current) {

components/terminal/runtime/outputFlowController.test.ts

@@ -0,0 +1,89 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createOutputFlowController } from "./outputFlowController.ts";
+
+function make(high = 100, low = 30) {
+  const events: string[] = [];
+  const controller = createOutputFlowController({
+    highWaterMark: high,
+    lowWaterMark: low,
+    onPause: () => events.push("pause"),
+    onResume: () => events.push("resume"),
+  });
+  return { controller, events };
+}
+
+test("does not pause while below the high watermark", () => {
+  const { controller, events } = make(100, 30);
+  controller.received(50);
+  controller.received(49); // 99 < 100
+  assert.deepEqual(events, []);
+  assert.equal(controller.isPaused(), false);
+});
+
+test("pauses once when crossing the high watermark", () => {
+  const { controller, events } = make(100, 30);
+  controller.received(60);
+  controller.received(60); // 120 >= 100 -> pause
+  assert.deepEqual(events, ["pause"]);
+  assert.equal(controller.isPaused(), true);
+  // Further received while already paused must not re-fire pause.
+  controller.received(100);
+  assert.deepEqual(events, ["pause"]);
+});
+
+test("resumes once when draining to at/below the low watermark", () => {
+  const { controller, events } = make(100, 30);
+  controller.received(120); // pause
+  controller.written(50); // 70 still > 30, no resume
+  assert.deepEqual(events, ["pause"]);
+  controller.written(50); // 20 <= 30 -> resume
+  assert.deepEqual(events, ["pause", "resume"]);
+  assert.equal(controller.isPaused(), false);
+});
+
+test("does not resume when still above the low watermark", () => {
+  const { controller, events } = make(100, 30);
+  controller.received(120); // pause
+  controller.written(80); // 40 > 30
+  assert.deepEqual(events, ["pause"]);
+  assert.equal(controller.isPaused(), true);
+});
+
+test("never lets pending go negative", () => {
+  const { controller } = make(100, 30);
+  controller.received(10);
+  controller.written(50); // over-written
+  assert.equal(controller.pendingBytes(), 0);
+});
+
+test("supports repeated pause/resume cycles", () => {
+  const { controller, events } = make(100, 30);
+  controller.received(120); // pause
+  controller.written(120); // resume (0 <= 30)
+  controller.received(120); // pause again
+  controller.written(120); // resume again
+  assert.deepEqual(events, ["pause", "resume", "pause", "resume"]);
+});
+
+test("reset clears state without firing callbacks", () => {
+  const { controller, events } = make(100, 30);
+  controller.received(120); // pause
+  controller.reset();
+  assert.equal(controller.isPaused(), false);
+  assert.equal(controller.pendingBytes(), 0);
+  assert.deepEqual(events, ["pause"]); // reset itself is silent
+  // A fresh cycle works after reset.
+  controller.received(120);
+  assert.deepEqual(events, ["pause", "pause"]);
+});
+
+test("ignores non-positive amounts", () => {
+  const { controller, events } = make(100, 30);
+  controller.received(0);
+  controller.written(0);
+  controller.received(-5);
+  assert.equal(controller.pendingBytes(), 0);
+  assert.deepEqual(events, []);
+});

components/terminal/runtime/outputFlowController.ts

@@ -0,0 +1,73 @@
+/**
+ * Watermark-based flow control for terminal output.
+ *
+ * SSH/PTY output has no back-pressure by default: the source streams as fast as
+ * it can, the main process forwards it over IPC, and the renderer queues every
+ * chunk into xterm. When output outpaces rendering (e.g. `cat` of a big file, a
+ * noisy build, `tail -f`, `yes`), the renderer-side backlog and xterm's internal
+ * buffer grow without bound — memory climbs and the whole UI, typing included,
+ * janks.
+ *
+ * This tracks bytes that have been received but not yet acknowledged by xterm's
+ * write callback. When the backlog crosses `highWaterMark` it asks the caller to
+ * pause the source; once it drains back to `lowWaterMark` it asks to resume. The
+ * hysteresis gap avoids rapid pause/resume flapping. During interactive use the
+ * backlog hovers near zero, so this never engages.
+ */
+export interface OutputFlowController {
+  /** Account bytes handed to xterm (call when a chunk is received). */
+  received(bytes: number): void;
+  /** Account bytes whose xterm write callback has fired. */
+  written(bytes: number): void;
+  /** Clear all state (e.g. on a fresh session attach). Fires no callbacks. */
+  reset(): void;
+  pendingBytes(): number;
+  isPaused(): boolean;
+}
+
+export interface OutputFlowControllerOptions {
+  highWaterMark: number;
+  lowWaterMark: number;
+  /** Asked to pause the source when the backlog crosses the high watermark. */
+  onPause: () => void;
+  /** Asked to resume the source when the backlog drains to the low watermark. */
+  onResume: () => void;
+}
+
+export function createOutputFlowController(
+  options: OutputFlowControllerOptions,
+): OutputFlowController {
+  const { highWaterMark, lowWaterMark, onPause, onResume } = options;
+  let pending = 0;
+  let paused = false;
+
+  return {
+    received(bytes: number): void {
+      if (bytes <= 0) return;
+      pending += bytes;
+      if (!paused && pending >= highWaterMark) {
+        paused = true;
+        onPause();
+      }
+    },
+    written(bytes: number): void {
+      if (bytes <= 0) return;
+      pending -= bytes;
+      if (pending < 0) pending = 0;
+      if (paused && pending <= lowWaterMark) {
+        paused = false;
+        onResume();
+      }
+    },
+    reset(): void {
+      pending = 0;
+      paused = false;
+    },
+    pendingBytes(): number {
+      return pending;
+    },
+    isPaused(): boolean {
+      return paused;
+    },
+  };
+}

electron/bridges/ptyOutputBuffer.cjs

@@ -0,0 +1,63 @@
+"use strict";
+
+/**
+ * Coalescing output buffer for terminal/PTY data on its way to the renderer.
+ *
+ * Incoming shell data is accumulated and delivered to `sendFn` in batches to
+ * keep IPC traffic down, but the batch is flushed on the *next event-loop turn*
+ * (`setImmediate`) rather than after a fixed time interval. A fixed interval
+ * adds that whole interval as latency to interactive echo — every keystroke
+ * round-trips through the buffer and waits out the timer before it can paint.
+ * Turn-based flushing coalesces only the data that has already arrived in the
+ * current turn, so a single echoed keystroke is forwarded almost immediately
+ * while bursts of output still collapse into one send.
+ *
+ * A byte cap still forces an immediate, synchronous flush so a flood of output
+ * can't grow the buffer without bound between turns.
+ *
+ * @param {(data: string) => void} sendFn delivers an accumulated batch
+ * @param {{ maxBufferSize?: number }} [options]
+ * @returns {{ bufferData: (data: string) => void, flush: () => void }}
+ */
+function createPtyOutputBuffer(sendFn, options = {}) {
+  const maxBufferSize = options.maxBufferSize ?? 16384; // 16KB
+
+  let dataBuffer = "";
+  let scheduled = null;
+
+  const cancelScheduled = () => {
+    if (scheduled) {
+      clearImmediate(scheduled);
+      scheduled = null;
+    }
+  };
+
+  const flushNow = () => {
+    scheduled = null;
+    if (dataBuffer.length > 0) {
+      const pending = dataBuffer;
+      dataBuffer = "";
+      sendFn(pending);
+    }
+  };
+
+  const bufferData = (data) => {
+    dataBuffer += data;
+    if (dataBuffer.length >= maxBufferSize) {
+      // Large enough to ship right now — don't wait for the turn flush.
+      cancelScheduled();
+      flushNow();
+    } else if (!scheduled) {
+      scheduled = setImmediate(flushNow);
+    }
+  };
+
+  const flush = () => {
+    cancelScheduled();
+    flushNow();
+  };
+
+  return { bufferData, flush };
+}
+
+module.exports = { createPtyOutputBuffer };

electron/bridges/ptyOutputBuffer.test.cjs

@@ -0,0 +1,90 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { createPtyOutputBuffer } = require("./ptyOutputBuffer.cjs");
+
+/** Resolve after one event-loop turn (immediates have run). */
+const tick = () => new Promise((resolve) => setImmediate(resolve));
+
+test("coalesces data buffered within the same turn into a single send", async () => {
+  const sends = [];
+  const buffer = createPtyOutputBuffer((data) => sends.push(data));
+
+  buffer.bufferData("a");
+  buffer.bufferData("b");
+  buffer.bufferData("c");
+
+  // Nothing is sent synchronously while still in the same turn.
+  assert.equal(sends.length, 0);
+
+  await tick();
+
+  assert.deepEqual(sends, ["abc"]);
+});
+
+test("flushes within a single event-loop turn (not on a fixed delay)", async () => {
+  const sends = [];
+  const buffer = createPtyOutputBuffer((data) => sends.push(data));
+
+  buffer.bufferData("x");
+
+  // A fixed-interval (e.g. 8ms) buffer would NOT have flushed after one
+  // immediate turn. Turn-based flushing must have delivered it by now.
+  await tick();
+
+  assert.deepEqual(sends, ["x"]);
+});
+
+test("flushes immediately and synchronously once the size cap is reached", async () => {
+  const sends = [];
+  const buffer = createPtyOutputBuffer((data) => sends.push(data), {
+    maxBufferSize: 4,
+  });
+
+  buffer.bufferData("ab");
+  assert.equal(sends.length, 0); // under cap, still pending
+
+  buffer.bufferData("cd"); // now "abcd" hits the 4-byte cap
+
+  // Cap flush happens synchronously, without waiting for the turn.
+  assert.deepEqual(sends, ["abcd"]);
+
+  // The pending turn flush must have been cancelled — no empty/duplicate send.
+  await tick();
+  assert.deepEqual(sends, ["abcd"]);
+});
+
+test("flush() forces a synchronous send and cancels the pending turn", async () => {
+  const sends = [];
+  const buffer = createPtyOutputBuffer((data) => sends.push(data));
+
+  buffer.bufferData("hello");
+  buffer.flush();
+
+  assert.deepEqual(sends, ["hello"]);
+
+  await tick();
+  assert.deepEqual(sends, ["hello"]); // not sent twice
+});
+
+test("flush() with an empty buffer does not send", async () => {
+  const sends = [];
+  const buffer = createPtyOutputBuffer((data) => sends.push(data));
+
+  buffer.flush();
+
+  assert.equal(sends.length, 0);
+});
+
+test("keeps batching after a flush", async () => {
+  const sends = [];
+  const buffer = createPtyOutputBuffer((data) => sends.push(data));
+
+  buffer.bufferData("first");
+  await tick();
+
+  buffer.bufferData("second");
+  await tick();
+
+  assert.deepEqual(sends, ["first", "second"]);
+});

electron/bridges/sshBridge.cjs

@@ -17,6 +17,7 @@ const passphraseHandler = require("./passphraseHandler.cjs");
 const hostKeyVerifier = require("./hostKeyVerifier.cjs");
 const { createProxySocket } = require("./proxyUtils.cjs");
 const { attachX11Forwarding } = require("./x11Forwarding.cjs");
+const { createPtyOutputBuffer } = require("./ptyOutputBuffer.cjs");
 const {
   buildAuthHandler,
   createKeyboardInteractiveHandler,
@@ -1287,35 +1288,14 @@ async function startSSHSession(event, options) {
               });
             }
 
-            // Data buffering for reduced IPC overhead
-            let dataBuffer = '';
-            let flushTimeout = null;
-            const FLUSH_INTERVAL = 8; // ms - flush every 8ms for ~120fps equivalent
-            const MAX_BUFFER_SIZE = 16384; // 16KB - flush immediately if buffer gets too large
-
-            const flushBuffer = () => {
-              if (dataBuffer.length > 0) {
-                const contents = event.sender;
-                safeSend(contents, "netcatty:data", { sessionId, data: dataBuffer });
-                dataBuffer = '';
-              }
-              flushTimeout = null;
-            };
-
-            const bufferData = (data) => {
-              dataBuffer += data;
-              // Immediate flush for large chunks
-              if (dataBuffer.length >= MAX_BUFFER_SIZE) {
-                if (flushTimeout) {
-                  clearTimeout(flushTimeout);
-                  flushTimeout = null;
-                }
-                flushBuffer();
-              } else if (!flushTimeout) {
-                // Schedule flush
-                flushTimeout = setTimeout(flushBuffer, FLUSH_INTERVAL);
-              }
-            };
+            // Coalesce shell output and deliver it to the renderer on the next
+            // event-loop turn (see ptyOutputBuffer) rather than on a fixed timer,
+            // so interactive echo isn't held back by the batch interval. A size
+            // cap still forces an immediate flush for bursts of output.
+            const { bufferData, flush: flushBuffer } = createPtyOutputBuffer((data) => {
+              const contents = event.sender;
+              safeSend(contents, "netcatty:data", { sessionId, data });
+            });
 
             const sshZmodemSentry = createZmodemSentry({
               sessionId,
@@ -1392,10 +1372,8 @@ async function startSSHSession(event, options) {
             });
 
             stream.on("close", () => {
-              // Always flush buffered data regardless of session state
-              if (flushTimeout) {
-                clearTimeout(flushTimeout);
-              }
+              // Always flush buffered data regardless of session state.
+              // flushBuffer() cancels any pending scheduled flush internally.
               flushBuffer();
               sessionLogStreamManager.stopStream(sessionId, logStreamToken);
               if (detachX11Forwarding) {

electron/bridges/terminalBridge.cjs

@@ -25,6 +25,7 @@ const moshHandshake = require("./moshHandshake.cjs");
 const tempDirBridge = require("./tempDirBridge.cjs");
 const { createTelnetAutoLogin } = require("./telnetAutoLogin.cjs");
 const telnetProtocol = require("./telnetProtocol.cjs");
+const { createPtyOutputBuffer } = require("./ptyOutputBuffer.cjs");
 
 const execFileAsync = promisify(execFile);
 
@@ -80,51 +81,6 @@ function init(deps) {
   electronModule = deps.electronModule;
 }
 
-/**
- * Create an 8ms/16KB PTY data buffer for reduced IPC overhead.
- * Mirrors the SSH stream buffering strategy in sshBridge.cjs.
- * @param {Function} sendFn - called with the accumulated string to deliver
- * @returns {{ bufferData: (data: string) => void, flush: () => void }}
- */
-function createPtyBuffer(sendFn) {
-  const FLUSH_INTERVAL = 8;      // ms - flush every 8ms (~120fps equivalent)
-  const MAX_BUFFER_SIZE = 16384; // 16KB - flush immediately if buffer grows too large
-
-  let dataBuffer = '';
-  let flushTimeout = null;
-
-  const flushBuffer = () => {
-    if (dataBuffer.length > 0) {
-      sendFn(dataBuffer);
-      dataBuffer = '';
-    }
-    flushTimeout = null;
-  };
-
-  const flush = () => {
-    if (flushTimeout) {
-      clearTimeout(flushTimeout);
-      flushTimeout = null;
-    }
-    flushBuffer();
-  };
-
-  const bufferData = (data) => {
-    dataBuffer += data;
-    if (dataBuffer.length >= MAX_BUFFER_SIZE) {
-      if (flushTimeout) {
-        clearTimeout(flushTimeout);
-        flushTimeout = null;
-      }
-      flushBuffer();
-    } else if (!flushTimeout) {
-      flushTimeout = setTimeout(flushBuffer, FLUSH_INTERVAL);
-    }
-  };
-
-  return { bufferData, flush };
-}
-
 /**
  * Locate an executable on POSIX systems by name.
  *
@@ -454,7 +410,7 @@ function startLocalSession(event, payload) {
     });
   }
 
-  const { bufferData: bufferLocalData, flush: flushLocal } = createPtyBuffer((data) => {
+  const { bufferData: bufferLocalData, flush: flushLocal } = createPtyOutputBuffer((data) => {
     const contents = electronModule.webContents.fromId(session.webContentsId);
     contents?.send("netcatty:data", { sessionId, data });
   });
@@ -662,7 +618,7 @@ async function startTelnetSession(event, options) {
     const telnetDecoderRef = { current: iconv.getDecoder(initialTelnetEncoding) };
 
     const telnetWebContentsId = event.sender.id;
-    const { bufferData: bufferTelnetData, flush: flushTelnet } = createPtyBuffer((data) => {
+    const { bufferData: bufferTelnetData, flush: flushTelnet } = createPtyOutputBuffer((data) => {
       const contents = electronModule.webContents.fromId(telnetWebContentsId);
       contents?.send("netcatty:data", { sessionId, data });
     });
@@ -1189,7 +1145,7 @@ async function startMoshSessionViaHandshake(event, options, { bareClient, sshExe
   // it to scope its stopStream call.
   session.logStreamToken = logStreamToken;
 
-  const { bufferData, flush } = createPtyBuffer((data) => {
+  const { bufferData, flush } = createPtyOutputBuffer((data) => {
     const contents = electronModule.webContents.fromId(session.webContentsId);
     contents?.send("netcatty:data", { sessionId, data });
   });
@@ -1593,6 +1549,31 @@ function writeToSession(event, payload) {
   }
 }
 
+/**
+ * Pause or resume a session's source stream for output back-pressure.
+ * The renderer asks for this when its write backlog crosses a watermark, so a
+ * flooding source can't outrun the terminal renderer. Works across session
+ * kinds: ssh2 channel (stream), node-pty (proc), telnet socket, serial port —
+ * all expose pause()/resume().
+ */
+function setSessionFlowPaused(event, payload) {
+  const session = sessions.get(payload.sessionId);
+  if (!session) return;
+  const target = session.stream || session.proc || session.socket || session.serialPort;
+  if (!target) return;
+  try {
+    if (payload.paused) {
+      target.pause?.();
+    } else {
+      target.resume?.();
+    }
+  } catch (err) {
+    if (err?.code !== 'EPIPE' && err?.code !== 'ERR_STREAM_DESTROYED') {
+      console.warn("Flow control toggle failed", err);
+    }
+  }
+}
+
 /**
  * Resize a session terminal
  */
@@ -1707,6 +1688,7 @@ function registerHandlers(ipcMain) {
   ipcMain.handle("netcatty:terminal:setEncoding", setSessionEncoding);
   ipcMain.on("netcatty:write", writeToSession);
   ipcMain.on("netcatty:resize", resizeSession);
+  ipcMain.on("netcatty:flow", setSessionFlowPaused);
   ipcMain.on("netcatty:close", closeSession);
 }
 
@@ -1892,6 +1874,7 @@ module.exports = {
   listSerialPorts,
   writeToSession,
   resizeSession,
+  setSessionFlowPaused,
   closeSession,
   cleanupAllSessions,
   getDefaultShell,

electron/preload.cjs

@@ -669,6 +669,9 @@ const api = {
   resizeSession: (sessionId, cols, rows) => {
     ipcRenderer.send("netcatty:resize", { sessionId, cols, rows });
   },
+  setSessionFlowPaused: (sessionId, paused) => {
+    ipcRenderer.send("netcatty:flow", { sessionId, paused: Boolean(paused) });
+  },
   closeSession: (sessionId) => {
     ipcRenderer.send("netcatty:close", { sessionId });
   },

eslint.config.js

@@ -3,11 +3,16 @@ import tsParser from "@typescript-eslint/parser";
 import tsPlugin from "@typescript-eslint/eslint-plugin";
 import unusedImports from "eslint-plugin-unused-imports";
 import reactHooks from "eslint-plugin-react-hooks";
+import globals from "globals";
 
 export default [
-  js.configs.recommended,
+  // The recommended preset has no file scope of its own, so scope it off all of
+  // electron/ — that main-process tree is historically unlinted. The bridges
+  // get a focused rule set in the dedicated block at the end of this config;
+  // every other electron/ file matches no config and stays unlinted as before.
+  { ...js.configs.recommended, ignores: ["electron/**"] },
   {
-    ignores: ["node_modules/**", "dist/**", "electron/**", "scripts/**", "public/monaco/**", ".github/**", ".claude/**", "release/**", ".worktrees/**"],
+    ignores: ["node_modules/**", "dist/**", "scripts/**", "public/monaco/**", ".github/**", ".claude/**", "release/**", ".worktrees/**"],
   },
   {
     files: ["**/*.{ts,tsx}"],
@@ -168,4 +173,26 @@ export default [
       ],
     },
   },
+  {
+    // Electron main-process bridges are CommonJS and were historically excluded
+    // from linting. Lint them for undefined references only — the cheap,
+    // high-value guard against e.g. a removed variable still referenced
+    // elsewhere. (The TS config disables no-undef because the type-checker
+    // already covers it there; these .cjs files have no such safety net.)
+    files: ["electron/bridges/**/*.cjs"],
+    languageOptions: {
+      ecmaVersion: "latest",
+      sourceType: "commonjs",
+      globals: globals.node,
+    },
+    linterOptions: {
+      // Only no-undef is enabled here, so pre-existing eslint-disable comments
+      // for other rules (no-console, no-control-regex, …) would all report as
+      // "unused". Don't flag them — they stay valid for future rule additions.
+      reportUnusedDisableDirectives: "off",
+    },
+    rules: {
+      "no-undef": "error",
+    },
+  },
 ];

global.d.ts

@@ -323,6 +323,7 @@ declare global {
     setSessionEncoding?(sessionId: string, encoding: string): Promise<{ ok: boolean; encoding: string }>;
     writeToSession(sessionId: string, data: string, options?: { automated?: boolean }): void;
     resizeSession(sessionId: string, cols: number, rows: number): void;
+    setSessionFlowPaused(sessionId: string, paused: boolean): void;
     closeSession(sessionId: string): void;
     // ZMODEM file transfer
     onZmodemEvent?(