@aexol/spectral 0.7.1 → 0.7.5

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 };
     }
 }
 /**

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

@@ -49,7 +49,7 @@
  *  instance is reused across `prompt()` calls).
  */
 import { createJiti } from "@mariozechner/jiti";
-import { AuthStorage, createAgentSession, DefaultResourceLoader, ModelRegistry, SessionManager, } from "@mariozechner/pi-coding-agent";
+import { AuthStorage, createAgentSession, DefaultResourceLoader, ModelRegistry, SessionManager, } from "../pi/coding-agent/index.js";
 import { randomUUID } from "node:crypto";
 import { existsSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
@@ -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() ?? []);
     }

package/dist/server/session-stream.js

@@ -41,9 +41,9 @@ import { PiBridge } from "./pi-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";
-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;
@@ -233,17 +233,7 @@ export class SessionStreamManager {
     machineJwt;
     bridgeFactory;
     agentDir;
-    titleLlmCall;
-    disableAutoTitle;
-    publishMetaEvent;
     streams = new Map();
-    /**
-     * Sessions for which we've already attempted (or queued) auto-title
-     * generation in this server process. Per-process is intentional: a server
-     * restart resets the set, but `isDefaultTitle()` still gates the work so a
-     * since-renamed session is never overwritten.
-     */
-    titleGenerationAttempted = new Set();
     disposed = false;
     constructor(opts) {
         this.store = opts.store;
@@ -252,9 +242,13 @@ export class SessionStreamManager {
         this.machineJwt = opts.machineJwt;
         this.bridgeFactory = opts.bridgeFactory ?? DEFAULT_BRIDGE_FACTORY;
         this.agentDir = opts.agentDir;
-        this.titleLlmCall = opts.titleLlmCall;
-        this.disableAutoTitle = opts.disableAutoTitle === true;
-        this.publishMetaEvent = opts.publishMetaEvent;
+        // Wire the project observations store singleton so the memory extension's
+        // read_project_observations tool can query cross-session observations.
+        setProjectObsStore({
+            insertProjectObservations: (pid, sid, obs, ts) => this.store.insertProjectObservations(pid, sid, obs, ts),
+            searchProjectObservations: (pid, q, limit) => this.store.searchProjectObservations(pid, q, limit),
+            getProjectByCwd: (cwd) => this.store.getProjectByCwd(cwd),
+        });
     }
     /**
      * Attach a subscriber to a session. Lazily creates the underlying pi
@@ -1161,6 +1155,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)`
                 : "";
@@ -1192,11 +1209,6 @@ export class SessionStreamManager {
             stream.lastFlushedEventCount = 0;
             const finishedTurn = stream.currentTurn;
             stream.currentTurn = null;
-            // Fire-and-forget auto-title generation. Runs only once per session
-            // per server lifetime, only when the session is still wearing its
-            // 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 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
@@ -1253,6 +1265,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) —
@@ -1300,98 +1320,6 @@ export class SessionStreamManager {
             console.error(`[spectral] error: batch-persist flush failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    /**
-     * Auto-title the session if it's still wearing the default title and we
-     * haven't already attempted generation in this process. Fire-and-forget
-     * (errors are caught, logged, and swallowed) — the user's stream finished
-     * before this runs, so blocking would only delay the broadcast.
-     */
-    maybeGenerateTitle(stream, finishedTurn) {
-        if (this.disableAutoTitle)
-            return;
-        if (this.titleGenerationAttempted.has(stream.sessionId))
-            return;
-        // Check the persisted title now (manual rename takes precedence).
-        const detail = this.store.getSession(stream.sessionId);
-        if (!detail || !isDefaultTitle(detail.title))
-            return;
-        // Find the first user message + the assistant text from the just-finished
-        // turn. We deliberately read user content from SQLite (authoritative)
-        // and assistant content from the in-memory turn buffer (cheap, and
-        // matches what the user just saw).
-        const firstUser = detail.messages.find((m) => m.role === "user");
-        if (!firstUser || !firstUser.content.trim())
-            return;
-        let assistantText = finishedTurn?.assistantText ?? "";
-        if (!assistantText) {
-            // Fallback: pull the most recent assistant message from SQLite. This
-            // can happen if `agent_end` fires for a turn whose buffer was cleared
-            // by an intervening error event, or when this code path is reached
-            // via a synthetic test event.
-            const lastAssistant = [...detail.messages]
-                .reverse()
-                .find((m) => m.role === "assistant");
-            assistantText = lastAssistant?.content ?? "";
-        }
-        // Mark BEFORE awaiting so a second `agent_end` arriving while we're
-        // generating doesn't double-fire. Even if generation throws, we leave
-        // the entry in place — one-shot semantics, no retries.
-        this.titleGenerationAttempted.add(stream.sessionId);
-        void this.runTitleGeneration(stream, firstUser.content, assistantText);
-    }
-    async runTitleGeneration(stream, firstUserMessage, firstAssistantMessage) {
-        try {
-            const title = await generateSessionTitle(firstUserMessage, firstAssistantMessage, {
-                cwd: stream.cwd,
-                agentDir: this.agentDir,
-                llmCall: this.titleLlmCall,
-            });
-            if (this.disposed)
-                return;
-            if (!title)
-                return;
-            // Re-check the title hasn't been changed underneath us while we were
-            // waiting on the LLM (e.g. user manually renamed mid-generation).
-            const current = this.store.getSession(stream.sessionId);
-            if (!current || !isDefaultTitle(current.title))
-                return;
-            const updated = this.store.renameSession(stream.sessionId, title);
-            if (!updated)
-                return;
-            // Broadcast to every subscriber of this session so all open tabs
-            // update their sidebar in real time. The wire event is independent
-            // of the in-flight turn lifecycle, so it's safe to fire post-agent_end.
-            this.broadcast(stream, {
-                type: "session_renamed",
-                sessionId: stream.sessionId,
-                title: updated.title,
-            });
-            // Cross-tab fan-out hint: tabs that don't have THIS session open
-            // (and so don't have a per-session ws subscription) still want to
-            // refresh their sidebar to show the new title. Best-effort; a
-            // failed publish never undoes the rename.
-            if (this.publishMetaEvent) {
-                try {
-                    this.publishMetaEvent({
-                        type: "session_renamed",
-                        projectId: updated.projectId,
-                        sessionId: stream.sessionId,
-                    });
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.warn(`[spectral] warn: meta publish for auto-title failed: ${msg}`);
-                }
-            }
-        }
-        catch (err) {
-            // Defensive: generateSessionTitle already swallows LLM errors. This
-            // catches any unexpected throw from rename/broadcast so the manager
-            // is never destabilized by a background title task.
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[spectral] warn: auto-title pipeline failed: ${msg}`);
-        }
-    }
     broadcast(stream, event) {
         const dead = [];
         for (const sub of stream.subscribers) {
@@ -1410,6 +1338,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

@@ -36,7 +36,7 @@ import { stripJsoncComments } from "../studio-binding.js";
  * Since this is local-only conversation history pre-1.0, we explicitly do not
  * preserve user data across schema changes.
  */
-const SCHEMA_VERSION = 3;
+const SCHEMA_VERSION = 4;
 const SCHEMA_SQL = `
 PRAGMA foreign_keys = ON;
 
@@ -78,6 +78,28 @@ CREATE TABLE IF NOT EXISTS session_memory_snapshots (
   covered_source_count INTEGER NOT NULL,
   updated_at INTEGER NOT NULL
 );
+
+CREATE TABLE IF NOT EXISTS project_observations (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  session_id TEXT NOT NULL,
+  content TEXT NOT NULL,
+  relevance TEXT NOT NULL CHECK (relevance IN ('low','medium','high','critical')),
+  created_at INTEGER NOT NULL
+);
+
+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.
@@ -108,7 +130,7 @@ function applyBindingFields(project) {
     };
 }
 /** Tables we own — used by the migration drop step. */
-const KNOWN_TABLES = ["session_memory_snapshots", "messages", "sessions", "projects"];
+const KNOWN_TABLES = ["prompt_queue", "project_observations", "session_memory_snapshots", "messages", "sessions", "projects"];
 /** Best-effort parse of the `images_json` column into `ImageAttachment[]`. */
 function parseImagesJson(raw) {
     if (!raw || raw === "")
@@ -169,6 +191,17 @@ export class SessionStore {
     // Fork & Compact: flag + per-session source tracking.
     stmtSetForkCompactSource;
     stmtGetForkCompactSource;
+    // Project observations: cross-session durable memory.
+    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
@@ -307,6 +340,27 @@ export class SessionStore {
         this.stmtSetSessionModel = this.db.prepare(`UPDATE sessions SET model_id = ? 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)
+       VALUES (?, ?, ?, ?, ?, ?)`);
+        this.stmtSearchProjectObs = this.db.prepare(`SELECT id, project_id, session_id, content, relevance, created_at
+       FROM project_observations
+       WHERE project_id = ? AND content LIKE ?
+       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() {
@@ -653,6 +707,104 @@ export class SessionStore {
     clearForkCompactSource(sessionId) {
         this.stmtSetForkCompactSource.run(null, sessionId);
     }
+    // ----------------------------------------------------------------------
+    // Project observations (cross-session durable memory)
+    // ----------------------------------------------------------------------
+    /**
+     * Insert multiple project observations in a single transaction.
+     * Uses INSERT OR REPLACE so re-running after the same compaction is idempotent.
+     */
+    insertProjectObservations(projectId, sessionId, observations, createdAt) {
+        if (observations.length === 0)
+            return;
+        const tx = this.db.transaction(() => {
+            for (const obs of observations) {
+                this.stmtInsertProjectObs.run(obs.id, projectId, sessionId, obs.content, obs.relevance, createdAt);
+            }
+        });
+        tx();
+    }
+    /**
+     * Search project observations by substring match. Returns up to 20 most recent.
+     */
+    searchProjectObservations(projectId, query, limit = 20) {
+        const pattern = `%${query}%`;
+        const rows = this.stmtSearchProjectObs.all(projectId, pattern);
+        return rows.slice(0, limit).map((r) => ({
+            content: r.content,
+            relevance: r.relevance,
+            createdAt: r.created_at,
+            sessionId: r.session_id,
+        }));
+    }
+    /**
+     * Look up a project by its absolute filesystem path.
+     * Returns null when no project has been registered for the given path.
+     */
+    getProjectByCwd(cwd) {
+        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;