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

package/packages/daemon/dist/tui/mirror/runtime/application-route-connection.js

@@ -1,15 +1,108 @@
+import { listTmuxServers, createTmuxServerClient, } from "@tmux-ide/daemon-client/tmux-server-client";
+import { canonicalDaemonUrl } from "../../../lib/canonical-daemon.js";
 import { fetchCanonicalLiveWorkspaceRouting } from "../canonical-workspace-routing.js";
 import { prepareOpenTuiApplicationShellConnection } from "../application-shell-daemon-connection.js";
 import { ensureOpenTuiSessionWorkspaceResult } from "../configless-session-bootstrap.js";
 /** Every retained tab gets this fixed route, including promotion and reconnect paths. */
-export function applicationRouteConnection(handle, expectedLiveSessionId, onDiagnostic) {
+export function applicationRouteConnection(handle, expectedLiveSessionId, onDiagnostic, server) {
+    let rootInstanceId = handle.read()?.instanceId;
+    let selectedServer = server;
+    let refresh = null;
+    const refreshAfterDaemonReplacement = async (nextRoot) => {
+        if (!selectedServer)
+            throw new Error("Select the server session again");
+        if (rootInstanceId === nextRoot)
+            return selectedServer;
+        if (!expectedLiveSessionId)
+            throw new Error("Select the server session again");
+        if (refresh?.root === nextRoot)
+            return refresh.promise;
+        const stableServerId = selectedServer.serverId;
+        const promise = (async () => {
+            const daemon = handle.read();
+            const epoch = handle.endpoint()?.epoch;
+            if (!daemon?.authToken || daemon.instanceId !== nextRoot)
+                throw new Error("Daemon changed during reconnect");
+            const options = {
+                baseUrl: canonicalDaemonUrl("http", daemon.bindHostname, daemon.port),
+                ownerToken: daemon.authToken,
+                hostClientId: `opentui-reconnect:${process.pid}`,
+                origin: "tmux-ide://opentui",
+            };
+            const catalog = await listTmuxServers(options);
+            const descriptor = catalog.servers.find((candidate) => candidate.serverId === stableServerId);
+            if (!descriptor || descriptor.state !== "online")
+                throw new Error("Selected tmux server is unavailable");
+            const scope = { serverId: descriptor.serverId, generation: descriptor.generation };
+            const client = createTmuxServerClient(options, scope);
+            try {
+                const sessions = await client.sessions();
+                if (!sessions.sessions.some((session) => session.liveSessionId === expectedLiveSessionId))
+                    throw new Error("Selected tmux session was replaced");
+            }
+            finally {
+                client.dispose();
+            }
+            if (handle.read()?.instanceId !== nextRoot || handle.endpoint()?.epoch !== epoch)
+                throw new Error("Daemon changed during reconnect");
+            rootInstanceId = nextRoot;
+            selectedServer = scope;
+            return scope;
+        })();
+        refresh = { root: nextRoot, promise };
+        try {
+            return await promise;
+        }
+        finally {
+            if (refresh?.promise === promise)
+                refresh = null;
+        }
+    };
     return {
         readDaemon: handle.read,
-        observeCanonicalGeneration: handle.observe,
+        observeCanonicalGeneration: server
+            ? async (listener) => {
+                let stopped = false;
+                let revision = 0;
+                const stop = await handle.observe((generation) => {
+                    const token = ++revision;
+                    if (!generation) {
+                        listener(null);
+                        return;
+                    }
+                    if (generation === rootInstanceId) {
+                        listener(selectedServer.generation);
+                        return;
+                    }
+                    // Retire old input before reading the replacement daemon's registration.
+                    listener(null);
+                    void refreshAfterDaemonReplacement(generation).then((scope) => {
+                        if (!stopped && token === revision && handle.read()?.instanceId === generation)
+                            listener(scope.generation);
+                    }, () => {
+                        if (!stopped && token === revision)
+                            listener(null);
+                    });
+                });
+                return () => {
+                    stopped = true;
+                    revision++;
+                    stop();
+                };
+            }
+            : handle.observe,
         resolveConnection: async (sessionName) => {
+            if (selectedServer) {
+                const currentRoot = handle.read()?.instanceId;
+                if (!currentRoot)
+                    return null;
+                await refreshAfterDaemonReplacement(currentRoot);
+            }
             const connection = await prepareOpenTuiApplicationShellConnection(sessionName, {
                 ...(onDiagnostic ? { onDiagnostic } : {}),
+                ...(selectedServer ? { server: selectedServer, expectedLiveSessionId } : {}),
                 readCanonicalDaemonInfo: handle.read,
+                readDaemonEndpoint: handle.endpoint,
                 isCanonicalDaemonAlive: handle.isAlive,
                 ensureSessionWorkspace: (name) => ensureOpenTuiSessionWorkspaceResult(name, {
                     readDaemon: handle.read,

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-interaction-controller.js

@@ -1,3 +1,5 @@
+import { WorkspaceWindowLinkSelectResultSchemaZ } from "@tmux-ide/contracts";
+import { windowLinkForPane, windowLinkTarget } from "./application-terminal-workspace-policy.js";
 import { createHash, randomUUID } from "node:crypto";
 import { currentTuiPerformanceEventSink, } from "../performance-events.js";
 import { prepareCausalCellFixtureV1 } from "./causal-cell-input-fixture.js";
@@ -354,8 +356,35 @@ export function createApplicationTerminalInteractionController(options) {
             pendingWindowSwitch = null;
         }
     };
+    let linkSelection = null;
+    const finishLinkSelection = (selected) => {
+        const pending = linkSelection;
+        if (!pending)
+            return;
+        linkSelection = null;
+        clearTimeout(pending.timer);
+        pending.resolve(selected);
+    };
+    const reconcileLinkSelection = (snapshot) => {
+        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({
         select: async (paneId) => {
+            finishLinkSelection(false);
             const expected = liveSelectionTarget();
             const selecting = pendingWindowSwitch;
             const operationId = selecting?.traceId;
@@ -363,7 +392,7 @@ export function createApplicationTerminalInteractionController(options) {
             const receipt = expected
                 ? await selectTerminalPane(expected, liveSelectionTarget, paneId, operationId, (failure) => {
                     selectionFailure.current = failure;
-                })
+                }, windowLinkForPane(options.layout(), paneId) ?? undefined)
                 : null;
             if (selecting && pendingWindowSwitch === selecting) {
                 const receiptAtMicros = options.detailedWindowSwitchTiming ? diagnosticNowMicros() : null;
@@ -540,6 +569,7 @@ export function createApplicationTerminalInteractionController(options) {
                     next.fastLane !== inputAuthorityIdentity.fastLane ||
                     next.adapter !== inputAuthorityIdentity.adapter);
             if (next === null || replaced) {
+                finishLinkSelection(false);
                 paneInput.invalidateSelection();
                 pendingWindowSwitch = null;
                 pendingWindowRename = null;
@@ -553,6 +583,7 @@ export function createApplicationTerminalInteractionController(options) {
             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;
@@ -635,7 +666,121 @@ export function createApplicationTerminalInteractionController(options) {
             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;
+            const settled = new Promise((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,
+                    },
+                }));
+                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 });
         },
@@ -857,6 +1002,17 @@ export function createApplicationTerminalInteractionController(options) {
                 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;

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-workspace-policy.js

@@ -191,3 +191,46 @@ export function terminalPaneResizePreview(separator, pointer, origin) {
             }),
     });
 }
+/** Resolve only live opaque observations; native indexes are display metadata. */
+export function windowLinkTarget(snapshot, linkId) {
+    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, paneId) {
+    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, notify, recover, cancelNavigation) {
+    return {
+        onSelectPane: recover((paneId) => {
+            cancelNavigation();
+            controller.selectPane(paneId);
+        }),
+        onZoomPane: recover((paneId) => {
+            void controller.zoomPane(paneId).then(notify);
+        }),
+        onSelectWindowLink: recover((target) => {
+            cancelNavigation();
+            void controller.selectWindowLink(target);
+        }),
+        onUnlinkWindowLink: recover((target) => {
+            void controller.unlinkWindowLink(target).then(notify);
+        }),
+    };
+}

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-workspace.jsx

@@ -1,3 +1,5 @@
+import { Menu } from "../ui/index.js";
+import { windowLinkTarget } from "./application-terminal-workspace-policy.js";
 /* @jsxImportSource @opentui/solid */
 import { clampTerminalViewportOrigin, terminalLiveViewportOrigin, reflowTerminalPosition, } from "../terminal-viewport.js";
 import { For, Show, createMemo, createEffect, createRenderEffect, createSignal, onCleanup, untrack, } from "solid-js";
@@ -14,7 +16,7 @@ import { PaneTitleBar } from "../workspace/terminal-pane-header.jsx";
 import { PANE_ACTION_MENU_ITEMS, PaneActionMenu } from "../workspace/pane-action-menu.jsx";
 import { createApplicationPaneMenuOwner } from "./application-pane-menu-owner.js";
 import { extractTerminalSelection, terminalMouseActionSupported, terminalGestureLeaseMatches, terminalSelectionCell, terminalMouseInput, } from "./terminal-selection.js";
-import { retainedTerminalWindowKey, terminalAgentStatusLabel, terminalPaneDisplayTitle, terminalPaneResizePreview, terminalPaneSeparatorAt, terminalPaneSeparators, terminalWindowAgentIndicator, terminalWindowPane, terminalWindowTitle, } from "./application-terminal-workspace-policy.js";
+import { terminalAgentStatusLabel, terminalPaneDisplayTitle, terminalPaneResizePreview, terminalPaneSeparatorAt, terminalPaneSeparators, terminalWindowAgentIndicator, terminalWindowPane, terminalWindowTitle, } from "./application-terminal-workspace-policy.js";
 export { terminalAgentStatusLabel, terminalPaneChromeLabel, terminalPaneDisplayTitle, } from "./application-terminal-workspace-policy.js";
 export function safeApplicationMouseIngressMicros(now = () => performance.now()) {
     try {
@@ -99,25 +101,54 @@ export function ApplicationTerminalWorkspace(props) {
     onCleanup(scrollback.dispose);
     createRenderEffect(() => scrollback.retain(new Set(layout().windows.flatMap((window) => window.panes.flatMap((pane) => (pane.pane ? [pane.pane] : []))))));
     const visibleFrames = createMemo(() => projectedFrames().filter((frame) => frame.visible));
-    const retainedWindowIds = createMemo(() => Object.freeze(layout()
-        .windows.map(retainedTerminalWindowKey)
-        .filter((id) => id !== null)), undefined, {
-        equals: (previous, next) => previous.length === next.length && previous.every((id, index) => id === next[index]),
+    const [windowLinkMenu, setWindowLinkMenu] = createSignal(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(() => {
+        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),
+                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,
+                },
+            ];
+        });
     });
-    const terminalWindowTabs = createMemo(() => retainedWindowIds().map((windowId, index) => {
-        const window = layout().windows.find((candidate) => retainedTerminalWindowKey(candidate) === windowId);
-        const indicator = terminalWindowAgentIndicator(window, agentIndicators());
-        return {
-            index,
-            name: terminalWindowTitle(window),
-            active: window.currentWindow,
-            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;
@@ -564,6 +595,15 @@ export function ApplicationTerminalWorkspace(props) {
     const handlePaneMenuKey = (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;
@@ -717,7 +757,10 @@ export function ApplicationTerminalWorkspace(props) {
         }
         return handlePaneMenuKey(name, event);
     }, () => 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.
         const paneId = retainedSelectionPane() ?? props.focusedPane;
@@ -736,7 +779,7 @@ export function ApplicationTerminalWorkspace(props) {
     const routePointer = (event) => {
         if (event.type === "down")
             wheelGesture.reset();
-        if (paneMenu.ownsInput()) {
+        if (windowLinkMenu() || paneMenu.ownsInput()) {
             event.stopPropagation?.();
             return;
         }
@@ -1178,10 +1221,17 @@ export function ApplicationTerminalWorkspace(props) {
       <box position="absolute" left={0} top={topOffset() - 1} width={props.width} height={1} backgroundColor={props.theme.roles.surfaces.panel} flexDirection="row" onMouse={routePointer}>
         <Show when={layout().windows.length > 0} fallback={<text fg={props.theme.roles.text.muted}> no terminal windows </text>}>
           <TerminalWindowStrip theme={props.theme} width={props.width} tabs={terminalWindowTabs} hoveredIndex={null} onActivate={(index) => {
-            const pane = terminalWindowTabs()[index]?.activePaneId;
-            if (pane)
-                props.onSelectPane(pane);
-        }} onNewWindow={() => props.onCreateWindow?.()}/>
+            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>
       </box>
       <For each={retainedPaneIds()}>
@@ -1244,6 +1294,9 @@ export function ApplicationTerminalWorkspace(props) {
             </Show>
           </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 theme={props.theme} left={menu().left} top={menu().top} width={paneContextMenuWidth()} viewportWidth={props.width} viewportHeight={props.height + topOffset()} paneTitle={menu().displayName} active onDismiss={paneMenu.dismiss} selectedId={menu().selectedId} closeArmed={menu().closeArmed} onHighlight={paneMenu.highlight} onActionIntent={paneMenu.activate}/>)}
       </Show>

package/packages/daemon/dist/tui/mirror/runtime/fleet-lifecycle-client.js

@@ -1,3 +1,4 @@
+import { createTmuxServerClient } from "@tmux-ide/daemon-client/tmux-server-client";
 import { applicationDaemonEndpoint, readApplicationDaemonInfo as readCanonicalDaemonInfo, } from "./application-daemon-authority.js";
 import { randomUUID } from "node:crypto";
 import { dispatchOwnerAction } from "@tmux-ide/daemon-client/owner-action-client";
@@ -43,11 +44,27 @@ async function dispatchOnHandle(handle, name, input) {
         ? result
         : null;
 }
-export function createFleetSession(input, name) {
+export function createFleetSession(input, name, server) {
     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,
@@ -59,6 +76,30 @@ export function createFleetSession(input, name) {
 export function closeFleetSession(handle, target) {
     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/dist/tui/mirror/runtime/open-tui-generation-host.js

@@ -162,7 +162,7 @@ function buildProductionBundle(connection, callbacks, readDaemon = readCanonical
             requestTerminalRuntimeInventoryRefresh: () => {
                 connection.transport.refreshTerminalRuntimeInventory();
             },
-            actions: productionOwnerActions(readDaemon),
+            actions: connection.ownerActions ?? productionOwnerActions(readDaemon),
         },
     });
     fastLane = createOpenTuiWorkspaceTerminalFastLane(client, OPEN_TUI_HOST_CLIENT_ID, causalCellLedger);

package/packages/daemon/dist/tui/mirror/runtime/select-terminal-pane.js

@@ -1,5 +1,5 @@
 /** Acquire controller authority before issuing the canonical pane-select intent. */
-export async function selectTerminalPane(expected, current, semanticPaneId, operationId, onFailure) {
+export async function selectTerminalPane(expected, current, semanticPaneId, operationId, onFailure, windowLink) {
     const fail = (failure) => {
         try {
             onFailure?.(failure);
@@ -57,6 +57,7 @@ export async function selectTerminalPane(expected, current, semanticPaneId, oper
                     verb: "workspace.pane.select",
                     workspaceName: expected.workspaceName,
                     semanticPaneId,
+                    ...(windowLink ? { windowLink } : {}),
                 },
             });
         }

package/packages/daemon/dist/tui/mirror/runtime/terminal-pane-input-router.js

@@ -30,15 +30,18 @@ export class TerminalPaneInputRouter {
             this.#pending = null;
     }
     selectPane(paneId, options = {}) {
-        if (this.#pending?.paneId === paneId)
+        if (!options.selection && this.#pending?.paneId === paneId)
             return;
-        if (this.#pending === null && this.#canonicalPane === paneId && this.#focusedPane === paneId)
+        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)

package/packages/daemon/dist/tui/mirror/workspace/application-command-description.js

@@ -5,8 +5,14 @@ import { PANE_ACTION_MENU_ITEMS } from "./pane-action-menu-model.js";
 export function applicationCommandDescription(command) {
     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") {
@@ -16,6 +22,9 @@ export function applicationCommandDescription(command) {
                 ? [
                     command.kind,
                     command.fleet.machineId,
+                    ...(command.fleet.server
+                        ? [command.fleet.server.serverId, command.fleet.server.generation]
+                        : []),
                     command.fleet.liveSessionId,
                     session ? null : command.paneId,
                 ]