tmux-ide 2.9.0-beta.9 → 2.9.3

package/packages/daemon/dist/lib/workspace-multiplexer-verbs.js

@@ -1,3 +1,4 @@
+import { discoverLiveSessionSummaries } from "../command-center/discovery.js";
 /**
  * The multiplexer mutation authority: split, kill, rename, zoom, select, swap
  * and resize.
@@ -17,7 +18,7 @@
  * for it, and tmux's own willingness to oblige is a trap rather than a feature.
  */
 import { realpathSync, statSync } from "node:fs";
-import { WorkspaceMultiplexerMutationRequestSchemaZ, WorkspaceMultiplexerMutationResultSchemaZ, } from "@tmux-ide/contracts";
+import { SESSION_RUNTIME_PANE_READ_MAX_BYTES, SESSION_RUNTIME_PANE_CAPTURE_MAX_BYTES, SessionRuntimePaneReadResultSchemaZ, WorkspaceMultiplexerMutationRequestSchemaZ, WorkspaceMultiplexerMutationResultSchemaZ, } from "@tmux-ide/contracts";
 import { TmuxError } from "@tmux-ide/tmux-bridge";
 import { createPinnedWorkspaceTmuxRunner, resolveWorkspacePaneTmuxAuthority, semanticPaneIdForOperation, } from "./workspace-pane-creation.js";
 import { prepareTmuxTruecolorEnvironment } from "./tmux-terminal-color.js";
@@ -25,6 +26,7 @@ import { getDefaultWorkspaceRegistry } from "./workspace-registry.js";
 import { internalInteractionOperationMarker } from "./tmux-external-interaction-observer.js";
 import { INTERNAL_READ_OPERATION_OPTION, INTERNAL_SEND_OPERATION_OPTION, } from "./tmux-interaction-options.js";
 import { memorablePaneName } from "../terminal/protocol/pane-display-name.js";
+import { WindowLinkResolutionError } from "../terminal/mirror/window-link-authority.js";
 const CREATION_OPTION = "@tmux_ide_creation_id";
 const SEMANTIC_PANE_OPTION = "@tmux_ide_pane_id";
 const SEMANTIC_WINDOW_OPTION = "@tmux_ide_window_id";
@@ -46,6 +48,10 @@ const ERROR_MESSAGES = {
     workspace_unavailable: "The requested workspace is not available for multiplexer verbs.",
     pane_not_found: "No pane in this workspace carries the requested semantic identity.",
     window_not_found: "No window in this workspace carries the requested identity.",
+    window_link_stale: "The window link observation is no longer current.",
+    window_link_ambiguous: "Select an explicit window link for this pane.",
+    window_link_session_mismatch: "The window link belongs to another session generation.",
+    window_link_backing_mismatch: "The window link no longer names the expected window.",
     ambiguous_target: "The requested identity names more than one live tmux object.",
     last_window_refused: "This is the session's last window. Close the session instead if that is what you mean.",
     last_pane_refused: "This is the session's last pane. Close the session instead if that is what you mean.",
@@ -76,6 +82,7 @@ const PANE_FIELDS = [
     "#{?window_zoomed_flag,1,0}",
     "#{?pane_active,1,0}",
     `#{${CREATION_OPTION}}`,
+    "#{pane_birth_id}",
 ].join("\t");
 const RUNTIME_PANE = /^%(?:0|[1-9][0-9]*)$/u;
 const RUNTIME_WINDOW = /^@(?:0|[1-9][0-9]*)$/u;
@@ -90,7 +97,7 @@ export function parseMultiplexerPaneRows(output) {
     const rows = [];
     for (const line of output.split("\n")) {
         const fields = line.split("\t");
-        if (fields.length !== 9) {
+        if (![9, 10, 11, 12].includes(fields.length)) {
             throw new WorkspaceMultiplexerError("workspace_unavailable", {
                 reason: "pane_listing_shape",
             });
@@ -103,6 +110,27 @@ export function parseMultiplexerPaneRows(output) {
         }
         const count = Number(paneCount);
         const index = Number(paneIndex);
+        const hasBirth = fields.length === 10 || fields.length === 12;
+        const birth = hasBirth ? fields[9] : "";
+        if (birth !== "" &&
+            birth !== "0" &&
+            (!/^[1-9][0-9]{0,19}$/u.test(birth) || BigInt(birth) > 18446744073709551615n))
+            throw new WorkspaceMultiplexerError("workspace_unavailable", {
+                reason: "pane_listing_birth",
+            });
+        const hasGeometry = fields.length === 11 || fields.length === 12;
+        const geometryOffset = hasBirth ? 10 : 9;
+        const geometry = hasGeometry
+            ? { width: Number(fields[geometryOffset]), height: Number(fields[geometryOffset + 1]) }
+            : {};
+        if (hasGeometry &&
+            (!Number.isSafeInteger(geometry.width) ||
+                geometry.width < 1 ||
+                !Number.isSafeInteger(geometry.height) ||
+                geometry.height < 1))
+            throw new WorkspaceMultiplexerError("workspace_unavailable", {
+                reason: "pane_listing_geometry",
+            });
         if (!Number.isInteger(count) || count < 1 || !Number.isInteger(index) || index < 0) {
             throw new WorkspaceMultiplexerError("workspace_unavailable", {
                 reason: "pane_listing_shape",
@@ -118,9 +146,23 @@ export function parseMultiplexerPaneRows(output) {
             windowZoomed: zoomed === "1",
             paneActive: active === "1",
             creationId: creationId === "" ? null : creationId,
+            ...(hasBirth ? { nativePaneBirthId: birth === "" || birth === "0" ? null : birth } : {}),
+            ...geometry,
         });
     }
-    return rows;
+    // list-panes -s repeats each backing for its session links. Identical native
+    // rows are one pane; conflicting observations fail closed.
+    const unique = new Map();
+    for (const row of rows) {
+        const previous = unique.get(row.paneId);
+        if (previous && JSON.stringify(previous) !== JSON.stringify(row)) {
+            throw new WorkspaceMultiplexerError("workspace_unavailable", {
+                reason: "conflicting_linked_pane_observation",
+            });
+        }
+        unique.set(row.paneId, row);
+    }
+    return [...unique.values()];
 }
 /** Distinct windows in a pane listing, in first-seen order. */
 export function windowIdsOf(rows) {
@@ -201,16 +243,133 @@ export class WorkspaceMultiplexerAuthority {
      * The returned promise is only an API envelope: no second queue or replay
      * ledger is allowed below SessionSemanticMutationExecutor.
      */
-    mutate(raw, timing) {
-        return this.#mutate(raw, timing);
+    mutate(raw, timing, execution) {
+        return this.#mutate(raw, timing, execution);
+    }
+    /** Retained control transport; owned by the same serialized semantic lane. */
+    async mutateResize(raw, transport) {
+        if (this.#disposed)
+            throw new WorkspaceMultiplexerError("workspace_unavailable");
+        const request = WorkspaceMultiplexerMutationRequestSchemaZ.parse(raw);
+        if (request.expectedDaemonInstanceId !== this.#daemonInstanceId)
+            throw new WorkspaceMultiplexerError("daemon_instance_mismatch");
+        const intent = request.intent;
+        if (intent.verb !== "workspace.pane.resize")
+            throw new TypeError("Expected pane resize");
+        const workspace = this.#registry.get(intent.workspaceName);
+        if (!workspace)
+            throw new WorkspaceMultiplexerError("workspace_not_found");
+        const envelope = {
+            operationId: request.operationId,
+            daemonInstanceId: this.#daemonInstanceId,
+            workspaceName: intent.workspaceName,
+        };
+        try {
+            const run = transport(workspace.sessionName);
+            const steps = this.#resizeSteps(intent, workspace.sessionName, envelope);
+            let next = steps.next();
+            while (!next.done) {
+                if (this.#disposed)
+                    throw new WorkspaceMultiplexerError("workspace_unavailable");
+                const observed = await run(next.value);
+                if (this.#disposed)
+                    throw new WorkspaceMultiplexerError("workspace_unavailable");
+                next = steps.next(observed);
+            }
+            return WorkspaceMultiplexerMutationResultSchemaZ.parse(next.value);
+        }
+        catch (cause) {
+            if (cause instanceof WorkspaceMultiplexerError)
+                throw cause;
+            // A missing reply may follow an effect. Never fall back or replay.
+            throw new WorkspaceMultiplexerError("mutation_unverified", { operationId: request.operationId }, cause);
+        }
+    }
+    /** Runs only inside the existing semantic mutation lane; never rediscovers a stale link. */
+    async mutateWindowLink(raw, execute, timing) {
+        if (this.#disposed)
+            throw new WorkspaceMultiplexerError("workspace_unavailable");
+        const request = WorkspaceMultiplexerMutationRequestSchemaZ.parse(raw);
+        if (request.expectedDaemonInstanceId !== this.#daemonInstanceId)
+            throw new WorkspaceMultiplexerError("daemon_instance_mismatch");
+        const intent = request.intent;
+        if (intent.verb !== "workspace.window.link.select" &&
+            intent.verb !== "workspace.window.link.unlink" &&
+            intent.verb !== "workspace.pane.select")
+            throw new TypeError("Expected a window-link selection or unlink intent");
+        const now = () => {
+            try {
+                return timing?.nowMicros() ?? null;
+            }
+            catch {
+                return null;
+            }
+        };
+        const record = (operation, start) => {
+            const end = now();
+            if (start !== null && end !== null) {
+                try {
+                    timing?.record(operation, start, end);
+                }
+                catch {
+                    /* Diagnostics cannot own selection. */
+                }
+            }
+        };
+        const lookupStarted = now();
+        const workspace = this.#registry.get(intent.workspaceName);
+        record("semantic-workspace-lookup", lookupStarted);
+        if (!workspace)
+            throw new WorkspaceMultiplexerError("workspace_not_found");
+        const envelope = {
+            operationId: request.operationId,
+            daemonInstanceId: this.#daemonInstanceId,
+            workspaceName: intent.workspaceName,
+        };
+        try {
+            const effectStarted = now();
+            const result = await execute(workspace.sessionName, intent.verb === "workspace.pane.select"
+                ? {
+                    action: "select",
+                    ...(intent.windowLink ? { target: intent.windowLink } : {}),
+                    paneId: intent.semanticPaneId,
+                }
+                : {
+                    action: intent.verb === "workspace.window.link.unlink" ? "unlink" : "select",
+                    target: intent.target,
+                });
+            record("window-link-effect-proof", effectStarted);
+            if (result.outcome !== "applied") {
+                throw new WorkspaceMultiplexerError(result.outcome === "stale"
+                    ? "window_link_stale"
+                    : result.outcome === "native-refused"
+                        ? "mutation_failed"
+                        : "mutation_unverified", { reason: result.outcome });
+            }
+            return WorkspaceMultiplexerMutationResultSchemaZ.parse(intent.verb === "workspace.pane.select"
+                ? {
+                    ...envelope,
+                    verb: intent.verb,
+                    outcome: "applied",
+                    semanticPaneId: intent.semanticPaneId,
+                }
+                : { ...envelope, verb: intent.verb, outcome: "applied", target: intent.target });
+        }
+        catch (error) {
+            if (error instanceof WorkspaceMultiplexerError)
+                throw error;
+            if (error instanceof WindowLinkResolutionError)
+                throw new WorkspaceMultiplexerError(error.reason, { operationId: request.operationId }, error);
+            throw new WorkspaceMultiplexerError("mutation_unverified", { operationId: request.operationId }, error);
+        }
     }
     /**
-     * Capture a semantically addressed pane for an authored read. The tmux
-     * after-capture hook is the completion authority; this method only performs
-     * the command-list and verifies that its semantic target survived it.
+     * Capture a semantically addressed pane once and return that bounded snapshot.
+     * Native command completion and post-capture identity checks prove the response;
+     * the separate stock after-capture hook is command-observation evidence only.
      * SessionRuntimeRegistry serializes this lane with authored sends.
      */
-    readPane(operationId, intent) {
+    readPane(operationId, intent, execution) {
         if (this.#disposed) {
             throw new WorkspaceMultiplexerError("workspace_unavailable", {
                 reason: "authority_disposed",
@@ -224,41 +383,75 @@ export class WorkspaceMultiplexerAuthority {
             });
         }
         const pane = resolvePaneRow(this.#panes(workspace.sessionName), intent.semanticPaneId);
+        const dispatch = { native: false };
+        let captured;
         try {
-            this.#io.runTmux([
-                "set-option",
-                "-p",
-                "-t",
-                pane.paneId,
-                INTERNAL_READ_OPERATION_OPTION,
-                internalInteractionOperationMarker(this.#daemonInstanceId, operationId),
-                ";",
-                "capture-pane",
-                "-p",
-                "-e",
-                "-J",
-                "-S",
-                "-2000",
-                "-t",
-                pane.paneId,
-            ]);
+            captured = this.#runAuthored(operationId, execution, pane, ["capture-pane"], [
+                [
+                    "set-option",
+                    "-p",
+                    "-t",
+                    pane.paneId,
+                    INTERNAL_READ_OPERATION_OPTION,
+                    internalInteractionOperationMarker(this.#daemonInstanceId, operationId),
+                ],
+                ["capture-pane", "-p", "-e", "-J", "-S", "-2000", "-t", pane.paneId],
+            ], dispatch, { preserveTrailingNewlines: true });
         }
-        catch (error) {
-            try {
-                this.#io.runTmux(["set-option", "-pu", "-t", pane.paneId, INTERNAL_READ_OPERATION_OPTION]);
-            }
-            catch {
-                // The pane may have disappeared with the failed capture.
+        catch {
+            if (!dispatch.native) {
+                try {
+                    this.#io.runTmux([
+                        "set-option",
+                        "-pu",
+                        "-t",
+                        pane.paneId,
+                        INTERNAL_READ_OPERATION_OPTION,
+                    ]);
+                }
+                catch {
+                    // The pane may have disappeared with the failed capture.
+                }
             }
-            throw error;
+            // Child-process errors can contain private stdout/stderr; do not expose them.
+            throw new WorkspaceMultiplexerError("mutation_failed", {
+                operationId,
+                reason: "pane_capture_failed",
+            });
+        }
+        const bytes = Buffer.from(captured, "utf8");
+        if (bytes.byteLength > SESSION_RUNTIME_PANE_CAPTURE_MAX_BYTES) {
+            throw new WorkspaceMultiplexerError("mutation_failed", {
+                operationId,
+                reason: "pane_capture_output_limit",
+            });
         }
         const observed = resolvePaneRow(this.#panes(workspace.sessionName), intent.semanticPaneId);
-        if (observed.paneId !== pane.paneId) {
+        if (observed.paneId !== pane.paneId ||
+            (pane.nativePaneBirthId != null && observed.nativePaneBirthId !== pane.nativePaneBirthId)) {
             throw new WorkspaceMultiplexerError("mutation_unverified", {
                 operationId,
                 reason: "pane_identity_changed_during_read",
             });
         }
+        // Retain the latest output, never split a UTF-8 code point at the cut.
+        let start = Math.max(0, bytes.byteLength - SESSION_RUNTIME_PANE_READ_MAX_BYTES);
+        while (start < bytes.byteLength && (bytes[start] & 0xc0) === 0x80)
+            start++;
+        const text = bytes.subarray(start).toString("utf8");
+        return SessionRuntimePaneReadResultSchemaZ.parse({
+            verb: "workspace.pane.read",
+            operationId,
+            daemonInstanceId: this.#daemonInstanceId,
+            workspaceName: intent.workspaceName,
+            semanticPaneId: intent.semanticPaneId,
+            format: "ansi",
+            availability: "available",
+            text,
+            byteCount: bytes.byteLength - start,
+            capturedByteCount: bytes.byteLength,
+            truncated: start > 0,
+        });
     }
     dispose() {
         this.#disposed = true;
@@ -339,7 +532,7 @@ export class WorkspaceMultiplexerAuthority {
             this.#paneIdentityCache.delete(oldest);
         }
     }
-    #mutate(raw, timing) {
+    #mutate(raw, timing, execution) {
         if (this.#disposed) {
             throw new WorkspaceMultiplexerError("workspace_unavailable", {
                 reason: "authority_disposed",
@@ -351,6 +544,36 @@ export class WorkspaceMultiplexerAuthority {
                 operationId: request.operationId,
             });
         }
+        if (request.intent.verb === "workspace.session.kill" && request.intent.fleetTarget) {
+            const target = request.intent.fleetTarget;
+            if (target.daemonInstanceId !== this.#daemonInstanceId)
+                throw new WorkspaceMultiplexerError("daemon_instance_mismatch", {
+                    operationId: request.operationId,
+                });
+            const raw = this.#io.runTmux([
+                "list-panes",
+                "-a",
+                "-F",
+                "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}",
+            ]);
+            const match = raw.split("\n").find((line) => {
+                const session = discoverLiveSessionSummaries(() => line)[0];
+                return (session?.liveSessionId === target.liveSessionId &&
+                    session.sessionName === target.sessionName);
+            });
+            if (!match)
+                throw new WorkspaceMultiplexerError("workspace_not_found", {
+                    reason: "session_incarnation_changed",
+                });
+            // Runtime session IDs are never reused by a live tmux server. The pinned runner
+            // separately refuses a replaced server; a name can therefore never retarget this kill.
+            const runtimeId = match.split("\t")[1];
+            return this.#killSession(target.sessionName, {
+                operationId: request.operationId,
+                daemonInstanceId: this.#daemonInstanceId,
+                workspaceName: request.intent.workspaceName,
+            }, runtimeId);
+        }
         const workspace = this.#registry.get(request.intent.workspaceName);
         if (!workspace) {
             throw new WorkspaceMultiplexerError("workspace_not_found", {
@@ -359,7 +582,7 @@ export class WorkspaceMultiplexerAuthority {
             });
         }
         try {
-            return WorkspaceMultiplexerMutationResultSchemaZ.parse(this.#perform(request, workspace, timing));
+            return WorkspaceMultiplexerMutationResultSchemaZ.parse(this.#perform(request, workspace, timing, execution));
         }
         catch (error) {
             const mapped = error instanceof WorkspaceMultiplexerError
@@ -396,7 +619,7 @@ export class WorkspaceMultiplexerAuthority {
         this.#setPaneIdentities(sessionName, identities);
         return rows;
     }
-    #perform(request, workspace, timing) {
+    #perform(request, workspace, timing, execution) {
         const intent = request.intent;
         const sessionName = workspace.sessionName;
         const envelope = {
@@ -405,6 +628,11 @@ export class WorkspaceMultiplexerAuthority {
             workspaceName: intent.workspaceName,
         };
         switch (intent.verb) {
+            case "workspace.window.link.select":
+            case "workspace.window.link.unlink":
+                throw new WorkspaceMultiplexerError("workspace_unavailable", {
+                    reason: "window_link_authority_required",
+                });
             case "workspace.window.split":
                 return this.#split(request, workspace, envelope);
             case "workspace.window.kill":
@@ -420,7 +648,7 @@ export class WorkspaceMultiplexerAuthority {
             case "workspace.pane.select":
                 return this.#select(intent, sessionName, envelope, timing);
             case "workspace.pane.send":
-                return this.#send(intent, sessionName, envelope);
+                return this.#send(intent, sessionName, envelope, execution);
             case "workspace.pane.swap":
                 return this.#swap(intent, sessionName, envelope);
             case "workspace.pane.resize":
@@ -599,10 +827,10 @@ export class WorkspaceMultiplexerAuthority {
             remainingWindowCount: windowIdsOf(after).length,
         };
     }
-    #killSession(sessionName, envelope) {
+    #killSession(sessionName, envelope, exactTarget = `=${sessionName}`) {
         let existed = true;
         try {
-            this.#io.runTmux(["has-session", "-t", `=${sessionName}`]);
+            this.#io.runTmux(["has-session", "-t", exactTarget]);
         }
         catch (error) {
             if (!this.#io.isMissingTmuxTarget(error))
@@ -610,10 +838,10 @@ export class WorkspaceMultiplexerAuthority {
             existed = false;
         }
         if (existed) {
-            this.#io.runTmux(["kill-session", "-t", `=${sessionName}`]);
+            this.#io.runTmux(["kill-session", "-t", exactTarget]);
             let stillPresent = true;
             try {
-                this.#io.runTmux(["has-session", "-t", `=${sessionName}`]);
+                this.#io.runTmux(["has-session", "-t", exactTarget]);
             }
             catch {
                 // A missing session is exactly the proof this verb wanted.
@@ -795,6 +1023,10 @@ export class WorkspaceMultiplexerAuthority {
         };
     }
     #select(intent, sessionName, envelope, timing) {
+        if (intent.windowLink)
+            throw new WorkspaceMultiplexerError("workspace_unavailable", {
+                reason: "window_link_authority_required",
+            });
         const timed = (operation, run) => {
             if (!timing)
                 return run();
@@ -891,13 +1123,40 @@ export class WorkspaceMultiplexerAuthority {
     // -------------------------------------------------------------------------
     // send
     // -------------------------------------------------------------------------
+    /** Optional metadata path; null alone permits pre-dispatch stock fallback. */
+    #runAuthored(operationId, execution, pane, expectedKinds, commands, dispatch, options) {
+        if (execution && pane.nativePaneBirthId && this.#io.runAuthoredNative) {
+            // Native outcomes complete the executor directly. Pane markers are only
+            // for the stock after-hook bridge and must not trigger native-path hooks.
+            const nativeCommands = commands.filter((command) => !(command[0] === "set-option" &&
+                command[1] === "-p" &&
+                command[2] === "-t" &&
+                command[3] === pane.paneId &&
+                (command[4] === INTERNAL_SEND_OPERATION_OPTION ||
+                    command[4] === INTERNAL_READ_OPERATION_OPTION)));
+            dispatch.native = true;
+            const result = this.#io.runAuthoredNative({
+                operationId,
+                context: execution,
+                targetPaneId: pane.paneId,
+                targetBirthId: pane.nativePaneBirthId,
+                commands: nativeCommands,
+                expectedKinds,
+            }, options);
+            if (result !== null)
+                return result.output;
+            dispatch.native = false;
+        }
+        return this.#io.runTmux(commands.flatMap((command, index) => (index === 0 ? [...command] : [";", ...command])), options);
+    }
     /**
      * Deliver literal bytes to a semantically addressed pane. A successful tmux
      * command plus a post-send identity read-back proves that the resolved pane
      * survived the operation; terminal output remains the independent observation
      * lane and is intentionally not parsed for prompt content.
      */
-    #send(intent, sessionName, envelope) {
+    #send(intent, sessionName, envelope, execution) {
+        const dispatch = { native: false };
         const before = this.#panes(sessionName);
         const pane = resolvePaneRow(before, intent.semanticPaneId);
         const sourcePane = intent.sourceSemanticPaneId
@@ -913,32 +1172,12 @@ export class WorkspaceMultiplexerAuthority {
         if (intent.submit) {
             const buffer = `tmux-ide-send-${envelope.operationId}`;
             try {
-                this.#io.runTmux([
-                    "set-buffer",
-                    "-b",
-                    buffer,
-                    "--",
-                    intent.text,
-                    ";",
-                    "paste-buffer",
-                    "-d",
-                    "-b",
-                    buffer,
-                    "-t",
-                    pane.paneId,
-                    ";",
-                    "set-option",
-                    "-p",
-                    "-t",
-                    pane.paneId,
-                    INTERNAL_SEND_OPERATION_OPTION,
-                    marker,
-                    ";",
-                    "send-keys",
-                    "-t",
-                    pane.paneId,
-                    "Enter",
-                ]);
+                this.#runAuthored(envelope.operationId, execution, pane, ["paste-buffer", "send-keys"], [
+                    ["set-buffer", "-b", buffer, "--", intent.text],
+                    ["paste-buffer", "-d", "-b", buffer, "-t", pane.paneId],
+                    ["set-option", "-p", "-t", pane.paneId, INTERNAL_SEND_OPERATION_OPTION, marker],
+                    ["send-keys", "-t", pane.paneId, "Enter"],
+                ], dispatch);
             }
             catch (error) {
                 try {
@@ -947,57 +1186,51 @@ export class WorkspaceMultiplexerAuthority {
                 catch {
                     // The one-shot paste already removed it, or the server disappeared.
                 }
-                try {
-                    this.#io.runTmux([
-                        "set-option",
-                        "-pu",
-                        "-t",
-                        pane.paneId,
-                        INTERNAL_SEND_OPERATION_OPTION,
-                    ]);
-                }
-                catch {
-                    // The pane may have disappeared with the failed send.
+                if (!dispatch.native) {
+                    try {
+                        this.#io.runTmux([
+                            "set-option",
+                            "-pu",
+                            "-t",
+                            pane.paneId,
+                            INTERNAL_SEND_OPERATION_OPTION,
+                        ]);
+                    }
+                    catch {
+                        // The pane may have disappeared with the failed send.
+                    }
                 }
                 throw error;
             }
         }
         else {
             try {
-                this.#io.runTmux([
-                    "set-option",
-                    "-p",
-                    "-t",
-                    pane.paneId,
-                    INTERNAL_SEND_OPERATION_OPTION,
-                    marker,
-                    ";",
-                    "send-keys",
-                    "-t",
-                    pane.paneId,
-                    "-l",
-                    "--",
-                    intent.text,
-                ]);
+                this.#runAuthored(envelope.operationId, execution, pane, ["send-keys"], [
+                    ["set-option", "-p", "-t", pane.paneId, INTERNAL_SEND_OPERATION_OPTION, marker],
+                    ["send-keys", "-t", pane.paneId, "-l", "--", intent.text],
+                ], dispatch);
             }
             catch (error) {
-                try {
-                    this.#io.runTmux([
-                        "set-option",
-                        "-pu",
-                        "-t",
-                        pane.paneId,
-                        INTERNAL_SEND_OPERATION_OPTION,
-                    ]);
-                }
-                catch {
-                    // The pane may have disappeared with the failed send.
+                if (!dispatch.native) {
+                    try {
+                        this.#io.runTmux([
+                            "set-option",
+                            "-pu",
+                            "-t",
+                            pane.paneId,
+                            INTERNAL_SEND_OPERATION_OPTION,
+                        ]);
+                    }
+                    catch {
+                        // The pane may have disappeared with the failed send.
+                    }
                 }
                 throw error;
             }
         }
         const observed = resolvePaneRow(this.#panes(sessionName), intent.semanticPaneId);
-        if (observed.paneId !== pane.paneId) {
+        if (observed.paneId !== pane.paneId ||
+            (pane.nativePaneBirthId != null && observed.nativePaneBirthId !== pane.nativePaneBirthId)) {
             throw new WorkspaceMultiplexerError("mutation_unverified", {
                 operationId: envelope.operationId,
                 reason: "pane_identity_changed_during_send",
@@ -1068,14 +1301,7 @@ export class WorkspaceMultiplexerAuthority {
     // resize
     // -------------------------------------------------------------------------
     /** The pane's own size on one axis, in cells, read straight from tmux. */
-    #paneCells(paneId, axis) {
-        const observed = this.#io.runTmux([
-            "display-message",
-            "-p",
-            "-t",
-            paneId,
-            axis === "cols" ? "#{pane_width}" : "#{pane_height}",
-        ]);
+    #paneCells(observed) {
         const cells = Number(observed);
         if (!Number.isInteger(cells) || cells < 1) {
             throw new WorkspaceMultiplexerError("mutation_unverified", { reason: "pane_size_shape" });
@@ -1093,7 +1319,22 @@ export class WorkspaceMultiplexerAuthority {
      * whole view exists to remove.
      */
     #resize(intent, sessionName, envelope) {
-        const rows = this.#panes(sessionName);
+        const steps = this.#resizeSteps(intent, sessionName, envelope);
+        let next = steps.next();
+        while (!next.done)
+            next = steps.next(this.#io.runTmux(next.value));
+        return next.value;
+    }
+    *#resizeSteps(intent, sessionName, envelope) {
+        const output = yield [
+            "list-panes",
+            "-s",
+            "-t",
+            `=${sessionName}`,
+            "-F",
+            `${PANE_FIELDS}\t#{pane_width}\t#{pane_height}`,
+        ];
+        const rows = parseMultiplexerPaneRows(output);
         const pane = resolvePaneRow(rows, intent.semanticPaneId);
         if (pane.windowPaneCount < 2) {
             throw new WorkspaceMultiplexerError("single_pane_window", {
@@ -1107,7 +1348,7 @@ export class WorkspaceMultiplexerAuthority {
                 semanticPaneId: intent.semanticPaneId,
             });
         }
-        const before = this.#paneCells(pane.paneId, intent.axis);
+        const before = this.#paneCells(intent.axis === "cols" ? pane.width : pane.height);
         if (before === intent.cells) {
             return {
                 ...envelope,
@@ -1118,14 +1359,22 @@ export class WorkspaceMultiplexerAuthority {
                 cells: before,
             };
         }
-        this.#io.runTmux([
+        // Keep mutation and authoritative readback in one tmux command queue.
+        // Avoid two extra synchronous client processes on every pointer update.
+        const observed = yield [
             "resize-pane",
             "-t",
             pane.paneId,
             intent.axis === "cols" ? "-x" : "-y",
             String(intent.cells),
-        ]);
-        const after = this.#paneCells(pane.paneId, intent.axis);
+            ";",
+            "display-message",
+            "-p",
+            "-t",
+            pane.paneId,
+            intent.axis === "cols" ? "#{pane_width}" : "#{pane_height}",
+        ];
+        const after = this.#paneCells(observed);
         return {
             ...envelope,
             verb: "workspace.pane.resize",