tmux-ide 2.9.5 → 2.9.6

package/packages/daemon/dist/command-center/tmux-servers.js

@@ -1,11 +1,13 @@
+import { WindowSplitLayoutUnavailable } from "../terminal/mirror/window-split-authority.js";
 import { streamTmuxInteractions } from "./tmux-server-interaction-events.js";
 import { mountTmuxServerNativeBackingRoute } from "./tmux-server-native-backing.js";
+import { mountTmuxServerEditorContextRoute } from "./tmux-server-editor-context.js";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { projectApplicationShellResource } from "./resources/application-shell.js";
 import { fleetSessionIdForName } from "./resources/fleet-catalog.js";
 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 { TmuxAgentOpenRequestSchemaZ, TmuxAgentOpenResponseSchemaZ, WorkspaceCatalogLiveSessionIdSchemaZ, WindowLinkTargetSchemaZ, WindowSplitLayoutResourceSchemaZ, TMUX_SERVERS_API_PATH, PANE_STREAM_ISSUE_PATH, TmuxServerIdSchemaZ, TmuxServerScopeSchemaZ, TmuxServersResourceSchemaZ, TmuxServerSessionsResourceSchemaZ, WorkspaceMultiplexerMutationRequestSchemaZ, WorkspacePaneCreateMutationRequestSchemaZ, WorkspaceSessionCreateArgumentsSchemaZ, } from "@tmux-ide/contracts";
 import { TmuxServerRegistrationSchemaZ, TmuxServerScopeError, } from "../lib/tmux-server-owners.js";
 import { WorkspaceMultiplexerError } from "../lib/workspace-multiplexer-verbs.js";
 import { ownerBearerMatches } from "./owner-authority.js";
@@ -17,7 +19,7 @@ const workspaceSchema = z
     .min(1)
     .max(160)
     .refine((value) => !/[\0\r\n]/u.test(value));
-async function boundedJson(request) {
+async function boundedJson(request, limit = 64 * 1024) {
     if (!request.body)
         throw new TypeError("Missing body");
     const reader = request.body.getReader();
@@ -29,7 +31,7 @@ async function boundedJson(request) {
             if (next.done)
                 break;
             size += next.value.byteLength;
-            if (size > 64 * 1024) {
+            if (size > limit) {
                 void reader.cancel().catch(() => undefined);
                 throw new TypeError("Body too large");
             }
@@ -48,6 +50,8 @@ async function boundedJson(request) {
     return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
 }
 function failure(c, error) {
+    if (error instanceof WindowSplitLayoutUnavailable)
+        return c.json({ error: { code: "split-layout-stale" } }, 409);
     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)
@@ -86,6 +90,25 @@ export function mountTmuxServerRoutes(app, options) {
         return c.json({ removed: true });
     }));
     const scoped = `${base}/:serverId/:generation`;
+    mountTmuxServerEditorContextRoute(app, {
+        scopedPath: scoped,
+        owners: options.owners,
+        readBody: (request) => boundedJson(request, 8 * 1024),
+    });
+    // Structured read only: this never acquires a channel or changes tmux geometry.
+    app.post(`${scoped}/split-layout/:workspaceName`, route(async (c) => {
+        const server = scope(c);
+        const workspaceName = workspaceSchema.parse(c.req.param("workspaceName"));
+        const target = WindowLinkTargetSchemaZ.parse(await boundedJson(c.req.raw));
+        c.req.raw.signal.throwIfAborted();
+        const resource = await options.owners.withOwner(server, (owner) => owner.readWindowSplitLayout(workspaceName, target));
+        c.req.raw.signal.throwIfAborted();
+        return c.json({
+            version: 1,
+            server,
+            resource: WindowSplitLayoutResourceSchemaZ.parse(resource),
+        });
+    }));
     app.get(`${scoped}/interaction-events`, route(async (c) => {
         const server = scope(c);
         const raw = c.req.query("after") ?? "0";
@@ -126,6 +149,17 @@ export function mountTmuxServerRoutes(app, options) {
             expectedDaemonInstanceId: server.generation,
         })));
     }));
+    app.post(`${scoped}/sessions/:liveSessionId/open-agent`, route(async (c) => {
+        const server = scope(c);
+        const liveSessionId = WorkspaceCatalogLiveSessionIdSchemaZ.parse(c.req.param("liveSessionId"));
+        const target = TmuxAgentOpenRequestSchemaZ.parse(await boundedJson(c.req.raw, 8192));
+        c.req.raw.signal.throwIfAborted();
+        const result = await options.owners.withOwner(server, (owner) => owner.openAgent(liveSessionId, target));
+        c.req.raw.signal.throwIfAborted();
+        if (result.liveSessionId !== liveSessionId)
+            return c.json({ error: { code: "stale-agent" } }, 409);
+        return c.json(TmuxAgentOpenResponseSchemaZ.parse({ version: 1, server, ...result }));
+    }));
     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"))));

package/packages/daemon/dist/command-center/ws-events.js

@@ -581,9 +581,13 @@ export function handleWsEventsConnection(socket, daemonIdentity, options = {}) {
     const subscribe = (sessionName, sendInitialSnapshot) => {
         if (subscriptions.has(sessionName))
             return;
-        const session = discoverSessions().find((s) => s.name === sessionName);
         subscriptions.add(sessionName);
-        if (session && sendInitialSnapshot && legacyDeliveryEnabled) {
+        if (sendInitialSnapshot && legacyDeliveryEnabled) {
+            // Semantic subscriptions use resource interests, not legacy snapshots.
+            // Avoid a synchronous full-fleet scan for every subscribed session.
+            const session = discoverSessions().find((s) => s.name === sessionName);
+            if (!session)
+                return;
             const data = buildSessionSnapshot(sessionName);
             if (data) {
                 send({ type: "snapshot", sessionName, data });

package/packages/daemon/dist/lib/canonical-split-mutation.js

@@ -0,0 +1,37 @@
+import { WorkspaceMultiplexerIntentSchemaZ, WorkspaceMultiplexerMutationResultSchemaZ, } from "@tmux-ide/contracts";
+import { WorkspaceMultiplexerError } from "./workspace-multiplexer-verbs.js";
+/** Only the authenticated geometry execution lane may call this adapter. */
+export async function executeCanonicalSplitMutation(options, operationId, input, authorizeBeforeEffect) {
+    const intent = WorkspaceMultiplexerIntentSchemaZ.parse(input);
+    if (intent.verb !== "workspace.window.split.resize")
+        throw new TypeError("Expected split resize");
+    if (!authorizeBeforeEffect)
+        throw new WorkspaceMultiplexerError("workspace_unavailable");
+    const session = options.resolveSession(intent.workspaceName);
+    if (!session)
+        throw new WorkspaceMultiplexerError("workspace_unavailable");
+    const authorize = () => {
+        if (options.resolveSession(intent.workspaceName) !== session)
+            throw new WorkspaceMultiplexerError("workspace_unavailable");
+        authorizeBeforeEffect();
+    };
+    authorize();
+    const resource = await options.registry.readWindowSplitLayout(session, intent.target.window);
+    const split = resource.splits.find((row) => row.splitId === intent.target.splitId);
+    if (!split || resource.layoutId !== intent.target.layoutId)
+        throw new WorkspaceMultiplexerError("workspace_unavailable");
+    const result = await options.registry.resizeWindowSplit(session, intent.target, operationId, authorize, options.runNative);
+    if (result.status !== "applied")
+        throw new WorkspaceMultiplexerError(result.status === "uncertain" ? "mutation_unverified" : "workspace_unavailable");
+    return WorkspaceMultiplexerMutationResultSchemaZ.parse({
+        operationId,
+        daemonInstanceId: options.generation,
+        workspaceName: intent.workspaceName,
+        verb: intent.verb,
+        outcome: result.changed ? "applied" : "unchanged",
+        target: intent.target,
+        axis: split.axis,
+        boundary: result.boundary,
+        successor: result.successor ?? null,
+    });
+}

package/packages/daemon/dist/lib/daemon-connection-owner.js

@@ -0,0 +1,333 @@
+import { createRuntimeConnectionSupervisor, } from "@tmux-ide/daemon-client/connection-supervisor";
+import { fleetReconnectBackoff, } from "@tmux-ide/daemon-client/fleet-dial-scheduler";
+import { watch } from "node:fs";
+import { basename, dirname } from "node:path";
+import { getCanonicalDaemonInfoPath, isCanonicalDaemonAlive, readCanonicalDaemonInfo, } from "./canonical-daemon.js";
+import { SshConnectionError, openSshDaemonTransport, probeSshDaemonIdentity, } from "./ssh-daemon-transport.js";
+const defaults = {
+    readLocal: readCanonicalDaemonInfo,
+    isLocalAlive: isCanonicalDaemonAlive,
+    async observeLocal(listener) {
+        const path = getCanonicalDaemonInfoPath();
+        let stopped = false;
+        let queued = false;
+        const watcher = watch(dirname(path), (_event, file) => {
+            if (stopped || queued || (file !== null && file.toString() !== basename(path)))
+                return;
+            queued = true;
+            queueMicrotask(() => {
+                queued = false;
+                const generation = readCanonicalDaemonInfo()?.instanceId;
+                if (!stopped && generation)
+                    listener(generation);
+            });
+        });
+        watcher.on("error", () => watcher.close());
+        return () => {
+            stopped = true;
+            watcher.close();
+        };
+    },
+    connect: openSshDaemonTransport,
+    verify: probeSshDaemonIdentity,
+};
+function monitorConnection(connection, dependencies, onLost) {
+    const verify = dependencies.verify;
+    if (!verify)
+        return () => { };
+    let stopped = false;
+    let failures = 0;
+    let active = null;
+    let timer = null;
+    const check = async () => {
+        if (stopped)
+            return;
+        const attempt = new AbortController();
+        active = attempt;
+        const deadline = setTimeout(() => attempt.abort(), dependencies.probeTimeoutMs ?? 1500);
+        let valid = false;
+        try {
+            // fetch cancellation bounds response reading as well as establishing the socket.
+            valid = await verify(connection.baseUrl, connection.daemon, attempt.signal);
+        }
+        catch {
+            /* A transient network failure gets one further probe before retirement. */
+        }
+        finally {
+            clearTimeout(deadline);
+            active = null;
+        }
+        if (stopped)
+            return;
+        failures = valid && !attempt.signal.aborted ? 0 : failures + 1;
+        if (failures >= 2) {
+            stopped = true;
+            onLost();
+            return;
+        }
+        timer = setTimeout(() => void check(), dependencies.probeIntervalMs ?? 2000);
+    };
+    timer = setTimeout(() => void check(), dependencies.probeIntervalMs ?? 2000);
+    return () => {
+        stopped = true;
+        if (timer !== null)
+            clearTimeout(timer);
+        active?.abort();
+    };
+}
+/** Owns one machine's authority and its single initial/reconnect lifecycle. */
+export function createDaemonConnectionOwner(dependencies = defaults, onStatus) {
+    let kind = "local";
+    let label = null;
+    let state = "ready";
+    let epoch = 0;
+    let connection = null;
+    let descriptor = null;
+    let remote = null;
+    let supervisor = null;
+    let stopped = false;
+    let paused = false;
+    let controlRevision = 0;
+    let diagnostic = {
+        phase: "ready",
+        attempt: 0,
+        nextRetryAt: null,
+        failure: null,
+    };
+    const statusListeners = new Set();
+    const updateStatus = (next) => {
+        diagnostic = Object.freeze(next);
+        try {
+            onStatus?.({
+                machine: label,
+                ...next,
+                instanceId: remote?.instanceId ?? null,
+                pid: remote?.pid ?? null,
+                port: remote?.port ?? null,
+            });
+        }
+        catch {
+            // Telemetry observers cannot interrupt connection ownership or cleanup.
+        }
+        for (const listener of statusListeners) {
+            try {
+                listener();
+            }
+            catch {
+                /* UI observers do not own transport lifetime. */
+            }
+        }
+    };
+    let removeParentAbort = null;
+    let rejectInitial = null;
+    const listeners = new Set();
+    const notify = (generation) => {
+        for (const listener of listeners) {
+            try {
+                listener(generation);
+            }
+            catch {
+                /* Observers do not own transport lifetime. */
+            }
+        }
+    };
+    let releaseConnection = null;
+    const retire = () => {
+        const release = releaseConnection;
+        releaseConnection = null;
+        connection = null;
+        descriptor = null;
+        remote = null;
+        state = "disconnected";
+        epoch++;
+        notify(null);
+        release?.();
+    };
+    const dispose = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        controlRevision++;
+        removeParentAbort?.();
+        removeParentAbort = null;
+        rejectInitial?.(new Error("SSH connection cancelled"));
+        rejectInitial = null;
+        if (kind === "ssh")
+            retire();
+        void supervisor?.stop();
+        updateStatus({ phase: "disconnected", attempt: 0, nextRetryAt: null, failure: null });
+        statusListeners.clear();
+    };
+    return {
+        read() {
+            return kind === "local" ? dependencies.readLocal() : descriptor;
+        },
+        async isAlive(info) {
+            if (kind === "local")
+                return dependencies.isLocalAlive(info);
+            return (state === "ready" &&
+                descriptor !== null &&
+                info.instanceId === descriptor.instanceId &&
+                info.startedAt === descriptor.startedAt &&
+                info.port === descriptor.port &&
+                info.bindHostname === descriptor.bindHostname);
+        },
+        endpoint() {
+            return Object.freeze({
+                kind,
+                label,
+                remote,
+                localBaseUrl: connection?.baseUrl ?? null,
+                epoch,
+                state,
+                diagnostic,
+            });
+        },
+        async observe(listener) {
+            if (kind === "local")
+                return dependencies.observeLocal(listener);
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        observeConnection(listener) {
+            statusListeners.add(listener);
+            return () => {
+                statusListeners.delete(listener);
+            };
+        },
+        disconnect() {
+            if (kind !== "ssh" || stopped)
+                return;
+            paused = true;
+            controlRevision++;
+            rejectInitial?.(new Error("SSH connection cancelled"));
+            rejectInitial = null;
+            retire();
+            void supervisor?.stop();
+            updateStatus({ phase: "disconnected", attempt: 0, nextRetryAt: null, failure: null });
+        },
+        async retry() {
+            if (kind !== "ssh" || stopped || !supervisor)
+                return;
+            const revision = ++controlRevision;
+            paused = true;
+            retire();
+            await supervisor.stop();
+            if (stopped || revision !== controlRevision)
+                return;
+            paused = false;
+            supervisor.start();
+        },
+        async initialize(alias, parentSignal, options = {}) {
+            if (kind !== "local" || stopped)
+                throw new Error("Application machine authority is already selected");
+            kind = "ssh";
+            label = alias;
+            state = "connecting";
+            epoch++;
+            const initial = new Promise((resolve, reject) => {
+                rejectInitial = reject;
+                supervisor = createRuntimeConnectionSupervisor({
+                    retryable: (error) => !(error instanceof SshConnectionError) || error.retryable,
+                    backoffMs: (attempt) => {
+                        const delay = dependencies.retryDelayMs ?? options.retryDelayMs ?? fleetReconnectBackoff(attempt);
+                        if (!stopped && !paused)
+                            updateStatus({
+                                ...diagnostic,
+                                phase: "reconnecting",
+                                attempt,
+                                nextRetryAt: Date.now() + delay,
+                            });
+                        return delay;
+                    },
+                    connect: async ({ signal, attempt }) => {
+                        if (stopped || paused || signal.aborted)
+                            throw new Error("SSH connection cancelled");
+                        state = "connecting";
+                        updateStatus({ phase: "connecting", attempt, nextRetryAt: null, failure: null });
+                        let next;
+                        try {
+                            const connect = () => dependencies.connect({ alias, signal });
+                            next = options.scheduler
+                                ? await options.scheduler.run(alias, signal, connect, (late) => late.dispose())
+                                : await connect();
+                            if (options.expectedEnvironmentId &&
+                                next.daemon.environmentId !== options.expectedEnvironmentId) {
+                                next.dispose();
+                                throw new SshConnectionError("Imported environment identity does not match the authenticated daemon", "identity-mismatch");
+                            }
+                        }
+                        catch (error) {
+                            if (!stopped && !paused) {
+                                state = "disconnected";
+                                updateStatus({
+                                    phase: error instanceof SshConnectionError && !error.retryable
+                                        ? "needs-attention"
+                                        : "reconnecting",
+                                    attempt,
+                                    nextRetryAt: null,
+                                    failure: error instanceof SshConnectionError ? error.code : "unavailable",
+                                });
+                            }
+                            rejectInitial?.(error);
+                            rejectInitial = null;
+                            throw error;
+                        }
+                        if (stopped || paused || signal.aborted) {
+                            next.dispose();
+                            throw new Error("SSH connection cancelled");
+                        }
+                        const endpoint = new URL(next.baseUrl);
+                        remote = Object.freeze({ ...next.daemon });
+                        descriptor = Object.freeze({
+                            ...next.daemon,
+                            bindHostname: "127.0.0.1",
+                            port: Number(endpoint.port),
+                        });
+                        connection = next;
+                        state = "ready";
+                        epoch++;
+                        let close;
+                        const closed = new Promise((done) => {
+                            close = done;
+                        });
+                        let released = false;
+                        let stopMonitor = null;
+                        const release = () => {
+                            if (released)
+                                return;
+                            released = true;
+                            stopMonitor?.();
+                            next.dispose();
+                            close();
+                        };
+                        const lost = () => {
+                            if (!released && connection === next)
+                                retire();
+                        };
+                        releaseConnection = release;
+                        void next.closed.then(lost, lost);
+                        stopMonitor = monitorConnection(next, dependencies, lost);
+                        notify(descriptor.instanceId);
+                        if (!stopped && !paused)
+                            updateStatus({ phase: "ready", attempt: 0, nextRetryAt: null, failure: null });
+                        rejectInitial = null;
+                        resolve();
+                        return { value: next, closed, dispose: release };
+                    },
+                });
+            });
+            const abort = () => dispose();
+            parentSignal?.addEventListener("abort", abort, { once: true });
+            removeParentAbort = () => parentSignal?.removeEventListener("abort", abort);
+            if (parentSignal?.aborted)
+                abort();
+            if (!stopped)
+                supervisor.start();
+            return initial;
+        },
+        dispose,
+    };
+}

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

@@ -6,6 +6,11 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+import { createNativeSplitCapabilityProbe, createNativeSplitReadiness, } from "./native-split-capability.js";
+import { executeCanonicalSplitMutation } from "./canonical-split-mutation.js";
+import { createGuardedNativeSplitResize } from "./guarded-native-split-resize.js";
+import { WindowLinkTargetSchemaZ } from "@tmux-ide/contracts";
+import { WindowSplitLayoutUnavailable } from "../terminal/mirror/window-split-authority.js";
 import { requireSupportedTmuxVersion } from "./tmux-version.js";
 import { join } from "node:path";
 import { createClaudeTeamMembershipReader } from "../terminal/attachments/claude-team-names.js";
@@ -19,6 +24,8 @@ import { OwnerInteractionObservation, nativeInteractionObservationRequested, } f
 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 { observedAgentSchema } from "./tmux-server-agent-admission.js";
+import { createPaneEditorContextResolver } from "./tmux-pane-editor-context.js";
 import { createServerGenerationFencedTmuxRunner, createServerGenerationFencedTmuxAsyncRunner, } from "./tmux-server-generation-runner.js";
 import { createNativeTmuxServerCatalog } from "./tmux-server-owner.js";
 import { createEmbeddedTmuxServerOwners } from "./embedded-tmux-server-owners.js";
@@ -948,6 +955,7 @@ async function startEmbeddedDaemonGeneration(opts) {
         let terminalAttachmentRuntime = null;
         let paneStreamRuntime = null;
         let serverOwners = null;
+        let defaultEditorContextRetired = false;
         const defaultSessionCreator = createNativeTmuxSessionCreator({
             generation: instanceId,
             registry: workspaceRegistry,
@@ -975,7 +983,20 @@ async function startEmbeddedDaemonGeneration(opts) {
         let startedServer;
         try {
             const selector = tmuxAuthority.socketSelector;
-            const executeRuntimeIntent = (operationId, intent, timing, execution) => {
+            const executeRuntimeIntent = (operationId, intent, timing, execution, authorizeBeforeEffect) => {
+                if (intent.verb === "workspace.window.split.resize") {
+                    if (!sessionRuntimeRegistry)
+                        throw new Error("Session runtime unavailable");
+                    return executeCanonicalSplitMutation({
+                        generation: instanceId,
+                        registry: sessionRuntimeRegistry,
+                        resolveSession: (name) => workspaceRegistry.get(name)?.sessionName ?? null,
+                        runNative: createGuardedNativeSplitResize({
+                            observation: () => observationSelector,
+                            runPinnedTmux: nativeGenerationTmuxRunner,
+                        }),
+                    }, operationId, intent, authorizeBeforeEffect);
+                }
                 if (intent.verb === "workspace.pane.read") {
                     return workspaceMultiplexer.readPane(operationId, intent, execution);
                 }
@@ -1060,6 +1081,15 @@ async function startEmbeddedDaemonGeneration(opts) {
                     publishResourceChange: (change) => broadcastResourceChanged(change, instanceId),
                 },
                 mirror: {
+                    splitLayoutEpoch: () => observationSelector?.nativeServerEpoch ?? null,
+                    splitLayoutPrepare: createNativeSplitReadiness({
+                        observation: () => observationSelector ?? null,
+                        runPinnedTmux: nativeGenerationTmuxRunner,
+                    }),
+                    splitLayoutCapability: createNativeSplitCapabilityProbe({
+                        observation: () => observationSelector ?? null,
+                        runPinnedTmux: nativeGenerationTmuxRunner,
+                    }),
                     createOwnedViewerAdapter: () => ownedViewerFactory?.(),
                     nativeServerIdentity: initialNativeServerIdentity,
                     executable: tmuxAuthority.executablePath,
@@ -1272,7 +1302,41 @@ async function startEmbeddedDaemonGeneration(opts) {
                         return grant ? interactionEvidence.captureSourceBinding(grant) : null;
                     },
                     interactionReceipts,
+                    resolvePaneEditorContext: createPaneEditorContextResolver({
+                        generation: instanceId,
+                        registry: workspaceRegistry,
+                        catalog: createNativeTmuxServerCatalog(workspaceRegistry, fleetFactsTmuxRunner),
+                        inventory: terminalInventoryRuntime,
+                        assertOpen: () => {
+                            if (defaultEditorContextRetired ||
+                                serverOwners?.defaultRetired ||
+                                !initialNativeServerIdentity ||
+                                terminalInventoryRuntime?.lifecycleState() !== "ready")
+                                throw new Error("Default tmux editor context owner is unavailable");
+                        },
+                    }),
                     catalog: createNativeTmuxServerCatalog(workspaceRegistry, fleetFactsTmuxRunner),
+                    readWindowSplitLayout: async (workspaceName, input) => {
+                        const target = WindowLinkTargetSchemaZ.parse(input);
+                        const sessions = await createNativeTmuxServerCatalog(workspaceRegistry, fleetFactsTmuxRunner)();
+                        const sessionName = workspaceRegistry.get(workspaceName)?.sessionName;
+                        if (!sessionName ||
+                            !sessions.some((row) => row.sessionName === sessionName && row.liveSessionId === target.liveSessionId))
+                            throw new WindowSplitLayoutUnavailable();
+                        if (!sessionRuntimeRegistry)
+                            throw new WindowSplitLayoutUnavailable();
+                        return sessionRuntimeRegistry.readWindowSplitLayout(sessionName, target);
+                    },
+                    openAgent: async (liveSessionId, observed) => {
+                        const target = observedAgentSchema.parse(observed);
+                        await createNativeTmuxServerCatalog(workspaceRegistry, fleetFactsTmuxRunner)();
+                        try {
+                            return await defaultSessionOpener.openAgent(liveSessionId, target);
+                        }
+                        finally {
+                            terminalInventoryRuntime.invalidate();
+                        }
+                    },
                     openSession: async (liveSessionId) => {
                         await createNativeTmuxServerCatalog(workspaceRegistry, fleetFactsTmuxRunner)();
                         const result = await defaultSessionOpener.openSession(liveSessionId);
@@ -1310,6 +1374,7 @@ async function startEmbeddedDaemonGeneration(opts) {
                     terminalInventoryRuntime,
                     paneStreamRuntime,
                     dispose: async () => {
+                        defaultEditorContextRetired = true;
                         sessionMonitor?.stop();
                         paneSourceCredentials.dispose();
                         const transportResults = await Promise.allSettled([

package/packages/daemon/dist/lib/guarded-native-split-resize.js

@@ -0,0 +1,84 @@
+import { randomUUID } from "node:crypto";
+import { parseLayoutTree } from "../terminal/protocol/layout-parse.js";
+import { resizeNativeSplit, } from "../terminal/protocol/native-split-resize.js";
+import { nativeOperationWrapperArgs, } from "./native-operation-command.js";
+import { decodeNativeOperationInvocation } from "./native-operation-reply.js";
+function hasPane(tree, paneId) {
+    return tree.kind === "leaf"
+        ? tree.id === paneId
+        : tree.children.some((child) => hasPane(child, paneId));
+}
+/** No stock fallback, journal completion claim or retry. The owner must supply a
+ * bounded synchronous raw pinned runner; it must not enqueue work after returning.
+ * The native wrapper guards server/session/pane lifetimes, while the split child
+ * atomically checks session membership and exact layout before changing geometry.
+ * Successful readback still needs canonical publication before a GUI settles. */
+export function createGuardedNativeSplitResize(options) {
+    return async (request, authority) => {
+        let captured;
+        let input;
+        try {
+            captured = {
+                ...authority,
+                session: { ...authority.session },
+                anchor: { ...authority.anchor },
+            };
+            input = { ...request, path: [...request.path] };
+            const tree = parseLayoutTree(input.expectedLayout);
+            if (input.sessionId !== captured.session.id ||
+                typeof captured.authorizeBeforeEffect !== "function" ||
+                !tree ||
+                !hasPane(tree, captured.anchor.paneId))
+                return { status: "refused", reason: "invalid-authority" };
+            // Validate all lifetime guards before probing or dispatching any command.
+            nativeOperationWrapperArgs(captured.operationId, [["tmux-ide-resize-split", "-V"]], captured.serverEpoch, captured.anchor, captured.session);
+        }
+        catch {
+            return { status: "refused", reason: "invalid-authority" };
+        }
+        const observer = options.observation();
+        const supported = () => observer !== null &&
+            options.observation() === observer &&
+            observer.ownedOperationTransport &&
+            observer.ownedOperationEpochGuard &&
+            observer.ownedOperationPaneGuard &&
+            observer.ownedOperationSessionGuard &&
+            observer.nativeServerEpoch === captured.serverEpoch;
+        if (!supported())
+            return { status: "refused", reason: "unsupported" };
+        let mutationDispatched = false;
+        let authorityRetired = false;
+        const result = await resizeNativeSplit(input, (command) => {
+            const probe = command.length === 2 && command[1] === "-V";
+            const operationId = probe ? randomUUID() : captured.operationId;
+            const args = [
+                "tmux-ide-events",
+                "-i",
+                ";",
+                ...nativeOperationWrapperArgs(operationId, [command], captured.serverEpoch, captured.anchor, captured.session),
+            ];
+            try {
+                if (!supported())
+                    throw new Error("Native owner retired");
+                captured.authorizeBeforeEffect();
+            }
+            catch {
+                authorityRetired = true;
+                throw new Error("Split resize authority retired");
+            }
+            // There is no await between final authorization and synchronous dispatch.
+            if (!probe)
+                mutationDispatched = true;
+            const raw = options.runPinnedTmux(args, { preserveTrailingNewlines: true });
+            if (Buffer.byteLength(raw, "utf8") > 16 * 1024 + 2050)
+                throw new Error("Split resize response exceeds bounds");
+            return decodeNativeOperationInvocation(raw, {
+                serverEpoch: captured.serverEpoch,
+                operationId,
+            }).output;
+        });
+        if (authorityRetired && !mutationDispatched)
+            return { status: "refused", reason: "authority-retired" };
+        return result;
+    };
+}