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

package/packages/daemon/dist/tui/mirror/runtime/application-performance-log.js

@@ -50,8 +50,11 @@ const LIFECYCLE_RUNTIME_PHASES = new Set([
     "stream-open-resolved",
 ]);
 const lifecycleRecords = new Map();
+let closing = false;
+let closePromise = null;
 function serializeMark(phase, details) {
     if (!stream ||
+        closing ||
         (!tuiPerfStream &&
             !LIFECYCLE_PHASES.has(phase) &&
             !(phase === "generation-runtime-progress" &&
@@ -120,11 +123,21 @@ async function flushTuiPerfMarks() {
         }
     });
 }
-export async function closeTuiPerfMarks() {
-    if (!stream)
-        return;
-    await flushTuiPerfMarks();
-    await new Promise((resolveClose) => stream.end(resolveClose));
-    stream.off("error", fail);
-    stream.off("drain", drain);
+export function closeTuiPerfMarks() {
+    if (closePromise)
+        return closePromise;
+    // Renderer/runtime callbacks can still emit marks during asynchronous teardown.
+    // Stop accepting them before yielding, and let every caller await one close.
+    closing = true;
+    closePromise = (async () => {
+        if (!stream)
+            return;
+        await flushTuiPerfMarks();
+        // No drain callback may enqueue another critical record after end().
+        stream.off("drain", drain);
+        await new Promise((resolveClose) => stream.end(resolveClose));
+        // Keep the error listener through the underlying file descriptor teardown;
+        // an asynchronous close error must remain a logging failure, not a crash.
+    })();
+    return closePromise;
 }

package/packages/daemon/dist/tui/mirror/runtime/application-root-configuration.js

@@ -1,3 +1,4 @@
+import { TmuxServerIdSchemaZ } from "@tmux-ide/contracts";
 import { parseArgs } from "node:util";
 import { loadAppConfig } from "../../../lib/app-config.js";
 import { tuiPerfMark } from "./application-performance-log.js";
@@ -6,16 +7,21 @@ export const parseApplicationArgs = (argv) => {
         args: [...argv],
         allowPositionals: true,
         strict: false,
-        options: { target: { type: "string" } },
+        options: { target: { type: "string" }, server: { type: "string" } },
     });
     const positional = parsed.positionals.find((value) => value !== "app") ?? null;
     const target = typeof parsed.values.target === "string" ? parsed.values.target : positional;
-    return Object.freeze({ target: target && target !== "home" ? target : null });
+    return Object.freeze({
+        target: target && target !== "home" ? target : null,
+        serverId: typeof parsed.values.server === "string"
+            ? TmuxServerIdSchemaZ.parse(parsed.values.server)
+            : null,
+    });
 };
 export async function loadApplicationConfig(args) {
     tuiPerfMark("config-load-start", { requestedTarget: args.target });
     // Home discovery is daemon-authoritative and remains live after mount. The
     // immutable bootstrap config only carries an explicit user target.
     tuiPerfMark("config-load-end", { target: args.target });
-    return Object.freeze({ app: loadAppConfig(), target: args.target });
+    return Object.freeze({ app: loadAppConfig(), target: args.target, serverId: args.serverId });
 }

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-shell-home.jsx

@@ -30,9 +30,10 @@ export function ApplicationHomeSurface(props) {
         naturalButtonWidth("Open terminals", "F2") +
             naturalButtonWidth("Commands", "F5") +
             (props.onCycleTheme ? naturalButtonWidth(themeLabel()) + 2 : 0) +
+            (props.onOpenTutorial ? naturalButtonWidth(props.tutorialLabel ?? "Learn tmux-ide") + 2 : 0) +
             2;
     const reservedRows = () => (spacious() ? 4 : 2) +
-        (actionsInRow() ? 1 : props.onCycleTheme ? 3 : 2) +
+        (actionsInRow() ? 1 : 2 + (props.onCycleTheme ? 1 : 0) + (props.onOpenTutorial ? 1 : 0)) +
         (spacious() ? 1 : 0) +
         (props.note ? (spacious() ? 2 : 1) : 0);
     const recentActivity = () => (props.recentPaneActivity ?? []).slice(0, spacious()
@@ -78,7 +79,7 @@ export function ApplicationHomeSurface(props) {
                 {clipTerminal(summary(), bodyWidth())}
               </text>
             </>}>
-          {(snapshot) => (<HomeAgentRoster theme={props.theme} width={bodyWidth()} height={rosterHeight()} snapshot={snapshot()} selection={props.agentSelection ?? { selectedKey: null, scrollOffset: 0 }} inputActive={props.agentInputActive ?? false} onSelect={(key) => props.onSelectAgent?.(key)} onMove={(delta) => props.onMoveAgent?.(delta)} onViewport={(rows) => props.onAgentViewport?.(rows)} onOpen={(row, source) => props.onOpenAgent?.(row, source)} onRetry={props.onRetryAgents} onLoadMore={props.onLoadMoreAgents}/>)}
+          {(snapshot) => (<HomeAgentRoster filterLabel={props.agentFilterLabel} onCycleMachine={props.onCycleAgentMachine} onToggleAttention={props.onToggleAgentAttention} theme={props.theme} width={bodyWidth()} height={rosterHeight()} snapshot={snapshot()} selection={props.agentSelection ?? { selectedKey: null, scrollOffset: 0 }} inputActive={props.agentInputActive ?? false} onSelect={(key) => props.onSelectAgent?.(key)} onMove={(delta) => props.onMoveAgent?.(delta)} onViewport={(rows) => props.onAgentViewport?.(rows)} onOpen={(row, source) => props.onOpenAgent?.(row, source)} onRetry={props.onRetryAgents} onLoadMore={props.onLoadMoreAgents}/>)}
         </Show>
         <Show when={activityHeight() > 0}>
           <box width={bodyWidth()} height={activityHeight()} flexShrink={0} flexDirection="column" overflow="hidden">
@@ -99,6 +100,9 @@ export function ApplicationHomeSurface(props) {
         <box width={bodyWidth()} flexShrink={0} flexDirection={actionsInRow() ? "row" : "column"} alignItems="flex-start" gap={actionsInRow() ? 2 : 0}>
           <TuiButton theme={props.theme} label="Open terminals" shortcut="F2" width={buttonWidth("Open terminals", "F2")} variant="primary" onPress={props.onOpenTerminals}/>
           <TuiButton theme={props.theme} label="Commands" shortcut="F5" width={buttonWidth("Commands", "F5")} onPress={props.onOpenCommands}/>
+          <Show when={props.onOpenTutorial}>
+            {(open) => (<TuiButton theme={props.theme} label={props.tutorialLabel ?? "Learn tmux-ide"} width={buttonWidth(props.tutorialLabel ?? "Learn tmux-ide")} onPress={open()}/>)}
+          </Show>
           <Show when={props.onCycleTheme}>
             {(onCycleTheme) => (<TuiButton theme={props.theme} label={themeLabel()} width={buttonWidth(themeLabel())} variant="ghost" background={props.theme.roles.surfaces.canvas} onPress={onCycleTheme()}/>)}
           </Show>

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/application-theme-repaint.js

@@ -1,3 +1,4 @@
+import { createEffect } from "solid-js";
 /**
  * OpenTUI 0.5 keeps a private full-frame damage flag. A semantic theme switch
  * changes backgrounds without necessarily changing glyphs, so its ordinary
@@ -32,3 +33,11 @@ export function applyApplicationAppearanceToRenderer(renderer, theme, generation
         requestApplicationThemeRepaint(renderer);
     return generation;
 }
+/** Bind the complete appearance publication to one renderer transaction. */
+export function createApplicationAppearanceRendererBinding(renderer, appearance) {
+    let paintedGeneration = null;
+    createEffect(() => {
+        const next = appearance.appearance();
+        paintedGeneration = applyApplicationAppearanceToRenderer(renderer, next.theme, next.generation, paintedGeneration);
+    });
+}