@aexol/spectral 0.7.7 → 0.8.0

package/dist/server/{pi-bridge.js → agent-bridge.js}

@@ -1,7 +1,7 @@
 /**
  * Per-connection pi SDK lifecycle.
  *
- * One `PiBridge` instance per active WebSocket connection. Wraps:
+ * One `AgentBridge` instance per active WebSocket connection. Wraps:
  *  - `createAgentSession` (in-memory session manager — we own persistence in
  *    SQLite; pi doesn't need to write its own JSONL files).
  *  - `subscribe` listener that translates pi `AgentSessionEvent`s into our
@@ -41,7 +41,7 @@
  * 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
+ *  to the AgentBridge via `AgentBridgeOptions.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
@@ -49,12 +49,13 @@
  *  instance is reused across `prompt()` calls).
  */
 import { createJiti } from "@mariozechner/jiti";
-import { AuthStorage, createAgentSession, DefaultResourceLoader, ModelRegistry, SessionManager, } from "../pi/coding-agent/index.js";
+import { AuthStorage, createAgentSession, DefaultResourceLoader, ModelRegistry, SessionManager, SettingsManager, } from "../sdk/coding-agent/index.js";
 import { randomUUID } from "node:crypto";
 import { existsSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import aexolMcpExtension from "../extensions/aexol-mcp.js";
+import spectralVisionExtension from "../extensions/spectral-vision-fallback.js";
 import subagentExt from "../agent/index.js";
 import designerExtension from "../designer/index.js";
 import observationalMemory from "../memory/index.js";
@@ -133,7 +134,7 @@ function extractTextFromContent(content) {
  */
 function resolveMcpAdapterEntry() {
     const __dirname = dirname(fileURLToPath(import.meta.url));
-    // pi-bridge.ts compiles to dist/server/pi-bridge.js;
+    // agent-bridge.ts compiles to dist/server/agent-bridge.js;
     // the bundled MCP adapter sits next door at dist/mcp/index.js.
     const bundledIndex = resolve(__dirname, "..", "mcp", "index.js");
     if (existsSync(bundledIndex))
@@ -195,6 +196,27 @@ function bareModelId(modelId) {
     const idx = modelId.lastIndexOf("/");
     return idx === -1 ? modelId : modelId.slice(idx + 1);
 }
+/** Get model cost from backend credit rates, falling back to hardcoded pricing table. */
+function getModelCost(m) {
+    // Prefer backend credit rates when configured
+    const hasCredits = m.creditInputPer1M != null ||
+        m.creditOutputPer1M != null ||
+        m.creditCacheReadPer1M != null ||
+        m.creditCacheWritePer1M != null;
+    if (hasCredits) {
+        return {
+            input: m.creditInputPer1M ?? 0,
+            output: m.creditOutputPer1M ?? 0,
+            cacheRead: m.creditCacheReadPer1M ?? 0,
+            cacheWrite: m.creditCacheWritePer1M ?? 0,
+        };
+    }
+    // Fall back to hardcoded pricing table when credits aren't configured
+    const pricing = lookupPricing(m.modelId);
+    return pricing
+        ? { input: pricing.input, output: pricing.output, cacheRead: pricing.cacheRead, cacheWrite: pricing.cacheWrite }
+        : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+}
 /** Look up pricing for a modelId. Returns null when unknown. */
 function lookupPricing(modelId) {
     const bare = bareModelId(modelId);
@@ -210,21 +232,28 @@ function lookupPricing(modelId) {
     }
     return null;
 }
-/**
- * Model prefixes known to support reasoning/thinking.
- * Mirrors pi-ai's supportsXhigh() + additional models.
- */
-const REASONING_SUPPORT_PREFIXES = [
-    "gpt-5.2", "gpt-5.3", "gpt-5.4", "gpt-5.5",
-    "claude-opus-4",
-    "o3", "o4",
-    "deepseek-r1",
-    "gemini-2.5",
-];
-/** Check if a modelId prefix indicates reasoning/thinking support. */
-function supportsReasoning(modelId) {
-    const bare = bareModelId(modelId);
-    return REASONING_SUPPORT_PREFIXES.some((p) => modelId.startsWith(p) || bare.startsWith(p));
+function inferSyntheticOpenAICompat(model) {
+    const bare = bareModelId(model.modelId);
+    const isDeepSeek = model.provider === "deepseek" ||
+        model.modelId.startsWith("deepseek/") ||
+        bare.startsWith("deepseek");
+    if (isDeepSeek) {
+        return {
+            thinkingFormat: "deepseek",
+            requiresReasoningContentOnAssistantMessages: true,
+            supportsDeveloperRole: false,
+        };
+    }
+    if (model.provider === "openrouter") {
+        const compat = {
+            thinkingFormat: "openrouter",
+        };
+        if (model.modelId.startsWith("anthropic/")) {
+            compat.cacheControlFormat = "anthropic";
+        }
+        return compat;
+    }
+    return undefined;
 }
 /**
  * Calculate credits from token usage using per-model credit rates.
@@ -348,7 +377,7 @@ function toRestoredMemorySnapshot(snapshot) {
         details: normalizeSnapshotDetails(snapshot.details),
     };
 }
-export class PiBridge {
+export class AgentBridge {
     session;
     sessionManager;
     unsubscribe;
@@ -388,8 +417,8 @@ export class PiBridge {
      */
     async start() {
         if (this.disposed)
-            throw new Error("PiBridge already disposed");
-        const extensionFactories = [aexolMcpExtension, async (pi) => { subagentExt(pi); }, async (pi) => { designerExtension(pi); }, async (pi) => { observationalMemory(pi); }];
+            throw new Error("AgentBridge already disposed");
+        const extensionFactories = [aexolMcpExtension, async (pi) => { spectralVisionExtension(pi); }, async (pi) => { subagentExt(pi); }, async (pi) => { designerExtension(pi); }, async (pi) => { observationalMemory(pi); }];
         // Load pi-mcp-adapter via jiti so tsc never crawls its .ts files in
         // node_modules. The static `import` was causing tsc to type-check
         // pi-mcp-adapter's source and fail the build on its type errors.
@@ -404,25 +433,25 @@ export class PiBridge {
                 }
             }
             catch {
-                console.info("[PiBridge] pi-mcp-adapter not found; standard MCP servers disabled.");
+                console.info("[AgentBridge] pi-mcp-adapter not found; standard MCP servers disabled.");
             }
         }
         else {
-            console.info("[PiBridge] pi-mcp-adapter not found; standard MCP servers disabled.");
+            console.info("[AgentBridge] pi-mcp-adapter not found; standard MCP servers disabled.");
         }
         // ResourceLoader with extensions wired in via factories.
         // Each factory's signature `(pi: ExtensionAPI) => Promise<void>` matches
         // the ExtensionFactory type exactly, so we can pass them directly.
         //
-        // Skill discovery: pi's defaults scan ~/.pi/agent/skills/ (user),
-        // .pi/skills/ (project via CONFIG_DIR_NAME), and .agents/skills/
+        // Skill discovery: pi's defaults scan ~/.spectral/agent/skills/ (user),
+        // .spectral/skills/ (project via CONFIG_DIR_NAME), and .agents/skills/
         // (ancestor-walked). We additionally walk ancestors for
         // .opencode/skills and .aexol/skills so OpenCode/Codex/Aexol skills
         // work out of the box.
         const extraSkillPaths = collectAncestorSkillDirs(this.opts.cwd, [".opencode/skills", ".aexol/skills"]);
         const resourceLoader = new DefaultResourceLoader({
             cwd: this.opts.cwd,
-            agentDir: this.opts.agentDir ?? `${process.env.HOME ?? ""}/.pi/agent`,
+            agentDir: this.opts.agentDir ?? `${process.env.HOME ?? ""}/.spectral/agent`,
             extensionFactories,
             noExtensions: false,
             noSkills: false,
@@ -528,7 +557,7 @@ export class PiBridge {
                 }
                 // system messages are informational only; skip for LLM context
             }
-            console.info(`[PiBridge] Rehydrated ${this.opts.history.length} history message(s) into session context`);
+            console.info(`[AgentBridge] Rehydrated ${this.opts.history.length} history message(s) into session context`);
         }
         if (this.opts.memorySnapshot) {
             const restoredSnapshot = toRestoredMemorySnapshot(this.opts.memorySnapshot);
@@ -544,10 +573,10 @@ export class PiBridge {
                     coveredSourceCount: restoredSnapshot.coveredSourceCount,
                 });
             }
-            console.info(`[PiBridge] Restored observational memory snapshot covering ${restoredSnapshot.coveredSourceCount} source entr${restoredSnapshot.coveredSourceCount === 1 ? "y" : "ies"}`);
+            console.info(`[AgentBridge] Restored observational memory snapshot covering ${restoredSnapshot.coveredSourceCount} source entr${restoredSnapshot.coveredSourceCount === 1 ? "y" : "ies"}`);
         }
-        // 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
+        // Build a model registry that does NOT touch ~/.spectral/agent/auth.json or
+        // ~/.spectral/agent/models.json — the backend is now the only source of
         // provider credentials and the only allowed inference target. We then
         // register synthetic providers (`spectral-proxy-anthropic` /
         // `spectral-proxy-openai`) whose `baseUrl` points at the backend's
@@ -560,21 +589,34 @@ export class PiBridge {
         // disk-based auth: this is the single path for `spectral serve`.
         const authStorage = AuthStorage.inMemory();
         this.modelRegistry = ModelRegistry.inMemory(authStorage);
-        const fetchModels = this.opts.fetchAllowedModels ?? defaultFetchAllowedModels;
         let allowedModels;
         try {
-            allowedModels = await fetchModels({
-                backendUrl: this.opts.backendUrl,
-                machineJwt: this.opts.machineJwt,
-            });
+            allowedModels = await this.refreshAllowedModels();
         }
         catch (err) {
             const e = err instanceof Error ? err : new Error(String(err));
             throw new Error(`Failed to fetch allowed models from backend; check SPECTRAL_BACKEND_URL ` +
                 `and machine JWT. Underlying error: ${e.message}`);
         }
-        this.allowedModels = allowedModels;
-        this.registerSyntheticProviders(allowedModels);
+        // Build an in-memory SettingsManager seeded with admin-configured
+        // defaults from the backend. findInitialModel() will pick up the
+        // isDefault model; the vision extension can query isVisionDefault.
+        const settingsOverrides = {};
+        const defaultModel = allowedModels.find((m) => m.isDefault);
+        if (defaultModel) {
+            const proxyProvider = this.proxyProviderForAllowedModel(defaultModel);
+            settingsOverrides.defaultProvider = proxyProvider;
+            settingsOverrides.defaultModel = defaultModel.modelId;
+            console.info(`✓ Default model from backend: ${proxyProvider}/${defaultModel.modelId}`);
+        }
+        const defaultVisionModel = allowedModels.find((m) => m.isVisionDefault);
+        if (defaultVisionModel) {
+            const proxyProvider = this.proxyProviderForAllowedModel(defaultVisionModel);
+            settingsOverrides.defaultVisionProvider = proxyProvider;
+            settingsOverrides.defaultVisionModel = defaultVisionModel.modelId;
+            console.info(`✓ Default vision model from backend: ${proxyProvider}/${defaultVisionModel.modelId}`);
+        }
+        const settingsManager = SettingsManager.inMemory(settingsOverrides);
         console.info(`✓ Inference routed via backend proxy (${allowedModels.length} model(s) available)`);
         const result = await createAgentSession({
             cwd: this.opts.cwd,
@@ -582,6 +624,7 @@ export class PiBridge {
             sessionManager,
             authStorage,
             modelRegistry: this.modelRegistry,
+            settingsManager,
         });
         this.session = result.session;
         // Headless UI context: forwards extension notify() calls as wire events
@@ -601,15 +644,38 @@ export class PiBridge {
         // registration.
         try {
             await this.session.bindExtensions({ uiContext });
-            console.info("[PiBridge] session_start emitted; extensions initialized.");
+            console.info("[AgentBridge] session_start emitted; extensions initialized.");
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[PiBridge] session_start failed (extension init error): ${msg}`);
+            console.warn(`[AgentBridge] session_start failed (extension init error): ${msg}`);
         }
         // Subscribe BEFORE any prompt fires.
         this.unsubscribe = this.session.subscribe((ev) => this.handleEvent(ev));
     }
+    proxyProviderForAllowedModel(model) {
+        if (model.provider === "anthropic") {
+            return SPECTRAL_PROXY_ANTHROPIC;
+        }
+        if (model.provider === "built-in") {
+            return SPECTRAL_PROXY_USER_MODEL;
+        }
+        return SPECTRAL_PROXY_OPENAI;
+    }
+    async refreshAllowedModels(opts) {
+        if (!this.modelRegistry) {
+            throw new Error("AgentBridge model registry unavailable");
+        }
+        const fetchModels = this.opts.fetchAllowedModels ?? defaultFetchAllowedModels;
+        const allowedModels = await fetchModels({
+            backendUrl: this.opts.backendUrl,
+            machineJwt: this.opts.machineJwt,
+            bypassCache: opts?.bypassCache,
+        });
+        this.allowedModels = allowedModels;
+        this.registerSyntheticProviders(allowedModels);
+        return allowedModels;
+    }
     /**
      * Register one synthetic provider per upstream API shape. Anthropic models
      * go to `${backendUrl}/v1/messages` (Messages API); everything else (OpenAI,
@@ -636,7 +702,6 @@ export class PiBridge {
                 authHeader: true,
                 api: "anthropic-messages",
                 models: anthropicModels.map((m) => {
-                    const pricing = lookupPricing(m.modelId);
                     return {
                         id: m.modelId,
                         name: m.displayName,
@@ -649,12 +714,9 @@ export class PiBridge {
                         // at our synthetic proxy provider so auth resolves to the machine JWT.
                         provider: SPECTRAL_PROXY_ANTHROPIC,
                         baseUrl,
-                        reasoning: supportsReasoning(m.modelId),
+                        reasoning: m.supportsReasoning ?? false,
                         input: m.supportsImages !== false ? ["text", "image"] : ["text"],
-                        // Real pricing so pi can compute accurate token costs.
-                        cost: pricing
-                            ? { input: pricing.input, output: pricing.output, cacheRead: pricing.cacheRead, cacheWrite: pricing.cacheWrite }
-                            : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                        cost: getModelCost(m),
                         contextWindow: m.contextWindow ?? 0,
                         maxTokens: 0,
                     };
@@ -668,7 +730,6 @@ export class PiBridge {
                 authHeader: true,
                 api: "openai-completions",
                 models: openaiCompatModels.map((m) => {
-                    const pricing = lookupPricing(m.modelId);
                     return {
                         id: m.modelId,
                         name: m.displayName,
@@ -679,14 +740,12 @@ export class PiBridge {
                         // breaking auth lookup against our synthetic proxy provider.
                         provider: SPECTRAL_PROXY_OPENAI,
                         baseUrl,
-                        reasoning: supportsReasoning(m.modelId),
+                        reasoning: m.supportsReasoning ?? false,
                         input: m.supportsImages !== false ? ["text", "image"] : ["text"],
-                        // Real pricing so pi can compute accurate token costs.
-                        cost: pricing
-                            ? { input: pricing.input, output: pricing.output, cacheRead: pricing.cacheRead, cacheWrite: pricing.cacheWrite }
-                            : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                        cost: getModelCost(m),
                         contextWindow: m.contextWindow ?? 0,
                         maxTokens: 0,
+                        compat: inferSyntheticOpenAICompat(m),
                     };
                 }),
             });
@@ -703,20 +762,18 @@ export class PiBridge {
                 authHeader: true,
                 api: "openai-completions",
                 models: userModelEntries.map((m) => {
-                    const pricing = lookupPricing(m.modelId);
                     return {
                         id: m.modelId,
                         name: m.displayName,
                         api: "openai-completions",
                         provider: SPECTRAL_PROXY_USER_MODEL,
                         baseUrl,
-                        reasoning: supportsReasoning(m.modelId),
+                        reasoning: m.supportsReasoning ?? false,
                         input: m.supportsImages !== false ? ["text", "image"] : ["text"],
-                        cost: pricing
-                            ? { input: pricing.input, output: pricing.output, cacheRead: pricing.cacheRead, cacheWrite: pricing.cacheWrite }
-                            : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                        cost: getModelCost(m),
                         contextWindow: m.contextWindow ?? 0,
                         maxTokens: 0,
+                        compat: inferSyntheticOpenAICompat(m),
                     };
                 }),
             });
@@ -794,7 +851,7 @@ export class PiBridge {
         if (!modelId)
             return true; // nothing to apply — pi keeps its current model
         if (!this.session)
-            throw new Error("PiBridge.start() not called");
+            throw new Error("AgentBridge.start() not called");
         if (this.lastAppliedModelId === modelId)
             return true; // idempotent: same model already in effect
         if (!this.modelRegistry) {
@@ -807,13 +864,26 @@ export class PiBridge {
             });
             return false;
         }
-        const model = this.modelRegistry
+        let model = this.modelRegistry
             .getAvailable()
             .find((m) => m.id === modelId);
+        let refreshError;
+        if (!model) {
+            try {
+                await this.refreshAllowedModels({ bypassCache: true });
+                model = this.modelRegistry
+                    .getAvailable()
+                    .find((m) => m.id === modelId);
+            }
+            catch (err) {
+                refreshError = err instanceof Error ? err : new Error(String(err));
+                this.opts.onError?.(refreshError);
+            }
+        }
         if (!model) {
             this.opts.emit({
                 type: "error",
-                message: `Unknown modelId "${modelId}" — not found in pi model registry`,
+                message: `Unknown modelId "${modelId}" — not found in pi model registry${refreshError ? ` after refresh: ${refreshError.message}` : ""}`,
             });
             return false;
         }
@@ -915,16 +985,14 @@ export class PiBridge {
      */
     async prompt(text, images) {
         if (!this.session)
-            throw new Error("PiBridge.start() not called");
-        // Check whether the currently active model supports image input.
-        // When `supportsImages` is null/undefined (unknown), we are conservative
-        // and convert images to text rather than risking a 400 error.
-        const currentModel = this.lastAppliedModelId
-            ? this.allowedModels?.find((m) => m.modelId === this.lastAppliedModelId)
-            : undefined;
-        const modelSupportsImages = currentModel?.supportsImages === true;
+            throw new Error("AgentBridge.start() not called");
+        // Always pass images through to the session.
+        // The spectral-vision-fallback extension intercepts images via the
+        // `context` event and replaces them with text descriptions using a
+        // vision-capable model BEFORE they reach the LLM. This means images
+        // work regardless of whether the main model supports them.
         try {
-            if (images && images.length > 0 && modelSupportsImages) {
+            if (images && images.length > 0) {
                 const imageContents = images.map((img) => ({
                     type: "image",
                     data: img.data,
@@ -932,20 +1000,6 @@ export class PiBridge {
                 }));
                 await this.session.prompt(text, { images: imageContents });
             }
-            else if (images && images.length > 0 && !modelSupportsImages) {
-                // Model doesn't support images — convert them to text descriptions
-                // so the conversation can continue instead of hanging.
-                const imageDescriptions = images
-                    .map((img, i) => `[Image ${i + 1}: ${img.mimeType}, ${img.data.length.toLocaleString()} bytes base64]`)
-                    .join("\n");
-                const augmentedText = `${text}\n\n---\nThe following image(s) were attached but the current model does not support image input:\n${imageDescriptions}\n(Describe what you see or ask the user to switch to a model that supports images.)`;
-                this.opts.emit({
-                    type: "agent_notification",
-                    message: `The current model does not support image input. ${images.length} image(s) were converted to text descriptions.`,
-                    level: "warning",
-                });
-                await this.session.prompt(augmentedText);
-            }
             else {
                 await this.session.prompt(text);
             }
@@ -967,7 +1021,7 @@ export class PiBridge {
      */
     async compact(customInstructions) {
         if (!this.session)
-            throw new Error("PiBridge.start() not called");
+            throw new Error("AgentBridge.start() not called");
         this.memoryPhase = "compacting";
         try {
             await this.session.compact(customInstructions);
@@ -1056,13 +1110,13 @@ export class PiBridge {
             e.type === "tool_call" ||
             e.type === "tool_result");
         if (!finalContent && !hasMeaningfulEvent) {
-            console.debug("[pi-bridge] skipping empty intermediate message");
+            console.debug("[agent-bridge] skipping empty intermediate message");
             try {
                 this.opts.onAssistantMessageSkipped?.(messageId);
             }
             catch (err) {
                 const e = err instanceof Error ? err : new Error(String(err));
-                console.error(`[pi-bridge] onAssistantMessageSkipped failed: ${e.message}`);
+                console.error(`[agent-bridge] onAssistantMessageSkipped failed: ${e.message}`);
             }
             return;
         }
@@ -1177,6 +1231,8 @@ export class PiBridge {
                         const done = details.results.filter(r => r.exitCode !== undefined && r.exitCode !== -1).length;
                         const running = total - done;
                         const currentAgent = details.results.find(r => r.exitCode === -1 || r.exitCode === undefined)?.agent;
+                        // Extract streaming text from partialResult content (set by text_delta forwarding).
+                        const streamingText = extractTextFromContent(partialResult?.content);
                         const se = {
                             type: "subagent_progress",
                             toolCallId: ev.toolCallId,
@@ -1190,6 +1246,7 @@ export class PiBridge {
                                 : mode === "chain"
                                     ? `Chain: step ${details.results.length}/${total}`
                                     : `Running ${currentAgent ?? "subagent"}...`,
+                            streamingText: mode === "single" ? streamingText : undefined,
                         };
                         try {
                             this.opts.emit(se);
@@ -1387,6 +1444,15 @@ function detectMemorySystem(message) {
     // Keep generic observational-memory messages visible in the landing badge.
     return "memory_observer";
 }
+/**
+ * Detect subsystem from notification messages by known prefix.
+ * Returns undefined for generic extension messages without a matching prefix.
+ */
+function detectNotifSystem(message) {
+    if (message.startsWith("[spectral-vision]"))
+        return "vision";
+    return detectMemorySystem(message);
+}
 /**
  * Create a minimal ExtensionUIContext that forwards `notify()` calls as
  * `agent_notification` wire events. All other UI methods are no-ops —
@@ -1397,15 +1463,18 @@ function detectMemorySystem(message) {
 function createHeadlessUIContext(emit) {
     // Defer to a Proxy so we don't need to stub every method.
     // `notify` is the only method called by extensions in serve mode
-    // (observational memory, MCP status bar updates).
+    // (observational memory, MCP status bar updates, spectral-vision).
     const handler = {
         get(_target, prop) {
             if (prop === "notify") {
                 return (message, type) => {
                     const level = type ?? "info";
-                    const system = detectMemorySystem(message);
+                    const system = detectNotifSystem(message);
                     if (system?.startsWith("memory_")) {
-                        console.info(`[PiBridge][memory][${level}] ${message}`);
+                        console.info(`[AgentBridge][memory][${level}] ${message}`);
+                    }
+                    else if (system === "vision") {
+                        console.info(`[AgentBridge][vision][${level}] ${message}`);
                     }
                     emit({
                         type: "agent_notification",

package/dist/server/handlers/sessions.js

@@ -65,6 +65,27 @@ export async function handleCompactSession(store, manager, id) {
     }
     return { ok: true };
 }
+/**
+ * Remember & delete: compact the session (which persists observations as
+ * project memory via the compaction hook), then delete the session.
+ *
+ * This gives the user a way to keep a session's reflections as durable
+ * cross-session memory even for short sessions that never hit the compaction
+ * threshold naturally.
+ */
+export async function handleRememberAndDeleteSession(store, manager, id) {
+    const detail = store.getSession(id);
+    if (!detail)
+        throw new NotFoundError("Session not found");
+    try {
+        await manager.compactSession(id);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new BadRequestError(message);
+    }
+    return { ok: true };
+}
 /**
  * Fork a session: create a new session copying all messages from the
  * source, with the `fork_compact_source_id` flag set so the

package/dist/server/session-stream.js

@@ -1,7 +1,7 @@
 /**
  * Session-scoped streaming layer for `spectral serve`.
  *
- * Background: prior to this module each WebSocket owned its own `PiBridge`
+ * Background: prior to this module each WebSocket owned its own `AgentBridge`
  * instance and the routes layer enforced single-writer-wins (4001 eviction)
  * to keep that bridge unique per session. That model lost data on browser
  * refresh — the WS close torn down the pi process mid-stream, and a re-open
@@ -37,14 +37,14 @@
  *   for now — streams accumulate for the lifetime of the server process.
  */
 import { randomUUID } from "node:crypto";
-import { PiBridge } from "./pi-bridge.js";
+import { AgentBridge } from "./agent-bridge.js";
 import { getMemoryState, isSourceEntry, rawTokensSinceLastBound, rawTokensSinceLastCompaction, } from "../memory/branch.js";
 import { observationPoolTokens, renderSummary } from "../memory/compaction.js";
 import { loadConfig } from "../memory/config.js";
 import { setProjectObsStore } from "../memory/project-observations-store.js";
 import { estimateStringTokens } from "../memory/tokens.js";
 import { reflectionContent, reflectionId } from "../memory/types.js";
-const DEFAULT_BRIDGE_FACTORY = (args) => new PiBridge(args);
+const DEFAULT_BRIDGE_FACTORY = (args) => new AgentBridge(args);
 /** Safety limit for autonomous loop iterations per session. */
 const MAX_LOOP_ITERATIONS = 100;
 /**
@@ -646,7 +646,7 @@ export class SessionStreamManager {
             assistantText: "",
         };
         // 4. Fire pi. `prompt` resolves on agent_end; errors are handled inside
-        //    PiBridge (it emits `error` for us). We don't await — broadcast is
+        //    AgentBridge (it emits `error` for us). We don't await — broadcast is
         //    driven by the bridge's emit callback.
         void stream.bridge.prompt(content, images);
     }
@@ -1127,7 +1127,7 @@ export class SessionStreamManager {
         }
         // Broadcast first, then maybe close out the turn. agent_end clears the
         // buffer because by that point the assistant message is already in
-        // SQLite (PiBridge calls onAssistantMessageComplete on message_end,
+        // SQLite (AgentBridge calls onAssistantMessageComplete on message_end,
         // which fires before agent_end).
         //
         // Track context window state from token_usage events — the bridge emits
@@ -1173,6 +1173,10 @@ export class SessionStreamManager {
                 prunePersistedHistoryAfterCompaction(this.store, stream.sessionId, stream.bridge);
             }
             persistObservationalMemorySnapshot(this.store, stream.sessionId, stream.bridge);
+            // Drain the prompt queue after compaction finishes. During
+            // compaction, auto-dequeue in agent_end is skipped to prevent the
+            // lossy prompt() guard from dropping queued items.
+            this.maybeAutoDequeue(stream);
             // After compaction the session context has been reduced; push updated
             // context-window stats to all subscribers so the frontend's context
             // bar refreshes immediately instead of waiting for the next turn.
@@ -1287,8 +1291,10 @@ export class SessionStreamManager {
             // pending, check the persistent prompt queue. If there's a queued
             // prompt, start it immediately without broadcasting agent_end —
             // the frontend transitions seamlessly to the next turn.
+            // Skip if compaction is in-flight (e.g. fork-compact just started
+            // above) — compaction_end will drain the queue when it finishes.
             if (!stream.loopActive || !stream.loopOriginalPrompt) {
-                if (this.maybeAutoDequeue(stream))
+                if (!stream.compacting && this.maybeAutoDequeue(stream))
                     return;
             }
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aexol/spectral",
-  "version": "0.7.7",
-  "description": "Always-on coding agent for Aexol — branded pi wrapper with relay-based browser access.",
+  "version": "0.8.0",
+  "description": "AI coding agent for Aexol with relay-based browser access.",
   "type": "module",
   "private": false,
   "bin": {
@@ -30,7 +30,6 @@
     "coding-agent",
     "ai",
     "cli",
-    "pi",
     "claude",
     "openai",
     "agent",
@@ -46,6 +45,10 @@
     "url": "https://gitlab.aexol.com/aexol/spectral/-/issues"
   },
   "license": "MIT",
+  "spectralConfig": {
+    "name": "spectral",
+    "configDir": ".spectral"
+  },
   "publishConfig": {
     "access": "public"
   },