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

package/packages/daemon/dist/lib/fleet-lifecycle-authority.js

@@ -22,6 +22,7 @@ export class FleetLifecycleAuthority {
     #startedAt;
     #registry;
     #runTmux;
+    #ensureChromeUpdater;
     #readFleet;
     #operations = new Map();
     #tail = Promise.resolve();
@@ -30,6 +31,7 @@ export class FleetLifecycleAuthority {
         this.#productVersion = options.productVersion;
         this.#startedAt = options.startedAt;
         this.#registry = options.registry;
+        this.#ensureChromeUpdater = options.ensureChromeUpdater ?? true;
         this.#runTmux = options.runTmux;
         this.#readFleet = options.readFleet ?? (() => readAdoptedFleet(this.#registry));
     }
@@ -94,11 +96,13 @@ export class FleetLifecycleAuthority {
             prepareTmuxTruecolorEnvironment(this.#runTmux, identity.sessionName);
             this.#runTmux(["set-environment", "-t", identity.sessionName, "TMUX_IDE", "1"]);
             this.#runTmux(adoptMarkArgv(identity.sessionName));
-            try {
-                this.#runTmux(updaterProbeArgv());
-            }
-            catch {
-                this.#runTmux(updaterSpawnArgv());
+            if (this.#ensureChromeUpdater) {
+                try {
+                    this.#runTmux(updaterProbeArgv());
+                }
+                catch {
+                    this.#runTmux(updaterSpawnArgv());
+                }
             }
             if (!existing)
                 this.#registry.add({
@@ -268,11 +272,13 @@ export class FleetLifecycleAuthority {
             this.#runTmux(["set-option", "-p", "-t", paneId, "@agent_launch", input.command]);
             this.#runTmux(["set-option", "-p", "-t", paneId, "@agent_hint", input.harness]);
             this.#runTmux(["select-pane", "-t", paneId, "-T", input.displayTitle]);
-            try {
-                this.#runTmux(updaterProbeArgv());
-            }
-            catch {
-                this.#runTmux(updaterSpawnArgv());
+            if (this.#ensureChromeUpdater) {
+                try {
+                    this.#runTmux(updaterProbeArgv());
+                }
+                catch {
+                    this.#runTmux(updaterSpawnArgv());
+                }
             }
         }
         catch (error) {

package/packages/daemon/dist/lib/headless-daemon.js

@@ -1,3 +1,5 @@
+import { assertCanonicalDaemonServerIntent } from "./canonical-daemon-bootstrap.js";
+import { resolveTmuxServerIntent } from "./runtime-namespace.js";
 import { canonicalDaemonUrl, matchesCanonicalDaemonPredecessor, getCanonicalDaemonInfoPath, prepareCanonicalDaemonInfoForBootstrap, isCanonicalDaemonAlive, isCanonicalDaemonRecordOwnerProvenDead, probeCanonicalDaemonHealth, probeCanonicalDaemonIdentity, warnOnDaemonVersionSkew, } from "./canonical-daemon.js";
 import { DAEMON_WIRE_PROTOCOL_VERSION, isDaemonWireProtocolCompatible, } from "@tmux-ide/contracts";
 import { startEmbeddedDaemon, } from "./daemon-embed.js";
@@ -63,12 +65,15 @@ function assertIdentityMatches(info, identity) {
     }
 }
 async function assertAttachableDaemon(deps, info, options) {
-    const identity = await deps.probeCanonicalDaemonIdentity(info);
+    const identity = await deps.probeCanonicalDaemonIdentity(info, undefined, Boolean(options.tmuxServerIntent));
     if (!identity) {
         throw new IdeError(`Canonical daemon PID ${info.pid} is alive but its identity endpoint is unavailable. ` +
             "Refusing takeover.", { code: "DAEMON_IDENTITY_UNAVAILABLE", exitCode: 1 });
     }
     assertIdentityMatches(info, identity);
+    await assertCanonicalDaemonServerIntent(info, options.tmuxServerIntent ?? null, {
+        identity: async () => identity,
+    });
     const health = await deps.probeCanonicalDaemonHealth(info);
     if (!health) {
         throw new IdeError(`Canonical daemon PID ${info.pid} is alive but its health endpoint is unavailable. ` +
@@ -180,6 +185,10 @@ async function waitForCanonicalWinner(deps, options, timeoutMs = 15_000) {
  * action converge on the same idempotent EmbeddedDaemonHandle.stop() path.
  */
 export async function runHeadlessDaemon(options = {}, deps = defaultDependencies) {
+    options = {
+        ...options,
+        tmuxServerIntent: options.tmuxServerIntent === undefined ? resolveTmuxServerIntent() : options.tmuxServerIntent,
+    };
     let restoreTmuxWorkspaces = false;
     const lifecycle = {};
     while (true) {

package/packages/daemon/dist/lib/runtime-namespace.js

@@ -212,6 +212,7 @@ export function resolveRuntimeNamespace(options = {}) {
         controlSocketPath: join(runtimeDir, "control.sock"),
         eventLogPath: join(stateHome, "events.jsonl"),
         tmuxSocket,
+        tmuxSocketExplicit: Boolean(tmuxSocketName || tmuxSocketPath),
         cleanupToken,
         namespaceId: development?.id ?? (isolated ? cleanupToken : "canonical"),
         persistence: isolated && !development ? "ephemeral" : "durable",
@@ -238,9 +239,11 @@ export function runtimeNamespaceEnvironment(namespace) {
         [STATE_HOME_ENV]: namespace.stateHome,
         [REGISTRY_DIR_ENV]: namespace.registryDir,
         [DAEMON_INFO_DIR_ENV]: namespace.daemonInfoDir,
-        ...(namespace.tmuxSocket.kind === "name"
-            ? { [TMUX_SOCKET_NAME_ENV]: namespace.tmuxSocket.name }
-            : { [TMUX_SOCKET_PATH_ENV]: namespace.tmuxSocket.path }),
+        ...(namespace.tmuxSocketExplicit === false
+            ? {}
+            : namespace.tmuxSocket.kind === "name"
+                ? { [TMUX_SOCKET_NAME_ENV]: namespace.tmuxSocket.name }
+                : { [TMUX_SOCKET_PATH_ENV]: namespace.tmuxSocket.path }),
         ...(namespace.cleanupToken ? { [CLEANUP_TOKEN_ENV]: namespace.cleanupToken } : {}),
     });
 }
@@ -294,3 +297,14 @@ export function assertQualifiedDevelopmentLaunch() {
     if (resolveRuntimeNamespace().development)
         throw new Error("Development launch requires exact build artifacts (D03); installed CLI fallback is disabled");
 }
+/** Caller intent differs from the default used when starting a new owner. */
+export function resolveTmuxServerIntent(options = {}) {
+    const env = options.env ?? process.env;
+    const namespace = resolveRuntimeNamespace(options);
+    if (namespace.isolated ||
+        nonEmpty(env, TMUX_SOCKET_NAME_ENV) ||
+        nonEmpty(env, TMUX_SOCKET_PATH_ENV))
+        return { source: "explicit", selector: namespace.tmuxSocket };
+    const current = /^(.*),[0-9]+,[0-9]+$/u.exec(env.TMUX ?? "")?.[1];
+    return current ? { source: "current", selector: { kind: "path", path: current } } : null;
+}

package/packages/daemon/dist/lib/tmux-client-execution.js

@@ -0,0 +1,59 @@
+import { accessSync, constants, realpathSync, statSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import { resolveRuntimeNamespace } from "./runtime-namespace.js";
+import { resolveBundledTmux } from "./bundled-tmux.js";
+export function resolveTmuxExecutable() {
+    if (resolveRuntimeNamespace().development)
+        return resolveBundledTmux();
+    const configured = process.env.TMUX_IDE_TMUX_BIN;
+    if (!configured) {
+        const bundled = resolveBundledTmux();
+        if (bundled)
+            return bundled;
+    }
+    const candidates = configured
+        ? [configured]
+        : (process.env.PATH ?? "")
+            .split(delimiter)
+            // Empty and relative PATH entries mean the daemon/project cwd. They
+            // are never executable authority for a privileged tmux mutation.
+            .filter((entry) => entry.length > 0 && isAbsolute(entry))
+            .map((entry) => join(entry, "tmux"));
+    for (const candidate of candidates) {
+        try {
+            if (!isAbsolute(candidate))
+                continue;
+            accessSync(candidate, constants.X_OK);
+            const canonical = realpathSync(candidate);
+            if (statSync(canonical).isFile())
+                return canonical;
+        }
+        catch {
+            // Continue to the next daemon-start candidate.
+        }
+    }
+    throw new Error("tmux_executable_unavailable");
+}
+const SAFE_TERMINAL_VALUE = /^(?:xterm|screen|tmux|rxvt|vt100|ansi)[A-Za-z0-9+._-]{0,58}$/u;
+const SAFE_LOCALE_VALUE = /^[A-Za-z0-9][A-Za-z0-9_.@-]{0,127}$/u;
+/**
+ * The pinned tmux client receives only presentation metadata. Everything else
+ * is denied by omission: PATH/HOME/SHELL, TMUX/TMUX_PANE/TMUX_TMPDIR, shell
+ * startup hooks, dynamic-loader variables, Node options, and project secrets
+ * cannot redirect authority or inject code into this daemon-owned execution.
+ */
+export function tmuxClientEnvironment(source) {
+    const environment = {
+        TERM: SAFE_TERMINAL_VALUE.test(source.TERM ?? "") ? source.TERM : "xterm-256color",
+        // A pinned runner may be the first tmux client and therefore create the
+        // server. Never let a headless parent (`TERM=dumb`, `NO_COLOR=1`) become
+        // the global environment inherited by every later interactive child.
+        COLORTERM: "truecolor",
+    };
+    for (const name of ["LANG", "LC_ALL", "LC_CTYPE"]) {
+        const value = source[name];
+        if (value && SAFE_LOCALE_VALUE.test(value))
+            environment[name] = value;
+    }
+    return environment;
+}

package/packages/daemon/dist/lib/tmux-named-socket-fence.js

@@ -63,3 +63,7 @@ export function createNamedSocketFence(authority, executable, environment) {
         isPinned: () => shared.identity !== null,
     };
 }
+/** True only before this exact authority has observed any live socket. */
+export function isNamedSocketAuthorityUnbound(authority) {
+    return authority.socketSelector.kind === "name" && !states.get(authority)?.identity;
+}

package/packages/daemon/dist/lib/tmux-server-generation-runner.js

@@ -0,0 +1,62 @@
+import { randomUUID } from "node:crypto";
+import { createPinnedWorkspaceTmuxRunner, createPinnedWorkspaceTmuxAsyncRunner, } from "./workspace-pane-creation.js";
+import { shellEscape } from "./shell.js";
+/** Guard each command on the server which actually accepted this connection. */
+export function fenceNativeTmuxCommand(args, expected) {
+    const { pid, startTime } = expected;
+    if (!/^[1-9][0-9]*$/u.test(pid) || !/^[1-9][0-9]*$/u.test(startTime))
+        throw new Error("Invalid native tmux server identity");
+    if (args.length === 0 || args.some((arg) => arg.includes("\0")))
+        throw new Error("Invalid tmux command");
+    const globalFlags = [];
+    let firstCommand = 0;
+    while (args[firstCommand]?.startsWith("-")) {
+        const flag = args[firstCommand];
+        if (flag !== "-N" && flag !== "-u")
+            throw new Error("Unsupported tmux global option in generation-fenced command");
+        globalFlags.push(flag);
+        firstCommand += 1;
+    }
+    if (firstCommand === args.length)
+        throw new Error("Missing tmux command");
+    const condition = `#{&&:#{==:#{pid},${pid}},#{==:#{start_time},${startTime}}}`;
+    // Preserve arbitrary literal payloads; a standalone ; is the native argv
+    // command separator already used by the existing runners.
+    const command = args
+        .slice(firstCommand)
+        .map((arg) => (arg === ";" ? ";" : shellEscape(arg)))
+        .join(" ");
+    const refusal = `tmux-server-stale.${randomUUID()}`;
+    return {
+        argv: [...globalFlags, "if-shell", "-F", condition, command, `display-message -p '${refusal}'`],
+        verify(output) {
+            if (output.trimEnd() === refusal)
+                throw new Error("Tmux server generation changed before command execution");
+            return output;
+        },
+    };
+}
+/** Socket validation alone leaves a validation-to-connect replacement race. */
+export function createServerGenerationFencedTmuxRunner(authority, expected) {
+    const run = createPinnedWorkspaceTmuxRunner(authority, { timeoutMs: 5_000 });
+    const [pid, startTime] = expected
+        ? [expected.pid, expected.startTime]
+        : run(["display-message", "-p", "#{pid}\t#{start_time}"]).split("\t");
+    if (!pid || !startTime)
+        throw new Error("Invalid native tmux server identity");
+    const identity = { pid, startTime };
+    // Validate once before publishing an owner; each command rechecks natively.
+    fenceNativeTmuxCommand(["display-message", "-p", ""], identity);
+    return (args) => {
+        const command = fenceNativeTmuxCommand(args, identity);
+        return command.verify(run(command.argv));
+    };
+}
+export function createServerGenerationFencedTmuxAsyncRunner(authority, expected) {
+    const run = createPinnedWorkspaceTmuxAsyncRunner(authority);
+    fenceNativeTmuxCommand(["display-message", "-p", ""], expected);
+    return async (args, signal) => {
+        const command = fenceNativeTmuxCommand(args, expected);
+        return command.verify(await run(command.argv, signal));
+    };
+}

package/packages/daemon/dist/lib/tmux-server-owner.js

@@ -0,0 +1,285 @@
+import { createNativeTmuxSessionCreator } from "./tmux-server-session-create.js";
+import { createTmuxSessionMutationFence } from "./tmux-session-mutation-fence.js";
+import { createNativeTmuxSessionOpener } from "./tmux-server-session-open.js";
+import { randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { z } from "zod";
+import { isVisibleFleetSession } from "../command-center/discovery.js";
+import { WorkspaceTerminalInventoryRuntime } from "../terminal/attachments/native-runtime.js";
+import { createTmuxAgentStatusProbe } from "../terminal/attachments/agent-status-probe.js";
+import { createPaneStreamRuntime } from "../terminal/pane-stream/runtime.js";
+import { liveSessionIdForNativeIdentity } from "../terminal/protocol/live-session-identity.js";
+import { SessionRuntimeRegistry } from "../terminal/session-runtime/registry.js";
+import { createSessionRuntimeMultiplexerBackend } from "../terminal/session-runtime/multiplexer-backend.js";
+import { TmuxExternalInteractionObserver } from "./tmux-external-interaction-observer.js";
+import { WorkspaceMultiplexerAuthority } from "./workspace-multiplexer-verbs.js";
+import { WorkspacePaneCreationAuthority, } from "./workspace-pane-creation.js";
+import { WorkspaceRegistry } from "./workspace-registry.js";
+import { createServerGenerationFencedTmuxRunner, createServerGenerationFencedTmuxAsyncRunner, } from "./tmux-server-generation-runner.js";
+/** Refresh discovered live membership without changing durable workspace intent or aliases. */
+export function createNativeTmuxServerCatalog(workspaceRegistry, run, assertOpen = () => undefined) {
+    return async () => {
+        assertOpen();
+        const raw = await run([
+            "list-panes",
+            "-a",
+            "-F",
+            "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}\t#{pane_id}\t#{session_path}",
+        ], AbortSignal.timeout(2_000));
+        assertOpen();
+        const rows = new Map();
+        for (const line of raw.trim().split("\n")) {
+            const [pid, id, created, name, pane, dir] = line.split("\t");
+            if (!pid ||
+                !/^\d+$/.test(pid) ||
+                !id ||
+                !/^\$\d+$/.test(id) ||
+                !created ||
+                !/^\d+$/.test(created) ||
+                !name ||
+                !pane ||
+                !/^%\d+$/.test(pane) ||
+                !dir)
+                throw new Error("Invalid native server catalog");
+            if (!isVisibleFleetSession(name))
+                continue;
+            const liveSessionId = liveSessionIdForNativeIdentity(pid, id, created);
+            const row = rows.get(liveSessionId) ?? {
+                summary: { liveSessionId, sessionName: name, paneCount: 0 },
+                panes: new Set(),
+                dir,
+            };
+            row.panes.add(pane);
+            rows.set(liveSessionId, row);
+        }
+        const names = new Set([...rows.values()].map(({ summary }) => summary.sessionName));
+        for (const workspace of workspaceRegistry.list())
+            if (workspaceRegistry.isVolatile(workspace.name) && !names.has(workspace.sessionName))
+                workspaceRegistry.remove(workspace.name);
+        for (const { summary, dir } of rows.values())
+            if (!workspaceRegistry.has(summary.sessionName) &&
+                !workspaceRegistry.list().some((workspace) => workspace.sessionName === summary.sessionName))
+                workspaceRegistry.add({
+                    name: summary.sessionName,
+                    sessionName: summary.sessionName,
+                    projectDir: dir,
+                    persistence: "volatile",
+                });
+        return [...rows.values()].map(({ summary, panes }) => ({ ...summary, paneCount: panes.size }));
+    };
+}
+/** One proven server incarnation. Never elects an endpoint or changes ambient tmux authority. */
+export async function createNativeTmuxServerOwner(options) {
+    const generation = z.uuid().parse(options.generation);
+    const authority = options.tmuxAuthority;
+    if (authority.socketSelector.kind !== "path") {
+        throw new Error("A server owner requires a proven direct socket authority");
+    }
+    const socketPath = authority.socketSelector.path;
+    mkdirSync(options.stateDirectory, { recursive: true, mode: 0o700 });
+    const workspaceRegistry = new WorkspaceRegistry({
+        dir: options.stateDirectory,
+        listSessions: () => [],
+    });
+    const sessionMutationFence = createTmuxSessionMutationFence();
+    const generationRun = sessionMutationFence.wrap(createServerGenerationFencedTmuxRunner(authority, options.nativeServerIdentity));
+    const identityParts = generationRun(["display-message", "-p", "#{pid}\t#{start_time}"]).split("\t");
+    const nativeServerIdentity = options.nativeServerIdentity ?? {
+        pid: identityParts[0],
+        startTime: identityParts[1],
+    };
+    const generationRunAsync = createServerGenerationFencedTmuxAsyncRunner(authority, nativeServerIdentity);
+    const multiplexer = new WorkspaceMultiplexerAuthority({
+        daemonInstanceId: generation,
+        registry: workspaceRegistry,
+        tmuxAuthority: authority,
+        io: { runTmux: generationRun },
+    });
+    const paneCreation = new WorkspacePaneCreationAuthority({
+        daemonInstanceId: generation,
+        registry: workspaceRegistry,
+        tmuxAuthority: authority,
+        io: { runTmux: generationRun },
+    });
+    let disposed = false;
+    let disposePromise = null;
+    let observerStarted = null;
+    let receiptSequence = 0;
+    const assertOpen = () => {
+        if (disposed)
+            throw new Error("Tmux server owner is retired");
+    };
+    const sessionRuntimeRegistry = new SessionRuntimeRegistry({
+        generation,
+        semanticMutations: {
+            resolveSession: (name) => workspaceRegistry.get(name)?.sessionName ?? null,
+            execute: (operationId, intent, timing) => {
+                assertOpen();
+                if (intent.verb === "workspace.pane.read")
+                    return multiplexer.readPane(operationId, intent);
+                if (intent.verb === "workspace.window.link.select" ||
+                    intent.verb === "workspace.window.link.unlink" ||
+                    intent.verb === "workspace.pane.select") {
+                    return multiplexer.mutateWindowLink({ operationId, expectedDaemonInstanceId: generation, intent }, (session, action) => sessionRuntimeRegistry.executeWindowLinkAction(session, action));
+                }
+                return multiplexer.mutate({ operationId, expectedDaemonInstanceId: generation, intent }, timing);
+            },
+            publishReceipt: (receipt) => ({
+                ...receipt,
+                type: "interaction.receipt",
+                sequence: ++receiptSequence,
+            }),
+            traceAuthority: { generation, incarnation: null },
+        },
+        mirror: {
+            executable: authority.executablePath,
+            socketPath,
+            resolveSocketPath: () => generationRun(["display-message", "-p", "#{socket_path}"]),
+            nativeServerIdentity,
+            internalReadHookEmission: (pane, marker) => observer.internalReadHookEmission(pane, marker),
+        },
+    });
+    const terminalInventoryRuntime = new WorkspaceTerminalInventoryRuntime({
+        registry: workspaceRegistry,
+        sessionRuntimeRegistry,
+        tmuxAuthority: { ...authority, trustedCwd: options.stateDirectory, nativeServerIdentity },
+        agentStatusProbeFactory: ({ run }) => createTmuxAgentStatusProbe({ run }),
+        onInventory: (snapshot) => multiplexer.adoptPaneInventory(snapshot.panes),
+        onSessionInventory: (session, snapshot) => multiplexer.adoptSessionPaneInventory(session, snapshot?.panes ?? []),
+    });
+    const observer = new TmuxExternalInteractionObserver({
+        daemonInstanceId: generation,
+        internalReadOwnerToken: randomUUID(),
+        registry: workspaceRegistry,
+        tmuxAuthority: authority,
+        io: { runTmux: generationRunAsync },
+        onGap: () => terminalInventoryRuntime.invalidate(),
+        onObserved: ({ workspaceName, semanticPaneId, operationKind, operationId }) => operationId !== null &&
+            sessionRuntimeRegistry.observeTmuxInteraction({
+                workspaceName,
+                semanticPaneId,
+                operationKind,
+                operationId,
+            }),
+    });
+    const paneStreamRuntime = createPaneStreamRuntime({
+        daemonInstanceId: generation,
+        webSocketUrl: options.webSocketUrl,
+        sessionRuntimeRegistry,
+        semanticPaneCatalog: terminalInventoryRuntime.semanticPaneCatalog,
+    });
+    const backend = createSessionRuntimeMultiplexerBackend({
+        registry: sessionRuntimeRegistry,
+        resolveSession: (name) => workspaceRegistry.get(name)?.sessionName ?? null,
+    });
+    const catalog = createNativeTmuxServerCatalog(workspaceRegistry, generationRunAsync, assertOpen);
+    const sessionCreator = createNativeTmuxSessionCreator({
+        generation,
+        registry: workspaceRegistry,
+        run: generationRun,
+        assertOpen,
+    });
+    const sessionOpener = createNativeTmuxSessionOpener({
+        generation,
+        registry: workspaceRegistry,
+        run: generationRunAsync,
+        assertOpen,
+    });
+    const openSession = async (liveSessionId) => {
+        await catalog();
+        const result = await sessionOpener.openSession(liveSessionId);
+        terminalInventoryRuntime.invalidate();
+        return result;
+    };
+    const multiplexerBackend = {
+        mutate: async (...args) => {
+            assertOpen();
+            if (args[0].expectedDaemonInstanceId !== generation)
+                throw new Error("Tmux server generation mismatch");
+            await catalog();
+            observerStarted ??= observer.start();
+            await observerStarted;
+            assertOpen();
+            return backend.mutate(...args);
+        },
+    };
+    const dispose = () => {
+        if (disposePromise)
+            return disposePromise;
+        disposed = true;
+        disposePromise = (async () => {
+            await sessionOpener.dispose();
+            await sessionCreator.dispose();
+            await paneCreation.dispose();
+            try {
+                await paneStreamRuntime.dispose();
+            }
+            finally {
+                try {
+                    await observer.dispose();
+                }
+                finally {
+                    terminalInventoryRuntime.dispose();
+                    try {
+                        await multiplexer.dispose();
+                    }
+                    finally {
+                        await sessionRuntimeRegistry.dispose();
+                    }
+                }
+            }
+        })();
+        return disposePromise;
+    };
+    try {
+        await terminalInventoryRuntime.whenReady();
+        await catalog();
+    }
+    catch (error) {
+        await dispose();
+        throw error;
+    }
+    return {
+        serverId: options.serverId,
+        generation,
+        catalog,
+        openSession,
+        createSession: sessionCreator.createSession,
+        createSessionPane: async (liveSessionId, request) => {
+            assertOpen();
+            await catalog();
+            const sessionName = workspaceRegistry.get(request.intent.workspaceName)?.sessionName;
+            if (!sessionName)
+                throw new Error("Selected workspace is unavailable");
+            const result = await sessionMutationFence.execute({
+                liveSessionId,
+                sessionName,
+                run: generationRunAsync,
+                mutate: () => paneCreation.create(request),
+            });
+            terminalInventoryRuntime.invalidate();
+            return result;
+        },
+        mutateSession: async (liveSessionId, request, authenticatedHostClientId) => {
+            assertOpen();
+            await catalog();
+            const sessionName = workspaceRegistry.get(request.intent.workspaceName)?.sessionName;
+            if (!sessionName)
+                throw new Error("Selected workspace is unavailable");
+            observerStarted ??= observer.start();
+            await observerStarted;
+            return sessionMutationFence.execute({
+                liveSessionId,
+                sessionName,
+                run: generationRunAsync,
+                mutate: () => multiplexerBackend.mutate(request, authenticatedHostClientId, undefined, true),
+            });
+        },
+        workspaceRegistry,
+        multiplexerBackend,
+        sessionRuntimeRegistry,
+        terminalInventoryRuntime,
+        paneStreamRuntime,
+        dispose,
+    };
+}