tmux-ide 2.9.2 → 2.9.4

package/packages/daemon/src/lib/runtime-namespace.ts

@@ -81,12 +81,11 @@ function absolutePath(value: string, cwd: string, key: string): string {
   return path;
 }
 
-function pathEntryExists(path: string): boolean {
+function pathEntryStat(path: string) {
   try {
-    lstatSync(path);
-    return true;
+    return lstatSync(path);
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
     throw error;
   }
 }
@@ -94,21 +93,23 @@ function pathEntryExists(path: string): boolean {
 function pathIdentity(path: string): string {
   let cursor = resolve(path);
   const suffix: string[] = [];
-  while (!pathEntryExists(cursor)) {
+  let stat = pathEntryStat(cursor);
+  while (!stat) {
     const parent = dirname(cursor);
     if (parent === cursor) break;
     suffix.unshift(basename(cursor));
     cursor = parent;
+    stat = pathEntryStat(cursor);
   }
-  if (pathEntryExists(cursor) && lstatSync(cursor).isSocket()) {
+  if (stat?.isSocket()) {
     return resolve(captureUnixSocketIdentity(cursor).path, ...suffix);
   }
-  return resolve(pathEntryExists(cursor) ? realpathSync(cursor) : cursor, ...suffix);
+  return resolve(stat ? realpathSync(cursor) : cursor, ...suffix);
 }
 
-function isInsideOrEqual(path: string, parent: string): boolean {
-  const child = pathIdentity(path);
-  const root = pathIdentity(parent);
+function isInsideOrEqual(path: string, parent: string, identity = pathIdentity): boolean {
+  const child = identity(path);
+  const root = identity(parent);
   const offset = relative(root, child);
   return offset === "" || (!offset.startsWith(`..${sep}`) && offset !== "..");
 }
@@ -124,6 +125,17 @@ function runtimeMode(env: NodeJS.ProcessEnv): RuntimeMode {
 export function resolveRuntimeNamespace(
   options: RuntimeNamespaceResolutionOptions = {},
 ): RuntimeNamespace {
+  // Reuse a path's identity only within this synchronous resolution. Every
+  // subsequent resolution must see new ancestors and replaced symlinks.
+  let identities: Map<string, string> | undefined;
+  const identity = (path: string): string => {
+    const cached = identities?.get(path);
+    if (cached !== undefined) return cached;
+    const resolved = pathIdentity(path);
+    (identities ??= new Map()).set(path, resolved);
+    return resolved;
+  };
+  const within = (path: string, parent: string) => isInsideOrEqual(path, parent, identity);
   const env = options.env ?? process.env;
   const userHome = options.userHome ?? homedir();
   const cwd = options.cwd ?? process.cwd();
@@ -205,16 +217,13 @@ export function resolveRuntimeNamespace(
   if (isolated && tmuxSocket.kind === "name" && tmuxSocket.name === "default") {
     throw new TypeError(`${mode} runtime requires a non-default ${TMUX_SOCKET_NAME_ENV}`);
   }
-  if (isolated && isInsideOrEqual(stateHome, canonicalHome)) {
+  if (isolated && within(stateHome, canonicalHome)) {
     throw new TypeError(`${mode} runtime cannot use the canonical tmux-ide state home`);
   }
-  if (
-    isolated &&
-    (isInsideOrEqual(registryDir, canonicalHome) || isInsideOrEqual(daemonInfoDir, canonicalHome))
-  ) {
+  if (isolated && (within(registryDir, canonicalHome) || within(daemonInfoDir, canonicalHome))) {
     throw new TypeError(`${mode} runtime cannot use canonical registry or daemon state`);
   }
-  if (isolated && tmuxSocket.kind === "path" && isInsideOrEqual(tmuxSocket.path, canonicalHome)) {
+  if (isolated && tmuxSocket.kind === "path" && within(tmuxSocket.path, canonicalHome)) {
     throw new TypeError(`${mode} runtime cannot use a tmux socket inside canonical state`);
   }
   if (isolated && cleanupToken === null) {
@@ -229,7 +238,7 @@ export function resolveRuntimeNamespace(
       (key === "TMUX_IDE_CONFIG" || key === "TMUX_IDE_SETTINGS_DIR"
         ? env[key]
         : nonEmpty(env, key)) ?? fallback;
-    if (development && (!isAbsolute(value) || !isInsideOrEqual(value, development.root)))
+    if (development && (!isAbsolute(value) || !within(value, development.root)))
       throw new TypeError(`development ${key} escapes instance`);
     return value;
   };
@@ -267,7 +276,7 @@ export function resolveRuntimeNamespace(
       if (nonEmpty(env, key)) scoped(key, "");
     if (env.TMUX) {
       const socket = /^(.*),[0-9]+,[0-9]+$/u.exec(env.TMUX)?.[1];
-      if (!socket || pathIdentity(socket) !== pathIdentity(join(runtimeDir, "tmux.sock")))
+      if (!socket || identity(socket) !== identity(join(runtimeDir, "tmux.sock")))
         throw new TypeError("development rejects inherited foreign TMUX authority");
     }
   }

package/packages/daemon/src/lib/saved-machines.ts

@@ -9,8 +9,9 @@ import {
   renameSync,
   unlinkSync,
   writeFileSync,
+  watch,
 } from "node:fs";
-import { dirname, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { SavedMachineRegistrySchema, type SavedMachineRegistry } from "@tmux-ide/contracts";
 import { changeSavedMachines, type SavedMachineChange } from "@tmux-ide/core";
 import { resolveRuntimeNamespace } from "./runtime-namespace.ts";
@@ -38,6 +39,44 @@ export function loadSavedMachines(path = savedMachinesPath()): SavedMachineRegis
   }
 }
 
+/** Watch the directory so atomic registry replacement does not detach the watcher. */
+export function watchSavedMachines(
+  onChange: (registry: SavedMachineRegistry) => void,
+  onError: () => void,
+  path = savedMachinesPath(),
+): () => void {
+  let stopped = false;
+  let pending: ReturnType<typeof setTimeout> | null = null;
+  const refresh = () => {
+    pending = null;
+    if (stopped) return;
+    try {
+      onChange(loadSavedMachines(path));
+    } catch {
+      // Keep the last valid routes while an editor is midway through a write.
+      onError();
+    }
+  };
+  // A first-run app can subscribe before the daemon creates its registry.
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const watcher = watch(dirname(path), (_event, file) => {
+    if (stopped || (file !== null && file.toString() !== basename(path))) return;
+    if (pending) clearTimeout(pending);
+    pending = setTimeout(refresh, 50);
+    pending.unref();
+  });
+  watcher.unref();
+  watcher.on("error", onError);
+  // Close the read-before-subscribe race at startup.
+  pending = setTimeout(refresh, 0);
+  pending.unref();
+  return () => {
+    stopped = true;
+    if (pending) clearTimeout(pending);
+    watcher.close();
+  };
+}
+
 /** The daemon owns writes. Synchronous read/reduce/rename cannot interleave within it. */
 export function updateSavedMachines(
   change: SavedMachineChange,

package/packages/daemon/src/lib/ssh-daemon-transport.ts

@@ -3,6 +3,7 @@ import { spawn, type ChildProcess } from "node:child_process";
 import { createServer } from "node:net";
 import type { Readable } from "node:stream";
 import { z } from "zod";
+import { remoteTmuxIdeCommand } from "./remote-tmux-command.ts";
 import { createSshDaemonRelay, type SshDaemonRelay } from "./ssh-daemon-relay.ts";
 import {
   CanonicalDaemonInfoSchema,
@@ -49,12 +50,30 @@ export class SshConnectionError extends Error {
     super(`SSH daemon connection: ${message}`);
   }
   get retryable(): boolean {
-    return this.code === "unavailable";
+    // A supervisor may temporarily remove the record while replacing its daemon.
+    return this.code === "unavailable" || this.code === "daemon-missing";
   }
 }
 function failure(message: string, code: FleetConnectionFailureCode = "unavailable"): Error {
   return new SshConnectionError(message, code);
 }
+
+/** Classify known OpenSSH errors without publishing remote stderr or credentials. */
+function observeSshFailure(child: SshTransportChild): () => FleetConnectionFailureCode {
+  let tail = "";
+  let code: FleetConnectionFailureCode = "unavailable";
+  child.stderr?.on("data", (chunk: Buffer) => {
+    tail = (tail + chunk.toString("utf8")).slice(-4096);
+    if (/Host key verification failed|REMOTE HOST IDENTIFICATION HAS CHANGED/i.test(tail))
+      code = "ssh-host-key";
+    else if (/Permission denied \((?:publickey|password|keyboard-interactive)[^)]*\)/i.test(tail))
+      code = "ssh-authentication";
+  });
+  child.once("close", () => {
+    tail = "";
+  });
+  return () => code;
+}
 const stoppedChildren = new WeakSet<SshTransportChild>();
 function stop(child: SshTransportChild): void {
   if (stoppedChildren.has(child) || child.exitCode !== null || child.signalCode !== null) return;
@@ -153,6 +172,7 @@ const defaults: SshDaemonTransportDependencies = {
   probe: probeSshDaemonIdentity,
 };
 function discover(child: SshTransportChild, signal: AbortSignal): Promise<RemoteDaemon> {
+  const sshFailure = observeSshFailure(child);
   return new Promise((resolve, reject) => {
     const chunks: Buffer[] = [];
     let bytes = 0;
@@ -177,8 +197,6 @@ function discover(child: SshTransportChild, signal: AbortSignal): Promise<Remote
       }
       chunks.push(Buffer.from(chunk));
     });
-    // Drain without capturing: SSH banners/errors may contain confidential remote information.
-    child.stderr?.resume();
     child.once("error", () => finish(failure("could not start OpenSSH")));
     child.once("close", (code) => {
       if (settled) return;
@@ -186,6 +204,7 @@ function discover(child: SshTransportChild, signal: AbortSignal): Promise<Remote
         finish(
           failure(
             "discovery failed; check SSH authentication, host trust, and remote tmux-ide installation",
+            code === 127 ? "remote-cli-missing" : sshFailure(),
           ),
         );
         return;
@@ -266,9 +285,7 @@ export async function openSshDaemonTransport(
       "ForkAfterAuthentication=no",
       "--",
       options.alias,
-      "tmux-ide",
-      "remote-daemon-info",
-      "--json",
+      remoteTmuxIdeCommand("discover"),
     ]);
     const daemon = await discover(child, signal);
     const port = await cancellable(dependencies.allocatePort(), signal);
@@ -307,7 +324,7 @@ export async function openSshDaemonTransport(
       options.alias,
     ]);
     child.stdout?.resume();
-    child.stderr?.resume();
+    const sshFailure = observeSshFailure(child);
     child.once("exit", dispose);
     const tunnelClosed = new Promise<void>((resolve) => {
       child!.once("close", () => {
@@ -342,6 +359,7 @@ export async function openSshDaemonTransport(
     }
     throw failure(
       "tunnel could not authenticate the expected daemon before cancellation or timeout",
+      sshFailure(),
     );
   } catch (error) {
     dispose();

package/packages/daemon/src/lib/tmux-server-owner.ts

@@ -268,6 +268,7 @@ export async function createNativeTmuxServerOwner(options: NativeTmuxServerOwner
           return multiplexer.mutateWindowLink(
             { operationId, expectedDaemonInstanceId: generation, intent },
             (session, action) => sessionRuntimeRegistry.executeWindowLinkAction(session, action),
+            timing,
           );
         }
         if (intent.verb === "workspace.pane.resize") {

package/packages/daemon/src/lib/tmux-server-registration.ts

@@ -77,11 +77,29 @@ export function createTmuxServerProbe(
         )
       ).stdout.trimEnd();
     try {
-      const first = await read(args);
+      // A direct socket can be pinned before contacting tmux. Named servers
+      // and aliases still need discovery followed by an explicit-path proof.
+      let pinned: ReturnType<typeof captureUnixSocketIdentity> | null = null;
+      if (selector.kind === "path") {
+        try {
+          pinned = captureUnixSocketIdentity(selector.path);
+        } catch {
+          // Preserve discovery for aliases which are not direct socket paths.
+        }
+      }
+      const first = await read(pinned ? ["-S", pinned.path] : args);
       const match = /^(.*)\|([1-9][0-9]*)\|([1-9][0-9]*)$/u.exec(first);
       if (!match) return null;
-      const socket = captureUnixSocketIdentity(match[1]!);
-      if ((await read(["-S", socket.path])) !== first) return null;
+      const reportedSocket = captureUnixSocketIdentity(match[1]!);
+      const socket = pinned ?? reportedSocket;
+      if (pinned) {
+        if (
+          reportedSocket.path !== pinned.path ||
+          reportedSocket.dev !== pinned.dev ||
+          reportedSocket.ino !== pinned.ino
+        )
+          return null;
+      } else if ((await read(["-S", socket.path])) !== first) return null;
       revalidateUnixSocketIdentity(socket);
       return {
         nativeServerIdentity: { pid: match[2]!, startTime: match[3]! },

package/packages/daemon/src/lib/tui-binary.ts

@@ -28,7 +28,7 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 import { gunzipSync } from "node:zlib";
-import { acquireTuiDownloadLock } from "./tui-download-lock.ts";
+import { acquirePrivateOperationLock } from "./private-operation-lock.ts";
 import { getCurrentVersion } from "./update-check.ts";
 
 /** The `<os>-<arch>` tags we publish a prebuilt TUI binary for. */
@@ -360,7 +360,7 @@ export async function downloadTuiBinary(
     timeoutMs: opts.timeoutMs ?? TUI_DOWNLOAD_TIMEOUT_MS,
   };
   mkdirSync(dirname(dest), { recursive: true });
-  const releaseLock = await acquireTuiDownloadLock(
+  const releaseLock = await acquirePrivateOperationLock(
     downloadLockPath(dest),
     limits.timeoutMs * 2 + 5_000,
   );

package/packages/daemon/src/lib/update.ts

@@ -1,3 +1,8 @@
+import {
+  managedInstallerPrefix,
+  runManagedInstallerUpdate,
+  MANAGED_INSTALLER_URL,
+} from "./managed-installer-update.ts";
 import { resolveRuntimeNamespace } from "./runtime-namespace.ts";
 import { parseStrictSemver } from "./semver.ts";
 /** Origin-aware update planning; unsupported origins never fall back to npm. */
@@ -28,6 +33,7 @@ export interface UpdatePlan {
   args?: string[];
   guidance?: string;
   proposedCommand?: string;
+  installerPrefix?: string;
 }
 export const UPDATE_COMMANDS: Record<PackageManager, string> = {
   npm: "npm install -g tmux-ide@latest",
@@ -62,7 +68,21 @@ export function planUpdate(input: {
       reason: `global ${method} layout (${input.cliPath})`,
     };
   }
+  if (method === "installer") {
+    const prefix = managedInstallerPrefix(input.cliPath);
+    if (prefix) {
+      return {
+        method,
+        channel,
+        installerPrefix: prefix,
+        command: `installer ${MANAGED_INSTALLER_URL} --prefix ${JSON.stringify(prefix)} --version ${channel}`,
+        reason: `verified active managed installation (${prefix})`,
+      };
+    }
+  }
   const guidance: Record<Exclude<InstallOrigin, PackageManager>, string> = {
+    installer:
+      "Rerun https://tmux-ide.com/install.sh with the same --prefix to update atomically and retain rollback. This managed release must not be modified by npm in place.",
     dev: "Update this checkout with git pull, then follow its build instructions.",
     homebrew: "Update with brew upgrade tmux-ide (using the tap/formula you installed).",
     yarn: `Update this Yarn global installation with yarn global add tmux-ide@${channel}.`,
@@ -167,6 +187,10 @@ export function runUpdate(
     });
     executed = true;
   }
+  if (!dryRun && plan.installerPrefix && plan.channel) {
+    runManagedInstallerUpdate(plan.installerPrefix, plan.channel, json, dependencies.execute);
+    executed = true;
+  }
   if (json) output(JSON.stringify({ ...plan, current, latest, dryRun, executed }));
   return plan;
 }

package/packages/daemon/src/lib/workspace-multiplexer-verbs.ts

@@ -468,6 +468,7 @@ export class WorkspaceMultiplexerAuthority {
       session: string,
       action: AuthoritativeWindowLinkAction,
     ) => Promise<AuthoritativeWindowLinkActionResult>,
+    timing?: WorkspaceMultiplexerOperationTiming,
   ): Promise<WorkspaceMultiplexerMutationResult> {
     if (this.#disposed) throw new WorkspaceMultiplexerError("workspace_unavailable");
     const request = WorkspaceMultiplexerMutationRequestSchemaZ.parse(raw);
@@ -480,7 +481,26 @@ export class WorkspaceMultiplexerAuthority {
       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: string, start: number | null) => {
+      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,
@@ -488,6 +508,7 @@ export class WorkspaceMultiplexerAuthority {
       workspaceName: intent.workspaceName,
     };
     try {
+      const effectStarted = now();
       const result = await execute(
         workspace.sessionName,
         intent.verb === "workspace.pane.select"
@@ -501,6 +522,7 @@ export class WorkspaceMultiplexerAuthority {
               target: intent.target,
             },
       );
+      record("window-link-effect-proof", effectStarted);
       if (result.outcome !== "applied") {
         throw new WorkspaceMultiplexerError(
           result.outcome === "stale"

package/packages/daemon/src/machines.ts

@@ -1,22 +1,70 @@
 import { readFileSync, statSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { SavedMachineRegistrySchema, SavedMachineSchema } from "@tmux-ide/contracts/saved-machines";
+import {
+  SavedMachineRegistrySchema,
+  SavedMachineSchema,
+  SavedMachineMutationSchema,
+} from "@tmux-ide/contracts/saved-machines";
 import { loadSavedMachines, planSavedMachineMerge } from "./lib/saved-machines.ts";
 import { loadFleetClientState } from "./lib/fleet-client-state.ts";
-import { saveMachineProfiles } from "./lib/local-fleet-request.ts";
+import { changeSavedMachines } from "@tmux-ide/core";
+import { saveMachineProfiles, mutateMachineProfile } from "./lib/local-fleet-request.ts";
+import { remoteTmuxIdeCommand } from "./lib/remote-tmux-command.ts";
 
 export async function machines(
   command: string | undefined,
   argument: string | undefined,
-  options: { write?: boolean; label?: string },
+  options: { write?: boolean; label?: string; sshTarget?: string },
 ) {
   const current = loadSavedMachines();
+  if (
+    (command === "enable" || command === "disable" || command === "remove" || command === "edit") &&
+    argument
+  ) {
+    const key = argument.normalize("NFKC").toLowerCase();
+    const match =
+      current.machines.find((machine) => machine.id === key) ??
+      current.machines.find((machine) => machine.label.normalize("NFKC").toLowerCase() === key);
+    if (!match)
+      throw new Error("Saved machine not found; use machines ls to select its ID or label.");
+    const change = SavedMachineMutationSchema.parse(
+      command === "edit"
+        ? {
+            id: match.id,
+            operation: command,
+            patch: {
+              ...(options.label !== undefined ? { label: options.label } : {}),
+              ...(options.sshTarget !== undefined ? { sshTarget: options.sshTarget } : {}),
+            },
+          }
+        : { id: match.id, operation: command },
+    );
+    const preview = changeSavedMachines(
+      current,
+      command === "remove"
+        ? { type: "remove", id: match.id }
+        : {
+            type: "update",
+            id: match.id,
+            patch: change.operation === "edit" ? change.patch : { enabled: command === "enable" },
+          },
+    );
+    return {
+      written: options.write === true,
+      registry: options.write ? await mutateMachineProfile(change) : preview,
+      ...(!options.write
+        ? {
+            note: "Repeat with --write to change this saved profile. Remote sessions and daemons are preserved.",
+          }
+        : {}),
+    };
+  }
   if (command === "start" && argument) {
     SavedMachineSchema.shape.sshTarget.parse(argument);
     if (!options.write)
       return {
         written: false,
-        command: ["ssh", "--", argument, "tmux-ide", "update", "--daemon", "--json"],
+        command: ["ssh", "--", argument, remoteTmuxIdeCommand("start")],
         note: "Repeat with --write to start the installed daemon. No package installation occurs.",
       };
     await (await import("./lib/remote-daemon-lifecycle.ts")).startInstalledRemoteDaemon(argument);
@@ -74,7 +122,7 @@ export async function machines(
     };
   } else
     throw new Error(
-      "Usage: tmux-ide machines ls|export|import <file>|add <alias> [--write] [--json]",
+      "Usage: tmux-ide machines ls|export|import <file>|add <alias>|edit|enable|disable|remove <id-or-label> [--write] [--json]",
     );
   const preview = planSavedMachineMerge(current, incoming);
   if (!options.write)

package/packages/daemon/src/terminal/attachments/direct-websocket.ts

@@ -210,7 +210,7 @@ export interface TerminalAttachmentAdmissionCoordinatorOptions {
   /** Trusted redemption boundary into the generation's SessionRuntime owner. */
   readonly bindSessionRuntime?: (
     descriptor: AttachmentLeaseDescriptor,
-  ) => SessionRuntimeRedeemedTransportBinding;
+  ) => SessionRuntimeRedeemedTransportBinding | Promise<SessionRuntimeRedeemedTransportBinding>;
   readonly maxPendingTickets?: number;
   readonly maxPreAuthSockets?: number;
   readonly maxLiveConnections?: number;
@@ -765,7 +765,13 @@ export class TerminalAttachmentAdmissionCoordinator {
         let sessionRuntimeBinding: SessionRuntimeRedeemedTransportBinding | null = null;
         let live: TerminalAttachmentLiveConnection;
         try {
-          sessionRuntimeBinding = this.#bindSessionRuntime?.(activeDescriptor) ?? null;
+          sessionRuntimeBinding = (await this.#bindSessionRuntime?.(activeDescriptor)) ?? null;
+          if (!admission.isOpen()) {
+            throw new TerminalAttachmentAdmissionError(
+              "redemption-rejected",
+              "Terminal attachment redemption was rejected.",
+            );
+          }
           live = new TerminalAttachmentLiveConnection({
             onRetire: (connection) => this.#trackRetiringRelease(connection),
             socket,

package/packages/daemon/src/terminal/attachments/native-runtime.ts

@@ -1307,6 +1307,7 @@ export class WorkspaceTerminalInventoryRuntime {
     }
   >();
   #lifecycle: "initializing" | "ready" | "failed" | "disposed" = "initializing";
+  #registeredWindows: { invalidate(): void; dispose(): void } | undefined;
   #disposed = false;
 
   constructor(options: WorkspaceTerminalInventoryRuntimeOptions) {
@@ -1318,6 +1319,16 @@ 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;
@@ -1441,10 +1452,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;
       const sessionName = sessionsByWorkspace.get(name);
@@ -1749,12 +1762,12 @@ export class WorkspaceTerminalInventoryRuntime {
     let catalogIssue: NativeTerminalInventoryCatalogIssue | null = 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 &&
@@ -1949,6 +1962,7 @@ export class WorkspaceTerminalInventoryRuntime {
     if (this.#disposed) return;
     this.#disposed = true;
     this.#lifecycle = "disposed";
+    this.#registeredWindows?.dispose();
     this.invalidate();
     this.#stopWorkspaceAddedObserver?.();
     this.#stopWorkspaceRemovedObserver?.();
@@ -2128,12 +2142,13 @@ export class NativeTerminalAttachmentRuntime {
       resolveGeometry: (descriptor, client) => geometry.resolve(descriptor, client),
       ...(options.sessionRuntimeRegistry
         ? {
-            bindSessionRuntime: (descriptor: AttachmentLeaseDescriptor) => {
+            bindSessionRuntime: async (descriptor: AttachmentLeaseDescriptor) => {
               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,
@@ -2357,12 +2372,12 @@ export class NativeTerminalAttachmentRuntime {
     const catalogIssue: NativeTerminalInventoryCatalogIssue | null = 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 →