tmux-ide 2.9.0-beta.21 → 2.9.0-beta.26

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

@@ -30,7 +30,7 @@ import { decodeNativeGridCapture, isNativeBootstrapCapture, } from "./native-gri
  */
 import { createHash, randomBytes } from "node:crypto";
 import { hostname } from "node:os";
-import { WORKSPACE_SEMANTIC_PANE_OPTION, WORKSPACE_SEMANTIC_WINDOW_OPTION, WorkspaceIdSchemaZ, } from "@tmux-ide/contracts";
+import { WINDOW_LINK_MAX_LINKS, WORKSPACE_SEMANTIC_PANE_OPTION, WORKSPACE_SEMANTIC_WINDOW_OPTION, WorkspaceIdSchemaZ, } from "@tmux-ide/contracts";
 import { textToHexKeys } from "../protocol/control.js";
 import { InputCoalescer } from "../protocol/input-coalescer.js";
 import { NativeGridCaptureReader } from "./native-grid-reader.js";
@@ -38,6 +38,9 @@ import { parseLayout, parseLayoutChange, parseSessionWindowChanged, parseWindowP
 import { SESSION_PANE_DESCRIPTOR_FORMAT, SessionDescriptorDiscovery, decodeControlReplyUtf8, decodeTmuxArgument, parseSessionPaneDescriptorReply, } from "../protocol/session-descriptor-discovery.js";
 import { resolvePaneDisplayName } from "../protocol/pane-display-name.js";
 import { finalizeWorkspaceTmuxReconciliation, planWorkspaceTmuxReconciliation, } from "../protocol/workspace-tmux-adapter.js";
+import { liveSessionIdForNativeIdentity } from "../protocol/live-session-identity.js";
+import { WindowLinkAuthority, WindowLinkResolutionError } from "./window-link-authority.js";
+import { buildNativeWindowLinkGuard, buildNativeWindowLinkPaneSelectGuard, classifyNativeWindowLinkGuardResult, } from "../../lib/tmux-window-link-guard.js";
 import { FlowLedger } from "./flow-ledger.js";
 import { PaneFeed } from "./pane-feed.js";
 import { INTERNAL_READ_OPERATION_OPTION, registerInternalReadOperation, retireInternalReadOperation, } from "../../lib/tmux-interaction-options.js";
@@ -165,6 +168,9 @@ export class SessionChannel {
     truthActive = new Map();
     truthWindow = new Map();
     currentWindow = "";
+    windowLinkAuthority = null;
+    latestWindowStage = null;
+    attachedServerGeneration = null;
     diagnostics = [];
     degraded = false;
     ageByRuntime = new Map();
@@ -325,7 +331,13 @@ export class SessionChannel {
                 ? this.trustedInventoryFlight
                 : Promise.reject(new Error(`trusted inventory identity changed for ${this.opts.session}`));
         }
-        const flight = this.refreshTrustedInventory(expectedRuntimeSessionId).finally(() => {
+        const flight = this.refreshTrustedInventory(expectedRuntimeSessionId)
+            .catch((error) => {
+            this.windowLinkAuthority?.invalidate();
+            this.latestWindowStage = null;
+            throw error;
+        })
+            .finally(() => {
             if (this.trustedInventoryFlight === flight) {
                 this.trustedInventoryFlight = null;
                 this.trustedInventoryFlightSessionId = null;
@@ -344,21 +356,92 @@ export class SessionChannel {
         return this.attachedIdentity;
     }
     async captureAttachedSessionIdentity() {
-        const lines = await this.io.request(`display-message -p "#{qa:session_name}\t#{session_id}"`);
+        const lines = await this.io.request(`display-message -p "#{qa:session_name}\t#{session_id}\t#{pid}\t#{session_created}"`);
         if (lines.length !== 1)
             throw new Error(`mirror session ${this.opts.session} identity is absent`);
         const decodedLine = decodeControlReplyUtf8(lines[0]);
         if (decodedLine === null)
             throw new Error(`mirror session ${this.opts.session} identity is malformed`);
-        const [encodedName = "", runtimeSessionId = ""] = decodedLine.split("\t");
+        const [encodedName = "", runtimeSessionId = "", serverPid = "", sessionCreated = ""] = decodedLine.split("\t");
         const sessionName = decodeTmuxArgument(encodedName);
         if (sessionName.length === 0 ||
             sessionName.length > 160 ||
             !/^\$(?:0|[1-9][0-9]*)$/u.test(runtimeSessionId) ||
-            runtimeSessionId.length > 32) {
+            runtimeSessionId.length > 32 ||
+            !/^[1-9][0-9]*$/u.test(serverPid) ||
+            !/^[0-9]+$/u.test(sessionCreated)) {
             throw new Error(`mirror session ${this.opts.session} identity is malformed`);
         }
         this.attachedIdentity = Object.freeze({ sessionName, runtimeSessionId });
+        this.attachedServerGeneration = { serverPid, sessionCreated };
+        if (this.disposed)
+            return;
+        this.bindWindowLinkAuthority(liveSessionIdForNativeIdentity(serverPid, runtimeSessionId, sessionCreated));
+    }
+    bindWindowLinkAuthority(liveSessionId) {
+        const identity = this.attachedIdentity;
+        if (!identity || this.disposed)
+            throw new WindowLinkResolutionError("window_link_stale");
+        if (this.windowLinkAuthority?.liveSessionId === liveSessionId)
+            return;
+        this.windowLinkAuthority?.dispose();
+        this.windowLinkAuthority = new WindowLinkAuthority(liveSessionId, identity.runtimeSessionId);
+        if (this.latestWindowStage)
+            this.windowLinkAuthority.reconcile(this.latestWindowStage.links);
+    }
+    async executeWindowLinkAction(request) {
+        const authority = this.windowLinkAuthority;
+        if (!authority || this.disposed)
+            throw new WindowLinkResolutionError("window_link_stale");
+        const pane = request.paneId ? this.panesBySemantic.get(request.paneId) : undefined;
+        if (request.paneId && !pane)
+            throw new WindowLinkResolutionError("window_link_backing_mismatch");
+        const semanticWindow = pane?.windowRuntimeId
+            ? this.windowsByRuntime.get(pane.windowRuntimeId)?.semanticId
+            : null;
+        const target = request.target ?? (semanticWindow ? authority.uniqueTargetForBacking(semanticWindow) : null);
+        if (!target)
+            throw new WindowLinkResolutionError("window_link_stale");
+        const resolved = authority.resolve(target);
+        if (pane && (pane.windowRuntimeId !== resolved.runtimeWindowId || request.action !== "select"))
+            throw new WindowLinkResolutionError("window_link_backing_mismatch");
+        const address = {
+            sessionId: resolved.runtimeSessionId,
+            windowIndex: resolved.index,
+            expectedWindowId: resolved.runtimeWindowId,
+            expectedServerPid: this.attachedServerGeneration.serverPid,
+            expectedSessionCreated: this.attachedServerGeneration.sessionCreated,
+        };
+        const args = pane
+            ? buildNativeWindowLinkPaneSelectGuard(address, pane.runtimeId)
+            : buildNativeWindowLinkGuard(address, request.action);
+        let outcome;
+        try {
+            if (!this.opts.executeWindowLinkGuard)
+                throw new Error("Window link executor unavailable");
+            const result = await this.opts.executeWindowLinkGuard(args);
+            outcome = classifyNativeWindowLinkGuardResult(result.status, result.stdout);
+        }
+        catch {
+            // A lost command boundary can follow a mutation; never retry automatically.
+            outcome = "indeterminate";
+        }
+        let timer;
+        const reconciled = await Promise.race([
+            this.syncNow().then(() => true, () => false),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(false), 2000);
+            }),
+        ]).finally(() => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        });
+        if (!reconciled) {
+            authority.invalidate();
+            this.latestWindowStage = null;
+            return { outcome, windowLinks: null };
+        }
+        return { outcome, windowLinks: authority.snapshot() };
     }
     /** Optional native backing, addressed through the verified semantic binding. */
     captureNativeBacking(semanticPaneId, ownsSubscription = () => true) {
@@ -494,7 +577,7 @@ export class SessionChannel {
                 throw error;
             }
         }
-        if (expectedByWindow.size !== inventory.panes[0].sessionWindowCount ||
+        if (this.latestWindowStage?.links.length !== inventory.panes[0].sessionWindowCount ||
             expectedByWindow.size !== this.windowsByRuntime.size) {
             throw new Error(`authoritative layout for ${this.opts.session} has incomplete windows`);
         }
@@ -631,6 +714,7 @@ export class SessionChannel {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.windowLinkAuthority?.dispose();
         this.nativeGrid.dispose();
         this.settleFirstJoin();
         this.cancelSync?.();
@@ -701,12 +785,13 @@ export class SessionChannel {
         this.noteRecoveryOutput(pane, outputOrdinal);
     }
     // ── Seed / reseed (the atomic recipe) ────────────────────────────────────
-    reseed(sub, onSettled, deferPublish = false, deadlineAt = this.recoveryNowMs() + RECOVERY_ABSOLUTE_DEADLINE_MS) {
+    reseed(lease, onSettled, deferPublish = false, deadlineAt = this.recoveryNowMs() + RECOVERY_ABSOLUTE_DEADLINE_MS) {
+        const { sub } = lease;
         if (sub.closed || sub.frozen || this.disposed) {
             onSettled?.(FAILED_RESEED_RESULT);
             return;
         }
-        sub.cancelCapture?.();
+        lease.cancelRecipe?.();
         const runtime = sub.pane.runtimeId;
         const epoch = sub.feed.beginReseed();
         let settled = false;
@@ -719,7 +804,7 @@ export class SessionChannel {
                 return;
             settled = true;
             cancelDeadline?.();
-            sub.cancelCapture = null;
+            lease.cancelRecipe = null;
             onSettled?.(result);
         };
         // Keystroke ordering: pending coalesced input leaves before the probes.
@@ -732,12 +817,12 @@ export class SessionChannel {
             markerRetired = true;
             this.retireInternalReadMarker(runtime, internalReadMarker);
         };
-        sub.cancelCapture = () => {
+        lease.cancelRecipe = () => {
             if (settled)
                 return;
             settled = true;
             cancelDeadline?.();
-            sub.cancelCapture = null;
+            lease.cancelRecipe = null;
             sub.feed.abort(epoch);
             if (!captureSucceeded)
                 retireMarker();
@@ -770,9 +855,9 @@ export class SessionChannel {
                     settled = true;
                     sub.feed.abort(epoch);
                     cancelDeadline?.();
-                    sub.cancelCapture = null;
+                    lease.cancelRecipe = null;
                     retireMarker();
-                    this.reseed(sub, onSettled, deferPublish, deadlineAt);
+                    this.reseed(lease, onSettled, deferPublish, deadlineAt);
                     return;
                 }
                 sub.feed.abort(epoch);
@@ -787,10 +872,10 @@ export class SessionChannel {
                 retireMarker();
                 sub.feed.abort(epoch);
                 cancelDeadline?.();
-                sub.cancelCapture = null;
+                lease.cancelRecipe = null;
                 sub.nativeBootstrap = false;
                 this.nativeBootstrapUnavailable = true;
-                this.reseed(sub, onSettled, deferPublish, deadlineAt);
+                this.reseed(lease, onSettled, deferPublish, deadlineAt);
                 return;
             }
             if (!reply.ok) {
@@ -864,14 +949,14 @@ export class SessionChannel {
     reseedPlain(sub, resumeReason = null) {
         if (sub.closed || sub.frozen || this.disposed)
             return;
-        if (this.plainReseedActive === sub)
+        if (this.plainReseedActive?.sub === sub)
             sub.cancelCapture?.();
         if (!this.plainReseedQueue.has(sub) && this.plainReseedQueue.size >= MAX_QUEUED_PLAIN_RESEEDS) {
             this.failPlainReseed(sub);
             return;
         }
         this.plainReseedQueue.set(sub, resumeReason);
-        if (this.plainReseedActive !== sub) {
+        if (this.plainReseedActive?.sub !== sub) {
             // Output before this queued recipe starts is already in its future
             // capture. Do not publish it using the prior geometry in the meantime.
             sub.feed.beginReseed();
@@ -904,13 +989,26 @@ export class SessionChannel {
             this.drainPlainReseeds();
             return;
         }
-        this.plainReseedActive = sub;
+        sub.cancelCapture?.();
+        const lease = { sub, cancelRecipe: null };
+        this.plainReseedActive = lease;
+        // The queue lease outlives individual native capability probes. Retrying
+        // or falling back replaces only cancelRecipe, never this queue owner.
+        sub.cancelCapture = () => {
+            if (this.plainReseedActive !== lease)
+                return;
+            lease.cancelRecipe?.();
+            sub.cancelCapture = null;
+            this.plainReseedActive = null;
+            this.drainPlainReseeds();
+        };
         // Only the recipe actually submitted to the control FIFO owns a five
         // second deadline. A large sibling projection cannot consume the waiting
         // panes' entire capture budgets before their commands have been written.
-        this.reseed(sub, (result) => {
-            if (this.plainReseedActive !== sub)
+        this.reseed(lease, (result) => {
+            if (this.plainReseedActive !== lease)
                 return;
+            sub.cancelCapture = null;
             this.plainReseedActive = null;
             if (!result.ok) {
                 // A stalled FIFO cannot make progress for queued recipes either. Retire
@@ -930,16 +1028,6 @@ export class SessionChannel {
             if (resumeReason && !sub.closed && !sub.frozen)
                 sub.onEvent({ type: "flow", state: "resumed", reason: resumeReason });
         }, true);
-        if (this.plainReseedActive === sub) {
-            const cancel = sub.cancelCapture;
-            sub.cancelCapture = () => {
-                cancel?.();
-                this.plainReseedQueue.delete(sub);
-                if (this.plainReseedActive === sub)
-                    this.plainReseedActive = null;
-                this.drainPlainReseeds();
-            };
-        }
     }
     retireInternalReadMarker(runtime, marker) {
         if (!/^%(?:0|[1-9][0-9]*)$/u.test(runtime))
@@ -2014,6 +2102,11 @@ export class SessionChannel {
             return;
         }
         if (name === "session-window-changed") {
+            // The notification carries backing identity only; duplicate links require an index read.
+            if (this.windowLinkAuthority) {
+                this.scheduleSync();
+                return;
+            }
             const change = parseSessionWindowChanged(rest);
             if (!change)
                 return;
@@ -2097,6 +2190,9 @@ export class SessionChannel {
             this.emitLayoutAuthorityTo(subscriber, runtimeSessionId);
     }
     emitLayoutAuthorityTo(subscriber, runtimeSessionId) {
+        const windowLinks = this.windowLinkAuthority?.snapshot();
+        if (!windowLinks)
+            return;
         const layouts = [...this.layoutByWindow.keys()]
             .map((runtimeId) => this.layoutEventFor(runtimeId))
             .filter((event) => event !== null);
@@ -2104,6 +2200,7 @@ export class SessionChannel {
             session: this.opts.session,
             runtimeSessionId,
             topologyEpoch: this.layoutTopologyEpoch,
+            windowLinks,
             layouts,
         });
     }
@@ -2207,8 +2304,9 @@ export class SessionChannel {
                 windowActive: windowActive === "1",
             });
         }
+        const previousCurrentWindow = this.currentWindow;
         const { listed, movedWindowRuntimeIds } = this.applyPaneTruth(truth);
-        await this.syncWindows(this.opts.session, movedWindowRuntimeIds);
+        await this.syncWindows(this.opts.session, movedWindowRuntimeIds, previousCurrentWindow);
         this.discovery.discover(listed);
     }
     applyPaneTruth(truth) {
@@ -2266,7 +2364,20 @@ export class SessionChannel {
             parsed.descriptors.length !== beforeLines.length) {
             throw new Error(`trusted inventory for ${this.opts.session} is malformed`);
         }
-        const descriptors = parsed.descriptors;
+        const descriptorByPane = new Map();
+        for (const row of parsed.descriptors) {
+            const previous = descriptorByPane.get(row.runtimePaneId);
+            if (previous) {
+                const comparable = (value) => JSON.stringify({ ...value, windowActive: false, windowIndex: null });
+                if (comparable(previous) !== comparable(row))
+                    throw new Error("Inconsistent linked pane observation");
+                if (row.windowActive)
+                    descriptorByPane.set(row.runtimePaneId, row);
+            }
+            else
+                descriptorByPane.set(row.runtimePaneId, row);
+        }
+        const descriptors = [...descriptorByPane.values()];
         const runtimePaneIds = new Set(descriptors.map((pane) => pane.runtimePaneId));
         const runtimeSessionIds = new Set(descriptors.map((pane) => pane.runtimeSessionId));
         const activeWindowIds = new Set(descriptors.filter((pane) => pane.windowActive).map((pane) => pane.windowId));
@@ -2286,10 +2397,26 @@ export class SessionChannel {
             computedWindowCounts.set(runtimeWindowId, (computedWindowCounts.get(runtimeWindowId) ?? 0) + 1);
         }
         if (descriptors.some((pane) => pane.windowPaneCount !== computedWindowCounts.get(pane.windowId) ||
-            pane.sessionWindowCount !== computedWindowCounts.size)) {
+            pane.sessionWindowCount !== descriptors[0].sessionWindowCount)) {
             throw new Error(`trusted inventory for ${this.opts.session} has incomplete counts`);
         }
         const windowStage = await this.stageWindows(expectedRuntimeSessionId);
+        const descriptorKeys = new Set();
+        for (const row of parsed.descriptors) {
+            const link = windowStage.links.find((link) => link.index === row.windowIndex);
+            const key = `${row.windowIndex}:${row.runtimePaneId}`;
+            if (!link ||
+                link.runtimeWindowId !== row.windowId ||
+                link.active !== row.windowActive ||
+                descriptorKeys.has(key))
+                throw new Error(`trusted inventory for ${this.opts.session} lacks verified identity: inconsistent linked pane membership`);
+            descriptorKeys.add(key);
+        }
+        for (const link of windowStage.links) {
+            const count = computedWindowCounts.get(link.runtimeWindowId);
+            if (parsed.descriptors.filter((row) => row.windowIndex === link.index).length !== count)
+                throw new Error("Incomplete linked pane membership");
+        }
         const repairedPanes = await this.repairTrustedPaneIdentity(descriptors, windowStage.layouts);
         const afterLines = await this.io.request(`list-panes -s -t "${expectedRuntimeSessionId}" -F "${SESSION_PANE_DESCRIPTOR_FORMAT}"`);
         const confirmedWindowStage = await this.stageWindows(expectedRuntimeSessionId);
@@ -2330,6 +2457,7 @@ export class SessionChannel {
                 break;
         }
         if (confirmedWindowStage.currentWindow !== activeWindowId ||
+            confirmedWindowStage.links.length !== descriptors[0].sessionWindowCount ||
             confirmedWindowStage.windows.size !== computedWindowCounts.size ||
             !stagedPaneMembershipExact ||
             stagedPaneCount !== descriptors.length ||
@@ -2367,7 +2495,7 @@ export class SessionChannel {
             throw new Error(`trusted inventory for ${this.opts.session} is degraded`);
         }
         const windowCounts = computedWindowCounts;
-        const sessionWindowCount = computedWindowCounts.size;
+        const sessionWindowCount = confirmedWindowStage.links.length;
         const panes = descriptors.map((descriptor) => {
             const record = this.panesByRuntime.get(descriptor.runtimePaneId);
             const runtimeWindowId = descriptor.windowId;
@@ -2406,12 +2534,18 @@ export class SessionChannel {
             panes: Object.freeze(panes),
         });
     }
-    async syncWindows(target = this.opts.session, requiredLayoutEmits = new Set()) {
-        const stage = await this.stageWindows(target);
-        this.commitWindowStage(stage, requiredLayoutEmits);
+    async syncWindows(target = this.opts.session, requiredLayoutEmits = new Set(), previousCurrentWindow = this.currentWindow) {
+        const stage = await this.stageWindows(target).catch((error) => {
+            this.windowLinkAuthority?.invalidate();
+            this.latestWindowStage = null;
+            throw error;
+        });
+        this.commitWindowStage(stage, requiredLayoutEmits, previousCurrentWindow);
         return stage.repairedIdentity;
     }
     commitWindowStage(stage, requiredLayoutEmits = new Set(), previousCurrentWindow = this.currentWindow) {
+        this.windowLinkAuthority?.reconcile(stage.links);
+        this.latestWindowStage = stage;
         const changedWindows = new Set();
         for (const [runtimeId, record] of stage.windows) {
             const previous = this.windowsByRuntime.get(runtimeId);
@@ -2468,7 +2602,8 @@ export class SessionChannel {
         this.emitLayoutAuthority();
     }
     windowStagesEqual(left, right) {
-        if (left.currentWindow !== right.currentWindow ||
+        if (JSON.stringify(left.links) !== JSON.stringify(right.links) ||
+            left.currentWindow !== right.currentWindow ||
             left.windows.size !== right.windows.size ||
             left.layouts.size !== right.layouts.size) {
             return false;
@@ -2504,29 +2639,35 @@ export class SessionChannel {
         return true;
     }
     async stageWindows(target = this.opts.session) {
-        const lines = await this.io.request(`list-windows -t "${target}" -F "#{window_id}\t#{qa:@tmux_ide_window_id}\t#{qa:window_name}\t#{window_active}\t#{window_visible_layout}\t#{?window_zoomed_flag,1,0}\t#{pane-border-status}\t#{window_layout}\t#{mode-keys}"`);
+        const lines = await this.io.request(`list-windows -t "${target}" -F "#{window_id}\t#{qa:@tmux_ide_window_id}\t#{qa:window_name}\t#{window_active}\t#{window_visible_layout}\t#{?window_zoomed_flag,1,0}\t#{pane-border-status}\t#{window_layout}\t#{mode-keys}\t#{window_index}"`);
+        if (lines.length > WINDOW_LINK_MAX_LINKS)
+            throw new Error("Window link observation exceeds bound");
         const rows = [];
-        const seenRuntimeIds = new Set();
+        const seenIndexes = new Set();
         for (const raw of lines) {
             // Replies are latin1 byte strings; recover UTF-8 window names first.
             const line = Buffer.from(raw, "latin1").toString("utf8");
             const parts = line.split("\t");
-            if (parts.length !== 7 && parts.length !== 8 && parts.length !== 9) {
+            if (parts.length !== 10) {
                 throw new Error(`window layout truth for ${this.opts.session} is malformed`);
             }
-            const [runtimeId = "", stampRaw = "", nameRaw = "", active = "", visible = "", zoomed = "", borderStatus = "off", full = visible, modeKeys,] = parts;
+            const [runtimeId = "", stampRaw = "", nameRaw = "", active = "", visible = "", zoomed = "", borderStatus = "off", full = visible, modeKeys, indexRaw = "",] = parts;
+            const index = Number(indexRaw);
             if (!/^@[0-9]+$/u.test(runtimeId) ||
-                seenRuntimeIds.has(runtimeId) ||
+                !/^(?:0|[1-9][0-9]*)$/u.test(indexRaw) ||
+                !Number.isSafeInteger(index) ||
+                seenIndexes.has(index) ||
                 (active !== "0" && active !== "1") ||
                 (zoomed !== "0" && zoomed !== "1") ||
                 (borderStatus !== "top" && borderStatus !== "bottom" && borderStatus !== "off") ||
                 (modeKeys !== undefined && modeKeys !== "emacs" && modeKeys !== "vi")) {
                 throw new Error(`window layout truth for ${this.opts.session} is malformed`);
             }
-            seenRuntimeIds.add(runtimeId);
+            seenIndexes.add(index);
             const stamp = decodeTmuxArgument(stampRaw);
             const name = decodeTmuxArgument(nameRaw);
             rows.push({
+                index,
                 runtimeId,
                 stamp: stamp.length > 0 ? stamp : null,
                 name: name.length > 0 ? name : null,
@@ -2545,8 +2686,22 @@ export class SessionChannel {
         if (activeRows.length !== 1) {
             throw new Error(`window layout truth for ${this.opts.session} has inconsistent active window`);
         }
-        const nextLayoutByWindow = new Map();
+        const backingRows = new Map();
         for (const row of rows) {
+            const previous = backingRows.get(row.runtimeId);
+            if (previous &&
+                (previous.stamp !== row.stamp ||
+                    previous.name !== row.name ||
+                    previous.visible !== row.visible ||
+                    previous.full !== row.full ||
+                    previous.zoomed !== row.zoomed ||
+                    previous.paneBorderStatus !== row.paneBorderStatus ||
+                    previous.modeKeys !== row.modeKeys))
+                throw new Error("Inconsistent linked backing observation");
+            backingRows.set(row.runtimeId, row);
+        }
+        const nextLayoutByWindow = new Map();
+        for (const row of backingRows.values()) {
             const parsed = parseLayout(row.visible);
             if (!parsed) {
                 throw new Error(`window layout truth for ${this.opts.session} is malformed`);
@@ -2559,7 +2714,7 @@ export class SessionChannel {
         // Valid unique stamps are identity; missing/invalid/duplicated stamps are
         // ALL regenerated and stamped back (the pane policy, applied to windows).
         const stampCounts = new Map();
-        for (const row of rows) {
+        for (const row of backingRows.values()) {
             if (row.stamp && WorkspaceIdSchemaZ.safeParse(row.stamp).success) {
                 stampCounts.set(row.stamp, (stampCounts.get(row.stamp) ?? 0) + 1);
             }
@@ -2568,10 +2723,8 @@ export class SessionChannel {
         const generateWindowId = this.opts.generateWindowId ?? defaultMirrorWindowId;
         let repairedIdentity = false;
         const next = new Map();
-        let nextCurrentWindow = "";
-        for (const row of rows) {
-            if (row.active)
-                nextCurrentWindow = row.runtimeId;
+        const nextCurrentWindow = activeRows[0].runtimeId;
+        for (const row of backingRows.values()) {
             let semanticId = null;
             if (row.stamp && stampCounts.get(row.stamp) === 1) {
                 semanticId = row.stamp;
@@ -2614,6 +2767,12 @@ export class SessionChannel {
             layouts: nextLayoutByWindow,
             currentWindow: nextCurrentWindow,
             repairedIdentity,
+            links: rows.map((row) => ({
+                index: row.index,
+                runtimeWindowId: row.runtimeId,
+                semanticWindowId: next.get(row.runtimeId).semanticId ?? "",
+                active: row.active,
+            })),
         };
     }
     async reconcileIdentity(descriptors, listed) {
@@ -2804,6 +2963,7 @@ export class SessionChannel {
     onChannelExit() {
         if (this.disposed)
             return;
+        this.windowLinkAuthority?.dispose();
         this.nativeGrid.dispose();
         this.settleFirstJoin();
         for (const runtime of [...this.recoveries.keys()])