tmux-ide 2.9.10 → 2.9.12

package/packages/daemon/dist/terminal/session-runtime/terminal-delivery-hub.js

@@ -1,7 +1,10 @@
+import { prepareProjection } from "./terminal-projection-delivery.js";
+import { TerminalProjectionEnvelopeSchemaZ, TerminalProjectionReceiptSchemaZ, TerminalProjectionMaterializeSchemaZ, } from "@tmux-ide/contracts";
+import { encodeTerminalProjectionCooperatively } from "@tmux-ide/core";
 import { StockCaptureTabUnavailableError } from "./stock-capture-fidelity.js";
 import { MAX_RETAINED_NATIVE_BACKING_BYTES, takeNativeSeedBacking, } from "./native-seed-backing.js";
 import { WorkspaceIdSchemaZ, TERMINAL_GRAPHICS_CAPABILITY_VERSION, TERMINAL_DELIVERY_PATCH_TO_SEED_BYTES, TERMINAL_DELIVERY_MAX_REPRESENTATION_BYTES, TerminalDeliveryEnvelopeSchemaZ, TerminalDeliveryAckSchemaZ, TerminalDeliveryNackSchemaZ, TerminalDeliveryOfferSchemaZ, TerminalDeliveryVisibilitySchemaZ, } from "@tmux-ide/contracts";
-import { TerminalDeliveryStateTooLargeError, terminalReplicaRowsEqual, TERMINAL_COMPACT_COOPERATIVE_SEED_CELLS, applyTerminalReplicaUpdate, applyTerminalReplicaUpdateCooperatively, terminalReplicaUpdateNeedsCooperativeReduction, encodeCompactSemanticTerminalUpdate, encodeCompactSemanticTerminalUpdateCooperatively, terminalSemanticUpdateNeedsCooperativeEncoding, encodeAnsiTerminalRepresentation, encodeSemanticTerminalUpdate, hashTerminalDeliveryRepresentation, negotiateTerminalDelivery, preaccountSemanticTerminalUpdateBytes, } from "@tmux-ide/core";
+import { TerminalDeliveryStateTooLargeError, terminalReplicaRowsEqual, TERMINAL_COMPACT_COOPERATIVE_SEED_CELLS, applyTerminalReplicaUpdate, applyTerminalReplicaUpdateCooperatively, terminalReplicaUpdateNeedsCooperativeReduction, encodeBinarySemanticTerminalUpdate, encodeBinarySemanticTerminalUpdateCooperatively, encodeCompactSemanticTerminalUpdate, encodeCompactSemanticTerminalUpdateCooperatively, terminalSemanticUpdateNeedsCooperativeEncoding, encodeAnsiTerminalRepresentation, encodeSemanticTerminalUpdate, hashTerminalDeliveryRepresentation, negotiateTerminalDelivery, preaccountSemanticTerminalUpdateBytes, } from "@tmux-ide/core";
 import { SYSTEM_SESSION_RUNTIME_SCHEDULER, } from "./runtime-scheduler.js";
 import { DISABLED_SESSION_RUNTIME_OBSERVABILITY, } from "./runtime-observability.js";
 import { registerTerminalDeliveryObservationOrdinal } from "./terminal-delivery-observation-identity.js";
@@ -15,6 +18,13 @@ const MAX_PANES = 32;
 const MAX_PENDING_CANONICAL_CELLS = 1_000_000;
 const MAX_CONNECTIONS = MAX_CLIENTS * MAX_PANES;
 const BACKGROUND_CADENCE_MS = 100;
+class DeferredProjectionEncoding extends Error {
+    payload;
+    constructor(payload) {
+        super("Deferred projection encoding");
+        this.payload = payload;
+    }
+}
 class DeferredSeedEncoding extends Error {
     payload;
     constructor(payload) {
@@ -135,6 +145,10 @@ export class SessionRuntimeTerminalDeliveryHub {
                 visibility: "visible",
                 baselineRevision: -1,
                 baselineHash: null,
+                projectionBaseline: null,
+                materializeRequested: false,
+                lastProjectionReceipt: null,
+                lastMaterialize: null,
                 reseedRequired: false,
                 inFlight: null,
                 latestRevision: pane.latest?.update.revision ?? null,
@@ -159,6 +173,8 @@ export class SessionRuntimeTerminalDeliveryHub {
                 negotiation,
                 closed,
                 ack: (ack) => this.#ack(client, ack),
+                projectionReceipt: (receipt) => this.#projectionReceipt(client, receipt),
+                materialize: (request) => this.#materialize(client, request),
                 nack: (nack) => this.#nack(client, nack),
                 setVisibility: (visibilityInput) => {
                     if (client.closed)
@@ -587,7 +603,10 @@ export class SessionRuntimeTerminalDeliveryHub {
             if (!client.lifecycleOpenRecorded)
                 client.lifecycleOpenRecorded = this.#recordDeliveryLifecycle(client, pane, "open");
             if (update.type === "terminal.tombstone" &&
-                (client.inFlight !== null || client.encoding !== null || client.visibility !== "visible")) {
+                (client.inFlight !== null ||
+                    client.encoding !== null ||
+                    client.visibility !== "visible" ||
+                    client.projectionBaseline !== null)) {
                 this.#fault(client, "source-closed", "Terminal source closed before final state delivery");
                 continue;
             }
@@ -705,8 +724,13 @@ export class SessionRuntimeTerminalDeliveryHub {
             encodedRepresentation = representation;
             const transactionId = this.#scheduler.createId();
             const chunkCount = Math.max(1, Math.ceil(representation.bytes.byteLength / (256 * 1024)));
-            const envelope = TerminalDeliveryEnvelopeSchemaZ.parse({
-                type: "terminal.delivery",
+            const envelope = (representation.projection
+                ? TerminalProjectionEnvelopeSchemaZ
+                : TerminalDeliveryEnvelopeSchemaZ).parse({
+                type: representation.projection ? "terminal.projection" : "terminal.delivery",
+                ...(representation.projection
+                    ? { projectionStateHash: representation.projection.hash }
+                    : {}),
                 workspaceName: client.deliveryWorkspaceName,
                 semanticPaneId: target.update.semanticPaneId,
                 generation: target.update.generation,
@@ -717,7 +741,11 @@ export class SessionRuntimeTerminalDeliveryHub {
                 protocolVersion: 1,
                 encoding: representation.encoding ?? client.negotiated.encoding,
                 frame: representation.frame,
-                baseRevision: representation.frame === "seed" ? null : Math.max(0, client.baselineRevision),
+                baseRevision: representation.projection
+                    ? representation.projectionBaseRevision
+                    : representation.frame === "seed"
+                        ? null
+                        : Math.max(0, client.baselineRevision),
                 canonicalRevision: target.update.revision,
                 canonicalStateHash: target.update.stateHash,
                 representationHash: representation.representationHash ??
@@ -733,6 +761,7 @@ export class SessionRuntimeTerminalDeliveryHub {
             registerTerminalDeliveryObservationOrdinal(envelope, deliveryOrdinal);
             client.inFlight = {
                 envelope,
+                projection: representation.projection ?? null,
                 deliveryOrdinal,
                 bytes: representation.bytes,
                 nextChunk: 0,
@@ -744,9 +773,9 @@ export class SessionRuntimeTerminalDeliveryHub {
                 pane.pendingDeliveryTrace = null;
         }
         catch (error) {
-            if (error instanceof DeferredSeedEncoding) {
+            if (error instanceof DeferredSeedEncoding || error instanceof DeferredProjectionEncoding) {
                 deferred = true;
-                this.#startEncoding(client, pane, target, error.payload, traceStarted);
+                this.#startEncoding(client, pane, target, error.payload, traceStarted, error instanceof DeferredProjectionEncoding);
                 return;
             }
             failedSelectionObservation = semanticSelectionObservationFromError(error);
@@ -804,7 +833,7 @@ export class SessionRuntimeTerminalDeliveryHub {
                 }
         }
     }
-    #startEncoding(client, pane, target, payload, traceStarted) {
+    #startEncoding(client, pane, target, payload, traceStarted, projection = false) {
         const key = cacheKey([
             target.update.workspaceName,
             client.paneId,
@@ -814,6 +843,9 @@ export class SessionRuntimeTerminalDeliveryHub {
             target.update.stateHash,
             client.negotiated.encoding,
             client.negotiated.richPlacements ? "rich" : "plain",
+            projection
+                ? `projection:${client.projectionBaseline?.revision ?? -1}:${client.projectionBaseline?.hash ?? "none"}`
+                : "complete",
         ]);
         let job = this.#pendingEncodings.get(key);
         let created = false;
@@ -844,10 +876,13 @@ export class SessionRuntimeTerminalDeliveryHub {
         owned.clients.add(client);
         if (!created)
             return;
-        void encodeCompactSemanticTerminalUpdateCooperatively(payload, {
-            signal: owned.abort.signal,
-            yieldControl: () => this.#yieldEncoding(owned),
-        }).then((bytes) => this.#completeEncoding(owned, { bytes }), (error) => this.#completeEncoding(owned, { error }));
+        const options = { signal: owned.abort.signal, yieldControl: () => this.#yieldEncoding(owned) };
+        const result = projection
+            ? encodeTerminalProjectionCooperatively(payload, options)
+            : client.negotiated.encoding === "semantic-binary-v1"
+                ? encodeBinarySemanticTerminalUpdateCooperatively(payload, options)
+                : encodeCompactSemanticTerminalUpdateCooperatively(payload, options);
+        void result.then((bytes) => this.#completeEncoding(owned, { bytes }), (error) => this.#completeEncoding(owned, { error }));
     }
     #yieldEncoding(job) {
         if (this.#scheduler.nowMs() - job.yieldStartedAt < 2)
@@ -914,6 +949,27 @@ export class SessionRuntimeTerminalDeliveryHub {
         this.#pruneCanonicalRevisions(client.paneId);
     }
     #representation(client, pane, target, seedOutcome) {
+        const snapshotForProjection = target.state.snapshot;
+        if (client.negotiated.alternateScreenProjection &&
+            !client.materializeRequested &&
+            (client.baselineRevision < 0 || client.projectionBaseline !== null) &&
+            snapshotForProjection?.modes.alternateScreen &&
+            snapshotForProjection.history.length > 0) {
+            const { payload, retained } = prepareProjection(snapshotForProjection, target.update.revision, target.update.incarnation, client.reseedRequired ? null : client.projectionBaseline);
+            if (!seedOutcome)
+                throw new DeferredProjectionEncoding(payload);
+            if ("error" in seedOutcome)
+                throw seedOutcome.error;
+            return {
+                bytes: seedOutcome.bytes,
+                encoding: "alternate-projection-binary-v1",
+                frame: payload.frame,
+                history: "deferred",
+                canonicalEquivalent: false,
+                projection: retained,
+                projectionBaseRevision: payload.frame === "seed" ? null : payload.baseRevision,
+            };
+        }
         const key = cacheKey([
             target.update.workspaceName,
             target.update.semanticPaneId,
@@ -937,18 +993,24 @@ export class SessionRuntimeTerminalDeliveryHub {
         const snapshot = target.state.snapshot;
         let result = null;
         if (client.negotiated.encoding === "semantic-v1" ||
-            client.negotiated.encoding === "semantic-compact-v1") {
+            client.negotiated.encoding === "semantic-compact-v1" ||
+            client.negotiated.encoding === "semantic-binary-v1") {
             const encodeSemantic = (payload) => {
-                if (client.negotiated.encoding !== "semantic-compact-v1")
+                if (client.negotiated.encoding !== "semantic-compact-v1" &&
+                    client.negotiated.encoding !== "semantic-binary-v1")
                     return encodeSemanticTerminalUpdate(payload);
-                if (terminalSemanticUpdateNeedsCooperativeEncoding(payload)) {
+                if (payload.frame === "seed" &&
+                    (client.negotiated.encoding === "semantic-binary-v1" ||
+                        terminalSemanticUpdateNeedsCooperativeEncoding(payload))) {
                     if (!seedOutcome)
                         throw new DeferredSeedEncoding(payload);
                     if ("error" in seedOutcome)
                         throw seedOutcome.error;
                     return seedOutcome.bytes;
                 }
-                return encodeCompactSemanticTerminalUpdate(payload);
+                return client.negotiated.encoding === "semantic-binary-v1"
+                    ? encodeBinarySemanticTerminalUpdate(payload)
+                    : encodeCompactSemanticTerminalUpdate(payload);
             };
             if (client.reseedRequired) {
                 const payload = semanticSeed(target);
@@ -1213,6 +1275,10 @@ export class SessionRuntimeTerminalDeliveryHub {
             return;
         }
         const envelope = flight.envelope;
+        if (envelope.type !== "terminal.delivery") {
+            this.#fault(client, "protocol-violation", "Canonical ACK cannot acknowledge a projection");
+            return;
+        }
         if (flight.nextChunk !== envelope.chunkCount ||
             ack.workspaceName !== envelope.workspaceName ||
             ack.semanticPaneId !== envelope.semanticPaneId ||
@@ -1227,6 +1293,8 @@ export class SessionRuntimeTerminalDeliveryHub {
             return;
         }
         this.#maxSlowClientMs = Math.max(this.#maxSlowClientMs, this.#scheduler.nowMs() - flight.sentAt);
+        client.projectionBaseline = null;
+        client.lastProjectionReceipt = null;
         client.baselineRevision = ack.canonicalRevision;
         client.baselineHash = ack.canonicalStateHash;
         client.reseedRequired = false;
@@ -1277,6 +1345,68 @@ export class SessionRuntimeTerminalDeliveryHub {
         this.#schedule(client);
         this.#recordDeliveryStatus(client, this.#panes.get(client.paneId));
     }
+    #projectionReceipt(client, input) {
+        const receipt = TerminalProjectionReceiptSchemaZ.parse(input);
+        if (client.lastProjectionReceipt &&
+            JSON.stringify(client.lastProjectionReceipt) === JSON.stringify(receipt))
+            return;
+        const flight = client.inFlight;
+        const envelope = flight?.envelope;
+        if (!flight ||
+            !flight.projection ||
+            envelope?.type !== "terminal.projection" ||
+            flight.nextChunk !== envelope.chunkCount ||
+            receipt.workspaceName !== envelope.workspaceName ||
+            receipt.semanticPaneId !== envelope.semanticPaneId ||
+            receipt.generation !== envelope.generation ||
+            receipt.incarnation !== envelope.incarnation ||
+            receipt.deliveryNonce !== envelope.deliveryNonce ||
+            receipt.transactionId !== envelope.transactionId ||
+            receipt.canonicalRevision !== envelope.canonicalRevision ||
+            receipt.canonicalStateHash !== envelope.canonicalStateHash ||
+            receipt.projectionStateHash !== envelope.projectionStateHash ||
+            receipt.representationHash !== envelope.representationHash) {
+            this.#fault(client, "protocol-violation", "Projection receipt does not identify the in-flight projection");
+            return;
+        }
+        client.projectionBaseline = flight.projection;
+        client.lastProjectionReceipt = receipt;
+        client.reseedRequired = false;
+        client.inFlight = null;
+        if (client.latestRevision === receipt.canonicalRevision)
+            client.latestRevision = null;
+        if (client.materializeRequested)
+            client.latestRevision = this.#panes.get(client.paneId)?.latest?.update.revision ?? null;
+        this.#pruneCanonicalRevisions(client.paneId);
+        this.#schedule(client);
+        this.#recordDeliveryStatus(client, this.#panes.get(client.paneId));
+    }
+    #materialize(client, input) {
+        const request = TerminalProjectionMaterializeSchemaZ.parse(input);
+        if (client.lastMaterialize &&
+            JSON.stringify(client.lastMaterialize) === JSON.stringify(request))
+            return;
+        const baseline = client.projectionBaseline;
+        if (!client.negotiated.alternateScreenProjection ||
+            !baseline ||
+            request.workspaceName !== client.deliveryWorkspaceName ||
+            request.semanticPaneId !== client.paneId ||
+            request.generation !== client.negotiated.generation ||
+            request.incarnation !== baseline.incarnation ||
+            request.deliveryNonce !== client.negotiated.deliveryNonce ||
+            request.canonicalRevision !== baseline.revision ||
+            request.projectionStateHash !== baseline.hash) {
+            this.#fault(client, "protocol-violation", "History request does not identify the retained projection");
+            return;
+        }
+        client.lastMaterialize = request;
+        client.materializeRequested = true;
+        this.#cancelEncoding(client);
+        client.latestRevision = this.#panes.get(client.paneId)?.latest?.update.revision ?? null;
+        // A queued projection still owns its transaction until its receipt arrives.
+        // The following complete seed then supersedes it, including at the same revision.
+        this.#schedule(client);
+    }
     #nack(client, input) {
         const nack = TerminalDeliveryNackSchemaZ.parse(input);
         const closed = client.sourceClosedFlight;

package/packages/daemon/dist/terminal/session-runtime/terminal-projection-delivery.js

@@ -0,0 +1,32 @@
+import { hashTerminalProjection, projectAlternateSnapshot, terminalReplicaRowsEqual, } from "@tmux-ide/core";
+export function prepareProjection(snapshot, revision, incarnation, baseline) {
+    const projected = projectAlternateSnapshot(snapshot);
+    const retained = {
+        revision,
+        incarnation,
+        hash: hashTerminalProjection(projected),
+        snapshot: projected,
+    };
+    if (!baseline ||
+        baseline.incarnation !== incarnation ||
+        baseline.snapshot.cols !== projected.cols ||
+        baseline.snapshot.rows !== projected.rows)
+        return { payload: { frame: "seed", revision, projection: projected }, retained };
+    const rows = projected.grid.flatMap((row, index) => terminalReplicaRowsEqual(row, baseline.snapshot.grid[index]) ? [] : [{ index, row }]);
+    return {
+        retained,
+        payload: {
+            frame: "patch",
+            baseRevision: baseline.revision,
+            revision,
+            patch: {
+                rows,
+                deferredHistory: projected.deferredHistory,
+                cursor: projected.cursor,
+                modes: projected.modes,
+                placements: projected.placements,
+                bootstrap: projected.bootstrap,
+            },
+        },
+    };
+}

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,11 @@ export class SessionRuntimeTerminalReplicaOwner {
     inputDispatchIncarnation() {
         return this.#disposed ? null : this.#publishedIncarnation;
     }
+    /** Screen recapture does not replace the terminal lifetime. Keep its input fence
+     * while resizing; disposal or a new owner still invalidates held input. */
+    inputAdmissionIncarnation() {
+        return this.#disposed ? 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/open-tui-workspace-runtime-port.js

@@ -335,6 +335,10 @@ class WireTerminalEndpoint {
         }
         if (this.#unavailable)
             return;
+        if (message.type === "terminal.projection") {
+            this.#failConnection(new Error("Unsolicited alternate-screen projection"));
+            return;
+        }
         if (message.type === "terminal.delivery") {
             this.#acceptEnvelope(message);
             return;

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;
+    }
+}