@aexol/spectral 0.1.3 → 0.1.7

package/dist/commands/serve.js

@@ -38,7 +38,7 @@ import { fileURLToPath } from "node:url";
 import { getConfigDir } from "../config.js";
 import { requireLogin } from "../preflight.js";
 import { RelayClient } from "../relay/client.js";
-import { detachAllSubscribers, handleClientMessage, handleRestRequest, handleSubscribe, } from "../relay/dispatcher.js";
+import { detachAllSubscribers, handleCancelTurn, handleClientMessage, handleRestRequest, handleSubscribe, } from "../relay/dispatcher.js";
 import { ensureMachineRegistered } from "../relay/registration.js";
 import { SessionStreamManager } from "../server/session-stream.js";
 import { gracefulShutdown } from "../server/shutdown.js";
@@ -252,6 +252,10 @@ export async function runServe(opts = {}) {
             });
             return;
         }
+        if (frame.kind === "cancel_turn") {
+            handleCancelTurn(frame, { manager });
+            return;
+        }
         // Other frames (error, machine_disconnected addressed to us, etc.)
         // are ignored at this layer. Future batches may surface them in
         // structured logs.

package/dist/relay/dispatcher.js

@@ -407,11 +407,12 @@ export function handleClientMessage(frame, deps) {
         return;
     }
     const content = message.content;
-    const isAexol = message.aexol === true;
+    const isLoop = message.loop === true;
     const validImages = coerceImages(message.images);
-    // Set autonomous refactor loop state before firing the prompt.
-    // aexol:true  → start/renew loop; aexol:false → stop loop.
-    manager.setAexolActive(sessionId, isAexol);
+    // 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);
     // 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.
@@ -465,10 +466,9 @@ export function handleClientMessage(frame, deps) {
     //    against the team-scoped whitelist; the CLI resolves it via pi's
     //    own model registry inside the manager → bridge.
     //
-    //    When `aexol: true` is set on the message, route to the refactor-loop
-    //    user model instead of the default session model.
-    const effectiveModelId = isAexol ? "__aexol_refactor_loop__" : modelId;
-    manager.prompt(sessionId, content, effectiveModelId, validImages).catch((err) => {
+    //    When `loop: true`, loop state is set before prompting; the normal
+    //    model is used — loop replay is handled by session-stream on agent_end.
+    manager.prompt(sessionId, content, modelId, validImages).catch((err) => {
         logger.error?.(`[dispatcher] manager.prompt failed for ${sessionId}:`, err);
     });
 }
@@ -532,6 +532,16 @@ export function handleSubscribe(frame, deps) {
         });
     }
 }
+/**
+ * Dispatch a `cancel_turn` frame. Disposes the session's pi bridge and
+ * removes the stream so the next user message creates a fresh one. The
+ * bridge dispose triggers `agent_end` broadcast to all subscribers.
+ *
+ * Idempotent: no-ops when no stream exists for the session.
+ */
+export function handleCancelTurn(frame, deps) {
+    deps.manager.cancelTurn(frame.sessionId);
+}
 /**
  * Detach every subscriber the dispatcher has attached. Called by
  * `serve.ts` on relay disconnect / shutdown so the underlying pi

package/dist/server/pi-bridge.js

@@ -38,14 +38,15 @@
  * configured) are caught by the caller in `routes.ts` and re-emitted as
  * `{type:"error"}`.
  *
- * History rehydration limitation:
- *  Pi's SDK exposes `messages` and `sendUserMessage` but reconstructing a
- *  fresh AgentSession from a transcript of `WireMessage`s is non-trivial —
- *  the SDK's internal state (tool registry, system prompt, model context)
- *  expects to own message creation. For the MVP we accept that pi sees a
- *  fresh context on reconnect; the user still sees the full transcript in
- *  the UI because we send `session_ready.history` from SQLite. Multi-turn
- *  conversations within a single WS connection work normally.
+ * History rehydration:
+ *  On first attach to a previously-created session (e.g. after a server
+ *  restart), the SessionStreamManager passes the full SQLite transcript
+ *  to the PiBridge via `PiBridgeOptions.history`. Before
+ *  `createAgentSession` is called, each message is appended to the
+ *  in-memory SessionManager so the LLM sees the full conversation
+ *  context from the very first prompt. Multi-turn conversations within
+ *  a single pi session also work normally (the same AgentSession
+ *  instance is reused across `prompt()` calls).
  */
 import { AuthStorage, createAgentSession, DefaultResourceLoader, ModelRegistry, SessionManager, } from "@mariozechner/pi-coding-agent";
 import { createJiti } from "@mariozechner/jiti";
@@ -69,7 +70,6 @@ import { fetchAllowedModels as defaultFetchAllowedModels, } from "../relay/model
 const SPECTRAL_PROXY_ANTHROPIC = "spectral-proxy-anthropic";
 const SPECTRAL_PROXY_OPENAI = "spectral-proxy-openai";
 const SPECTRAL_PROXY_USER_MODEL = "spectral-proxy-user-model";
-const SPECTRAL_PROXY_AEXOL_REFACTOR = "spectral-proxy-aexol-refactor";
 /**
  * Concatenate text from an `AssistantMessage.content` array. Returns the
  * empty string when no text blocks are present (tool-only turns) or when
@@ -192,6 +192,53 @@ export class PiBridge {
         await resourceLoader.reload();
         // In-memory session: SQLite is our source of truth.
         const sessionManager = SessionManager.inMemory(this.opts.cwd);
+        // Rehydrate session history so the LLM sees the full conversation
+        // transcript from the beginning (not just the current prompt).
+        // Previously this was documented as a "History rehydration
+        // limitation" — the UI saw the transcript but pi did not.
+        if (this.opts.history && this.opts.history.length > 0) {
+            for (const msg of this.opts.history) {
+                if (msg.role === "user") {
+                    const content = msg.images && msg.images.length > 0
+                        ? [
+                            ...msg.images.map((img) => ({
+                                type: "image",
+                                data: img.data,
+                                mimeType: img.mimeType,
+                            })),
+                            { type: "text", text: msg.content },
+                        ]
+                        : msg.content;
+                    sessionManager.appendMessage({
+                        role: "user",
+                        content,
+                        timestamp: msg.createdAt,
+                    });
+                }
+                else if (msg.role === "assistant") {
+                    const textBlocks = msg.content ? [{ type: "text", text: msg.content }] : [];
+                    sessionManager.appendMessage({
+                        role: "assistant",
+                        content: textBlocks,
+                        api: "anthropic-messages",
+                        provider: "spectral-proxy-anthropic",
+                        model: "unknown",
+                        usage: {
+                            input: 0,
+                            output: 0,
+                            cacheRead: 0,
+                            cacheWrite: 0,
+                            totalTokens: 0,
+                            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+                        },
+                        stopReason: "stop",
+                        timestamp: msg.createdAt,
+                    });
+                }
+                // system messages are informational only; skip for LLM context
+            }
+            console.info(`[PiBridge] Rehydrated ${this.opts.history.length} history message(s) into session context`);
+        }
         // Build a model registry that does NOT touch ~/.pi/agent/auth.json or
         // ~/.pi/agent/models.json — the backend is now the only source of
         // provider credentials and the only allowed inference target. We then
@@ -340,31 +387,6 @@ export class PiBridge {
                 })),
             });
         }
-        // Refactor-loop model — dedicated endpoint for Aexol agent chat toggle.
-        // Routes to the team user model at /models/team/aexol/refactor-loop/v1
-        // using machine JWT auth, same as other synthetic providers.
-        {
-            const refactorBaseUrl = `${this.opts.backendUrl.replace(/\/$/, "")}/models/built-in/refactor-loop/v1`;
-            this.modelRegistry.registerProvider(SPECTRAL_PROXY_AEXOL_REFACTOR, {
-                baseUrl: refactorBaseUrl,
-                apiKey: this.opts.machineJwt,
-                authHeader: true,
-                api: "openai-completions",
-                models: [
-                    {
-                        id: "__aexol_refactor_loop__",
-                        name: "Aexol Refactor Loop",
-                        api: "openai-completions",
-                        baseUrl: refactorBaseUrl,
-                        reasoning: false,
-                        input: ["text", "image"],
-                        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-                        contextWindow: 0,
-                        maxTokens: 0,
-                    },
-                ],
-            });
-        }
     }
     /**
      * Apply a sticky model selection to the underlying pi session, if it

package/dist/server/session-stream.js

@@ -40,8 +40,10 @@ import { randomUUID } from "node:crypto";
 import { PiBridge } from "./pi-bridge.js";
 import { generateSessionTitle, isDefaultTitle, } from "./title-generator.js";
 const DEFAULT_BRIDGE_FACTORY = (args) => new PiBridge(args);
-/** Safety limit for autonomous refactor loop iterations per session. */
-const MAX_AEXOL_ITERATIONS = 100;
+/** Safety limit for autonomous loop iterations per session. */
+const MAX_LOOP_ITERATIONS = 100;
+/** Marker the agent emits in its response to signal the task is complete. */
+const LOOP_DONE_MARKER = "<LOOP_DONE>";
 export class SessionStreamManager {
     store;
     cwd;
@@ -89,7 +91,7 @@ export class SessionStreamManager {
             throw new Error(`Unknown sessionId: ${sessionId}`);
         let stream = this.streams.get(sessionId);
         if (!stream) {
-            stream = this.createStream(sessionId);
+            stream = this.createStream(sessionId, detail.messages);
             this.streams.set(sessionId, stream);
         }
         stream.subscribers.add(subscriber);
@@ -145,9 +147,52 @@ export class SessionStreamManager {
     async prompt(sessionId, content, modelId, images) {
         if (this.disposed)
             throw new Error("SessionStreamManager disposed");
-        const stream = this.streams.get(sessionId);
+        let stream = this.streams.get(sessionId);
         if (!stream)
             throw new Error(`No active stream for session: ${sessionId}`);
+        // If the bridge was disposed (e.g. by cancelTurn), recreate it before
+        // proceeding. We rebuild only the bridge inside the existing stream so
+        // subscribers, cwd, and other metadata are preserved.
+        if (stream.startError) {
+            const history = this.store.getSession(sessionId)?.messages;
+            const bridgeOpts = {
+                cwd: stream.cwd,
+                agentDir: this.agentDir,
+                backendUrl: this.backendUrl,
+                machineJwt: this.machineJwt,
+                history,
+                emit: (event) => this.handleBridgeEvent(stream, event),
+                onAssistantMessageComplete: ({ messageId, content, eventsJsonl }) => {
+                    try {
+                        this.store.appendMessage(sessionId, {
+                            id: messageId,
+                            role: "assistant",
+                            content,
+                            eventsJsonl,
+                        });
+                    }
+                    catch (err) {
+                        console.error(`[spectral] error: failed to persist assistant message: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                },
+                onError: (err) => {
+                    console.error(`[spectral] error: pi bridge error: ${err.message}`);
+                },
+            };
+            stream.bridge = this.bridgeFactory(bridgeOpts);
+            stream.startError = null;
+            stream.ready = stream.bridge
+                .start()
+                .catch((err) => {
+                const e = err instanceof Error ? err : new Error(String(err));
+                stream.startError = e;
+                this.broadcast(stream, {
+                    type: "error",
+                    message: `Failed to start agent: ${e.message}`,
+                });
+                throw e;
+            });
+        }
         // Wait for pi to be ready before we persist + invoke. If start failed,
         // surface to all subscribers instead of throwing into the route handler.
         try {
@@ -237,7 +282,7 @@ export class SessionStreamManager {
             return;
         this.disposed = true;
         for (const stream of this.streams.values()) {
-            stream.aexolActive = false;
+            stream.loopActive = false;
             try {
                 stream.bridge.dispose();
             }
@@ -270,6 +315,49 @@ export class SessionStreamManager {
         }
         return n;
     }
+    /**
+     * Cancel the in-flight turn for a session (user pressed Stop in the UI).
+     * Disposes the pi bridge and broadcasts `agent_end` so all subscribers
+     * see the turn close. The stream itself is kept alive — the next user
+     * message (via `prompt()`) will lazily create a fresh bridge.
+     *
+     * Idempotent: if no stream exists for the session, or no turn is in
+     * flight, this is a no-op.
+     */
+    cancelTurn(sessionId) {
+        const stream = this.streams.get(sessionId);
+        if (!stream)
+            return;
+        // Stop any active loop before disposing — if the loop was mid-iteration
+        // the next agent_end would otherwise trigger another prompt.
+        stream.loopActive = false;
+        stream.loopOriginalPrompt = 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
+        // events will flow. We broadcast agent_end ourselves below.
+        try {
+            stream.bridge.dispose();
+        }
+        catch {
+            // ignore
+        }
+        // Set startError so any late `await stream.ready` in the loop path
+        // (if the loop was between iterations when we disposed) 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");
+        // Broadcast agent_end so all subscribers close their open turn and
+        // re-enable their composers.
+        if (stream.currentTurn) {
+            this.broadcast(stream, { type: "agent_end" });
+            stream.currentTurn = null;
+        }
+        // Don't delete the stream — the subscribers are still attached and the
+        // next `prompt()` call will create a fresh bridge via `createStream()`.
+        // We just need to signal that the bridge is gone so `prompt()` knows to
+        // recreate one.
+    }
     /**
      * Tear down a single session's stream — disposes the pi bridge and clears
      * subscribers. Idempotent. Called by the routes layer right before
@@ -282,7 +370,7 @@ export class SessionStreamManager {
         const stream = this.streams.get(sessionId);
         if (!stream)
             return;
-        stream.aexolActive = false;
+        stream.loopActive = false;
         try {
             stream.bridge.dispose();
         }
@@ -318,20 +406,25 @@ export class SessionStreamManager {
         }
     }
     /**
-     * Set the autonomous refactor loop state for a session. When `active` is
-     * true, the manager will auto-send "continue" after each `agent_end` event
-     * until deactivated or the safety limit is reached.
+     * Set the autonomous iterative loop state for a session.
+     *
+     * When `active` is true, the manager replays `originalPrompt` after each
+     * `agent_end` event — the agent sees its own file changes from prior
+     * iterations and iteratively improves its solution (Ralph Wiggum pattern).
+     * The loop stops when the agent emits `<LOOP_DONE>` in its response or the
+     * safety iteration limit is reached.
      */
-    setAexolActive(sessionId, active) {
+    setLoopActive(sessionId, active, originalPrompt) {
         const stream = this.streams.get(sessionId);
         if (stream) {
-            stream.aexolActive = active;
+            stream.loopActive = active;
+            stream.loopOriginalPrompt = active ? (originalPrompt ?? null) : null;
             if (!active)
-                stream.aexolIterationCount = 0;
+                stream.loopIterationCount = 0;
         }
     }
     // --- internals ----------------------------------------------------------
-    createStream(sessionId) {
+    createStream(sessionId, history) {
         // Resolve cwd from the owning project. Sessions without a project
         // shouldn't exist (FK enforces it), but we fall back to the manager's
         // default cwd if the lookup somehow fails — better than crashing the
@@ -353,14 +446,16 @@ export class SessionStreamManager {
             startError: null,
             subscribers: new Set(),
             currentTurn: null,
-            aexolActive: false,
-            aexolIterationCount: 0,
+            loopActive: false,
+            loopIterationCount: 0,
+            loopOriginalPrompt: null,
         };
         const bridgeOpts = {
             cwd,
             agentDir: this.agentDir,
             backendUrl: this.backendUrl,
             machineJwt: this.machineJwt,
+            history,
             emit: (event) => this.handleBridgeEvent(stream, event),
             onAssistantMessageComplete: ({ messageId, content, eventsJsonl }) => {
                 try {
@@ -428,19 +523,47 @@ export class SessionStreamManager {
             // default title, and never blocks the user's stream (the user's
             // turn is already complete by the time this runs).
             this.maybeGenerateTitle(stream, finishedTurn);
-            // Autonomous refactor loop: when aexolActive is set, auto-send
-            // "continue" after each agent_end to keep the loop going.
-            if (stream.aexolActive && stream.aexolIterationCount < MAX_AEXOL_ITERATIONS) {
-                stream.aexolIterationCount++;
-                console.log(`[aexol-loop] iteration ${stream.aexolIterationCount}/${MAX_AEXOL_ITERATIONS}`);
-                void this.prompt(stream.sessionId, "continue", undefined).catch((err) => {
-                    console.error(`[aexol-loop] iteration failed: ${err instanceof Error ? err.message : String(err)}`);
-                    stream.aexolActive = false;
-                });
-            }
-            else if (stream.aexolActive) {
-                console.log("[aexol-loop] max iterations reached, stopping");
-                stream.aexolActive = false;
+            // Autonomous iterative loop (Ralph Wiggum pattern).
+            // When loopActive is set, check for completion marker, then re-send
+            // the ORIGINAL prompt so the agent sees its prior changes and
+            // iteratively improves the solution.
+            if (stream.loopActive && stream.loopOriginalPrompt) {
+                const finishedAssistantText = finishedTurn?.assistantText ?? "";
+                if (finishedAssistantText.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;
+                    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`);
+                    stream.loopActive = false;
+                    stream.loopOriginalPrompt = null;
+                    this.broadcast(stream, {
+                        type: "loop_max_iterations",
+                        iterations: stream.loopIterationCount,
+                    });
+                }
+                else {
+                    stream.loopIterationCount++;
+                    console.log(`[loop] iteration ${stream.loopIterationCount}/${MAX_LOOP_ITERATIONS}`);
+                    this.broadcast(stream, {
+                        type: "loop_iteration",
+                        iteration: stream.loopIterationCount,
+                        maxIterations: MAX_LOOP_ITERATIONS,
+                        prompt: stream.loopOriginalPrompt,
+                    });
+                    void this.prompt(stream.sessionId, stream.loopOriginalPrompt, undefined).catch((err) => {
+                        console.error(`[loop] iteration failed: ${err instanceof Error ? err.message : String(err)}`);
+                        stream.loopActive = false;
+                        stream.loopOriginalPrompt = null;
+                    });
+                }
             }
         }
         else if (event.type === "error") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aexol/spectral",
-  "version": "0.1.3",
+  "version": "0.1.7",
   "description": "Always-on coding agent for Aexol — branded pi wrapper with relay-based browser access.",
   "type": "module",
   "private": false,
@@ -54,7 +54,7 @@
     "@mariozechner/jiti": "^2.6.5",
     "@mariozechner/pi-coding-agent": "^0.70.2",
     "better-sqlite3": "^12.9.0",
-    "pi-mcp-adapter": "^2.5.4",
+    "pi-mcp-adapter": "file:../packages/pi-mcp-adapter",
     "picocolors": "^1.1.1",
     "ws": "^8.20.0"
   },