@getpaseo/server 0.1.3 → 0.1.6

package/dist/server/client/daemon-client.js

@@ -1,7 +1,10 @@
 import { AgentCreateFailedStatusPayloadSchema, AgentCreatedStatusPayloadSchema, AgentRefreshedStatusPayloadSchema, AgentResumedStatusPayloadSchema, RestartRequestedStatusPayloadSchema, SessionInboundMessageSchema, WSOutboundMessageSchema, } from "../shared/messages.js";
 import { getAgentProviderDefinition } from "../server/agent/provider-manifest.js";
-import { createClientChannel, } from "@getpaseo/relay/e2ee";
 import { isRelayClientWebSocketUrl } from "../shared/daemon-endpoints.js";
+import { asUint8Array, decodeBinaryMuxFrame, encodeBinaryMuxFrame, BinaryMuxChannel, TerminalBinaryFlags, TerminalBinaryMessageType, } from "../shared/binary-mux.js";
+import { encodeTerminalKeyInput, } from "../shared/terminal-key-input.js";
+import { TerminalStreamManager, } from "./daemon-client-terminal-stream-manager.js";
+import { createRelayE2eeTransportFactory, createWebSocketTransportFactory, decodeMessageData, defaultWebSocketFactory, describeTransportClose, describeTransportError, encodeUtf8String, safeRandomId, } from "./daemon-client-transport.js";
 const consoleLogger = {
     debug: (obj, msg) => console.debug(msg, obj),
     info: (obj, msg) => console.info(msg, obj),
@@ -21,6 +24,12 @@ const DEFAULT_RECONNECT_BASE_DELAY_MS = 1500;
 const DEFAULT_RECONNECT_MAX_DELAY_MS = 30000;
 /** Default timeout for waiting for connection before sending queued messages */
 const DEFAULT_SEND_QUEUE_TIMEOUT_MS = 10000;
+const DEFAULT_DICTATION_FINISH_ACCEPT_TIMEOUT_MS = 15000;
+const DEFAULT_DICTATION_FINISH_FALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_DICTATION_FINISH_TIMEOUT_GRACE_MS = 5000;
+function isWaiterTimeoutError(error) {
+    return (error instanceof Error && error.message.startsWith("Timeout waiting for message"));
+}
 export class DaemonClient {
     constructor(config) {
         this.config = config;
@@ -43,9 +52,21 @@ export class DaemonClient {
         this.connectionState = { status: "idle" };
         this.agentUpdateSubscriptions = new Map();
         this.checkoutDiffSubscriptions = new Map();
+        this.terminalDirectorySubscriptions = new Set();
         this.pendingSendQueue = [];
         this.relayClientId = null;
         this.logger = config.logger ?? consoleLogger;
+        this.terminalStreams = new TerminalStreamManager({
+            sendAck: (ack) => {
+                this.sendBinaryFrame({
+                    channel: BinaryMuxChannel.Terminal,
+                    messageType: TerminalBinaryMessageType.Ack,
+                    streamId: ack.streamId,
+                    offset: ack.offset,
+                    payload: new Uint8Array(0),
+                });
+            },
+        });
         // Relay requires a clientId so the daemon can create an independent
         // socket + E2EE channel per connected client. Generate one per DaemonClient
         // instance (stable across reconnects in this tab/app session).
@@ -132,6 +153,7 @@ export class DaemonClient {
                     this.updateConnectionState({ status: "connected" });
                     this.resubscribeAgentUpdates();
                     this.resubscribeCheckoutDiffSubscriptions();
+                    this.resubscribeTerminalDirectorySubscriptions();
                     this.flushPendingSendQueue();
                     this.resolveConnect();
                 }),
@@ -235,6 +257,7 @@ export class DaemonClient {
         }
         this.disposeTransport(1000, "Client closed");
         this.clearWaiters(new Error("Daemon client closed"));
+        this.terminalStreams.clearAll();
         this.updateConnectionState({
             status: "disconnected",
             reason: "client_closed",
@@ -329,6 +352,23 @@ export class DaemonClient {
             throw error instanceof Error ? error : new Error(String(error));
         }
     }
+    sendBinaryFrame(frame) {
+        if (!this.transport || this.connectionState.status !== "connected") {
+            if (this.config.suppressSendErrors) {
+                return;
+            }
+            throw new Error(`Transport not connected (status: ${this.connectionState.status})`);
+        }
+        try {
+            this.transport.send(encodeBinaryMuxFrame(frame));
+        }
+        catch (error) {
+            if (this.config.suppressSendErrors) {
+                return;
+            }
+            throw error instanceof Error ? error : new Error(String(error));
+        }
+    }
     /**
      * Send a session message for RPC methods that create waiters.
      * If the connection is still being established ("connecting"), the message
@@ -428,6 +468,43 @@ export class DaemonClient {
         }
         return result.value;
     }
+    async sendCorrelatedRequest(params) {
+        return this.sendRequest({
+            requestId: params.requestId,
+            message: params.message,
+            timeout: params.timeout,
+            options: params.options,
+            select: (msg) => {
+                const correlated = msg;
+                if (correlated.type !== params.responseType) {
+                    return null;
+                }
+                const payload = correlated.payload;
+                if (payload.requestId !== params.requestId) {
+                    return null;
+                }
+                if (!params.selectPayload) {
+                    return payload;
+                }
+                return params.selectPayload(payload);
+            },
+        });
+    }
+    sendCorrelatedSessionRequest(params) {
+        const resolvedRequestId = this.createRequestId(params.requestId);
+        const message = SessionInboundMessageSchema.parse({
+            ...params.message,
+            requestId: resolvedRequestId,
+        });
+        return this.sendCorrelatedRequest({
+            requestId: resolvedRequestId,
+            message,
+            responseType: params.responseType,
+            timeout: params.timeout,
+            options: { skipQueue: true },
+            ...(params.selectPayload ? { selectPayload: params.selectPayload } : {}),
+        });
+    }
     sendSessionMessageStrict(message) {
         if (!this.transport || this.connectionState.status !== "connected") {
             throw new Error("Transport not connected");
@@ -496,6 +573,8 @@ export class DaemonClient {
             type: "fetch_agents_request",
             requestId: resolvedRequestId,
             ...(options?.filter ? { filter: options.filter } : {}),
+            ...(options?.sort ? { sort: options.sort } : {}),
+            ...(options?.page ? { page: options.page } : {}),
         });
         return this.sendRequest({
             requestId: resolvedRequestId,
@@ -509,29 +588,6 @@ export class DaemonClient {
                 if (msg.payload.requestId !== resolvedRequestId) {
                     return null;
                 }
-                return msg.payload.agents;
-            },
-        });
-    }
-    async fetchAgentsGroupedByProject(options) {
-        const resolvedRequestId = this.createRequestId(options?.requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "fetch_agents_grouped_by_project_request",
-            requestId: resolvedRequestId,
-            ...(options?.filter ? { filter: options.filter } : {}),
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 15000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "fetch_agents_grouped_by_project_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
                 return msg.payload;
             },
         });
@@ -610,6 +666,17 @@ export class DaemonClient {
             this.sendSessionMessage(message);
         }
     }
+    resubscribeTerminalDirectorySubscriptions() {
+        if (this.terminalDirectorySubscriptions.size === 0) {
+            return;
+        }
+        for (const cwd of this.terminalDirectorySubscriptions) {
+            this.sendSessionMessage({
+                type: "subscribe_terminals_request",
+                cwd,
+            });
+        }
+    }
     // ============================================================================
     // Agent Lifecycle
     // ============================================================================
@@ -783,20 +850,24 @@ export class DaemonClient {
             },
         });
     }
-    async initializeAgent(agentId, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
+    async fetchAgentTimeline(agentId, options = {}) {
+        const resolvedRequestId = this.createRequestId(options.requestId);
         const message = SessionInboundMessageSchema.parse({
-            type: "initialize_agent_request",
+            type: "fetch_agent_timeline_request",
             agentId,
             requestId: resolvedRequestId,
+            ...(options.direction ? { direction: options.direction } : {}),
+            ...(options.cursor ? { cursor: options.cursor } : {}),
+            ...(typeof options.limit === "number" ? { limit: options.limit } : {}),
+            ...(options.projection ? { projection: options.projection } : {}),
         });
         const payload = await this.sendRequest({
             requestId: resolvedRequestId,
             message,
-            timeout: 10000,
+            timeout: 15000,
             options: { skipQueue: true },
             select: (msg) => {
-                if (msg.type !== "initialize_agent_request") {
+                if (msg.type !== "fetch_agent_timeline_response") {
                     return null;
                 }
                 if (msg.payload.requestId !== resolvedRequestId) {
@@ -808,11 +879,7 @@ export class DaemonClient {
         if (payload.error) {
             throw new Error(payload.error);
         }
-        const agent = await this.fetchAgent(agentId);
-        if (!agent) {
-            throw new Error(`Agent not found after initialize: ${agentId}`);
-        }
-        return agent;
+        return payload;
     }
     // ============================================================================
     // Agent Interaction
@@ -972,7 +1039,7 @@ export class DaemonClient {
             ...(agentId ? { agentId } : {}),
             requestId,
         });
-        return this.sendRequest({
+        const response = await this.sendRequest({
             requestId,
             message,
             timeout: 10000,
@@ -986,11 +1053,18 @@ export class DaemonClient {
                 return msg.payload;
             },
         });
+        if (!response.accepted) {
+            const codeSuffix = typeof response.reasonCode === "string" && response.reasonCode.trim().length > 0
+                ? ` (${response.reasonCode})`
+                : "";
+            throw new Error((response.error ?? "Failed to set voice mode") + codeSuffix);
+        }
+        return response;
     }
     async sendVoiceAudioChunk(audio, format, isLast) {
         this.sendSessionMessage({ type: "voice_audio_chunk", audio, format, isLast });
     }
-    startDictationStream(dictationId, format) {
+    async startDictationStream(dictationId, format) {
         const ack = this.waitForWithCancel((msg) => {
             if (msg.type !== "dictation_stream_ack") {
                 return null;
@@ -1016,23 +1090,22 @@ export class DaemonClient {
         const errorPromise = streamError.promise.then((payload) => {
             throw new Error(payload.error);
         });
+        const cleanupError = new Error("Cancelled dictation start waiter");
         try {
             this.sendSessionMessageStrict({ type: "dictation_stream_start", dictationId, format });
+            await Promise.race([ackPromise, errorPromise]);
         }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            ack.cancel(err);
-            streamError.cancel(err);
+        finally {
+            ack.cancel(cleanupError);
+            streamError.cancel(cleanupError);
             void ackPromise.catch(() => undefined);
             void errorPromise.catch(() => undefined);
-            throw err;
         }
-        return Promise.race([ackPromise, errorPromise]);
     }
     sendDictationStreamChunk(dictationId, seq, audio, format) {
         this.sendSessionMessageStrict({ type: "dictation_stream_chunk", dictationId, seq, audio, format });
     }
-    finishDictationStream(dictationId, finalSeq) {
+    async finishDictationStream(dictationId, finalSeq) {
         const final = this.waitForWithCancel((msg) => {
             if (msg.type !== "dictation_stream_final") {
                 return null;
@@ -1041,7 +1114,7 @@ export class DaemonClient {
                 return null;
             }
             return msg.payload;
-        }, 30000, { skipQueue: true });
+        }, 0, { skipQueue: true });
         const streamError = this.waitForWithCancel((msg) => {
             if (msg.type !== "dictation_stream_error") {
                 return null;
@@ -1050,23 +1123,96 @@ export class DaemonClient {
                 return null;
             }
             return msg.payload;
-        }, 30000, { skipQueue: true });
+        }, 0, { skipQueue: true });
+        const finishAccepted = this.waitForWithCancel((msg) => {
+            if (msg.type !== "dictation_stream_finish_accepted") {
+                return null;
+            }
+            if (msg.payload.dictationId !== dictationId) {
+                return null;
+            }
+            return msg.payload;
+        }, DEFAULT_DICTATION_FINISH_ACCEPT_TIMEOUT_MS, { skipQueue: true });
         const finalPromise = final.promise;
         const errorPromise = streamError.promise.then((payload) => {
             throw new Error(payload.error);
         });
+        const finishAcceptedPromise = finishAccepted.promise;
+        const finalOutcomePromise = finalPromise.then((payload) => ({
+            kind: "final",
+            payload,
+        }));
+        const errorOutcomePromise = errorPromise.then(() => ({
+            kind: "error",
+            error: new Error("Unexpected dictation stream error state"),
+        }), (error) => ({
+            kind: "error",
+            error: error instanceof Error ? error : new Error(String(error)),
+        }));
+        const finishAcceptedOutcomePromise = finishAcceptedPromise.then((payload) => ({ kind: "accepted", payload }), (error) => {
+            if (isWaiterTimeoutError(error)) {
+                return { kind: "accepted_timeout" };
+            }
+            return {
+                kind: "accepted_error",
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        });
+        const waitForFinalResult = async (timeoutMs) => {
+            if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+                const outcome = await Promise.race([finalOutcomePromise, errorOutcomePromise]);
+                if (outcome.kind === "error") {
+                    throw outcome.error;
+                }
+                return outcome.payload;
+            }
+            let timeoutHandle = null;
+            const timeoutPromise = new Promise((resolve) => {
+                timeoutHandle = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
+            });
+            const outcome = await Promise.race([
+                finalOutcomePromise,
+                errorOutcomePromise,
+                timeoutPromise,
+            ]);
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            if (outcome.kind === "timeout") {
+                throw new Error(`Timeout waiting for dictation finalization (${timeoutMs}ms)`);
+            }
+            if (outcome.kind === "error") {
+                throw outcome.error;
+            }
+            return outcome.payload;
+        };
+        const cleanupError = new Error("Cancelled dictation finish waiter");
         try {
             this.sendSessionMessageStrict({ type: "dictation_stream_finish", dictationId, finalSeq });
+            const firstOutcome = await Promise.race([
+                finalOutcomePromise,
+                errorOutcomePromise,
+                finishAcceptedOutcomePromise,
+            ]);
+            if (firstOutcome.kind === "final") {
+                return firstOutcome.payload;
+            }
+            if (firstOutcome.kind === "error") {
+                throw firstOutcome.error;
+            }
+            if (firstOutcome.kind === "accepted") {
+                return await waitForFinalResult(firstOutcome.payload.timeoutMs + DEFAULT_DICTATION_FINISH_TIMEOUT_GRACE_MS);
+            }
+            return await waitForFinalResult(DEFAULT_DICTATION_FINISH_FALLBACK_TIMEOUT_MS);
         }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            final.cancel(err);
-            streamError.cancel(err);
+        finally {
+            final.cancel(cleanupError);
+            streamError.cancel(cleanupError);
+            finishAccepted.cancel(cleanupError);
             void finalPromise.catch(() => undefined);
             void errorPromise.catch(() => undefined);
-            throw err;
+            void finishAcceptedPromise.catch(() => undefined);
         }
-        return Promise.race([finalPromise, errorPromise]);
     }
     cancelDictationStream(dictationId) {
         this.sendSessionMessageStrict({ type: "dictation_stream_cancel", dictationId });
@@ -1171,22 +1317,17 @@ export class DaemonClient {
             requestId: resolvedRequestId,
         });
         try {
-            return await this.sendRequest({
+            return await this.sendCorrelatedRequest({
                 requestId: resolvedRequestId,
                 message,
+                responseType: "subscribe_checkout_diff_response",
                 timeout: 60000,
                 options: { skipQueue: true },
-                select: (msg) => {
-                    if (msg.type !== "subscribe_checkout_diff_response") {
-                        return null;
-                    }
-                    if (msg.payload.requestId !== resolvedRequestId) {
-                        return null;
-                    }
-                    if (msg.payload.subscriptionId !== subscriptionId) {
+                selectPayload: (payload) => {
+                    if (payload.subscriptionId !== subscriptionId) {
                         return null;
                     }
-                    return msg.payload;
+                    return payload;
                 },
             });
         }
@@ -1208,441 +1349,238 @@ export class DaemonClient {
         });
     }
     async checkoutCommit(cwd, input, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "checkout_commit_request",
-            cwd,
-            message: input.message,
-            addAll: input.addAll,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 60000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "checkout_commit_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout_commit_request",
+                cwd,
+                message: input.message,
+                addAll: input.addAll,
             },
+            responseType: "checkout_commit_response",
+            timeout: 60000,
         });
     }
     async checkoutMerge(cwd, input, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "checkout_merge_request",
-            cwd,
-            baseRef: input.baseRef,
-            strategy: input.strategy,
-            requireCleanTarget: input.requireCleanTarget,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 60000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "checkout_merge_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout_merge_request",
+                cwd,
+                baseRef: input.baseRef,
+                strategy: input.strategy,
+                requireCleanTarget: input.requireCleanTarget,
             },
+            responseType: "checkout_merge_response",
+            timeout: 60000,
         });
     }
     async checkoutMergeFromBase(cwd, input, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "checkout_merge_from_base_request",
-            cwd,
-            baseRef: input.baseRef,
-            requireCleanTarget: input.requireCleanTarget,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 60000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "checkout_merge_from_base_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout_merge_from_base_request",
+                cwd,
+                baseRef: input.baseRef,
+                requireCleanTarget: input.requireCleanTarget,
             },
+            responseType: "checkout_merge_from_base_response",
+            timeout: 60000,
         });
     }
     async checkoutPush(cwd, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "checkout_push_request",
-            cwd,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 60000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "checkout_push_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout_push_request",
+                cwd,
             },
+            responseType: "checkout_push_response",
+            timeout: 60000,
         });
     }
     async checkoutPrCreate(cwd, input, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "checkout_pr_create_request",
-            cwd,
-            title: input.title,
-            body: input.body,
-            baseRef: input.baseRef,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 60000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "checkout_pr_create_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout_pr_create_request",
+                cwd,
+                title: input.title,
+                body: input.body,
+                baseRef: input.baseRef,
             },
+            responseType: "checkout_pr_create_response",
+            timeout: 60000,
         });
     }
     async checkoutPrStatus(cwd, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "checkout_pr_status_request",
-            cwd,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 60000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "checkout_pr_status_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout_pr_status_request",
+                cwd,
             },
+            responseType: "checkout_pr_status_response",
+            timeout: 60000,
         });
     }
     async getPaseoWorktreeList(input, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "paseo_worktree_list_request",
-            cwd: input.cwd,
-            repoRoot: input.repoRoot,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 60000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "paseo_worktree_list_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "paseo_worktree_list_request",
+                cwd: input.cwd,
+                repoRoot: input.repoRoot,
             },
+            responseType: "paseo_worktree_list_response",
+            timeout: 60000,
         });
     }
     async archivePaseoWorktree(input, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "paseo_worktree_archive_request",
-            worktreePath: input.worktreePath,
-            repoRoot: input.repoRoot,
-            branchName: input.branchName,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 20000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "paseo_worktree_archive_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "paseo_worktree_archive_request",
+                worktreePath: input.worktreePath,
+                repoRoot: input.repoRoot,
+                branchName: input.branchName,
             },
+            responseType: "paseo_worktree_archive_response",
+            timeout: 20000,
         });
     }
     async validateBranch(options, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "validate_branch_request",
-            cwd: options.cwd,
-            branchName: options.branchName,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "validate_branch_request",
+                cwd: options.cwd,
+                branchName: options.branchName,
+            },
+            responseType: "validate_branch_response",
             timeout: 10000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "validate_branch_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        });
+    }
+    async getBranchSuggestions(options, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "branch_suggestions_request",
+                cwd: options.cwd,
+                query: options.query,
+                limit: options.limit,
             },
+            responseType: "branch_suggestions_response",
+            timeout: 10000,
         });
     }
     // ============================================================================
     // File Explorer
     // ============================================================================
     async exploreFileSystem(agentId, path, mode = "list", requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "file_explorer_request",
-            agentId,
-            path,
-            mode,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 10000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "file_explorer_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "file_explorer_request",
+                agentId,
+                path,
+                mode,
             },
+            responseType: "file_explorer_response",
+            timeout: 10000,
         });
     }
     async requestDownloadToken(agentId, path, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "file_download_token_request",
-            agentId,
-            path,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 10000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "file_download_token_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "file_download_token_request",
+                agentId,
+                path,
             },
+            responseType: "file_download_token_response",
+            timeout: 10000,
         });
     }
     async requestProjectIcon(cwd, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "project_icon_request",
-            cwd,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 10000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "project_icon_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "project_icon_request",
+                cwd,
             },
+            responseType: "project_icon_response",
+            timeout: 10000,
         });
     }
     // ============================================================================
     // Provider Models / Commands
     // ============================================================================
     async listProviderModels(provider, options) {
-        const resolvedRequestId = this.createRequestId(options?.requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "list_provider_models_request",
-            provider,
-            cwd: options?.cwd,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 30000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "list_provider_models_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId: options?.requestId,
+            message: {
+                type: "list_provider_models_request",
+                provider,
+                cwd: options?.cwd,
             },
+            responseType: "list_provider_models_response",
+            timeout: 30000,
         });
     }
     async listAvailableProviders(options) {
-        const resolvedRequestId = this.createRequestId(options?.requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "list_available_providers_request",
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 30000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "list_available_providers_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId: options?.requestId,
+            message: {
+                type: "list_available_providers_request",
             },
+            responseType: "list_available_providers_response",
+            timeout: 30000,
         });
     }
     async listSpeechModels(requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "speech_models_list_request",
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 30000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "speech_models_list_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "speech_models_list_request",
             },
+            responseType: "speech_models_list_response",
+            timeout: 30000,
         });
     }
     async downloadSpeechModels(options) {
-        const resolvedRequestId = this.createRequestId(options?.requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "speech_models_download_request",
-            modelIds: options?.modelIds,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 30 * 60 * 1000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "speech_models_download_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId: options?.requestId,
+            message: {
+                type: "speech_models_download_request",
+                modelIds: options?.modelIds,
             },
+            responseType: "speech_models_download_response",
+            timeout: 30 * 60 * 1000,
         });
     }
     async listCommands(agentId, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "list_commands_request",
-            agentId,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 30000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "list_commands_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "list_commands_request",
+                agentId,
             },
+            responseType: "list_commands_response",
+            timeout: 30000,
         });
     }
     async executeCommand(agentId, commandName, args, requestId) {
-        const resolvedRequestId = this.createRequestId(requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "execute_command_request",
-            agentId,
-            commandName,
-            args,
-            requestId: resolvedRequestId,
-        });
-        return this.sendRequest({
-            requestId: resolvedRequestId,
-            message,
-            timeout: 30000,
-            options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "execute_command_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "execute_command_request",
+                agentId,
+                commandName,
+                args,
             },
+            responseType: "execute_command_response",
+            timeout: 30000,
         });
     }
     // ============================================================================
@@ -1704,20 +1642,12 @@ export class DaemonClient {
             agentId,
             timeoutMs: timeout,
         });
-        const payload = await this.sendRequest({
+        const payload = await this.sendCorrelatedRequest({
             requestId,
             message,
+            responseType: "wait_for_finish_response",
             timeout: timeout + 5000,
             options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "wait_for_finish_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== requestId) {
-                    return null;
-                }
-                return msg.payload;
-            },
         });
         return {
             status: payload.status,
@@ -1729,6 +1659,26 @@ export class DaemonClient {
     // ============================================================================
     // Terminals
     // ============================================================================
+    subscribeTerminals(input) {
+        this.terminalDirectorySubscriptions.add(input.cwd);
+        if (!this.transport || this.connectionState.status !== "connected") {
+            return;
+        }
+        this.sendSessionMessage({
+            type: "subscribe_terminals_request",
+            cwd: input.cwd,
+        });
+    }
+    unsubscribeTerminals(input) {
+        this.terminalDirectorySubscriptions.delete(input.cwd);
+        if (!this.transport || this.connectionState.status !== "connected") {
+            return;
+        }
+        this.sendSessionMessage({
+            type: "unsubscribe_terminals_request",
+            cwd: input.cwd,
+        });
+    }
     async listTerminals(cwd, requestId) {
         const resolvedRequestId = this.createRequestId(requestId);
         const message = SessionInboundMessageSchema.parse({
@@ -1736,20 +1686,12 @@ export class DaemonClient {
             cwd,
             requestId: resolvedRequestId,
         });
-        return this.sendRequest({
+        return this.sendCorrelatedRequest({
             requestId: resolvedRequestId,
             message,
+            responseType: "list_terminals_response",
             timeout: 10000,
             options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "list_terminals_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
-            },
         });
     }
     async createTerminal(cwd, name, requestId) {
@@ -1760,20 +1702,12 @@ export class DaemonClient {
             name,
             requestId: resolvedRequestId,
         });
-        return this.sendRequest({
+        return this.sendCorrelatedRequest({
             requestId: resolvedRequestId,
             message,
+            responseType: "create_terminal_response",
             timeout: 10000,
             options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "create_terminal_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
-            },
         });
     }
     async subscribeTerminal(terminalId, requestId) {
@@ -1783,20 +1717,12 @@ export class DaemonClient {
             terminalId,
             requestId: resolvedRequestId,
         });
-        return this.sendRequest({
+        return this.sendCorrelatedRequest({
             requestId: resolvedRequestId,
             message,
+            responseType: "subscribe_terminal_response",
             timeout: 10000,
             options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "subscribe_terminal_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
-                }
-                return msg.payload;
-            },
         });
     }
     unsubscribeTerminal(terminalId) {
@@ -1819,20 +1745,94 @@ export class DaemonClient {
             terminalId,
             requestId: resolvedRequestId,
         });
-        return this.sendRequest({
+        return this.sendCorrelatedRequest({
             requestId: resolvedRequestId,
             message,
+            responseType: "kill_terminal_response",
             timeout: 10000,
             options: { skipQueue: true },
-            select: (msg) => {
-                if (msg.type !== "kill_terminal_response") {
-                    return null;
-                }
-                if (msg.payload.requestId !== resolvedRequestId) {
-                    return null;
+        });
+    }
+    async attachTerminalStream(terminalId, options, requestId) {
+        const resolvedRequestId = this.createRequestId(requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "attach_terminal_stream_request",
+            terminalId,
+            requestId: resolvedRequestId,
+            ...(options?.resumeOffset !== undefined ? { resumeOffset: options.resumeOffset } : {}),
+            ...(options?.rows !== undefined ? { rows: options.rows } : {}),
+            ...(options?.cols !== undefined ? { cols: options.cols } : {}),
+        });
+        return this.sendCorrelatedRequest({
+            requestId: resolvedRequestId,
+            message,
+            responseType: "attach_terminal_stream_response",
+            timeout: 10000,
+            options: { skipQueue: true },
+        });
+    }
+    async detachTerminalStream(streamId, requestId) {
+        const resolvedRequestId = this.createRequestId(requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "detach_terminal_stream_request",
+            streamId,
+            requestId: resolvedRequestId,
+        });
+        const payload = await this.sendCorrelatedRequest({
+            requestId: resolvedRequestId,
+            message,
+            responseType: "detach_terminal_stream_response",
+            timeout: 10000,
+            options: { skipQueue: true },
+        });
+        this.terminalStreams.clearStream({ streamId });
+        return payload;
+    }
+    onTerminalStreamData(streamId, handler) {
+        return this.terminalStreams.subscribe({ streamId, handler });
+    }
+    async waitForTerminalStreamData(streamId, predicate, timeout = 5000) {
+        return new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                unsubscribe();
+                reject(new Error(`Timeout waiting for terminal stream data (${timeout}ms)`));
+            }, timeout);
+            const unsubscribe = this.onTerminalStreamData(streamId, (chunk) => {
+                if (!predicate(chunk)) {
+                    return;
                 }
-                return msg.payload;
-            },
+                clearTimeout(timeoutHandle);
+                unsubscribe();
+                resolve(chunk);
+            });
+        });
+    }
+    sendTerminalStreamInput(streamId, data) {
+        const payload = typeof data === "string" ? encodeUtf8String(data) : data;
+        this.sendBinaryFrame({
+            channel: BinaryMuxChannel.Terminal,
+            messageType: TerminalBinaryMessageType.InputUtf8,
+            streamId,
+            offset: 0,
+            payload,
+        });
+    }
+    sendTerminalStreamKey(streamId, input) {
+        const encoded = encodeTerminalKeyInput(input);
+        if (!encoded) {
+            return;
+        }
+        this.sendTerminalStreamInput(streamId, encoded);
+    }
+    sendTerminalStreamAck(streamId, offset) {
+        const normalizedOffset = Math.max(0, Math.floor(offset));
+        this.terminalStreams.noteAck({ streamId, offset: normalizedOffset });
+        this.sendBinaryFrame({
+            channel: BinaryMuxChannel.Terminal,
+            messageType: TerminalBinaryMessageType.Ack,
+            streamId,
+            offset: normalizedOffset,
+            payload: new Uint8Array(0),
         });
     }
     async waitForTerminalOutput(terminalId, timeout = 5000) {
@@ -1883,6 +1883,14 @@ export class DaemonClient {
         const rawData = data && typeof data === "object" && "data" in data
             ? data.data
             : data;
+        const rawBytes = asUint8Array(rawData);
+        if (rawBytes) {
+            const frame = decodeBinaryMuxFrame(rawBytes);
+            if (frame) {
+                this.handleBinaryFrame(frame);
+                return;
+            }
+        }
         const payload = decodeMessageData(rawData);
         if (!payload) {
             return;
@@ -1905,6 +1913,20 @@ export class DaemonClient {
         }
         this.handleSessionMessage(parsed.data.message);
     }
+    handleBinaryFrame(frame) {
+        if (frame.channel === BinaryMuxChannel.Terminal &&
+            frame.messageType === TerminalBinaryMessageType.OutputUtf8) {
+            const chunk = {
+                streamId: frame.streamId,
+                offset: frame.offset,
+                endOffset: frame.offset + (frame.payload?.byteLength ?? 0),
+                replay: Boolean((frame.flags ?? 0) & TerminalBinaryFlags.Replay),
+                data: frame.payload ?? new Uint8Array(0),
+            };
+            this.terminalStreams.receiveChunk({ chunk });
+            return;
+        }
+    }
     updateConnectionState(next) {
         this.connectionState = next;
         for (const listener of this.connectionListeners) {
@@ -1937,6 +1959,7 @@ export class DaemonClient {
         // and responses from the previous connection will never arrive.
         this.clearWaiters(new Error(reason ?? "Connection lost"));
         this.rejectPendingSendQueue(new Error(reason ?? "Connection lost"));
+        this.terminalStreams.clearAll();
         this.updateConnectionState({
             status: "disconnected",
             ...(reason ? { reason } : {}),
@@ -1950,6 +1973,9 @@ export class DaemonClient {
         }, delay);
     }
     handleSessionMessage(msg) {
+        if (msg.type === "terminal_stream_exit") {
+            this.terminalStreams.clearStream({ streamId: msg.payload.streamId });
+        }
         if (this.rawMessageListeners.size > 0) {
             for (const handler of this.rawMessageListeners) {
                 try {
@@ -2016,6 +2042,8 @@ export class DaemonClient {
                     agentId: msg.payload.agentId,
                     event: msg.payload.event,
                     timestamp: msg.payload.timestamp,
+                    ...(typeof msg.payload.seq === "number" ? { seq: msg.payload.seq } : {}),
+                    ...(typeof msg.payload.epoch === "string" ? { epoch: msg.payload.epoch } : {}),
                 };
             case "status":
                 return { type: "status", payload: msg.payload };
@@ -2101,333 +2129,6 @@ export class DaemonClient {
         return { promise, cancel };
     }
 }
-// ============================================================================
-// Helpers
-// ============================================================================
-function defaultWebSocketFactory(url, _options) {
-    const globalWs = globalThis.WebSocket;
-    if (!globalWs) {
-        throw new Error("WebSocket is not available in this runtime");
-    }
-    return new globalWs(url);
-}
-function createWebSocketTransportFactory(factory) {
-    return ({ url, headers }) => {
-        const ws = factory(url, { headers });
-        return {
-            send: (data) => {
-                if (typeof ws.readyState === "number" && ws.readyState !== 1) {
-                    throw new Error(`WebSocket not open (readyState=${ws.readyState})`);
-                }
-                ws.send(data);
-            },
-            close: (code, reason) => ws.close(code, reason),
-            onOpen: (handler) => bindWsHandler(ws, "open", handler),
-            onClose: (handler) => bindWsHandler(ws, "close", handler),
-            onError: (handler) => bindWsHandler(ws, "error", handler),
-            onMessage: (handler) => bindWsHandler(ws, "message", handler),
-        };
-    };
-}
-function createRelayE2eeTransportFactory(args) {
-    return ({ url, headers }) => {
-        const base = args.baseFactory({ url, headers });
-        return createEncryptedTransport(base, args.daemonPublicKeyB64, args.logger);
-    };
-}
-function createEncryptedTransport(base, daemonPublicKeyB64, logger) {
-    let channel = null;
-    let opened = false;
-    let closed = false;
-    const openHandlers = new Set();
-    const closeHandlers = new Set();
-    const errorHandlers = new Set();
-    const messageHandlers = new Set();
-    const emitOpen = () => {
-        if (opened || closed)
-            return;
-        opened = true;
-        for (const handler of openHandlers) {
-            try {
-                handler();
-            }
-            catch {
-                // no-op
-            }
-        }
-    };
-    const emitClose = (event) => {
-        if (closed)
-            return;
-        closed = true;
-        for (const handler of closeHandlers) {
-            try {
-                handler(event);
-            }
-            catch {
-                // no-op
-            }
-        }
-    };
-    const emitError = (event) => {
-        if (closed)
-            return;
-        for (const handler of errorHandlers) {
-            try {
-                handler(event);
-            }
-            catch {
-                // no-op
-            }
-        }
-    };
-    const emitMessage = (data) => {
-        if (closed)
-            return;
-        for (const handler of messageHandlers) {
-            try {
-                handler(data);
-            }
-            catch {
-                // no-op
-            }
-        }
-    };
-    const relayTransport = {
-        send: (data) => {
-            if (typeof data === "string") {
-                base.send(data);
-                return;
-            }
-            if (data instanceof ArrayBuffer) {
-                if (typeof TextDecoder !== "undefined") {
-                    base.send(new TextDecoder().decode(data));
-                    return;
-                }
-                if (typeof Buffer !== "undefined") {
-                    base.send(Buffer.from(data).toString("utf8"));
-                    return;
-                }
-                base.send(String(data));
-                return;
-            }
-            base.send(String(data));
-        },
-        close: (code, reason) => base.close(code, reason),
-        onmessage: null,
-        onclose: null,
-        onerror: null,
-    };
-    const startHandshake = async () => {
-        try {
-            channel = await createClientChannel(relayTransport, daemonPublicKeyB64, {
-                onopen: emitOpen,
-                onmessage: (data) => emitMessage(data),
-                onclose: (code, reason) => emitClose({ code, reason }),
-                onerror: (error) => emitError(error),
-            });
-        }
-        catch (error) {
-            logger.warn({ err: error }, "relay_e2ee_handshake_failed");
-            emitError(error);
-            base.close(1011, "E2EE handshake failed");
-        }
-    };
-    base.onOpen(() => {
-        void startHandshake();
-    });
-    base.onMessage((event) => {
-        relayTransport.onmessage?.(extractRelayMessageData(event));
-    });
-    base.onClose((event) => {
-        const record = event;
-        relayTransport.onclose?.(record?.code ?? 0, record?.reason ?? "");
-        emitClose(event);
-    });
-    base.onError((event) => {
-        relayTransport.onerror?.(event instanceof Error ? event : new Error(String(event)));
-        emitError(event);
-    });
-    return {
-        send: (data) => {
-            if (!channel) {
-                throw new Error("Encrypted channel not ready");
-            }
-            void channel.send(data).catch((error) => {
-                emitError(error);
-            });
-        },
-        close: (code, reason) => {
-            if (channel) {
-                channel.close(code, reason);
-            }
-            else {
-                base.close(code, reason);
-            }
-            emitClose({ code, reason });
-        },
-        onMessage: (handler) => {
-            messageHandlers.add(handler);
-            return () => messageHandlers.delete(handler);
-        },
-        onOpen: (handler) => {
-            openHandlers.add(handler);
-            if (opened) {
-                try {
-                    handler();
-                }
-                catch {
-                    // no-op
-                }
-            }
-            return () => openHandlers.delete(handler);
-        },
-        onClose: (handler) => {
-            closeHandlers.add(handler);
-            if (closed) {
-                try {
-                    handler();
-                }
-                catch {
-                    // no-op
-                }
-            }
-            return () => closeHandlers.delete(handler);
-        },
-        onError: (handler) => {
-            errorHandlers.add(handler);
-            return () => errorHandlers.delete(handler);
-        },
-    };
-}
-function extractRelayMessageData(event) {
-    const raw = event && typeof event === "object" && "data" in event
-        ? event.data
-        : event;
-    if (typeof raw === "string")
-        return raw;
-    if (raw instanceof ArrayBuffer)
-        return raw;
-    if (ArrayBuffer.isView(raw)) {
-        const view = new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
-        const out = new Uint8Array(view.byteLength);
-        out.set(view);
-        return out.buffer;
-    }
-    return String(raw ?? "");
-}
-function bindWsHandler(ws, event, handler) {
-    if (typeof ws.addEventListener === "function") {
-        ws.addEventListener(event, handler);
-        return () => {
-            if (typeof ws.removeEventListener === "function") {
-                ws.removeEventListener(event, handler);
-            }
-        };
-    }
-    if (typeof ws.on === "function") {
-        ws.on(event, handler);
-        return () => {
-            if (typeof ws.off === "function") {
-                ws.off(event, handler);
-                return;
-            }
-            if (typeof ws.removeListener === "function") {
-                ws.removeListener(event, handler);
-            }
-        };
-    }
-    const prop = `on${event}`;
-    const previous = ws[prop];
-    ws[prop] = handler;
-    return () => {
-        if (ws[prop] === handler) {
-            ws[prop] = previous ?? null;
-        }
-    };
-}
-function describeTransportClose(event) {
-    if (!event) {
-        return "Transport closed";
-    }
-    if (event instanceof Error) {
-        return event.message;
-    }
-    if (typeof event === "string") {
-        return event;
-    }
-    if (typeof event === "object") {
-        const record = event;
-        if (typeof record.reason === "string" && record.reason.trim().length > 0) {
-            return record.reason.trim();
-        }
-        if (typeof record.message === "string" && record.message.trim().length > 0) {
-            return record.message.trim();
-        }
-        if (typeof record.code === "number") {
-            return `Transport closed (code ${record.code})`;
-        }
-    }
-    return "Transport closed";
-}
-function describeTransportError(event) {
-    if (!event) {
-        return "Transport error";
-    }
-    if (event instanceof Error) {
-        return event.message;
-    }
-    if (typeof event === "string") {
-        return event;
-    }
-    if (typeof event === "object") {
-        const record = event;
-        if (typeof record.message === "string" && record.message.trim().length > 0) {
-            return record.message.trim();
-        }
-    }
-    return "Transport error";
-}
-function safeRandomId() {
-    try {
-        if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-            return crypto.randomUUID();
-        }
-    }
-    catch {
-        // ignore
-    }
-    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-}
-function decodeMessageData(data) {
-    if (data === null || data === undefined) {
-        return null;
-    }
-    if (typeof data === "string") {
-        return data;
-    }
-    if (typeof ArrayBuffer !== "undefined" && data instanceof ArrayBuffer) {
-        if (typeof Buffer !== "undefined") {
-            return Buffer.from(data).toString("utf8");
-        }
-        if (typeof TextDecoder !== "undefined") {
-            return new TextDecoder().decode(data);
-        }
-    }
-    if (ArrayBuffer.isView(data)) {
-        const view = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        if (typeof Buffer !== "undefined") {
-            return Buffer.from(view).toString("utf8");
-        }
-        if (typeof TextDecoder !== "undefined") {
-            return new TextDecoder().decode(view);
-        }
-    }
-    if (typeof data.toString === "function") {
-        return data.toString();
-    }
-    return null;
-}
 function resolveAgentConfig(options) {
     const { config, provider, cwd, initialPrompt: _initialPrompt, images: _images, git: _git, worktreeName: _worktreeName, requestId: _requestId, labels: _labels, ...overrides } = options;
     const baseConfig = {