tmux-ide 2.9.5 → 2.9.7

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

@@ -1,6 +1,6 @@
 import { PaneStreamLayoutSnapshotFrameSchemaZ } from "@tmux-ide/contracts";
 import { z } from "zod";
-import { PANE_STREAM_MAX_HELD_DELTAS, PANE_STREAM_MAX_OUTPUT_BYTES, PANE_STREAM_MAX_PANES, PANE_STREAM_MAX_SEED_BYTES, PANE_STREAM_PROTOCOL_VERSION, PANE_STREAM_REDEEM_PATH, PANE_STREAM_WEBSOCKET_SUBPROTOCOL, PaneStreamClientFrameSchemaZ, PaneStreamLoopbackWebSocketUrlSchemaZ, PaneStreamRedeemFrameSchemaZ, PaneStreamServerFrameSchemaZ, sharedMonotonicMicros, } from "@tmux-ide/contracts";
+import { PANE_STREAM_MAX_HELD_DELTAS, PANE_STREAM_MAX_OUTPUT_BYTES, PANE_STREAM_MAX_PANES, PANE_STREAM_MAX_SEED_BYTES, PANE_STREAM_PROTOCOL_VERSION, PANE_STREAM_REDEEM_PATH, PANE_STREAM_WEBSOCKET_SUBPROTOCOL, TERMINAL_GRAPHICS_BLOB_CHUNK_BYTES, PaneStreamClientFrameSchemaZ, PaneStreamLoopbackWebSocketUrlSchemaZ, PaneStreamRedeemFrameSchemaZ, PaneStreamServerFrameSchemaZ, sharedMonotonicMicros, } from "@tmux-ide/contracts";
 import { canonicalOriginOrNull, digestSecret, digestsEqual, rawDataByteLength, rawDataToBuffer, safeCloseSocket, strictJsonParse, } from "../attachments/admission-util.js";
 import { SessionRuntimeControllerLeaseError } from "../session-runtime/registry.js";
 import { terminalDeliveryObservationOrdinal } from "../session-runtime/terminal-delivery-observation-identity.js";
@@ -37,6 +37,8 @@ function semanticBackendRefusal(error) {
     for (let depth = 0; depth < 3; depth += 1) {
         if (!candidate || typeof candidate !== "object")
             return null;
+        if ("code" in candidate && candidate.code === "mutation_unverified")
+            return "mutation_unverified";
         const context = "context" in candidate ? candidate.context : null;
         const reason = context && typeof context === "object" && "reason" in context ? context.reason : null;
         if (typeof reason === "string" && SEMANTIC_BACKEND_REFUSALS.has(reason))
@@ -590,6 +592,8 @@ class PreAuthAdmission {
         socket.off("error", this.#onClose);
     }
 }
+const GRAPHICS_MAX_QUEUED_DIGESTS = 256;
+const GRAPHICS_SEND_WINDOW_BYTES = 2 * 1024 * 1024;
 export class PaneStreamLiveConnection {
     #clientId;
     #socket;
@@ -721,6 +725,9 @@ export class PaneStreamLiveConnection {
                 frozenByWire: false,
                 closed: false,
                 batch: null,
+                graphicsAnnounced: false,
+                graphicsQueue: [],
+                graphicsSending: false,
             });
         }
     }
@@ -956,16 +963,20 @@ export class PaneStreamLiveConnection {
         const openings = channels.map(async (channel) => {
             const pending = [];
             let ready = false;
+            let negotiated = false;
             const delivery = await binding.openTerminalDelivery(channel.semanticPaneId, offer, (message) => {
-                if (!ready)
+                if (!ready && !(negotiated && message.type === "terminal.delivery.fault"))
                     pending.push(message);
                 else
                     return this.#sendTerminalDelivery(channel.semanticPaneId, message);
-            });
+            }, this.#descriptor.workspaceName);
             return {
                 channel,
                 delivery,
                 pending,
+                markNegotiated: () => {
+                    negotiated = true;
+                },
                 markReady: () => {
                     ready = true;
                 },
@@ -990,7 +1001,7 @@ export class PaneStreamLiveConnection {
             for (const message of pending) {
                 if (message.type !== "terminal.delivery")
                     continue;
-                if (message.workspaceName !== this.#descriptor.sessionName ||
+                if (message.workspaceName !== this.#descriptor.workspaceName ||
                     message.semanticPaneId !== channel.semanticPaneId ||
                     message.generation !== negotiated.generation ||
                     message.deliveryNonce !== negotiated.deliveryNonce ||
@@ -1047,7 +1058,7 @@ export class PaneStreamLiveConnection {
         const visibleAtDelivery = new Set(authority.layouts.flatMap((layout) => layout.currentWindow ? layout.panes.map((pane) => pane.semanticPaneId) : []));
         opened.sort((left, right) => Number(visibleAtDelivery.has(right.channel.semanticPaneId)) -
             Number(visibleAtDelivery.has(left.channel.semanticPaneId)));
-        for (const { channel, delivery } of opened) {
+        for (const { channel, delivery, markNegotiated } of opened) {
             if (this.#closed || channel.closed) {
                 await delivery.close();
                 continue;
@@ -1075,6 +1086,8 @@ export class PaneStreamLiveConnection {
                 pane: channel.semanticPaneId,
                 negotiation: delivery.negotiation,
             });
+            // Lifecycle faults may bypass bulk replay only after validated negotiation.
+            markNegotiated();
         }
         // Every observer can now subscribe without waiting behind another pane's
         // seed/backpressure. Readiness is negotiation only; canonical seeds still
@@ -1082,9 +1095,14 @@ export class PaneStreamLiveConnection {
         for (const { channel, pending, markReady } of opened) {
             if (this.#closed || channel.closed)
                 continue;
-            markReady();
+            // Keep live arrivals in the same FIFO while replay yields for credit.
+            // Array iteration includes messages appended during those awaits; only
+            // switch to direct delivery once the entire staged queue is drained.
             for (const message of pending)
                 await this.#sendTerminalDelivery(channel.semanticPaneId, message);
+            pending.length = 0;
+            markReady();
+            this.#startGraphics(channel);
         }
         this.#closeIfAllPanesGone();
     }
@@ -1097,9 +1115,8 @@ export class PaneStreamLiveConnection {
             const channel = this.#panes.get(pane);
             if (channel?.deliveryAddress)
                 channel.deliveryAddress.incarnation = message.incarnation;
-            // SessionRuntime keys canonical replicas by the tmux session, while the
-            // public pane-stream lease is keyed by its workspace identity. Translate
-            // at this boundary so the renderer has one coherent address vocabulary.
+            // The trusted lease address was fixed at delivery admission; preserve the
+            // exact envelope and its observation identity through transmission.
             const detailedDeliveryObservation = this.#observability?.enabled === true;
             const trace = message.performanceTraceId && detailedDeliveryObservation
                 ? this.#observability.beginTrace("terminal-input-to-paint", { generation: message.generation, incarnation: message.incarnation }, message.performanceTraceId)
@@ -1124,7 +1141,7 @@ export class PaneStreamLiveConnection {
             this.#sendFrame(pane, {
                 type: "terminal-delivery-envelope",
                 pane,
-                envelope: { ...message, workspaceName: this.#descriptor.workspaceName },
+                envelope: message,
             });
             if (startedAtMicros !== null) {
                 let endedAtMicros;
@@ -1190,6 +1207,73 @@ export class PaneStreamLiveConnection {
         }
         await this.#awaitSemanticCredit(pane);
     }
+    /** Announce the pane's kitty graphics state; the client pulls bytes it lacks. */
+    #startGraphics(channel) {
+        const graphics = channel.delivery?.graphics;
+        if (!graphics)
+            return;
+        graphics.subscribe((state) => {
+            if (this.#closed || channel.closed)
+                return;
+            channel.graphicsAnnounced = true;
+            this.#sendFrame(null, { type: "terminal-graphics", pane: channel.semanticPaneId, state });
+        });
+    }
+    #requestGraphics(pane, digests) {
+        const channel = this.#panes.get(pane);
+        // Requests are only meaningful after an announcement; ignore stray ones.
+        if (!channel || channel.closed || !channel.graphicsAnnounced)
+            return;
+        for (const digest of digests)
+            if (!channel.graphicsQueue.includes(digest) &&
+                channel.graphicsQueue.length < GRAPHICS_MAX_QUEUED_DIGESTS)
+                channel.graphicsQueue.push(digest);
+        if (!channel.graphicsSending)
+            void this.#drainGraphics(channel);
+    }
+    /**
+     * Blob bytes yield to terminal frames: each chunk waits until the socket's
+     * buffered bytes fall below a small window, so images never trip the
+     * socket-wide backpressure ceiling or delay a pane's next seed for long.
+     */
+    async #drainGraphics(channel) {
+        channel.graphicsSending = true;
+        try {
+            while (!this.#closed && !channel.closed && channel.graphicsQueue.length > 0) {
+                const digest = channel.graphicsQueue.shift();
+                const image = channel.delivery?.graphics?.image(digest);
+                if (!image)
+                    continue;
+                const total = image.data.byteLength;
+                for (let offset = 0; offset < total; offset += TERMINAL_GRAPHICS_BLOB_CHUNK_BYTES) {
+                    while ((this.#socket.bufferedAmount ?? 0) > GRAPHICS_SEND_WINDOW_BYTES) {
+                        if (this.#closed || channel.closed)
+                            return;
+                        await new Promise((resolve) => setTimeout(resolve, 5));
+                    }
+                    if (this.#closed || channel.closed)
+                        return;
+                    const end = Math.min(total, offset + TERMINAL_GRAPHICS_BLOB_CHUNK_BYTES);
+                    this.#sendFrame(null, {
+                        type: "terminal-graphics-blob",
+                        pane: channel.semanticPaneId,
+                        blob: {
+                            digest,
+                            format: image.format,
+                            width: image.width,
+                            height: image.height,
+                            total,
+                            offset,
+                        },
+                        data: Buffer.from(image.data.subarray(offset, end)).toString("base64"),
+                    });
+                }
+            }
+        }
+        finally {
+            channel.graphicsSending = false;
+        }
+    }
     #awaitSemanticCredit(pane) {
         // Backpressure is pane-local. Aggregate pressure is guarded by the hard
         // socket ceiling in #drainNow, but must not let a noisy sibling prevent a
@@ -1736,14 +1820,14 @@ export class PaneStreamLiveConnection {
             const channel = this.#deliveryChannel(frame.ack);
             if (!channel)
                 return;
-            channel.delivery.ack({ ...frame.ack, workspaceName: this.#descriptor.sessionName });
+            channel.delivery.ack(frame.ack);
             return;
         }
         if (frame.type === "terminal-delivery-nack") {
             const channel = this.#deliveryChannel(frame.nack);
             if (!channel)
                 return;
-            channel.delivery.nack({ ...frame.nack, workspaceName: this.#descriptor.sessionName });
+            channel.delivery.nack(frame.nack);
             return;
         }
         if (frame.type === "terminal-delivery-visibility") {
@@ -1763,6 +1847,10 @@ export class PaneStreamLiveConnection {
             this.#acceptSemanticIntent(frame.operationId, frame.intent);
             return;
         }
+        if (frame.type === "terminal-graphics-request") {
+            this.#requestGraphics(frame.pane, frame.digests);
+            return;
+        }
         if (frame.type === "viewport") {
             if (!this.#descriptor.terminalDelivery ||
                 this.#descriptor.viewerMode !== "interactive" ||
@@ -1869,7 +1957,8 @@ export class PaneStreamLiveConnection {
         }
         if (!this.#prepareInputAuthority(false))
             return;
-        void this.#sessionRuntimeBinding.submitIntent(operationId, intent)
+        // Normalize synchronous admission refusals into the same rejected ACK path.
+        void (async () => this.#sessionRuntimeBinding.submitIntent(operationId, intent))()
             .then((result) => {
             this.#sendFrame(null, {
                 type: "semantic-intent-ack",
@@ -1897,6 +1986,7 @@ export class PaneStreamLiveConnection {
                 "pane_inventory_not_ready",
                 "pane_identity_changed_before_select",
                 "pane_not_active",
+                "mutation_unverified",
             ].includes(rawCode)
                 ? rawCode
                 : "stream-unavailable";
@@ -1906,7 +1996,11 @@ export class PaneStreamLiveConnection {
                 outcome: {
                     status: "rejected",
                     code,
-                    message: error instanceof Error ? error.message.slice(0, 512) : "Semantic intent failed",
+                    message: code === "mutation_unverified"
+                        ? "Mutation outcome is uncertain; do not retry with a new operation ID."
+                        : error instanceof Error
+                            ? error.message.slice(0, 512)
+                            : "Semantic intent failed",
                 },
             });
         });

package/packages/daemon/dist/terminal/protocol/layout-parse.js

@@ -19,6 +19,24 @@
  * Everything here is unit-tested against layout strings captured from a real
  * tmux 3.7b server (splits, zoom, storms) — no tmux at test time.
  */
+// Internal parsing bound, matching fleet catalog capacity. This is NOT the
+// smaller pane-stream publication limit; future wire callers must enforce that.
+const MAX_TREE_LEAVES = 512;
+/**
+ * Bounded ancestry parser, deliberately stricter than the legacy flat parser.
+ * Up to 512 leaves (fleet catalog bound), 1023 nodes, depth 64 and 64 KiB.
+ * Validates exact ordered tiling with one separator cell, including parent
+ * bounds. The checksum prefix is grammar only, not an authenticity proof.
+ */
+export function parseLayoutTree(layout) {
+    if (layout.length > 64 * 1024 || !/^[0-9a-fA-F]{4},/.test(layout))
+        return null;
+    const s = layout.slice(5);
+    const root = parseCell(s, 0, [], { nodes: 0, ids: new Set() });
+    if (!root?.node || root.pos !== s.length || root.node.left !== 0 || root.node.top !== 0)
+        return null;
+    return root.node;
+}
 /** Parse a tmux layout string (`csum,WxH,X,Y…`). Null on any malformed input
  *  (the caller falls back to the slow list-panes path — never throw here). */
 export function parseLayout(layout) {
@@ -32,11 +50,20 @@ export function parseLayout(layout) {
     return { width: root.width, height: root.height, leaves };
 }
 /** Recursive-descent cell parse from `pos`; appends leaves in layout order. */
-function parseCell(s, pos, leaves) {
+function parseCell(s, pos, leaves, tree, depth = 1) {
+    if (tree && (depth > 64 || ++tree.nodes > MAX_TREE_LEAVES * 2 - 1))
+        return null;
     const dims = readDims(s, pos);
     if (!dims)
         return null;
     const { width, height, left, top } = dims;
+    if (tree &&
+        (![width, height, left, top, left + width, top + height].every(Number.isSafeInteger) ||
+            width <= 0 ||
+            height <= 0 ||
+            left < 0 ||
+            top < 0))
+        return null;
     pos = dims.pos;
     const ch = s[pos];
     if (ch === ",") {
@@ -44,23 +71,46 @@ function parseCell(s, pos, leaves) {
         const id = readInt(s, pos + 1);
         if (!id)
             return null;
-        leaves.push({ id: `%${id.value}`, left, top, width, height });
-        return { width, height, pos: id.pos };
+        const leaf = { id: `%${id.value}`, left, top, width, height };
+        if (tree) {
+            if (!Number.isSafeInteger(id.value) ||
+                tree.ids.has(leaf.id) ||
+                tree.ids.size >= MAX_TREE_LEAVES)
+                return null;
+            tree.ids.add(leaf.id);
+        }
+        leaves.push(leaf);
+        return {
+            width,
+            height,
+            pos: id.pos,
+            ...(tree ? { node: { kind: "leaf", ...leaf } } : {}),
+        };
     }
     if (ch === "{" || ch === "[") {
         const close = ch === "{" ? "}" : "]";
+        const children = [];
         pos++;
         for (;;) {
-            const child = parseCell(s, pos, leaves);
+            const child = parseCell(s, pos, leaves, tree, depth + 1);
             if (!child)
                 return null;
+            if (tree && child.node)
+                children.push(child.node);
             pos = child.pos;
             if (s[pos] === ",") {
                 pos++;
                 continue;
             }
-            if (s[pos] === close)
-                return { width, height, pos: pos + 1 };
+            if (s[pos] === close) {
+                if (!tree)
+                    return { width, height, pos: pos + 1 };
+                const axis = ch === "{" ? "cols" : "rows";
+                const node = { kind: "split", axis, left, top, width, height, children };
+                if (!tilesParent(node))
+                    return null;
+                return { width, height, pos: pos + 1, node };
+            }
             return null;
         }
     }
@@ -68,6 +118,23 @@ function parseCell(s, pos, leaves) {
     // the leaf id was consumed above, so anything else here is malformed.
     return null;
 }
+/** Child ordering and separator widths must describe precisely this parent. */
+function tilesParent(node) {
+    if (node.children.length < 2)
+        return false;
+    const cols = node.axis === "cols";
+    let next = cols ? node.left : node.top;
+    for (const child of node.children) {
+        if ((cols ? child.left : child.top) !== next ||
+            (cols ? child.top : child.left) !== (cols ? node.top : node.left) ||
+            (cols ? child.height : child.width) !== (cols ? node.height : node.width))
+            return false;
+        next += (cols ? child.width : child.height) + 1;
+        if (!Number.isSafeInteger(next))
+            return false;
+    }
+    return next - 1 === (cols ? node.left + node.width : node.top + node.height);
+}
 /** Read `WxH,X,Y` at `pos`. */
 function readDims(s, pos) {
     const w = readInt(s, pos);

package/packages/daemon/dist/terminal/protocol/native-split-resize.js

@@ -0,0 +1,193 @@
+import { parseLayoutTree } from "./layout-parse.js";
+function object(value, keys) {
+    return (value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === keys.length &&
+        keys.every((key) => Object.hasOwn(value, key)));
+}
+function json(text, limit) {
+    if (typeof text !== "string" || text.length > limit || Buffer.byteLength(text) > limit)
+        throw new Error("Bounded native response required");
+    return JSON.parse(text);
+}
+function capability(text) {
+    const value = json(text, 1024);
+    return (object(value, [
+        "schemaVersion",
+        "capability",
+        "sessionMembership",
+        "maxDepth",
+        "maxLeaves",
+        "maxGrid",
+    ]) &&
+        value.schemaVersion === 1 &&
+        value.capability === "split-resize-v1" &&
+        value.sessionMembership === "exact-session-link-v1" &&
+        value.maxDepth === 64 &&
+        value.maxLeaves === 512 &&
+        value.maxGrid === 4096);
+}
+/** Read-only, uncached probe; the caller pins and bounds the selected server. */
+export async function supportsNativeSplitResize(runTmux) {
+    try {
+        return capability(await runTmux(["tmux-ide-resize-split", "-V"]));
+    }
+    catch {
+        return false;
+    }
+}
+function validTree(tree) {
+    let budget = 5;
+    const visit = (node) => {
+        if (node.left + node.width > 4096 || node.top + node.height > 4096)
+            return false;
+        budget += 21;
+        if (node.kind === "leaf") {
+            const id = node.id.slice(1);
+            if (!/^(0|[1-9][0-9]*)$/.test(id) || Number(id) > 0xffffffff)
+                return false;
+            budget += id.length;
+        }
+        else if (!node.children.every(visit))
+            return false;
+        return budget <= 8192;
+    };
+    return visit(tree);
+}
+function locate(tree, path) {
+    let node = tree;
+    let parent;
+    for (const index of path) {
+        if (node.kind !== "split" || !node.children[index])
+            return null;
+        parent = node;
+        node = node.children[index];
+    }
+    return parent && path.at(-1) < parent.children.length - 1 ? { parent, node } : null;
+}
+function edge(node, axis) {
+    return axis === "cols" ? node.left + node.width : node.top + node.height;
+}
+function sameRect(a, b) {
+    return a.left === b.left && a.top === b.top && a.width === b.width && a.height === b.height;
+}
+/** Only geometry inside the exact parent may change, along the requested axis.
+ * Native redistribution can affect multiple siblings. This verifies convergence,
+ * not exclusive causation or authentication of the returned layout. */
+function preservesTree(before, after, affected, axis, inside = false) {
+    const begins = before === affected;
+    if (before.kind !== after.kind || ((!inside || begins) && !sameRect(before, after)))
+        return false;
+    inside ||= begins;
+    if (inside &&
+        (axis === "cols"
+            ? before.top !== after.top || before.height !== after.height
+            : before.left !== after.left || before.width !== after.width))
+        return false;
+    if (before.kind === "leaf")
+        return after.kind === "leaf" && before.id === after.id;
+    return (after.kind === "split" &&
+        before.axis === after.axis &&
+        before.children.length === after.children.length &&
+        before.children.every((child, index) => preservesTree(child, after.children[index], affected, axis, inside)));
+}
+/** Internal foundation only; no route or native capability is enabled here.
+ * Capability is checked on every invocation, never cached across generations.
+ * A failed command or invalid post-dispatch receipt is uncertain: do not retry. */
+export async function resizeNativeSplit(request, runTmux) {
+    let captured, before;
+    try {
+        if (!object(request, ["sessionId", "windowId", "expectedLayout", "path", "axis", "boundary"]) ||
+            typeof request.sessionId !== "string" ||
+            !/^\$(0|[1-9][0-9]{0,9})$/.test(request.sessionId) ||
+            Number(request.sessionId.slice(1)) > 0xffffffff ||
+            typeof request.windowId !== "string" ||
+            !/^@(0|[1-9][0-9]{0,9})$/.test(request.windowId) ||
+            Number(request.windowId.slice(1)) > 0xffffffff ||
+            typeof request.expectedLayout !== "string" ||
+            !Array.isArray(request.path) ||
+            request.path.length < 1 ||
+            request.path.length >= 64 ||
+            request.path.some((index) => !Number.isInteger(index) || index < 0 || index > 511) ||
+            request.path.join(".").length > 256 ||
+            (request.axis !== "cols" && request.axis !== "rows") ||
+            !Number.isInteger(request.boundary) ||
+            request.boundary < 0 ||
+            request.boundary > 4096)
+            return { status: "refused", reason: "invalid-request" };
+        const tree = parseLayoutTree(request.expectedLayout);
+        if (!tree || !validTree(tree))
+            return { status: "refused", reason: "invalid-request" };
+        const selected = locate(tree, request.path);
+        if (!selected || selected.parent.axis !== request.axis)
+            return { status: "refused", reason: "invalid-request" };
+        before = tree;
+        // Snapshot all command data before any await or externally supplied callback.
+        captured = { ...request, path: [...request.path] };
+    }
+    catch {
+        return { status: "refused", reason: "invalid-request" };
+    }
+    try {
+        if (!capability(await runTmux(["tmux-ide-resize-split", "-V"])))
+            return { status: "refused", reason: "unsupported" };
+    }
+    catch {
+        return { status: "refused", reason: "unsupported" };
+    }
+    let response;
+    try {
+        response = await runTmux([
+            "tmux-ide-resize-split",
+            "-t",
+            captured.windowId,
+            "-s",
+            captured.sessionId,
+            "-E",
+            captured.expectedLayout,
+            "-p",
+            captured.path.join("."),
+            "-a",
+            captured.axis,
+            "-c",
+            String(captured.boundary),
+        ]);
+    }
+    catch {
+        return { status: "uncertain", reason: "command-failed" };
+    }
+    try {
+        const receipt = json(response, 16 * 1024);
+        if (!object(receipt, ["schemaVersion", "boundary", "layout"]) ||
+            receipt.schemaVersion !== 1 ||
+            typeof receipt.layout !== "string" ||
+            typeof receipt.boundary !== "number" ||
+            !Number.isInteger(receipt.boundary) ||
+            receipt.boundary < 0 ||
+            receipt.boundary > 4096)
+            return { status: "uncertain", reason: "invalid-receipt" };
+        const after = parseLayoutTree(receipt.layout);
+        const original = locate(before, captured.path);
+        const actual = after && locate(after, captured.path);
+        const previous = edge(original.node, captured.axis);
+        if (!after ||
+            !validTree(after) ||
+            !actual ||
+            !preservesTree(before, after, original.parent, captured.axis) ||
+            receipt.boundary !== edge(actual.node, captured.axis) ||
+            receipt.boundary < Math.min(previous, captured.boundary) ||
+            receipt.boundary > Math.max(previous, captured.boundary))
+            return { status: "uncertain", reason: "invalid-receipt" };
+        return {
+            status: "applied",
+            boundary: receipt.boundary,
+            layout: receipt.layout,
+            tree: after,
+            changed: receipt.layout !== captured.expectedLayout,
+        };
+    }
+    catch {
+        return { status: "uncertain", reason: "invalid-receipt" };
+    }
+}

package/packages/daemon/dist/terminal/protocol/session-descriptor-discovery.js

@@ -129,7 +129,6 @@ export function parseSessionPaneDescriptorReply(lines) {
             !bounded(type, 256) ||
             !bounded(currentCommand, 512) ||
             !bounded(cwd, 4_096) ||
-            !bounded(title, 1_024) ||
             !bounded(windowName, 1_024) ||
             !bounded(name, 256) ||
             !bounded(missionStamp, 256) ||
@@ -148,7 +147,9 @@ export function parseSessionPaneDescriptorReply(lines) {
             type: nonempty(type),
             currentCommand: nonempty(currentCommand),
             cwd: nonempty(cwd),
-            title: nonempty(title),
+            // Stock tmux turns any APC, including kitty graphics payloads, into the
+            // pane title; an overlong title names nothing and must not drop the pane.
+            title: bounded(title, 1_024) ? nonempty(title) : null,
             windowIndex,
             windowName: nonempty(windowName),
             windowId: /^@(?:0|[1-9][0-9]*)$/u.test(windowId) ? windowId : null,