@getpaseo/server 0.1.14 → 0.1.16

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

@@ -4,13 +4,19 @@ 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';
+import { createRelayE2eeTransportFactory, createWebSocketTransportFactory, decodeMessageData, defaultWebSocketFactory, describeTransportClose, describeTransportError, encodeUtf8String, } from './daemon-client-transport.js';
 const consoleLogger = {
-    debug: (obj, msg) => console.debug(msg, obj),
+    debug: () => { },
     info: (obj, msg) => console.info(msg, obj),
     warn: (obj, msg) => console.warn(msg, obj),
     error: (obj, msg) => console.error(msg, obj),
 };
+function getNowMs() {
+    if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+        return performance.now();
+    }
+    return Date.now();
+}
 class DaemonRpcError extends Error {
     constructor(params) {
         super(params.error);
@@ -22,6 +28,7 @@ class DaemonRpcError extends Error {
 }
 const DEFAULT_RECONNECT_BASE_DELAY_MS = 1500;
 const DEFAULT_RECONNECT_MAX_DELAY_MS = 30000;
+const DEFAULT_CONNECT_TIMEOUT_MS = 15000;
 /** 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;
@@ -30,6 +37,42 @@ const DEFAULT_DICTATION_FINISH_TIMEOUT_GRACE_MS = 5000;
 function isWaiterTimeoutError(error) {
     return error instanceof Error && error.message.startsWith('Timeout waiting for message');
 }
+function normalizeClientId(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function hashForLog(value) {
+    let hash = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = (hash * 31 + value.charCodeAt(index)) | 0;
+    }
+    return `h_${Math.abs(hash).toString(16)}`;
+}
+function toReasonCode(reason) {
+    if (!reason) {
+        return null;
+    }
+    const normalized = reason.toLowerCase();
+    if (normalized.includes('timed out')) {
+        return 'connect_timeout';
+    }
+    if (normalized.includes('disposed')) {
+        return 'disposed';
+    }
+    if (normalized.includes('client closed')) {
+        return 'client_closed';
+    }
+    if (normalized.includes('transport')) {
+        return 'transport_error';
+    }
+    if (normalized.includes('failed to connect')) {
+        return 'connect_failed';
+    }
+    return 'unknown';
+}
 export class DaemonClient {
     constructor(config) {
         this.config = config;
@@ -42,6 +85,7 @@ export class DaemonClient {
         this.checkoutStatusInFlight = new Map();
         this.connectionListeners = new Set();
         this.reconnectTimeout = null;
+        this.connectTimeout = null;
         this.pendingGenericTransportErrorTimeout = null;
         this.reconnectAttempt = 0;
         this.shouldReconnect = true;
@@ -53,8 +97,28 @@ export class DaemonClient {
         this.checkoutDiffSubscriptions = new Map();
         this.terminalDirectorySubscriptions = new Set();
         this.pendingSendQueue = [];
-        this.relayClientId = null;
+        this.lastWelcomeMessage = null;
         this.logger = config.logger ?? consoleLogger;
+        this.logConnectionPath = isRelayClientWebSocketUrl(this.config.url) ? 'relay' : 'direct';
+        let parsedUrlForLog = null;
+        try {
+            parsedUrlForLog = new URL(this.config.url);
+        }
+        catch {
+            parsedUrlForLog = null;
+        }
+        const parsedServerIdForLog = normalizeClientId(parsedUrlForLog?.searchParams.get('serverId'));
+        this.logServerId = parsedServerIdForLog ?? parsedUrlForLog?.host ?? null;
+        const resolvedClientId = normalizeClientId(this.config.clientId);
+        if (!resolvedClientId) {
+            throw new Error('Daemon client requires a non-empty clientId');
+        }
+        this.config.clientId = resolvedClientId;
+        this.logClientIdHash = hashForLog(resolvedClientId);
+        this.logGeneration =
+            typeof this.config.runtimeGeneration === 'number' && Number.isFinite(this.config.runtimeGeneration)
+                ? this.config.runtimeGeneration
+                : null;
         this.terminalStreams = new TerminalStreamManager({
             sendAck: (ack) => {
                 this.sendBinaryFrame({
@@ -66,27 +130,22 @@ export class DaemonClient {
                 });
             },
         });
-        // 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).
-        if (isRelayClientWebSocketUrl(this.config.url)) {
-            try {
-                const parsed = new URL(this.config.url);
-                if (!parsed.searchParams.get('clientId')) {
-                    this.relayClientId = `clt_${safeRandomId()}`;
-                    parsed.searchParams.set('clientId', this.relayClientId);
-                    this.config.url = parsed.toString();
-                }
-            }
-            catch {
-                // ignore - invalid URL will be handled on connect
-            }
+    }
+    emitDiagnosticsEvent(event) {
+        try {
+            this.config.onDiagnosticsEvent?.(event);
+        }
+        catch {
+            // Diagnostics hooks must never break daemon message handling.
         }
     }
     // ============================================================================
     // Connection
     // ============================================================================
     async connect() {
+        if (this.connectionState.status === 'disposed') {
+            throw new Error('Daemon client is disposed');
+        }
         if (this.connectionState.status === 'connected') {
             return;
         }
@@ -102,6 +161,10 @@ export class DaemonClient {
         return this.connectPromise;
     }
     attemptConnect() {
+        if (this.connectionState.status === 'disposed') {
+            this.rejectConnect(new Error('Daemon client is disposed'));
+            return;
+        }
         if (!this.shouldReconnect) {
             this.rejectConnect(new Error('Daemon client is closed'));
             return;
@@ -114,10 +177,8 @@ export class DaemonClient {
             headers['Authorization'] = this.config.authHeader;
         }
         try {
-            // If we reconnect while the previous socket is still open (common in browsers
-            // where `onerror` may fire before `onclose`), we can end up with multiple
-            // concurrent relay sockets. Cloudflare then closes the old one with
-            // "Replaced by new connection", causing a disconnect loop.
+            // Reconnect can overlap with browser close/error delivery ordering.
+            // Always dispose previous transport before constructing the next one.
             this.disposeTransport();
             const baseTransportFactory = this.config.transportFactory ??
                 createWebSocketTransportFactory(this.config.webSocketFactory ?? defaultWebSocketFactory);
@@ -134,12 +195,28 @@ export class DaemonClient {
                     logger: this.logger,
                 });
             }
-            const transport = transportFactory({ url: this.config.url, headers });
+            const transportUrl = this.resolveTransportUrlForAttempt();
+            const transport = transportFactory({ url: transportUrl, headers });
             this.transport = transport;
+            this.lastWelcomeMessage = null;
             this.updateConnectionState({
                 status: 'connecting',
                 attempt: this.reconnectAttempt,
-            });
+            }, { event: 'CONNECT_REQUEST' });
+            this.resetConnectTimeout();
+            const timeoutMs = Math.max(1, this.config.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS);
+            this.connectTimeout = setTimeout(() => {
+                if (this.connectionState.status !== 'connecting') {
+                    return;
+                }
+                this.lastErrorValue = 'Connection timed out';
+                this.disposeTransport(1001, 'Connection timed out');
+                this.scheduleReconnect({
+                    reason: 'Connection timed out',
+                    event: 'CONNECT_TIMEOUT',
+                    reasonCode: 'connect_timeout',
+                });
+            }, timeoutMs);
             this.transportCleanup = [
                 transport.onOpen(() => {
                     if (this.pendingGenericTransportErrorTimeout) {
@@ -147,48 +224,26 @@ export class DaemonClient {
                         this.pendingGenericTransportErrorTimeout = null;
                     }
                     this.lastErrorValue = null;
-                    this.reconnectAttempt = 0;
-                    this.updateConnectionState({ status: 'connected' });
-                    this.resubscribeCheckoutDiffSubscriptions();
-                    this.resubscribeTerminalDirectorySubscriptions();
-                    this.flushPendingSendQueue();
-                    this.resolveConnect();
+                    this.sendHelloMessage();
                 }),
                 transport.onClose((event) => {
+                    this.resetConnectTimeout();
                     if (this.pendingGenericTransportErrorTimeout) {
                         clearTimeout(this.pendingGenericTransportErrorTimeout);
                         this.pendingGenericTransportErrorTimeout = null;
                     }
-                    const closeRecord = event;
-                    const closeCode = closeRecord && typeof closeRecord === 'object' && typeof closeRecord.code === 'number'
-                        ? closeRecord.code
-                        : null;
-                    const closeReason = closeRecord && typeof closeRecord === 'object' && typeof closeRecord.reason === 'string'
-                        ? closeRecord.reason
-                        : null;
                     const reason = describeTransportClose(event);
                     if (reason) {
                         this.lastErrorValue = reason;
                     }
-                    this.updateConnectionState({
-                        status: 'disconnected',
-                        ...(reason ? { reason } : {}),
+                    this.scheduleReconnect({
+                        reason,
+                        event: 'TRANSPORT_CLOSE',
+                        reasonCode: 'transport_closed',
                     });
-                    // When connecting over the relay, only one client connection is allowed at a time.
-                    // If another device/tab takes over, we should not auto-reconnect and "fight" the new
-                    // connection (which causes flapping where both sides repeatedly replace each other).
-                    if (isRelayClientWebSocketUrl(this.config.url) &&
-                        closeCode === 1008 &&
-                        (closeReason ?? reason) === 'Replaced by new connection') {
-                        this.shouldReconnect = false;
-                        this.clearWaiters(new Error(reason ?? 'Replaced by new connection'));
-                        this.rejectPendingSendQueue(new Error(reason ?? 'Replaced by new connection'));
-                        this.rejectConnect(new Error(reason ?? 'Replaced by new connection'));
-                        return;
-                    }
-                    this.scheduleReconnect(reason);
                 }),
                 transport.onError((event) => {
+                    this.resetConnectTimeout();
                     const reason = describeTransportError(event);
                     const isGeneric = reason === 'Transport error';
                     // Browser WebSocket.onerror often provides no useful details and is followed
@@ -202,8 +257,11 @@ export class DaemonClient {
                                 if (this.connectionState.status === 'connected' ||
                                     this.connectionState.status === 'connecting') {
                                     this.lastErrorValue = reason;
-                                    this.updateConnectionState({ status: 'disconnected', reason });
-                                    this.scheduleReconnect(reason);
+                                    this.scheduleReconnect({
+                                        reason,
+                                        event: 'TRANSPORT_ERROR',
+                                        reasonCode: 'transport_error',
+                                    });
                                 }
                             }, 250);
                         }
@@ -214,16 +272,24 @@ export class DaemonClient {
                         this.pendingGenericTransportErrorTimeout = null;
                     }
                     this.lastErrorValue = reason;
-                    this.updateConnectionState({ status: 'disconnected', reason });
-                    this.scheduleReconnect(reason);
+                    this.scheduleReconnect({
+                        reason,
+                        event: 'TRANSPORT_ERROR',
+                        reasonCode: 'transport_error',
+                    });
                 }),
                 transport.onMessage((data) => this.handleTransportMessage(data)),
             ];
         }
         catch (error) {
+            this.resetConnectTimeout();
             const message = error instanceof Error ? error.message : 'Failed to connect';
             this.lastErrorValue = message;
-            this.scheduleReconnect(message);
+            this.scheduleReconnect({
+                reason: message,
+                event: 'CONNECT_FAILED',
+                reasonCode: 'connect_failed',
+            });
             this.rejectConnect(error instanceof Error ? error : new Error(message));
         }
     }
@@ -244,6 +310,9 @@ export class DaemonClient {
         this.connectReject = null;
     }
     async close() {
+        if (this.connectionState.status === 'disposed') {
+            return;
+        }
         this.shouldReconnect = false;
         this.connectPromise = null;
         this.connectResolve = null;
@@ -252,15 +321,18 @@ export class DaemonClient {
             clearTimeout(this.reconnectTimeout);
             this.reconnectTimeout = null;
         }
+        this.resetConnectTimeout();
         this.disposeTransport(1000, 'Client closed');
         this.clearWaiters(new Error('Daemon client closed'));
+        this.rejectPendingSendQueue(new Error('Daemon client closed'));
         this.terminalStreams.clearAll();
-        this.updateConnectionState({
-            status: 'disconnected',
-            reason: 'client_closed',
-        });
+        this.lastWelcomeMessage = null;
+        this.updateConnectionState({ status: 'disposed' }, { event: 'DISPOSE', reason: 'Client closed', reasonCode: 'disposed' });
     }
     ensureConnected() {
+        if (this.connectionState.status === 'disposed') {
+            return;
+        }
         if (!this.shouldReconnect) {
             this.shouldReconnect = true;
         }
@@ -614,7 +686,10 @@ export class DaemonClient {
         if (payload.error) {
             throw new Error(payload.error);
         }
-        return payload.agent;
+        if (!payload.agent) {
+            return null;
+        }
+        return { agent: payload.agent, project: payload.project ?? null };
     }
     resubscribeCheckoutDiffSubscriptions() {
         if (this.checkoutDiffSubscriptions.size === 0) {
@@ -653,6 +728,7 @@ export class DaemonClient {
             requestId,
             config,
             ...(options.initialPrompt ? { initialPrompt: options.initialPrompt } : {}),
+            ...(options.clientMessageId ? { clientMessageId: options.clientMessageId } : {}),
             ...(options.outputSchema ? { outputSchema: options.outputSchema } : {}),
             ...(options.images && options.images.length > 0 ? { images: options.images } : {}),
             ...(options.git ? { git: options.git } : {}),
@@ -1594,15 +1670,91 @@ export class DaemonClient {
     // Waiting / Streaming Helpers
     // ============================================================================
     async waitForAgentUpsert(agentId, predicate, timeout = 60000) {
-        const startedAt = Date.now();
-        while (Date.now() - startedAt < timeout) {
-            const snapshot = await this.fetchAgent(agentId).catch(() => null);
-            if (snapshot && predicate(snapshot)) {
-                return snapshot;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 250));
-        }
-        throw new Error(`Timed out waiting for agent ${agentId}`);
+        const initialResult = await this.fetchAgent(agentId).catch(() => null);
+        if (initialResult && predicate(initialResult.agent)) {
+            return initialResult.agent;
+        }
+        const deadline = Date.now() + timeout;
+        return await new Promise((resolve, reject) => {
+            let settled = false;
+            let pollInFlight = false;
+            let pollTimer = null;
+            let timeoutTimer = null;
+            let unsubscribe = null;
+            const finish = (result) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                if (timeoutTimer) {
+                    clearTimeout(timeoutTimer);
+                    timeoutTimer = null;
+                }
+                if (pollTimer) {
+                    clearInterval(pollTimer);
+                    pollTimer = null;
+                }
+                if (unsubscribe) {
+                    unsubscribe();
+                    unsubscribe = null;
+                }
+                if (result.kind === 'ok') {
+                    resolve(result.snapshot);
+                    return;
+                }
+                reject(result.error);
+            };
+            const maybeResolve = (snapshot) => {
+                if (!snapshot) {
+                    return false;
+                }
+                if (!predicate(snapshot)) {
+                    return false;
+                }
+                finish({ kind: 'ok', snapshot });
+                return true;
+            };
+            const poll = async () => {
+                if (settled || pollInFlight) {
+                    return;
+                }
+                pollInFlight = true;
+                try {
+                    const result = await this.fetchAgent(agentId).catch(() => null);
+                    maybeResolve(result?.agent ?? null);
+                }
+                finally {
+                    pollInFlight = false;
+                }
+            };
+            unsubscribe = this.on('agent_update', (message) => {
+                if (settled) {
+                    return;
+                }
+                if (message.type !== 'agent_update') {
+                    return;
+                }
+                if (message.payload.kind !== 'upsert') {
+                    return;
+                }
+                const snapshot = message.payload.agent;
+                if (snapshot.id !== agentId) {
+                    return;
+                }
+                maybeResolve(snapshot);
+            });
+            const remaining = Math.max(1, deadline - Date.now());
+            timeoutTimer = setTimeout(() => {
+                finish({
+                    kind: 'error',
+                    error: new Error(`Timed out waiting for agent ${agentId}`),
+                });
+            }, remaining);
+            pollTimer = setInterval(() => {
+                void poll();
+            }, 250);
+            void poll();
+        });
     }
     async waitForFinish(agentId, timeout = 60000) {
         const requestId = this.createRequestId();
@@ -1822,6 +1974,39 @@ export class DaemonClient {
     createRequestId(requestId) {
         return requestId ?? crypto.randomUUID();
     }
+    getLastWelcomeMessage() {
+        return this.lastWelcomeMessage;
+    }
+    resolveTransportUrlForAttempt() {
+        return this.config.url;
+    }
+    sendHelloMessage() {
+        if (!this.transport) {
+            this.scheduleReconnect({
+                reason: 'Transport unavailable before hello',
+                event: 'HELLO_TRANSPORT_MISSING',
+                reasonCode: 'transport_error',
+            });
+            return;
+        }
+        try {
+            this.transport.send(JSON.stringify({
+                type: 'hello',
+                clientId: this.config.clientId,
+                clientType: this.config.clientType ?? 'cli',
+                protocolVersion: 1,
+            }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to send hello message';
+            this.lastErrorValue = message;
+            this.scheduleReconnect({
+                reason: message,
+                event: 'HELLO_SEND_FAILED',
+                reasonCode: 'transport_error',
+            });
+        }
+    }
     disposeTransport(code = 1001, reason = 'Reconnecting') {
         this.cleanupTransport();
         if (this.transport) {
@@ -1835,6 +2020,7 @@ export class DaemonClient {
         }
     }
     cleanupTransport() {
+        this.resetConnectTimeout();
         if (this.pendingGenericTransportErrorTimeout) {
             clearTimeout(this.pendingGenericTransportErrorTimeout);
             this.pendingGenericTransportErrorTimeout = null;
@@ -1849,12 +2035,26 @@ export class DaemonClient {
         }
         this.transportCleanup = [];
     }
+    resetConnectTimeout() {
+        if (!this.connectTimeout) {
+            return;
+        }
+        clearTimeout(this.connectTimeout);
+        this.connectTimeout = null;
+    }
     handleTransportMessage(data) {
+        const startedAtMs = getNowMs();
         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.emitDiagnosticsEvent({
+                    type: 'transport_binary_frame',
+                    channel: frame.channel,
+                    messageType: frame.messageType,
+                    payloadBytes: frame.payload?.byteLength ?? 0,
+                });
                 this.handleBinaryFrame(frame);
                 return;
             }
@@ -1864,21 +2064,64 @@ export class DaemonClient {
             return;
         }
         let parsedJson;
+        let parseMs = 0;
         try {
+            const parseStartedAtMs = getNowMs();
             parsedJson = JSON.parse(payload);
+            parseMs = getNowMs() - parseStartedAtMs;
         }
         catch {
+            this.emitDiagnosticsEvent({
+                type: 'transport_message_timing',
+                messageType: 'unknown',
+                payloadBytes: payload.length,
+                parseMs: 0,
+                validateMs: 0,
+                totalMs: getNowMs() - startedAtMs,
+                outcome: 'parse_error',
+            });
             return;
         }
+        const validateStartedAtMs = getNowMs();
         const parsed = WSOutboundMessageSchema.safeParse(parsedJson);
+        const validateMs = getNowMs() - validateStartedAtMs;
         if (!parsed.success) {
-            const msgType = parsedJson?.message?.type ?? 'unknown';
+            const msgType = parsedJson?.type ?? 'unknown';
+            this.emitDiagnosticsEvent({
+                type: 'transport_message_timing',
+                messageType: msgType,
+                payloadBytes: payload.length,
+                parseMs,
+                validateMs,
+                totalMs: getNowMs() - startedAtMs,
+                outcome: 'validation_error',
+            });
             this.logger.warn({ msgType, error: parsed.error.message }, 'Message validation failed');
             return;
         }
+        this.emitDiagnosticsEvent({
+            type: 'transport_message_timing',
+            messageType: parsed.data.type,
+            payloadBytes: payload.length,
+            parseMs,
+            validateMs,
+            totalMs: getNowMs() - startedAtMs,
+            outcome: 'ok',
+        });
         if (parsed.data.type === 'pong') {
             return;
         }
+        if (parsed.data.type === 'welcome') {
+            this.lastWelcomeMessage = parsed.data;
+            this.resetConnectTimeout();
+            this.reconnectAttempt = 0;
+            this.updateConnectionState({ status: 'connected' }, { event: 'HELLO_WELCOME' });
+            this.resubscribeCheckoutDiffSubscriptions();
+            this.resubscribeTerminalDirectorySubscriptions();
+            this.flushPendingSendQueue();
+            this.resolveConnect();
+            return;
+        }
         this.handleSessionMessage(parsed.data.message);
     }
     handleBinaryFrame(frame) {
@@ -1895,8 +2138,25 @@ export class DaemonClient {
             return;
         }
     }
-    updateConnectionState(next) {
+    updateConnectionState(next, metadata) {
+        const previous = this.connectionState;
         this.connectionState = next;
+        const reasonFromNext = next.status === 'disconnected' && typeof next.reason === 'string'
+            ? next.reason
+            : null;
+        const reason = metadata?.reason ?? reasonFromNext;
+        const reasonCode = metadata?.reasonCode ?? toReasonCode(reason);
+        this.logger.debug({
+            serverId: this.logServerId,
+            clientIdHash: this.logClientIdHash,
+            from: previous.status,
+            to: next.status,
+            event: metadata?.event ?? 'STATE_UPDATE',
+            connectionPath: this.logConnectionPath,
+            generation: this.logGeneration,
+            reasonCode,
+            reason,
+        }, 'DaemonClientTransition');
         for (const listener of this.connectionListeners) {
             try {
                 listener(next);
@@ -1906,20 +2166,13 @@ export class DaemonClient {
             }
         }
     }
-    scheduleReconnect(reason) {
+    scheduleReconnect(input) {
         if (this.reconnectTimeout) {
             clearTimeout(this.reconnectTimeout);
             this.reconnectTimeout = null;
         }
-        if (!this.shouldReconnect || this.config.reconnect?.enabled === false) {
-            this.rejectConnect(new Error(reason ?? 'Transport disconnected before connect'));
-            return;
-        }
-        const attempt = this.reconnectAttempt;
-        const baseDelay = this.config.reconnect?.baseDelayMs ?? DEFAULT_RECONNECT_BASE_DELAY_MS;
-        const maxDelay = this.config.reconnect?.maxDelayMs ?? DEFAULT_RECONNECT_MAX_DELAY_MS;
-        const delay = Math.min(baseDelay * 2 ** attempt, maxDelay);
-        this.reconnectAttempt = attempt + 1;
+        const wasDisposed = this.connectionState.status === 'disposed';
+        const reason = input?.reason;
         if (typeof reason === 'string' && reason.trim().length > 0) {
             this.lastErrorValue = reason.trim();
         }
@@ -1928,10 +2181,28 @@ export class DaemonClient {
         this.clearWaiters(new Error(reason ?? 'Connection lost'));
         this.rejectPendingSendQueue(new Error(reason ?? 'Connection lost'));
         this.terminalStreams.clearAll();
+        this.lastWelcomeMessage = null;
+        if (wasDisposed) {
+            this.rejectConnect(new Error(reason ?? 'Daemon client is disposed'));
+            return;
+        }
         this.updateConnectionState({
             status: 'disconnected',
             ...(reason ? { reason } : {}),
+        }, {
+            event: input?.event ?? 'TRANSPORT_CLOSE',
+            ...(reason ? { reason } : {}),
+            ...(input?.reasonCode ? { reasonCode: input.reasonCode } : {}),
         });
+        if (!this.shouldReconnect || this.config.reconnect?.enabled === false) {
+            this.rejectConnect(new Error(reason ?? 'Transport disconnected before connect'));
+            return;
+        }
+        const attempt = this.reconnectAttempt;
+        const baseDelay = this.config.reconnect?.baseDelayMs ?? DEFAULT_RECONNECT_BASE_DELAY_MS;
+        const maxDelay = this.config.reconnect?.maxDelayMs ?? DEFAULT_RECONNECT_MAX_DELAY_MS;
+        const delay = Math.min(baseDelay * 2 ** attempt, maxDelay);
+        this.reconnectAttempt = attempt + 1;
         this.reconnectTimeout = setTimeout(() => {
             this.reconnectTimeout = null;
             if (!this.shouldReconnect) {