@aexol/spectral 0.4.10 → 0.4.12

package/dist/server/session-stream.js

@@ -47,8 +47,6 @@ const MAX_LOOP_ITERATIONS = 100;
  * Aligned with the observational memory extension default (memory/config.ts).
  */
 const LOOP_COMPACTION_THRESHOLD_TOKENS = 50_000;
-/** Maximum time (ms) to wait for compaction to finish between loop iterations. */
-const LOOP_COMPACTION_MAX_WAIT_MS = 30_000;
 /**
  * Number of accumulated wire events before flushing the in-flight turn
  * to SQLite. Batch-persisting means a server crash mid-turn only loses
@@ -546,42 +544,44 @@ export class SessionStreamManager {
      * A duplicate call from the extension's delayed compaction trigger is
      * harmless — pi throws "Already compacted" which the extension catches.
      */
-    async sendNextLoopIteration(stream) {
-        // The observational-memory extension's compaction-trigger fires on
-        // agent_end (via setTimeout, so it's slightly delayed). We wait for
-        // either:
-        //   (a) compaction to start and finish (stream.compacting becomes
-        //       true then false), or
-        //   (b) a grace period to elapse without compaction starting (context
-        //       was below the threshold, or the extension deferred).
-        //
-        // This guarantees the LLM sees the compacted context when the
-        // compaction threshold was reached, and doesn't delay the loop when
-        // no compaction is needed.
-        const GRACE_MS = 500; // give the trigger's setTimeout a chance
-        const start = Date.now();
-        // Wait for the trigger to start compaction, or for grace period to pass.
-        while (!stream.compacting && Date.now() - start < GRACE_MS) {
-            await new Promise((r) => setTimeout(r, 50));
-        }
-        if (stream.compacting) {
-            console.log("[loop] compaction in progress, waiting...");
-            await this.waitForCompactionOrTimeout(stream);
-            console.log("[loop] compaction finished, sending next iteration");
-        }
-        await this.prompt(stream.sessionId, stream.loopOriginalPrompt, undefined);
-    }
     /**
-     * Poll until stream.compacting becomes false or the timeout elapses.
+     * Send the next prompt for an autonomous loop iteration, compacting first
+     * if the context window exceeds the threshold.
+     *
+     * Instead of polling for the extension's delayed compaction-trigger (which
+     * fires via setTimeout), we proactively call bridge.compact() directly.
+     * bridge.compact() → session.compact() → fires session_before_compact
+     * (where the extension's compaction-hook provides the observational-memory
+     * summary), then appends the compaction entry, reloads the compacted
+     * context into agent.state.messages, and emits compaction_start/end.
+     *
+     * The extension's trigger still fires (via setTimeout), but by the time
+     * its callback runs, bridge.compact() has already appended the compaction
+     * entry → prepareCompaction() returns undefined → "Already compacted"
+     * → the trigger's onError handler catches it harmlessly.
      */
-    async waitForCompactionOrTimeout(stream) {
-        const start = Date.now();
-        while (stream.compacting && Date.now() - start < LOOP_COMPACTION_MAX_WAIT_MS) {
-            await new Promise((r) => setTimeout(r, 200));
-        }
-        if (stream.compacting) {
-            console.warn(`[loop] compaction still in-flight after ${LOOP_COMPACTION_MAX_WAIT_MS}ms, proceeding anyway`);
+    async sendNextLoopIteration(stream) {
+        const shouldCompact = stream.bridge.compact &&
+            typeof stream.contextWindowUsed === "number" &&
+            stream.contextWindowUsed > LOOP_COMPACTION_THRESHOLD_TOKENS;
+        if (shouldCompact) {
+            try {
+                console.log(`[loop] compacting context (~${stream.contextWindowUsed.toLocaleString()} tokens > ${LOOP_COMPACTION_THRESHOLD_TOKENS.toLocaleString()} threshold)`);
+                await stream.bridge.compact();
+                console.log("[loop] compaction complete, sending next iteration");
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (msg === "Already compacted" ||
+                    msg === "Nothing to compact (session too small)") {
+                    console.log("[loop] compaction already done or not needed, proceeding");
+                }
+                else {
+                    console.error(`[loop] compaction failed: ${msg}`);
+                }
+            }
         }
+        await this.prompt(stream.sessionId, stream.loopOriginalPrompt, undefined);
     }
     // --- internals ----------------------------------------------------------
     createStream(sessionId, history) {
@@ -614,7 +614,6 @@ export class SessionStreamManager {
             loopOriginalPrompt: null,
             forkCompactSourceId: forkSourceId ?? null,
             compacting: false,
-            compactionEndResolve: null,
             contextWindowUsed: null,
             contextWindowMax: null,
         };
@@ -763,17 +762,13 @@ export class SessionStreamManager {
             if (event.contextWindowMax != null)
                 stream.contextWindowMax = event.contextWindowMax;
         }
-        // Track compaction lifecycle so the loop (and prompt() guard) can wait
-        // for it to complete before starting the next iteration.
+        // Track compaction lifecycle so prompt() can block new messages while
+        // compaction is running.
         if (event.type === "compaction_start") {
             stream.compacting = true;
         }
         if (event.type === "compaction_end") {
             stream.compacting = false;
-            if (stream.compactionEndResolve) {
-                stream.compactionEndResolve();
-                stream.compactionEndResolve = null;
-            }
         }
         this.broadcast(stream, event);
         if (event.type === "agent_end") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aexol/spectral",
-  "version": "0.4.10",
+  "version": "0.4.12",
   "description": "Always-on coding agent for Aexol — branded pi wrapper with relay-based browser access.",
   "type": "module",
   "private": false,