@knpkv/herdr-connect 0.3.1 → 0.4.0

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAmC,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,KAAK,WAAW,MAAM,wCAAwC,CAAA;AACrE,OAAO,KAAK,IAAI,MAAM,iCAAiC,CAAA;AAIvD,OAAO,EAAyC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAG7E,OAAO,EACL,KAAK,YAAY,EAMlB,MAAM,YAAY,CAAA;AAOnB,OAAO,EAAqD,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAA;;;;AAOvG,cAAM,mBAAoB,SAAQ,wBAEhC;CAAG;;;;AAEL,cAAM,kBAAmB,SAAQ,uBAE/B;CAAG;;;;;AAEL,cAAM,oBAAqB,SAAQ,yBAGjC;CAAG;;;;;AAEL,cAAM,sBAAuB,SAAQ,2BAGnC;CAAG;AAML,KAAK,eAAe,GAChB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GAC7D;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GAC5D;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GACzD;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAA;AAEL,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CACpB,CAAA;AAwGD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc5B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAoP9D,eAAO,MAAM,cAAc,oCAIxB;IACD,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,CAAA;CAChC,gCAuPA,CAAA"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.tsx"],"names":[],"mappings":"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"}

package/dist/client.js

@@ -4,21 +4,30 @@ import { BrowserHttpClient } from "@effect/platform-browser";
 import { StateLabel, Surface, Text } from "@knpkv/rly/primitives";
 import { decodeBoundedResponseJson } from "@knpkv/herdr-fleet/response";
 import { Cause, Effect, Fiber, Result, Schedule, Schema } from "effect";
-import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
-import * as Atom from "effect/unstable/reactivity/Atom";
-import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Atom from "effect/reactivity/Atom";
+import * as HttpClient from "effect/http/HttpClient";
 import { FitAddon, init, Terminal } from "ghostty-web";
-import { useEffect, useRef } from "react";
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { buildConnectForest } from "./forest.js";
 import { applyTerminalInputIdentity } from "./terminal-input-identity.js";
+import { clampTerminalDimensions, terminalResizeCommand } from "./terminal-dimensions.js";
 import { FleetConnectAgentPage, FleetConnectAgents, TerminalServerSignal } from "./model.js";
 import { makePendingTerminalInput, makeTouchScrollGesture, pageScrollCommand, wheelScrollCommand } from "./terminal-input.js";
-import { AgentDirectory, connectAgentKey, ConnectWorkspace } from "./view.js";
+import { makeTerminalInputHandler, makeTerminalOutputBoundary, writeTerminalOutput } from "./terminal-output.js";
+import { AgentDirectory, connectAgentKey, ConnectWorkspace, TerminalKeyRail } from "./view.js";
 import { acquireTerminalSetup, ConnectTerminalSetupError } from "./terminal-setup.js";
 import { terminalBackground } from "./terminal-theme.js";
-import { bindTerminalViewport } from "./terminal-viewport.js";
+import { bindTerminalDocumentLock, bindTerminalViewport, terminalViewportBindingActive } from "./terminal-viewport.js";
 import { resolveConnectPreferenceDecision } from "./target.js";
 import { nextConnectAgentIndex } from "./keyboard.js";
+import { applyTerminalModifierToInput, dispatchTerminalKey, toggleTerminalModifier } from "./terminal-keyboard.js";
+import { WorkSnapshots } from "@knpkv/herdr-work/model";
+import { ConnectAgentIdentity } from "./work-goal-link-view.js";
+import { resolveConnectWorkGoal, workSnapshotForAssociation } from "./work-goal-link.js";
+import { WorkPollMount } from "./work-poll.js";
+import { makeTerminalWorkerGuard } from "./terminal-worker-guard.js";
+import { enterTerminalWorkspaceWithLock, returnToDirectoryWorkspace } from "./workspace-focus.js";
 class ConnectNetworkError extends Schema.TaggedError()("ConnectNetworkError", {
     detail: Schema.String
 }) {
@@ -100,9 +109,23 @@ const loadAgents = Effect.gen(function* () {
     })));
     return directory;
 });
+const loadWork = Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient;
+    const response = yield* client
+        .get("/v1/work")
+        .pipe(Effect.mapError((cause) => new ConnectNetworkError({ detail: String(cause) })));
+    if (response.status < 200 || response.status >= 300) {
+        return yield* new ConnectStatusError({ status: response.status });
+    }
+    return yield* decodeBoundedResponseJson(response, WorkSnapshots).pipe(Effect.mapError((cause) => new ConnectProtocolError({
+        detail: "invalid Work snapshot",
+        cause
+    })));
+});
 const browserRuntime = Atom.runtime(BrowserHttpClient.layerFetch);
 export const makeConnectAtoms = () => {
     const agents = browserRuntime.atom(loadAgents);
+    const work = browserRuntime.atom(loadWork);
     return {
         activityFilter: Atom.make("all"),
         agents,
@@ -113,10 +136,13 @@ export const makeConnectAtoms = () => {
         preference: Atom.make(loadRememberedAgent),
         preferenceError: Atom.make(null),
         query: Atom.make(""),
-        selectedKey: Atom.make(null)
+        selectedKey: Atom.make(null),
+        work,
+        workPoll: browserRuntime.atom(Atom.refresh(work).pipe(Effect.repeat(Schedule.spaced("5 seconds"))))
     };
 };
-const socketUrl = (agent, cols, rows) => {
+const socketUrl = (agent, dimensions) => {
+    const { cols, rows } = clampTerminalDimensions(dimensions);
     const url = new URL("/v1/connect/session", window.location.href);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
     url.searchParams.set("host", agent.host);
@@ -125,7 +151,18 @@ const socketUrl = (agent, cols, rows) => {
     url.searchParams.set("rows", String(rows));
     return url.toString();
 };
-const terminalWorker = (container, agent, update) => Effect.scoped(Effect.gen(function* () {
+const renderTerminalOutput = (terminal, data, outputBoundary, onError) => {
+    Effect.runFork(Effect.try({
+        try: () => {
+            writeTerminalOutput(terminal, data, outputBoundary);
+        },
+        catch: (cause) => new ConnectProtocolError({
+            detail: "terminal output could not be rendered",
+            cause
+        })
+    }).pipe(Effect.catch((error) => Effect.sync(() => onError(error)))));
+};
+const terminalWorker = (container, agent, update, keyboard) => Effect.scoped(Effect.gen(function* () {
     update({ _tag: "connecting", agent });
     yield* Effect.tryPromise({
         try: init,
@@ -167,42 +204,62 @@ const terminalWorker = (container, agent, update) => Effect.scoped(Effect.gen(fu
         });
     }
     applyTerminalInputIdentity(textarea);
+    const releaseTerminalFocus = keyboard.setTerminalFocus(textarea, () => terminal.terminal.focus());
+    yield* Effect.addFinalizer(() => Effect.sync(releaseTerminalFocus));
     let ready = false;
     let socket = null;
     let inputOverflow = false;
+    const outputBoundary = makeTerminalOutputBoundary();
     let pendingResize = null;
     const pendingInput = makePendingTerminalInput();
     const send = (command) => {
         if (socket?.readyState === WebSocket.OPEN) {
             socket.send(JSON.stringify(command));
+            return true;
         }
+        return false;
     };
-    const input = terminal.terminal.onData((text) => {
-        if (ready) {
-            send({ type: "terminal.input", text });
+    const sendInput = (text) => send({ type: "terminal.input", text });
+    const releaseInputSender = keyboard.setInputSender((command) => send(command));
+    yield* Effect.addFinalizer(() => Effect.sync(releaseInputSender));
+    const releaseCursorModeReader = keyboard.setCursorModeReader(() => terminal.terminal.getMode(1) ? "application" : "normal");
+    yield* Effect.addFinalizer(() => Effect.sync(releaseCursorModeReader));
+    const applyInput = (text) => {
+        const application = applyTerminalModifierToInput(keyboard.getModifier(), text);
+        if (application._tag === "unsupported") {
+            keyboard.reportError(application);
+            return null;
         }
-        else if (pendingInput.push(text) === "overflow") {
-            inputOverflow = true;
-            update({
-                _tag: "failed",
-                agent,
-                detail: "terminal input queue exceeded 64 KiB before ready"
-            });
-            socket?.close(4429, "terminal input queue limit reached");
-        }
-    });
+        return application;
+    };
+    const input = terminal.terminal.onData(makeTerminalInputHandler({
+        applyInput,
+        isReady: () => ready,
+        onFailure: (failure) => {
+            if (failure === "input_queue_overflow") {
+                inputOverflow = true;
+                update({
+                    _tag: "failed",
+                    agent,
+                    detail: "terminal input queue exceeded 64 KiB before ready"
+                });
+                socket?.close(4429, "terminal input queue limit reached");
+                return;
+            }
+            update({ _tag: "failed", agent, detail: "terminal input could not be sent" });
+            socket?.close(4429, "terminal input unavailable");
+        },
+        outputBoundary,
+        pendingInput,
+        sendInput,
+        setModifier: keyboard.setModifier
+    }));
     const resize = terminal.terminal.onResize(({ cols, rows }) => {
         if (!ready) {
             pendingResize = { cols, rows };
             return;
         }
-        send({
-            type: "terminal.resize",
-            cols,
-            rows,
-            cell_width_px: 0,
-            cell_height_px: 0
-        });
+        send(terminalResizeCommand({ cols, rows }));
     });
     terminal.terminal.attachCustomWheelEventHandler((event) => {
         const command = wheelScrollCommand(event, terminal.terminal.rows);
@@ -263,7 +320,7 @@ const terminalWorker = (container, agent, update) => Effect.scoped(Effect.gen(fu
         container.removeEventListener("touchcancel", touchCancel);
     }));
     const connectedSocket = yield* Effect.acquireRelease(Effect.callback((resume) => {
-        const value = new WebSocket(socketUrl(agent, terminal.terminal.cols, terminal.terminal.rows));
+        const value = new WebSocket(socketUrl(agent, { cols: terminal.terminal.cols, rows: terminal.terminal.rows }));
         value.binaryType = "arraybuffer";
         let settled = false;
         value.addEventListener("open", () => {
@@ -292,7 +349,10 @@ const terminalWorker = (container, agent, update) => Effect.scoped(Effect.gen(fu
         const message = (event) => {
             const binary = Schema.decodeUnknownResult(Schema.instanceOf(ArrayBuffer))(event.data);
             if (Result.isSuccess(binary)) {
-                terminal.terminal.write(new Uint8Array(binary.success));
+                renderTerminalOutput(terminal.terminal, new Uint8Array(binary.success), outputBoundary, (error) => {
+                    update({ _tag: "failed", agent, detail: error.detail });
+                    connectedSocket.close(4400, "terminal output could not be rendered");
+                });
                 return;
             }
             const decoded = Schema.decodeUnknownResult(Schema.fromJsonString(TerminalServerSignal))(event.data);
@@ -309,21 +369,16 @@ const terminalWorker = (container, agent, update) => Effect.scoped(Effect.gen(fu
                 ready = true;
                 const queued = pendingInput.drain();
                 if (queued.length > 0) {
-                    send({ type: "terminal.input", text: queued });
+                    if (!sendInput(queued)) {
+                        update({ _tag: "failed", agent, detail: "terminal input could not be sent" });
+                        connectedSocket.close(4429, "terminal input unavailable");
+                        return;
+                    }
                 }
                 if (pendingResize !== null) {
-                    send({
-                        type: "terminal.resize",
-                        cols: pendingResize.cols,
-                        rows: pendingResize.rows,
-                        cell_width_px: 0,
-                        cell_height_px: 0
-                    });
+                    send(terminalResizeCommand(pendingResize));
                     pendingResize = null;
                 }
-                if (window.matchMedia("(pointer: fine)").matches) {
-                    terminal.terminal.focus();
-                }
                 update({ _tag: "connected", agent });
             }
         };
@@ -355,28 +410,206 @@ export const ConnectSurface = ({ atoms, embedded = false, roomFooter }) => {
     const [preferenceError, setPreferenceError] = useAtom(atoms.preferenceError);
     const [query, setQuery] = useAtom(atoms.query);
     const [selectedKey, setSelectedKey] = useAtom(atoms.selectedKey);
+    const work = useAtomValue(atoms.work);
     const preferenceApplied = useRef(false);
-    const requestId = useRef(0);
+    const requestId = useRef(connectionRequest?.id ?? 0);
+    const directorySearchRef = useRef(null);
+    const directoryViewportRef = useRef(null);
+    const shellRef = useRef(null);
+    const [shellElement, setShellElement] = useState(null);
+    const terminalActiveRequestRef = useRef(null);
+    const terminalEntryLockRef = useRef(null);
+    const terminalBackRef = useRef(null);
     const terminalRef = useRef(null);
+    const terminalFocusTargetRef = useRef(null);
     const terminalViewportRef = useRef(null);
+    const workspaceRef = useRef(null);
+    const terminalInputRef = useRef(() => false);
+    const terminalInputOwnerRef = useRef(null);
+    const terminalFocusRef = useRef(() => { });
+    const terminalCursorModeReaderRef = useRef(() => "normal");
+    const terminalCursorModeOwnerRef = useRef(null);
+    const terminalModifierRef = useRef(null);
+    const [terminalModifier, setTerminalModifier] = useState(null);
+    const [terminalKeyError, setTerminalKeyError] = useState(null);
+    const [workspaceFocusFailure, setWorkspaceFocusFailure] = useState(null);
     useAtomMount(atoms.agentsPoll);
+    const releaseTerminalEntryLock = useCallback(() => {
+        const release = terminalEntryLockRef.current;
+        terminalEntryLockRef.current = null;
+        release?.();
+    }, []);
+    const attachShell = useCallback((element) => {
+        shellRef.current = element;
+        setShellElement(element);
+    }, []);
+    const workspaceElements = () => {
+        const directoryScreen = directoryViewportRef.current;
+        const terminalScreen = terminalViewportRef.current;
+        const workspace = workspaceRef.current;
+        return directoryScreen === null || terminalScreen === null || workspace === null
+            ? null
+            : { directory: directoryScreen, terminal: terminalScreen, workspace };
+    };
+    const directoryFocusTarget = (agent) => {
+        const directoryScreen = directoryViewportRef.current;
+        if (directoryScreen === null)
+            return null;
+        const key = connectAgentKey(agent);
+        return ([...directoryScreen.querySelectorAll(".connect-agent")].find((button) => button.dataset.agentKey === key) ??
+            directorySearchRef.current ??
+            directoryScreen);
+    };
+    const restoreDirectoryFocus = (agent) => {
+        const elements = workspaceElements();
+        const focusTarget = directoryFocusTarget(agent);
+        if (elements !== null && focusTarget !== null)
+            return returnToDirectoryWorkspace(elements, focusTarget);
+        const terminalScreen = terminalViewportRef.current;
+        const activeElement = Schema.decodeUnknownResult(Schema.instanceOf(HTMLElement))(window.document.activeElement);
+        if (terminalScreen !== null && Result.isSuccess(activeElement) && terminalScreen.contains(activeElement.success)) {
+            activeElement.success.blur();
+        }
+        return { _tag: "failed", reason: "detached_element" };
+    };
     useEffect(() => {
         const container = terminalRef.current;
         if (connectionRequest === null || container === null)
             return;
-        const fiber = Effect.runFork(terminalWorker(container, connectionRequest.agent, setConnection));
+        const terminalRequestId = connectionRequest.id;
+        const workerGuard = makeTerminalWorkerGuard(terminalRequestId);
+        const releaseTerminalFocus = () => {
+            workerGuard.release();
+            terminalFocusRef.current = () => { };
+            terminalFocusTargetRef.current = null;
+            terminalActiveRequestRef.current = null;
+        };
+        const invalidateTerminalRequest = () => {
+            if (requestId.current === terminalRequestId)
+                requestId.current += 1;
+            setConnectionRequest(null);
+        };
+        const fiber = Effect.runFork(terminalWorker(container, connectionRequest.agent, (state) => {
+            if (!workerGuard.accepts(requestId.current))
+                return;
+            if (state._tag === "connected") {
+                const elements = workspaceElements();
+                const focusTarget = window.matchMedia("(pointer: fine)").matches
+                    ? terminalFocusTargetRef.current
+                    : terminalBackRef.current;
+                if (elements === null || focusTarget === null) {
+                    releaseTerminalFocus();
+                    invalidateTerminalRequest();
+                    setConnection({
+                        _tag: "failed",
+                        agent: state.agent,
+                        detail: "terminal focus transition failed: detached_element"
+                    });
+                    return;
+                }
+                releaseTerminalEntryLock();
+                const lockedTransition = enterTerminalWorkspaceWithLock(elements, focusTarget, () => bindTerminalDocumentLock(window));
+                terminalEntryLockRef.current = lockedTransition.releaseLock;
+                const transition = lockedTransition.transition;
+                if (transition._tag === "failed") {
+                    releaseTerminalEntryLock();
+                    releaseTerminalFocus();
+                    invalidateTerminalRequest();
+                    setConnection({
+                        _tag: "failed",
+                        agent: state.agent,
+                        detail: `terminal focus transition failed: ${transition.reason}`
+                    });
+                    return;
+                }
+                setWorkspaceFocusFailure(null);
+                terminalActiveRequestRef.current = terminalRequestId;
+            }
+            else if (state._tag === "closed" || state._tag === "failed") {
+                if (terminalActiveRequestRef.current === terminalRequestId) {
+                    const transition = restoreDirectoryFocus(state.agent);
+                    if (transition._tag === "failed") {
+                        setWorkspaceFocusFailure(transition.reason);
+                    }
+                    else {
+                        setWorkspaceFocusFailure(null);
+                    }
+                    terminalActiveRequestRef.current = null;
+                }
+                invalidateTerminalRequest();
+            }
+            setConnection(state);
+        }, {
+            getModifier: () => terminalModifierRef.current,
+            setTerminalFocus: (target, focus) => {
+                terminalFocusTargetRef.current = target;
+                terminalFocusRef.current = focus;
+                return () => {
+                    if (terminalFocusRef.current === focus)
+                        terminalFocusRef.current = () => { };
+                    if (terminalFocusTargetRef.current === target)
+                        terminalFocusTargetRef.current = null;
+                };
+            },
+            reportError: () => setTerminalKeyError("That modifier combination is not supported."),
+            setInputSender: (sendInput) => {
+                const owner = Symbol("terminal-input-sender");
+                terminalInputOwnerRef.current = owner;
+                terminalInputRef.current = sendInput;
+                return () => {
+                    if (terminalInputOwnerRef.current !== owner)
+                        return;
+                    terminalInputOwnerRef.current = null;
+                    terminalInputRef.current = () => false;
+                };
+            },
+            setCursorModeReader: (read) => {
+                const owner = Symbol("terminal-cursor-mode-reader");
+                terminalCursorModeOwnerRef.current = owner;
+                terminalCursorModeReaderRef.current = read;
+                return () => {
+                    if (terminalCursorModeOwnerRef.current !== owner)
+                        return;
+                    terminalCursorModeOwnerRef.current = null;
+                    terminalCursorModeReaderRef.current = () => "normal";
+                };
+            },
+            setModifier: (modifier) => {
+                terminalModifierRef.current = modifier;
+                setTerminalModifier((current) => (current === modifier ? current : modifier));
+                setTerminalKeyError(null);
+            }
+        }));
         return () => {
+            releaseTerminalEntryLock();
+            workerGuard.release();
             Effect.runFork(Fiber.interrupt(fiber));
             container.replaceChildren();
         };
-    }, [connectionRequest, setConnection]);
-    const terminalConnected = connection._tag === "connected";
-    useEffect(() => {
+    }, [connectionRequest, releaseTerminalEntryLock, setConnection]);
+    const terminalVisible = connection._tag === "connected" || workspaceFocusFailure === "focus_rejected";
+    const terminalViewportActive = terminalViewportBindingActive({
+        connectionRequested: connectionRequest !== null,
+        focusRejected: workspaceFocusFailure === "focus_rejected",
+        terminalConnected: connection._tag === "connected"
+    });
+    // Size the hidden terminal before its first visible frame so Fleet navigation never overlaps it.
+    useLayoutEffect(() => {
         const room = terminalViewportRef.current;
-        if (!terminalConnected || room === null)
+        if (!terminalViewportActive || room === null)
             return;
-        return bindTerminalViewport(room, window);
-    }, [terminalConnected]);
+        const attachedShell = shellElement ?? shellRef.current;
+        const topBoundary = embedded ? attachedShell : undefined;
+        if (topBoundary === null)
+            return;
+        try {
+            return bindTerminalViewport(room, window, topBoundary, terminalVisible);
+        }
+        finally {
+            if (terminalVisible)
+                releaseTerminalEntryLock();
+        }
+    }, [embedded, releaseTerminalEntryLock, shellElement, terminalViewportActive, terminalVisible]);
     const current = AsyncResult.isSuccess(directory)
         ? directory.value
         : directory._tag === "Failure" && directory.previousSuccess._tag === "Some"
@@ -387,9 +620,26 @@ export const ConnectSurface = ({ atoms, embedded = false, roomFooter }) => {
         (connectionRequest !== null && connectAgentKey(connectionRequest.agent) === selectedKey
             ? connectionRequest.agent
             : null);
+    const currentWork = workSnapshotForAssociation(work);
+    const workGoalResolution = selected === null
+        ? { _tag: "unavailable", reason: "snapshot_unavailable" }
+        : currentWork === null
+            ? { _tag: "unavailable", reason: "snapshot_unavailable" }
+            : resolveConnectWorkGoal(selected, currentWork);
     const selectAgent = (agent) => {
         preferenceApplied.current = true;
         const key = connectAgentKey(agent);
+        terminalInputOwnerRef.current = null;
+        terminalInputRef.current = () => false;
+        terminalFocusRef.current = () => { };
+        terminalFocusTargetRef.current = null;
+        terminalCursorModeOwnerRef.current = null;
+        terminalCursorModeReaderRef.current = () => "normal";
+        terminalModifierRef.current = null;
+        terminalActiveRequestRef.current = null;
+        setTerminalModifier(null);
+        setTerminalKeyError(null);
+        setWorkspaceFocusFailure(null);
         setSelectedKey(key);
         setConnection({ _tag: "connecting", agent });
         requestId.current += 1;
@@ -436,8 +686,53 @@ export const ConnectSurface = ({ atoms, embedded = false, roomFooter }) => {
         next.focus();
     };
     const disconnect = () => {
+        let nextConnection = { _tag: "idle" };
+        let nextFocusFailure = null;
+        if (connection._tag !== "idle" && (connection._tag === "connected" || workspaceFocusFailure === "focus_rejected")) {
+            const transition = restoreDirectoryFocus(connection.agent);
+            if (transition._tag === "failed") {
+                nextConnection = {
+                    _tag: "failed",
+                    agent: connection.agent,
+                    detail: `terminal focus transition failed: ${transition.reason}`
+                };
+                nextFocusFailure = transition.reason;
+            }
+        }
+        requestId.current += 1;
+        terminalActiveRequestRef.current = null;
+        setConnection(nextConnection);
         setConnectionRequest(null);
-        setConnection({ _tag: "idle" });
+        terminalInputOwnerRef.current = null;
+        terminalInputRef.current = () => false;
+        terminalFocusRef.current = () => { };
+        terminalFocusTargetRef.current = null;
+        terminalCursorModeOwnerRef.current = null;
+        terminalCursorModeReaderRef.current = () => "normal";
+        terminalModifierRef.current = null;
+        setTerminalModifier(null);
+        setTerminalKeyError(null);
+        setWorkspaceFocusFailure(nextFocusFailure);
+    };
+    const changeTerminalModifier = (modifier) => {
+        const next = toggleTerminalModifier(terminalModifierRef.current, modifier);
+        terminalModifierRef.current = next;
+        setTerminalModifier(next);
+        setTerminalKeyError(null);
+    };
+    const sendTerminalRailKey = (key) => {
+        const dispatch = dispatchTerminalKey(key, terminalModifierRef.current, terminalCursorModeReaderRef.current());
+        if (dispatch._tag === "unsupported") {
+            setTerminalKeyError("That modifier combination is not supported.");
+            return;
+        }
+        if (!terminalInputRef.current(dispatch.command)) {
+            setTerminalKeyError("Terminal connection is unavailable.");
+            return;
+        }
+        terminalModifierRef.current = dispatch.nextModifier;
+        setTerminalModifier(dispatch.nextModifier);
+        setTerminalKeyError(null);
     };
     const directoryScreen = (_jsxs(_Fragment, { children: [embedded ? (_jsxs("header", { className: "connect-embedded-intro", children: [_jsxs("div", { children: [_jsx(Text, { variant: "meta", tone: "secondary", children: "Live fleet directory" }), _jsx(Text, { as: "h1", variant: "page-title", children: "Connect to an agent" }), _jsx(Text, { tone: "secondary", children: "Choose a worker, reviewer, or coordinator to open its exact terminal." })] }), _jsx(StateLabel, { label: current === null ? "Loading" : `${String(agents.length)} agents`, size: "compact", tone: current === null ? "neutral" : "positive" })] })) : (_jsxs("header", { className: "connect-header", children: [_jsxs("div", { children: [_jsx(Text, { variant: "meta", tone: "secondary", children: "Herdr fleet" }), _jsx(Text, { as: "h1", variant: "page-title", children: "Connect" })] }), _jsxs("nav", { className: "fleet-app-nav", "aria-label": "Fleet applications", children: [_jsx("a", { href: "/", children: "Approvals" }), _jsx("a", { href: "/connect/", "aria-current": "page", children: "Connect" })] })] })), _jsxs("section", { className: "connect-agents", "aria-label": "Herdr agents", onKeyDown: moveAgentFocus, children: [_jsxs("label", { className: "connect-search", children: [_jsx("span", { children: "Find agent" }), _jsx("input", { autoComplete: "off", id: "connect-agent-search", name: "agent-search", onChange: (event) => setQuery(event.currentTarget.value), onKeyDown: (event) => {
                                     if (event.key === "Escape") {
@@ -455,8 +750,12 @@ export const ConnectSurface = ({ atoms, embedded = false, roomFooter }) => {
                                         return;
                                     event.preventDefault();
                                     firstAgent.focus();
-                                }, placeholder: "Name, host, state\u2026", type: "search", value: query })] }), current === null ? (_jsx(Text, { tone: "secondary", children: directory._tag === "Failure" ? Cause.pretty(directory.cause) : "Loading fleet agents…" })) : agents.length === 0 ? (_jsx(Text, { tone: "secondary", children: "No live agents." })) : (_jsx(AgentDirectory, { activityFilter: activityFilter, agents: agents, hostFilter: hostFilter, onActivityFilter: setActivityFilter, onHostFilter: setHostFilter, onSelect: selectAgent, query: query, selectedKey: selectedKey })), connection._tag === "connecting" ? (_jsxs("small", { className: "connect-status-message", children: ["Connecting to ", connection.agent.name, "\u2026"] })) : connection._tag === "failed" ? (_jsxs("small", { className: "connect-status-message", "data-tone": "critical", children: [connection.agent.name, " \u00B7 ", connection.detail] })) : connection._tag === "closed" ? (_jsxs("small", { className: "connect-status-message", children: [connection.agent.name, " disconnected."] })) : null, remembered._tag === "Failure" ? (_jsxs("small", { className: "connect-preference-error", children: ["Selection memory unavailable \u00B7 ", Cause.pretty(remembered.cause)] })) : preferenceError === null ? null : (_jsxs("small", { className: "connect-preference-error", children: ["Selection memory unavailable \u00B7 ", preferenceError] })), (current?.failures.length ?? 0) === 0 ? null : (_jsx("div", { className: "connect-failures", children: current?.failures.map((failure) => (_jsxs("small", { children: [failure.host, " \u00B7 ", failure.reason.replaceAll("_", " ")] }, failure.host))) }))] })] }));
-    const terminalScreen = (_jsxs(Surface, { as: "section", padding: "none", className: "terminal-stage", children: [_jsxs("div", { className: "terminal-bar", children: [_jsx("button", { className: "terminal-back", onClick: disconnect, type: "button", children: "Agents" }), _jsxs("div", { children: [_jsx("strong", { children: selected?.name ?? "Agent" }), _jsx("small", { children: selected === null ? "Herdr terminal" : `${selected.host} · ${selected.kind}` })] }), _jsx(StateLabel, { label: "connected", tone: "positive", size: "compact" })] }), _jsx("div", { "aria-label": selected === null ? "Agent terminal" : `${selected.name} terminal`, className: "ghostty-terminal", ref: terminalRef })] }));
-    return (_jsxs("div", { className: embedded ? "connect-shell connect-shell-embedded" : "connect-shell", children: [_jsx(ConnectWorkspace, { directory: directoryScreen, mode: connection._tag === "connected" ? "terminal" : "directory", terminal: terminalScreen, terminalViewportRef: terminalViewportRef }), roomFooter] }));
+                                }, placeholder: "Name, host, state\u2026", ref: directorySearchRef, type: "search", value: query })] }), current === null ? (_jsx(Text, { tone: "secondary", children: directory._tag === "Failure" ? Cause.pretty(directory.cause) : "Loading fleet agents…" })) : agents.length === 0 ? (_jsx(Text, { tone: "secondary", children: "No live agents." })) : (_jsx(AgentDirectory, { activityFilter: activityFilter, agents: agents, hostFilter: hostFilter, onActivityFilter: setActivityFilter, onHostFilter: setHostFilter, onSelect: selectAgent, query: query, selectedKey: selectedKey })), connection._tag === "connecting" ? (_jsxs("small", { className: "connect-status-message", children: ["Connecting to ", connection.agent.name, "\u2026"] })) : connection._tag === "failed" ? (_jsxs("small", { className: "connect-status-message", "data-tone": "critical", children: [connection.agent.name, " \u00B7 ", connection.detail] })) : connection._tag === "closed" ? (_jsxs("small", { className: "connect-status-message", children: [connection.agent.name, " disconnected."] })) : null, remembered._tag === "Failure" ? (_jsxs("small", { className: "connect-preference-error", children: ["Selection memory unavailable \u00B7 ", Cause.pretty(remembered.cause)] })) : preferenceError === null ? null : (_jsxs("small", { className: "connect-preference-error", children: ["Selection memory unavailable \u00B7 ", preferenceError] })), workspaceFocusFailure === null || workspaceFocusFailure === "focus_rejected" ? null : (_jsxs("small", { className: "connect-status-message", "data-tone": "critical", children: ["Terminal focus transition failed \u00B7 ", workspaceFocusFailure] })), (current?.failures.length ?? 0) === 0 ? null : (_jsx("div", { className: "connect-failures", children: current?.failures.map((failure) => (_jsxs("small", { children: [failure.host, " \u00B7 ", failure.reason.replaceAll("_", " ")] }, failure.host))) }))] })] }));
+    const terminalScreen = (_jsxs(Surface, { as: "section", padding: "none", className: "terminal-stage", children: [_jsxs("div", { className: "terminal-bar", children: [_jsx("button", { className: "terminal-back", onClick: disconnect, ref: terminalBackRef, type: "button", children: "Agents" }), _jsxs("div", { children: [selected === null ? (_jsx("strong", { children: "Agent" })) : (_jsx(ConnectAgentIdentity, { agent: selected, resolution: workGoalResolution })), _jsx("small", { children: selected === null ? "Herdr terminal" : `${selected.host} · ${selected.kind}` })] }), _jsx(StateLabel, { label: connection._tag === "connected"
+                            ? "connected"
+                            : connection._tag === "closed"
+                                ? "disconnected"
+                                : "unavailable", tone: connection._tag === "connected" ? "positive" : connection._tag === "failed" ? "critical" : "neutral", size: "compact" })] }), workspaceFocusFailure === "focus_rejected" ? (_jsxs("small", { className: "connect-status-message", "data-tone": "critical", role: "alert", children: ["Terminal focus transition failed \u00B7 ", workspaceFocusFailure] })) : null, _jsx(TerminalKeyRail, { disabled: connection._tag !== "connected", error: terminalKeyError, modifier: terminalModifier, onFocusTerminal: () => terminalFocusRef.current(), onKey: sendTerminalRailKey, onModifierChange: changeTerminalModifier }), _jsx("div", { "aria-label": selected === null ? "Agent terminal" : `${selected.name} terminal`, className: "ghostty-terminal", ref: terminalRef })] }));
+    return (_jsxs("div", { className: embedded ? "connect-shell connect-shell-embedded" : "connect-shell", ref: attachShell, tabIndex: -1, children: [_jsx(WorkPollMount, { atom: atoms.workPoll }), _jsx(ConnectWorkspace, { directory: directoryScreen, directoryViewportRef: directoryViewportRef, mode: terminalVisible ? "terminal" : "directory", terminal: terminalScreen, terminalViewportRef: terminalViewportRef, workspaceRef: workspaceRef }), roomFooter] }));
 };
 //# sourceMappingURL=client.js.map