tmux-ide 2.9.2 → 2.9.4

package/packages/daemon/src/terminal/mirror/mirror-service.ts

@@ -1,3 +1,5 @@
+import { SharedWindowIndex } from "./shared-window-index.ts";
+import { RegisteredWindowGuard, type RegisteredWindowReader } from "./registered-window-guard.ts";
 import type { OwnedViewerAdapter } from "./owned-viewer-adapter.ts";
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
 import { isAbsolute } from "node:path";
@@ -47,6 +49,7 @@ import {
 } from "./control-mode-ownership.ts";
 
 export interface MirrorServiceOptions {
+  onSharedWindowConflict?: (session: string, conflicted: boolean) => void;
   createOwnedViewerAdapter?: (session: string) => OwnedViewerAdapter | undefined;
   nativeServerIdentity?: import("../../lib/tmux-server-generation-runner.ts").NativeTmuxServerIdentity;
   resolveSocketPath?: () => string;
@@ -148,6 +151,47 @@ interface ChannelEntry {
 export class MirrorService {
   private readonly opts: MirrorServiceOptions;
   private readonly channels = new Map<string, ChannelEntry>();
+  private readonly sharedWindows = new SharedWindowIndex<SessionChannel>();
+  private readonly channelSessions = new Map<SessionChannel, string>();
+  private registeredWindows: RegisteredWindowGuard | null = null;
+  private readonly registeredConflicts = new Set<string>();
+
+  setRegisteredWindowReader(reader: RegisteredWindowReader): {
+    invalidate(): void;
+    dispose(): void;
+  } {
+    this.registeredWindows?.dispose();
+    const guard = new RegisteredWindowGuard(reader);
+    this.registeredWindows = guard;
+    this.invalidateRegisteredWindows();
+    return {
+      invalidate: () => {
+        if (this.registeredWindows === guard) this.invalidateRegisteredWindows();
+      },
+      dispose: () => guard.dispose(),
+    };
+  }
+
+  private invalidateRegisteredWindows(): void {
+    this.registeredWindows?.invalidate();
+  }
+
+  async verifyRegisteredWindows(): Promise<void> {
+    const guard = this.registeredWindows;
+    if (!guard) return;
+    await guard.verify();
+    if (guard !== this.registeredWindows || this.disposed)
+      throw new Error("Window ownership changed during discovery");
+    for (const [channel, session] of this.channelSessions) {
+      if (guard.blocked(session)) {
+        channel.setGeometryParticipation(false);
+        if (!this.registeredConflicts.has(session)) {
+          this.registeredConflicts.add(session);
+          this.opts.onSharedWindowConflict?.(session, true);
+        }
+      } else this.registeredConflicts.delete(session);
+    }
+  }
   private readonly pendingDisposals = new Set<Promise<void>>();
   private readonly drainingChannels = new Map<string, Promise<void>>();
   private readonly sessionExitListeners = new Set<(session: string) => void>();
@@ -239,8 +283,14 @@ export class MirrorService {
       reseed: () => handle.reseed(),
       readHistorySize: () => handle.readHistorySize(),
       captureNativeBacking: () => handle.captureNativeBacking(),
-      sendText: (text) => handle.sendText(text),
-      sendKey: (key) => handle.sendKey(key),
+      sendText: (text) => {
+        this.assertWindowOwnership(request.session);
+        handle.sendText(text);
+      },
+      sendKey: (key) => {
+        this.assertWindowOwnership(request.session);
+        handle.sendKey(key);
+      },
       close: async () => {
         if (closed) return;
         closed = true;
@@ -303,6 +353,7 @@ export class MirrorService {
     return (args: readonly string[]) => {
       if (entry.retired || this.channels.get(session) !== entry)
         return Promise.reject(new Error("Resize mirror session retired"));
+      this.assertWindowOwnership(session);
       return run(args);
     };
   }
@@ -313,6 +364,7 @@ export class MirrorService {
   ) {
     const entry = this.channels.get(session);
     if (!entry || entry.retired) throw new Error(`Mirror session ${session} is unavailable`);
+    this.assertWindowOwnership(session);
     return entry.channel.executeWindowLinkAction(request);
   }
 
@@ -326,6 +378,7 @@ export class MirrorService {
   ): void {
     const entry = this.channels.get(session);
     if (!entry || entry.retired) throw new Error(`Mirror session ${session} is unavailable`);
+    this.assertWindowOwnership(session);
     entry.channel.sendText(semanticPaneId, text, performanceTraceId, isolated);
   }
 
@@ -337,24 +390,61 @@ export class MirrorService {
   ): void {
     const entry = this.channels.get(session);
     if (!entry || entry.retired) throw new Error(`Mirror session ${session} is unavailable`);
+    this.assertWindowOwnership(session);
     entry.channel.sendBytes(semanticPaneId, data, performanceTraceId);
   }
 
   sendKey(session: string, semanticPaneId: string, key: string, performanceTraceId?: string): void {
     const entry = this.channels.get(session);
     if (!entry || entry.retired) throw new Error(`Mirror session ${session} is unavailable`);
+    this.assertWindowOwnership(session);
     entry.channel.sendKey(semanticPaneId, key, performanceTraceId);
   }
 
+  private assertWindowOwnership(session: string): void {
+    const message = this.windowOwnershipMessage(session);
+    if (message) throw new Error(message);
+  }
+
+  windowOwnershipMessage(session: string): string | null {
+    if (this.registeredWindows?.pending())
+      return "Window ownership is being verified. Retry after session discovery completes.";
+    if (this.hasSharedWindowConflict(session))
+      return "Linked windows across registered sessions are unsupported. Unlink the shared window before controlling this session.";
+    return null;
+  }
+
+  hasSharedWindowConflict(session: string): boolean {
+    const entry = this.channels.get(session);
+    return (
+      (this.registeredWindows?.blocked(session) ?? false) ||
+      (!!entry && this.sharedWindows.conflicted(entry.channel))
+    );
+  }
+
+  private updateWindowMembership(channel: SessionChannel, windows: readonly string[]): void {
+    // A topology read may finish after retirement. It must not resurrect the
+    // old channel's membership or conflict with its replacement.
+    if (!this.channelSessions.has(channel)) return;
+    for (const [peer, conflict] of this.sharedWindows.update(channel, windows)) {
+      const session = this.channelSessions.get(peer);
+      if (session === undefined) continue;
+      if (conflict) peer.setGeometryParticipation(false);
+      this.opts.onSharedWindowConflict?.(session, conflict);
+    }
+  }
+
   fitViewport(session: string, cols: number, rows: number): void {
     const entry = this.channels.get(session);
     if (!entry || entry.retired) throw new Error(`Mirror session ${session} is unavailable`);
+    this.assertWindowOwnership(session);
     entry.channel.fitViewport(cols, rows);
   }
 
   fitWindowViewport(session: string, semanticWindowId: string, cols: number, rows: number): void {
     const entry = this.channels.get(session);
     if (!entry || entry.retired) throw new Error(`Mirror session ${session} is unavailable`);
+    this.assertWindowOwnership(session);
     entry.channel.fitWindowViewport(semanticWindowId, cols, rows);
   }
 
@@ -367,7 +457,7 @@ export class MirrorService {
   setGeometryParticipation(session: string, active: boolean): void {
     const entry = this.channels.get(session);
     if (!entry || entry.retired) return;
-    entry.channel.setGeometryParticipation(active);
+    entry.channel.setGeometryParticipation(active && !this.hasSharedWindowConflict(session));
   }
 
   /**
@@ -412,12 +502,15 @@ export class MirrorService {
 
   async dispose(): Promise<void> {
     this.disposed = true;
+    this.registeredWindows?.dispose();
     this.sessionExitListeners.clear();
     const entries = [...this.channels.values()];
     this.channels.clear();
     await Promise.allSettled(
       entries.map(async (entry) => {
         entry.retired = true;
+        this.updateWindowMembership(entry.channel, []);
+        this.channelSessions.delete(entry.channel);
         try {
           await entry.channel.dispose();
         } finally {
@@ -468,6 +561,12 @@ export class MirrorService {
         );
         const channelOptions: SessionChannelOptions = {
           session,
+          onWindowMembership: (windows) => this.updateWindowMembership(channel, windows),
+          hasSharedWindowConflict: () => this.hasSharedWindowConflict(session),
+          beforeIdentityRepair: () => this.verifyRegisteredWindows(),
+          onWindowTopologyChanged: () => {
+            if (this.channelSessions.has(channel)) this.invalidateRegisteredWindows();
+          },
           ownedViewer,
           createIo: (handlers) =>
             this.opts.createIo?.(session, handlers) ??
@@ -547,6 +646,7 @@ export class MirrorService {
         releaseAuthority();
         throw cause;
       }
+      this.channelSessions.set(channel, session);
       entry = {
         channel,
         started: channel.start(),
@@ -583,6 +683,8 @@ export class MirrorService {
   private retire(session: string, entry: ChannelEntry): void {
     if (entry.retired) return;
     entry.retired = true;
+    this.updateWindowMembership(entry.channel, []);
+    this.channelSessions.delete(entry.channel);
     if (this.channels.get(session) === entry) this.channels.delete(session);
     const disposal = entry.channel
       .dispose()

package/packages/daemon/src/terminal/mirror/registered-window-guard.ts

@@ -0,0 +1,66 @@
+export type RegisteredWindowReader = (
+  signal: AbortSignal,
+) => Promise<readonly { session: string; window: string }[]>;
+
+/** A bounded registration/topology proof, shared by all retained channels. */
+export class RegisteredWindowGuard {
+  #epoch = 0;
+  #current = false;
+  #disposed = false;
+  #conflicts = new Set<string>();
+  #read: { abort: AbortController; promise: Promise<void> } | null = null;
+
+  constructor(private readonly reader: RegisteredWindowReader) {}
+
+  blocked(session: string): boolean {
+    return !this.#current || this.#conflicts.has(session);
+  }
+
+  pending(): boolean {
+    return !this.#current;
+  }
+
+  invalidate(): void {
+    this.#epoch++;
+    this.#current = false;
+    this.#read?.abort.abort();
+    this.#read = null;
+  }
+
+  dispose(): void {
+    this.#disposed = true;
+    this.invalidate();
+  }
+
+  async verify(): Promise<void> {
+    if (this.#disposed) throw new Error("Registered window inventory is disposed");
+    if (this.#current) return;
+    if (this.#read) return this.#read.promise;
+    const epoch = this.#epoch;
+    const abort = new AbortController();
+    const promise = Promise.resolve()
+      .then(async () => {
+        abort.signal.throwIfAborted();
+        const rows = await this.reader(abort.signal);
+        abort.signal.throwIfAborted();
+        if (epoch !== this.#epoch) throw new Error("Window ownership changed during discovery");
+        const owners = new Map<string, Set<string>>();
+        for (const row of rows) {
+          const sessions = owners.get(row.window) ?? new Set<string>();
+          sessions.add(row.session);
+          owners.set(row.window, sessions);
+        }
+        this.#conflicts = new Set(
+          [...owners.values()]
+            .filter((sessions) => sessions.size > 1)
+            .flatMap((sessions) => [...sessions]),
+        );
+        this.#current = true;
+      })
+      .finally(() => {
+        if (this.#read?.abort === abort) this.#read = null;
+      });
+    this.#read = { abort, promise };
+    return promise;
+  }
+}

package/packages/daemon/src/terminal/mirror/session-channel.ts

@@ -123,7 +123,10 @@ const STRUCTURAL_NOTIFICATIONS = new Set([
   "window-add",
   "window-close",
   "window-renamed",
+  "unlinked-window-add",
   "unlinked-window-close",
+  "session-renamed",
+  "sessions-changed",
 ]);
 const NATIVE_CLIENT_NOTIFICATIONS = new Set([
   "client-attached",
@@ -239,6 +242,10 @@ export interface MirrorFlowRecoveryObservation {
 }
 
 export interface SessionChannelOptions {
+  onWindowMembership?: (windows: readonly string[]) => void;
+  hasSharedWindowConflict?: () => boolean;
+  beforeIdentityRepair?: () => Promise<void>;
+  onWindowTopologyChanged?: () => void;
   ownedViewer?: Pick<OwnedViewerAdapter, "bindIo" | "tryDispatch" | "dispose"> &
     Partial<Pick<OwnedViewerAdapter, "atomicSnapshotEpoch">>;
   executeWindowLinkGuard?: (args: string[]) => Promise<{ status: number | null; stdout: string }>;
@@ -441,6 +448,7 @@ function layoutIdentitiesEqual(left: WindowLayout, right: WindowLayout): boolean
 }
 
 interface WindowSyncStage {
+  readonly observedAuthorityOrdinal: number;
   readonly windows: Map<string, WindowRecord>;
   readonly layouts: Map<string, ParsedLayout & { zoomed: boolean; unzoomed?: ParsedLayout }>;
   readonly currentWindow: string;
@@ -502,6 +510,7 @@ export class SessionChannel {
   private nativeClientProbePending = false;
   // Native captures fence every geometry event; inventory fences identity only.
   private windowAuthorityOrdinal = 0;
+  private readonly layoutNotificationOrdinals = new Map<string, number>();
   private windowIdentityOrdinal = 0;
   private paneIncarnation = 0;
   private recoveryOrdinal = 0;
@@ -1186,9 +1195,31 @@ export class SessionChannel {
     }
     this.input.flush();
     this.clearWindowViewports();
+    this.restoreWindowSizing(this.attachedIdentity?.runtimeSessionId ?? `=${this.opts.session}`);
     this.io.send(`refresh-client -C ${cols}x${rows}`);
   }
 
+  private restoreWindowSizing(target: string): void {
+    if (!this.geometryParticipating) return;
+    // resize-window pins a window (including through inherited session options).
+    // Evaluate inside the existing control connection: no shell, polling, or extra
+    // request/response round trip. The shell also pre-fits hidden windows;
+    // only the active window may have its manual policy repaired.
+    const quoted = tmuxSingleQuote(target);
+    // if-shell emits its own reply and the selected branch emits another.
+    // Keep both branches at one command so either policy consumes exactly two
+    // FIFO slots; a discard-only send would misroute the next capture replies.
+    this.io.commandListInline(
+      `if-shell -F -t ${quoted} '#{&&:#{window_active},#{==:#{window-size},manual}}' ` +
+        tmuxSingleQuote(`set-option -w -t ${quoted} window-size latest`) +
+        " " +
+        tmuxSingleQuote(`display-message -p -t ${quoted} ''`),
+      2,
+      1,
+      () => {},
+    );
+  }
+
   /**
    * Experimental: window-specific overrides stay private to this control client.
    * Native tmux still falls back to the client size for unscoped neighbours;
@@ -1214,6 +1245,7 @@ export class SessionChannel {
     const previous = this.fittedWindows.get(window.runtimeId);
     if (previous?.cols === cols && previous.rows === rows) return;
     this.input.flush();
+    this.restoreWindowSizing(window.runtimeId);
     this.io.send(`refresh-client -C ${window.runtimeId}:${cols}x${rows}`);
     this.fittedWindows.set(window.runtimeId, { cols, rows });
   }
@@ -1288,6 +1320,7 @@ export class SessionChannel {
       pane.subs.clear();
     }
     this.pendingLayoutOutput.clear();
+    this.layoutNotificationOrdinals.clear();
     this.layoutSubscribers.clear();
     this.layoutAuthoritySubscribers.clear();
     await this.io.dispose();
@@ -2851,6 +2884,15 @@ export class SessionChannel {
   }
 
   private onNotify(name: string, rest: string): void {
+    if (
+      name === "window-add" ||
+      name === "window-close" ||
+      name === "unlinked-window-add" ||
+      name === "unlinked-window-close" ||
+      name === "session-renamed" ||
+      name === "sessions-changed"
+    )
+      this.opts.onWindowTopologyChanged?.();
     if (name === "subscription-changed") {
       const policy =
         /^tmux-ide-scroll-on-clear\s+\$[0-9]+\s+@[0-9]+\s+[0-9]+\s+(%[0-9]+)\s+:\s+([01])\s*$/u.exec(
@@ -2976,6 +3018,7 @@ export class SessionChannel {
         this.scheduleSync(); // never guess from a failed parse
         return;
       }
+      this.layoutNotificationOrdinals.set(change.windowId, this.windowAuthorityOrdinal);
       const pendingLayout = {
         ...parsed,
         zoomed: change.zoomed,
@@ -3294,8 +3337,10 @@ export class SessionChannel {
       previousCurrentWindow,
       syncOrdinal,
     );
-    for (const pane of this.panesByRuntime.values())
+    for (const pane of this.panesByRuntime.values()) {
+      if (pane.windowRuntimeId && this.pendingLayoutOutput.has(pane.windowRuntimeId)) continue;
       for (const sub of pane.subs) sub.resumeLayoutCapture?.(syncOrdinal);
+    }
     this.discovery.discover(listed);
   }
 
@@ -3593,6 +3638,29 @@ export class SessionChannel {
     previousCurrentWindow = this.currentWindow,
     syncOrdinal?: number,
   ): void {
+    // Control notifications in the same read chunk run before a promise-based
+    // inventory read resumes. Preserve newer geometry (and its pending border
+    // query) rather than letting that older inventory erase the notification.
+    const newerLayouts = new Set(
+      [...this.layoutNotificationOrdinals]
+        .filter(([, ordinal]) => ordinal > stage.observedAuthorityOrdinal)
+        .map(([runtimeId]) => runtimeId),
+    );
+    if (newerLayouts.size > 0) {
+      stage = { ...stage, windows: new Map(stage.windows), layouts: new Map(stage.layouts) };
+      for (const runtimeId of newerLayouts) {
+        const currentLayout = this.layoutByWindow.get(runtimeId);
+        const currentWindow = this.windowsByRuntime.get(runtimeId);
+        const stagedWindow = stage.windows.get(runtimeId);
+        if (currentLayout && currentWindow && stagedWindow) {
+          stage.layouts.set(runtimeId, currentLayout);
+          stage.windows.set(runtimeId, {
+            ...stagedWindow,
+            paneBorderStatus: currentWindow.paneBorderStatus,
+          });
+        }
+      }
+    }
     this.windowLinkAuthority?.reconcile(stage.links);
     this.latestWindowStage = stage;
     const changedWindows = new Set<string>();
@@ -3647,8 +3715,14 @@ export class SessionChannel {
           ),
         );
     for (const runtimeId of this.pendingLayoutOutput.keys())
-      if (!stage.windows.has(runtimeId)) this.pendingLayoutOutput.delete(runtimeId);
-    for (const runtimeId of layoutEmits) this.releasePendingLayout(runtimeId, syncOrdinal);
+      if (!stage.windows.has(runtimeId) && !newerLayouts.has(runtimeId))
+        this.pendingLayoutOutput.delete(runtimeId);
+    for (const runtimeId of this.layoutNotificationOrdinals.keys())
+      if (!stage.windows.has(runtimeId) && !newerLayouts.has(runtimeId))
+        this.layoutNotificationOrdinals.delete(runtimeId);
+    for (const runtimeId of layoutEmits)
+      if (!newerLayouts.has(runtimeId) || !this.pendingLayoutOutput.has(runtimeId))
+        this.releasePendingLayout(runtimeId, syncOrdinal);
     this.emitLayoutAuthority();
   }
 
@@ -3686,6 +3760,7 @@ export class SessionChannel {
   }
 
   private async stageWindows(target = this.opts.session): Promise<WindowSyncStage> {
+    const observedAuthorityOrdinal = this.windowAuthorityOrdinal;
     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}"`,
     );
@@ -3791,6 +3866,10 @@ export class SessionChannel {
       if (!unzoomed) throw new Error(`full window layout for ${this.opts.session} is malformed`);
       nextLayoutByWindow.set(row.runtimeId, { ...parsed, zoomed: row.zoomed, unzoomed });
     }
+    // Publish validated physical membership before any identity repair writes.
+    // The receiving session may introduce duplicate stamps by linking a window.
+    this.opts.onWindowMembership?.([...backingRows.keys()]);
+    await this.opts.beforeIdentityRepair?.();
     // 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<string, number>();
@@ -3808,7 +3887,7 @@ export class SessionChannel {
       let semanticId: string | null = null;
       if (row.stamp && stampCounts.get(row.stamp) === 1) {
         semanticId = row.stamp;
-      } else {
+      } else if (!this.opts.hasSharedWindowConflict?.()) {
         repairedIdentity = true;
         let candidate: string | null = null;
         for (let attempt = 0; attempt < 32 && !candidate; attempt += 1) {
@@ -3846,6 +3925,7 @@ export class SessionChannel {
       });
     }
     return {
+      observedAuthorityOrdinal,
       windows: next,
       layouts: nextLayoutByWindow,
       currentWindow: nextCurrentWindow,
@@ -3864,6 +3944,10 @@ export class SessionChannel {
     listed: ReadonlySet<string>,
   ): Promise<boolean> {
     if (this.disposed) return false;
+    if (this.opts.hasSharedWindowConflict?.()) {
+      this.settleFirstJoin();
+      return false;
+    }
     const snapshots: WorkspaceTmuxPaneSnapshot[] = descriptors
       .filter((descriptor) => listed.has(descriptor.runtimePaneId))
       .map((descriptor) => ({
@@ -4005,6 +4089,10 @@ export class SessionChannel {
     descriptors: readonly SessionPaneDescriptor[],
     layouts: ReadonlyMap<string, ParsedLayout & { zoomed: boolean; unzoomed?: ParsedLayout }>,
   ): Promise<boolean> {
+    if (this.opts.hasSharedWindowConflict?.())
+      throw new Error(
+        "Linked windows across controlled sessions are unsupported. Unlink the shared window before controlling this session.",
+      );
     const rectForRuntime = (runtimePaneId: string): WorkspacePaneRect => {
       for (const layout of layouts.values()) {
         const leaf = layout.leaves.find(({ id }) => id === runtimePaneId);

package/packages/daemon/src/terminal/mirror/shared-window-index.ts

@@ -0,0 +1,42 @@
+/** Event-fed physical window membership for one pinned tmux server. */
+export class SharedWindowIndex<Owner> {
+  readonly #windows = new Map<string, Set<Owner>>();
+  readonly #owners = new Map<Owner, Set<string>>();
+  readonly #conflicts = new Set<Owner>();
+
+  conflicted(owner: Owner): boolean {
+    return this.#conflicts.has(owner);
+  }
+
+  update(owner: Owner, windows: readonly string[]): Map<Owner, boolean> {
+    const previous = this.#owners.get(owner) ?? new Set<string>();
+    const next = new Set(windows);
+    const affected = new Set<Owner>([owner]);
+    for (const window of new Set([...previous, ...next])) {
+      for (const peer of this.#windows.get(window) ?? []) affected.add(peer);
+      if (previous.has(window) && !next.has(window)) {
+        const peers = this.#windows.get(window)!;
+        peers.delete(owner);
+        if (!peers.size) this.#windows.delete(window);
+      }
+      if (next.has(window)) {
+        const peers = this.#windows.get(window) ?? new Set<Owner>();
+        peers.add(owner);
+        this.#windows.set(window, peers);
+      }
+    }
+    if (next.size) this.#owners.set(owner, next);
+    else this.#owners.delete(owner);
+    const changed = new Map<Owner, boolean>();
+    for (const peer of affected) {
+      const conflict = [...(this.#owners.get(peer) ?? [])].some(
+        (window) => (this.#windows.get(window)?.size ?? 0) > 1,
+      );
+      if (conflict === this.#conflicts.has(peer)) continue;
+      if (conflict) this.#conflicts.add(peer);
+      else this.#conflicts.delete(peer);
+      changed.set(peer, conflict);
+    }
+    return changed;
+  }
+}

package/packages/daemon/src/terminal/pane-stream/pane-stream-websocket.ts

@@ -2219,7 +2219,18 @@ export class PaneStreamLiveConnection {
         !this.#sessionRuntimeBinding.authoritySnapshot
       )
         return this.#failProtocol("protocol-error");
-      const lease = this.#sessionRuntimeBinding.requestAuthority(frame.authority);
+      let lease: SessionRuntimeAuthorityLease | null = null;
+      try {
+        lease = this.#sessionRuntimeBinding.requestAuthority(frame.authority);
+      } catch (error) {
+        // Topology changes can temporarily prevent ownership. Reject this
+        // request without letting an expected conflict terminate the daemon.
+        if (
+          !(error instanceof SessionRuntimeControllerLeaseError) ||
+          error.code !== "controller-conflict"
+        )
+          return this.#failProtocol("input-rejected");
+      }
       if (lease) this.#requestedAuthorities.add(frame.authority);
       this.#sendFrame(null, {
         type: "authority-receipt",

package/packages/daemon/src/terminal/session-runtime/multiplexer-backend.ts

@@ -26,6 +26,7 @@ export interface SessionRuntimeMultiplexerBackendOptions {
     | "bindExecutionSource"
     | "assertExecutionHandle"
     | "submitPaneCredentialIntent"
+    | "verifyWindowOwnership"
   >;
   readonly resolveSession: (workspaceName: string) => string | null;
   readonly resolvePaneSourceBinding?: (
@@ -192,6 +193,7 @@ export function createSessionRuntimeMultiplexerBackend(
       if (!ownerAuthorized) {
         throw new Error("Semantic mutation requires a live host, pane, or owner principal");
       }
+      await options.registry.verifyWindowOwnership();
       const owner = acquireOwner(session);
       try {
         let lease: ReturnType<SessionRuntimeConsumer["acquireController"]>;