@aexol/spectral 0.9.260 → 0.9.263

package/dist/server/session-stream.js

@@ -104,6 +104,23 @@ const UI_HISTORY_TAIL_MESSAGE_LIMIT = 60;
  * at most the last `BATCH_FLUSH_INTERVAL` events, not the entire turn.
  */
 const BATCH_FLUSH_INTERVAL = 10;
+/**
+ * Auto-recovery threshold (FIX 4): a `bridge.prompt()` rejection that
+ * settles within this window is "fast" — it indicates the bridge/SDK
+ * session state is broken (synchronous throws settle in single-digit ms)
+ * rather than a slow provider failure. Legitimate turn failures (model
+ * timeouts, tool errors) take seconds, so they never count toward the
+ * streak.
+ */
+const FAST_PROMPT_REJECTION_THRESHOLD_MS = 500;
+/**
+ * Auto-recovery threshold (FIX 4): after this many CONSECUTIVE fast
+ * `bridge.prompt()` rejections while the stream is idle (no compaction,
+ * no active turn), the bridge is disposed and marked for rebuild so the
+ * next `prompt()` constructs a fresh bridge from the SQLite history —
+ * the same recovery `cancelTurn` performed, but automatic.
+ */
+const AUTO_REBUILD_AFTER_FAST_REJECTIONS = 3;
 export class SessionStreamManager {
     store;
     cwd;
@@ -1121,13 +1138,47 @@ export class SessionStreamManager {
         //    (e.g. disposed bridge, missing session) arrive as a rejected promise
         //    we handle here so the frontend sees the error rather than a silent
         //    dead turn.
-        stream.bridge.prompt(annotatedContent, images).catch((err) => {
+        const promptStartedAt = Date.now();
+        stream.bridge
+            .prompt(annotatedContent, images)
+            .then(() => {
+            // The turn completed — a fast-rejection streak (if any) is over.
+            stream.consecutiveFastPromptRejections = 0;
+        })
+            .catch((err) => {
             const msg = err instanceof Error ? err.message : String(err);
             console.error(`[spectral] error: bridge.prompt failed: ${msg}`);
             this.broadcast(stream, {
                 type: "error",
                 message: humanizeProviderError(err),
             });
+            // FIX 4 auto-recovery: a broken SDK session state makes
+            // `bridge.prompt()` reject synchronously (~ms) on EVERY attempt while
+            // the stream itself returns to idle — the bridge's own catch emits
+            // `agent_end`, which clears `currentTurn`. Without recovery the dead
+            // bridge is reused forever until the user manually presses Stop
+            // (cancelTurn). Count consecutive FAST rejections observed while the
+            // stream is idle (no compaction, no active turn); after a short streak
+            // dispose the bridge and mark it for rebuild so the next `prompt()`
+            // constructs a fresh bridge from the SQLite history. The user message
+            // was persisted BEFORE `bridge.prompt()`, so the rebuild loses nothing.
+            const fast = Date.now() - promptStartedAt <
+                FAST_PROMPT_REJECTION_THRESHOLD_MS;
+            if (!stream.compacting && stream.currentTurn == null && fast) {
+                stream.consecutiveFastPromptRejections += 1;
+                if (stream.consecutiveFastPromptRejections
+                    >= AUTO_REBUILD_AFTER_FAST_REJECTIONS) {
+                    const streak = stream.consecutiveFastPromptRejections;
+                    stream.consecutiveFastPromptRejections = 0;
+                    console.warn(`[spectral] warn: auto-rebuilding bridge for ${sessionId}: ${streak} consecutive fast prompt rejections (<${FAST_PROMPT_REJECTION_THRESHOLD_MS}ms) while idle — disposing bridge to rebuild from SQLite history. Last error: ${msg}`);
+                    this.disposeAndMarkForRebuild(stream, `Auto-rebuild after ${streak} fast prompt rejections: ${msg}`);
+                }
+            }
+            else {
+                // Slow rejection, compaction in flight, or a turn still active:
+                // no evidence of a broken-bridge streak — reset the counter.
+                stream.consecutiveFastPromptRejections = 0;
+            }
         });
     }
     /**
@@ -1181,6 +1232,35 @@ export class SessionStreamManager {
         }
         return n;
     }
+    /**
+     * Shared teardown for "the bridge is dead — rebuild it from SQLite on the
+     * next prompt": disposes the current bridge and marks the stream with a
+     * `startError` so `dispatchPrompt` reconstructs a fresh bridge from the
+     * persisted session history (subscribers, cwd and stream metadata are
+     * preserved — only the bridge is replaced).
+     *
+     * Used by `cancelTurn` (the user pressed Stop) and by the FIX 4
+     * auto-recovery path in the `bridge.prompt().catch` handler (repeated
+     * fast rejections from a broken SDK session state). The user message of
+     * a failed prompt is persisted BEFORE `bridge.prompt()` is invoked, so
+     * the rebuild loses nothing.
+     */
+    disposeAndMarkForRebuild(stream, reason) {
+        try {
+            stream.bridge.dispose();
+        }
+        catch {
+            // ignore — dispose failures must not mask the rebuild marker
+        }
+        // Set startError so any late `await stream.ready` rejects cleanly
+        // instead of hanging. Also prevents the next prompt() from waiting on
+        // a dead bridge's ready promise.
+        stream.startError = new Error(reason);
+        // Clear batch-persist tracking so the next turn doesn't accidentally
+        // flush events against a stale messageId.
+        stream.currentMessageId = null;
+        stream.lastFlushedEventCount = 0;
+    }
     /**
      * Cancel the in-flight turn for a session (user pressed Stop in the UI).
      * Disposes the agent bridge and broadcasts `agent_end` so all subscribers
@@ -1214,20 +1294,7 @@ export class SessionStreamManager {
         // Dispose the agent bridge immediately — this tears down spectral's session and
         // unsubscribe. The bridge's own event handler is detached; no further
         // events will flow. We broadcast agent_end ourselves below.
-        try {
-            stream.bridge.dispose();
-        }
-        catch {
-            // ignore
-        }
-        // Set startError so any late `await stream.ready` rejects cleanly
-        // instead of hanging. Also prevents the next prompt() from waiting on
-        // a dead bridge's ready promise.
-        stream.startError = new Error("Turn cancelled");
-        // Clear batch-persist tracking so the next turn doesn't accidentally
-        // flush events against a stale messageId.
-        stream.currentMessageId = null;
-        stream.lastFlushedEventCount = 0;
+        this.disposeAndMarkForRebuild(stream, "Turn cancelled");
         // Broadcast agent_end so all subscribers close their open turn and
         // re-enable their composers. Use the pre-disposal flag — dispose()
         // may have cleared currentTurn via an error event from the torn-down
@@ -1660,6 +1727,7 @@ export class SessionStreamManager {
             contextWindowUsed: null,
             contextWindowMax: null,
             lastDcpEvent: null,
+            consecutiveFastPromptRejections: 0,
         };
         const memorySnapshot = this.store.getSessionMemorySnapshot(sessionId);
         const bridgeHistory = selectHistoryForBridge(history, memorySnapshot != null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aexol/spectral",
-  "version": "0.9.260",
+  "version": "0.9.263",
   "description": "AI coding agent for Aexol with relay-based browser access.",
   "type": "module",
   "private": false,