@moxt-ai/mobius 0.0.2 → 0.0.4

package/dist/relay-connection/liveness.d.ts

@@ -0,0 +1,14 @@
+import { type RuntimeHeartbeatAckEvent } from "@moxt-ai/mobius-protocol";
+import type { DaemonTimer } from "./timer.ts";
+export interface RelayLivenessTransport {
+    readonly send: (message: string) => void;
+    readonly unresponsive: () => void;
+}
+export declare class RelayConnectionLiveness {
+    #private;
+    constructor(timer: DaemonTimer, transport: RelayLivenessTransport);
+    readonly acknowledge: (event: RuntimeHeartbeatAckEvent) => void;
+    readonly close: () => void;
+    readonly start: () => void;
+}
+//# sourceMappingURL=liveness.d.ts.map

package/dist/relay-connection/liveness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveness.d.ts","sourceRoot":"","sources":["../../src/relay-connection/liveness.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAuB,WAAW,EAAE,MAAM,YAAY,CAAC;AA+BnE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;CACnC;AAED,qBAAa,uBAAuB;;IAKlC,YAAY,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,sBAAsB,EAGhE;IAED,QAAQ,CAAC,WAAW,UAAW,wBAAwB,KAAG,IAAI,CAc5D;IAEF,QAAQ,CAAC,KAAK,QAAO,IAAI,CAYvB;IAEF,QAAQ,CAAC,KAAK,QAAO,IAAI,CAevB;CAuCH"}

package/dist/relay-connection/liveness.js

@@ -0,0 +1,102 @@
+import { randomUUID } from "node:crypto";
+import { encodeRuntimeHeartbeatEvent, MOBIUS_PROTOCOL_VERSION, RUNTIME_HEARTBEAT_KIND, } from "@moxt-ai/mobius-protocol";
+const HEARTBEAT_ACK_TIMEOUT_MILLISECONDS = 10_000;
+const HEARTBEAT_INTERVAL_MILLISECONDS = 20_000;
+class RelayLivenessState {
+}
+class UnsupportedRelayLivenessState extends RelayLivenessState {
+}
+class AwaitingHeartbeatAckState extends RelayLivenessState {
+    heartbeatId;
+    timeout;
+    constructor(heartbeatId, timeout) {
+        super();
+        this.heartbeatId = heartbeatId;
+        this.timeout = timeout;
+    }
+}
+class WaitingForHeartbeatState extends RelayLivenessState {
+    schedule;
+    constructor(schedule) {
+        super();
+        this.schedule = schedule;
+    }
+}
+class FinishedRelayLivenessState extends RelayLivenessState {
+}
+export class RelayConnectionLiveness {
+    #timer;
+    #transport;
+    #state = new UnsupportedRelayLivenessState();
+    constructor(timer, transport) {
+        this.#timer = timer;
+        this.#transport = transport;
+    }
+    acknowledge = (event) => {
+        if (!(this.#state instanceof AwaitingHeartbeatAckState)) {
+            throw new Error("Unexpected relay heartbeat acknowledgement");
+        }
+        if (event.heartbeatId !== this.#state.heartbeatId) {
+            throw new Error("Relay acknowledged the wrong heartbeat");
+        }
+        this.#state.timeout.cancel();
+        this.#state = new WaitingForHeartbeatState(this.#timer.schedule(this.#sendHeartbeat, HEARTBEAT_INTERVAL_MILLISECONDS));
+    };
+    close = () => {
+        if (this.#state instanceof AwaitingHeartbeatAckState) {
+            this.#state.timeout.cancel();
+        }
+        else if (this.#state instanceof WaitingForHeartbeatState) {
+            this.#state.schedule.cancel();
+        }
+        else if (!(this.#state instanceof UnsupportedRelayLivenessState) &&
+            !(this.#state instanceof FinishedRelayLivenessState)) {
+            throw new Error("Unknown relay liveness state");
+        }
+        this.#state = new FinishedRelayLivenessState();
+    };
+    start = () => {
+        if (this.#state instanceof UnsupportedRelayLivenessState) {
+            this.#sendHeartbeat();
+            return;
+        }
+        if (this.#state instanceof AwaitingHeartbeatAckState ||
+            this.#state instanceof WaitingForHeartbeatState) {
+            return;
+        }
+        if (this.#state instanceof FinishedRelayLivenessState) {
+            return;
+        }
+        throw new Error("Unknown relay liveness state");
+    };
+    #handleTimeout = () => {
+        if (this.#state instanceof FinishedRelayLivenessState) {
+            return;
+        }
+        if (!(this.#state instanceof AwaitingHeartbeatAckState)) {
+            throw new Error("Heartbeat timeout occurred in an invalid state");
+        }
+        this.#state.timeout.cancel();
+        this.#state = new FinishedRelayLivenessState();
+        this.#transport.unresponsive();
+    };
+    #sendHeartbeat = () => {
+        if (this.#state instanceof WaitingForHeartbeatState) {
+            this.#state.schedule.cancel();
+        }
+        else if (!(this.#state instanceof UnsupportedRelayLivenessState)) {
+            if (this.#state instanceof FinishedRelayLivenessState) {
+                return;
+            }
+            throw new Error("Heartbeat was scheduled in an invalid state");
+        }
+        const heartbeatId = randomUUID();
+        this.#state = new AwaitingHeartbeatAckState(heartbeatId, this.#timer.schedule(this.#handleTimeout, HEARTBEAT_ACK_TIMEOUT_MILLISECONDS));
+        this.#transport.send(encodeRuntimeHeartbeatEvent({
+            heartbeatId,
+            kind: RUNTIME_HEARTBEAT_KIND,
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+        }));
+    };
+}
+//# sourceMappingURL=liveness.js.map

package/dist/relay-connection/liveness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveness.js","sourceRoot":"","sources":["../../src/relay-connection/liveness.ts"],"names":[],"mappings":"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"}

package/dist/relay-connection/timer.d.ts

@@ -0,0 +1,8 @@
+export interface DaemonScheduledTask {
+    readonly cancel: () => void;
+}
+export interface DaemonTimer {
+    readonly schedule: (callback: () => void, milliseconds: number) => DaemonScheduledTask;
+}
+export declare const systemDaemonTimer: DaemonTimer;
+//# sourceMappingURL=timer.d.ts.map

package/dist/relay-connection/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/relay-connection/timer.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,CACjB,QAAQ,EAAE,MAAM,IAAI,EACpB,YAAY,EAAE,MAAM,KACjB,mBAAmB,CAAC;CAC1B;AAYD,eAAO,MAAM,iBAAiB,EAAE,WAAqC,CAAC"}

package/dist/relay-connection/timer.js

@@ -0,0 +1,8 @@
+class SystemDaemonTimer {
+    schedule = (callback, milliseconds) => {
+        const timeout = setTimeout(callback, milliseconds);
+        return { cancel: () => clearTimeout(timeout) };
+    };
+}
+export const systemDaemonTimer = new SystemDaemonTimer();
+//# sourceMappingURL=timer.js.map

package/dist/relay-connection/timer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.js","sourceRoot":"","sources":["../../src/relay-connection/timer.ts"],"names":[],"mappings":"AAWA,MAAM,iBAAiB;IACZ,QAAQ,GAAG,CAClB,QAAoB,EACpB,YAAoB,EACC,EAAE;QACvB,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QACnD,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC;IACjD,CAAC,CAAC;CACH;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAgB,IAAI,iBAAiB,EAAE,CAAC"}

package/dist/run-daemon.d.ts

@@ -1,4 +1,5 @@
 import type { AuditStore } from "./audit/audit-store.ts";
 import { type DaemonConfig } from "./config.ts";
-export declare function runDaemon(config: DaemonConfig, audit: AuditStore, signal: AbortSignal): Promise<void>;
+import { type DaemonTimer } from "./relay-connection/timer.ts";
+export declare function runDaemon(config: DaemonConfig, audit: AuditStore, signal: AbortSignal, timer?: DaemonTimer): Promise<void>;
 //# sourceMappingURL=run-daemon.d.ts.map

package/dist/run-daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-daemon.d.ts","sourceRoot":"","sources":["../src/run-daemon.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAE,KAAK,YAAY,EAAkB,MAAM,aAAa,CAAC;AA4UhE,wBAAsB,SAAS,CAC7B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,IAAI,CAAC,CAwBf"}
+{"version":3,"file":"run-daemon.d.ts","sourceRoot":"","sources":["../src/run-daemon.ts"],"names":[],"mappings":"AAsEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD,OAAO,EAAE,KAAK,YAAY,EAAkB,MAAM,aAAa,CAAC;AAGhE,OAAO,EAEL,KAAK,WAAW,EAEjB,MAAM,6BAA6B,CAAC;AAqzBrC,wBAAsB,SAAS,CAC7B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,WAAW,EACnB,KAAK,GAAE,WAA+B,GACrC,OAAO,CAAC,IAAI,CAAC,CAwCf"}

package/dist/run-daemon.js

@@ -1,11 +1,119 @@
 import { randomUUID } from "node:crypto";
-import { AGENT_ACTIVITY_KIND, AGENT_MESSAGE_DELTA_KIND, decodeMessageKind, decodeSessionCancelCommand, decodeSessionPromptCommand, encodeAgentActivityEvent, encodeAgentMessageDeltaEvent, encodeSessionCompletedEvent, encodeSessionFailedEvent, encodeSessionStartedEvent, MOBIUS_PROTOCOL_VERSION, SESSION_CANCEL_KIND, SESSION_COMPLETED_KIND, SESSION_FAILED_KIND, SESSION_PROMPT_KIND, SESSION_STARTED_KIND, } from "@moxt-ai/mobius-protocol";
+import { basename } from "node:path";
+import { AGENT_ACTIVITY_KIND, AGENT_MESSAGE_DELTA_KIND, decodeMessageKind, decodeRuntimeHeartbeatAckEvent, decodeRuntimeLivenessReadyEvent, decodeSessionCancelCommand, decodeSessionConfigureCommand, decodeSessionElicitationRespondCommand, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionPromptCommand, decodeWorkspaceListCommand, encodeAgentActivityEvent, encodeAgentContentEvent, 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 { WebSocket } from "undici";
-import { AcpSessionManager } from "./acp/session-manager.js";
-import { authorizeBinding } from "./authorization/authorize-binding.js";
+import { AcpExecutionError, AcpSessionManager, NullAcpSessionObserver, } from "./acp/session-manager.js";
+import { SqliteAcpSessionStore } from "./acp/session-store.js";
+import { LocalAuthorizationError } from "./authorization/authorize-binding.js";
+import { WorkspaceDirectoryService } from "./authorization/workspace-directory.js";
 import { findLocalAgent } from "./config.js";
 import { connectRelay } from "./relay-connection/connect.js";
+import { RelayConnectionLiveness } from "./relay-connection/liveness.js";
+import { systemDaemonTimer, } from "./relay-connection/timer.js";
 const RELAY_RECONNECT_DELAY_MILLISECONDS = 500;
+const RELAY_CONNECTION_REFRESH_MILLISECONDS = 20 * 60 * 1_000;
+class RelayConnectionRefreshState {
+}
+class ScheduledRelayConnectionRefreshState extends RelayConnectionRefreshState {
+}
+class DueRelayConnectionRefreshState extends RelayConnectionRefreshState {
+}
+class FinishedRelayConnectionRefreshState extends RelayConnectionRefreshState {
+}
+class RelayConnectionRefresh {
+    #isSafe;
+    #refresh;
+    #scheduledTask;
+    #state = new ScheduledRelayConnectionRefreshState();
+    constructor(timer, isSafe, refresh) {
+        this.#isSafe = isSafe;
+        this.#refresh = refresh;
+        this.#scheduledTask = timer.schedule(this.#request, RELAY_CONNECTION_REFRESH_MILLISECONDS);
+    }
+    afterTurnFinished = () => {
+        if (this.#state instanceof DueRelayConnectionRefreshState) {
+            this.#request();
+            return;
+        }
+        if (this.#state instanceof ScheduledRelayConnectionRefreshState ||
+            this.#state instanceof FinishedRelayConnectionRefreshState) {
+            return;
+        }
+        throw new Error("Unknown relay connection refresh state");
+    };
+    close = () => {
+        this.#scheduledTask.cancel();
+        this.#state = new FinishedRelayConnectionRefreshState();
+    };
+    #request = () => {
+        if (this.#state instanceof FinishedRelayConnectionRefreshState) {
+            return;
+        }
+        if (!(this.#state instanceof ScheduledRelayConnectionRefreshState) &&
+            !(this.#state instanceof DueRelayConnectionRefreshState)) {
+            throw new Error("Unknown relay connection refresh state");
+        }
+        if (!this.#isSafe()) {
+            this.#state = new DueRelayConnectionRefreshState();
+            return;
+        }
+        this.#state = new FinishedRelayConnectionRefreshState();
+        this.#scheduledTask.cancel();
+        this.#refresh();
+    };
+}
+class DaemonAcpObserver {
+    #socket;
+    constructor(socket) {
+        this.#socket = socket;
+    }
+    onCommands = (event) => {
+        send(this.#socket, encodeSessionCommandsUpdatedEvent(event));
+        return Promise.resolve();
+    };
+    onConfig = (event) => {
+        send(this.#socket, encodeSessionConfigUpdatedEvent(event));
+        return Promise.resolve();
+    };
+    onContent = (event) => {
+        send(this.#socket, encodeAgentContentEvent(event));
+        return Promise.resolve();
+    };
+    onElicitation = (event) => {
+        send(this.#socket, encodeSessionElicitationRequestedEvent(event));
+        return Promise.resolve();
+    };
+    onElicitationResolved = (event) => {
+        send(this.#socket, encodeSessionElicitationResolvedEvent(event));
+        return Promise.resolve();
+    };
+    onInfo = (event) => {
+        send(this.#socket, encodeSessionInfoUpdatedEvent(event));
+        return Promise.resolve();
+    };
+    onPermission = (event) => {
+        send(this.#socket, encodeSessionPermissionRequestedEvent(event));
+        return Promise.resolve();
+    };
+    onPermissionResolved = (event) => {
+        send(this.#socket, encodeSessionPermissionResolvedEvent(event));
+        return Promise.resolve();
+    };
+    onUsage = (event) => {
+        send(this.#socket, encodeSessionUsageUpdatedEvent(event));
+        return Promise.resolve();
+    };
+}
+class ResolvedSessionDirectories {
+    additionalDirectories;
+    additionalDirectoryEntries;
+    cwd;
+    constructor(cwd, additionalDirectories, additionalDirectoryEntries) {
+        this.additionalDirectories = additionalDirectories;
+        this.additionalDirectoryEntries = additionalDirectoryEntries;
+        this.cwd = cwd;
+    }
+}
 class ActiveDaemonTurn {
     command;
     #connectionController;
@@ -49,9 +157,148 @@ function reportFailure(socket, command, code, message) {
         sessionId: command.sessionId,
     }));
 }
-async function executePrompt(socket, command, config, audit, sessions, signal) {
+function operationErrorCode(error) {
+    if (error instanceof AcpExecutionError ||
+        error instanceof LocalAuthorizationError) {
+        return error.code;
+    }
+    return "session_operation_failed";
+}
+function operationErrorMessage(error) {
+    if (error instanceof AcpExecutionError ||
+        error instanceof LocalAuthorizationError) {
+        return error.message;
+    }
+    return "The local agent operation could not be completed";
+}
+function reportOperationFailure(socket, requestId, sessionId, error) {
+    if (socket.readyState !== WebSocket.OPEN) {
+        return;
+    }
+    send(socket, encodeSessionOperationFailedEvent({
+        code: operationErrorCode(error),
+        kind: "session.operation.failed",
+        message: operationErrorMessage(error),
+        protocolVersion: MOBIUS_PROTOCOL_VERSION,
+        requestId,
+        sessionId,
+    }));
+}
+async function resolveSessionDirectories(directories, bindingId, directoryId, additionalDirectoryIds) {
+    const cwd = await directories.resolve(bindingId, directoryId);
+    const additionalDirectories = [];
+    const additionalDirectoryEntries = [];
+    const unique = new Set([cwd]);
+    for (const additionalDirectoryId of additionalDirectoryIds) {
+        const directory = await directories.resolve(bindingId, additionalDirectoryId);
+        if (unique.has(directory)) {
+            throw new LocalAuthorizationError("Workspace directories must resolve to distinct locations");
+        }
+        unique.add(directory);
+        additionalDirectories.push(directory);
+        additionalDirectoryEntries.push({
+            directoryId: additionalDirectoryId,
+            name: basename(directory),
+        });
+    }
+    return new ResolvedSessionDirectories(cwd, additionalDirectories, additionalDirectoryEntries);
+}
+async function executeWorkspaceList(socket, command, directories, audit) {
+    try {
+        const listing = await directories.list(command.bindingId, command.directoryId);
+        audit.record({
+            commandId: command.requestId,
+            event: "workspace_list_authorized",
+            sessionId: "workspace-browser",
+        });
+        send(socket, encodeWorkspaceEntriesEvent({
+            bindingId: command.bindingId,
+            directoryId: listing.directoryId,
+            directoryLabel: listing.directoryLabel,
+            entries: listing.entries,
+            kind: "workspace.entries",
+            parentDirectoryId: listing.parentDirectoryId,
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+            requestId: command.requestId,
+        }));
+    }
+    catch (error) {
+        reportOperationFailure(socket, command.requestId, "", error);
+    }
+}
+async function executeSessionPrepare(socket, command, config, directories, audit, sessions, signal) {
+    try {
+        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds);
+        const agent = findLocalAgent(config.agents, command.agentId);
+        const prepared = await sessions.prepareSession({
+            additionalDirectories: resolved.additionalDirectories,
+            agent,
+            cwd: resolved.cwd,
+            sessionId: command.sessionId,
+            signal,
+        });
+        const listing = await directories.list(command.bindingId, command.directoryId);
+        audit.record({
+            commandId: command.requestId,
+            event: "session_prepared",
+            sessionId: command.sessionId,
+        });
+        send(socket, encodeSessionReadyEvent({
+            additionalDirectories: resolved.additionalDirectoryEntries,
+            agentId: command.agentId,
+            agentName: prepared.agentName,
+            agentVersion: prepared.agentVersion,
+            capabilities: prepared.capabilities,
+            commands: prepared.commands,
+            configOptions: prepared.configOptions,
+            directoryId: command.directoryId,
+            directoryLabel: listing.directoryLabel,
+            kind: "session.ready",
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+            requestId: command.requestId,
+            restored: prepared.restored,
+            sessionId: command.sessionId,
+        }));
+    }
+    catch (error) {
+        reportOperationFailure(socket, command.requestId, command.sessionId, error);
+    }
+}
+async function executeSessionConfigure(socket, command, config, directories, audit, sessions, signal) {
+    try {
+        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds);
+        const configOptions = await sessions.configureSession({
+            additionalDirectories: resolved.additionalDirectories,
+            agent: findLocalAgent(config.agents, command.agentId),
+            booleanValue: command.booleanValue,
+            configId: command.configId,
+            cwd: resolved.cwd,
+            requestId: command.requestId,
+            sessionId: command.sessionId,
+            signal,
+            value: command.value,
+            valueType: command.valueType,
+        });
+        audit.record({
+            commandId: command.requestId,
+            event: "session_configured",
+            sessionId: command.sessionId,
+        });
+        send(socket, encodeSessionConfigUpdatedEvent({
+            configOptions,
+            kind: "session.config.updated",
+            protocolVersion: MOBIUS_PROTOCOL_VERSION,
+            requestId: command.requestId,
+            sessionId: command.sessionId,
+        }));
+    }
+    catch (error) {
+        reportOperationFailure(socket, command.requestId, command.sessionId, error);
+    }
+}
+async function executePrompt(socket, command, config, directories, audit, sessions, signal) {
     try {
-        const approvedRoot = await authorizeBinding(command.bindingId, config.bindingId, config.approvedRoot);
+        const resolved = await resolveSessionDirectories(directories, command.bindingId, command.directoryId, command.additionalDirectoryIds);
         const agent = findLocalAgent(config.agents, command.agentId);
         const processAttemptId = randomUUID();
         audit.record({
@@ -67,13 +314,17 @@ async function executePrompt(socket, command, config, audit, sessions, signal) {
             sessionId: command.sessionId,
         }));
         const result = await sessions.runPrompt({
+            additionalDirectories: resolved.additionalDirectories,
             agent,
-            cwd: approvedRoot,
+            commandId: command.commandId,
+            cwd: resolved.cwd,
+            images: command.images,
             onActivity: (activity) => {
                 send(socket, encodeAgentActivityEvent({
                     activityId: activity.activityId,
                     activityType: activity.activityType,
                     commandId: command.commandId,
+                    content: activity.content,
                     input: activity.input,
                     kind: AGENT_ACTIVITY_KIND,
                     locations: activity.locations,
@@ -99,6 +350,7 @@ async function executePrompt(socket, command, config, audit, sessions, signal) {
                 return Promise.resolve();
             },
             prompt: command.prompt,
+            resources: command.resources,
             sessionId: command.sessionId,
             signal,
         });
@@ -127,30 +379,37 @@ async function executePrompt(socket, command, config, audit, sessions, signal) {
         console.error("Mobius daemon command failed", error);
     }
 }
-function waitForRelayRetry(signal) {
+function waitForRelayRetry(signal, timer) {
     if (signal.aborted) {
         return Promise.resolve();
     }
     return new Promise((resolve) => {
-        const timeout = setTimeout(finish, RELAY_RECONNECT_DELAY_MILLISECONDS);
+        const retry = timer.schedule(finish, RELAY_RECONNECT_DELAY_MILLISECONDS);
         function finish() {
-            clearTimeout(timeout);
+            retry.cancel();
             signal.removeEventListener("abort", finish);
             resolve();
         }
         signal.addEventListener("abort", finish, { once: true });
     });
 }
-async function runRelayConnection(config, audit, sessions, signal) {
-    const socket = await connectRelay(config.relayUrl, signal);
+async function runRelayConnection(config, directories, audit, sessions, 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();
+    sessions.setObserver(new DaemonAcpObserver(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);
+            connectionController.abort();
             for (const turn of activeTurns.values()) {
                 turn.abortConnection();
             }
@@ -176,6 +435,18 @@ async function runRelayConnection(config, audit, sessions, signal) {
             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();
@@ -190,11 +461,21 @@ async function runRelayConnection(config, audit, sessions, signal) {
         const handleMessage = (event) => {
             const encoded = event.data;
             if (typeof encoded !== "string") {
-                socket.close(1003, "Text message required");
+                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;
+                }
                 if (kind === SESSION_CANCEL_KIND) {
                     const cancellation = decodeSessionCancelCommand(encoded);
                     const turn = activeTurns.get(cancellation.commandId);
@@ -215,10 +496,56 @@ async function runRelayConnection(config, audit, sessions, signal) {
                     });
                     return;
                 }
-                if (kind !== SESSION_PROMPT_KIND) {
-                    socket.close(1008, "Unsupported protocol message");
+                if (kind === WORKSPACE_LIST_KIND) {
+                    const command = decodeWorkspaceListCommand(encoded);
+                    void executeWorkspaceList(socket, command, directories, audit);
+                    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 !== 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");
@@ -226,17 +553,19 @@ async function runRelayConnection(config, audit, sessions, signal) {
                 }
                 const turn = new ActiveDaemonTurn(command, new AbortController());
                 activeTurns.set(command.commandId, turn);
-                void executePrompt(socket, command, config, audit, sessions, turn.signal)
+                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(1008, "Invalid protocol message");
+                socket.close(4008, "Invalid protocol message");
+                rejectConnection();
             }
         };
         socket.addEventListener("close", handleClose);
@@ -247,13 +576,15 @@ async function runRelayConnection(config, audit, sessions, signal) {
         }
     });
 }
-export async function runDaemon(config, audit, signal) {
-    const sessions = new AcpSessionManager();
+export async function runDaemon(config, audit, signal, timer = systemDaemonTimer) {
+    const sessionStore = new SqliteAcpSessionStore(config.auditDatabasePath);
+    const sessions = new AcpSessionManager(new NullAcpSessionObserver(), sessionStore);
+    const directories = new WorkspaceDirectoryService(config.bindingId, config.approvedRoot);
     let retryAnnounced = false;
     try {
         while (!signal.aborted) {
             try {
-                await runRelayConnection(config, audit, sessions, signal);
+                await runRelayConnection(config, directories, audit, sessions, signal, timer);
                 retryAnnounced = false;
             }
             catch {
@@ -265,11 +596,12 @@ export async function runDaemon(config, audit, signal) {
                     retryAnnounced = true;
                 }
             }
-            await waitForRelayRetry(signal);
+            await waitForRelayRetry(signal, timer);
         }
     }
     finally {
         await sessions.close();
+        sessionStore.close();
     }
 }
 //# sourceMappingURL=run-daemon.js.map