tmux-ide 2.9.6 → 2.9.8

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

@@ -1,6 +1,6 @@
 import { StockCaptureTabUnavailableError } from "./stock-capture-fidelity.js";
 import { MAX_RETAINED_NATIVE_BACKING_BYTES, takeNativeSeedBacking, } from "./native-seed-backing.js";
-import { WorkspaceIdSchemaZ, TERMINAL_DELIVERY_PATCH_TO_SEED_BYTES, TERMINAL_DELIVERY_MAX_REPRESENTATION_BYTES, TerminalDeliveryEnvelopeSchemaZ, TerminalDeliveryAckSchemaZ, TerminalDeliveryNackSchemaZ, TerminalDeliveryOfferSchemaZ, TerminalDeliveryVisibilitySchemaZ, } from "@tmux-ide/contracts";
+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 { SYSTEM_SESSION_RUNTIME_SCHEDULER, } from "./runtime-scheduler.js";
 import { DISABLED_SESSION_RUNTIME_OBSERVABILITY, } from "./runtime-observability.js";
@@ -171,6 +171,9 @@ export class SessionRuntimeTerminalDeliveryHub {
                     this.#recordDeliveryStatus(client, this.#panes.get(client.paneId));
                 },
                 close: async () => this.#closeClient(client),
+                ...(offer.protocolVersions.includes(TERMINAL_GRAPHICS_CAPABILITY_VERSION)
+                    ? { graphics: this.#graphicsFor(semanticPaneId, client, closed) }
+                    : {}),
             };
         }
         catch (error) {
@@ -196,6 +199,22 @@ export class SessionRuntimeTerminalDeliveryHub {
             this.#pendingClients.delete(key);
         }
     }
+    #graphicsFor(semanticPaneId, client, closed) {
+        const owner = this.#ownerForPane(semanticPaneId);
+        return {
+            subscribe: (listener) => {
+                if (client.closed || !owner.subscribeGraphics)
+                    return () => { };
+                const unsubscribe = owner.subscribeGraphics((state) => {
+                    if (!client.closed)
+                        listener(state);
+                });
+                void closed.then(unsubscribe);
+                return unsubscribe;
+            },
+            image: (digest) => (client.closed ? null : (owner.graphicsImage?.(digest) ?? null)),
+        };
+    }
     /** Retire only this pane's delivery owners before its canonical owner is disposed. */
     failPaneCapture(semanticPaneId, error) {
         for (const client of this.#clients.values())

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

@@ -6,6 +6,7 @@ import { SYSTEM_SESSION_RUNTIME_SCHEDULER, } from "./runtime-scheduler.js";
 import { DISABLED_SESSION_RUNTIME_OBSERVABILITY, } from "./runtime-observability.js";
 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";
 /** Daemon-owned, sans-I/O VT interpreter with one FIFO for bytes and geometry. */
 export class TerminalReplicaInterpreter {
     #nativeSeedBackingCandidate;
@@ -37,6 +38,13 @@ export class TerminalReplicaInterpreter {
     #pendingWrites = [];
     #writeFlushScheduled = false;
     #widgetGate = false;
+    // kitty graphics: images outlive reseeds; the scanner owns split APCs.
+    #kittyScanner = new KittyApcScanner();
+    #kitty;
+    #kittyPending = new Map();
+    #graphicsListeners = new Set();
+    #graphics = null;
+    #graphicsKey = "";
     #markerTail = "";
     #pendingResize = null;
     // null: no unpublished writes; undefined: a write requires full projection.
@@ -79,6 +87,8 @@ export class TerminalReplicaInterpreter {
             rows: options.rows,
             scrollback: this.#scrollback,
         });
+        this.#kitty = new KittyImageStore(options.kittyImageBudget ? { budget: options.kittyImageBudget } : {});
+        this.#attachKitty(this.#backend);
         this.#snapshot = blankTerminalReplicaSnapshot(options.cols, options.rows);
         this.#seedReady = new Promise((resolve, reject) => {
             this.#resolveSeedReady = resolve;
@@ -239,6 +249,18 @@ export class TerminalReplicaInterpreter {
             }
             const previous = this.#backend;
             this.#backend = replacement;
+            this.#attachKitty(replacement);
+            // A capture replay does not erase graphics already observed by this owner.
+            // Keep anchors only when both backends agree on their coordinate basis;
+            // reflow, history replacement and authoritative stream resets are ambiguous.
+            const sameGraphicsBasis = operation.bootstrap === "painted-capture" &&
+                previous.cols === replacement.cols &&
+                previous.rows === replacement.rows &&
+                previous.graphicsViewportTop?.() !== undefined &&
+                previous.graphicsViewportTop?.() === replacement.graphicsViewportTop?.() &&
+                previous.modes().alternateScreen === replacement.modes().alternateScreen;
+            if (!sameGraphicsBasis)
+                this.#kitty.dropCursorPlacements();
             this.#nativeReseedRequested = false;
             this.#scrollback = scrollback;
             this.#bootstrap = {
@@ -262,6 +284,7 @@ export class TerminalReplicaInterpreter {
                 this.#nativeSeedBackingCandidate = undefined;
             }
             previous.dispose();
+            this.#publishGraphics();
             return;
         }
         if (operation.type === "cursor") {
@@ -276,6 +299,8 @@ export class TerminalReplicaInterpreter {
             return;
         }
         if (operation.type === "resize") {
+            if (operation.cols !== this.#backend.cols || operation.rows !== this.#backend.rows)
+                this.#kitty.dropCursorPlacements();
             this.#causalCell?.fail("geometry-drift");
             if (this.#backend.modes().synchronizedOutput) {
                 // Geometry is part of the admitted FIFO even while publication is
@@ -287,6 +312,7 @@ export class TerminalReplicaInterpreter {
             }
             this.#backend.resize(operation.cols, operation.rows);
             this.#commit(false);
+            this.#publishGraphics();
             return;
         }
         const baseRevision = this.#revision;
@@ -304,6 +330,7 @@ export class TerminalReplicaInterpreter {
         };
         this.#revision = revision;
         this.#closed = true;
+        this.#kitty.dispose();
         this.#causalCell?.fail("transport-closed");
         this.#clearSyncRecovery();
         if (this.#needsSeed)
@@ -321,8 +348,20 @@ export class TerminalReplicaInterpreter {
         this.#admitRaw(data);
         this.#stats.parseBatches += 1;
         this.#observeMarkerBytes(data);
+        const scanned = this.#kittyScanner.scan(data);
+        for (const command of scanned.commands)
+            this.#kittyPending.set(command.marker, command);
         const parseStarted = this.#observability.enabled ? this.#observability.nowMicros() : 0;
-        await this.#writeToBackend(this.#backend, data);
+        // Always forward the scanner's output: tmux splits %output (~2 KiB) inside
+        // kitty APCs (~4 KiB chunks), so a chunk with no completed command can still
+        // be all image payload that must never reach the VT parser as text.
+        // A chunk entirely inside image payload changes nothing the parser can
+        // see. Skipping it matters: every parser write settles on a later timer
+        // turn, so a frame split into dozens of %output chunks would otherwise
+        // 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);
         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
@@ -356,6 +395,7 @@ export class TerminalReplicaInterpreter {
         else {
             this.#commit(false, this.#backend.dirtyRange(), trace);
         }
+        this.#publishGraphics();
     }
     #scheduleSyncRecovery() {
         if (this.#syncRecovery || this.#closed)
@@ -541,6 +581,50 @@ export class TerminalReplicaInterpreter {
             bootstrap: this.#bootstrap,
         });
     }
+    /** The pane's kitty image store (bytes for the graphics side channel). */
+    kittyImages() {
+        return this.#kitty;
+    }
+    /** Latest graphics state, or null while the pane has never held an image. */
+    currentGraphics() {
+        return this.#graphics;
+    }
+    onGraphics(listener) {
+        this.#graphicsListeners.add(listener);
+        return () => this.#graphicsListeners.delete(listener);
+    }
+    /** Publish graphics state when the store or the viewport-relative placements moved. */
+    #publishGraphics() {
+        if (this.#graphics === null && this.#kitty.revision === 0)
+            return;
+        const state = this.#kitty.state(this.#backend.graphicsViewportTop?.() ?? 0, this.#backend.rows, this.#backend.cols, this.#backend.modes().alternateScreen);
+        const key = JSON.stringify([state.revision, state.placements]);
+        if (key === this.#graphicsKey)
+            return;
+        this.#graphicsKey = key;
+        this.#graphics = state;
+        for (const listener of this.#graphicsListeners) {
+            try {
+                listener(state);
+            }
+            catch {
+                // Renderer callbacks never poison the authoritative parser FIFO.
+            }
+        }
+    }
+    #attachKitty(backend) {
+        // Minimal test backends omit the OSC seam; they simply never place images.
+        if (typeof backend.registerOscHandler !== "function")
+            return;
+        backend.registerOscHandler(KITTY_PLACEMENT_OSC, (data) => {
+            const command = this.#kittyPending.get(Number(data));
+            if (!command)
+                return true;
+            this.#kittyPending.delete(Number(data));
+            this.#kitty.apply(command, backend.graphicsCursor?.() ?? null);
+            return true;
+        });
+    }
     #currentSnapshotHash() {
         return (this.#snapshotHash ??= hashTerminalReplicaSnapshot(this.#snapshot));
     }

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

@@ -1,3 +1,4 @@
+import { HistoryAnchorOwner, } from "./history-anchor-owner.js";
 import { layoutContentRows } from "../mirror/layout-content-rows.js";
 import { terminalReplicaRowsEqual } from "@tmux-ide/core";
 import { projectNativeGridRow } from "../mirror/native-grid-projection.js";
@@ -20,6 +21,7 @@ export class SessionRuntimeTerminalReplicaOwner {
     #start;
     #upstream = null;
     #disposed = false;
+    #historyAnchors = new HistoryAnchorOwner();
     #cols = 80;
     #rows = 24;
     #layoutEpoch = 0;
@@ -56,12 +58,14 @@ export class SessionRuntimeTerminalReplicaOwner {
                 if (this.#disposed || this.#reseed || this.#waitingForGeometryCapture)
                     return;
                 this.#waitingForGeometryCapture = true;
+                this.#historyAnchors.invalidate();
                 this.#supervise(this.#start.then(() => {
                     if (!this.#disposed && this.#waitingForGeometryCapture)
                         this.#upstream?.reseed();
                 }));
             },
             onUpdate: (update, trace) => {
+                this.#historyAnchors.observe(update);
                 this.#publishedIncarnation = update.incarnation;
                 if (update.type === "terminal.seed") {
                     this.#bootstrapped = true;
@@ -137,6 +141,16 @@ export class SessionRuntimeTerminalReplicaOwner {
     failCausalCell(reason, traceId) {
         this.#interpreter.failCausalCell(reason, traceId);
     }
+    captureHistoryAnchor(proof, historyIndex) {
+        if (this.#disposed || this.#reseed || this.#waitingForGeometryCapture)
+            return { status: "unavailable" };
+        return this.#historyAnchors.capture(proof, historyIndex);
+    }
+    resolveHistoryAnchor(proof, token) {
+        if (this.#disposed || this.#reseed || this.#waitingForGeometryCapture)
+            return { status: "unavailable" };
+        return this.#historyAnchors.resolve(proof, token);
+    }
     /** Scalar diagnostic only: no seed construction, hashing, or owner creation. */
     inputDispatchIncarnation() {
         return this.#disposed ? null : this.#publishedIncarnation;
@@ -248,6 +262,17 @@ export class SessionRuntimeTerminalReplicaOwner {
             },
         };
     }
+    /** Kitty graphics side channel: current state now (if any), then every change. */
+    subscribeGraphics(listener) {
+        const current = this.#interpreter.currentGraphics();
+        if (current)
+            listener(current);
+        return this.#interpreter.onGraphics(listener);
+    }
+    /** Image bytes by content digest, while the pane's store still holds them. */
+    graphicsImage(digest) {
+        return this.#interpreter.kittyImages().imageByDigest(digest) ?? null;
+    }
     async subscribeSource(listener, onRaw) {
         const canonical = await this.subscribe(listener);
         this.#rawListeners.add(onRaw);
@@ -268,6 +293,7 @@ export class SessionRuntimeTerminalReplicaOwner {
             return;
         this.#noteLifecycle(`dispose-${reason}`);
         this.#disposed = true;
+        this.#historyAnchors.invalidate();
         this.#historyTimer?.cancel();
         this.#historyTimer = null;
         this.#subscriptionEpoch += 1;
@@ -330,6 +356,7 @@ export class SessionRuntimeTerminalReplicaOwner {
             // Deterministic capture point: reset opens the atomic capture. A probe
             // armed after reset belongs to the next post-capture delta, never to this
             // already-started reseed.
+            this.#historyAnchors.invalidate();
             this.#reseed = {
                 nativeCols: event.cols,
                 nativeRows: event.rows,
@@ -447,6 +474,7 @@ export class SessionRuntimeTerminalReplicaOwner {
         if (!this.#bootstrapped || this.#reseed || this.#waitingForGeometryCapture)
             return;
         this.#waitingForGeometryCapture = true;
+        this.#historyAnchors.invalidate();
         void this.#start.then(() => {
             if (!this.#disposed && this.#waitingForGeometryCapture)
                 this.#upstream?.reseed();
@@ -557,6 +585,7 @@ export class SessionRuntimeTerminalReplicaOwner {
         this.#noteLifecycle("reseed-retry", diagnostic);
         this.#reseedRetryCount += 1;
         this.#waitingForGeometryCapture = true;
+        this.#historyAnchors.invalidate();
         void this.#start.then(() => {
             if (!this.#disposed)
                 this.#upstream?.reseed();
@@ -564,6 +593,7 @@ export class SessionRuntimeTerminalReplicaOwner {
     }
     #supervise(operation) {
         void operation.catch((error) => {
+            this.#historyAnchors.invalidate();
             this.#noteLifecycle("interpreter-fault");
             this.#interpreter.abort(error);
             this.#onFault?.(error);

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

@@ -29,6 +29,13 @@ function assertLiveControllerPrincipal(shared, lease) {
         throw new SessionRuntimeControllerLeaseError("stale-controller-lease", "The host no longer owns session controller authority.");
     }
 }
+function holdsCurrentLease(shared) {
+    const lease = shared.lease;
+    if (!lease)
+        return false;
+    const snapshot = shared.consumer.controllerSnapshot();
+    return snapshot.controllerClientId === lease.clientId && snapshot.revision === lease.revision;
+}
 const clientsByRegistry = new WeakMap();
 function authenticatedSurface(transport, hostClientId) {
     // The production host and development gateway mint these principals
@@ -290,6 +297,10 @@ export class SessionRuntimeTransportBinding {
             throw error;
         }
     }
+    setCellPixels(width, height, precise) {
+        this.#assertOpen();
+        this.#shared.consumer.setCellPixels?.(width, height, precise);
+    }
     fitViewport(expectedLease, cols, rows, semanticWindowId) {
         this.#assertOpen();
         if (this.#shared.geometryTransportLeaseIds.at(-1) !== this.#transportLeaseId) {
@@ -471,18 +482,33 @@ export class SessionRuntimeTransportBinder {
             : this.registry.bindExecutionSource(base, sourceSemanticPaneId);
     }
     activateController(target) {
-        if (target.lease)
+        if (target.lease && holdsCurrentLease(target))
             return;
-        const current = [...this.#clients.values()].find((candidate) => candidate !== target &&
-            candidate.consumer.session === target.consumer.session &&
-            candidate.lease);
-        if (current?.lease) {
-            const previous = current.lease;
-            current.lease = null;
-            target.lease = current.consumer.handoffController(previous, target.consumer.clientId);
+        target.lease = null;
+        const controllerClientId = target.consumer.controllerSnapshot().controllerClientId;
+        const current = controllerClientId === null || controllerClientId === target.consumer.clientId
+            ? undefined
+            : [...this.#clients.values()].find((candidate) => candidate !== target &&
+                candidate.consumer.session === target.consumer.session &&
+                candidate.consumer.clientId === controllerClientId);
+        if (!current) {
+            // Free, already ours, or held by a principal outside this binder (for
+            // example the command-center owner route): plain acquisition decides.
+            target.lease = target.consumer.acquireController();
             return;
         }
-        target.lease = target.consumer.acquireController();
+        // A transport-bound holder whose binding lost its executable lease can
+        // never type again, yet it would keep every other viewer locked out. Re-
+        // derive its exact current lease so the handoff below reclaims it; a live
+        // holder simply hands off as before. Either way only one client can type.
+        const previous = current.lease && holdsCurrentLease(current)
+            ? current.lease
+            : current.consumer.acquireController();
+        const handedOff = current.consumer.handoffController(previous, target.consumer.clientId);
+        // Drop the holder's lease only after the runtime accepted the handoff; a
+        // refusal (e.g. during topology verification) must leave it executable.
+        current.lease = null;
+        target.lease = handedOff;
     }
     async release(shared, grants, interactive) {
         if (shared.refs <= 0)
@@ -500,19 +526,25 @@ export class SessionRuntimeTransportBinder {
         shared.refs -= 1;
         if (shared.refs > 0)
             return;
-        if (shared.lease) {
-            // A same-host passive session channel keeps the controller PRINCIPAL
-            // continuous across interactive pane retargeting. It contributes no
-            // source-pane grant and cannot type; the lease retires with the last
-            // host/session ref, while a passive-only host never acquires one.
-            const retired = shared.lease;
-            shared.lease = null;
-            shared.consumer.releaseController(retired);
+        try {
+            if (shared.lease) {
+                // A same-host passive session channel keeps the controller PRINCIPAL
+                // continuous across interactive pane retargeting. It contributes no
+                // source-pane grant and cannot type; the lease retires with the last
+                // host/session ref, while a passive-only host never acquires one.
+                const retired = shared.lease;
+                shared.lease = null;
+                shared.consumer.releaseController(retired);
+            }
         }
-        for (const [key, candidate] of this.#clients) {
-            if (candidate === shared)
-                this.#clients.delete(key);
+        finally {
+            // A refused surrender must never strand the controller on a client with
+            // no transport: closing the consumer retires whatever it still owns.
+            for (const [key, candidate] of this.#clients) {
+                if (candidate === shared)
+                    this.#clients.delete(key);
+            }
+            await shared.consumer.close();
         }
-        await shared.consumer.close();
     }
 }

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

@@ -82,6 +82,17 @@ export class XtermTerminalInterpreterBackend {
     get rows() {
         return this.#terminal.rows;
     }
+    graphicsCursor() {
+        const buffer = this.#terminal.buffer.active;
+        return {
+            x: Math.min(buffer.cursorX, this.#terminal.cols - 1),
+            line: buffer.baseY + buffer.cursorY,
+            alternate: buffer.type === "alternate",
+        };
+    }
+    graphicsViewportTop() {
+        return this.#terminal.buffer.active.baseY;
+    }
     write(data) {
         return new Promise((resolve) => this.#terminal.write(data, resolve));
     }

package/packages/daemon/dist/tui/mirror/runtime/application-home-agents-owner.js

@@ -232,8 +232,14 @@ export function createApplicationHomeNavigationOwner(options) {
                 command === "whats-new" ||
                 command === "switch-session")
                 return null;
-            if (options.sessionOwner()?.snapshot()?.status !== "live")
+            const status = options.sessionOwner()?.snapshot()?.status;
+            if (status !== "live") {
+                if (status === "rebinding")
+                    return "Terminal is updating. Try again shortly.";
+                if (status === "connecting")
+                    return "Opening terminal…";
                 return "Open a live session first";
+            }
             return command !== "new-window" && command !== "new-agent" && !options.focusedPane()
                 ? "Select a live pane first"
                 : null;

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

@@ -103,7 +103,14 @@ export function createApplicationTerminalInputIngress(interaction, generation, s
             }
             : undefined;
         recovery.inputs.push(async () => {
-            for (const [index, input] of inputs.entries()) {
+            if (version !== recoveryVersion ||
+                !sameScope(target, scope()) ||
+                generation()?.status !== "live")
+                return false;
+            const framed = typeof inputs === "function" ? inputs() : inputs;
+            if (framed === null)
+                return false;
+            for (const [index, input] of framed.entries()) {
                 if (version !== recoveryVersion ||
                     !sameScope(target, scope()) ||
                     generation()?.status !== "live" ||
@@ -155,6 +162,24 @@ export function createApplicationTerminalInputIngress(interaction, generation, s
             }
         })();
     };
+    const pasteMode = () => {
+        const active = generation();
+        const pane = focusedPane();
+        if (active?.status !== "live" || !active.fastLane || !pane)
+            return null;
+        const mode = active.fastLane.lane.paneState(pane)?.snapshot?.modes.bracketedPaste;
+        return typeof mode === "boolean" ? mode : null;
+    };
+    const deliverPaste = (bytes) => {
+        const mode = pasteMode();
+        if (mode === null) {
+            // Do not let the successful drain of the surrounding FIFO hide refusal.
+            ownsNote = false;
+            setNote("terminal unavailable · paste was not sent");
+            return;
+        }
+        sendApplicationTerminalPaste(interaction, bytes, captureOrigin(), mode);
+    };
     const captureOrigin = () => Boolean(currentTuiPerformanceEventSink()?.terminalInputOrigin);
     const flush = () => {
         const owner = sessionOwner();
@@ -243,7 +268,7 @@ export function createApplicationTerminalInputIngress(interaction, generation, s
                 return;
             const copy = Uint8Array.from(bytes);
             try {
-                terminalInputsForPaste(Buffer.from(copy).toString("utf8"));
+                terminalInputsForPaste(Buffer.from(copy).toString("utf8"), false);
             }
             catch {
                 setNote("terminal unavailable · paste was rejected");
@@ -255,12 +280,17 @@ export function createApplicationTerminalInputIngress(interaction, generation, s
                 active?.status === "live" &&
                 active.fastLane &&
                 focusedPane()) {
-                sendApplicationTerminalPaste(interaction, copy, captureOrigin());
+                deliverPaste(copy);
                 return;
             }
-            if (recover(terminalInputsForPaste(Buffer.from(copy).toString("utf8")), copy, "paste"))
+            if (recover(() => {
+                const mode = pasteMode();
+                return mode === null
+                    ? null
+                    : terminalInputsForPaste(Buffer.from(copy).toString("utf8"), mode);
+            }, copy, "paste"))
                 return;
-            noteAdmission(pending.enqueue(() => sendApplicationTerminalPaste(interaction, copy, captureOrigin()), copy.byteLength), "paste");
+            noteAdmission(pending.enqueue(() => deliverPaste(copy), copy.byteLength), "paste");
         },
         dispose() {
             cancelInteractionInput();

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

@@ -10,9 +10,9 @@ export function sendApplicationTerminalKey(interaction, event, captureOrigin) {
     void interaction.sendInput(input, parserOrigin);
     return true;
 }
-export function sendApplicationTerminalPaste(interaction, bytes, captureOrigin) {
+export function sendApplicationTerminalPaste(interaction, bytes, captureOrigin, bracketedPaste) {
     const text = Buffer.from(bytes).toString("utf8");
-    const inputs = terminalInputsForPaste(text);
+    const inputs = terminalInputsForPaste(text, bracketedPaste);
     for (let index = 0; index < inputs.length; index += 1) {
         const parserOrigin = index === 0 && captureOrigin
             ? { origin: "bracketed-paste", payload: Buffer.from(bytes) }

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

@@ -33,12 +33,12 @@ export function terminalInputForOpenTuiKey(event) {
     return SessionRuntimeTerminalInputSchemaZ.parse({ kind: "text", data });
 }
 /** Preserve paste ordering and bracketed-paste semantics without an unbounded frame. */
-export function terminalInputsForPaste(text) {
+export function terminalInputsForPaste(text, bracketedPaste) {
     if (text.length === 0)
         return [];
     if (text.includes("\0"))
         throw new TypeError("terminal paste must not contain NUL");
-    const framed = `\u001b[200~${text}\u001b[201~`;
+    const framed = bracketedPaste ? `\u001b[200~${text}\u001b[201~` : text;
     const inputs = [];
     for (let offset = 0; offset < framed.length;) {
         let end = Math.min(offset + SESSION_RUNTIME_MAX_TERMINAL_INPUT_TEXT_CHARS, framed.length);

package/packages/daemon/src/command-center/tmux-server-diagnostics.ts

@@ -0,0 +1,38 @@
+import type { Hono } from "hono";
+import { TmuxServerScopeSchemaZ, TmuxServerDiagnosticsSchemaZ } from "@tmux-ide/contracts";
+import { TmuxServerScopeError, type TmuxServerOwners } from "../lib/tmux-server-owners.ts";
+import type { NativeTmuxServerOwner } from "../lib/tmux-server-owner.ts";
+
+/** Mount beneath the existing owner-authenticated, no-store server router. */
+export function mountTmuxServerDiagnosticsRoute(
+  app: Hono,
+  options: {
+    scopedPath: string;
+    owners: TmuxServerOwners<NativeTmuxServerOwner>;
+  },
+) {
+  app.get(`${options.scopedPath}/diagnostics`, async (c) => {
+    const scope = TmuxServerScopeSchemaZ.safeParse({
+      serverId: c.req.param("serverId"),
+      generation: c.req.param("generation"),
+    });
+    if (!scope.success) return c.json({ error: { code: "invalid-request" } }, 400);
+    try {
+      c.req.raw.signal.throwIfAborted();
+      const tmuxVersion = await options.owners.withOwner(scope.data, (owner) =>
+        owner.readServerVersion(c.req.raw.signal),
+      );
+      c.req.raw.signal.throwIfAborted();
+      return c.json(
+        TmuxServerDiagnosticsSchemaZ.parse({ version: 1, server: scope.data, tmuxVersion }),
+      );
+    } catch (error) {
+      if (error instanceof TmuxServerScopeError)
+        return c.json(
+          { error: { code: "scope-unavailable" } },
+          error.code === "not-found" ? 404 : 409,
+        );
+      return c.json({ error: { code: "diagnostics-unavailable" } }, 503);
+    }
+  });
+}

package/packages/daemon/src/command-center/tmux-server-history-anchor.ts

@@ -0,0 +1,69 @@
+import type { Hono } from "hono";
+import {
+  HistoryAnchorRequestSchemaZ,
+  HistoryAnchorResponseSchemaZ,
+  TmuxServerScopeSchemaZ,
+} from "@tmux-ide/contracts";
+import { TmuxServerScopeError, type TmuxServerOwners } from "../lib/tmux-server-owners.ts";
+import type { NativeTmuxServerOwner } from "../lib/tmux-server-owner.ts";
+/** Mounted below owner-authenticated no-store middleware. Never opens a runtime. */
+export function mountTmuxServerHistoryAnchorRoute(
+  app: Hono,
+  options: {
+    scopedPath: string;
+    owners: TmuxServerOwners<NativeTmuxServerOwner>;
+    readBody: (request: Request) => Promise<unknown>;
+  },
+) {
+  app.post(`${options.scopedPath}/history-anchor`, async (c) => {
+    const scope = TmuxServerScopeSchemaZ.safeParse({
+      serverId: c.req.param("serverId"),
+      generation: c.req.param("generation"),
+    });
+    if (!scope.success) return c.json({ error: { code: "invalid-request" } }, 400);
+    let body;
+    try {
+      body = HistoryAnchorRequestSchemaZ.parse(await options.readBody(c.req.raw));
+    } catch {
+      return c.json({ error: { code: "invalid-request" } }, 400);
+    }
+    if (body.proof.generation !== scope.data.generation)
+      return c.json({ error: { code: "stale-generation" } }, 409);
+    try {
+      c.req.raw.signal.throwIfAborted();
+      const result = await options.owners.withOwner(scope.data, async (owner) => {
+        const sessions = await owner.catalog();
+        c.req.raw.signal.throwIfAborted();
+        const workspace = owner.workspaceRegistry.get(body.proof.workspaceName);
+        if (
+          !workspace ||
+          !sessions.some(
+            (row) =>
+              row.sessionName === workspace.sessionName && row.liveSessionId === body.liveSessionId,
+          )
+        )
+          return { status: "stale" as const };
+        const result = owner.sessionRuntimeRegistry.historyAnchor(
+          workspace.sessionName,
+          HistoryAnchorRequestSchemaZ.parse({
+            ...body,
+            proof: { ...body.proof, workspaceName: workspace.sessionName },
+          }),
+        );
+        // Delivery aliases are transport addresses, not canonical session names.
+        return result.status === "resolved"
+          ? { ...result, proof: { ...result.proof, workspaceName: body.proof.workspaceName } }
+          : result;
+      });
+      c.req.raw.signal.throwIfAborted();
+      return c.json(HistoryAnchorResponseSchemaZ.parse({ version: 1, server: scope.data, result }));
+    } catch (error) {
+      if (error instanceof TmuxServerScopeError)
+        return c.json(
+          { error: { code: "scope-unavailable" } },
+          error.code === "not-found" ? 404 : 409,
+        );
+      return c.json({ error: { code: "history-unavailable" } }, 503);
+    }
+  });
+}