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

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,

package/packages/daemon/src/command-center/tmux-server-native-backing.ts

@@ -0,0 +1,49 @@
+import { Hono } from "hono";
+import { TmuxServerScopeSchemaZ } from "@tmux-ide/contracts";
+import { TmuxServerScopeError, type TmuxServerOwners } from "../lib/tmux-server-owners.ts";
+import type { NativeTmuxServerOwner } from "../lib/tmux-server-owner.ts";
+import { mountTerminalNativeBackingRoute } from "./resources/terminal-native-backing-route.ts";
+
+/** Retain admission/coalescing limits for the lifetime of each independent owner. */
+export function mountTmuxServerNativeBackingRoute(
+  app: Hono,
+  options: {
+    scopedPath: string;
+    ownerToken: string | null;
+    owners: TmuxServerOwners<NativeTmuxServerOwner>;
+  },
+): void {
+  const routers = new WeakMap<NativeTmuxServerOwner, Hono>();
+  app.get(`${options.scopedPath}/native-backing/:workspaceName/:pane`, async (c) => {
+    const scope = TmuxServerScopeSchemaZ.safeParse({
+      serverId: c.req.param("serverId"),
+      generation: c.req.param("generation"),
+    });
+    if (!scope.success) return c.json({ status: "invalid" }, 400);
+    try {
+      return await options.owners.withOwner(scope.data, async (owner) => {
+        let router = routers.get(owner);
+        if (!router) {
+          router = new Hono();
+          mountTerminalNativeBackingRoute(router, {
+            ownerToken: options.ownerToken,
+            generation: owner.generation,
+            resolveSession: (workspace) =>
+              owner.workspaceRegistry.get(workspace)?.sessionName ?? null,
+            capture: (session, pane, expected) =>
+              owner.sessionRuntimeRegistry.captureNativeBacking(session, pane, expected),
+          });
+          routers.set(owner, router);
+        }
+        const url = new URL(c.req.url);
+        url.pathname = `/api/project/${encodeURIComponent(c.req.param("workspaceName"))}/terminal-native-backing/${encodeURIComponent(c.req.param("pane"))}`;
+        return await router.request(new Request(url, c.req.raw));
+      });
+    } catch (error) {
+      return c.json(
+        { status: error instanceof TmuxServerScopeError ? "retired" : "unavailable" },
+        error instanceof TmuxServerScopeError ? 409 : 503,
+      );
+    }
+  });
+}

package/packages/daemon/src/command-center/tmux-servers.ts

@@ -0,0 +1,468 @@
+import { mountTmuxServerNativeBackingRoute } from "./tmux-server-native-backing.ts";
+import { Hono, type Context } from "hono";
+import { streamSSE } from "hono/streaming";
+import { projectApplicationShellResource } from "./resources/application-shell.ts";
+import { fleetSessionIdForName } from "./resources/fleet-catalog.ts";
+import { z } from "zod";
+import {
+  TMUX_SERVERS_API_PATH,
+  PANE_STREAM_ISSUE_PATH,
+  TmuxServerIdSchemaZ,
+  TmuxServerScopeSchemaZ,
+  TmuxServersResourceSchemaZ,
+  TmuxServerSessionsResourceSchemaZ,
+  WorkspaceMultiplexerMutationRequestSchemaZ,
+  WorkspacePaneCreateMutationRequestSchemaZ,
+  WorkspaceSessionCreateArgumentsSchemaZ,
+} from "@tmux-ide/contracts";
+import {
+  TmuxServerOwners,
+  TmuxServerRegistrationSchemaZ,
+  TmuxServerScopeError,
+} from "../lib/tmux-server-owners.ts";
+import type { NativeTmuxServerOwner } from "../lib/tmux-server-owner.ts";
+import { WorkspaceMultiplexerError } from "../lib/workspace-multiplexer-verbs.ts";
+import { ownerBearerMatches } from "./owner-authority.ts";
+import { mountPaneStreamIssueRoute } from "./pane-stream-issue.ts";
+import { projectTerminalRuntimeInventory } from "./resources/terminal-runtime-inventory.ts";
+
+export interface TmuxServerRoutesOptions {
+  readonly ownerToken: string | null;
+  readonly owners: TmuxServerOwners<NativeTmuxServerOwner>;
+}
+const registrationSchema = TmuxServerRegistrationSchemaZ.omit({ serverId: true }).strict();
+const workspaceSchema = z
+  .string()
+  .min(1)
+  .max(160)
+  .refine((value) => !/[\0\r\n]/u.test(value));
+async function boundedJson(request: Request): Promise<unknown> {
+  if (!request.body) throw new TypeError("Missing body");
+  const reader = request.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  try {
+    for (;;) {
+      const next = await reader.read();
+      if (next.done) break;
+      size += next.value.byteLength;
+      if (size > 64 * 1024) {
+        void reader.cancel().catch(() => undefined);
+        throw new TypeError("Body too large");
+      }
+      chunks.push(next.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+}
+function failure(c: Context, error: unknown): Response {
+  if (error instanceof TmuxServerScopeError)
+    return c.json(
+      { error: { code: error.code } },
+      error.code === "not-found" ? 404 : error.code === "capacity" ? 429 : 409,
+    );
+  if (error instanceof WorkspaceMultiplexerError)
+    return c.json({ error: { code: error.code } }, 409);
+  if (error instanceof z.ZodError || error instanceof SyntaxError || error instanceof TypeError)
+    return c.json({ error: { code: "invalid-request" } }, 400);
+  return c.json({ error: { code: "server-unavailable" } }, 503);
+}
+/** Owner capability is mandatory even when the ordinary local HTTP surface is open. */
+export function mountTmuxServerRoutes(app: Hono, options: TmuxServerRoutesOptions): void {
+  const base = TMUX_SERVERS_API_PATH;
+  const authorize = async (c: Context, next: () => Promise<void>) => {
+    c.header("Cache-Control", "no-store");
+    if (!ownerBearerMatches(c.req.header("Authorization"), options.ownerToken))
+      return c.json({ error: { code: "owner-required" } }, 401);
+    await next();
+  };
+  app.use(base, authorize);
+  app.use(`${base}/*`, authorize);
+  const route = (work: (c: Context) => Promise<Response>) => async (c: Context) => {
+    try {
+      return await work(c);
+    } catch (error) {
+      return failure(c, error);
+    }
+  };
+  const scope = (c: Context) =>
+    TmuxServerScopeSchemaZ.parse({
+      serverId: c.req.param("serverId"),
+      generation: c.req.param("generation"),
+    });
+  app.get(
+    base,
+    route(async (c) =>
+      c.json(
+        TmuxServersResourceSchemaZ.parse({ version: 1, servers: await options.owners.refresh() }),
+      ),
+    ),
+  );
+  app.post(
+    base,
+    route(async (c) =>
+      c.json(
+        await options.owners.register(registrationSchema.parse(await boundedJson(c.req.raw))),
+        201,
+      ),
+    ),
+  );
+  app.delete(
+    `${base}/:serverId`,
+    route(async (c) => {
+      await options.owners.remove(TmuxServerIdSchemaZ.parse(c.req.param("serverId")));
+      return c.json({ removed: true });
+    }),
+  );
+  const scoped = `${base}/:serverId/:generation`;
+  mountTmuxServerNativeBackingRoute(app, {
+    scopedPath: scoped,
+    ownerToken: options.ownerToken,
+    owners: options.owners,
+  });
+  app.post(
+    `${scoped}/sessions/create`,
+    route(async (c) => {
+      const server = scope(c);
+      const request = z
+        .object({
+          operationId: z.uuid(),
+          expectedDaemonInstanceId: z.uuid(),
+          intent: WorkspaceSessionCreateArgumentsSchemaZ,
+        })
+        .strict()
+        .parse(await boundedJson(c.req.raw));
+      if (
+        request.expectedDaemonInstanceId !== server.generation ||
+        (request.intent.expectedDaemonInstanceId &&
+          request.intent.expectedDaemonInstanceId !== server.generation)
+      )
+        return c.json({ error: { code: "stale-generation" } }, 409);
+      return c.json(
+        await options.owners.withOwner(server, (owner) =>
+          owner.createSession(request.operationId, {
+            ...request.intent,
+            expectedDaemonInstanceId: server.generation,
+          }),
+        ),
+      );
+    }),
+  );
+  app.post(
+    `${scoped}/sessions/:liveSessionId/open`,
+    route(async (c) => {
+      const server = scope(c);
+      const result = await options.owners.withOwner(server, (owner) =>
+        owner.openSession(workspaceSchema.parse(c.req.param("liveSessionId"))),
+      );
+      return c.json({ version: 1, server, ...result });
+    }),
+  );
+  app.get(
+    `${scoped}/sessions`,
+    route(async (c) => {
+      const server = scope(c);
+      return c.json(
+        TmuxServerSessionsResourceSchemaZ.parse({
+          version: 1,
+          server,
+          sessions: await options.owners.withOwner(server, async (owner) => {
+            const sessions = await owner.catalog();
+            const workspaces = owner.workspaceRegistry.list();
+            return sessions.map((session) => {
+              const aliases = workspaces.filter(
+                (workspace) => workspace.sessionName === session.sessionName,
+              );
+              return { ...session, workspaceName: aliases.length === 1 ? aliases[0]!.name : null };
+            });
+          }),
+        }),
+      );
+    }),
+  );
+  app.get(
+    `${scoped}/inventory/:workspaceName`,
+    route(async (c) => {
+      const server = scope(c);
+      const workspaceName = workspaceSchema.parse(c.req.param("workspaceName"));
+      const resource = await options.owners.withOwner(server, async (owner) => {
+        const sessions = await owner.catalog();
+        const workspace = owner.workspaceRegistry.get(workspaceName);
+        if (!workspace) return null;
+        const expected = c.req.query("liveSessionId");
+        if (
+          expected &&
+          !sessions.some(
+            (row) => row.sessionName === workspace.sessionName && row.liveSessionId === expected,
+          )
+        )
+          throw new TmuxServerScopeError("stale-generation");
+        const snapshot = await owner.terminalInventoryRuntime.discoverTerminalRuntimeSession(
+          workspace.sessionName,
+          c.req.raw.signal,
+        );
+        return snapshot ? projectTerminalRuntimeInventory(snapshot, 0) : null;
+      });
+      return resource
+        ? c.json({ version: 1, server, resource })
+        : c.json({ error: { code: "workspace-not-found" } }, 404);
+    }),
+  );
+  app.get(
+    `${scoped}/catalog`,
+    route(async (c) => {
+      const server = scope(c);
+      const resource = await options.owners.withOwner(server, async (owner) => {
+        const sessions = await owner.catalog();
+        return {
+          intents: owner.workspaceRegistry.list().map((entry) => ({
+            workspaceName: entry.name,
+            sessionName: entry.sessionName,
+            source: "workspace",
+            availability: sessions.some((row) => row.sessionName === entry.sessionName)
+              ? "live"
+              : "stopped",
+          })),
+          liveSessions: sessions.map((row) => ({
+            sessionName: row.sessionName,
+            fleetSessionId: fleetSessionIdForName(row.sessionName),
+            paneCount: row.paneCount,
+          })),
+        };
+      });
+      return c.json({ version: 1, server, resource });
+    }),
+  );
+  app.get(
+    `${scoped}/application-shell/:workspaceName`,
+    route(async (c) => {
+      const server = scope(c);
+      const workspaceName = workspaceSchema.parse(c.req.param("workspaceName"));
+      const resource = await options.owners.withOwner(server, async (owner) => {
+        const sessions = await owner.catalog();
+        const workspace = owner.workspaceRegistry.get(workspaceName);
+        if (!workspace) return null;
+        if (
+          !sessions.some(
+            (row) =>
+              row.sessionName === workspace.sessionName &&
+              row.liveSessionId === c.req.query("liveSessionId"),
+          )
+        )
+          throw new TmuxServerScopeError("stale-generation");
+        const snapshot = await owner.terminalInventoryRuntime.discoverTerminalRuntimeSession(
+          workspace.sessionName,
+          c.req.raw.signal,
+        );
+        return snapshot ? projectApplicationShellResource(snapshot) : null;
+      });
+      return resource
+        ? c.json({ version: 1, server, resource })
+        : c.json({ error: { code: "workspace-not-found" } }, 404);
+    }),
+  );
+  // Subscribe before publishing ready: a topology change during the subsequent HTTP read
+  // invalidates that read. This shares the owner's retained mirror, never a new tmux client.
+  app.get(
+    `${scoped}/session-events/:workspaceName`,
+    route(async (c) => {
+      const server = scope(c);
+      const workspaceName = workspaceSchema.parse(c.req.param("workspaceName"));
+      const owner = await options.owners.withOwner(server, async (candidate) => {
+        const sessions = await candidate.catalog();
+        const workspace = candidate.workspaceRegistry.get(workspaceName);
+        if (
+          !workspace ||
+          !sessions.some(
+            (row) =>
+              row.sessionName === workspace.sessionName &&
+              row.liveSessionId === c.req.query("liveSessionId"),
+          )
+        )
+          throw new TmuxServerScopeError("stale-generation");
+        return candidate;
+      });
+      const workspace = owner.workspaceRegistry.get(workspaceName)!;
+      return streamSSE(c, async (stream) => {
+        let stopped = false;
+        let wake: (() => void) | null = null;
+        let revision = 0;
+        const dirty = () => {
+          revision++;
+          wake?.();
+        };
+        stream.onAbort(() => {
+          stopped = true;
+          wake?.();
+        });
+        const identity = await owner.sessionRuntimeRegistry.describeSessionAuthority(
+          workspace.sessionName,
+        );
+        let topology: string | null = null;
+        let sessionReplaced = false;
+        const subscription = await owner.sessionRuntimeRegistry.subscribeLayout(
+          workspace.sessionName,
+          () => undefined,
+          {
+            expectedRuntimeSessionId: identity.runtimeSessionId,
+            expectedSemanticPaneIds: identity.description.panes.map((pane) => pane.semanticPaneId),
+            onAuthority(snapshot) {
+              if (snapshot.windowLinks.liveSessionId !== c.req.query("liveSessionId")) {
+                sessionReplaced = true;
+                dirty();
+                return;
+              }
+              // Full replacement observes removed windows and retains no historical keys.
+              // Geometry, focus and active-link changes stay entirely on the pane stream.
+              const signature = JSON.stringify(
+                snapshot.layouts
+                  .map((layout) => [
+                    layout.semanticWindowId,
+                    layout.windowName,
+                    layout.panes.map((pane) => pane.semanticPaneId).sort(),
+                  ])
+                  .sort((a, b) => String(a[0]).localeCompare(String(b[0]))),
+              );
+              if (topology === signature) return;
+              topology = signature;
+              dirty();
+            },
+          },
+        );
+        try {
+          options.owners.current(server);
+          if (sessionReplaced) throw new TmuxServerScopeError("stale-generation");
+          await stream.writeSSE({
+            data: JSON.stringify({ version: 1, server, type: "ready", revision }),
+          });
+          let sent = revision;
+          let nextIdentityCheck = Date.now() + 5000;
+          while (!stopped) {
+            await new Promise<void>((resolve) => {
+              const timer = setTimeout(resolve, 1000);
+              wake = () => {
+                clearTimeout(timer);
+                resolve();
+              };
+              if (stopped || revision !== sent) wake();
+            });
+            wake = null;
+            if (stopped) break;
+            if (sessionReplaced) throw new TmuxServerScopeError("stale-generation");
+            options.owners.current(server);
+            if (Date.now() >= nextIdentityCheck) {
+              const sessions = await owner.catalog();
+              options.owners.current(server);
+              if (
+                !sessions.some(
+                  (row) =>
+                    row.sessionName === workspace.sessionName &&
+                    row.liveSessionId === c.req.query("liveSessionId"),
+                )
+              )
+                throw new TmuxServerScopeError("stale-generation");
+              nextIdentityCheck = Date.now() + 5000;
+            }
+            if (revision !== sent) {
+              sent = revision;
+              await stream.writeSSE({
+                data: JSON.stringify({ version: 1, server, type: "invalidate", revision }),
+              });
+            } else
+              await stream.writeSSE({
+                data: JSON.stringify({ version: 1, server, type: "heartbeat", revision }),
+              });
+          }
+        } catch {
+          if (!stopped)
+            await stream
+              .writeSSE({ data: JSON.stringify({ version: 1, server, type: "retired", revision }) })
+              .catch(() => undefined);
+        } finally {
+          await subscription.close();
+        }
+      });
+    }),
+  );
+  app.post(
+    `${scoped}/panes/create`,
+    route(async (c) => {
+      const server = scope(c);
+      const liveSessionId = workspaceSchema.parse(c.req.query("liveSessionId"));
+      const request = WorkspacePaneCreateMutationRequestSchemaZ.parse(await boundedJson(c.req.raw));
+      if (request.expectedDaemonInstanceId !== server.generation)
+        return c.json({ error: { code: "stale-generation" } }, 409);
+      return c.json(
+        await options.owners.withOwner(server, (owner) =>
+          owner.createSessionPane(liveSessionId, request),
+        ),
+      );
+    }),
+  );
+  app.post(
+    `${scoped}/mutations`,
+    route(async (c) => {
+      const server = scope(c);
+      const request = WorkspaceMultiplexerMutationRequestSchemaZ.parse(
+        await boundedJson(c.req.raw),
+      );
+      if (request.expectedDaemonInstanceId !== server.generation)
+        return c.json({ error: { code: "stale-generation" } }, 409);
+      const liveSessionId = c.req.query("liveSessionId");
+      const result = await options.owners.withOwner(server, (owner) =>
+        liveSessionId
+          ? owner.mutateSession(liveSessionId, request, c.req.header("X-Tmux-Ide-Host-Client-Id"))
+          : owner.multiplexerBackend.mutate(
+              request,
+              c.req.header("X-Tmux-Ide-Host-Client-Id"),
+              undefined,
+              true,
+            ),
+      );
+      return c.json(result);
+    }),
+  );
+  app.post(
+    `${scoped}/pane-streams/issue`,
+    route(async (c) => {
+      const server = scope(c);
+      return options.owners.withOwner(server, async (owner) => {
+        const sessions = await owner.catalog();
+        const liveSessionId = c.req.query("liveSessionId");
+        if (liveSessionId) {
+          const body = (await boundedJson(c.req.raw.clone())) as {
+            stream?: { workspaceName?: string };
+          };
+          const workspace = owner.workspaceRegistry.get(body.stream?.workspaceName ?? "");
+          if (
+            !workspace ||
+            !sessions.some(
+              (row) =>
+                row.sessionName === workspace.sessionName && row.liveSessionId === liveSessionId,
+            )
+          )
+            throw new TmuxServerScopeError("stale-generation");
+        }
+        const issueApp = new Hono();
+        mountPaneStreamIssueRoute(issueApp, {
+          daemonInstanceId: server.generation,
+          ownerToken: options.ownerToken,
+          workspaceRegistry: owner.workspaceRegistry,
+          backend: owner.paneStreamRuntime.coordinator,
+        });
+        const url = new URL(c.req.url);
+        url.pathname = PANE_STREAM_ISSUE_PATH;
+        url.search = "";
+        return await issueApp.request(new Request(url, c.req.raw));
+      });
+    }),
+  );
+}