@aexol/spectral 0.5.1 → 0.6.1

package/dist/relay/dispatcher.js

@@ -465,11 +465,13 @@ export function handleClientMessage(frame, deps) {
     }
     const content = message.content;
     const isLoop = message.loop === true;
+    const loopMaxIterations = message.loopMaxIterations;
+    const loopGoal = message.loopGoal;
     const validImages = coerceImages(message.images);
     // Set autonomous iterative loop state before firing the prompt.
     // loop:true  → start/renew loop with the current content as original prompt;
     // loop:false → stop any active loop.
-    manager.setLoopActive(sessionId, isLoop, content);
+    manager.setLoopActive(sessionId, isLoop, content, loopMaxIterations, loopGoal);
     // 2. Attach (idempotent). On first attach we capture the replay payload
     //    and synthesize a `session_ready` ws_event so the browser sees the
     //    same first frame it would have on a direct WS connection.

package/dist/server/session-stream.js

@@ -642,6 +642,7 @@ export class SessionStreamManager {
         // the next agent_end would otherwise trigger another prompt.
         stream.loopActive = false;
         stream.loopOriginalPrompt = null;
+        stream.loopGoal = null;
         stream.loopIterationCount = 0;
         // Dispose the pi bridge immediately — this tears down pi's session and
         // unsubscribe. The bridge's own event handler is detached; no further
@@ -731,13 +732,22 @@ export class SessionStreamManager {
      * The loop stops when the agent emits `<LOOP_DONE>` in its response or the
      * safety iteration limit is reached.
      */
-    setLoopActive(sessionId, active, originalPrompt) {
+    setLoopActive(sessionId, active, originalPrompt, maxIterations, goal) {
         const stream = this.streams.get(sessionId);
         if (stream) {
             stream.loopActive = active;
             stream.loopOriginalPrompt = active ? (originalPrompt ?? null) : null;
-            if (!active)
+            if (active) {
+                if (maxIterations !== undefined && maxIterations > 0) {
+                    stream.loopMaxIterations = Math.min(maxIterations, MAX_LOOP_ITERATIONS);
+                }
+                stream.loopGoal = goal?.trim() || null;
+            }
+            else {
                 stream.loopIterationCount = 0;
+                stream.loopMaxIterations = MAX_LOOP_ITERATIONS;
+                stream.loopGoal = null;
+            }
         }
     }
     /**
@@ -825,6 +835,29 @@ export class SessionStreamManager {
      * entry → prepareCompaction() returns undefined → "Already compacted"
      * → the trigger's onError handler catches it harmlessly.
      */
+    buildLoopPrompt(stream) {
+        const parts = [];
+        if (stream.loopGoal) {
+            parts.push(`[GOAL]: ${stream.loopGoal}`);
+        }
+        parts.push(stream.loopOriginalPrompt);
+        parts.push("");
+        parts.push("--- LOOP INSTRUCTIONS ---\n" +
+            "You are running in an iterative loop. Each iteration you see your previous changes\n" +
+            "and can improve them further.\n" +
+            (stream.loopGoal
+                ? "The [GOAL] above defines what you need to achieve.\n"
+                : "\n") +
+            "CRITICAL: After EVERY response you MUST self-evaluate:\n" +
+            "- If the task IS FULLY COMPLETE (nothing meaningful left to do), " +
+            "respond with <LOOP_DONE> as the VERY FIRST text in your reply,\n" +
+            "  followed by a brief summary of what was accomplished.\n" +
+            "- If more work remains, continue working WITHOUT <LOOP_DONE>.\n" +
+            "- <LOOP_DONE> is the ONLY way to stop the loop. If you do not emit it,\n" +
+            "  you WILL be prompted again to keep working.\n" +
+            "Be decisive: if the task is done, stop. Do not keep polishing.");
+        return parts.join("\n");
+    }
     async sendNextLoopIteration(stream) {
         const shouldCompact = stream.bridge.compact &&
             typeof stream.contextWindowUsed === "number" &&
@@ -846,7 +879,7 @@ export class SessionStreamManager {
                 }
             }
         }
-        await this.prompt(stream.sessionId, stream.loopOriginalPrompt, undefined);
+        await this.prompt(stream.sessionId, this.buildLoopPrompt(stream), undefined);
     }
     // --- internals ----------------------------------------------------------
     createStream(sessionId, history) {
@@ -877,6 +910,8 @@ export class SessionStreamManager {
             loopActive: false,
             loopIterationCount: 0,
             loopOriginalPrompt: null,
+            loopMaxIterations: MAX_LOOP_ITERATIONS,
+            loopGoal: null,
             forkCompactSourceId: forkSourceId ?? null,
             compacting: false,
             contextWindowUsed: null,
@@ -1064,21 +1099,26 @@ export class SessionStreamManager {
             // iteratively improves the solution.
             if (stream.loopActive && stream.loopOriginalPrompt) {
                 const finishedAssistantText = finishedTurn?.assistantText ?? "";
-                if (finishedAssistantText.includes(LOOP_DONE_MARKER)) {
+                // Check for the loop-done marker in the first portion of the
+                // response (the prompt instructs the agent to emit it first).
+                const head = finishedAssistantText.slice(0, 500);
+                if (head.includes(LOOP_DONE_MARKER)) {
                     console.log(`[loop] completion marker detected after ${stream.loopIterationCount} iteration(s), stopping`);
                     const completedIterations = stream.loopIterationCount;
                     stream.loopActive = false;
                     stream.loopIterationCount = 0;
                     stream.loopOriginalPrompt = null;
+                    stream.loopGoal = null;
                     this.broadcast(stream, {
                         type: "loop_complete",
                         iterations: completedIterations,
                     });
                 }
-                else if (stream.loopIterationCount >= MAX_LOOP_ITERATIONS) {
-                    console.log(`[loop] max iterations (${MAX_LOOP_ITERATIONS}) reached, stopping`);
+                else if (stream.loopIterationCount >= stream.loopMaxIterations) {
+                    console.log(`[loop] max iterations (${stream.loopMaxIterations}) reached, stopping`);
                     stream.loopActive = false;
                     stream.loopOriginalPrompt = null;
+                    stream.loopGoal = null;
                     this.broadcast(stream, {
                         type: "loop_max_iterations",
                         iterations: stream.loopIterationCount,
@@ -1086,17 +1126,18 @@ export class SessionStreamManager {
                 }
                 else {
                     stream.loopIterationCount++;
-                    console.log(`[loop] iteration ${stream.loopIterationCount}/${MAX_LOOP_ITERATIONS}`);
+                    console.log(`[loop] iteration ${stream.loopIterationCount}/${stream.loopMaxIterations}`);
                     this.broadcast(stream, {
                         type: "loop_iteration",
                         iteration: stream.loopIterationCount,
-                        maxIterations: MAX_LOOP_ITERATIONS,
+                        maxIterations: stream.loopMaxIterations,
                         prompt: stream.loopOriginalPrompt,
                     });
                     void this.sendNextLoopIteration(stream).catch((err) => {
                         console.error(`[loop] iteration failed: ${err instanceof Error ? err.message : String(err)}`);
                         stream.loopActive = false;
                         stream.loopOriginalPrompt = null;
+                        stream.loopGoal = null;
                     });
                 }
             }

package/package.json

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