@moxt-ai/mobius 0.0.5 → 0.0.6

package/dist/run-daemon.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { basename } from "node:path";
-import { AGENT_ACTIVITY_KIND, AGENT_INSTALL_AWAITING_APPROVAL_KIND, AGENT_INSTALL_CANCEL_KIND, AGENT_INSTALL_CANCELLED_KIND, AGENT_INSTALL_COMPLETED_KIND, AGENT_INSTALL_FAILED_KIND, AGENT_INSTALL_PROGRESS_KIND, AGENT_INSTALL_REQUEST_KIND, AGENT_INSTALL_STARTED_KIND, AGENT_MESSAGE_DELTA_KIND, decodeAgentInstallCancelCommand, decodeAgentInstallRequestCommand, decodeMessageKind, decodeRuntimeHeartbeatAckEvent, decodeRuntimeLivenessReadyEvent, decodeSessionCancelCommand, decodeSessionConfigureCommand, decodeSessionElicitationRespondCommand, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionPromptCommand, decodeWorkspaceListCommand, encodeAgentActivityEvent, encodeAgentContentEvent, encodeAgentInstallAwaitingApprovalEvent, encodeAgentInstallCancelledEvent, encodeAgentInstallCompletedEvent, encodeAgentInstallFailedEvent, encodeAgentInstallProgressEvent, encodeAgentInstallStartedEvent, encodeAgentMessageDeltaEvent, encodeSessionCommandsUpdatedEvent, encodeSessionCompletedEvent, encodeSessionConfigUpdatedEvent, encodeSessionElicitationRequestedEvent, encodeSessionElicitationResolvedEvent, encodeSessionFailedEvent, encodeSessionInfoUpdatedEvent, encodeSessionOperationFailedEvent, encodeSessionPermissionRequestedEvent, encodeSessionPermissionResolvedEvent, encodeSessionReadyEvent, encodeSessionStartedEvent, encodeSessionUsageUpdatedEvent, encodeWorkspaceEntriesEvent, MOBIUS_PROTOCOL_VERSION, RUNTIME_HEARTBEAT_ACK_KIND, RUNTIME_LIVENESS_READY_KIND, SESSION_CANCEL_KIND, SESSION_COMPLETED_KIND, SESSION_CONFIGURE_KIND, SESSION_ELICITATION_RESPOND_KIND, SESSION_FAILED_KIND, SESSION_PERMISSION_RESPOND_KIND, SESSION_PREPARE_KIND, SESSION_PROMPT_KIND, SESSION_STARTED_KIND, WORKSPACE_LIST_KIND, } from "@moxt-ai/mobius-protocol";
+import { AGENT_ACTIVITY_KIND, AGENT_INSTALL_AWAITING_APPROVAL_KIND, AGENT_INSTALL_CANCEL_KIND, AGENT_INSTALL_CANCELLED_KIND, AGENT_INSTALL_COMPLETED_KIND, AGENT_INSTALL_FAILED_KIND, AGENT_INSTALL_PROGRESS_KIND, AGENT_INSTALL_REQUEST_KIND, AGENT_INSTALL_STARTED_KIND, AGENT_MESSAGE_DELTA_KIND, decodeAgentInstallCancelCommand, decodeAgentInstallRequestCommand, decodeMessageKind, decodeNativeSessionCancel, decodeNativeSessionCommand, decodeRuntimeHeartbeatAckEvent, decodeRuntimeLivenessReadyEvent, decodeSessionCancelCommand, decodeSessionConfigureCommand, decodeSessionElicitationRespondCommand, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionPromptCommand, decodeWorkspaceListCommand, encodeAgentActivityEvent, encodeAgentContentEvent, encodeAgentInstallAwaitingApprovalEvent, encodeAgentInstallCancelledEvent, encodeAgentInstallCompletedEvent, encodeAgentInstallFailedEvent, encodeAgentInstallProgressEvent, encodeAgentInstallStartedEvent, encodeAgentMessageDeltaEvent, encodeNativeSessionResult, encodeSessionCommandsUpdatedEvent, encodeSessionCompletedEvent, encodeSessionConfigUpdatedEvent, encodeSessionElicitationRequestedEvent, encodeSessionElicitationResolvedEvent, encodeSessionFailedEvent, encodeSessionInfoUpdatedEvent, encodeSessionOperationFailedEvent, encodeSessionPermissionRequestedEvent, encodeSessionPermissionResolvedEvent, encodeSessionReadyEvent, encodeSessionStartedEvent, encodeSessionUsageUpdatedEvent, encodeWorkspaceEntriesEvent, MOBIUS_PROTOCOL_VERSION, NATIVE_SESSION_CANCEL_KIND, NATIVE_SESSION_REQUEST_KIND, RUNTIME_HEARTBEAT_ACK_KIND, RUNTIME_LIVENESS_READY_KIND, SESSION_CANCEL_KIND, SESSION_COMPLETED_KIND, SESSION_CONFIGURE_KIND, SESSION_ELICITATION_RESPOND_KIND, SESSION_FAILED_KIND, SESSION_PERMISSION_RESPOND_KIND, SESSION_PREPARE_KIND, SESSION_PROMPT_KIND, SESSION_STARTED_KIND, WORKSPACE_LIST_KIND, } from "@moxt-ai/mobius-protocol";
 import { WebSocket } from "undici";
 import { AcpExecutionError, AcpSessionManager, NullAcpSessionObserver, } from "./acp/session-manager.js";
 import { SqliteAcpSessionStore } from "./acp/session-store.js";
@@ -12,8 +12,9 @@ import { AutomaticAdapterProvisioner } from "./agent-installation/automatic-adap
 import { FixedInstallationExecutor } from "./agent-installation/fixed-installation-executor.js";
 import { ConsoleInstallationAuthorizer } from "./agent-installation/local-installation-authorizer.js";
 import { ManagedAdapterInstaller } from "./agent-installation/managed-adapter-installer.js";
-import { LocalAuthorizationError } from "./authorization/authorize-binding.js";
+import { LocalAuthorizationError } from "./authorization/local-authorization-error.js";
 import { WorkspaceDirectoryService } from "./authorization/workspace-directory.js";
+import { NativeSessionService } from "./native-sessions/service.js";
 import { connectRelay } from "./relay-connection/connect.js";
 import { RelayConnectionLiveness } from "./relay-connection/liveness.js";
 import { systemDaemonTimer, } from "./relay-connection/timer.js";
@@ -298,13 +299,13 @@ function reportOperationFailure(socket, requestId, sessionId, error) {
         sessionId,
     }));
 }
-async function resolveSessionDirectories(directories, bindingId, directoryId, additionalDirectoryIds) {
-    const cwd = await directories.resolve(bindingId, directoryId);
+async function resolveSessionDirectories(directories, bindingId, directoryId, additionalDirectoryIds, signal) {
+    const cwd = await directories.resolve(bindingId, directoryId, signal);
     const additionalDirectories = [];
     const additionalDirectoryEntries = [];
     const unique = new Set([cwd]);
     for (const additionalDirectoryId of additionalDirectoryIds) {
-        const directory = await directories.resolve(bindingId, additionalDirectoryId);
+        const directory = await directories.resolve(bindingId, additionalDirectoryId, signal);
         if (unique.has(directory)) {
             throw new LocalAuthorizationError("Workspace directories must resolve to distinct locations");
         }
@@ -317,9 +318,9 @@ async function resolveSessionDirectories(directories, bindingId, directoryId, ad
     }
     return new ResolvedSessionDirectories(cwd, additionalDirectories, additionalDirectoryEntries);
 }
-async function executeWorkspaceList(socket, command, directories, audit) {
+async function executeWorkspaceList(socket, command, directories, audit, signal) {
     try {
-        const listing = await directories.list(command.bindingId, command.directoryId);
+        const listing = await directories.list(command.bindingId, command.directoryId, signal);
         audit.record({
             commandId: command.requestId,
             event: "workspace_list_authorized",
@@ -342,7 +343,7 @@ async function executeWorkspaceList(socket, command, directories, audit) {
 }
 async function executeSessionPrepare(socket, command, config, directories, audit, sessions, signal) {
     try {
-        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds);
+        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds, signal);
         const agent = config.catalog.find(command.agentId);
         const prepared = await sessions.prepareSession({
             additionalDirectories: resolved.additionalDirectories,
@@ -351,7 +352,7 @@ async function executeSessionPrepare(socket, command, config, directories, audit
             sessionId: command.sessionId,
             signal,
         });
-        const listing = await directories.list(command.bindingId, command.directoryId);
+        const listing = await directories.list(command.bindingId, command.directoryId, signal);
         audit.record({
             commandId: command.requestId,
             event: "session_prepared",
@@ -380,7 +381,7 @@ async function executeSessionPrepare(socket, command, config, directories, audit
 }
 async function executeSessionConfigure(socket, command, config, directories, audit, sessions, signal) {
     try {
-        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds);
+        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds, signal);
         const configOptions = await sessions.configureSession({
             additionalDirectories: resolved.additionalDirectories,
             agent: config.catalog.find(command.agentId),
@@ -412,7 +413,7 @@ async function executeSessionConfigure(socket, command, config, directories, aud
 }
 async function executePrompt(socket, command, config, directories, audit, sessions, signal) {
     try {
-        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds);
+        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds, signal);
         const agent = config.catalog.find(command.agentId);
         const processAttemptId = randomUUID();
         audit.record({
@@ -510,215 +511,295 @@ function waitForRelayRetry(signal, timer) {
         signal.addEventListener("abort", finish, { once: true });
     });
 }
-async function runRelayConnection(config, directories, audit, sessions, installations, installationObserver, signal, timer) {
+async function runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, signal, timer) {
     const relayUrl = new URL(config.relayUrl);
     relayUrl.searchParams.set("liveness", "1");
     const socket = await connectRelay(relayUrl, signal);
     const activeTurns = new Map();
     const connectionController = new AbortController();
+    const nativeRequests = new Map();
     sessions.setObserver(new DaemonAcpObserver(socket));
     installationObserver.connect(socket);
-    await new Promise((resolve, reject) => {
-        let finished = false;
-        const cleanup = () => {
-            connectionRefresh.close();
-            connectionLiveness.close();
-            signal.removeEventListener("abort", stop);
-            socket.removeEventListener("close", handleClose);
-            socket.removeEventListener("error", handleError);
-            socket.removeEventListener("message", handleMessage);
-            installationObserver.disconnect(socket);
-            connectionController.abort();
-            for (const turn of activeTurns.values()) {
-                turn.abortConnection();
-            }
-            activeTurns.clear();
-        };
-        const resolveConnection = () => {
-            if (finished) {
-                return;
-            }
-            finished = true;
-            cleanup();
-            resolve();
-        };
-        const rejectConnection = () => {
-            if (finished) {
-                return;
-            }
-            finished = true;
-            cleanup();
-            reject(new Error("Relay WebSocket failed"));
-        };
-        const stop = () => {
-            socket.close(1000, "Daemon stopped");
-            resolveConnection();
-        };
-        const refreshConnection = () => {
-            socket.close(1000, "Refreshing idle relay connection");
-            resolveConnection();
-        };
-        const connectionLiveness = new RelayConnectionLiveness(timer, {
-            send: (message) => send(socket, message),
-            unresponsive: () => {
-                socket.close(4001, "Relay liveness check timed out");
-                resolveConnection();
-            },
-        });
-        const connectionRefresh = new RelayConnectionRefresh(timer, () => activeTurns.size === 0, refreshConnection);
-        signal.addEventListener("abort", stop, { once: true });
-        const handleClose = () => {
-            resolveConnection();
-        };
-        const handleError = () => {
-            if (signal.aborted) {
-                resolveConnection();
-                return;
-            }
-            rejectConnection();
-        };
-        const handleMessage = (event) => {
-            const encoded = event.data;
-            if (typeof encoded !== "string") {
-                socket.close(4003, "Text message required");
-                rejectConnection();
-                return;
-            }
-            try {
-                const kind = decodeMessageKind(encoded);
-                if (kind === RUNTIME_LIVENESS_READY_KIND) {
-                    decodeRuntimeLivenessReadyEvent(encoded);
-                    connectionLiveness.start();
-                    return;
-                }
-                if (kind === RUNTIME_HEARTBEAT_ACK_KIND) {
-                    connectionLiveness.acknowledge(decodeRuntimeHeartbeatAckEvent(encoded));
-                    return;
+    try {
+        await new Promise((resolve, reject) => {
+            let finished = false;
+            const cleanup = () => {
+                connectionRefresh.close();
+                connectionLiveness.close();
+                signal.removeEventListener("abort", stop);
+                socket.removeEventListener("close", handleClose);
+                socket.removeEventListener("error", handleError);
+                socket.removeEventListener("message", handleMessage);
+                installationObserver.disconnect(socket);
+                connectionController.abort();
+                for (const turn of activeTurns.values()) {
+                    turn.abortConnection();
                 }
-                if (kind === SESSION_CANCEL_KIND) {
-                    const cancellation = decodeSessionCancelCommand(encoded);
-                    const turn = activeTurns.get(cancellation.commandId);
-                    if (turn === undefined || !turn.matches(cancellation)) {
-                        console.warn("Mobius daemon ignored cancellation for an inactive turn");
-                        return;
-                    }
-                    if (!turn.requestCancellation()) {
-                        return;
-                    }
-                    audit.record({
-                        commandId: cancellation.commandId,
-                        event: "session_cancellation_requested",
-                        sessionId: cancellation.sessionId,
-                    });
-                    void sessions.cancelPrompt(cancellation.sessionId).catch((error) => {
-                        console.error("Mobius daemon could not cancel the agent turn", error);
-                    });
+                activeTurns.clear();
+            };
+            const resolveConnection = () => {
+                if (finished) {
                     return;
                 }
-                if (kind === WORKSPACE_LIST_KIND) {
-                    const command = decodeWorkspaceListCommand(encoded);
-                    void executeWorkspaceList(socket, command, directories, audit);
+                finished = true;
+                cleanup();
+                resolve();
+            };
+            const rejectConnection = () => {
+                if (finished) {
                     return;
                 }
-                if (kind === SESSION_PREPARE_KIND) {
-                    const command = decodeSessionPrepareCommand(encoded);
-                    void executeSessionPrepare(socket, command, config, directories, audit, sessions, connectionController.signal);
+                finished = true;
+                cleanup();
+                reject(new Error("Relay WebSocket failed"));
+            };
+            const stop = () => {
+                socket.close(1000, "Daemon stopped");
+                resolveConnection();
+            };
+            const refreshConnection = () => {
+                socket.close(1000, "Refreshing idle relay connection");
+                resolveConnection();
+            };
+            const connectionLiveness = new RelayConnectionLiveness(timer, {
+                send: (message) => send(socket, message),
+                unresponsive: () => {
+                    socket.close(4001, "Relay liveness check timed out");
+                    resolveConnection();
+                },
+            });
+            const connectionRefresh = new RelayConnectionRefresh(timer, () => activeTurns.size === 0, refreshConnection);
+            signal.addEventListener("abort", stop, { once: true });
+            const handleClose = () => {
+                resolveConnection();
+            };
+            const handleError = () => {
+                if (signal.aborted) {
+                    resolveConnection();
                     return;
                 }
-                if (kind === SESSION_CONFIGURE_KIND) {
-                    const command = decodeSessionConfigureCommand(encoded);
-                    void executeSessionConfigure(socket, command, config, directories, audit, sessions, connectionController.signal);
+                rejectConnection();
+            };
+            const handleMessage = (event) => {
+                const encoded = event.data;
+                if (typeof encoded !== "string") {
+                    socket.close(4003, "Text message required");
+                    rejectConnection();
                     return;
                 }
-                if (kind === SESSION_PERMISSION_RESPOND_KIND) {
-                    const command = decodeSessionPermissionRespondCommand(encoded);
-                    void sessions
-                        .respondPermission(command)
-                        .then(() => {
-                        audit.record({
-                            commandId: command.interactionId,
-                            event: "session_permission_resolved",
+                try {
+                    const kind = decodeMessageKind(encoded);
+                    if (kind === NATIVE_SESSION_CANCEL_KIND) {
+                        const command = decodeNativeSessionCancel(encoded);
+                        const pending = nativeRequests.get(command.requestId);
+                        if (pending?.sessionId === command.sessionId)
+                            pending.controller.abort(new AcpExecutionError("Native session operation cancelled", {}, "native_session_cancelled"));
+                        return;
+                    }
+                    if (kind === NATIVE_SESSION_REQUEST_KIND) {
+                        const command = decodeNativeSessionCommand(encoded);
+                        const previous = [...nativeRequests.values()].filter((request) => request.agentId === command.agentId);
+                        if (nativeRequests.has(command.requestId) ||
+                            nativeRequests.size >= 4 ||
+                            previous.some((request) => !request.controller.signal.aborted)) {
+                            reportOperationFailure(socket, command.requestId, command.sessionId, new AcpExecutionError("Another native session operation is running", {}, "native_session_busy"));
+                            return;
+                        }
+                        const controller = new AbortController();
+                        const operationSignal = AbortSignal.any([
+                            connectionController.signal,
+                            controller.signal,
+                        ]);
+                        const timeout = timer.schedule(() => controller.abort(new AcpExecutionError("Native session operation timed out", {}, "native_session_timeout")), 90_000);
+                        const completion = (async () => {
+                            try {
+                                operationSignal.throwIfAborted();
+                                if (previous.length > 0) {
+                                    await new Promise((resolve, reject) => {
+                                        const cancel = () => reject(operationSignal.reason);
+                                        operationSignal.addEventListener("abort", cancel, {
+                                            once: true,
+                                        });
+                                        void Promise.all(previous.map((request) => request.completion)).then(() => {
+                                            operationSignal.removeEventListener("abort", cancel);
+                                            resolve();
+                                        }, (error) => {
+                                            operationSignal.removeEventListener("abort", cancel);
+                                            reject(error);
+                                        });
+                                    });
+                                }
+                                operationSignal.throwIfAborted();
+                                const result = await nativeSessions.execute(command, operationSignal);
+                                if (socket.readyState === WebSocket.OPEN)
+                                    send(socket, encodeNativeSessionResult(result));
+                            }
+                            catch (error) {
+                                const failure = operationSignal.aborted
+                                    ? (controller.signal.reason ??
+                                        new AcpExecutionError("Native session operation cancelled", {}, "native_session_cancelled"))
+                                    : error;
+                                audit.record({
+                                    commandId: command.requestId,
+                                    sessionId: command.sessionId,
+                                    event: "native_session_operation_failed",
+                                    details: { code: operationErrorCode(failure) },
+                                });
+                                reportOperationFailure(socket, command.requestId, command.sessionId, failure);
+                            }
+                            finally {
+                                timeout.cancel();
+                                nativeRequests.delete(command.requestId);
+                            }
+                        })();
+                        nativeRequests.set(command.requestId, {
+                            agentId: command.agentId,
                             sessionId: command.sessionId,
+                            controller,
+                            completion,
                         });
-                    })
-                        .catch((error) => {
-                        reportOperationFailure(socket, command.interactionId, command.sessionId, error);
-                    });
-                    return;
-                }
-                if (kind === SESSION_ELICITATION_RESPOND_KIND) {
-                    const command = decodeSessionElicitationRespondCommand(encoded);
-                    void sessions
-                        .respondElicitation(command)
-                        .then(() => {
+                        return;
+                    }
+                    if (kind === RUNTIME_LIVENESS_READY_KIND) {
+                        decodeRuntimeLivenessReadyEvent(encoded);
+                        connectionLiveness.start();
+                        return;
+                    }
+                    if (kind === RUNTIME_HEARTBEAT_ACK_KIND) {
+                        connectionLiveness.acknowledge(decodeRuntimeHeartbeatAckEvent(encoded));
+                        return;
+                    }
+                    if (kind === SESSION_CANCEL_KIND) {
+                        const cancellation = decodeSessionCancelCommand(encoded);
+                        const turn = activeTurns.get(cancellation.commandId);
+                        if (turn === undefined || !turn.matches(cancellation)) {
+                            console.warn("Mobius daemon ignored cancellation for an inactive turn");
+                            return;
+                        }
+                        if (!turn.requestCancellation()) {
+                            return;
+                        }
                         audit.record({
-                            commandId: command.interactionId,
-                            event: "session_elicitation_resolved",
-                            sessionId: command.sessionId,
+                            commandId: cancellation.commandId,
+                            event: "session_cancellation_requested",
+                            sessionId: cancellation.sessionId,
                         });
-                    })
-                        .catch((error) => {
-                        reportOperationFailure(socket, command.interactionId, command.sessionId, error);
-                    });
-                    return;
-                }
-                if (kind === AGENT_INSTALL_REQUEST_KIND) {
-                    const command = decodeAgentInstallRequestCommand(encoded);
-                    void installations
-                        .request(command, signal)
-                        .catch((error) => {
-                        console.error("Mobius Agent installation failed", error);
-                    });
-                    return;
-                }
-                if (kind === AGENT_INSTALL_CANCEL_KIND) {
-                    const command = decodeAgentInstallCancelCommand(encoded);
-                    void installations
-                        .cancel(command.requestId)
+                        void sessions
+                            .cancelPrompt(cancellation.sessionId)
+                            .catch((error) => {
+                            console.error("Mobius daemon could not cancel the agent turn", error);
+                        });
+                        return;
+                    }
+                    if (kind === WORKSPACE_LIST_KIND) {
+                        const command = decodeWorkspaceListCommand(encoded);
+                        void executeWorkspaceList(socket, command, directories, audit, connectionController.signal);
+                        return;
+                    }
+                    if (kind === SESSION_PREPARE_KIND) {
+                        const command = decodeSessionPrepareCommand(encoded);
+                        void executeSessionPrepare(socket, command, config, directories, audit, sessions, connectionController.signal);
+                        return;
+                    }
+                    if (kind === SESSION_CONFIGURE_KIND) {
+                        const command = decodeSessionConfigureCommand(encoded);
+                        void executeSessionConfigure(socket, command, config, directories, audit, sessions, connectionController.signal);
+                        return;
+                    }
+                    if (kind === SESSION_PERMISSION_RESPOND_KIND) {
+                        const command = decodeSessionPermissionRespondCommand(encoded);
+                        void sessions
+                            .respondPermission(command)
+                            .then(() => {
+                            audit.record({
+                                commandId: command.interactionId,
+                                event: "session_permission_resolved",
+                                sessionId: command.sessionId,
+                            });
+                        })
+                            .catch((error) => {
+                            reportOperationFailure(socket, command.interactionId, command.sessionId, error);
+                        });
+                        return;
+                    }
+                    if (kind === SESSION_ELICITATION_RESPOND_KIND) {
+                        const command = decodeSessionElicitationRespondCommand(encoded);
+                        void sessions
+                            .respondElicitation(command)
+                            .then(() => {
+                            audit.record({
+                                commandId: command.interactionId,
+                                event: "session_elicitation_resolved",
+                                sessionId: command.sessionId,
+                            });
+                        })
+                            .catch((error) => {
+                            reportOperationFailure(socket, command.interactionId, command.sessionId, error);
+                        });
+                        return;
+                    }
+                    if (kind === AGENT_INSTALL_REQUEST_KIND) {
+                        const command = decodeAgentInstallRequestCommand(encoded);
+                        void installations
+                            .request(command, signal)
+                            .catch((error) => {
+                            console.error("Mobius Agent installation failed", error);
+                        });
+                        return;
+                    }
+                    if (kind === AGENT_INSTALL_CANCEL_KIND) {
+                        const command = decodeAgentInstallCancelCommand(encoded);
+                        void installations
+                            .cancel(command.requestId)
+                            .catch((error) => {
+                            reportOperationFailure(socket, command.requestId, "", error);
+                        });
+                        return;
+                    }
+                    if (kind !== SESSION_PROMPT_KIND) {
+                        throw new Error("Unsupported protocol message");
+                    }
+                    const command = decodeSessionPromptCommand(encoded);
+                    if (activeTurns.has(command.commandId)) {
+                        reportFailure(socket, command, "duplicate_command", "The command is already running");
+                        return;
+                    }
+                    const turn = new ActiveDaemonTurn(command, new AbortController());
+                    activeTurns.set(command.commandId, turn);
+                    void executePrompt(socket, command, config, directories, audit, sessions, turn.signal)
                         .catch((error) => {
-                        reportOperationFailure(socket, command.requestId, "", error);
+                        console.error("Mobius daemon turn failed", error);
+                    })
+                        .finally(() => {
+                        activeTurns.delete(command.commandId);
+                        connectionRefresh.afterTurnFinished();
                     });
-                    return;
                 }
-                if (kind !== SESSION_PROMPT_KIND) {
-                    throw new Error("Unsupported protocol message");
+                catch (error) {
+                    console.error("Mobius daemon rejected a message", error);
+                    socket.close(4008, "Invalid protocol message");
+                    rejectConnection();
                 }
-                const command = decodeSessionPromptCommand(encoded);
-                if (activeTurns.has(command.commandId)) {
-                    reportFailure(socket, command, "duplicate_command", "The command is already running");
-                    return;
-                }
-                const turn = new ActiveDaemonTurn(command, new AbortController());
-                activeTurns.set(command.commandId, turn);
-                void executePrompt(socket, command, config, directories, audit, sessions, turn.signal)
-                    .catch((error) => {
-                    console.error("Mobius daemon turn failed", error);
-                })
-                    .finally(() => {
-                    activeTurns.delete(command.commandId);
-                    connectionRefresh.afterTurnFinished();
-                });
-            }
-            catch (error) {
-                console.error("Mobius daemon rejected a message", error);
-                socket.close(4008, "Invalid protocol message");
-                rejectConnection();
+            };
+            socket.addEventListener("close", handleClose);
+            socket.addEventListener("error", handleError);
+            socket.addEventListener("message", handleMessage);
+            if (signal.aborted) {
+                stop();
             }
-        };
-        socket.addEventListener("close", handleClose);
-        socket.addEventListener("error", handleError);
-        socket.addEventListener("message", handleMessage);
-        if (signal.aborted) {
-            stop();
-        }
-    });
+        });
+    }
+    finally {
+        connectionController.abort();
+        await Promise.all([...nativeRequests.values()].map((request) => request.completion));
+    }
 }
 export async function runDaemon(config, audit, signal, timer = systemDaemonTimer) {
     const installationAudit = new AuditInstallationEvents(audit);
     const stateDirectory = readStateDirectory();
     const specifications = supportedLocalAgentSpecifications();
     const installationExecutor = new FixedInstallationExecutor({
-        approvedRoot: config.approvedRoot,
+        defaultWorkspace: config.defaultWorkspace,
         audit: installationAudit,
         catalog: config.catalog,
         environment: process.env,
@@ -726,26 +807,26 @@ export async function runDaemon(config, audit, signal, timer = systemDaemonTimer
         stateDirectory,
     });
     await new AutomaticAdapterProvisioner({
-        approvedRoot: config.approvedRoot,
+        defaultWorkspace: config.defaultWorkspace,
         audit: installationAudit,
         catalog: config.catalog,
         environment: process.env,
     }, new ManagedAdapterInstaller({
-        approvedRoot: config.approvedRoot,
         environment: process.env,
         stateDirectory,
     }), specifications).prepare(signal);
     const sessionStore = new SqliteAcpSessionStore(config.auditDatabasePath);
     const sessions = new AcpSessionManager(new NullAcpSessionObserver(), sessionStore);
-    const directories = new WorkspaceDirectoryService(config.bindingId, config.approvedRoot);
+    const directories = new WorkspaceDirectoryService(config.bindingId, config.defaultWorkspace);
     const installationObserver = new DaemonInstallationObserver();
+    const nativeSessions = new NativeSessionService(config, directories, sessions, audit);
     const installations = new AgentInstallationManager(specifications, new ConsoleInstallationAuthorizer(stateDirectory), installationExecutor, installationObserver, installationAudit);
     let retryAnnounced = false;
     try {
         while (!signal.aborted) {
             try {
                 await publishAgentCatalog(config, signal);
-                await runRelayConnection(config, directories, audit, sessions, installations, installationObserver, signal, timer);
+                await runRelayConnection(config, directories, audit, sessions, installations, installationObserver, nativeSessions, signal, timer);
                 retryAnnounced = false;
             }
             catch {