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

package/packages/daemon/src/tui/mirror/runtime/application-terminal-interaction-controller.ts

@@ -1,6 +1,8 @@
+import { WorkspaceWindowLinkSelectResultSchemaZ } from "@tmux-ide/contracts";
+import { windowLinkForPane, windowLinkTarget } from "./application-terminal-workspace-policy.ts";
 import { createHash, randomUUID } from "node:crypto";
 import type { Accessor, Setter } from "solid-js";
-import type { SessionRuntimeTerminalInput } from "@tmux-ide/contracts";
+import type { WindowLinkTarget, SessionRuntimeTerminalInput } from "@tmux-ide/contracts";
 import {
   currentTuiPerformanceEventSink,
   type TuiTerminalInputOrigin,
@@ -79,6 +81,8 @@ export interface ApplicationTerminalInteractionController {
   adoptGeneration(snapshot: OpenTuiGenerationHostSnapshot | null): void;
   adoptLayout(snapshot: OpenTuiWorkspaceLayoutSnapshot): void;
   selectPane(paneId: string): void;
+  selectWindowLink(target: WindowLinkTarget): Promise<void>;
+  unlinkWindowLink(target: WindowLinkTarget): Promise<string>;
   sendInput(
     input: SessionRuntimeTerminalInput,
     parserOrigin?: Omit<
@@ -628,6 +632,41 @@ export function createApplicationTerminalInteractionController(
     }
   };
 
+  let linkSelection: {
+    target: WindowLinkTarget;
+    paneId: string;
+    layout: OpenTuiWorkspaceLayoutSnapshot;
+    received: boolean;
+    resolve: (selected: boolean) => void;
+    timer: ReturnType<typeof setTimeout>;
+  } | null = null;
+  const finishLinkSelection = (selected: boolean) => {
+    const pending = linkSelection;
+    if (!pending) return;
+    linkSelection = null;
+    clearTimeout(pending.timer);
+    pending.resolve(selected);
+  };
+  const reconcileLinkSelection = (snapshot: OpenTuiWorkspaceLayoutSnapshot) => {
+    const pending = linkSelection;
+    if (!pending) return;
+    pending.layout = snapshot;
+    const observed = windowLinkTarget(snapshot, pending.target.linkId);
+    if (
+      !observed ||
+      observed.linkRevision !== pending.target.linkRevision ||
+      observed.liveSessionId !== pending.target.liveSessionId ||
+      observed.expectedSemanticWindowId !== pending.target.expectedSemanticWindowId
+    ) {
+      finishLinkSelection(false);
+      return;
+    }
+    if (!pending.received || snapshot.windowLinks?.activeLinkId !== pending.target.linkId) return;
+    finishLinkSelection(
+      snapshot.current !== null && paneForWindow(snapshot.current) === pending.paneId,
+    );
+  };
+
   const paneInput = new TerminalPaneInputRouter<{
     readonly input: SessionRuntimeTerminalInput;
     readonly parserOrigin?: Omit<
@@ -636,6 +675,7 @@ export function createApplicationTerminalInteractionController(
     >;
   }>({
     select: async (paneId) => {
+      finishLinkSelection(false);
       const expected = liveSelectionTarget();
       const selecting = pendingWindowSwitch;
       const operationId = selecting?.traceId;
@@ -649,6 +689,7 @@ export function createApplicationTerminalInteractionController(
             (failure) => {
               selectionFailure.current = failure;
             },
+            windowLinkForPane(options.layout(), paneId) ?? undefined,
           )
         : null;
       if (selecting && pendingWindowSwitch === selecting) {
@@ -833,6 +874,7 @@ export function createApplicationTerminalInteractionController(
           next.fastLane !== inputAuthorityIdentity.fastLane ||
           next.adapter !== inputAuthorityIdentity.adapter);
       if (next === null || replaced) {
+        finishLinkSelection(false);
         paneInput.invalidateSelection();
         pendingWindowSwitch = null;
         pendingWindowRename = null;
@@ -846,6 +888,7 @@ export function createApplicationTerminalInteractionController(
       inputAuthorityIdentity = next;
     },
     adoptLayout(snapshot) {
+      reconcileLinkSelection(snapshot);
       paneInput.adoptCanonicalPane(snapshot.current ? paneForWindow(snapshot.current) : null);
       const currentWindow = snapshot.current?.semanticWindowId ?? snapshot.current?.windowName;
       const currentPane = snapshot.current ? paneForWindow(snapshot.current) : null;
@@ -933,7 +976,130 @@ export function createApplicationTerminalInteractionController(
       maybeRequestWindowSwitchFrame();
       maybeRequestPaneResizeFrame();
     },
-    selectPane: (paneId) => paneInput.selectPane(paneId),
+    selectPane: (paneId) => {
+      finishLinkSelection(false);
+      paneInput.selectPane(paneId);
+    },
+    async unlinkWindowLink(target) {
+      const expected = liveSelectionTarget();
+      const observed = windowLinkTarget(options.layout(), target.linkId);
+      if (
+        !expected ||
+        !observed ||
+        observed.liveSessionId !== target.liveSessionId ||
+        observed.linkRevision !== target.linkRevision ||
+        observed.expectedSemanticWindowId !== target.expectedSemanticWindowId
+      )
+        return "Window link changed; reopen its menu";
+      try {
+        if (
+          !expected.client.ownsRuntimeAuthority?.("input") &&
+          !(await expected.client.requestAuthority("input"))
+        )
+          return "Window unlink requires input control";
+        const current = liveSelectionTarget();
+        if (
+          current?.client !== expected.client ||
+          current.daemonGeneration !== expected.daemonGeneration
+        )
+          return "Session changed; reopen the window menu";
+        await expected.client.dispatch({
+          kind: "semantic-intent",
+          intent: {
+            verb: "workspace.window.link.unlink",
+            workspaceName: expected.workspaceName,
+            target,
+          },
+        });
+        return "Window link removed";
+      } catch {
+        return "Window link could not be removed; it may be the last link or have changed";
+      }
+    },
+    async selectWindowLink(target) {
+      const expected = liveSelectionTarget();
+      const snapshot = options.layout();
+      const observed = windowLinkTarget(snapshot, target.linkId);
+      const backing = snapshot.windows.find(
+        (window) => window.semanticWindowId === target.expectedSemanticWindowId,
+      );
+      const paneId = backing && paneForWindow(backing);
+      if (
+        !expected ||
+        !paneId ||
+        !observed ||
+        observed.liveSessionId !== target.liveSessionId ||
+        observed.linkRevision !== target.linkRevision ||
+        observed.expectedSemanticWindowId !== target.expectedSemanticWindowId
+      )
+        return;
+      finishLinkSelection(false);
+      let resolve!: (selected: boolean) => void;
+      const settled = new Promise<boolean>((done) => {
+        resolve = done;
+      });
+      const pending = {
+        target,
+        paneId,
+        layout: snapshot,
+        received: false,
+        resolve,
+        timer: setTimeout(() => {
+          if (linkSelection === pending) finishLinkSelection(false);
+        }, 5_000),
+      };
+      pending.timer.unref?.();
+      linkSelection = pending;
+      // Register input ordering synchronously, before authority or command awaits.
+      paneInput.selectPane(paneId, { presentOptimistically: false, selection: () => settled });
+      try {
+        if (
+          !expected.client.ownsRuntimeAuthority?.("input") &&
+          !(await expected.client.requestAuthority("input"))
+        ) {
+          if (linkSelection === pending) finishLinkSelection(false);
+          return;
+        }
+        const current = liveSelectionTarget();
+        if (
+          linkSelection !== pending ||
+          current?.client !== expected.client ||
+          current.daemonGeneration !== expected.daemonGeneration
+        ) {
+          if (linkSelection === pending) finishLinkSelection(false);
+          return;
+        }
+        const wrapper = (await expected.client.dispatch({
+          kind: "semantic-intent",
+          intent: {
+            verb: "workspace.window.link.select",
+            workspaceName: expected.workspaceName,
+            target,
+          },
+        })) as { kind?: string; operationId?: string; result?: unknown };
+        const result = WorkspaceWindowLinkSelectResultSchemaZ.safeParse(wrapper.result);
+        if (linkSelection !== pending) return;
+        if (
+          wrapper.kind !== "semantic-intent" ||
+          !result.success ||
+          result.data.operationId !== wrapper.operationId ||
+          result.data.daemonInstanceId !== expected.daemonGeneration ||
+          result.data.workspaceName !== expected.workspaceName ||
+          result.data.target.linkId !== target.linkId ||
+          result.data.target.liveSessionId !== target.liveSessionId ||
+          result.data.target.linkRevision !== target.linkRevision ||
+          result.data.target.expectedSemanticWindowId !== target.expectedSemanticWindowId
+        ) {
+          finishLinkSelection(false);
+          return;
+        }
+        pending.received = true;
+        reconcileLinkSelection(pending.layout);
+        await settled;
+      } catch {
+        if (linkSelection === pending) finishLinkSelection(false);
+      }
+    },
     sendInput: async (input, parserOrigin) => {
       await paneInput.sendInput({ input, parserOrigin });
     },
@@ -1152,6 +1318,15 @@ export function createApplicationTerminalInteractionController(
       if (next) paneInput.selectPane(next);
     },
     cycleWindow() {
+      const topology = options.layout().windowLinks;
+      if (topology) {
+        if (topology.links.length < 2) return;
+        const current = topology.links.findIndex((link) => link.linkId === topology.activeLinkId);
+        const next = topology.links[(current + 1) % topology.links.length]!;
+        const target = windowLinkTarget(options.layout(), next.linkId);
+        if (target) void this.selectWindowLink(target);
+        return;
+      }
       const windows = options.layout().windows;
       if (windows.length < 2) return;
       const current = windows.findIndex((window) => window.currentWindow);

package/packages/daemon/src/tui/mirror/runtime/application-terminal-workspace-policy.ts

@@ -1,3 +1,4 @@
+import type { WindowLinkTarget } from "@tmux-ide/contracts";
 import type { AgentActivity } from "@tmux-ide/contracts";
 
 import type { OpenTuiWorkspaceLayoutSnapshot } from "../open-tui-workspace-runtime-port.ts";
@@ -309,3 +310,64 @@ export function terminalPaneResizePreview(
           }),
   });
 }
+
+/** Resolve only live opaque observations; native indexes are display metadata. */
+export function windowLinkTarget(
+  snapshot: OpenTuiWorkspaceLayoutSnapshot,
+  linkId: string,
+): WindowLinkTarget | null {
+  const topology = snapshot.windowLinks;
+  const link = topology?.links.find((candidate) => candidate.linkId === linkId);
+  if (!topology || !link) return null;
+  return {
+    liveSessionId: topology.liveSessionId,
+    linkRevision: topology.linkRevision,
+    linkId: link.linkId,
+    expectedSemanticWindowId: link.semanticWindowId,
+  };
+}
+
+/** Pane navigation within the active link must not silently choose a sibling link. */
+export function windowLinkForPane(
+  snapshot: OpenTuiWorkspaceLayoutSnapshot,
+  paneId: string,
+): WindowLinkTarget | null {
+  const backing = snapshot.windows.find((window) =>
+    window.panes.some((pane) => pane.pane === paneId),
+  );
+  const topology = snapshot.windowLinks;
+  if (!backing || !topology) return null;
+  const links = topology.links.filter((link) => link.semanticWindowId === backing.semanticWindowId);
+  const link =
+    links.find((candidate) => candidate.linkId === topology.activeLinkId) ??
+    (links.length === 1 ? links[0] : undefined);
+  return link ? windowLinkTarget(snapshot, link.linkId) : null;
+}
+
+/** Root composition for backing zoom and link actions, all restoring host focus. */
+export function terminalWindowActionCallbacks(
+  controller: Pick<
+    import("./application-terminal-interaction-controller.ts").ApplicationTerminalInteractionController,
+    "selectWindowLink" | "unlinkWindowLink" | "zoomPane" | "selectPane"
+  >,
+  notify: (message: string) => void,
+  recover: import("./application-host-focus-presentation.ts").ApplicationHostFocusRecovery,
+  cancelNavigation: () => void,
+) {
+  return {
+    onSelectPane: recover((paneId: string) => {
+      cancelNavigation();
+      controller.selectPane(paneId);
+    }),
+    onZoomPane: recover((paneId?: string) => {
+      void controller.zoomPane(paneId).then(notify);
+    }),
+    onSelectWindowLink: recover((target: WindowLinkTarget) => {
+      cancelNavigation();
+      void controller.selectWindowLink(target);
+    }),
+    onUnlinkWindowLink: recover((target: WindowLinkTarget) => {
+      void controller.unlinkWindowLink(target).then(notify);
+    }),
+  };
+}

package/packages/daemon/src/tui/mirror/runtime/application-terminal-workspace.tsx

@@ -1,3 +1,6 @@
+import { Menu } from "../ui/index.ts";
+import type { WindowLinkTarget } from "@tmux-ide/contracts";
+import { windowLinkTarget } from "./application-terminal-workspace-policy.ts";
 import type { PaneInteractionProjection } from "@tmux-ide/core";
 /* @jsxImportSource @opentui/solid */
 import {
@@ -61,7 +64,6 @@ import {
   type TerminalSelectionRange,
 } from "./terminal-selection.ts";
 import {
-  retainedTerminalWindowKey,
   terminalAgentStatusLabel,
   terminalPaneDisplayTitle,
   terminalPaneResizePreview,
@@ -168,6 +170,8 @@ export interface ApplicationTerminalWorkspaceProps {
   /** Daemon-authored semantic agent state, keyed by durable pane identity. */
   readonly agentIndicators?: Accessor<ReadonlyMap<string, ApplicationTerminalAgentIndicator>>;
   readonly onSelectPane: (paneId: string) => void;
+  readonly onSelectWindowLink?: (target: WindowLinkTarget) => void;
+  readonly onUnlinkWindowLink?: (target: WindowLinkTarget) => void;
   readonly onCreateWindow?: () => void;
   readonly onPaneContextAction?: (
     paneId: string,
@@ -332,37 +336,56 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
     ),
   );
   const visibleFrames = createMemo(() => projectedFrames().filter((frame) => frame.visible));
-  const retainedWindowIds = createMemo(
-    () =>
-      Object.freeze(
-        layout()
-          .windows.map(retainedTerminalWindowKey)
-          .filter((id): id is string => id !== null),
-      ),
-    undefined,
-    {
-      equals: (previous, next) =>
-        previous.length === next.length && previous.every((id, index) => id === next[index]),
-    },
-  );
-  const terminalWindowTabs = createMemo<readonly TerminalWindowTab[]>(() =>
-    retainedWindowIds().map((windowId, index) => {
-      const window = layout().windows.find(
-        (candidate) => retainedTerminalWindowKey(candidate) === windowId,
-      )!;
-      const indicator = terminalWindowAgentIndicator(window, agentIndicators());
-      return {
+  const [windowLinkMenu, setWindowLinkMenu] = createSignal<WindowLinkTarget | null>(null);
+  const unlinkWindowTab = () => {
+    const target = windowLinkMenu();
+    setWindowLinkMenu(null);
+    if (target) props.onUnlinkWindowLink?.(target);
+  };
+  createEffect(() => {
+    const target = windowLinkMenu();
+    const observed = target && windowLinkTarget(layout(), target.linkId);
+    if (
+      target &&
+      (!observed ||
+        observed.liveSessionId !== target.liveSessionId ||
+        observed.linkRevision !== target.linkRevision)
+    )
+      setWindowLinkMenu(null);
+  });
+  const terminalWindowTabs = createMemo<readonly TerminalWindowTab[]>(() => {
+    const snapshot = layout();
+    if (!snapshot.windowLinks)
+      return snapshot.windows.map((window, index) => ({
         index,
         name: terminalWindowTitle(window),
         active: window.currentWindow,
         sync: false,
         semanticWindowId: window.semanticWindowId,
         activePaneId: terminalWindowPane(window),
-        status: indicator ? terminalAgentStatusLabel(indicator.activity) : undefined,
-        attention: indicator?.attention,
-      };
-    }),
-  );
+        disabled: true,
+      }));
+    return snapshot.windowLinks.links.flatMap((link) => {
+      const window = snapshot.windows.find(
+        (candidate) => candidate.semanticWindowId === link.semanticWindowId,
+      );
+      if (!window) return [];
+      const indicator = terminalWindowAgentIndicator(window, agentIndicators());
+      return [
+        {
+          linkId: link.linkId,
+          index: link.displayIndex,
+          name: terminalWindowTitle(window),
+          active: snapshot.windowLinks?.activeLinkId === link.linkId,
+          sync: false,
+          semanticWindowId: window.semanticWindowId,
+          activePaneId: terminalWindowPane(window),
+          status: indicator ? terminalAgentStatusLabel(indicator.activity) : undefined,
+          attention: indicator?.attention,
+        },
+      ];
+    });
+  });
   if (props.onWindowPresented)
     createRenderEffect(() => {
       const current = layout().current;
@@ -911,6 +934,12 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
   props.onSelectionCopyOwner?.(copySelection);
   const handlePaneMenuKey: PaneMenuKeyHandler = (name, event) => {
     if (props.interactive === false) return false;
+    if (windowLinkMenu()) {
+      if (event?.eventType === "release") return true;
+      if (name === "escape") setWindowLinkMenu(null);
+      else if (name === "return" || name === "enter" || name === "u") unlinkWindowTab();
+      return true;
+    }
     if (paneMenu.handleKey(name, event)) return true;
     const focused = props.focusedPane;
     const keyboard = keyboardCopy();
@@ -1097,7 +1126,10 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
     },
     () =>
       props.interactive !== false &&
-      (drag !== null || paneMenu.ownsInput() || keyboardCopy() !== null),
+      (drag !== null ||
+        windowLinkMenu() !== null ||
+        paneMenu.ownsInput() ||
+        keyboardCopy() !== null),
     () => {
       // Called only after global shortcuts, copy, and local navigation decline
       // the event, immediately before terminal key or paste delivery.
@@ -1116,7 +1148,7 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
   // listener and the typed listener on a target, even after stopPropagation.
   const routePointer = (event: WorkspaceMouseEvent): void => {
     if (event.type === "down") wheelGesture.reset();
-    if (paneMenu.ownsInput()) {
+    if (windowLinkMenu() || paneMenu.ownsInput()) {
       event.stopPropagation?.();
       return;
     }
@@ -1649,9 +1681,18 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
             tabs={terminalWindowTabs}
             hoveredIndex={null}
             onActivate={(index) => {
-              const pane = terminalWindowTabs()[index]?.activePaneId;
-              if (pane) props.onSelectPane(pane);
+              const tab = terminalWindowTabs().find((candidate) => candidate.index === index);
+              const target = tab?.linkId ? windowLinkTarget(layout(), tab.linkId) : null;
+              if (target) props.onSelectWindowLink?.(target);
             }}
+            onWindowActions={
+              props.onUnlinkWindowLink
+                ? (index) => {
+                    const tab = terminalWindowTabs().find((candidate) => candidate.index === index);
+                    if (tab?.linkId) setWindowLinkMenu(windowLinkTarget(layout(), tab.linkId));
+                  }
+                : undefined
+            }
             onNewWindow={() => props.onCreateWindow?.()}
           />
         </Show>
@@ -1805,6 +1846,22 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
           </box>
         )}
       </For>
+      <Show when={windowLinkMenu()}>
+        <Menu
+          theme={props.theme}
+          title="Window link"
+          left={0}
+          top={1}
+          width={Math.min(36, props.width)}
+          viewportWidth={props.width}
+          viewportHeight={props.height}
+          selectedId="unlink"
+          items={[{ id: "unlink", label: "Unlink this tab", shortcut: "U" }]}
+          footer="Other links keep their panes"
+          onDismiss={() => setWindowLinkMenu(null)}
+          onSelect={unlinkWindowTab}
+        />
+      </Show>
       <Show when={paneContextMenu()}>
         {(menu) => (
           <PaneActionMenu

package/packages/daemon/src/tui/mirror/runtime/fleet-lifecycle-client.ts

@@ -1,3 +1,5 @@
+import { createTmuxServerClient } from "@tmux-ide/daemon-client/tmux-server-client";
+import type { TmuxServerScope } from "@tmux-ide/contracts";
 import type { ApplicationMachineAuthorityHandle } from "./application-machine-authority.ts";
 import type { ActionResult, WorkspaceSessionKillArguments } from "@tmux-ide/contracts";
 import {
@@ -52,6 +54,7 @@ async function dispatch<
 
 type FleetHandle = Pick<ApplicationMachineAuthorityHandle, "read" | "endpoint">;
 export interface FleetSessionCloseTarget {
+  readonly server?: TmuxServerScope;
   readonly daemonInstanceId: string;
   readonly liveSessionId: string;
   readonly sessionName: string;
@@ -91,10 +94,31 @@ async function dispatchOnHandle<Name extends "workspace.session.create" | "works
 export function createFleetSession(
   input: WorkspaceSessionCreateArguments | FleetHandle,
   name?: string,
+  server?: TmuxServerScope,
 ): Promise<WorkspaceSessionCreateResult | null> {
   if ("read" in input) {
     const daemon = input.read();
     if (!daemon || !name) return Promise.resolve(null);
+    if (server) {
+      if (!daemon.authToken || input.endpoint().state !== "ready") return Promise.resolve(null);
+      const epoch = input.endpoint().epoch;
+      const baseUrl = canonicalDaemonUrl("http", daemon.bindHostname, daemon.port);
+      const client = createTmuxServerClient(
+        { baseUrl, ownerToken: daemon.authToken, hostClientId: HOST_CLIENT_ID, origin: baseUrl },
+        server,
+      );
+      return client
+        .createSession(randomUUID(), {
+          displayName: name,
+          expectedDaemonInstanceId: server.generation,
+        })
+        .then((result) =>
+          input.endpoint().epoch === epoch && input.read()?.instanceId === daemon.instanceId
+            ? result
+            : null,
+        )
+        .finally(() => client.dispose());
+    }
     return dispatchOnHandle(input, "workspace.session.create", {
       displayName: name,
       expectedDaemonInstanceId: daemon.instanceId,
@@ -109,6 +133,34 @@ export function closeFleetSession(
   target: FleetSessionCloseTarget,
 ): Promise<ActionResult<"workspace.session.kill"> | null> {
   if (handle.read()?.instanceId !== target.daemonInstanceId) return Promise.resolve(null);
+  if (target.server) {
+    const daemon = handle.read();
+    if (!daemon?.authToken || handle.endpoint().state !== "ready") return Promise.resolve(null);
+    const epoch = handle.endpoint().epoch;
+    const baseUrl = canonicalDaemonUrl("http", daemon.bindHostname, daemon.port);
+    const client = createTmuxServerClient(
+      { baseUrl, ownerToken: daemon.authToken, hostClientId: HOST_CLIENT_ID, origin: baseUrl },
+      target.server,
+    );
+    return client
+      .mutate(randomUUID(), {
+        verb: "workspace.session.kill",
+        workspaceName: target.workspaceName ?? target.sessionName,
+        fleetTarget: {
+          daemonInstanceId: target.server.generation,
+          liveSessionId: target.liveSessionId,
+          sessionName: target.sessionName,
+        },
+      })
+      .then((result) =>
+        handle.endpoint().epoch === epoch &&
+        handle.read()?.instanceId === target.daemonInstanceId &&
+        result.verb === "workspace.session.kill"
+          ? result
+          : null,
+      )
+      .finally(() => client.dispose());
+  }
   return dispatchOnHandle(handle, "workspace.session.kill", {
     workspaceName: target.workspaceName ?? target.sessionName,
     fleetTarget: {

package/packages/daemon/src/tui/mirror/runtime/open-tui-generation-host.ts

@@ -316,7 +316,7 @@ function buildProductionBundle(
       requestTerminalRuntimeInventoryRefresh: () => {
         connection.transport.refreshTerminalRuntimeInventory();
       },
-      actions: productionOwnerActions(readDaemon),
+      actions: connection.ownerActions ?? productionOwnerActions(readDaemon),
     },
   });
   fastLane = createOpenTuiWorkspaceTerminalFastLane(

package/packages/daemon/src/tui/mirror/runtime/select-terminal-pane.ts

@@ -1,3 +1,4 @@
+import type { WindowLinkTarget } from "@tmux-ide/contracts";
 import type { WorkspaceClientDispatch } from "@tmux-ide/daemon-client/workspace-client-types";
 
 interface PaneSelectionClient {
@@ -40,6 +41,7 @@ export async function selectTerminalPane(
   semanticPaneId: string,
   operationId?: string,
   onFailure?: (failure: PaneSelectionFailure) => void,
+  windowLink?: WindowLinkTarget,
 ): Promise<PaneSelectionReceipt | null> {
   const fail = (failure: PaneSelectionFailure): null => {
     try {
@@ -95,6 +97,7 @@ export async function selectTerminalPane(
           verb: "workspace.pane.select",
           workspaceName: expected.workspaceName,
           semanticPaneId,
+          ...(windowLink ? { windowLink } : {}),
         },
       });
     } catch (error) {

package/packages/daemon/src/tui/mirror/runtime/terminal-pane-input-router.ts

@@ -44,14 +44,25 @@ export class TerminalPaneInputRouter<Input> {
     if (this.#pending?.selected === true) this.#pending = null;
   }
 
-  selectPane(paneId: string, options: { readonly presentOptimistically?: boolean } = {}): void {
-    if (this.#pending?.paneId === paneId) return;
-    if (this.#pending === null && this.#canonicalPane === paneId && this.#focusedPane === paneId)
+  selectPane(
+    paneId: string,
+    options: {
+      readonly presentOptimistically?: boolean;
+      readonly selection?: () => Promise<boolean>;
+    } = {},
+  ): void {
+    if (!options.selection && this.#pending?.paneId === paneId) return;
+    if (
+      !options.selection &&
+      this.#pending === null &&
+      this.#canonicalPane === paneId &&
+      this.#focusedPane === paneId
+    )
       return;
     const token = ++this.#selectionToken;
     const presentOptimistically = options.presentOptimistically !== false;
     if (presentOptimistically) this.#setFocusedPane(paneId);
-    const settled = this.#options.select(paneId);
+    const settled = options.selection ? options.selection() : this.#options.select(paneId);
     this.#pending = { token, paneId, presentOptimistically, settled, selected: null };
     void settled.then((selected) => {
       if (this.#pending?.token !== token) return;

package/packages/daemon/src/tui/mirror/workspace/application-command-description.ts

@@ -1,7 +1,9 @@
+import type { TmuxServerScope } from "@tmux-ide/contracts";
 import { fuzzyTermsMatch as commandSearchMatch } from "../../team/fuzzy.ts";
 export { fuzzyTermsMatch as commandSearchMatch } from "../../team/fuzzy.ts";
 import { PANE_ACTION_MENU_ITEMS } from "./pane-action-menu-model.ts";
 export interface FleetPaletteTarget {
+  readonly server?: TmuxServerScope;
   readonly machineId: string;
   readonly liveSessionId: string;
   readonly hostLabel: string;
@@ -51,8 +53,14 @@ export type ApplicationPaletteCommand =
 export function applicationCommandDescription(command: ApplicationPaletteCommand) {
   if (typeof command === "object" && command.kind === "open-machine")
     return {
-      id: JSON.stringify([command.kind, command.fleet.machineId]),
-      label: `Machine · ${command.label}`,
+      id: JSON.stringify([
+        command.kind,
+        command.fleet.machineId,
+        ...(command.fleet.server
+          ? [command.fleet.server.serverId, command.fleet.server.generation]
+          : []),
+      ]),
+      label: `${command.fleet.server ? "Server" : "Machine"} · ${command.label}`,
       detail: command.fleet.disabled ? "Unavailable" : "Browse sessions or create on this host",
     };
   if (typeof command === "object") {
@@ -63,6 +71,9 @@ export function applicationCommandDescription(command: ApplicationPaletteCommand
           ? [
               command.kind,
               command.fleet.machineId,
+              ...(command.fleet.server
+                ? [command.fleet.server.serverId, command.fleet.server.generation]
+                : []),
               command.fleet.liveSessionId,
               session ? null : command.paneId,
             ]