@aexol/spectral 0.9.181 → 0.9.183

package/dist/relay/client.js

@@ -7,12 +7,16 @@
  *    machine JWT via `Authorization: Bearer <jwt>`.
  *  - Reply `{kind:"pong"}` to backend `{kind:"ping"}`. Backend closes
  *    `4408 heartbeat-timeout` if it doesn't hear from us within 90s; we
- *    rely on the backend pings rather than emitting our own (single source
- *    of liveness, no jitter on our side).
+ *    keep this app-level reply in addition to the protocol-level heartbeat
+ *    below.
+ *  - **Client heartbeat:** additionally emits a protocol-level `ws` ping
+ *    every `HEARTBEAT_INTERVAL_MS` and requires a `pong` within
+ *    `HEARTBEAT_TIMEOUT_MS`. This detects a half-open send path (e.g. after
+ *    laptop sleep/wake) where `readyState` still reports `OPEN`.
  *  - **Watchdog timer:** tracks `lastActivityMs` on every received frame /
  *    ping. Every 15 s, if no activity within `WATCHDOG_MS` (120 s = 2×
- *    backend timeout), force-closes the socket (4001 "watchdog-timeout")
- *    and triggers a reconnect. Detects silent backend death (Docker OOM
+ *    backend timeout), terminates the socket and triggers a reconnect.
+ *    Detects silent backend death (Docker OOM
  *    kill, network partition without TCP RST) where the socket stays open
  *    but no data flows.
  *  - **Pre-reconnect health check:** before opening a new WS, does a quick
@@ -66,6 +70,14 @@ const WATCHDOG_INTERVAL_MS = 15_000;
 const WATCHDOG_SILENCE_MS = 120_000;
 /** HTTP timeout for the pre-reconnect health check. */
 const HEALTH_CHECK_TIMEOUT_MS = 5_000;
+/** TCP keepalive initial delay (ms). Lets the OS detect a dead path after sleep. */
+const TCP_KEEPALIVE_MS = 30_000;
+/** Client-originated protocol-level ping interval (ms). */
+const HEARTBEAT_INTERVAL_MS = 30_000;
+/** Client pong timeout before forcing a reconnect (ms). */
+const HEARTBEAT_TIMEOUT_MS = 10_000;
+/** Outbound write acknowledgement timeout (ms). */
+const SEND_TIMEOUT_MS = 10_000;
 export class RelayClient extends EventEmitter {
     relayUrl;
     machineJwt;
@@ -86,11 +98,19 @@ export class RelayClient extends EventEmitter {
     tightLoopWindowStart = 0;
     reconnectTimer = null;
     sendQueue = [];
+    /** Wire currently waiting on a `ws.send` callback. Only one in flight to preserve FIFO. */
+    sendInFlight = null;
+    sendTimer = null;
     /** Set true when the WS error handler sees an HTTP 401/403 upgrade rejection. */
     authFailed = false;
     /** Timestamp of last received frame / ping — drives the watchdog. */
     lastActivityMs = 0;
     watchdogTimer = null;
+    heartbeatTimer = null;
+    heartbeatPongTimer = null;
+    heartbeatPending = false;
+    /** Guards the async window of `scheduleReconnect` (health check). */
+    reconnectInFlight = false;
     constructor(opts) {
         super();
         this.relayUrl = opts.relayUrl;
@@ -106,7 +126,7 @@ export class RelayClient extends EventEmitter {
     connect() {
         if (this.disposed)
             return;
-        if (this.ws)
+        if (this.ws || this.reconnectTimer || this.reconnectInFlight)
             return;
         this.openSocket();
     }
@@ -122,22 +142,8 @@ export class RelayClient extends EventEmitter {
         if (this.disposed)
             return false;
         const wire = typeof frame === "string" ? frame : JSON.stringify(frame);
-        const ws = this.ws;
-        if (ws && ws.readyState === WebSocket.OPEN) {
-            try {
-                ws.send(wire);
-                return true;
-            }
-            catch (err) {
-                this.emit("error", err);
-                return false;
-            }
-        }
-        // Queue it.
-        if (this.sendQueue.length >= SEND_QUEUE_CAP) {
-            this.sendQueue.shift();
-        }
-        this.sendQueue.push(wire);
+        this.enqueueWire(wire);
+        this.flushSendQueue();
         return true;
     }
     /**
@@ -156,6 +162,8 @@ export class RelayClient extends EventEmitter {
             clearInterval(this.watchdogTimer);
             this.watchdogTimer = null;
         }
+        this.stopHeartbeat();
+        this.clearSendInFlight();
         const ws = this.ws;
         this.ws = null;
         if (ws) {
@@ -183,25 +191,20 @@ export class RelayClient extends EventEmitter {
         this.lastActivityMs = Date.now();
         this.startWatchdog();
         ws.on("open", () => {
+            if (this.ws !== ws)
+                return;
             this.lastActivityMs = Date.now();
             this.openedAtMs = Date.now();
-            // Flush any queued frames.
-            const queued = this.sendQueue;
-            this.sendQueue = [];
-            for (const wire of queued) {
-                try {
-                    ws.send(wire);
-                }
-                catch (err) {
-                    // Re-queue on failure and stop draining; the next open will retry.
-                    this.sendQueue = queued.slice(queued.indexOf(wire));
-                    this.emit("error", err);
-                    return;
-                }
-            }
+            this.setTcpKeepAlive(ws);
+            this.startHeartbeat();
+            // Flush any queued frames with write acknowledgements and timeouts.
+            this.clearSendInFlight();
+            this.flushSendQueue();
             this.emit("open");
         });
         ws.on("message", (data) => {
+            if (this.ws !== ws)
+                return;
             this.lastActivityMs = Date.now();
             let parsed;
             try {
@@ -213,12 +216,7 @@ export class RelayClient extends EventEmitter {
             }
             // Heartbeat: reply pong inline, do NOT propagate.
             if (parsed && parsed.kind === "ping") {
-                try {
-                    ws.send(JSON.stringify({ kind: "pong" }));
-                }
-                catch (err) {
-                    this.emit("error", err);
-                }
+                this.send({ kind: "pong" });
                 return;
             }
             if (parsed && parsed.kind === "welcome") {
@@ -230,7 +228,21 @@ export class RelayClient extends EventEmitter {
             }
             this.emit("frame", parsed);
         });
+        ws.on("pong", () => {
+            if (this.ws !== ws)
+                return;
+            this.lastActivityMs = Date.now();
+            if (this.heartbeatPending) {
+                this.heartbeatPending = false;
+                if (this.heartbeatPongTimer) {
+                    clearTimeout(this.heartbeatPongTimer);
+                    this.heartbeatPongTimer = null;
+                }
+            }
+        });
         ws.on("error", (err) => {
+            if (this.ws !== ws)
+                return;
             // Detect HTTP auth failures during the WS upgrade handshake.
             // The `ws` library surfaces these as `Error: Unexpected server
             // response: 401` (or 403). Mark `authFailed` so the close handler
@@ -240,97 +252,13 @@ export class RelayClient extends EventEmitter {
                 msg.includes("Unexpected server response: 403")) {
                 this.authFailed = true;
             }
-            // `ws` emits 'error' before 'close'; we don't reconnect here — the
-            // 'close' handler is the single reconnect entry point so we don't
-            // double-schedule.
+            // `ws` emits 'error' before 'close'. Reconnect is driven from the
+            // `close` handler (or `forceReconnect` for suspected-dead sockets);
+            // scheduling it here would double-schedule.
             this.emit("error", err);
         });
         ws.on("close", (code, reason) => {
-            this.ws = null;
-            this.stopWatchdog();
-            // Stable-open gate: only reset backoff if the socket was open long
-            // enough to be considered healthy. A connect→immediate-die loop (1006,
-            // proxy kill, duplicate instance) must escalate through the full
-            // schedule instead of pinning at RECONNECT_SCHEDULE[0] = 1s forever.
-            const openDuration = this.openedAtMs > 0 ? Date.now() - this.openedAtMs : 0;
-            this.openedAtMs = 0;
-            if (openDuration >= STABLE_OPEN_MS) {
-                this.reconnectAttempt = 0;
-                this.consecutiveRapidCloses = 0;
-            }
-            else {
-                // Tight-loop detection: if the socket dies repeatedly right after
-                // open, bail out with an actionable message instead of reconnecting
-                // forever.
-                const now = Date.now();
-                if (now - this.tightLoopWindowStart > TIGHT_LOOP_WINDOW_MS) {
-                    this.tightLoopWindowStart = now;
-                    this.consecutiveRapidCloses = 1;
-                }
-                else {
-                    this.consecutiveRapidCloses++;
-                }
-                if (this.consecutiveRapidCloses >= TIGHT_LOOP_MAX_CLOSES) {
-                    this.logger.error("\n✗ Relay connection dropped repeatedly right after opening.");
-                    this.logger.error("  This usually means another `spectral serve` process is running for the same machine,");
-                    this.logger.error("  or a reverse proxy / firewall is closing the WebSocket immediately.");
-                    this.logger.error('  Check: `ps aux | grep "spectral serve"` and your proxy WS timeout settings.\n');
-                    this.dispose();
-                    this.exit(1);
-                    return;
-                }
-            }
-            const reasonStr = reason?.toString() ?? "";
-            this.emit("close", { code, reason: reasonStr });
-            if (this.disposed)
-                return;
-            // Backend evicts older WS sessions when a newer registration arrives
-            // for the same machineId (see backend `registry.ts: register()`).
-            // If we reconnect here we'll just kick out the new instance, which
-            // will then reconnect and kick us out — an infinite ping-pong.
-            // Exit instead so the operator (or process supervisor) notices.
-            if (code === 1000 && reasonStr === "replaced-by-newer-registration") {
-                this.logger.error("\n✗ Another `spectral serve` instance has registered for this machine.");
-                this.logger.error("  This instance is exiting to avoid a reconnect loop.");
-                this.logger.error("  If you want to run multiple instances, use distinct `--machine-name` values.\n");
-                this.dispose();
-                this.exit(1);
-                return;
-            }
-            // Machine was revoked by the team admin from the Aexol Studio panel
-            // (backend sets `KnownMachine.revokedAt` and closes the socket with
-            // 4001 "machine-revoked"). Exit immediately — the machine JWT is now
-            // invalid and re-registration requires a fresh `spectral serve`.
-            if (code === 4001 && reasonStr === "machine-revoked") {
-                this.logger.error("\n✗ This machine has been disconnected from the Aexol Studio panel.");
-                // Delete the machine identity file so the next `spectral serve`
-                // forces a fresh registration rather than reusing the revoked JWT.
-                unlink(getMachineFile()).catch(() => { });
-                this.logger.error("  Run `spectral login` then `spectral serve` to re-register.\n");
-                this.dispose();
-                this.exit(1);
-                return;
-            }
-            if (reasonStr === "team-changed") {
-                // Team was changed via Studio — the machine_team_changed frame handler
-                // in serve.ts already saved the new JWT. Just reconnect normally.
-                if (this.authFailed) {
-                    this.emit("auth-failed");
-                    return;
-                }
-                this.scheduleReconnect();
-                return;
-            }
-            // Auth failure at the transport layer (HTTP 401/403 on WS upgrade).
-            // The machine JWT is invalid (expired, malformed, or revoked by key
-            // rotation) but the backend didn't send a structured close reason.
-            // Signal the caller so it can attempt re-registration instead of
-            // entering an infinite reconnect loop with a dead token.
-            if (this.authFailed) {
-                this.emit("auth-failed");
-                return;
-            }
-            this.scheduleReconnect();
+            this.handleDisconnect(ws, code, reason?.toString() ?? "");
         });
     }
     // --- watchdog -------------------------------------------------------------
@@ -343,16 +271,7 @@ export class RelayClient extends EventEmitter {
             const elapsed = Date.now() - this.lastActivityMs;
             if (elapsed > WATCHDOG_SILENCE_MS) {
                 this.logger.warn(`Watchdog: no relay activity for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
-                const ws = this.ws;
-                this.ws = null;
-                if (ws) {
-                    try {
-                        ws.close(4001, "watchdog-timeout");
-                    }
-                    catch {
-                        // ignore
-                    }
-                }
+                this.forceReconnect("watchdog-timeout");
             }
         }, WATCHDOG_INTERVAL_MS);
     }
@@ -362,6 +281,250 @@ export class RelayClient extends EventEmitter {
             this.watchdogTimer = null;
         }
     }
+    // --- heartbeat -------------------------------------------------------------
+    startHeartbeat() {
+        if (this.heartbeatTimer)
+            return;
+        this.heartbeatTimer = setInterval(() => {
+            if (this.disposed)
+                return;
+            const ws = this.ws;
+            if (!ws || ws.readyState !== WebSocket.OPEN || this.heartbeatPending) {
+                return;
+            }
+            this.heartbeatPending = true;
+            this.heartbeatPongTimer = setTimeout(() => {
+                this.heartbeatPongTimer = null;
+                if (!this.heartbeatPending)
+                    return;
+                this.heartbeatPending = false;
+                this.logger.warn("Heartbeat: no pong from relay, forcing reconnect");
+                this.forceReconnect("heartbeat-timeout");
+            }, HEARTBEAT_TIMEOUT_MS);
+            try {
+                ws.ping();
+            }
+            catch (err) {
+                this.heartbeatPending = false;
+                if (this.heartbeatPongTimer) {
+                    clearTimeout(this.heartbeatPongTimer);
+                    this.heartbeatPongTimer = null;
+                }
+                this.emit("error", err);
+                this.forceReconnect("heartbeat-error");
+            }
+        }, HEARTBEAT_INTERVAL_MS);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.heartbeatPongTimer) {
+            clearTimeout(this.heartbeatPongTimer);
+            this.heartbeatPongTimer = null;
+        }
+        this.heartbeatPending = false;
+    }
+    // --- outbound send safety ---------------------------------------------------
+    enqueueWire(wire) {
+        if (this.sendQueue.length >= SEND_QUEUE_CAP) {
+            // Never evict the frame currently awaiting a write callback — it is
+            // still at the front of the queue and must survive a reconnect.
+            const dropIndex = this.sendInFlight !== null ? 1 : 0;
+            if (this.sendQueue.length > dropIndex) {
+                this.sendQueue.splice(dropIndex, 1);
+            }
+        }
+        this.sendQueue.push(wire);
+    }
+    clearSendInFlight() {
+        this.sendInFlight = null;
+        if (this.sendTimer) {
+            clearTimeout(this.sendTimer);
+            this.sendTimer = null;
+        }
+    }
+    /**
+     * Drain the FIFO send queue over the current socket. Exactly one frame is
+     * in flight at a time so ordering is preserved. If `ws.send` never calls
+     * its callback (half-open socket), the frame stays at the front of the
+     * queue and the connection is force-reconnected; the next `open` flushes
+     * it again.
+     */
+    flushSendQueue() {
+        if (this.disposed)
+            return;
+        const ws = this.ws;
+        if (!ws ||
+            ws.readyState !== WebSocket.OPEN ||
+            this.sendInFlight !== null ||
+            this.sendQueue.length === 0) {
+            return;
+        }
+        const wire = this.sendQueue[0];
+        this.sendInFlight = wire;
+        this.sendTimer = setTimeout(() => {
+            this.sendTimer = null;
+            if (this.sendInFlight !== wire || this.ws !== ws)
+                return;
+            this.sendInFlight = null;
+            this.logger.warn("Relay send timed out; forcing reconnect");
+            this.forceReconnect("send-timeout");
+        }, SEND_TIMEOUT_MS);
+        try {
+            ws.send(wire, (err) => {
+                if (this.sendInFlight !== wire)
+                    return;
+                this.sendInFlight = null;
+                if (this.sendTimer) {
+                    clearTimeout(this.sendTimer);
+                    this.sendTimer = null;
+                }
+                if (err) {
+                    this.logger.warn(`Relay send failed: ${err.message}`);
+                    this.forceReconnect("send-error");
+                    return;
+                }
+                if (this.sendQueue[0] === wire) {
+                    this.sendQueue.shift();
+                }
+                this.flushSendQueue();
+            });
+        }
+        catch (err) {
+            if (this.sendInFlight === wire) {
+                this.sendInFlight = null;
+                if (this.sendTimer) {
+                    clearTimeout(this.sendTimer);
+                    this.sendTimer = null;
+                }
+                this.emit("error", err);
+                this.forceReconnect("send-error");
+            }
+        }
+    }
+    setTcpKeepAlive(ws) {
+        const socket = ws._socket;
+        if (socket && typeof socket.setKeepAlive === "function") {
+            socket.setKeepAlive(true, TCP_KEEPALIVE_MS);
+        }
+    }
+    /**
+     * Tear down a suspected-dead socket and schedule a reconnect immediately.
+     * Unlike the `close` path, this does not wait for a (possibly never
+     * arriving) `close` event — `terminate()` destroys the socket directly.
+     */
+    forceReconnect(reason) {
+        if (this.disposed)
+            return;
+        const ws = this.ws;
+        if (!ws) {
+            void this.scheduleReconnect();
+            return;
+        }
+        try {
+            ws.terminate();
+        }
+        catch (err) {
+            this.emit("error", err);
+        }
+        this.handleDisconnect(ws, 1006, reason);
+    }
+    /**
+     * Single disconnect entry point for both real `close` events and forced
+     * reconnects. Ignored for sockets that have already been replaced.
+     */
+    handleDisconnect(ws, code, reason) {
+        if (this.ws !== ws)
+            return;
+        this.ws = null;
+        this.stopWatchdog();
+        this.stopHeartbeat();
+        this.clearSendInFlight();
+        // Stable-open gate: only reset backoff if the socket was open long
+        // enough to be considered healthy. A connect→immediate-die loop (1006,
+        // proxy kill, duplicate instance) must escalate through the full
+        // schedule instead of pinning at RECONNECT_SCHEDULE[0] = 1s forever.
+        const openDuration = this.openedAtMs > 0 ? Date.now() - this.openedAtMs : 0;
+        this.openedAtMs = 0;
+        if (openDuration >= STABLE_OPEN_MS) {
+            this.reconnectAttempt = 0;
+            this.consecutiveRapidCloses = 0;
+        }
+        else {
+            // Tight-loop detection: if the socket dies repeatedly right after
+            // open, bail out with an actionable message instead of reconnecting
+            // forever.
+            const now = Date.now();
+            if (now - this.tightLoopWindowStart > TIGHT_LOOP_WINDOW_MS) {
+                this.tightLoopWindowStart = now;
+                this.consecutiveRapidCloses = 1;
+            }
+            else {
+                this.consecutiveRapidCloses++;
+            }
+            if (this.consecutiveRapidCloses >= TIGHT_LOOP_MAX_CLOSES) {
+                this.logger.error("\n✗ Relay connection dropped repeatedly right after opening.");
+                this.logger.error("  This usually means another `spectral serve` process is running for the same machine,");
+                this.logger.error("  or a reverse proxy / firewall is closing the WebSocket immediately.");
+                this.logger.error('  Check: `ps aux | grep "spectral serve"` and your proxy WS timeout settings.\n');
+                this.dispose();
+                this.exit(1);
+                return;
+            }
+        }
+        this.emit("close", { code, reason });
+        if (this.disposed)
+            return;
+        // Backend evicts older WS sessions when a newer registration arrives
+        // for the same machineId (see backend `registry.ts: register()`).
+        // If we reconnect here we'll just kick out the new instance, which
+        // will then reconnect and kick us out — an infinite ping-pong.
+        // Exit instead so the operator (or process supervisor) notices.
+        if (code === 1000 && reason === "replaced-by-newer-registration") {
+            this.logger.error("\n✗ Another `spectral serve` instance has registered for this machine.");
+            this.logger.error("  This instance is exiting to avoid a reconnect loop.");
+            this.logger.error("  If you want to run multiple instances, use distinct `--machine-name` values.\n");
+            this.dispose();
+            this.exit(1);
+            return;
+        }
+        // Machine was revoked by the team admin from the Aexol Studio panel
+        // (backend sets `KnownMachine.revokedAt` and closes the socket with
+        // 4001 "machine-revoked"). Exit immediately — the machine JWT is now
+        // invalid and re-registration requires a fresh `spectral serve`.
+        if (code === 4001 && reason === "machine-revoked") {
+            this.logger.error("\n✗ This machine has been disconnected from the Aexol Studio panel.");
+            // Delete the machine identity file so the next `spectral serve`
+            // forces a fresh registration rather than reusing the revoked JWT.
+            unlink(getMachineFile()).catch(() => { });
+            this.logger.error("  Run `spectral login` then `spectral serve` to re-register.\n");
+            this.dispose();
+            this.exit(1);
+            return;
+        }
+        if (reason === "team-changed") {
+            // Team was changed via Studio — the machine_team_changed frame handler
+            // in serve.ts already saved the new JWT. Just reconnect normally.
+            if (this.authFailed) {
+                this.emit("auth-failed");
+                return;
+            }
+            void this.scheduleReconnect();
+            return;
+        }
+        // Auth failure at the transport layer (HTTP 401/403 on WS upgrade).
+        // The machine JWT is invalid (expired, malformed, or revoked by key
+        // rotation) but the backend didn't send a structured close reason.
+        // Signal the caller so it can attempt re-registration instead of
+        // entering an infinite reconnect loop with a dead token.
+        if (this.authFailed) {
+            this.emit("auth-failed");
+            return;
+        }
+        void this.scheduleReconnect();
+    }
     /**
      * Pre-reconnect health check: quick HTTP GET to `<backendUrl>/health`.
      * Returns true when the backend is reachable (or when no backendUrl is
@@ -400,54 +563,62 @@ export class RelayClient extends EventEmitter {
     async scheduleReconnect() {
         if (this.disposed)
             return;
-        if (this.reconnectTimer)
+        if (this.reconnectTimer || this.reconnectInFlight)
             return;
-        // Pre-reconnect health check — avoids wasting time on a slow TCP
-        // connect when the backend is down. The health endpoint is a cheap
-        // HTTP GET; if even that fails, skip the WS attempt entirely.
-        const healthy = await this.healthCheck();
-        if (!healthy) {
-            // Backend unreachable — use a fixed 5 s retry instead of advancing
-            // the backoff schedule (this is an environment problem, not a WS
-            // handshake problem).
+        this.reconnectInFlight = true;
+        try {
+            // Pre-reconnect health check — avoids wasting time on a slow TCP
+            // connect when the backend is down. The health endpoint is a cheap
+            // HTTP GET; if even that fails, skip the WS attempt entirely.
+            const healthy = await this.healthCheck();
+            if (this.disposed)
+                return;
+            if (!healthy) {
+                // Backend unreachable — use a fixed 5 s retry instead of advancing
+                // the backoff schedule (this is an environment problem, not a WS
+                // handshake problem).
+                const idx = Math.min(this.reconnectAttempt, RECONNECT_SCHEDULE.length - 1);
+                const delay = RECONNECT_SCHEDULE[idx];
+                this.reconnectAttempt++;
+                this.emit("reconnect-scheduled", { delayMs: delay, attempt: this.reconnectAttempt });
+                this.reconnectTimer = setTimeout(() => {
+                    this.reconnectTimer = null;
+                    void this.scheduleReconnect().catch(() => { });
+                }, delay);
+                return;
+            }
             const idx = Math.min(this.reconnectAttempt, RECONNECT_SCHEDULE.length - 1);
-            const delay = RECONNECT_SCHEDULE[idx];
+            const base = RECONNECT_SCHEDULE[idx];
+            const jitter = base * JITTER_RATIO * (Math.random() * 2 - 1);
+            const delay = Math.max(0, Math.round(base + jitter));
             this.reconnectAttempt++;
             this.emit("reconnect-scheduled", { delayMs: delay, attempt: this.reconnectAttempt });
+            // IMPORTANT: do NOT `unref()` this timer. `spectral serve` is a long-
+            // lived daemon and the reconnect timer is frequently the ONLY thing
+            // keeping the event loop alive between a WS close and the next open
+            // (the SessionStreamManager holds nothing while idle). An unref'd
+            // timer lets Node decide the loop is empty and exit the process,
+            // which manifests as the daemon silently dying after a network blip.
+            // Tests dispose the client explicitly via `dispose()`, which clears
+            // this timer, so they still terminate cleanly.
             this.reconnectTimer = setTimeout(() => {
                 this.reconnectTimer = null;
-                void this.scheduleReconnect().catch(() => { });
+                if (this.disposed)
+                    return;
+                try {
+                    this.openSocket();
+                }
+                catch (err) {
+                    // A synchronous throw from the WebSocket constructor (DNS, bad
+                    // URL, etc.) must not kill the daemon — log it and re-schedule
+                    // so the backoff continues forever.
+                    this.emit("error", err);
+                    void this.scheduleReconnect().catch(() => { });
+                }
             }, delay);
-            return;
         }
-        const idx = Math.min(this.reconnectAttempt, RECONNECT_SCHEDULE.length - 1);
-        const base = RECONNECT_SCHEDULE[idx];
-        const jitter = base * JITTER_RATIO * (Math.random() * 2 - 1);
-        const delay = Math.max(0, Math.round(base + jitter));
-        this.reconnectAttempt++;
-        this.emit("reconnect-scheduled", { delayMs: delay, attempt: this.reconnectAttempt });
-        // IMPORTANT: do NOT `unref()` this timer. `spectral serve` is a long-
-        // lived daemon and the reconnect timer is frequently the ONLY thing
-        // keeping the event loop alive between a WS close and the next open
-        // (the SessionStreamManager holds nothing while idle). An unref'd
-        // timer lets Node decide the loop is empty and exit the process,
-        // which manifests as the daemon silently dying after a network blip.
-        // Tests dispose the client explicitly via `dispose()`, which clears
-        // this timer, so they still terminate cleanly.
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = null;
-            if (this.disposed)
-                return;
-            try {
-                this.openSocket();
-            }
-            catch (err) {
-                // A synchronous throw from the WebSocket constructor (DNS, bad
-                // URL, etc.) must not kill the daemon — log it and re-schedule
-                // so the backoff continues forever.
-                this.emit("error", err);
-                void this.scheduleReconnect().catch(() => { });
-            }
-        }, delay);
+        finally {
+            this.reconnectInFlight = false;
+        }
     }
 }

package/dist/relay/models-fetch.d.ts

@@ -2,9 +2,9 @@
  * Fetch the admin-managed list of allowed base models from the backend.
  *
  * Used by `AgentBridge` at startup to register synthetic providers
- * (`spectral-proxy-anthropic` / `spectral-proxy-openai`) that route every
- * inference call through the backend's `/v1/messages` and
- * `/v1/chat/completions` endpoints. The backend authenticates the call
+ * (`spectral-proxy-openai` / `spectral-proxy-user-model`) that route every
+ * inference call through the backend's `/v1/chat/completions` endpoint.
+ * The backend authenticates the call
  * with the machine JWT (Bearer) and forwards to the upstream provider
  * using its own (centralized) API keys.
  *

package/dist/relay/models-fetch.js

@@ -2,9 +2,9 @@
  * Fetch the admin-managed list of allowed base models from the backend.
  *
  * Used by `AgentBridge` at startup to register synthetic providers
- * (`spectral-proxy-anthropic` / `spectral-proxy-openai`) that route every
- * inference call through the backend's `/v1/messages` and
- * `/v1/chat/completions` endpoints. The backend authenticates the call
+ * (`spectral-proxy-openai` / `spectral-proxy-user-model`) that route every
+ * inference call through the backend's `/v1/chat/completions` endpoint.
+ * The backend authenticates the call
  * with the machine JWT (Bearer) and forwards to the upstream provider
  * using its own (centralized) API keys.
  *

package/dist/sdk/ai/cache-benchmark/benchmark.d.ts

@@ -0,0 +1,6 @@
+import type { BenchmarkConfig, BenchmarkResult, CacheStrategy } from "./types.js";
+export declare function runBenchmark(strategy: CacheStrategy, config: BenchmarkConfig): BenchmarkResult;
+/** Run several strategies over one scenario and fill in the keep-all cost delta. */
+export declare function runBenchmarkSuite(strategies: CacheStrategy[], config: BenchmarkConfig): BenchmarkResult[];
+export declare function formatBenchmarkReport(results: BenchmarkResult[]): string;
+//# sourceMappingURL=benchmark.d.ts.map