tmux-ide 2.9.2 → 2.9.4

package/packages/daemon/dist/tui/mirror/runtime/application-machine-authority.js

@@ -14,6 +14,7 @@ export function createApplicationMachineAuthorityManager(dependencies = {
     let selectedId = LOCAL_MACHINE_ID;
     let selectedEpoch = 0;
     let disposed = false;
+    let stopProfiles = null;
     const safe = (callback) => {
         try {
             callback();
@@ -31,7 +32,7 @@ export function createApplicationMachineAuthorityManager(dependencies = {
             safe(() => listener(generation));
     };
     const changed = (machine, generation) => {
-        if (disposed)
+        if (disposed || machine.retired)
             return;
         machine.epoch++;
         for (const listener of machine.listeners)
@@ -52,7 +53,7 @@ export function createApplicationMachineAuthorityManager(dependencies = {
                 changed(machine, generation);
         })
             .then((stop) => {
-            if (disposed || machine.owner !== owner)
+            if (disposed || machine.retired || machine.owner !== owner)
                 stop();
             else
                 machine.stopObserver = stop;
@@ -80,23 +81,28 @@ export function createApplicationMachineAuthorityManager(dependencies = {
             stopObserver: null,
             observingOwner: null,
             stopStatus: null,
+            retired: false,
         };
         const handle = Object.freeze({
             id,
-            label,
+            get label() {
+                return machine.label;
+            },
             kind: machine.kind,
             ready,
-            read: () => (disposed ? null : machine.owner.read()),
-            isAlive: (info) => disposed ? Promise.resolve(false) : machine.owner.isAlive(info),
+            read: () => (disposed || machine.retired ? null : machine.owner.read()),
+            isAlive: (info) => disposed || machine.retired ? Promise.resolve(false) : machine.owner.isAlive(info),
             endpoint: () => Object.freeze({
                 ...machine.owner.endpoint(),
                 kind: machine.kind,
-                label: profile ? label : null,
+                label: machine.profile ? machine.label : null,
                 epoch: machine.epoch,
-                ...(disposed ? { state: "disconnected", remote: null, localBaseUrl: null } : {}),
+                ...(disposed || machine.retired
+                    ? { state: "disconnected", remote: null, localBaseUrl: null }
+                    : {}),
             }),
             observe: async (listener) => {
-                if (disposed)
+                if (disposed || machine.retired)
                     return () => { };
                 if (machine.kind === "local")
                     observe(machine, machine.owner);
@@ -119,7 +125,7 @@ export function createApplicationMachineAuthorityManager(dependencies = {
         });
         observe(machine, owner);
         publish();
-        void initializing.then(() => settle(!disposed), () => settle(false));
+        void initializing.then(() => settle(!disposed && !machine.retired), () => settle(false));
         return machine;
     };
     makeMachine(LOCAL_MACHINE_ID, "Local");
@@ -206,6 +212,48 @@ export function createApplicationMachineAuthorityManager(dependencies = {
                 if (profile.enabled)
                     manager.add(profile);
         },
+        reconcile(profiles) {
+            if (disposed)
+                return;
+            const next = SavedMachineRegistrySchema.parse({ version: 1, machines: profiles });
+            const previousSelection = selectedId;
+            for (const machine of [...machines.values()]) {
+                if (!machine.profile)
+                    continue;
+                const profile = next.machines.find((candidate) => candidate.id === machine.id && candidate.enabled);
+                if (profile &&
+                    profile.sshTarget === machine.profile.sshTarget &&
+                    profile.expectedEnvironmentId === machine.profile.expectedEnvironmentId) {
+                    // Labels are presentation metadata, not transport identity. Preserve
+                    // the connected owner and every consumer holding its stable handle.
+                    machine.label = profile.label;
+                    machine.profile = profile;
+                    continue;
+                }
+                if (selectedId === machine.id)
+                    manager.select(LOCAL_MACHINE_ID);
+                machine.retired = true;
+                machine.stopStatus?.();
+                machine.stopObserver?.();
+                for (const listener of machine.listeners)
+                    safe(() => listener(null));
+                machine.owner.dispose();
+                machine.listeners.clear();
+                machines.delete(machine.id);
+            }
+            for (const profile of next.machines)
+                if (profile.enabled)
+                    manager.add(profile);
+            if (machines.has(previousSelection))
+                manager.select(previousSelection);
+            publish();
+        },
+        followProfiles(subscribe) {
+            if (disposed)
+                return;
+            stopProfiles?.();
+            stopProfiles = subscribe(manager.reconcile);
+        },
         read: () => machines.get(selectedId)?.handle.read() ?? null,
         isAlive: (info) => machines.get(selectedId)?.handle.isAlive(info) ?? Promise.resolve(false),
         endpoint: () => Object.freeze({ ...machines.get(selectedId).handle.endpoint(), epoch: selectedEpoch }),
@@ -223,6 +271,8 @@ export function createApplicationMachineAuthorityManager(dependencies = {
             if (disposed)
                 return;
             disposed = true;
+            stopProfiles?.();
+            stopProfiles = null;
             lifetime.abort();
             selectedEpoch++;
             selectedGeneration(null);

package/packages/daemon/dist/tui/mirror/runtime/application-machine-navigation.js

@@ -123,7 +123,9 @@ export function createApplicationMachineNavigation(options) {
             return false;
         }
         const selected = candidates[0];
-        const sameSelection = activeSessionKey() === selected.id && options.sessionName() === name;
+        const sameSelection = manager.snapshot().selectedMachineId === id &&
+            activeSessionKey() === selected.id &&
+            options.sessionName() === name;
         setActiveSessionKey(selected.id);
         expectedLiveSessionId = selected.liveSessionId;
         server = selected.server;
@@ -222,18 +224,25 @@ export function createApplicationMachineNavigation(options) {
             tabs.observe(tab.key, tabAgents(tab));
     });
     const sidebar = {
-        groups: () => snapshot().groups.map((group) => ({
-            ...group,
-            agentsAvailable: group.sessions.some((session) => isDefaultSession(group.id, session)) &&
-                (agentGroups().find((value) => value.machineId === group.id)?.available ?? false),
-            agents: !group.sessions.some((session) => isDefaultSession(group.id, session))
-                ? []
-                : (agentGroups().find((value) => value.machineId === group.id)?.agents ?? []).map((agent) => ({
-                    ...agent,
-                    server: group.sessions.find((session) => session.liveSessionId === agent.liveSessionId &&
-                        isDefaultSession(group.id, session))?.server,
-                })),
-        })),
+        groups: () => {
+            const groupsById = new Map(agentGroups().map((group) => [group.machineId, group]));
+            return snapshot().groups.map((group) => {
+                // Read once per projection: local authority reads validate the record on disk.
+                // The next projection (and action admission) still observes replacement immediately.
+                const instanceId = manager.getMachine(group.id)?.read()?.instanceId;
+                const defaultSessions = group.sessions.filter((session) => !session.server || session.server.generation === instanceId);
+                const agents = defaultSessions.length ? groupsById.get(group.id) : undefined;
+                return {
+                    ...group,
+                    agentsAvailable: agents?.available ?? false,
+                    agents: (agents?.agents ?? []).map((agent) => ({
+                        ...agent,
+                        server: defaultSessions.find((session) => session.liveSessionId === agent.liveSessionId)
+                            ?.server,
+                    })),
+                };
+            });
+        },
         tabs: () => {
             tabRevision();
             const value = tabs.snapshot();
@@ -409,7 +418,9 @@ export function createApplicationMachineNavigation(options) {
         paletteCommands() {
             const groupsById = new Map(agentGroups().map((group) => [group.machineId, group]));
             return snapshot().groups.flatMap((group) => {
-                const agentGroup = !group.sessions.some((session) => isDefaultSession(group.id, session))
+                const daemon = manager.getMachine(group.id)?.read();
+                const isDefault = (session) => !session.server || session.server.generation === daemon?.instanceId;
+                const agentGroup = !group.sessions.some((session) => isDefault(session))
                     ? undefined
                     : groupsById.get(group.id);
                 const agentsBySession = new Map();
@@ -420,7 +431,6 @@ export function createApplicationMachineNavigation(options) {
                     list.push(agent);
                     agentsBySession.set(agent.liveSessionId, list);
                 }
-                const daemon = manager.getMachine(group.id)?.read();
                 const sessions = group.sessions.flatMap((session) => {
                     if (!session.liveSessionId)
                         return [];
@@ -433,7 +443,7 @@ export function createApplicationMachineNavigation(options) {
                         liveSessionId: session.liveSessionId,
                         server: session.server,
                         hostLabel: `${group.label}${session.serverLabel ? ` / ${session.serverLabel}` : ""}`,
-                        agentActivities: isDefaultSession(group.id, session) && agentGroup?.available
+                        agentActivities: isDefault(session) && agentGroup?.available
                             ? (agentsBySession.get(session.liveSessionId) ?? []).map((a) => ({
                                 paneId: a.paneId,
                                 attention: a.attention,
@@ -445,9 +455,7 @@ export function createApplicationMachineNavigation(options) {
                     };
                     return [
                         { kind: "open-session", sessionName: session.name, label: session.name, fleet },
-                        ...(isDefaultSession(group.id, session)
-                            ? (agentsBySession.get(session.liveSessionId) ?? [])
-                            : []).map((a) => ({
+                        ...(isDefault(session) ? (agentsBySession.get(session.liveSessionId) ?? []) : []).map((a) => ({
                             kind: "jump-agent",
                             sessionName: session.name,
                             paneId: a.paneId,

package/packages/daemon/dist/tui/mirror/runtime/application-machine-sidebar.jsx

@@ -5,13 +5,16 @@ import { fleetHostColor } from "./fleet-presentation.js";
 /* @jsxImportSource @opentui/solid */
 import { fleetConnectionMessage, } from "@tmux-ide/daemon-client/fleet-connection-status";
 import { For, Show, createEffect, createMemo, createSignal, } from "solid-js";
-import { friendlySessionLabel } from "../terminal-text.js";
+import { friendlySessionLabel, wrapText } from "../terminal-text.js";
 import { KeyHint } from "../ui/key-hint.jsx";
 import { NavigationRow } from "../ui/navigation-row.jsx";
 import { Surface } from "../ui/surface.jsx";
 import { useKeyboardRoute } from "../ui/keyboard-router.jsx";
 /** Pure machine navigation. All connection and session authority stays with the caller. */
 export function ApplicationMachineSidebar(props) {
+    // All visible sections share one projection for the current reactive inputs.
+    // Event handlers retain the model's fresh authority checks at action time.
+    const groups = createMemo(() => props.model.groups());
     const [localFocused, setLocalFocused] = createSignal(false);
     const focused = () => props.model.focused?.() ?? localFocused();
     const [localCollapsed, setCollapsed] = createSignal(new Set());
@@ -19,16 +22,14 @@ export function ApplicationMachineSidebar(props) {
     const [selectedKey, setSelectedKey] = createSignal(null);
     let scroll;
     const agentHeight = () => (props.agentRows ?? 0) > 0
-        ? Math.min((props.agentRows ?? 0) + 2, Math.max(0, Math.floor(props.height / 2)))
+        ? Math.min((props.agentRows ?? 0) + 2, Math.max(0, Math.floor(props.height / 2)), Math.max(0, props.height - fixedHeight() - controlsHeight() - 2))
         : 0;
-    const controlsHeight = () => (props.height >= 8 && controlGroup() ? 4 : 0);
+    const controlsHeight = () => (props.height >= 8 && controlGroup() ? controlTextHeight() + 2 : 0);
     const searchHeight = () => (props.model.onOpenSwitcher ? 1 : 0) + (props.model.onOpenAttention ? 1 : 0);
-    const machineHeight = () => Math.max(0, props.height -
-        1 -
-        (props.model.onAddMachine ? 1 : 0) -
-        agentHeight() -
-        controlsHeight() -
-        searchHeight());
+    const fixedHeight = () => 1 + (props.model.onAddMachine ? 1 : 0) + searchHeight();
+    // Keep both action rows and at least two machine rows available on short terminals.
+    const controlTextHeight = () => Math.min(controlTextLines().length, Math.max(1, props.height - fixedHeight() - 4));
+    const machineHeight = () => Math.max(0, props.height - fixedHeight() - agentHeight() - controlsHeight());
     const active = (row) => row.group.id === props.model.activeMachineId() &&
         (row.agent
             ? row.group.state === "ready" &&
@@ -46,7 +47,7 @@ export function ApplicationMachineSidebar(props) {
                 : row.session?.name === props.model.activeSessionName());
     const preferenceKey = (group) => group.environmentId ?? group.id;
     const rows = createMemo(() => [
-        ...props.model.groups().flatMap((group) => groupApplicationTeamRows(group.agents ?? []).map((agent) => ({
+        ...groups().flatMap((group) => groupApplicationTeamRows(group.agents ?? []).map((agent) => ({
             key: JSON.stringify([
                 group.id,
                 "agent",
@@ -57,7 +58,7 @@ export function ApplicationMachineSidebar(props) {
             group,
             agent,
         }))),
-        ...props.model.groups().flatMap((group) => [
+        ...groups().flatMap((group) => [
             { key: JSON.stringify([group.id]), group },
             ...group.sessions
                 .filter((session) => !collapsed().has(preferenceKey(group)) ||
@@ -118,6 +119,12 @@ export function ApplicationMachineSidebar(props) {
                 : "disconnected"
             : diagnostic.phase;
     };
+    const controlTextLines = createMemo(() => {
+        const group = controlGroup();
+        return group
+            ? wrapText(group.diagnostic ? fleetConnectionMessage(group.diagnostic) : connectionDetail(group), Math.max(1, props.width))
+            : [];
+    });
     const toggle = (group, value = !collapsed().has(preferenceKey(group))) => {
         const next = new Set(collapsed());
         if (value)
@@ -163,7 +170,7 @@ export function ApplicationMachineSidebar(props) {
     const sectionGap = (row) => (!row.session && !row.agent && !row.server ? 1 : 0);
     const rowHeight = (row) => (row.agent ? 2 : row.serverHeading ? 2 : 1) +
         sectionGap(row) +
-        (hasAgents() && row.key === JSON.stringify([props.model.groups()[0]?.id]) ? 1 : 0);
+        (hasAgents() && row.key === JSON.stringify([groups()[0]?.id]) ? 1 : 0);
     const revealFocusedRow = () => {
         if (!focused() || !scroll)
             return;
@@ -346,7 +353,7 @@ export function ApplicationMachineSidebar(props) {
                         props.model.onSelectServer?.(row.group.id, row.session.server);
                 }}/>
                 </Show>
-                <Show when={hasAgents() && row.key === JSON.stringify([props.model.groups()[0]?.id])}>
+                <Show when={hasAgents() && row.key === JSON.stringify([groups()[0]?.id])}>
                   <text height={1} fg={props.theme.roles.text.secondary}>
                     {" "}
                     Machines
@@ -399,14 +406,12 @@ export function ApplicationMachineSidebar(props) {
         <KeyHint theme={props.theme} keys={CHROME_ACTIONS.sessions.keys} label="Browse all sessions" width={props.width} quiet button onPress={() => props.model.onOpenSwitcher?.()}/>
       </Show>
       <Show when={props.model.onOpenAttention}>
-        <KeyHint theme={props.theme} keys={CHROME_ACTIONS.attention.keys} label={`${CHROME_ACTIONS.attention.label} (${props.model.groups().reduce((sum, group) => sum + (group.state === "ready" ? (group.agents ?? []).filter((agent) => agent.attention && !agent.disabled).length : 0), 0)})`} width={props.width} quiet button onPress={() => props.model.onOpenAttention?.()}/>
+        <KeyHint theme={props.theme} keys={CHROME_ACTIONS.attention.keys} label={`${CHROME_ACTIONS.attention.label} (${groups().reduce((sum, group) => sum + (group.state === "ready" ? (group.agents ?? []).filter((agent) => agent.attention && !agent.disabled).length : 0), 0)})`} width={props.width} quiet button onPress={() => props.model.onOpenAttention?.()}/>
       </Show>
       <Show when={controlsHeight() > 0 && controlGroup()}>
         {(group) => (<>
-            <text height={2} fg={props.theme.roles.text.secondary}>
-              {group().diagnostic
-                ? fleetConnectionMessage(group().diagnostic)
-                : connectionDetail(group())}
+            <text height={controlTextHeight()} flexShrink={0} fg={props.theme.roles.text.secondary}>
+              {controlTextLines().join("\n")}
             </text>
             <KeyHint theme={props.theme} keys={SIDEBAR_ACTIONS.retry.keys} label={SIDEBAR_ACTIONS.retry.label} width={props.width} quiet button onPress={() => props.model.onRetryMachine?.(group().id)}/>
             <KeyHint theme={props.theme} keys={SIDEBAR_ACTIONS.disconnect.keys} label={SIDEBAR_ACTIONS.disconnect.label} width={props.width} quiet button onPress={() => props.model.onDisconnectMachine?.(group().id)}/>

package/packages/daemon/dist/tui/mirror/runtime/application-machine-startup.js

@@ -1,8 +1,9 @@
 import { resolveRuntimeNamespace } from "../../../lib/runtime-namespace.js";
 import { randomUUID } from "node:crypto";
 import { SavedMachineSchema } from "@tmux-ide/contracts";
-import { loadSavedMachines } from "../../../lib/saved-machines.js";
+import { loadSavedMachines, watchSavedMachines } from "../../../lib/saved-machines.js";
 import { applicationMachineAuthorityManager } from "./application-machine-authority.js";
+import { tuiPerfMark } from "./application-performance-log.js";
 /** Labels describe access routes; they never become routing identities. */
 export function ephemeralMachineProfile(alias, existing) {
     const target = SavedMachineSchema.shape.sshTarget.parse(alias);
@@ -20,17 +21,45 @@ export function ephemeralMachineProfile(alias, existing) {
 }
 /** Local discovery and rendering never wait for any remote handshake. */
 export function initializeApplicationMachines(aliases) {
-    const profiles = resolveRuntimeNamespace().development ? [] : [...loadSavedMachines().machines];
+    const development = resolveRuntimeNamespace().development;
+    const profiles = development ? [] : [...loadSavedMachines().machines];
+    const ephemeral = [];
     let preferred = null;
     for (const alias of aliases) {
         let profile = profiles.find((p) => p.sshTarget === alias && p.enabled);
         if (!profile) {
             profile = ephemeralMachineProfile(alias, profiles);
             profiles.push(profile);
+            ephemeral.push(profile);
         }
         preferred ??= profile.id;
     }
     applicationMachineAuthorityManager.initialize(profiles);
     if (preferred)
         applicationMachineAuthorityManager.select(preferred);
+    if (!development) {
+        const failed = () => tuiPerfMark("machine-registry-error", { reason: "registry-unavailable-or-invalid" });
+        try {
+            applicationMachineAuthorityManager.followProfiles((onChange) => watchSavedMachines((registry) => {
+                const next = [...registry.machines];
+                for (let index = 0; index < ephemeral.length; index++) {
+                    let profile = ephemeral[index];
+                    // A newly saved route may claim an ephemeral display label. Keep the
+                    // explicit connection's identity while making the label unambiguous.
+                    if (next.some((entry) => entry.label.normalize("NFKC").toLowerCase() ===
+                        profile.label.normalize("NFKC").toLowerCase()))
+                        profile = {
+                            ...profile,
+                            label: ephemeralMachineProfile(profile.sshTarget, next).label,
+                        };
+                    ephemeral[index] = profile;
+                    next.push(profile);
+                }
+                onChange(next);
+            }, failed));
+        }
+        catch {
+            failed();
+        }
+    }
 }

package/packages/daemon/dist/tui/mirror/runtime/application-palette-search-owner.js

@@ -1,4 +1,4 @@
-import { createMemo, createSignal } from "solid-js";
+import { createMemo, createSignal, untrack } from "solid-js";
 import { applicationCommandDescription, filterApplicationCommands, } from "../workspace/application-command-description.js";
 import { applicationPaletteKeyboardDisposition, } from "./application-palette-input.js";
 import { applicationPaneRenameKeyAction, applicationPaneRenamePaste, } from "./application-pane-rename-input.js";
@@ -11,9 +11,13 @@ export function createApplicationPaletteSearchOwner(options) {
     const [help, setHelp] = createSignal(false);
     const [query, setQuery] = createSignal("");
     const [selectedId, setSelectedId] = createSignal(null);
-    const commands = createMemo(() => filterApplicationCommands(options
+    const readCommands = () => filterApplicationCommands(options
         .commands()
-        .filter((c) => !localOnly() || typeof c === "string" || !c.fleet || c.fleet.machineId === "local"), query()));
+        .filter((c) => !localOnly() || typeof c === "string" || !c.fleet || c.fleet.machineId === "local"), query());
+    // Closed overlays must not subscribe to catalog churn. Explicit reads still
+    // resolve current commands, including reset() before the open action commits.
+    const activeCommands = createMemo(() => (options.open() ? readCommands() : null));
+    const commands = () => activeCommands() ?? untrack(readCommands);
     const selection = () => Math.max(0, commands().findIndex((command) => applicationCommandDescription(command).id === selectedId()));
     const select = (index) => {
         const command = commands()[index];

package/packages/daemon/dist/tui/mirror/runtime/application-performance-log.js

@@ -29,6 +29,8 @@ stream?.on("drain", drain);
 export const tuiLifecycleStream = stream ? Object.freeze({ enabled: true }) : null;
 export const tuiPerfStream = TUI_PERF_LOG ? tuiLifecycleStream : null;
 const LIFECYCLE_PHASES = new Set([
+    "machine-connection-status",
+    "machine-registry-error",
     "generation-status",
     "generation-connection-start",
     "generation-connection-resolved",
@@ -132,6 +134,7 @@ export function closeTuiPerfMarks() {
     closePromise = (async () => {
         if (!stream)
             return;
+        await writer?.flush();
         await flushTuiPerfMarks();
         // No drain callback may enqueue another critical record after end().
         stream.off("drain", drain);

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-input-ingress.js

@@ -7,6 +7,133 @@ import { terminalInputForOpenTuiKey, terminalInputsForPaste, } from "./terminal-
 export function createApplicationTerminalInputIngress(interaction, generation, sessionOwner, focusedPane, setNote) {
     const pending = createApplicationPendingTerminalInputOwner();
     let ownsNote = false;
+    let recovery = null;
+    const scope = () => {
+        const active = generation();
+        const owner = sessionOwner();
+        const pane = focusedPane();
+        const session = owner?.sessionName();
+        if (!active ||
+            !["live", "rebinding"].includes(active.status) ||
+            !active.connection ||
+            !active.client ||
+            !active.daemonGeneration ||
+            !owner ||
+            !session ||
+            !pane)
+            return null;
+        try {
+            const clientGeneration = active.client.getSnapshot().generation;
+            if (!Number.isSafeInteger(clientGeneration))
+                return null;
+            return {
+                owner,
+                connection: active.connection,
+                client: active.client,
+                daemon: active.daemonGeneration,
+                clientGeneration: clientGeneration,
+                session: session,
+                pane,
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    const sameScope = (left, right) => right !== null &&
+        left.owner === right.owner &&
+        left.connection === right.connection &&
+        left.client === right.client &&
+        left.daemon === right.daemon &&
+        left.clientGeneration === right.clientGeneration &&
+        left.session === right.session &&
+        left.pane === right.pane;
+    let recoveryVersion = 0;
+    const cancelRecovery = () => {
+        recoveryVersion++;
+        if (recovery)
+            clearTimeout(recovery.timer);
+        recovery = null;
+    };
+    const recover = (inputs, bytes, kind) => {
+        if (pending.snapshot().sessionName !== null ||
+            (!recovery && generation()?.status !== "rebinding"))
+            return false;
+        const target = scope();
+        if (!target)
+            return false;
+        if (recovery && !sameScope(recovery.scope, target))
+            cancelRecovery();
+        if (!recovery) {
+            const timer = setTimeout(() => {
+                cancelRecovery();
+                setNote("terminal recovery timed out · queued input was not sent");
+            }, 5_000);
+            timer.unref?.();
+            recovery = { scope: target, inputs: [], weight: 0, admitted: 0, draining: false, timer };
+        }
+        const weight = bytes.byteLength;
+        if (recovery.admitted >= 64 || recovery.weight + weight > 1024 * 1024) {
+            setNote("terminal input queue full · wait for the session to connect");
+            return true;
+        }
+        recovery.weight += weight;
+        recovery.admitted++;
+        const version = recoveryVersion;
+        const parserOrigin = captureOrigin()
+            ? {
+                origin: kind === "paste" ? "bracketed-paste" : "keyboard",
+                payload: Buffer.from(bytes),
+            }
+            : undefined;
+        recovery.inputs.push(async () => {
+            for (const [index, input] of inputs.entries()) {
+                if (version !== recoveryVersion ||
+                    !sameScope(target, scope()) ||
+                    generation()?.status !== "live" ||
+                    !(await interaction.sendInputToPane(target.pane, input, index === 0 ? parserOrigin : undefined)))
+                    return false;
+            }
+            return true;
+        });
+        setNote(`${target.session} · terminal ${kind} queued`);
+        return true;
+    };
+    const flushRecovery = () => {
+        const waiting = recovery;
+        if (!waiting || waiting.draining)
+            return;
+        if (!sameScope(waiting.scope, scope())) {
+            cancelRecovery();
+            setNote("terminal changed · queued input was not sent");
+            return;
+        }
+        if (generation()?.status !== "live" || !generation()?.fastLane)
+            return;
+        waiting.draining = true;
+        const version = recoveryVersion;
+        void (async () => {
+            while (version === recoveryVersion && waiting.inputs.length > 0) {
+                const send = waiting.inputs.shift();
+                try {
+                    if (await send())
+                        continue;
+                }
+                catch {
+                    /* An uncertain send is never retried. */
+                }
+                if (version !== recoveryVersion)
+                    return;
+                cancelRecovery();
+                setNote("terminal unavailable · queued input was not sent");
+                return;
+            }
+            if (version === recoveryVersion) {
+                cancelRecovery();
+                setNote(null);
+            }
+        })();
+    };
     const captureOrigin = () => Boolean(currentTuiPerformanceEventSink()?.terminalInputOrigin);
     const flush = () => {
         const owner = sessionOwner();
@@ -36,9 +163,14 @@ export function createApplicationTerminalInputIngress(interaction, generation, s
         else
             setNote(`terminal unavailable · ${kind} was not sent`);
     };
+    const cancelInteractionInput = () => {
+        cancelRecovery();
+        interaction.cancelPendingInput();
+    };
     return {
         wrapStarter(starter) {
             const start = async (...args) => {
+                cancelInteractionInput();
                 const [sessionName] = args;
                 const identity = pending.begin(sessionName);
                 const result = await starter(...args);
@@ -52,24 +184,32 @@ export function createApplicationTerminalInputIngress(interaction, generation, s
             };
             return Object.assign(start, {
                 cancel() {
+                    cancelInteractionInput();
                     pending.dispose();
                     starter.cancel();
                 },
             });
         },
-        adopt() {
+        adopt(terminalsActive = true) {
+            if (!terminalsActive)
+                cancelInteractionInput();
             flush();
+            flushRecovery();
         },
         routeKey(event) {
             const active = generation();
             if (pending.snapshot().sessionName === null &&
+                recovery === null &&
                 active?.status === "live" &&
                 active.fastLane &&
                 focusedPane()) {
                 sendApplicationTerminalKey(interaction, event, captureOrigin());
                 return;
             }
-            if (!terminalInputForOpenTuiKey(event))
+            const recoveryInput = terminalInputForOpenTuiKey(event);
+            if (!recoveryInput)
+                return;
+            if (recover([recoveryInput], Buffer.from(recoveryInput.data, "utf8"), "input"))
                 return;
             const copy = { name: event.name, ctrl: event.ctrl, meta: event.meta, shift: event.shift };
             noteAdmission(pending.enqueue(() => sendApplicationTerminalKey(interaction, copy, captureOrigin()), Buffer.byteLength(event.name, "utf8")), "input");
@@ -87,15 +227,19 @@ export function createApplicationTerminalInputIngress(interaction, generation, s
             }
             const active = generation();
             if (pending.snapshot().sessionName === null &&
+                recovery === null &&
                 active?.status === "live" &&
                 active.fastLane &&
                 focusedPane()) {
                 sendApplicationTerminalPaste(interaction, copy, captureOrigin());
                 return;
             }
+            if (recover(terminalInputsForPaste(Buffer.from(copy).toString("utf8")), copy, "paste"))
+                return;
             noteAdmission(pending.enqueue(() => sendApplicationTerminalPaste(interaction, copy, captureOrigin()), copy.byteLength), "paste");
         },
         dispose() {
+            cancelInteractionInput();
             pending.dispose();
         },
     };