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

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,13 +44,31 @@ async function dispatchOnHandle(handle, name, input) {
         ? result
         : null;
 }
-export function createFleetSession(input, name) {
+export function createFleetSession(input, name, server, options) {
     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,
+                ...(options?.includeLiveSessionId ? { includeLiveSessionId: true } : {}),
+                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,
+            ...(options?.includeLiveSessionId ? { includeLiveSessionId: true } : {}),
             expectedDaemonInstanceId: daemon.instanceId,
         });
     }
@@ -59,6 +78,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/guided-tour-coach.jsx

@@ -0,0 +1,54 @@
+/* @jsxImportSource @opentui/solid */
+import { Show } from "solid-js";
+import { TuiButton } from "../ui/button.jsx";
+import { clipTerminal } from "../terminal-text.js";
+import { GUIDED_TOUR_STEPS, guidedTourCopy, } from "./guided-tour.js";
+/** Non-modal coach: terminal interaction stays available throughout the tour. */
+export function GuidedTourCoach(props) {
+    const copy = () => guidedTourCopy(props.state.step, props.shortcuts);
+    const width = () => Math.max(1, props.width);
+    const primary = () => {
+        switch (props.state.step) {
+            case "welcome":
+                return { label: "Let's try it", run: props.onWelcomeRead };
+            case "practice":
+                return { label: "Create practice session", run: props.onCreatePractice };
+            case "split":
+            case "commands":
+                return { label: "Open commands", run: props.onOpenCommands };
+            case "theme":
+                return { label: "Choose theme", run: props.onOpenAppearance };
+            case "leave":
+                return { label: "Open Home", run: props.onOpenHome };
+            case "reopen":
+                return { label: "Reopen practice", run: props.onOpenPractice };
+            default:
+                return null;
+        }
+    };
+    return (<box id="guided-tour-coach" width={width()} height={props.height ?? 10} overflow="hidden" flexShrink={0} flexDirection="column" paddingX={1} backgroundColor={props.theme.roles.surfaces.panel}>
+      <text height={1} fg={props.theme.roles.text.primary}>
+        <strong>
+          {clipTerminal(`Learn tmux-ide · ${GUIDED_TOUR_STEPS.indexOf(props.state.step) + 1}/${GUIDED_TOUR_STEPS.length} · ${copy().title}`, Math.max(0, width() - 2))}
+        </strong>
+      </text>
+      <scrollbox flexGrow={1} width="100%">
+        <text fg={props.theme.roles.text.secondary}>{copy().body}</text>
+      </scrollbox>
+      <Show when={props.error}>
+        <text fg={props.theme.roles.text.primary}>{props.error}</text>
+      </Show>
+      <box flexDirection="row" flexWrap="wrap" flexShrink={0} gap={1}>
+        <Show when={props.state.practice && ["split", "focus", "resize"].includes(props.state.step)}>
+          <TuiButton theme={props.theme} label="Open practice" onPress={props.onOpenPractice} width={Math.min(Math.max(1, width() - 2), 17)}/>
+        </Show>
+        <Show when={props.onReplay && props.error}>
+          <TuiButton theme={props.theme} label="Restart tour" onPress={props.onReplay} width={Math.min(Math.max(1, width() - 2), 16)}/>
+        </Show>
+        <Show when={primary()}>
+          {(action) => (<TuiButton theme={props.theme} label={action().label} width={Math.min(Math.max(1, width() - 2), action().label.length + 4)} loading={props.busy} onPress={action().run}/>)}
+        </Show>
+        <TuiButton theme={props.theme} label={props.state.step === "complete" ? "Done" : "Pause tour"} width={Math.min(Math.max(1, width() - 2), 14)} variant="ghost" onPress={props.onPause}/>
+      </box>
+    </box>);
+}

package/packages/daemon/dist/tui/mirror/runtime/guided-tour-storage.js

@@ -0,0 +1,67 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { runtimeOwnedPath } from "../../../lib/runtime-namespace.js";
+import { stateHome } from "../../../lib/state-home.js";
+import { GUIDED_TOUR_STEPS, initialGuidedTourState } from "./guided-tour.js";
+export function guidedTourStatePath() {
+    return runtimeOwnedPath(join(stateHome(), "guided-tour.json"));
+}
+export function parseGuidedTourState(value) {
+    if (!value || typeof value !== "object")
+        return initialGuidedTourState();
+    const raw = value;
+    if (raw.version !== 1 ||
+        !GUIDED_TOUR_STEPS.includes(raw.step) ||
+        typeof raw.active !== "boolean")
+        return initialGuidedTourState();
+    let practice = null;
+    if (raw.practice && typeof raw.practice === "object") {
+        const p = raw.practice;
+        if ([p.machineId, p.serverId, p.generation, p.sessionId, p.sessionName].every((v) => typeof v === "string" && v.length > 0)) {
+            practice = {
+                machineId: p.machineId,
+                serverId: p.serverId,
+                generation: p.generation,
+                sessionId: p.sessionId,
+                sessionName: p.sessionName,
+            };
+        }
+    }
+    const step = raw.step;
+    return {
+        version: 1,
+        step: !practice && !["welcome", "practice", "complete"].includes(step) ? "practice" : step,
+        active: raw.active,
+        practice,
+    };
+}
+export function readGuidedTourState(path = guidedTourStatePath()) {
+    try {
+        return parseGuidedTourState(JSON.parse(readFileSync(path, "utf8")));
+    }
+    catch {
+        return initialGuidedTourState();
+    }
+}
+/** Atomic, best-effort persistence; failure must not prevent using terminals. */
+export function writeGuidedTourState(state, path = guidedTourStatePath()) {
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(temporary, JSON.stringify(state), { mode: 0o600 });
+        renameSync(temporary, path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        try {
+            rmSync(temporary, { force: true });
+        }
+        catch {
+            /* Best effort. */
+        }
+    }
+}

package/packages/daemon/dist/tui/mirror/runtime/guided-tour.js

@@ -0,0 +1,113 @@
+/** A small, action-driven tour. No timers and no mutations of terminal sessions. */
+export const GUIDED_TOUR_STEPS = [
+    "welcome",
+    "practice",
+    "split",
+    "focus",
+    "resize",
+    "commands",
+    "theme",
+    "leave",
+    "reopen",
+    "complete",
+];
+export function initialGuidedTourState() {
+    return { version: 1, step: "welcome", active: false, practice: null };
+}
+export function sameGuidedTourPractice(a, b) {
+    return (a !== null &&
+        a.machineId === b.machineId &&
+        a.serverId === b.serverId &&
+        a.generation === b.generation &&
+        a.sessionId === b.sessionId);
+}
+/** Call confirmation events only after an observed change, never on request dispatch. */
+export function reduceGuidedTour(state, event) {
+    if (event.type === "replay")
+        return { ...initialGuidedTourState(), active: true };
+    if (event.type === "pause")
+        return state.active ? { ...state, active: false } : state;
+    if (event.type === "start" || event.type === "resume") {
+        return state.step === "complete" ? state : { ...state, active: true };
+    }
+    if (event.type === "practice-created" && state.step === "practice") {
+        return { ...state, step: "split", practice: event.practice };
+    }
+    if (!state.active)
+        return state;
+    if (event.type === "practice-missing" && state.practice && state.step !== "complete") {
+        return { ...state, step: "practice", practice: null };
+    }
+    if (event.type === "welcome-read" && state.step === "welcome")
+        return { ...state, step: "practice" };
+    if ("practice" in event && !sameGuidedTourPractice(state.practice, event.practice))
+        return state;
+    const expected = {
+        split: "split-confirmed",
+        focus: "focus-confirmed",
+        resize: "resize-confirmed",
+        commands: "commands-opened",
+        theme: "theme-changed",
+        leave: "home-opened",
+        reopen: "reopened",
+    };
+    if (expected[state.step] !== event.type)
+        return state;
+    const step = GUIDED_TOUR_STEPS[GUIDED_TOUR_STEPS.indexOf(state.step) + 1];
+    return { ...state, step };
+}
+export function guidedTourCopy(step, keys = {}) {
+    const shortcut = (key) => (key ? ` (${key})` : "");
+    switch (step) {
+        case "welcome":
+            return {
+                title: "Meet tmux-ide",
+                body: "A machine can run several tmux servers. Each server has sessions; sessions contain windows, and windows contain terminal panes. Home brings agents across connected machines together.",
+            };
+        case "practice":
+            return {
+                title: "Your practice space",
+                body: "Create a separate local practice session. The tour leaves your existing sessions alone. You can pause now and resume from Home.",
+            };
+        case "split":
+            return {
+                title: "Make room",
+                body: `Split the practice pane${shortcut(keys.split)}. You can also find Split right in Commands${shortcut(keys.commands)}. The next step unlocks when the new pane appears.`,
+            };
+        case "focus":
+            return {
+                title: "Move between panes",
+                body: `Select the other practice pane by clicking it or using your pane navigation shortcut${shortcut(keys.focus)}. Each pane is an independent terminal.`,
+            };
+        case "resize":
+            return {
+                title: "Find a comfortable layout",
+                body: "Drag the divider between the practice panes. Continue working while tmux updates the layout; the tour advances after the changed dimensions arrive.",
+            };
+        case "commands":
+            return {
+                title: "Find an action",
+                body: `Open Commands${shortcut(keys.commands)} to discover actions and their current shortcuts. Close the palette when you are ready to continue.`,
+            };
+        case "theme":
+            return {
+                title: "Make it yours",
+                body: "Choose a different theme from Home. Automatic contrast correction improves hard-to-read terminal colors; you can turn it off in settings.",
+            };
+        case "leave":
+            return {
+                title: "Leave without losing work",
+                body: `Open Home${shortcut(keys.home)}. Your practice terminals keep running in tmux while you look at agents or other sessions.`,
+            };
+        case "reopen":
+            return {
+                title: "Pick up where you left off",
+                body: "Reopen your practice session. tmux keeps your terminals alive independently of which page or session you are viewing.",
+            };
+        case "complete":
+            return {
+                title: "Ready to explore",
+                body: "You have split, focused and resized panes, found commands, changed theme and returned to a running session. Your practice session remains available; close it when you are finished. Replay this tour from Home.",
+            };
+    }
+}

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/resize-terminal-pane.js

@@ -27,6 +27,10 @@ export async function resizeTerminalPane(expected, current, input, onFailure) {
         });
     };
     try {
+        // Geometry acquisition is itself a mutation of the ownership lease. A stale
+        // gesture must not take it from another client even when resize is refused.
+        if (!isCurrent())
+            return fail({ stage: "pre-dispatch", reason: "generation-replaced" });
         if (expected.client.ownsRuntimeAuthority?.("geometry") !== true) {
             let lease;
             try {

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/semantic-shell-viewport-resize.js

@@ -8,7 +8,7 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
     let applied = null;
     let pending = null;
     let desired = null;
-    let scopedFlight = false;
+    let scopedFlight = null;
     let scopedEpoch = 0;
     let authorityClient = null;
     let stopAuthority = null;
@@ -21,7 +21,8 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
     const drain = async () => {
         if (scopedFlight || disposed || authoritySuspended)
             return;
-        scopedFlight = true;
+        const flight = {};
+        scopedFlight = flight;
         try {
             while (desired && !disposed && !authoritySuspended) {
                 const owner = desired;
@@ -41,7 +42,7 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
                 if (disposed || !desired)
                     break;
                 if (epoch !== scopedEpoch)
-                    continue;
+                    break;
                 const stillDesired = desired.targets.some((entry) => targetKey(entry) === targetKey(target) && targetSize(entry) === targetSize(target));
                 if (outcome.status !== "applied") {
                     if (!stillDesired)
@@ -55,7 +56,8 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
             }
         }
         finally {
-            scopedFlight = false;
+            if (scopedFlight === flight)
+                scopedFlight = null;
         }
     };
     const sameAuthority = (left, right) => left.lane === right.lane &&
@@ -83,6 +85,7 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
                 pending = null;
                 desired = null;
                 scopedEpoch += 1;
+                scopedFlight = null;
                 scopedApplied.clear();
                 return;
             }
@@ -110,6 +113,7 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
                         pending = null;
                         scopedApplied.clear();
                         scopedEpoch += 1;
+                        scopedFlight = null;
                         if (!authoritySuspended)
                             retry?.();
                     }) ?? null;
@@ -130,6 +134,8 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
                 pending = null;
                 if (!desired || !sameAuthority(desired.identity, target)) {
                     scopedEpoch += 1;
+                    // A retired lane must not hold a replacement lane behind its receipt.
+                    scopedFlight = null;
                     scopedApplied.clear();
                 }
                 const retainedWindows = new Set(["", ...windows.map((window) => window.semanticWindowId)]);
@@ -156,6 +162,7 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
             if (desired) {
                 desired = null;
                 scopedEpoch += 1;
+                scopedFlight = null;
                 scopedApplied.clear();
                 applied = null;
                 pending = null;
@@ -186,6 +193,7 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
             stopAuthority = null;
             authorityClient = null;
             desired = null;
+            scopedFlight = null;
             scopedApplied.clear();
             applied = null;
             pending = null;

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,
                 ]

package/packages/daemon/dist/tui/mirror/workspace/terminal-window-strip.jsx

@@ -214,9 +214,10 @@ function agentStatus(status) {
  */
 export function TerminalWindowStrip(props) {
     const tabs = () => (typeof props.tabs === "function" ? props.tabs() : props.tabs);
-    const tabId = (tab) => tab.semanticWindowId ?? `window:${tab.index}`;
+    const tabId = (tab) => tab.linkId ?? tab.semanticWindowId ?? `window:${tab.index}`;
     const items = createMemo(() => tabs().map((tab) => ({
         id: tabId(tab),
+        disabled: tab.disabled,
         windowIndex: tab.index,
         title: tab.name,
         agentStatus: agentStatus(tab.status),

package/packages/daemon/src/command-center/actions/command-definitions.ts

@@ -48,6 +48,12 @@ const ACTION_COMMAND_METADATA: Record<ActionName, ActionCommandMetadata> = {
   "workspace.open.cancel": { label: "Cancel workspace handoff", category: "workspace" },
   "workspace.promote": { label: "Promote live session to workspace", category: "workspace" },
   "workspace.app-window.mutate": { label: "Mutate application window", category: "workspace" },
+  "workspace.window.link.select": { label: "Focus window link", category: "workspace" },
+  "workspace.window.link.unlink": {
+    label: "Unlink window",
+    category: "workspace",
+    dangerous: true,
+  },
   "workspace.window.split": { label: "Split pane", category: "workspace" },
   "workspace.window.kill": { label: "Close window", category: "workspace", dangerous: true },
   "workspace.pane.kill": { label: "Close pane", category: "workspace", dangerous: true },

package/packages/daemon/src/command-center/actions/errors.ts

@@ -72,6 +72,10 @@ export type ActionErrorCode =
   | "pane_not_found"
   | "window_not_found"
   | "ambiguous_target"
+  | "window_link_stale"
+  | "window_link_ambiguous"
+  | "window_link_session_mismatch"
+  | "window_link_backing_mismatch"
   | "last_window_refused"
   | "last_pane_refused"
   | "mutation_failed"

package/packages/daemon/src/command-center/actions/handlers/workspace-multiplexer.ts

@@ -84,6 +84,8 @@ function verbHandler<V extends WorkspaceMultiplexerVerb>(verb: V) {
   ): Promise<ActionResult<V>> => (await runVerb(verb, input, context, deps)) as ActionResult<V>;
 }
 
+export const workspaceWindowLinkSelectHandler = verbHandler("workspace.window.link.select");
+export const workspaceWindowLinkUnlinkHandler = verbHandler("workspace.window.link.unlink");
 export const workspaceWindowSplitHandler = verbHandler("workspace.window.split");
 export const workspaceWindowKillHandler = verbHandler("workspace.window.kill");
 export const workspacePaneKillHandler = verbHandler("workspace.pane.kill");

package/packages/daemon/src/command-center/actions/registry.ts

@@ -70,6 +70,8 @@ import {
   workspaceRenameHandler,
   workspaceSessionKillHandler,
   workspaceWindowKillHandler,
+  workspaceWindowLinkSelectHandler,
+  workspaceWindowLinkUnlinkHandler,
   workspaceWindowSplitHandler,
 } from "./handlers/workspace-multiplexer.ts";
 
@@ -301,6 +303,18 @@ export const actionRegistry: RegistryShape = {
     handler: (input) => workspacePaneZoomToggleHandler(input),
     handlerWithContext: workspacePaneZoomToggleHandler,
   },
+  "workspace.window.link.select": {
+    inputSchema: ActionContractsZ["workspace.window.link.select"].input,
+    resultSchema: ActionContractsZ["workspace.window.link.select"].result,
+    handler: (input) => workspaceWindowLinkSelectHandler(input),
+    handlerWithContext: workspaceWindowLinkSelectHandler,
+  },
+  "workspace.window.link.unlink": {
+    inputSchema: ActionContractsZ["workspace.window.link.unlink"].input,
+    resultSchema: ActionContractsZ["workspace.window.link.unlink"].result,
+    handler: (input) => workspaceWindowLinkUnlinkHandler(input),
+    handlerWithContext: workspaceWindowLinkUnlinkHandler,
+  },
   "workspace.pane.select": {
     inputSchema: ActionContractsZ["workspace.pane.select"].input,
     resultSchema: ActionContractsZ["workspace.pane.select"].result,

package/packages/daemon/src/command-center/discovery.ts

@@ -1,6 +1,6 @@
+import { liveSessionIdForNativeIdentity } from "../terminal/protocol/live-session-identity.ts";
 import { runtimeTmuxArgs } from "../lib/runtime-namespace.ts";
 import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
 import { listSessionPanes } from "../widgets/lib/pane-comms.ts";
 import type { PaneInfo } from "@tmux-ide/contracts";
 import { getDefaultWorkspaceRegistry } from "../lib/workspace-registry.ts";
@@ -80,14 +80,6 @@ export interface LiveSessionSummary {
   readonly paneCount: number;
 }
 
-function liveSessionId(serverPid: string, sessionId: string, sessionCreated: string) {
-  const digest = createHash("sha256")
-    .update(`${serverPid}\0${sessionId}\0${sessionCreated}`)
-    .digest("hex")
-    .slice(0, 20);
-  return `live-session.${digest}` as const;
-}
-
 /**
  * Enumerate observed tmux truth without consulting the workspace registry.
  *
@@ -120,7 +112,7 @@ export function discoverLiveSessionSummaries(
     if (!/^\d+$/u.test(serverPid) || !/^\$\d+$/u.test(sessionId) || !/^\d+$/u.test(sessionCreated))
       continue;
     if (!sessionName || !isVisibleFleetSession(sessionName)) continue;
-    const identity = liveSessionId(serverPid, sessionId, sessionCreated);
+    const identity = liveSessionIdForNativeIdentity(serverPid, sessionId, sessionCreated);
     const previous = sessions.get(identity);
     sessions.set(identity, {
       liveSessionId: identity,

package/packages/daemon/src/command-center/server.ts

@@ -1,3 +1,4 @@
+import { mountTmuxServerRoutes } from "./tmux-servers.ts";
 import { streamBoundedLogs } from "./log-stream.ts";
 import { mountWorkspaceAdmissionRoute } from "./resources/workspace-admission-route.ts";
 import { mountFleetPreviewRoute } from "./resources/fleet-preview-route.ts";
@@ -162,6 +163,11 @@ import {
 } from "./resources/startup-readiness-route.ts";
 import { readWidgetAsset } from "../lib/widget-asset-store.ts";
 export interface CreateAppOptions {
+  tmuxServerOwners?: import("../lib/tmux-server-owners.ts").TmuxServerOwners<
+    import("../lib/tmux-server-owner.ts").NativeTmuxServerOwner
+  >;
+  /** Fresh, credential-free proof of this owner's pinned tmux server. */
+  tmuxServerProof?: () => Promise<import("../lib/tmux-server-proof.ts").TmuxServerProof | null>;
   authService?: AuthService;
   authConfig?: AuthConfig;
   remoteAccess?: {
@@ -533,6 +539,12 @@ export function createApp(options: CreateAppOptions = {}): Hono {
   // Allow cross-origin (Next.js dashboard, Tailscale, etc.)
   app.use("/*", cors());
 
+  if (options.tmuxServerOwners)
+    mountTmuxServerRoutes(app, {
+      ownerToken: options.remoteAccess?.ownerToken ?? null,
+      owners: options.tmuxServerOwners,
+    });
+
   // Owner-only reads use the same early routing boundary as issuance below:
   // remote/project credentials neither authorize nor block the owner bearer.
   mountDiagnosticsRoute(app, {
@@ -743,10 +755,26 @@ export function createApp(options: CreateAppOptions = {}): Hono {
   // Credential-free endpoint binding. A desktop host reads the nonce from the
   // owner-only canonical record, probes this endpoint, and compares before it
   // sends any remote-access or local-bypass credential.
-  app.get("/identity", (c) => {
+  // Coalesce concurrent probes, but never reuse a completed server proof.
+  let pendingTmuxProof: Promise<
+    import("../lib/tmux-server-proof.ts").TmuxServerProof | null
+  > | null = null;
+  app.get("/identity", async (c) => {
+    const wantsTmuxProof = c.req.query("tmuxServerProof") === "1";
+    let tmuxServerProof = null;
+    if (wantsTmuxProof && options.tmuxServerProof) {
+      pendingTmuxProof ??= Promise.resolve()
+        .then(options.tmuxServerProof)
+        .catch(() => null)
+        .finally(() => {
+          pendingTmuxProof = null;
+        });
+      tmuxServerProof = await pendingTmuxProof;
+    }
     return c.json({
       ok: true,
       pid: process.pid,
+      ...(wantsTmuxProof && options.tmuxServerProof ? { tmuxServerProof } : {}),
       protocolVersion: DAEMON_WIRE_PROTOCOL_VERSION,
       productVersion: daemonIdentity.productVersion,
       instanceId: daemonIdentity.instanceId,