tmux-ide 2.9.0-beta.9 → 2.9.3

package/packages/daemon/dist/terminal/attachments/native-runtime.js

@@ -1,3 +1,5 @@
+import { nativePaneIdentity } from "../../lib/native-pane-identity.js";
+import { fenceNativeTmuxCommand, } from "../../lib/tmux-server-generation-runner.js";
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
 import { execFile } from "node:child_process";
 import { isAbsolute } from "node:path";
@@ -91,6 +93,7 @@ function canonicalAuthority(input) {
             socketArgv = ["-L", input.socketSelector.name];
         }
         return Object.freeze({
+            nativeServerIdentity: input.nativeServerIdentity,
             namedSocketFence: socketSelector.kind === "name" ? (input.namedSocketFence ?? null) : null,
             executablePath,
             socketSelector: Object.freeze(socketSelector),
@@ -144,13 +147,16 @@ function pinnedRunner(authority, execute, startupPolicy) {
             if (command.executable !== "tmux")
                 return { status: "failed" };
             try {
-                const stdout = execute(authority.executablePath, [...currentSocketArgv(authority), ...command.argv], {
+                const guarded = authority.nativeServerIdentity
+                    ? fenceNativeTmuxCommand(command.argv, authority.nativeServerIdentity)
+                    : null;
+                const stdout = execute(authority.executablePath, [...currentSocketArgv(authority), ...(guarded?.argv ?? command.argv)], {
                     cwd: authority.trustedCwd,
                     env: authority.environment,
                     maxBuffer: MAX_TMUX_OUTPUT_BYTES,
                     timeoutMs: TERMINAL_ATTACHMENT_TMUX_COMMAND_TIMEOUT_MS,
                 });
-                const value = String(stdout);
+                const value = guarded ? guarded.verify(String(stdout)) : String(stdout);
                 if (authority.namedSocketFence && !authority.namedSocketFence.isPinned())
                     authority.namedSocketFence.resolve();
                 if (value.includes("\0") || Buffer.byteLength(value, "utf8") > MAX_TMUX_OUTPUT_BYTES) {
@@ -209,11 +215,14 @@ function pinnedReadRunner(authority, execute) {
             if (command.executable !== "tmux" || signal?.aborted)
                 return { status: "failed" };
             try {
+                const guarded = authority.nativeServerIdentity
+                    ? fenceNativeTmuxCommand(command.argv, authority.nativeServerIdentity)
+                    : null;
                 const stdout = await execute(authority.executablePath, [
                     ...(authority.namedSocketFence
                         ? await authority.namedSocketFence.resolveAsync(signal)
                         : currentSocketArgv(authority)),
-                    ...command.argv,
+                    ...(guarded?.argv ?? command.argv),
                 ], {
                     cwd: authority.trustedCwd,
                     env: authority.environment,
@@ -221,7 +230,7 @@ function pinnedReadRunner(authority, execute) {
                     timeoutMs: TERMINAL_ATTACHMENT_TMUX_COMMAND_TIMEOUT_MS,
                     ...(signal ? { signal } : {}),
                 });
-                const value = String(stdout);
+                const value = guarded ? guarded.verify(String(stdout)) : String(stdout);
                 if (authority.namedSocketFence && !authority.namedSocketFence.isPinned())
                     await authority.namedSocketFence.resolveAsync(signal);
                 if (value.includes("\0") || Buffer.byteLength(value, "utf8") > MAX_TMUX_OUTPUT_BYTES)
@@ -341,6 +350,7 @@ function projectTrustedMirrorInventory(trusted, workspaceName, expectedSessionNa
         return Object.freeze({
             workspaceName,
             semanticPaneId: nullable(pane.semanticPaneId),
+            nativePaneBirthId: pane.nativePaneBirthId ?? null,
             windowStamp: nullable(pane.semanticWindowId),
             sessionId: pane.runtimeSessionId,
             windowId: pane.runtimeWindowId,
@@ -354,6 +364,7 @@ function projectTrustedMirrorInventory(trusted, workspaceName, expectedSessionNa
             active: pane.active,
             role: nullable(pane.role),
             name: nullable(pane.name),
+            ...(pane.nameSource ? { nameSource: nullable(pane.nameSource) } : {}),
             type: nullable(pane.type),
             missionStamp: nullable(pane.missionStamp),
             dir: boundedWireValue(pane.dir, 4_096),
@@ -366,6 +377,44 @@ function projectTrustedMirrorInventory(trusted, workspaceName, expectedSessionNa
     }
     return Object.freeze(panes);
 }
+function analyzeInventoryPanes(panes) {
+    return analyzeTrustedSemanticPaneCatalog(panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, interactionEndpoint: _interactionEndpoint, nativeIdentity: _nativeIdentity, nativePaneBirthId: _nativePaneBirthId, ...row }) => row));
+}
+function hasWindowStampCollision(rows) {
+    const windows = new Map();
+    for (const row of rows) {
+        if (row.windowStamp == null)
+            continue;
+        const previous = windows.get(row.windowStamp);
+        if (previous !== undefined && previous !== row.windowId)
+            return true;
+        windows.set(row.windowStamp, row.windowId);
+    }
+    return false;
+}
+function hasCompleteWindowIdentity(rows) {
+    const stamps = new Map();
+    for (const row of rows) {
+        if (row.windowStamp == null)
+            return false;
+        const previous = stamps.get(row.windowId);
+        if (previous !== undefined && previous !== row.windowStamp)
+            return false;
+        stamps.set(row.windowId, row.windowStamp);
+    }
+    return !hasWindowStampCollision(rows);
+}
+function projectQualifiedInventory(trusted, workspaceName, sessionName) {
+    const panes = projectTrustedMirrorInventory(trusted, workspaceName, sessionName);
+    const catalog = analyzeInventoryPanes(panes);
+    if (catalog.invalidRuntimeProof ||
+        catalog.missingSemanticStamp ||
+        catalog.duplicateSemanticStamp ||
+        catalog.duplicateRuntimePaneBinding) {
+        throw new NativeTerminalAttachmentRuntimeError("invalid-tmux-output");
+    }
+    return Object.freeze({ panes, catalog });
+}
 async function awaitInventoryUnlessAborted(promise, signal) {
     if (signal.aborted)
         throw new NativeTerminalAttachmentRuntimeError("runtime-disposed");
@@ -405,6 +454,8 @@ const PANE_FORMAT = [
     // window reports the same value; the catalog requires it before a multi-pane
     // window is attachable.
     "#{@tmux_ide_window_id}",
+    "#{window_index}",
+    "#{pane_birth_id}",
     PANE_WIRE_SENTINEL,
 ].join(WIRE_SEPARATOR);
 async function requiredTmuxResult(runner, argv, signal) {
@@ -441,25 +492,24 @@ async function liveSessionIdentities(runner, signal) {
 }
 function parsePaneSnapshot(stdout, expected) {
     const panes = [];
-    const runtimeIds = new Set();
+    const runtimeIds = new Map();
+    const links = new Map();
     for (const line of strictLines(stdout, MAX_DISCOVERED_PANES)) {
         const fields = line.split(WIRE_SEPARATOR);
-        if (fields.length !== 19 || fields[18] !== PANE_WIRE_SENTINEL) {
+        if (fields.length !== 21 || fields[20] !== PANE_WIRE_SENTINEL) {
             throw new NativeTerminalAttachmentRuntimeError("invalid-tmux-output");
         }
-        const [sessionName, sessionId, windowId, runtimePaneId, paneCountValue, windowCountValue, stamp, indexValue, title, currentCommand, windowActive, paneActive, role, name, type, missionStamp, dir, windowStampValue,] = fields;
+        const [sessionName, sessionId, windowId, runtimePaneId, paneCountValue, windowCountValue, stamp, indexValue, title, currentCommand, windowActive, paneActive, role, name, type, missionStamp, dir, windowStampValue, windowIndexValue, nativePaneBirthId,] = fields;
         if (sessionName !== expected.name ||
             sessionId !== expected.id ||
             !RUNTIME_WINDOW_ID.test(windowId) ||
             !RUNTIME_PANE_ID.test(runtimePaneId) ||
-            runtimeIds.has(runtimePaneId) ||
             !["0", "1"].includes(windowActive) ||
             !["0", "1"].includes(paneActive)) {
             throw new NativeTerminalAttachmentRuntimeError("invalid-tmux-output");
         }
-        runtimeIds.add(runtimePaneId);
         const nullable = (value) => boundedWireValue(value, 256).length === 0 ? null : value;
-        panes.push({
+        const facts = {
             sessionName,
             sessionId,
             windowId,
@@ -467,6 +517,7 @@ function parsePaneSnapshot(stdout, expected) {
             windowPaneCount: positiveInteger(paneCountValue),
             sessionWindowCount: positiveInteger(windowCountValue),
             semanticPaneId: nullable(stamp),
+            nativePaneBirthId: nativePaneBirthId || null,
             windowStamp: nullable(windowStampValue),
             index: nonnegativeInteger(indexValue),
             title: boundedWireValue(title, 1_024),
@@ -481,18 +532,51 @@ function parsePaneSnapshot(stdout, expected) {
             // registered workspace remains the trusted application-shell root, so
             // keep discovery available and carry the empty presentation value.
             dir: boundedWireValue(dir, 4_096),
-        });
+        };
+        const windowIndex = nonnegativeInteger(windowIndexValue);
+        const link = links.get(windowIndex) ?? {
+            windowId,
+            active: windowActive === "1",
+            panes: new Set(),
+        };
+        if (link.windowId !== windowId ||
+            link.active !== (windowActive === "1") ||
+            link.panes.has(runtimePaneId)) {
+            throw new NativeTerminalAttachmentRuntimeError("invalid-tmux-output");
+        }
+        link.panes.add(runtimePaneId);
+        links.set(windowIndex, link);
+        // Only link index and current-link state may differ for a shared backing.
+        const proof = JSON.stringify(fields.filter((_value, index) => index !== 10 && index !== 18));
+        const previous = runtimeIds.get(runtimePaneId);
+        if (previous) {
+            if (previous.proof !== proof)
+                throw new NativeTerminalAttachmentRuntimeError("invalid-tmux-output");
+            if (facts.active && !previous.facts.active) {
+                const merged = { ...previous.facts, active: true };
+                panes[panes.indexOf(previous.facts)] = merged;
+                previous.facts = merged;
+            }
+        }
+        else {
+            runtimeIds.set(runtimePaneId, { facts, proof });
+            panes.push(facts);
+        }
     }
     const counts = new Map();
     for (const pane of panes)
         counts.set(pane.windowId, (counts.get(pane.windowId) ?? 0) + 1);
-    const windows = new Set(panes.map((pane) => pane.windowId));
     if (panes.some((pane) => counts.get(pane.windowId) !== pane.windowPaneCount ||
-        windows.size !== pane.sessionWindowCount) ||
+        links.size !== pane.sessionWindowCount) ||
+        [...links.values()].some((link) => link.panes.size !== counts.get(link.windowId)) ||
+        [...links.values()].filter((link) => link.active).length > 1 ||
         panes.filter((pane) => pane.active).length > 1) {
         throw new NativeTerminalAttachmentRuntimeError("invalid-tmux-output");
     }
-    return panes;
+    return {
+        panes,
+        linksProof: JSON.stringify([...links].map(([index, link]) => [index, link.windowId, [...link.panes]])),
+    };
 }
 /**
  * One bounded, old-tmux-safe discovery path for both live attachment and the
@@ -520,11 +604,13 @@ export async function discoverWorkspaceRegistryTerminalInventory(registry, runne
         const before = await requiredTmuxResult(runner, argv, signal);
         if (before === null)
             continue;
-        const panes = parsePaneSnapshot(before, identity);
+        const first = parsePaneSnapshot(before, identity);
+        const panes = first.panes;
         const after = await requiredTmuxResult(runner, argv, signal);
         if (after === null)
             throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
-        const latest = parsePaneSnapshot(after, identity);
+        const second = parsePaneSnapshot(after, identity);
+        const latest = second.panes;
         // Foreground commands, titles, focus and paths can change while the same
         // pane remains valid. Fence binding/topology only, then publish one complete
         // latest snapshot rather than mixing presentation values across reads.
@@ -539,7 +625,8 @@ export async function discoverWorkspaceRegistryTerminalInventory(registry, runne
             "windowStamp",
             "index",
         ];
-        if (panes.length !== latest.length ||
+        if (first.linksProof !== second.linksProof ||
+            panes.length !== latest.length ||
             panes.some((pane, index) => proofKeys.some((key) => pane[key] !== latest[index][key]))) {
             throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
         }
@@ -554,13 +641,13 @@ export async function discoverWorkspaceRegistryTerminalInventory(registry, runne
             }
         }
     }
-    const catalog = analyzeTrustedSemanticPaneCatalog(panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, ...row }) => row));
+    const catalog = analyzeTrustedSemanticPaneCatalog(panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, interactionEndpoint: _interactionEndpoint, nativeIdentity: _nativeIdentity, nativePaneBirthId: _nativePaneBirthId, ...row }) => row));
     return Object.freeze({ panes: Object.freeze(panes), catalog });
 }
 /** Internal raw-id discovery; callers expose only SemanticPaneCatalog resolution. */
 export async function discoverWorkspaceRegistrySemanticPanes(registry, runner, signal) {
     const inventory = await discoverWorkspaceRegistryTerminalInventory(registry, runner, signal);
-    return inventory.panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, ...row }) => row);
+    return inventory.panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, interactionEndpoint: _interactionEndpoint, nativeIdentity: _nativeIdentity, nativePaneBirthId: _nativePaneBirthId, ...row }) => row);
 }
 function quoteArgument(value) {
     if (/\0|\r|\n/u.test(value)) {
@@ -712,6 +799,8 @@ async function enumerateStartupMarkedViews(executor) {
  * legacy attachment stack.
  */
 export class WorkspaceTerminalInventoryRuntime {
+    #nativeServerEpoch;
+    #resolveInteractionEndpoint;
     semanticPaneCatalog;
     runner;
     readRunner;
@@ -732,6 +821,7 @@ export class WorkspaceTerminalInventoryRuntime {
     #inventoryRead = null;
     #applicationReads = new Map();
     #lifecycle = "initializing";
+    #registeredWindows;
     #disposed = false;
     constructor(options) {
         const authority = canonicalAuthority(options.tmuxAuthority);
@@ -742,7 +832,13 @@ export class WorkspaceTerminalInventoryRuntime {
         });
         this.readRunner = pinnedReadRunner(authority, executeRead);
         this.#registry = options.registry;
+        this.#registeredWindows = options.sessionRuntimeRegistry?.setRegisteredWindowReader?.(async (signal) => {
+            const snapshot = await discoverWorkspaceRegistryTerminalInventory(this.#registry, this.readRunner, signal);
+            return snapshot.panes.map((pane) => ({ session: pane.sessionName, window: pane.windowId }));
+        });
         this.#observability = options.observability ?? DISABLED_SESSION_RUNTIME_OBSERVABILITY;
+        this.#resolveInteractionEndpoint = options.resolveInteractionEndpoint;
+        this.#nativeServerEpoch = options.nativeServerEpoch;
         this.#onInventory = options.onInventory ?? null;
         this.#onSessionInventory = options.onSessionInventory ?? null;
         this.#discoverTerminalInventory = (signal) => this.#readInventory(signal);
@@ -751,7 +847,7 @@ export class WorkspaceTerminalInventoryRuntime {
                 new SemanticPaneCatalog({
                     discover: async () => {
                         const inventory = await this.#discoverTerminalInventory();
-                        return inventory.panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, ...row }) => row);
+                        return inventory.panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, interactionEndpoint: _interactionEndpoint, nativeIdentity: _nativeIdentity, nativePaneBirthId: _nativePaneBirthId, ...row }) => row);
                     },
                 });
         const orphanExecutor = new TmuxAttachmentViewExecutor({ runner: this.runner });
@@ -838,10 +934,12 @@ export class WorkspaceTerminalInventoryRuntime {
             this.#observeWorkspaceSession = null;
         }
         this.#stopWorkspaceAddedObserver = options.registry.on("workspace.added", (workspace) => {
+            this.#registeredWindows?.invalidate();
             this.invalidate();
             this.#observeWorkspaceSession?.(workspace.name, workspace.sessionName);
         });
         this.#stopWorkspaceRemovedObserver = options.registry.on("workspace.removed", (name) => {
+            this.#registeredWindows?.invalidate();
             this.invalidate();
             if (!options.sessionRuntimeRegistry)
                 return;
@@ -911,19 +1009,41 @@ export class WorkspaceTerminalInventoryRuntime {
     #readInventoryAttempt(signal) {
         return this.#observeAttempt("terminal-inventory-discovery", () => discoverWorkspaceRegistryTerminalInventory(this.#registry, this.readRunner, signal));
     }
-    #publishInventory(snapshot) {
+    async #publishInventory(snapshot, nativeEpoch, signal, epoch) {
         try {
-            this.#onInventory?.(snapshot);
+            await this.#onInventory?.(snapshot, signal);
         }
         catch {
-            // Cache adoption is an optimization/readiness fence, never inventory authority.
+            if (signal.aborted || this.#disposed || this.#inventoryEpoch !== epoch)
+                throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+            // Inventory still renders; stale evidence must not escape a failed adoption.
+            return {
+                ...snapshot,
+                panes: snapshot.panes.map((pane) => ({
+                    ...pane,
+                    interactionEndpoint: null,
+                    nativeIdentity: null,
+                })),
+            };
         }
-        return snapshot;
+        if (signal.aborted || this.#disposed || this.#inventoryEpoch !== epoch)
+            throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+        return {
+            ...snapshot,
+            panes: snapshot.panes.map((pane) => ({
+                ...pane,
+                nativeIdentity: nativePaneIdentity(nativeEpoch === this.#nativeServerEpoch?.() ? nativeEpoch : null, pane.nativePaneBirthId),
+                interactionEndpoint: pane.semanticPaneId
+                    ? (this.#resolveInteractionEndpoint?.(pane.workspaceName, pane.semanticPaneId) ?? null)
+                    : null,
+            })),
+        };
     }
     async #readInventory(signal, staleRetry = 0) {
         if (this.#disposed)
             throw new NativeTerminalAttachmentRuntimeError("runtime-disposed");
         const epoch = this.#inventoryEpoch;
+        const nativeEpoch = this.#nativeServerEpoch?.() ?? null;
         if (signal) {
             if (signal.aborted)
                 throw new NativeTerminalAttachmentRuntimeError("runtime-disposed");
@@ -946,7 +1066,7 @@ export class WorkspaceTerminalInventoryRuntime {
                     return this.#readInventory(signal, staleRetry + 1);
                 throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
             }
-            return this.#publishInventory(snapshot);
+            return this.#publishInventory(snapshot, nativeEpoch, signal, epoch);
         }
         if (this.#inventoryRead?.epoch === epoch)
             return this.#inventoryRead.promise;
@@ -969,7 +1089,7 @@ export class WorkspaceTerminalInventoryRuntime {
                     return this.#readInventory(undefined, staleRetry + 1);
                 throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
             }
-            return this.#publishInventory(value);
+            return this.#publishInventory(value, nativeEpoch, abort.signal, epoch);
         })().finally(() => {
             if (this.#inventoryRead?.promise === promise)
                 this.#inventoryRead = null;
@@ -1028,6 +1148,7 @@ export class WorkspaceTerminalInventoryRuntime {
             return Promise.reject(new NativeTerminalAttachmentRuntimeError("discovery-failed"));
         };
         assertLive();
+        const nativeEpoch = this.#nativeServerEpoch?.() ?? null;
         const memberships = this.#registry
             .list()
             .filter((workspace) => workspace.sessionName === requestedSessionName);
@@ -1046,15 +1167,7 @@ export class WorkspaceTerminalInventoryRuntime {
                 return trustedRetry;
             if (trusted) {
                 try {
-                    const panes = projectTrustedMirrorInventory(trusted.inventory, workspace.name, workspace.sessionName);
-                    const catalog = analyzeTrustedSemanticPaneCatalog(panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, ...row }) => row));
-                    if (catalog.invalidRuntimeProof ||
-                        catalog.missingSemanticStamp ||
-                        catalog.duplicateSemanticStamp ||
-                        catalog.duplicateRuntimePaneBinding) {
-                        throw new NativeTerminalAttachmentRuntimeError("invalid-tmux-output");
-                    }
-                    inventory = Object.freeze({ panes, catalog });
+                    inventory = projectQualifiedInventory(trusted.inventory, workspace.name, workspace.sessionName);
                     trustedInventory = true;
                     trustedInventoryToken = trusted.token;
                 }
@@ -1073,49 +1186,90 @@ export class WorkspaceTerminalInventoryRuntime {
         const inventoryRetry = retryIfReplaced();
         if (inventoryRetry)
             return inventoryRetry;
-        const panes = inventory.panes.filter((pane) => pane.workspaceName === workspace.name && pane.sessionName === workspace.sessionName);
+        let panes = inventory.panes.filter((pane) => pane.workspaceName === workspace.name && pane.sessionName === workspace.sessionName);
         if (panes.length === 0)
             return null;
-        const active = panes.find((pane) => pane.active) ?? panes[0];
-        const sessionCatalog = analyzeTrustedSemanticPaneCatalog(panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, ...row }) => row));
-        const windowStamps = new Map();
-        let windowIdentityReady = true;
-        for (const pane of sessionCatalog.rows) {
-            const stamp = pane.windowStamp ?? null;
-            const previous = windowStamps.get(pane.windowId);
-            if (stamp === null || (previous !== undefined && previous !== stamp)) {
-                windowIdentityReady = false;
-                break;
-            }
-            windowStamps.set(pane.windowId, stamp);
-        }
-        if (new Set(windowStamps.values()).size !== windowStamps.size)
-            windowIdentityReady = false;
+        let active = panes.find((pane) => pane.active) ?? panes[0];
+        const sessionCatalog = analyzeInventoryPanes(panes);
         const shouldPrewarm = !sessionCatalog.invalidRuntimeProof &&
             !sessionCatalog.missingSemanticStamp &&
             !sessionCatalog.duplicateSemanticStamp &&
             !sessionCatalog.duplicateRuntimePaneBinding &&
-            windowIdentityReady;
-        const catalogIssue = inventory.catalog
+            hasCompleteWindowIdentity(sessionCatalog.rows);
+        // Missing-stamp error precedence must not hide another global ambiguity.
+        // The cross-window guard applies only to this new cold exception; it is not
+        // a claim that a retained session carries a permanent global certificate.
+        const coldAmbiguous = inventory.catalog.invalidRuntimeProof ||
+            inventory.catalog.duplicateSemanticStamp ||
+            inventory.catalog.duplicateRuntimePaneBinding;
+        const missingElsewhere = !trustedInventory && inventory.catalog.missingSemanticStamp;
+        const allowColdQualification = !coldAmbiguous && (!missingElsewhere || !hasWindowStampCollision(inventory.catalog.rows));
+        let catalogIssue = inventory.catalog
             .invalidRuntimeProof
             ? "invalid-runtime-proof"
-            : inventory.catalog.missingSemanticStamp
-                ? "missing-semantic-stamp"
-                : inventory.catalog.duplicateSemanticStamp
-                    ? "duplicate-semantic-stamp"
-                    : inventory.catalog.duplicateRuntimePaneBinding
-                        ? "duplicate-runtime-pane-binding"
+            : inventory.catalog.duplicateRuntimePaneBinding
+                ? "duplicate-runtime-pane-binding"
+                : inventory.catalog.missingSemanticStamp
+                    ? "missing-semantic-stamp"
+                    : inventory.catalog.duplicateSemanticStamp
+                        ? "duplicate-semantic-stamp"
                         : null;
-        if (shouldPrewarm && this.#prewarmSessionRuntime) {
-            await awaitInventoryUnlessAborted(this.#prewarmSessionRuntime(workspace.sessionName, active.sessionId, signal), signal).catch(() => undefined);
+        if (shouldPrewarm &&
+            (trustedInventory || allowColdQualification) &&
+            this.#prewarmSessionRuntime) {
+            const coldRuntimeSessionId = active.sessionId;
+            const qualified = await awaitInventoryUnlessAborted(this.#prewarmSessionRuntime(workspace.sessionName, coldRuntimeSessionId, signal), signal).then(() => true, () => false);
             const prewarmRetry = retryIfReplaced();
             if (prewarmRetry)
                 return prewarmRetry;
+            if (missingElsewhere && qualified && this.#discoverTrustedSessionInventory) {
+                // One handoff attempt, not another global scan or a local reinterpretation
+                // of rejected cold rows. Only the newly verified exact runtime can publish.
+                const candidate = await awaitInventoryUnlessAborted(this.#discoverTrustedSessionInventory(workspace.sessionName, signal), signal).catch(() => null);
+                const handoffRetry = retryIfReplaced();
+                if (handoffRetry)
+                    return handoffRetry;
+                if (candidate) {
+                    if (candidate.inventory.runtimeSessionId !== coldRuntimeSessionId) {
+                        if (staleRetry < 1)
+                            return this.#discoverTerminalRuntimeSession(requestedSessionName, signal, staleRetry + 1);
+                        throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+                    }
+                    let projected = null;
+                    try {
+                        const candidateProjection = projectQualifiedInventory(candidate.inventory, workspace.name, workspace.sessionName);
+                        if (hasCompleteWindowIdentity(candidateProjection.catalog.rows)) {
+                            projected = candidateProjection;
+                        }
+                    }
+                    catch {
+                        // Malformed candidate data cannot replace the conservative cold
+                        // rejection. Cancellation and epoch checks remain outside this catch.
+                    }
+                    if (projected) {
+                        inventory = projected;
+                        panes = projected.panes;
+                        active = panes.find((pane) => pane.active) ?? panes[0];
+                        trustedInventory = true;
+                        trustedInventoryToken = candidate.token;
+                        catalogIssue = null;
+                    }
+                }
+            }
         }
         const finalRetry = retryIfReplaced();
         if (finalRetry)
             return finalRetry;
+        let trustedInteractionInventoryAdopted = false;
         if (trustedInventory) {
+            const currentMembership = this.#registry
+                .list()
+                .filter((entry) => entry.sessionName === workspace.sessionName);
+            if (currentMembership.length !== 1 ||
+                currentMembership[0].name !== workspace.name ||
+                currentMembership[0].projectDir !== workspace.projectDir) {
+                throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+            }
             if (trustedInventoryToken === null ||
                 this.#trustedSessionInventoryCurrent?.(workspace.sessionName, trustedInventoryToken) !==
                     true) {
@@ -1124,12 +1278,22 @@ export class WorkspaceTerminalInventoryRuntime {
                 throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
             }
             try {
-                this.#onSessionInventory?.(workspace.sessionName, shouldPrewarm ? inventory : null);
+                await this.#onSessionInventory?.(workspace.sessionName, shouldPrewarm ? inventory : null, signal);
+                const callbackRetry = retryIfReplaced();
+                if (callbackRetry)
+                    return callbackRetry;
+                if (this.#trustedSessionInventoryCurrent?.(workspace.sessionName, trustedInventoryToken) !==
+                    true)
+                    throw new NativeTerminalAttachmentRuntimeError("discovery-failed");
+                trustedInteractionInventoryAdopted = shouldPrewarm;
             }
             catch {
                 // A cache consumer cannot own terminal inventory discovery.
             }
         }
+        const adoptionRetry = retryIfReplaced();
+        if (adoptionRetry)
+            return adoptionRetry;
         this.#observeWorkspaceSession?.(workspace.name, workspace.sessionName);
         return Object.freeze({
             workspaceName: workspace.name,
@@ -1137,7 +1301,19 @@ export class WorkspaceTerminalInventoryRuntime {
             runtimeSessionId: active.sessionId,
             dir: workspace.projectDir,
             catalogIssue,
-            panes: Object.freeze(panes.map(({ workspaceName: _workspaceName, sessionName: _sessionName, sessionId: _sessionId, sessionWindowCount: _sessionWindowCount, dir: _dir, ...pane }) => Object.freeze({ ...pane }))),
+            panes: Object.freeze(panes.map(({ workspaceName: _workspaceName, sessionName: _sessionName, sessionId: _sessionId, sessionWindowCount: _sessionWindowCount, dir: _dir, ...pane }) => Object.freeze({
+                ...pane,
+                ...(trustedInventory
+                    ? {
+                        nativeIdentity: trustedInteractionInventoryAdopted
+                            ? nativePaneIdentity(nativeEpoch === this.#nativeServerEpoch?.() ? nativeEpoch : null, pane.nativePaneBirthId)
+                            : null,
+                        interactionEndpoint: trustedInteractionInventoryAdopted && pane.semanticPaneId
+                            ? (this.#resolveInteractionEndpoint?.(workspace.name, pane.semanticPaneId) ?? null)
+                            : null,
+                    }
+                    : {}),
+            }))),
         });
     }
     async #discoverApplicationShellSession(requestedSessionName, signal) {
@@ -1157,6 +1333,7 @@ export class WorkspaceTerminalInventoryRuntime {
                     nowSec: Math.floor(Date.now() / 1000),
                     panes: session.panes.map((pane) => ({
                         runtimePaneId: pane.runtimePaneId,
+                        nativeIdentity: pane.nativeIdentity ?? null,
                         currentCommand: pane.currentCommand,
                         title: pane.title,
                     })),
@@ -1178,6 +1355,7 @@ export class WorkspaceTerminalInventoryRuntime {
             return;
         this.#disposed = true;
         this.#lifecycle = "disposed";
+        this.#registeredWindows?.dispose();
         this.invalidate();
         this.#stopWorkspaceAddedObserver?.();
         this.#stopWorkspaceRemovedObserver?.();
@@ -1221,7 +1399,7 @@ export class NativeTerminalAttachmentRuntime {
             new SemanticPaneCatalog({
                 discover: async () => {
                     const inventory = await discoverTerminalInventory();
-                    return inventory.panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, ...row }) => row);
+                    return inventory.panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, interactionEndpoint: _interactionEndpoint, nativeIdentity: _nativeIdentity, nativePaneBirthId: _nativePaneBirthId, ...row }) => row);
                 },
             });
         const launcher = new PtyTmuxAttachmentLauncher({
@@ -1290,13 +1468,14 @@ export class NativeTerminalAttachmentRuntime {
             resolveGeometry: (descriptor, client) => geometry.resolve(descriptor, client),
             ...(options.sessionRuntimeRegistry
                 ? {
-                    bindSessionRuntime: (descriptor) => {
+                    bindSessionRuntime: async (descriptor) => {
                         const workspace = options.registry.get(descriptor.target.workspaceName);
                         if (!workspace)
                             throw new Error("Terminal attachment workspace is unavailable");
                         if (!descriptor.hostClientId) {
                             throw new Error("Interactive terminal attachment lacks trusted host identity");
                         }
+                        await options.sessionRuntimeRegistry.verifyWindowOwnership();
                         return new SessionRuntimeTransportBinder(options.sessionRuntimeRegistry).bind({
                             transport: "terminal-attachment",
                             transportLeaseId: descriptor.leaseId,
@@ -1464,7 +1643,7 @@ export class NativeTerminalAttachmentRuntime {
         if (panes.length === 0)
             return null;
         const active = panes.find((pane) => pane.active) ?? panes[0];
-        const sessionCatalog = analyzeTrustedSemanticPaneCatalog(panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, ...row }) => row));
+        const sessionCatalog = analyzeTrustedSemanticPaneCatalog(panes.map(({ sessionName: _sessionName, index: _index, title: _title, currentCommand: _currentCommand, active: _active, role: _role, name: _name, type: _type, missionStamp: _missionStamp, dir: _dir, interactionEndpoint: _interactionEndpoint, nativeIdentity: _nativeIdentity, nativePaneBirthId: _nativePaneBirthId, ...row }) => row));
         const windowStamps = new Map();
         let windowIdentityReady = true;
         for (const pane of sessionCatalog.rows) {
@@ -1486,12 +1665,12 @@ export class NativeTerminalAttachmentRuntime {
         const catalogIssue = inventory.catalog
             .invalidRuntimeProof
             ? "invalid-runtime-proof"
-            : inventory.catalog.missingSemanticStamp
-                ? "missing-semantic-stamp"
-                : inventory.catalog.duplicateSemanticStamp
-                    ? "duplicate-semantic-stamp"
-                    : inventory.catalog.duplicateRuntimePaneBinding
-                        ? "duplicate-runtime-pane-binding"
+            : inventory.catalog.duplicateRuntimePaneBinding
+                ? "duplicate-runtime-pane-binding"
+                : inventory.catalog.missingSemanticStamp
+                    ? "missing-semantic-stamp"
+                    : inventory.catalog.duplicateSemanticStamp
+                        ? "duplicate-semantic-stamp"
                         : null;
         // Ground-truth agent facts (authority + scrape fallback). All IO stays here;
         // the resource projector composes them purely. Absent probe → no facts →
@@ -1504,6 +1683,7 @@ export class NativeTerminalAttachmentRuntime {
                     nowSec: Math.floor(Date.now() / 1000),
                     panes: panes.map((pane) => ({
                         runtimePaneId: pane.runtimePaneId,
+                        nativeIdentity: pane.nativeIdentity ?? null,
                         currentCommand: pane.currentCommand,
                         title: pane.title,
                     })),

package/packages/daemon/dist/terminal/attachments/pty-tmux-attachment-launcher.js

@@ -1,3 +1,4 @@
+import { withBundledTmuxResources } from "../../lib/bundled-tmux.js";
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
 import { delimiter, isAbsolute, join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -157,7 +158,7 @@ export class PtyTmuxAttachmentLauncher {
             throw new TypeError("trusted cwd must be an absolute daemon-owned path");
         }
         this.#trustedCwd = options.trustedCwd;
-        this.#environment = terminalEnvironment(options.environment ?? process.env);
+        this.#environment = withBundledTmuxResources(this.#tmuxExecutable, terminalEnvironment(options.environment ?? process.env));
         if (options.proofRunner && options.proofCommandExecutor) {
             throw new TypeError("proof runner and proof command executor are mutually exclusive");
         }