@aexol/spectral 0.4.9 → 0.4.10

package/dist/server/session-stream.js

@@ -42,6 +42,13 @@ import { generateSessionTitle, isDefaultTitle, } from "./title-generator.js";
 const DEFAULT_BRIDGE_FACTORY = (args) => new PiBridge(args);
 /** Safety limit for autonomous loop iterations per session. */
 const MAX_LOOP_ITERATIONS = 100;
+/**
+ * Token threshold above which the loop triggers compaction between iterations.
+ * 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
@@ -524,6 +531,58 @@ export class SessionStreamManager {
             }
         });
     }
+    /**
+     * Send the next prompt for an autonomous loop iteration, waiting for any
+     * in-flight observational-memory compaction to finish first so the LLM
+     * sees the compacted context.
+     *
+     * The compaction-trigger extension fires on agent_end (via setTimeout),
+     * so we poll stream.compacting briefly. If compaction hasn't started after
+     * a short grace period, we check whether the context window exceeds the
+     * threshold and proactively trigger compaction via the bridge (which
+     * invokes pi's full pipeline, including the session_before_compact hook
+     * where the observational memory extension provides its summary).
+     *
+     * 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.
+     */
+    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`);
+        }
+    }
     // --- internals ----------------------------------------------------------
     createStream(sessionId, history) {
         // Resolve cwd from the owning project. Sessions without a project
@@ -555,6 +614,7 @@ export class SessionStreamManager {
             loopOriginalPrompt: null,
             forkCompactSourceId: forkSourceId ?? null,
             compacting: false,
+            compactionEndResolve: null,
             contextWindowUsed: null,
             contextWindowMax: null,
         };
@@ -703,6 +763,18 @@ 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.
+        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") {
             // Final flush + clear batch-persist tracking. `onAssistantMessageComplete`
@@ -753,7 +825,7 @@ export class SessionStreamManager {
                         maxIterations: MAX_LOOP_ITERATIONS,
                         prompt: stream.loopOriginalPrompt,
                     });
-                    void this.prompt(stream.sessionId, stream.loopOriginalPrompt, undefined).catch((err) => {
+                    void this.sendNextLoopIteration(stream).catch((err) => {
                         console.error(`[loop] iteration failed: ${err instanceof Error ? err.message : String(err)}`);
                         stream.loopActive = false;
                         stream.loopOriginalPrompt = null;

package/package.json

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