@aexol/spectral 0.7.3 → 0.7.6

package/dist/relay/dispatcher.js

@@ -42,6 +42,7 @@ import { BadRequestError, NotFoundError } from "../server/handlers/errors.js";
 import { handlePathAutocomplete } from "../server/handlers/paths-autocomplete.js";
 import { handleBindStudioProject, handleCreateProject, handleDeleteProject, handleListProjects, handleListSessionsByProject, handleUpdateProject, } from "../server/handlers/projects.js";
 import { handleCompactSession, handleCreateSession, handleDeleteSession, handleForkSession, handleGetSessionDetail, handleGetSessionMemoryDetails, handleGetSessionMemoryStatus, handleUpdateSession, } from "../server/handlers/sessions.js";
+import { handleClearPromptQueue, handleEnqueuePrompt, handleGetPromptQueue, handleRemovePrompt, } from "../server/handlers/queue.js";
 import { shutdownState } from "../server/shutdown.js";
 import { handleAutoResearch } from "./auto-research.js";
 /**
@@ -133,6 +134,25 @@ export function matchRoute(method, path) {
             return { route: "fork_session", id };
         return null;
     }
+    // /api/sessions/:id/queue  and  /api/sessions/:id/queue/:itemId
+    const queueMatch = /^\/api\/sessions\/([^/]+)\/queue(\/([^/]+))?$/.exec(cleanPath);
+    if (queueMatch) {
+        const id = decodeURIComponent(queueMatch[1]);
+        const itemId = queueMatch[3] ? decodeURIComponent(queueMatch[3]) : undefined;
+        if (!itemId) {
+            if (method === "GET")
+                return { route: "get_prompt_queue", id };
+            if (method === "POST")
+                return { route: "enqueue_prompt", id };
+            if (method === "DELETE")
+                return { route: "clear_prompt_queue", id };
+        }
+        else {
+            if (method === "DELETE")
+                return { route: "remove_prompt", id, itemId };
+        }
+        return null;
+    }
     return null;
 }
 /**
@@ -334,6 +354,16 @@ async function dispatchRoute(match, body, deps) {
             const prefix = match.query?.get("prefix") ?? "";
             return handlePathAutocomplete(prefix);
         }
+        case "enqueue_prompt":
+            return handleEnqueuePrompt(store, manager, id, asObject(body));
+        case "get_prompt_queue":
+            return handleGetPromptQueue(store, id);
+        case "remove_prompt":
+            handleRemovePrompt(store, manager, id, match.itemId ?? "");
+            return { ok: true };
+        case "clear_prompt_queue":
+            handleClearPromptQueue(store, manager, id);
+            return { ok: true };
     }
 }
 /**
@@ -442,7 +472,7 @@ function makeRelaySubscriber(sessionId, relay) {
  *    an `error` event to subscribers, so we don't double-report.
  */
 export function handleClientMessage(frame, deps) {
-    const { sessionId, message, modelId } = frame;
+    const { sessionId, message, modelId, reasoningEffort } = frame;
     const { manager, relay, subscribers } = deps;
     const logger = deps.logger ?? console;
     // 0. Shutdown gate. Once `gracefulShutdown` flips the flag we refuse
@@ -553,7 +583,7 @@ export function handleClientMessage(frame, deps) {
     //
     //    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) => {
+    manager.prompt(sessionId, content, modelId, validImages, reasoningEffort).catch((err) => {
         logger.error?.(`[dispatcher] manager.prompt failed for ${sessionId}:`, err);
     });
 }

package/dist/server/handlers/queue.js

@@ -0,0 +1,52 @@
+/**
+ * Pure REST handlers for `/api/sessions/:sessionId/queue/*`.
+ *
+ * Same contract as sessions/projects handlers — pure functions that take
+ * `store` + `manager` dependencies, throw `BadRequestError`/`NotFoundError`
+ * on invalid input, and return typed responses.
+ *
+ * After mutating the queue, each handler calls `manager.pushQueueState()`
+ * to broadcast the updated queue to all subscribers via `queue_changed`.
+ */
+import { BadRequestError, NotFoundError } from "./errors.js";
+export function handleEnqueuePrompt(store, manager, sessionId, body) {
+    if (typeof body.content !== "string" || !body.content.trim()) {
+        throw new BadRequestError("content (non-empty string) is required");
+    }
+    const session = store.getSession(sessionId);
+    if (!session)
+        throw new NotFoundError("Session not found");
+    const row = store.enqueuePrompt(sessionId, body.content);
+    manager.pushQueueState(sessionId);
+    return {
+        id: row.id,
+        content: row.content,
+        position: row.position,
+        createdAt: row.created_at,
+    };
+}
+export function handleGetPromptQueue(store, sessionId) {
+    const session = store.getSession(sessionId);
+    if (!session)
+        throw new NotFoundError("Session not found");
+    return store.getPromptQueue(sessionId).map((r) => ({
+        id: r.id,
+        content: r.content,
+        position: r.position,
+        createdAt: r.created_at,
+    }));
+}
+export function handleRemovePrompt(store, manager, sessionId, itemId) {
+    const session = store.getSession(sessionId);
+    if (!session)
+        throw new NotFoundError("Session not found");
+    store.removePrompt(sessionId, itemId);
+    manager.pushQueueState(sessionId);
+}
+export function handleClearPromptQueue(store, manager, sessionId) {
+    const session = store.getSession(sessionId);
+    if (!session)
+        throw new NotFoundError("Session not found");
+    store.clearPromptQueue(sessionId);
+    manager.pushQueueState(sessionId);
+}

package/dist/server/pi-bridge.js

@@ -750,6 +750,14 @@ export class PiBridge {
     getFirstAvailableModelId() {
         return this.allowedModels?.[0]?.modelId;
     }
+    /**
+     * Return current session context usage from pi's built-in estimator.
+     * Used after compaction and session start to push updated context-window
+     * stats to the frontend without waiting for the next assistant turn.
+     */
+    getContextUsage() {
+        return this.session?.getContextUsage();
+    }
     getSessionBranch() {
         return (this.sessionManager?.getBranch() ?? []);
     }
@@ -834,6 +842,65 @@ export class PiBridge {
             return false;
         }
     }
+    /**
+     * Map a frontend reasoning-effort string to pi's ThinkingLevel.
+     * Frontend sends: xhigh | high | medium | low | minimal | none | undefined
+     * Pi expects:   "high" | "medium" | "low" | "minimal" | "off"
+     *
+     * Mapping:
+     *   xhigh   → high    (pi doesn't have xhigh, default to max)
+     *   high    → high
+     *   medium  → medium
+     *   low     → low
+     *   minimal → minimal
+     *   none    → off
+     *   undefined → no-op (pi keeps whatever it has currently)
+     */
+    mapReasoningEffortToThinkingLevel(effort) {
+        if (effort === undefined)
+            return undefined;
+        switch (effort) {
+            case "xhigh":
+                return "high";
+            case "high":
+            case "medium":
+            case "low":
+            case "minimal":
+                return effort;
+            case "none":
+                return "off";
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Set the reasoning/thinking effort level for the next prompt.
+     * Pass `undefined` to leave pi's current level unchanged.
+     *
+     * The caller (SessionStreamManager) is responsible for persisting the
+     * value to SQLite; this method only applies it to pi's in-memory session.
+     */
+    setReasoningEffort(effort) {
+        const level = this.mapReasoningEffortToThinkingLevel(effort);
+        if (level === undefined)
+            return;
+        if (!this.session) {
+            // Bridge hasn't started yet — the reasoning effort will be picked
+            // up from storage on the next prompt via session-stream's persistence.
+            return;
+        }
+        try {
+            this.session.setThinkingLevel(level);
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            this.opts.onError?.(e);
+            this.opts.emit({
+                type: "error",
+                message: `Failed to set reasoning effort: ${e.message}`,
+            });
+        }
+    }
     /**
      * Forward a user message to pi. Resolves when the full turn ends.
      * The caller is responsible for persisting the user message to SQLite

package/dist/server/session-stream.js

@@ -483,7 +483,7 @@ export class SessionStreamManager {
      *   - When neither envelope nor SQLite have a value, we leave model
      *     selection to pi's own settings file (pre-Phase-3 behaviour).
      */
-    async prompt(sessionId, content, modelId, images) {
+    async prompt(sessionId, content, modelId, images, reasoningEffort) {
         if (this.disposed)
             throw new Error("SessionStreamManager disposed");
         let stream = this.streams.get(sessionId);
@@ -599,6 +599,24 @@ export class SessionStreamManager {
                 console.warn(`[spectral] warn: failed to persist sticky model for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
+        // Sticky reasoning-effort resolution. Same order as modelId:
+        //   a) Envelope-supplied value → apply + persist.
+        //   b) Otherwise, look up the persisted value from SQLite.
+        //   c) When neither is present, leave pi's current thinking level unchanged.
+        // We apply BEFORE persisting the user message so the turn runs with the
+        // correct reasoning level.
+        const effectiveReasoningEffort = reasoningEffort ?? this.store.getSessionReasoningEffort(sessionId) ?? undefined;
+        if (effectiveReasoningEffort && stream.bridge.setReasoningEffort) {
+            stream.bridge.setReasoningEffort(effectiveReasoningEffort);
+        }
+        if (reasoningEffort !== undefined) {
+            try {
+                this.store.setSessionReasoningEffort(sessionId, reasoningEffort || null);
+            }
+            catch (err) {
+                console.warn(`[spectral] warn: failed to persist reasoning effort for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
         // 1. Persist user message first (survives mid-prompt failures).
         let stored;
         try {
@@ -1155,6 +1173,29 @@ export class SessionStreamManager {
                 prunePersistedHistoryAfterCompaction(this.store, stream.sessionId, stream.bridge);
             }
             persistObservationalMemorySnapshot(this.store, stream.sessionId, stream.bridge);
+            // 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.
+            const ctx = stream.bridge.getContextUsage?.();
+            if (ctx) {
+                stream.contextWindowUsed = ctx.tokens;
+                stream.contextWindowMax = ctx.contextWindow;
+                this.broadcast(stream, {
+                    type: "token_usage",
+                    messageId: "",
+                    usage: {
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        cacheReadTokens: 0,
+                        cacheWriteTokens: 0,
+                        totalTokens: 0,
+                        cost: null,
+                        creditsUsed: 0,
+                    },
+                    contextWindowUsed: ctx.tokens,
+                    contextWindowMax: ctx.contextWindow,
+                });
+            }
             const tokensMsg = typeof event.tokensBefore === "number"
                 ? ` (from ~${event.tokensBefore.toLocaleString()} tokens)`
                 : "";
@@ -1242,6 +1283,14 @@ export class SessionStreamManager {
                 stream.forkCompactSourceId = null; // one-shot
                 this.triggerForkCompact(stream);
             }
+            // Auto-dequeue: after the turn finishes and no loop iteration is
+            // 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.
+            if (!stream.loopActive || !stream.loopOriginalPrompt) {
+                if (this.maybeAutoDequeue(stream))
+                    return;
+            }
         }
         else if (event.type === "error") {
             // An error event arriving outside a turn (or bubbling out of one) —
@@ -1307,6 +1356,43 @@ export class SessionStreamManager {
         for (const sub of dead)
             stream.subscribers.delete(sub);
     }
+    /**
+     * Push the current prompt queue state to all subscribers of a session.
+     * Called after every queue mutation (enqueue, remove, clear, dequeue).
+     * Safe to call when no stream exists or no subscribers — silently no-ops.
+     */
+    pushQueueState(sessionId) {
+        const stream = this.streams.get(sessionId);
+        if (!stream || stream.subscribers.size === 0)
+            return;
+        const rows = this.store.getPromptQueue(sessionId);
+        this.broadcast(stream, {
+            type: "queue_changed",
+            queue: rows.map((r) => ({
+                id: r.id,
+                content: r.content,
+                position: r.position,
+                createdAt: r.created_at,
+            })),
+        });
+    }
+    /**
+     * Auto-dequeue the next prompt from the persistent queue and start a
+     * new turn. Called from the `agent_end` handler when no loop is active.
+     * Returns true if a prompt was dequeued and a turn started.
+     */
+    maybeAutoDequeue(stream) {
+        const next = this.store.dequeuePrompt(stream.sessionId);
+        if (!next)
+            return false;
+        // Push updated queue state so the frontend sees the item was removed.
+        this.pushQueueState(stream.sessionId);
+        // Fire the next prompt. Reuses the sticky model from the just-completed
+        // turn (persisted by `prompt()` into the sessions.model_id column).
+        const lastModelId = this.store.getSessionModel(stream.sessionId);
+        void this.prompt(stream.sessionId, next.content, lastModelId ?? undefined);
+        return true;
+    }
 }
 function isReplayable(event) {
     return (event.type === "message_start" ||

package/dist/server/storage.js

@@ -32,11 +32,12 @@ import { dirname, join } from "node:path";
 import { getConfigDir } from "../config.js";
 import { stripJsoncComments } from "../studio-binding.js";
 /**
- * Schema version. Bump + the on-open migration drops & recreates every table.
- * Since this is local-only conversation history pre-1.0, we explicitly do not
- * preserve user data across schema changes.
+ * Schema version — informational, stamped into every new database.
+ *
+ * ALL schema changes are additive (ALTER TABLE ADD COLUMN).  The version is
+ * never used to trigger destructive drops; it is purely for troubleshooting.
  */
-const SCHEMA_VERSION = 3;
+const SCHEMA_VERSION = 4;
 const SCHEMA_SQL = `
 PRAGMA foreign_keys = ON;
 
@@ -54,7 +55,8 @@ CREATE TABLE IF NOT EXISTS sessions (
   title TEXT NOT NULL,
   created_at INTEGER NOT NULL,
   updated_at INTEGER NOT NULL,
-  model_id TEXT
+  model_id TEXT,
+  reasoning_effort TEXT
 );
 
 CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id, updated_at DESC);
@@ -89,6 +91,17 @@ CREATE TABLE IF NOT EXISTS project_observations (
 );
 
 CREATE INDEX IF NOT EXISTS idx_project_obs_project ON project_observations(project_id, created_at DESC);
+
+CREATE TABLE IF NOT EXISTS prompt_queue (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  content TEXT NOT NULL,
+  position INTEGER NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(session_id, position)
+);
+
+CREATE INDEX IF NOT EXISTS idx_prompt_queue_session ON prompt_queue(session_id, position);
 `;
 /**
  * Synchronous binding-file reader for a project at the given filesystem path.
@@ -119,7 +132,6 @@ function applyBindingFields(project) {
     };
 }
 /** Tables we own — used by the migration drop step. */
-const KNOWN_TABLES = ["project_observations", "session_memory_snapshots", "messages", "sessions", "projects"];
 /** Best-effort parse of the `images_json` column into `ImageAttachment[]`. */
 function parseImagesJson(raw) {
     if (!raw || raw === "")
@@ -177,6 +189,8 @@ export class SessionStore {
     // Phase 3: per-session sticky model.
     stmtGetSessionModel;
     stmtSetSessionModel;
+    stmtGetSessionReasoningEffort;
+    stmtSetSessionReasoningEffort;
     // Fork & Compact: flag + per-session source tracking.
     stmtSetForkCompactSource;
     stmtGetForkCompactSource;
@@ -184,6 +198,13 @@ export class SessionStore {
     stmtInsertProjectObs;
     stmtSearchProjectObs;
     stmtGetProjectByCwd;
+    // Prompt queue statements
+    stmtEnqueuePrompt;
+    stmtGetPromptQueue;
+    stmtDequeuePrompt;
+    stmtDeleteQueueItem;
+    stmtClearSessionQueue;
+    stmtShiftPositions;
     constructor(path) {
         this.path = path;
         // Make sure the parent directory exists. mkdirSync with recursive is a
@@ -192,28 +213,17 @@ export class SessionStore {
         this.db = new Database(path);
         this.db.pragma("journal_mode = WAL");
         this.db.pragma("foreign_keys = ON");
-        // ---- migration --------------------------------------------------------
-        // Detect schema version and drop+recreate on mismatch. Pre-1.0: no data
-        // preservation. The first open on a brand-new file reports version 0
-        // and falls through to the create path below (drops are no-ops on
-        // missing tables).
-        const versionRow = this.db.pragma("user_version", { simple: true });
-        if (versionRow !== SCHEMA_VERSION) {
-            // Disable FKs for the duration of the drop so order doesn't matter
-            // (we drop children first regardless, but this keeps it bullet-proof
-            // if KNOWN_TABLES order is ever reshuffled).
-            this.db.pragma("foreign_keys = OFF");
-            const tx = this.db.transaction(() => {
-                for (const t of KNOWN_TABLES) {
-                    this.db.exec(`DROP TABLE IF EXISTS ${t}`);
-                }
-            });
-            tx();
-            this.db.pragma("foreign_keys = ON");
-        }
+        // ---- schema creation -------------------------------------------------
+        // SCHEMA_SQL uses CREATE TABLE IF NOT EXISTS for every table, so it is
+        // always safe to run — on a fresh database all tables are created;
+        // on an existing one every statement is a no-op.  Schema changes that
+        // add columns are handled by the additive migration block below.
+        //
+        // We NO LONGER drop tables when the stored user_version differs from
+        // SCHEMA_VERSION.  The previous destructive behaviour caused permanent
+        // data loss on version bumps.  SCHEMA_VERSION is now informational — it
+        // is stamped into every new database purely for troubleshooting.
         this.db.exec(SCHEMA_SQL);
-        // Stamp the version AFTER schema creation so a crash mid-create is
-        // detected next open and re-runs the (idempotent) create.
         this.db.pragma(`user_version = ${SCHEMA_VERSION}`);
         // ---- additive column migration ---------------------------------------
         // Phase 3 (Available Models): per-session sticky model selection lives in
@@ -230,6 +240,9 @@ export class SessionStore {
         if (!sessionCols.some((c) => c.name === "model_id")) {
             this.db.exec(`ALTER TABLE sessions ADD COLUMN model_id TEXT`);
         }
+        if (!sessionCols.some((c) => c.name === "reasoning_effort")) {
+            this.db.exec(`ALTER TABLE sessions ADD COLUMN reasoning_effort TEXT`);
+        }
         // Additive migration: images_json column for base64 image attachments on
         // user messages. Older rows default to '' (no images).
         const msgCols = this.db
@@ -320,6 +333,8 @@ export class SessionStore {
         this.stmtDeleteSessionMemorySnapshot = this.db.prepare(`DELETE FROM session_memory_snapshots WHERE session_id = ?`);
         this.stmtGetSessionModel = this.db.prepare(`SELECT model_id FROM sessions WHERE id = ?`);
         this.stmtSetSessionModel = this.db.prepare(`UPDATE sessions SET model_id = ? WHERE id = ?`);
+        this.stmtGetSessionReasoningEffort = this.db.prepare(`SELECT reasoning_effort FROM sessions WHERE id = ?`);
+        this.stmtSetSessionReasoningEffort = this.db.prepare(`UPDATE sessions SET reasoning_effort = ? WHERE id = ?`);
         this.stmtSetForkCompactSource = this.db.prepare(`UPDATE sessions SET fork_compact_source_id = ? WHERE id = ?`);
         this.stmtGetForkCompactSource = this.db.prepare(`SELECT fork_compact_source_id FROM sessions WHERE id = ?`);
         this.stmtInsertProjectObs = this.db.prepare(`INSERT OR REPLACE INTO project_observations (id, project_id, session_id, content, relevance, created_at)
@@ -330,6 +345,19 @@ export class SessionStore {
        ORDER BY created_at DESC
        LIMIT 20`);
         this.stmtGetProjectByCwd = this.db.prepare(`SELECT id FROM projects WHERE path = ? LIMIT 1`);
+        // ---- prompt queue statements ----------------------------------------
+        this.stmtEnqueuePrompt = this.db.prepare(`INSERT INTO prompt_queue (id, session_id, content, position, created_at)
+       VALUES (?, ?, ?, ?, ?)`);
+        this.stmtGetPromptQueue = this.db.prepare(`SELECT id, session_id, content, position, created_at
+       FROM prompt_queue WHERE session_id = ?
+       ORDER BY position ASC`);
+        this.stmtDequeuePrompt = this.db.prepare(`SELECT id, session_id, content, position, created_at
+       FROM prompt_queue WHERE session_id = ?
+       ORDER BY position ASC LIMIT 1`);
+        this.stmtDeleteQueueItem = this.db.prepare(`DELETE FROM prompt_queue WHERE id = ? AND session_id = ?`);
+        this.stmtClearSessionQueue = this.db.prepare(`DELETE FROM prompt_queue WHERE session_id = ?`);
+        this.stmtShiftPositions = this.db.prepare(`UPDATE prompt_queue SET position = position + ?
+       WHERE session_id = ? AND position >= ?`);
     }
     /** Smoke check: returns the names of the tables in the DB. */
     listTables() {
@@ -614,6 +642,23 @@ export class SessionStore {
     setSessionModel(sessionId, modelId) {
         this.stmtSetSessionModel.run(modelId, sessionId);
     }
+    /**
+     * Get the persisted reasoningEffort for a session, or null if none
+     * was ever set. Returns null for unknown sessions (consistent with
+     * getSessionModel's contract).
+     */
+    getSessionReasoningEffort(sessionId) {
+        const row = this.stmtGetSessionReasoningEffort.get(sessionId);
+        return row?.reasoning_effort ?? null;
+    }
+    /**
+     * Persist the reasoningEffort for a session. Pass `null` to clear.
+     * Same semantics as setSessionModel — best-effort metadata, does
+     * not bump `updated_at`.
+     */
+    setSessionReasoningEffort(sessionId, effort) {
+        this.stmtSetSessionReasoningEffort.run(effort, sessionId);
+    }
     // ----------------------------------------------------------------------
     // Fork & Compact
     // ----------------------------------------------------------------------
@@ -714,6 +759,66 @@ export class SessionStore {
         const row = this.stmtGetProjectByCwd.get(cwd);
         return row?.id ?? null;
     }
+    // ----------------------------------------------------------------------
+    // Prompt Queue
+    // ----------------------------------------------------------------------
+    /**
+     * Enqueue a prompt for a session. Returns the created queue item.
+     * Position is auto-assigned as (max existing position + 1).
+     */
+    enqueuePrompt(sessionId, content) {
+        const id = randomUUID();
+        const items = this.stmtGetPromptQueue.all(sessionId);
+        const nextPosition = items.length > 0
+            ? Math.max(...items.map((r) => r.position)) + 1
+            : 0;
+        const createdAt = new Date().toISOString();
+        this.stmtEnqueuePrompt.run(id, sessionId, content, nextPosition, createdAt);
+        return { id, session_id: sessionId, content, position: nextPosition, created_at: createdAt };
+    }
+    /**
+     * Dequeue (remove and return) the first prompt for a session.
+     * Returns null if the queue is empty.
+     * Renumbers remaining items so positions stay contiguous from 0.
+     */
+    dequeuePrompt(sessionId) {
+        const row = this.stmtDequeuePrompt.get(sessionId);
+        if (!row)
+            return null;
+        const tx = this.db.transaction(() => {
+            this.stmtDeleteQueueItem.run(row.id, sessionId);
+            // Shift remaining positions down by 1
+            this.stmtShiftPositions.run(sessionId, -1, row.position);
+        });
+        tx();
+        return row;
+    }
+    /**
+     * Get the full prompt queue for a session, ordered by position.
+     */
+    getPromptQueue(sessionId) {
+        return this.stmtGetPromptQueue.all(sessionId);
+    }
+    /**
+     * Remove a specific prompt from the queue by id.
+     * Renumbers remaining items so positions stay contiguous.
+     */
+    removePrompt(sessionId, itemId) {
+        const row = this.stmtGetPromptQueue.all(sessionId).find((r) => r.id === itemId);
+        if (!row)
+            return;
+        const tx = this.db.transaction(() => {
+            this.stmtDeleteQueueItem.run(itemId, sessionId);
+            this.stmtShiftPositions.run(sessionId, -1, row.position);
+        });
+        tx();
+    }
+    /**
+     * Clear the entire prompt queue for a session.
+     */
+    clearPromptQueue(sessionId) {
+        this.stmtClearSessionQueue.run(sessionId);
+    }
     close() {
         if (this.closed)
             return;

package/package.json

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