nebula-notebook 0.1.1 → 0.2.1

package/node-server/dist/terminal/agent-registry.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * Agent registry — the server-side ledger of agent sessions (Claude Code /
+ * Codex CLIs running inside terminal ptys).
+ *
+ * Agents are project-scoped (keyed by the working directory they were
+ * launched in) and decoupled from notebooks: switching notebooks never kills
+ * or switches an agent; the user does, through the agent manager. Records
+ * persist to disk so agents survive as *resumable* entities even when their
+ * pty dies (browser gone, server restart, user hibernates them): the CLI's
+ * own on-disk trajectory (`claude --resume <id>` / `codex resume`) can
+ * reconstruct the conversation — the registry just remembers what exists,
+ * where, and how to revive it. The client owns launch/revive command
+ * construction (it knows about remote-agent mode); the server owns truth
+ * about what is live.
+ *
+ * States: 'live' (pty exists) → 'hibernated' (pty gone, trajectory on disk).
+ * All records load as 'hibernated' on boot — ptys never survive a restart.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentRegistry = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const pty_manager_1 = require("./pty-manager");
+const STATE_FILE = process.env.NEBULA_AGENTS_FILE || path.join(os.homedir(), '.nebula', 'agents.json');
+const MAX_RECORDS = 50; // oldest hibernated records beyond this are dropped
+class AgentRegistry {
+    records = new Map();
+    exitUnsubs = new Map();
+    loaded = false;
+    ensureLoaded() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        try {
+            if (fs.existsSync(STATE_FILE)) {
+                const list = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+                for (const r of list) {
+                    if (!r?.terminalId)
+                        continue;
+                    // Ptys never survive a server restart — everything reloads hibernated.
+                    r.state = 'hibernated';
+                    this.records.set(r.terminalId, r);
+                }
+            }
+        }
+        catch (err) {
+            console.error('[AgentRegistry] failed to load state:', err);
+        }
+    }
+    persist() {
+        try {
+            const dir = path.dirname(STATE_FILE);
+            fs.mkdirSync(dir, { recursive: true });
+            const all = [...this.records.values()].sort((a, b) => b.lastLaunchAt - a.lastLaunchAt);
+            const live = all.filter((r) => r.state === 'live');
+            const hibernated = all.filter((r) => r.state !== 'live').slice(0, MAX_RECORDS - live.length);
+            const tmp = `${STATE_FILE}.tmp`;
+            fs.writeFileSync(tmp, JSON.stringify([...live, ...hibernated], null, 2));
+            fs.renameSync(tmp, STATE_FILE);
+        }
+        catch (err) {
+            console.error('[AgentRegistry] failed to persist state:', err);
+        }
+    }
+    /**
+     * Register (or re-register on revive) an agent launched in a terminal.
+     * MERGE semantics: fields the caller didn't supply NEVER overwrite stored
+     * truth — a resume relaunch that doesn't know the sessionId must not erase
+     * the registry's copy (that id is the conversation; losing it downgrades
+     * every later Continue to a picker).
+     */
+    register(rec) {
+        this.ensureLoaded();
+        const existing = this.records.get(rec.terminalId);
+        const record = {
+            ...existing,
+            ...rec,
+            sessionId: rec.sessionId ?? existing?.sessionId,
+            mirrorSlug: rec.mirrorSlug ?? existing?.mirrorSlug,
+            launchedFrom: rec.launchedFrom ?? existing?.launchedFrom,
+            state: 'live',
+            createdAt: existing?.createdAt ?? Date.now(),
+            lastLaunchAt: Date.now(),
+        };
+        this.records.set(rec.terminalId, record);
+        // When the pty dies for any reason (user exits the CLI and closes the
+        // terminal, hibernate, server-side kill), the agent is not gone — its
+        // trajectory is on disk. Mark it hibernated, ready to revive.
+        this.exitUnsubs.get(rec.terminalId)?.();
+        const unsub = pty_manager_1.ptyManager.addExitListener(rec.terminalId, () => {
+            const r = this.records.get(rec.terminalId);
+            if (r && r.state === 'live') {
+                r.state = 'hibernated';
+                this.persist();
+            }
+            this.exitUnsubs.delete(rec.terminalId);
+        });
+        this.exitUnsubs.set(rec.terminalId, unsub);
+        // SERVER-SIDE liveness: the pty stream passes through this process, so the
+        // agent-alive state machine lives HERE, not in whichever browser happens to
+        // be attached. TUI teardown with no re-init within the grace window means
+        // the agent exited to the shell — the record flips to 'hibernated' even
+        // though the pty lives on (revive types the resume command into it).
+        this.watchLiveness(rec.terminalId);
+        this.persist();
+        return record;
+    }
+    static TUI_INIT_RE = /\x1b\[\?(1049|1004|1000|1002|1003)h/;
+    static TUI_TEARDOWN_RE = /\x1b\[\?(1049|1004|1000|1002|1003)l/;
+    dataUnsubs = new Map();
+    graceTimers = new Map();
+    watchLiveness(terminalId) {
+        this.dataUnsubs.get(terminalId)?.();
+        const unsub = pty_manager_1.ptyManager.addDataListener(terminalId, (chunk) => {
+            this.observeOutput(terminalId, chunk);
+        });
+        if (unsub)
+            this.dataUnsubs.set(terminalId, unsub);
+    }
+    /** Feed pty output through the liveness machine (public for tests). */
+    observeOutput(terminalId, chunk) {
+        const r = this.records.get(terminalId);
+        if (!r)
+            return;
+        if (AgentRegistry.TUI_INIT_RE.test(chunk)) {
+            const t = this.graceTimers.get(terminalId);
+            if (t) {
+                clearTimeout(t);
+                this.graceTimers.delete(terminalId);
+            }
+            if (r.state !== 'live') {
+                r.state = 'live';
+                r.lastLaunchAt = Date.now();
+                this.persist();
+            }
+            return;
+        }
+        if (AgentRegistry.TUI_TEARDOWN_RE.test(chunk) && r.state === 'live' && !this.graceTimers.has(terminalId)) {
+            this.graceTimers.set(terminalId, setTimeout(() => {
+                this.graceTimers.delete(terminalId);
+                const rec = this.records.get(terminalId);
+                if (rec && rec.state === 'live') {
+                    rec.state = 'hibernated'; // agent exited; pty may still be a plain shell
+                    this.persist();
+                }
+            }, 2000));
+        }
+    }
+    /** List all agents, reconciling 'live' against actual pty existence. */
+    list() {
+        this.ensureLoaded();
+        for (const r of this.records.values()) {
+            if (r.state === 'live' && !pty_manager_1.ptyManager.get(r.terminalId)) {
+                r.state = 'hibernated';
+            }
+        }
+        return [...this.records.values()].sort((a, b) => b.lastLaunchAt - a.lastLaunchAt);
+    }
+    /**
+     * list() plus process-table facts for every record whose pty exists:
+     * - `busy`: the pty's shell has a live child — SOMETHING is running there.
+     *   Crucially reported on HIBERNATED records too: the TUI-stream liveness
+     *   machine can mis-score (an agent resumed by hand never re-registers), and
+     *   a client that trusts 'hibernated' then types a launch command straight
+     *   into the running TUI's input box (lab report: a live codex politely
+     *   declined to run the pasted ssh line). The process table is authoritative.
+     * - `idleShell` on live records: the inverse — 'live' but nothing running
+     *   (a hung-then-dead ssh hop leaves exactly this; a dead transport emits
+     *   no teardown, so only the process table can see it).
+     * Unknown checks claim nothing.
+     */
+    async listEnriched() {
+        return Promise.all(this.list().map(async (r) => {
+            if (!pty_manager_1.ptyManager.get(r.terminalId))
+                return r;
+            const hasChild = await pty_manager_1.ptyManager.hasLiveChild(r.terminalId);
+            if (hasChild === null)
+                return r;
+            return r.state === 'live'
+                ? { ...r, idleShell: !hasChild, busy: hasChild }
+                : { ...r, busy: hasChild };
+        }));
+    }
+    /** Hibernate: close the pty; the record (and on-disk trajectory) remain. */
+    hibernate(terminalId) {
+        this.ensureLoaded();
+        const r = this.records.get(terminalId);
+        if (!r)
+            return false;
+        if (pty_manager_1.ptyManager.get(terminalId))
+            pty_manager_1.ptyManager.kill(terminalId); // exit listener marks hibernated
+        r.state = 'hibernated';
+        this.persist();
+        return true;
+    }
+    /** Forget the agent entirely (pty closed; registry record removed). */
+    remove(terminalId) {
+        this.ensureLoaded();
+        const r = this.records.get(terminalId);
+        if (!r)
+            return false;
+        this.exitUnsubs.get(terminalId)?.();
+        this.exitUnsubs.delete(terminalId);
+        if (pty_manager_1.ptyManager.get(terminalId))
+            pty_manager_1.ptyManager.kill(terminalId);
+        this.records.delete(terminalId);
+        this.persist();
+        return true;
+    }
+}
+exports.agentRegistry = new AgentRegistry();

package/node-server/dist/terminal/binding-store.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Terminal Bindings
+ *
+ * A notebook has exactly one binding per plane (shell / agent) that decides
+ * which named pty its panel attaches to — attach is always deterministic and
+ * duplicates are impossible by construction (get-or-create on the name).
+ *
+ * Scopes:
+ *   server   → the per-server shared terminal (well-known name `srv-main`)
+ *   project  → shared by all notebooks in the same directory (`proj-<hash>-<dir>`)
+ *   notebook → private to the notebook (`nb-<hash>-<plane>-<slug>` — the exact
+ *              scheme the panel has always used, so pre-binding ptys with live
+ *              jobs are grandfathered in, not orphaned)
+ *   named    → a user-chosen name (normalized like every pty name)
+ *
+ * Persisted as JSON at ~/.nebula/terminal-bindings.json so a notebook's
+ * binding follows it across browsers (same pattern as the agent registry).
+ */
+export type TerminalPlane = 'shell' | 'agent';
+export type TerminalBindingScope = 'server' | 'project' | 'notebook' | 'named';
+export interface TerminalBinding {
+    filePath: string;
+    plane: TerminalPlane;
+    scope: TerminalBindingScope;
+    /** Resolved pty name the panel attaches to (get-or-create). Null for
+     *  agent/project bindings — the client derives it from the chosen workdir. */
+    name: string | null;
+    /** The raw user-supplied name for scope 'named'. */
+    customName?: string;
+    updatedAt: number;
+}
+/** Well-known name of the per-server shared shell. */
+export declare const SHARED_SHELL_NAME = "srv-main";
+/** Well-known name of the per-server shared AGENT terminal. */
+export declare const SHARED_AGENT_NAME = "agent-srv";
+/**
+ * Resolve a (plane, scope) to the pty name it binds to. Pure — no I/O.
+ *
+ * Agent-plane specifics: names double as agent-record keys. `project` returns
+ * null — the workdir is a client-side choice (workdir chip), so the client
+ * derives the legacy `agent-<hash>-<slug>` name from it (which is also why
+ * every pre-binding record keeps working). Named agents get an `agent-`
+ * prefix so they can never collide with a shell terminal of the same name.
+ */
+export declare function resolveBindingName(plane: TerminalPlane, scope: TerminalBindingScope, filePath: string, customName?: string): string | null;
+export declare class TerminalBindingStore {
+    private file;
+    private bindings;
+    constructor(file?: string);
+    private key;
+    private load;
+    private persist;
+    get(filePath: string, plane: TerminalPlane): TerminalBinding | null;
+    set(filePath: string, plane: TerminalPlane, scope: TerminalBindingScope, customName?: string): TerminalBinding;
+    delete(filePath: string, plane: TerminalPlane): void;
+}
+export declare const terminalBindings: TerminalBindingStore;

package/node-server/dist/terminal/pty-manager.d.ts

@@ -13,8 +13,9 @@ interface TerminalSession {
     created: number;
     lastActivity: number;
     outputBuffer: string;
-    onData: ((data: string) => void) | null;
-    onExit: ((code: number) => void) | null;
+    activeModes: Set<number>;
+    dataListeners: Set<(data: string) => void>;
+    exitListeners: Set<(code: number) => void>;
 }
 export declare class PtyManager {
     private sessions;
@@ -48,6 +49,13 @@ export declare class PtyManager {
      * Get a terminal session by ID
      */
     get(id: string): TerminalSession | undefined;
+    /**
+     * Whether the pty's shell has any child process — i.e. something (an agent
+     * CLI, an ssh hop, a user command) is actually running in it. `false` means
+     * a bare idle shell with certainty; `null` means unknown (no such pty, or
+     * pgrep unavailable) and callers must not conclude anything from it.
+     */
+    hasLiveChild(id: string): Promise<boolean | null>;
     /**
      * Get terminal info by ID
      */
@@ -80,17 +88,26 @@ export declare class PtyManager {
      */
     kill(id: string): boolean;
     /**
-     * Set data listener for a terminal (for WebSocket connection)
+     * Subscribe to a terminal's output. Returns an unsubscribe function
+     * (no-op if the terminal is gone).
      */
-    setOnData(id: string, callback: ((data: string) => void) | null): void;
+    addDataListener(id: string, callback: (data: string) => void): () => void;
     /**
-     * Set exit listener for a terminal
+     * Subscribe to a terminal's exit. Returns an unsubscribe function.
      */
-    setOnExit(id: string, callback: ((code: number) => void) | null): void;
+    addExitListener(id: string, callback: (code: number) => void): () => void;
     /**
      * Get buffered output for reconnection
      */
     getOutputBuffer(id: string): string;
+    /**
+     * Sequences that reassert the sticky input modes (see TRACKED_INPUT_MODES) to
+     * the authoritative state observed on the full pty stream. Appended after the
+     * replay buffer so a reconnect never leaves mouse/focus reporting dangling on
+     * at the shell: the 100 KB buffer trim can drop or split the app's own
+     * mode-reset, and this puts it back deterministically.
+     */
+    getModeReset(id: string): string;
     /**
      * Kill all terminal sessions (for cleanup)
      */

package/node-server/dist/terminal/pty-manager.js

@@ -37,9 +37,24 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ptyManager = exports.PtyManager = void 0;
+const path = __importStar(require("path"));
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
 const pty = __importStar(require("@homebridge/node-pty-prebuilt-multiarch"));
 const uuid_1 = require("uuid");
 const types_1 = require("./types");
+// Sticky DEC private modes that turn mouse moves / focus changes into garbage
+// *input* when left enabled at a shell prompt (the classic "reconnected terminal
+// spews <b;x;yM sequences"). Tracked from the raw pty stream so a reconnect can
+// restore the AUTHORITATIVE state even when the enabling/disabling sequence has
+// scrolled out of — or been split by — the 100 KB buffer trim. 1000 click /
+// 1002 button-drag / 1003 any-motion mouse · 1004 focus events · 1006 SGR
+// encoding. (Bracketed paste 2004 is intentionally excluded — the shell prompt
+// toggles it itself, so forcing it would fight the shell.)
+const TRACKED_INPUT_MODES = [1000, 1002, 1003, 1004, 1006];
+// DECSET (…h) / DECRST (…l); params may be ;-separated, e.g. \x1b[?1000;1006h
+// eslint-disable-next-line no-control-regex
+const DEC_PRIVATE_MODE_RE = /\x1b\[\?([0-9;]+)([hl])/g;
 class PtyManager {
     sessions = new Map();
     /**
@@ -76,8 +91,20 @@ class PtyManager {
         const cwd = options?.cwd || process.cwd();
         const cols = options?.cols || 80;
         const rows = options?.rows || 24;
-        // Spawn PTY process
-        const ptyProcess = pty.spawn(shell, [], {
+        // Make the `nebula` agent CLI resolvable in every Nebula terminal, and
+        // pre-point it at this server. The CLI is a thin layer over the same
+        // client the MCP uses (packages/mcp) — agents in the built-in terminal
+        // can drive notebooks without any MCP registration.
+        const nebulaCliBinDir = path.resolve(__dirname, '..', '..', '..', 'packages', 'mcp', 'bin');
+        // Spawn as a LOGIN shell (-l): Nebula terminals must see the same
+        // environment as the user's ssh sessions. Non-login shells skip
+        // .zprofile/.bash_profile, so env set there (agent auth tokens like
+        // CLAUDE_CODE_OAUTH_TOKEN, module inits, PATH) silently vanished from
+        // server-side agent launches — Claude then fell back to its stored OAuth
+        // session and demanded /login whenever that had expired. Windows shells
+        // don't take -l; posix only.
+        const shellArgs = process.platform === 'win32' ? [] : ['-l'];
+        const ptyProcess = pty.spawn(shell, shellArgs, {
             name: 'xterm-256color',
             cols,
             rows,
@@ -86,6 +113,8 @@ class PtyManager {
                 ...process.env,
                 TERM: 'xterm-256color',
                 COLORTERM: 'truecolor',
+                NEBULA_URL: process.env.NEBULA_URL ?? `http://localhost:${process.env.PORT || 3000}`,
+                PATH: `${nebulaCliBinDir}:${process.env.PATH ?? ''}`,
             },
         });
         const session = {
@@ -98,27 +127,50 @@ class PtyManager {
             created: Date.now(),
             lastActivity: Date.now(),
             outputBuffer: '',
-            onData: null,
-            onExit: null,
+            activeModes: new Set(),
+            dataListeners: new Set(),
+            exitListeners: new Set(),
         };
         // Handle PTY output
         ptyProcess.onData((data) => {
             session.lastActivity = Date.now();
             // Append to output buffer for reconnection
             session.outputBuffer += data;
+            // Track sticky input-mode transitions from the RAW stream (before the
+            // trim below can drop or split them) so replay can reassert the true state.
+            DEC_PRIVATE_MODE_RE.lastIndex = 0;
+            let modeMatch;
+            while ((modeMatch = DEC_PRIVATE_MODE_RE.exec(data)) !== null) {
+                const enable = modeMatch[2] === 'h';
+                for (const p of modeMatch[1].split(';')) {
+                    const n = Number(p);
+                    if (TRACKED_INPUT_MODES.includes(n)) {
+                        if (enable)
+                            session.activeModes.add(n);
+                        else
+                            session.activeModes.delete(n);
+                    }
+                }
+            }
             // Trim buffer if too large
             if (session.outputBuffer.length > types_1.OUTPUT_BUFFER_MAX_SIZE) {
                 session.outputBuffer = session.outputBuffer.slice(-types_1.OUTPUT_BUFFER_TRIM_SIZE);
             }
-            // Forward to listener if connected
-            if (session.onData) {
-                session.onData(data);
+            // Forward to all listeners (websocket clients, watchers)
+            for (const cb of session.dataListeners) {
+                try {
+                    cb(data);
+                }
+                catch { /* one bad listener must not break the rest */ }
             }
         });
         // Handle PTY exit
         ptyProcess.onExit(({ exitCode }) => {
-            if (session.onExit) {
-                session.onExit(exitCode);
+            for (const cb of session.exitListeners) {
+                try {
+                    cb(exitCode);
+                }
+                catch { /* see above */ }
             }
             this.sessions.delete(id);
         });
@@ -146,6 +198,36 @@ class PtyManager {
     get(id) {
         return this.sessions.get(id);
     }
+    /**
+     * Whether the pty's shell has any child process — i.e. something (an agent
+     * CLI, an ssh hop, a user command) is actually running in it. `false` means
+     * a bare idle shell with certainty; `null` means unknown (no such pty, or
+     * pgrep unavailable) and callers must not conclude anything from it.
+     */
+    async hasLiveChild(id) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return null;
+        const pid = session.pty.pid;
+        // Fast path (Linux): the kernel lists a process's children directly —
+        // an O(1) ~3ms read, vs pgrep's O(all processes) table scan (~50ms on a
+        // busy shared login node with 1300+ processes). Absent on macOS and on
+        // kernels without CONFIG_PROC_CHILDREN — fall back to pgrep there.
+        try {
+            const children = await fs_1.promises.readFile(`/proc/${pid}/task/${pid}/children`, 'utf-8');
+            return children.trim().length > 0;
+        }
+        catch { /* not Linux (or file gone with the process) — pgrep decides */ }
+        return new Promise((resolve) => {
+            (0, child_process_1.execFile)('pgrep', ['-P', String(pid)], (error) => {
+                if (!error)
+                    return resolve(true); // exit 0: at least one child
+                // pgrep exits 1 for "no processes matched" — that's a definitive no.
+                const code = error.code;
+                resolve(code === 1 ? false : null);
+            });
+        });
+    }
     /**
      * Get terminal info by ID
      */
@@ -177,6 +259,12 @@ class PtyManager {
         const session = this.sessions.get(id);
         if (!session)
             return false;
+        // Skip no-op resizes: TIOCSWINSZ raises SIGWINCH even when the size is
+        // unchanged, forcing a full-screen repaint from any running TUI. On a
+        // reconnect several resize messages arrive with the SAME dimensions, and
+        // that repaint burst is what stalls input after a refresh.
+        if (session.cols === cols && session.rows === rows)
+            return true;
         session.pty.resize(cols, rows);
         session.cols = cols;
         session.rows = rows;
@@ -208,22 +296,25 @@ class PtyManager {
         return true;
     }
     /**
-     * Set data listener for a terminal (for WebSocket connection)
+     * Subscribe to a terminal's output. Returns an unsubscribe function
+     * (no-op if the terminal is gone).
      */
-    setOnData(id, callback) {
+    addDataListener(id, callback) {
         const session = this.sessions.get(id);
-        if (session) {
-            session.onData = callback;
-        }
+        if (!session)
+            return () => { };
+        session.dataListeners.add(callback);
+        return () => { this.sessions.get(id)?.dataListeners.delete(callback); };
     }
     /**
-     * Set exit listener for a terminal
+     * Subscribe to a terminal's exit. Returns an unsubscribe function.
      */
-    setOnExit(id, callback) {
+    addExitListener(id, callback) {
         const session = this.sessions.get(id);
-        if (session) {
-            session.onExit = callback;
-        }
+        if (!session)
+            return () => { };
+        session.exitListeners.add(callback);
+        return () => { this.sessions.get(id)?.exitListeners.delete(callback); };
     }
     /**
      * Get buffered output for reconnection
@@ -232,6 +323,34 @@ class PtyManager {
         const session = this.sessions.get(id);
         return session?.outputBuffer || '';
     }
+    /**
+     * Sequences that reassert the sticky input modes (see TRACKED_INPUT_MODES) to
+     * the authoritative state observed on the full pty stream. Appended after the
+     * replay buffer so a reconnect never leaves mouse/focus reporting dangling on
+     * at the shell: the 100 KB buffer trim can drop or split the app's own
+     * mode-reset, and this puts it back deterministically.
+     */
+    getModeReset(id) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return '';
+        // If the pty's FOREGROUND process is a plain shell, no TUI can be holding
+        // the sticky input modes — any tracked "on" state is stale (a TUI died
+        // without its teardown bytes reaching the pty, e.g. an agent riding a
+        // collapsed reverse tunnel, or a SIGKILL). Reasserting it would turn the
+        // user's mouse movements into SGR garbage typed at the prompt, so reset
+        // everything OFF instead.
+        try {
+            const fg = (session.pty.process || '').split('/').pop() || '';
+            if (/^-?(bash|zsh|sh|dash|fish|tcsh|ksh)$/.test(fg)) {
+                session.activeModes.clear();
+            }
+        }
+        catch { /* can't inspect foreground — keep tracked state */ }
+        return TRACKED_INPUT_MODES
+            .map((n) => `\x1b[?${n}${session.activeModes.has(n) ? 'h' : 'l'}`)
+            .join('');
+    }
     /**
      * Kill all terminal sessions (for cleanup)
      */