tmux-ide 2.9.9 → 2.9.11

package/packages/daemon/dist/terminal/mirror/session-channel.js

@@ -177,6 +177,8 @@ export class SessionChannel {
     fittedWindows = new Map();
     cancelSync = null;
     syncOrdinal = 0;
+    identityJoinOrdinal = 0;
+    trustedInventoryJoinsMissing = false;
     completedSyncOrdinal = 0;
     lastDisplayNameSyncAtMs = 0;
     disposed = false;
@@ -412,20 +414,28 @@ export class SessionChannel {
     }
     /**
      * Strict daemon-internal inventory from this channel's current tmux truth.
-     * Unlike the background discovery path, this query awaits descriptor
-     * reconciliation before projecting and rejects incomplete identity rather
-     * than returning the previous descriptor snapshot.
+     * Unlike background discovery, this query verifies current native membership
+     * before projecting and rejects incomplete identity. Stream admission may
+     * explicitly join missing pane records after that verification; ordinary
+     * inventory readers retain their existing fail-closed no-join contract.
      */
-    describeTrustedInventory(expectedRuntimeSessionId) {
+    describeTrustedInventory(expectedRuntimeSessionId, joinMissingPanes = false) {
         if (this.disposed) {
             return Promise.reject(new Error(`mirror session ${this.opts.session} is disposed`));
         }
         if (this.trustedInventoryFlight) {
+            // A default read can fail precisely because it does not join new panes.
+            // Preserve that failure for its caller, then qualify admission separately.
+            if (joinMissingPanes &&
+                !this.trustedInventoryJoinsMissing &&
+                this.trustedInventoryFlightSessionId === expectedRuntimeSessionId)
+                return this.trustedInventoryFlight.then(() => this.describeTrustedInventory(expectedRuntimeSessionId, true), () => this.describeTrustedInventory(expectedRuntimeSessionId, true));
             return this.trustedInventoryFlightSessionId === expectedRuntimeSessionId
                 ? this.trustedInventoryFlight
                 : Promise.reject(new Error(`trusted inventory identity changed for ${this.opts.session}`));
         }
-        const flight = this.refreshTrustedInventory(expectedRuntimeSessionId)
+        this.trustedInventoryJoinsMissing = joinMissingPanes;
+        const flight = this.refreshTrustedInventory(expectedRuntimeSessionId, 0, joinMissingPanes)
             .catch((error) => {
             this.windowLinkAuthority?.invalidate();
             this.latestWindowStage = null;
@@ -2723,7 +2733,7 @@ export class SessionChannel {
         }
         return { listed, movedWindowRuntimeIds };
     }
-    async refreshTrustedInventory(expectedRuntimeSessionId, attempt = 0) {
+    async refreshTrustedInventory(expectedRuntimeSessionId, attempt = 0, joinMissingPanes = false) {
         const authorityOrdinal = this.windowIdentityOrdinal;
         const beforeLines = await this.io.request(`list-panes -s -t "${expectedRuntimeSessionId}" -F "${SESSION_PANE_DESCRIPTOR_FORMAT}"`);
         if (this.disposed)
@@ -2800,7 +2810,7 @@ export class SessionChannel {
             authorityOrdinal !== this.windowIdentityOrdinal) {
             if (attempt >= 1)
                 throw new Error(`trusted inventory for ${this.opts.session} did not settle`);
-            return await this.refreshTrustedInventory(expectedRuntimeSessionId, attempt + 1);
+            return await this.refreshTrustedInventory(expectedRuntimeSessionId, attempt + 1, joinMissingPanes);
         }
         if (this.disposed)
             throw new Error(`mirror session ${this.opts.session} is disposed`);
@@ -2832,17 +2842,27 @@ export class SessionChannel {
             !stagedPaneMembershipExact ||
             stagedPaneCount !== descriptors.length ||
             stagedPaneIds.size !== descriptors.length ||
-            [...computedWindowCounts.keys()].some((runtimeWindowId) => !confirmedWindowStage.windows.has(runtimeWindowId)) ||
-            descriptors.some((descriptor) => {
-                const pane = this.panesByRuntime.get(descriptor.runtimePaneId);
-                const window = confirmedWindowStage.windows.get(descriptor.windowId);
-                return (!pane ||
-                    !window?.semanticId ||
-                    descriptor.semanticPaneId !== pane.semanticId ||
-                    descriptor.semanticWindowId !== window.semanticId ||
-                    !WorkspaceIdSchemaZ.safeParse(pane.semanticId).success ||
-                    !WorkspaceIdSchemaZ.safeParse(window.semanticId).success);
-            })) {
+            [...computedWindowCounts.keys()].some((runtimeWindowId) => !confirmedWindowStage.windows.has(runtimeWindowId)))
+            throw new Error(`trusted inventory for ${this.opts.session} lacks verified identity`);
+        // Fresh native inventory can beat background discovery after window creation.
+        // Join verified stable membership before projecting semantic records.
+        if (joinMissingPanes &&
+            descriptors.some((pane) => this.panesByRuntime.get(pane.runtimePaneId)?.semanticId !== pane.semanticPaneId)) {
+            this.discovery.invalidate();
+            await this.reconcileIdentity(descriptors, runtimePaneIds, () => authorityOrdinal === this.windowIdentityOrdinal, false);
+        }
+        if (this.disposed || authorityOrdinal !== this.windowIdentityOrdinal)
+            throw new Error(`trusted inventory for ${this.opts.session} changed during identity join`);
+        if (descriptors.some((descriptor) => {
+            const pane = this.panesByRuntime.get(descriptor.runtimePaneId);
+            const window = confirmedWindowStage.windows.get(descriptor.windowId);
+            return (!pane ||
+                !window?.semanticId ||
+                descriptor.semanticPaneId !== pane.semanticId ||
+                descriptor.semanticWindowId !== window.semanticId ||
+                !WorkspaceIdSchemaZ.safeParse(pane.semanticId).success ||
+                !WorkspaceIdSchemaZ.safeParse(window.semanticId).success);
+        })) {
             throw new Error(`trusted inventory for ${this.opts.session} lacks verified identity`);
         }
         const previousCurrentWindow = this.currentWindow;
@@ -3174,7 +3194,8 @@ export class SessionChannel {
             })),
         };
     }
-    async reconcileIdentity(descriptors, listed) {
+    async reconcileIdentity(descriptors, listed, current = () => true, publish = true) {
+        const joinOrdinal = ++this.identityJoinOrdinal;
         if (this.disposed)
             return false;
         if (this.opts.hasSharedWindowConflict?.()) {
@@ -3205,7 +3226,7 @@ export class SessionChannel {
             ok: false,
             error: cause instanceof Error ? cause.message : String(cause),
         }))));
-        if (this.disposed)
+        if (this.disposed || !current() || joinOrdinal !== this.identityJoinOrdinal)
             return plan.stampEffects.length > 0;
         const reconciliation = finalizeWorkspaceTmuxReconciliation(plan, outcomes);
         const descriptorByRuntime = new Map(descriptors.map((d) => [d.runtimePaneId, d]));
@@ -3311,9 +3332,11 @@ export class SessionChannel {
          * without this the new pane stays invisible until something else happens to
          * move a layout, and a split looks like it did not reach the view.
          */
-        for (const runtimeId of this.layoutByWindow.keys())
-            this.emitLayout(runtimeId);
-        this.emitLayoutAuthority();
+        if (publish) {
+            for (const runtimeId of this.layoutByWindow.keys())
+                this.emitLayout(runtimeId);
+            this.emitLayoutAuthority();
+        }
         this.settleFirstJoin();
         return plan.stampEffects.length > 0;
     }

package/packages/daemon/dist/terminal/pane-stream/pane-stream-websocket.js

@@ -1,3 +1,4 @@
+import { PANE_STREAM_INPUT_LIFETIME_CAPABILITY_VERSION, } from "@tmux-ide/contracts";
 import { inflateSync } from "node:zlib";
 import { PaneStreamLayoutSnapshotFrameSchemaZ } from "@tmux-ide/contracts";
 import { z } from "zod";
@@ -193,7 +194,7 @@ export class PaneStreamAdmissionCoordinator {
             try {
                 const describeStartedAtMicros = trace ? this.#observability.nowMicros() : 0;
                 if (this.#mirror.describeSessionAuthority) {
-                    const authority = await this.#mirror.describeSessionAuthority(context.sessionName);
+                    const authority = await this.#mirror.describeSessionAuthority(context.sessionName, request.panes);
                     described = authority.description;
                     runtimeSessionId = authority.runtimeSessionId;
                 }
@@ -765,6 +766,10 @@ export class PaneStreamLiveConnection {
         try {
             sendControl(this.#socket, {
                 type: "ready",
+                ...(this.#sessionRuntimeBinding &&
+                    this.#descriptor.terminalDelivery?.protocolVersions.includes(PANE_STREAM_INPUT_LIFETIME_CAPABILITY_VERSION)
+                    ? { inputLifetime: true }
+                    : {}),
                 protocolVersion: PANE_STREAM_PROTOCOL_VERSION,
                 daemonInstanceId: this.#binding.daemonInstanceId,
                 requestId: this.#binding.requestId,
@@ -1995,7 +2000,7 @@ export class PaneStreamLiveConnection {
             }
             return;
         }
-        this.#acceptInput(frame.pane, frame.seq, frame.kind, frame.data, byteLength, frame.performanceTraceId, frame.causalProbe, ingressAtMicros, callbackAtSharedMicros, ingressAtSharedMicros);
+        this.#acceptInput(frame.pane, frame.seq, frame.kind, frame.data, byteLength, frame.performanceTraceId, frame.causalProbe, ingressAtMicros, callbackAtSharedMicros, ingressAtSharedMicros, frame.expectedLifetime);
     };
     #acceptAuthorityGeneration(generation) {
         if (!this.#sessionRuntimeBinding || generation !== this.#sessionRuntimeBinding.generation) {
@@ -2121,7 +2126,13 @@ export class PaneStreamLiveConnection {
         this.#ledger.give(this.#clientId, pane, "renderer-backlog", returned);
         this.#evaluateResume(pane);
     }
-    #acceptInput(pane, seq, kind, data, frameBytes, performanceTraceId, causalProbe, ingressAtMicros = null, callbackAtSharedMicros = null, ingressAtSharedMicros = null) {
+    #acceptInput(pane, seq, kind, data, frameBytes, performanceTraceId, causalProbe, ingressAtMicros = null, callbackAtSharedMicros = null, ingressAtSharedMicros = null, expectedLifetime) {
+        if (expectedLifetime &&
+            (!this.#sessionRuntimeBinding ||
+                !this.#descriptor.terminalDelivery?.protocolVersions.includes(PANE_STREAM_INPUT_LIFETIME_CAPABILITY_VERSION))) {
+            this.#failProtocol("input-rejected");
+            return;
+        }
         if (this.#descriptor.viewerMode !== "interactive") {
             this.#failProtocol("input-rejected");
             return;
@@ -2213,7 +2224,7 @@ export class PaneStreamLiveConnection {
                             });
                         }
                     }
-                    : undefined);
+                    : undefined, expectedLifetime);
             else if (kind === "text")
                 channel.sub.sendText(data);
             else

package/packages/daemon/dist/terminal/session-runtime/registry.js

@@ -472,10 +472,10 @@ export class SessionRuntimeRegistry {
             return { status: "retired" };
         return result;
     }
-    async describeSessionAuthority(session) {
+    async describeSessionAuthority(session, expectedSemanticPaneIds) {
         const runtime = this.#runtime(session);
         await runtime.whenReady();
-        const authority = await this.#mirror.describeSessionAuthority(session);
+        const authority = await this.#mirror.describeSessionAuthority(session, expectedSemanticPaneIds);
         if (this.#disposed || this.#sessions.get(session) !== runtime) {
             const error = new Error(`session runtime ${session} changed topology`);
             error.name = "MirrorTopologyChangedError";
@@ -1003,7 +1003,7 @@ class SessionRuntime {
             return Promise.reject(error);
         }
     }
-    sendInput(clientId, lease, semanticPaneId, rawInput, performanceTraceId, rawCausalProbe, onCausalResult) {
+    sendInput(clientId, lease, semanticPaneId, rawInput, performanceTraceId, rawCausalProbe, onCausalResult, expectedLifetime) {
         this.assertController(lease, clientId);
         const inputLease = this.#authority.leaseFor(clientId, "input");
         if (!inputLease) {
@@ -1037,7 +1037,11 @@ class SessionRuntime {
                 })
                 : null;
         const started = this.#observability.enabled ? this.#observability.nowMicros() : 0;
-        const replicaOwner = this.#terminalReplicaOwner(semanticPaneId);
+        const replicaOwner = expectedLifetime
+            ? this.#terminalReplicas.get(semanticPaneId)
+            : this.#terminalReplicaOwner(semanticPaneId);
+        if (!replicaOwner)
+            throw new Error("Input target lifetime unavailable");
         if (causalProbe) {
             this.#activeCausalCellProbes += 1;
             let settled = false;
@@ -1061,6 +1065,13 @@ class SessionRuntime {
             this.#outputTraces.arm(semanticPaneId, trace);
         }
         try {
+            // Synchronous final admission: never create a new owner to satisfy a stale
+            // held-input fence, and never await between this check and mirror dispatch.
+            if (expectedLifetime &&
+                (expectedLifetime.generation !== this.generation ||
+                    this.#terminalReplicas.get(semanticPaneId) !== replicaOwner ||
+                    replicaOwner.inputAdmissionIncarnation() !== expectedLifetime.incarnation))
+                throw new Error("Input target lifetime changed");
             if (input.kind === "text")
                 this.#mirror.sendText(this.session, semanticPaneId, input.data, performanceTraceId, causalProbe !== null);
             else if (input.kind === "bytes")
@@ -1564,9 +1575,9 @@ class SessionRuntimeConsumerImpl {
         this.#assertOpen();
         return this.#runtime.submitIntent(this.clientId, lease, operationId, intent);
     }
-    sendInput(lease, semanticPaneId, input, performanceTraceId, causalProbe, onCausalResult) {
+    sendInput(lease, semanticPaneId, input, performanceTraceId, causalProbe, onCausalResult, expectedLifetime) {
         this.#assertOpen();
-        this.#runtime.sendInput(this.clientId, lease, semanticPaneId, input, performanceTraceId, causalProbe, onCausalResult);
+        this.#runtime.sendInput(this.clientId, lease, semanticPaneId, input, performanceTraceId, causalProbe, onCausalResult, expectedLifetime);
     }
     failCausalCellProbe(semanticPaneId, traceId, reason) {
         this.#runtime.failCausalCellProbe(semanticPaneId, traceId, reason);

package/packages/daemon/dist/terminal/session-runtime/terminal-replica-interpreter.js

@@ -7,6 +7,9 @@ import { DISABLED_SESSION_RUNTIME_OBSERVABILITY, } from "./runtime-observability
 import { createXtermTerminalInterpreterBackend } from "./xterm-terminal-interpreter-backend.js";
 import { CAUSAL_CELL_OSC, CausalCellLedger, cellsEqual, } from "./causal-cell-ledger.js";
 import { KITTY_PLACEMENT_OSC, KittyApcScanner, KittyImageStore, } from "../graphics/kitty-graphics.js";
+// Bound parser work per turn without changing byte-stream semantics. This is a
+// batch bound, not a producer queue cap: upstream pressure must preserve bytes.
+const MAX_INGEST_BATCH_BYTES = 256 * 1024;
 /** Daemon-owned, sans-I/O VT interpreter with one FIFO for bytes and geometry. */
 export class TerminalReplicaInterpreter {
     #nativeSeedBackingCandidate;
@@ -35,8 +38,7 @@ export class TerminalReplicaInterpreter {
     #needsSeed = true;
     #closed = false;
     #walkCount = 0;
-    #pendingWrites = [];
-    #writeFlushScheduled = false;
+    #pendingWrites = null;
     #widgetGate = false;
     // kitty graphics: images outlive reseeds; the scanner owns split APCs.
     #kittyScanner = new KittyApcScanner();
@@ -106,16 +108,25 @@ export class TerminalReplicaInterpreter {
         if (operation.type === "write") {
             const data = operation.data.slice();
             const trace = operation.trace ?? null;
-            const pendingTrace = this.#pendingWrites[0]?.trace ?? null;
-            if (this.#pendingWrites.length > 0 &&
-                (pendingTrace?.traceId ?? null) !== (trace?.traceId ?? null))
+            if (this.#pendingWrites &&
+                (this.#pendingWrites.trace?.traceId ?? null) !== (trace?.traceId ?? null))
                 this.#flushWrites();
+            const group = (this.#pendingWrites ??= {
+                entries: [],
+                bytes: 0,
+                scheduled: false,
+                flushQueued: false,
+                trace,
+            });
             const promise = new Promise((resolve, reject) => {
-                this.#pendingWrites.push({ data, trace, resolve, reject });
+                group.entries.push({ data, offset: 0, resolve, reject });
+                group.bytes += data.length;
             });
-            if (!this.#writeFlushScheduled) {
-                this.#writeFlushScheduled = true;
-                this.#scheduler.microtask(() => this.#flushWrites());
+            // Leave this group open while the parser awaits its callback. Scheduling
+            // it once on the FIFO lets later arrivals join the next bounded batch.
+            if (!group.scheduled && !group.flushQueued) {
+                group.flushQueued = true;
+                this.#scheduler.microtask(() => this.#scheduleWriteGroup(group));
             }
             return promise;
         }
@@ -361,22 +372,26 @@ export class TerminalReplicaInterpreter {
         // serialize dozens of turns and fall behind a 30 fps image stream.
         if (scanned.forward.byteLength === 0)
             return;
-        await this.#writeToBackend(this.#backend, scanned.forward);
+        // Scanning can prepend an escape retained from the previous chunk. Bound
+        // the actual parser calls too, and union damage across every fragment.
+        for (let offset = 0; offset < scanned.forward.length; offset += MAX_INGEST_BATCH_BYTES) {
+            await this.#writeToBackend(this.#backend, scanned.forward.subarray(offset, offset + MAX_INGEST_BATCH_BYTES));
+            // The parser resets its dirty tracker per write. Synchronized output and
+            // bounded fragments can both span writes before canonical publication.
+            const dirty = this.#backend.dirtyRange();
+            const pending = this.#pendingWriteDirty;
+            this.#pendingWriteDirty =
+                pending === null
+                    ? dirty
+                    : pending === undefined || dirty === undefined
+                        ? undefined
+                        : {
+                            start: Math.min(pending.start, dirty.start),
+                            end: Math.max(pending.end, dirty.end),
+                        };
+        }
         if (this.#observability.enabled)
             this.#observability.recordSpan("parse", "terminal-replica-write", parseStarted, this.#observability.nowMicros(), trace);
-        // The parser resets its dirty tracker per write. Synchronized output may
-        // span many writes before publication, so retain their union until commit.
-        const dirty = this.#backend.dirtyRange();
-        const pending = this.#pendingWriteDirty;
-        this.#pendingWriteDirty =
-            pending === null
-                ? dirty
-                : pending === undefined || dirty === undefined
-                    ? undefined
-                    : {
-                        start: Math.min(pending.start, dirty.start),
-                        end: Math.max(pending.end, dirty.end),
-                    };
         // DEC synchronized-output is atomic: no intermediate frame leaks.
         if (this.#backend.requiresNativeReseed()) {
             this.#commit(false);
@@ -402,6 +417,7 @@ export class TerminalReplicaInterpreter {
             return;
         this.#syncRecovery = this.#scheduler.timer(() => {
             this.#syncRecovery = null;
+            this.#flushWrites();
             const run = this.#tail.then(async () => {
                 if (this.#closed || !this.#backend.modes().synchronizedOutput)
                     return;
@@ -661,22 +677,65 @@ export class TerminalReplicaInterpreter {
             }
         }
     }
+    /** Seal the current group at every trace, control and idle barrier. */
     #flushWrites() {
-        this.#writeFlushScheduled = false;
-        if (this.#pendingWrites.length === 0)
+        const group = this.#pendingWrites;
+        this.#pendingWrites = null;
+        if (group)
+            this.#scheduleWriteGroup(group);
+    }
+    #scheduleWriteGroup(group) {
+        if (group.scheduled)
             return;
-        const pending = this.#pendingWrites.splice(0);
-        const length = pending.reduce((total, entry) => total + entry.data.length, 0);
-        const data = new Uint8Array(length);
-        let offset = 0;
-        for (const entry of pending) {
-            data.set(entry.data, offset);
-            offset += entry.data.length;
-        }
-        const trace = pending.find(({ trace }) => trace !== null)?.trace ?? null;
-        const run = this.#tail.then(() => this.#write(data, trace));
+        group.scheduled = true;
+        const run = this.#tail.then(async () => {
+            try {
+                while (group.entries.length > 0) {
+                    const length = Math.min(group.bytes, MAX_INGEST_BATCH_BYTES);
+                    const data = new Uint8Array(length);
+                    const completed = [];
+                    let offset = 0;
+                    for (const entry of group.entries) {
+                        const take = Math.min(entry.data.length - entry.offset, length - offset);
+                        data.set(entry.data.subarray(entry.offset, entry.offset + take), offset);
+                        offset += take;
+                        entry.offset += take;
+                        if (entry.offset === entry.data.length)
+                            completed.push(entry);
+                        else
+                            break;
+                        if (offset === length && length > 0)
+                            break;
+                    }
+                    group.entries.splice(0, completed.length);
+                    group.bytes -= length;
+                    try {
+                        await this.#write(data, group.trace);
+                    }
+                    catch (error) {
+                        for (const entry of completed)
+                            entry.reject(error);
+                        throw error;
+                    }
+                    for (const entry of completed)
+                        entry.resolve();
+                }
+            }
+            catch (error) {
+                // Reject every remaining fragment in the failed group; later FIFO
+                // controls (including recovery reseeds and close) still execute.
+                for (const entry of group.entries)
+                    entry.reject(error);
+                group.entries.length = 0;
+                group.bytes = 0;
+                throw error;
+            }
+            finally {
+                if (this.#pendingWrites === group)
+                    this.#pendingWrites = null;
+            }
+        });
         this.#tail = run.catch(() => undefined);
-        void run.then(() => pending.forEach((entry) => entry.resolve()), (error) => pending.forEach((entry) => entry.reject(error)));
     }
     #observeMarkerBytes(data) {
         if (this.#widgetGate)

package/packages/daemon/dist/terminal/session-runtime/terminal-replica-owner.js

@@ -155,6 +155,12 @@ export class SessionRuntimeTerminalReplicaOwner {
     inputDispatchIncarnation() {
         return this.#disposed ? null : this.#publishedIncarnation;
     }
+    /** Scalar admission fence; unavailable while canonical replacement is pending. */
+    inputAdmissionIncarnation() {
+        return this.#disposed || this.#reseed || this.#waitingForGeometryCapture
+            ? null
+            : this.#publishedIncarnation;
+    }
     qualificationSnapshot() {
         const seed = this.#interpreter.currentSeed();
         return Object.freeze({

package/packages/daemon/dist/terminal/session-runtime/transport-binding.js

@@ -275,7 +275,7 @@ export class SessionRuntimeTransportBinding {
         authorize();
         return authorize;
     }
-    sendInput(semanticPaneId, input, performanceTraceId, causalProbe, onCausalResult) {
+    sendInput(semanticPaneId, input, performanceTraceId, causalProbe, onCausalResult, expectedLifetime) {
         this.assertController(semanticPaneId);
         const lease = this.#shared.lease;
         if (!lease) {
@@ -289,7 +289,7 @@ export class SessionRuntimeTransportBinding {
                     this.#causalCellProbes.delete(causalProbe.traceId);
                     onCausalResult?.(result);
                 }
-                : onCausalResult);
+                : onCausalResult, expectedLifetime);
         }
         catch (error) {
             if (causalProbe)

package/packages/daemon/dist/tui/mirror/runtime/application-generation-starter.js

@@ -67,8 +67,23 @@ export function createApplicationAgentNavigator(options) {
     return async (sessionName, paneId, source = "mouse") => {
         const token = ++navigationToken;
         const currentOwner = options.sessionOwner();
+        const snapshot = currentOwner.snapshot();
+        // A renderer rebind keeps its semantic control connection. Reserve this
+        // exact target synchronously; the controller fences and bounds first send.
+        const retainedControl = (() => {
+            try {
+                return (snapshot?.status === "rebinding" &&
+                    snapshot.connection?.workspaceName === sessionName &&
+                    snapshot.daemonGeneration &&
+                    snapshot.client &&
+                    Number.isSafeInteger(snapshot.client.getSnapshot().generation));
+            }
+            catch {
+                return false;
+            }
+        })();
         if (currentOwner.sessionName() === sessionName &&
-            applicationGenerationNavigationKey(currentOwner.snapshot()) !== null) {
+            (applicationGenerationNavigationKey(snapshot) !== null || retainedControl)) {
             // Sidebar agents belong to the already-live workspace. Select their pane
             // before returning control to OpenTUI so the very next key cannot leak to
             // the pane that was focused before the click.

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

@@ -1,3 +1,4 @@
+import { retainsAgentControl } from "./application-retained-agent.js";
 import { createApplicationHomeAgentNavigator, } from "./application-home-agent-navigation.js";
 import { applicationGenerationNavigationKey } from "./application-generation-starter.js";
 import { waitForHomeAgentSemantic } from "./application-home-agents-owner.js";
@@ -16,6 +17,18 @@ export function createApplicationMachineAgentNavigator(options) {
             opening = true;
             const selected = () => options.selectedMachineId() === machineId;
             const generation = () => selected() && options.generationMachineId() === machineId ? options.generation() : null;
+            if (selected() &&
+                options.isCurrentTarget(machineId, target) &&
+                options.sessionName() === target.sessionName &&
+                retainsAgentControl(generation(), target)) {
+                // Reserve before the next key; the terminal controller waits for a fresh
+                // coherent runtime and remains the only owner of physical input.
+                options.selectPane(target.paneId, source);
+                options.showTerminals(source);
+                options.setNote(null);
+                opening = false;
+                return Promise.resolve({ opened: true });
+            }
             current = createApplicationHomeAgentNavigator({
                 isCurrentTarget: (row) => selected() && options.isCurrentTarget(machineId, row),
                 currentGeneration() {

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

@@ -1,3 +1,4 @@
+import { retainsAgentControl } from "./application-retained-agent.js";
 import { fleetHostColor } from "./fleet-presentation.js";
 import { createFleetTabs } from "./application-fleet-tabs.js";
 import { saveMachineProfiles } from "../../../lib/local-fleet-request.js";
@@ -64,7 +65,7 @@ export function createApplicationMachineNavigation(options) {
     const [tabRevision, setTabRevision] = createSignal(0);
     const history = [...saved().recent].reverse();
     let historyIndex = history.length - 1;
-    const select = (id, expectedLiveSessionId, server) => {
+    const select = (id, expectedLiveSessionId, server, retainedAgent) => {
         if (!manager.getMachine(id))
             return false;
         if (manager.snapshot().selectedMachineId !== id) {
@@ -78,8 +79,15 @@ export function createApplicationMachineNavigation(options) {
             manager.select(id);
         }
         else if (expectedLiveSessionId) {
-            const attached = options.attachedTarget?.() ??
-                attachedMachineNavigationTarget(options.attachedGeneration?.() ?? null);
+            const active = options.attachedGeneration?.() ?? null;
+            const retained = retainedAgent && retainsAgentControl(active, retainedAgent)
+                ? {
+                    liveSessionId: active.connection.liveSessionId,
+                    daemonGeneration: active.daemonGeneration,
+                    ...(active.connection.server ? { server: active.connection.server } : {}),
+                }
+                : null;
+            const attached = options.attachedTarget?.() ?? attachedMachineNavigationTarget(active) ?? retained;
             const sameAuthority = attached?.liveSessionId === expectedLiveSessionId &&
                 (server
                     ? attached.server
@@ -302,7 +310,7 @@ export function createApplicationMachineNavigation(options) {
                 return;
             }
             options.cancelOpen();
-            if (!select(id, selectedSession?.liveSessionId, selectedSession?.server))
+            if (!select(id, selectedSession?.liveSessionId, selectedSession?.server, row))
                 return;
             if (selectedSession)
                 setActiveSessionKey(selectedSession.id);

package/packages/daemon/dist/tui/mirror/runtime/application-retained-agent.js

@@ -0,0 +1,18 @@
+/** Selection intent may wait on this exact retained control; input cannot use it yet. */
+export function retainsAgentControl(active, target) {
+    if (active?.status !== "rebinding" ||
+        !active.client ||
+        !target.paneId ||
+        active.daemonGeneration !== target.daemonInstanceId ||
+        active.connection?.workspaceName !== target.sessionName ||
+        active.connection.liveSessionId !== target.liveSessionId)
+        return false;
+    try {
+        const state = active.client.getSnapshot();
+        return (Number.isSafeInteger(state.generation) &&
+            state.semantic?.sidebar.agents.some((agent) => agent.id === target.agentId && agent.paneId === target.paneId) === true);
+    }
+    catch {
+        return false;
+    }
+}