@lelouchhe/webagent 0.7.0 → 0.8.0

package/lib/session-manager.js

@@ -3,12 +3,13 @@ import { randomUUID } from "node:crypto";
 import { rm } from "node:fs/promises";
 import { stat } from "node:fs/promises";
 import { join } from "node:path";
+import { MessageNotFoundError } from "./store.js";
 import { SessionStateManager } from "./session-state.js";
 import { buildLabelMap } from "./attachment-labels.js";
 import { log } from "./log.js";
 const slog = log.scope("session");
 const IS_WIN = process.platform === "win32";
-export function interruptBashProc(proc) {
+export function interruptBashProc(proc, force = false) {
     if (!proc)
         return;
     if (IS_WIN && typeof proc.pid === "number") {
@@ -18,19 +19,23 @@ export function interruptBashProc(proc) {
     }
     if (typeof proc.pid === "number") {
         try {
-            process.kill(-proc.pid, "SIGINT");
+            process.kill(-proc.pid, force ? "SIGKILL" : "SIGINT");
             return;
         }
         catch {
             // Fall through to direct child kill when the process is not a group leader.
         }
     }
-    proc.kill("SIGINT");
+    proc.kill(force ? "SIGKILL" : "SIGINT");
 }
-/** Known config option IDs that we persist per-session. */
-const _PERSISTED_CONFIG_IDS = ["model", "mode", "reasoning_effort"];
 /** Minimum age (seconds) before an empty session is eligible for cleanup. */
 const EMPTY_SESSION_MIN_AGE_S = 60;
+export class InvalidSessionDirectoryError extends Error {
+    constructor(cwd) {
+        super(`Directory does not exist: ${cwd}`);
+        this.name = "InvalidSessionDirectoryError";
+    }
+}
 /**
  * Centralizes all session-related state that was previously scattered
  * across module-level variables in server.ts.
@@ -42,13 +47,20 @@ export class SessionManager {
     assistantBuffers = new Map();
     thinkingBuffers = new Map();
     activePrompts = new Set();
+    pendingPromptSubmissions = new Map();
+    cancelledPromptSubmissions = new Set();
     runningBashProcs = new Map();
+    interruptedBashProcs = new WeakSet();
     /** Pending permission requests keyed by requestId. */
     pendingPermissions = new Map();
     /** Per-session runtime state (busy/streaming/permissions snapshots + patches). */
     state = new SessionStateManager();
     /** Deduplicates concurrent resume calls for the same session. */
     pendingResumes = new Map();
+    nextPromptNumber = 0;
+    nextPromptSubmissionNumber = 0;
+    /** Deduplicates concurrent attempts to materialize one inbox message. */
+    pendingMessageConsumes = new Map();
     /**
      * Per-session attachment label map (CLAUDE.md "Attachment label
      * egress rewrite"). Built lazily from the `attachments` table on
@@ -76,7 +88,7 @@ export class SessionManager {
         }
     }
     /** Create a new session in both bridge and store, inheriting the source session's config. */
-    async createSession(bridge, cwd, inheritFromSessionId, source = "auto") {
+    async createSession(bridge, cwd, inheritFromSessionId, source = "auto", opts) {
         const sessionCwd = cwd ?? this.defaultCwd;
         try {
             const info = await stat(sessionCwd);
@@ -84,7 +96,7 @@ export class SessionManager {
                 throw new Error("not a directory");
         }
         catch {
-            throw new Error(`Directory does not exist: ${sessionCwd}`);
+            throw new InvalidSessionDirectoryError(sessionCwd);
         }
         // Clean up empty sessions (no events) older than the threshold
         const cleaned = this.store.deleteEmptySessions(EMPTY_SESSION_MIN_AGE_S);
@@ -97,9 +109,20 @@ export class SessionManager {
         const sourceSession = inheritFromSessionId
             ? this.store.getSession(inheritFromSessionId)
             : null;
-        const { sessionId } = await bridge.newSession(sessionCwd);
+        const { sessionId, configOptions: createdConfigOptions } = await bridge.newSession(sessionCwd, { silent: opts?.silent });
+        let configOptions = createdConfigOptions;
+        try {
+            this.store.createSession(sessionId, sessionCwd, source);
+        }
+        catch (err) {
+            slog.warn("ACP session created but local persistence failed", {
+                sessionId,
+                error: err,
+            });
+            throw err;
+        }
         this.liveSessions.add(sessionId);
-        this.store.createSession(sessionId, sessionCwd, source);
+        this.recordConfigOptions(sessionId, createdConfigOptions);
         // Inherit config options from source session
         if (sourceSession) {
             const inherited = [
@@ -110,8 +133,14 @@ export class SessionManager {
                 if (!value)
                     continue;
                 try {
-                    await bridge.setConfigOption(sessionId, configId, value);
-                    this.store.updateSessionConfig(sessionId, configId, value);
+                    const updatedConfigOptions = await bridge.setConfigOption(sessionId, configId, value);
+                    if (updatedConfigOptions.length > 0) {
+                        configOptions = updatedConfigOptions;
+                        this.recordConfigOptions(sessionId, updatedConfigOptions);
+                    }
+                    else {
+                        this.store.updateSessionConfig(sessionId, configId, value);
+                    }
                 }
                 catch {
                     // Option may no longer be available; ignore
@@ -121,9 +150,73 @@ export class SessionManager {
         const session = this.store.getSession(sessionId);
         return {
             sessionId,
-            configOptions: session ? this.buildConfigOptions(session) : [],
+            configOptions: session
+                ? this.applyStoredConfig(configOptions, session)
+                : [],
         };
     }
+    /** Cache the ACP config schema and persist this session's current values. */
+    recordConfigOptions(sessionId, configOptions) {
+        if (configOptions.length === 0)
+            return;
+        this.cachedConfigOptions = configOptions;
+        for (const option of configOptions) {
+            if (typeof option.currentValue === "string") {
+                this.store.updateSessionConfig(sessionId, option.id, option.currentValue);
+            }
+        }
+    }
+    /**
+     * Materialize a pending inbox message as a real ACP-backed session.
+     * Returns null when the message is neither pending nor previously consumed.
+     */
+    consumeMessage(bridge, messageId, inheritFromSessionId) {
+        const pending = this.pendingMessageConsumes.get(messageId);
+        if (pending)
+            return pending;
+        const existing = this.store.findConsumedMessageSession(messageId);
+        if (existing) {
+            return Promise.resolve({
+                sessionId: existing,
+                alreadyConsumed: true,
+            });
+        }
+        const operation = this.consumePendingMessage(bridge, messageId, inheritFromSessionId).finally(() => {
+            if (this.pendingMessageConsumes.get(messageId) === operation) {
+                this.pendingMessageConsumes.delete(messageId);
+            }
+        });
+        this.pendingMessageConsumes.set(messageId, operation);
+        return operation;
+    }
+    async consumePendingMessage(bridge, messageId, inheritFromSessionId) {
+        const message = this.store.getMessage(messageId);
+        if (!message)
+            return null;
+        const { sessionId } = await this.createSession(bridge, message.cwd ?? undefined, inheritFromSessionId, "message", { silent: true });
+        try {
+            const result = this.store.consumeMessageTx(messageId, sessionId);
+            if (result.alreadyConsumed) {
+                this.deleteSession(sessionId);
+            }
+            return result;
+        }
+        catch (err) {
+            this.deleteSession(sessionId);
+            if (err instanceof MessageNotFoundError) {
+                const consumedSessionId = this.store.findConsumedMessageSession(messageId);
+                return consumedSessionId
+                    ? { sessionId: consumedSessionId, alreadyConsumed: true }
+                    : null;
+            }
+            slog.warn("message consume left an unreachable ACP session", {
+                messageId,
+                sessionId,
+                error: err,
+            });
+            throw err;
+        }
+    }
     /** Resume a session — returns event to send to the requesting client. */
     async resumeSession(bridge, sessionId) {
         const session = this.store.getSession(sessionId);
@@ -233,7 +326,7 @@ export class SessionManager {
     /** Override currentValue in configOptions with stored session values. */
     applyStoredConfig(configOptions, session) {
         if (!configOptions.length)
-            return this.cachedConfigOptions;
+            return configOptions;
         const stored = {
             model: session.model,
             mode: session.mode,
@@ -311,6 +404,11 @@ export class SessionManager {
         this.assistantBuffers.delete(sessionId);
         this.thinkingBuffers.delete(sessionId);
         this.activePrompts.delete(sessionId);
+        const pendingSubmission = this.pendingPromptSubmissions.get(sessionId);
+        this.pendingPromptSubmissions.delete(sessionId);
+        if (pendingSubmission !== undefined) {
+            this.cancelledPromptSubmissions.delete(pendingSubmission);
+        }
         this.runningBashProcs.delete(sessionId);
         this.attachmentLabelCache.delete(sessionId);
         this.agentCommandSnapshots.delete(sessionId);
@@ -338,17 +436,17 @@ export class SessionManager {
     /** Flush only the assistant message buffer to store. */
     flushAssistantBuffer(sessionId) {
         const assistant = this.assistantBuffers.get(sessionId);
-        if (assistant) {
+        this.assistantBuffers.delete(sessionId);
+        if (assistant && this.store.getSession(sessionId)) {
             this.store.saveEvent(sessionId, "assistant_message", { text: assistant }, { from_ref: "agent" });
-            this.assistantBuffers.delete(sessionId);
         }
     }
     /** Flush only the thinking buffer to store. */
     flushThinkingBuffer(sessionId) {
         const thinking = this.thinkingBuffers.get(sessionId);
-        if (thinking) {
+        this.thinkingBuffers.delete(sessionId);
+        if (thinking && this.store.getSession(sessionId)) {
             this.store.saveEvent(sessionId, "thinking", { text: thinking }, { from_ref: "agent" });
-            this.thinkingBuffers.delete(sessionId);
         }
     }
     /** Append to assistant message buffer. */
@@ -366,12 +464,52 @@ export class SessionManager {
         return this.store.getSession(sessionId)?.cwd ?? this.defaultCwd;
     }
     getBusyKind(sessionId) {
-        if (this.runningBashProcs.has(sessionId))
-            return "bash";
+        if (this.pendingPromptSubmissions.has(sessionId))
+            return "agent";
         if (this.activePrompts.has(sessionId))
             return "agent";
+        if (this.runningBashProcs.has(sessionId))
+            return "bash";
         return null;
     }
+    /**
+     * True when `promptId` still names the session's live turn. A turn can
+     * outlive its own supersession — cancelling one and immediately starting
+     * another interleaves them — and its terminal work must not clear state
+     * that now belongs to the replacement. An absent id is treated as current
+     * so callers predating turn identity keep their old behaviour.
+     */
+    isCurrentPrompt(sessionId, promptId) {
+        if (!promptId)
+            return true;
+        const current = this.state.getState(sessionId).runtime.busy?.promptId;
+        return current == null || current === promptId;
+    }
+    reservePromptSubmission(sessionId) {
+        if (this.getBusyKind(sessionId) !== null)
+            return null;
+        const submissionId = ++this.nextPromptSubmissionNumber;
+        this.pendingPromptSubmissions.set(sessionId, submissionId);
+        return submissionId;
+    }
+    cancelPendingPromptSubmission(sessionId) {
+        const submissionId = this.pendingPromptSubmissions.get(sessionId);
+        if (submissionId === undefined)
+            return false;
+        this.cancelledPromptSubmissions.add(submissionId);
+        return true;
+    }
+    isPromptSubmissionCancelled(submissionId) {
+        return this.cancelledPromptSubmissions.has(submissionId);
+    }
+    releasePromptSubmission(sessionId, submissionId, sync = true) {
+        if (this.pendingPromptSubmissions.get(sessionId) === submissionId) {
+            this.pendingPromptSubmissions.delete(sessionId);
+        }
+        this.cancelledPromptSubmissions.delete(submissionId);
+        if (sync)
+            this.syncBusy(sessionId);
+    }
     /**
      * Recompute busy from active prompts/bash procs and patch the state manager.
      * Call this immediately after mutating activePrompts / runningBashProcs so
@@ -390,8 +528,14 @@ export class SessionManager {
             this.state.clearCancelSafety(sessionId);
             return;
         }
-        const nextPromptId = kind === "agent" ? (promptId ?? current?.promptId ?? null) : null;
-        if (current?.kind === kind && current.promptId === nextPromptId)
+        const nextPromptId = kind === "agent"
+            ? (promptId ??
+                (current?.kind === "agent"
+                    ? current.promptId
+                    : `prompt-${++this.nextPromptNumber}`))
+            : null;
+        const sameWork = current?.kind === kind && current.promptId === nextPromptId;
+        if (sameWork)
             return;
         this.state.patch(sessionId, {
             runtime: {
@@ -399,6 +543,7 @@ export class SessionManager {
                     kind: kind,
                     since: current?.kind === kind ? current.since : new Date().toISOString(),
                     promptId: nextPromptId,
+                    cancelStatus: null,
                 },
             },
         });
@@ -417,13 +562,16 @@ export class SessionManager {
         });
         this.activePrompts.add(sessionId);
         this.syncBusy(sessionId);
+        const promptId = this.state.getState(sessionId).runtime.busy?.promptId ?? undefined;
         bridge
-            .prompt(sessionId, "Continue your previous response — it was interrupted mid-way.")
+            .prompt(sessionId, "Continue your previous response — it was interrupted mid-way.", undefined, promptId)
             .catch((err) => {
             slog.error("auto-retry failed", {
                 sessionId: sessionId.slice(0, 8) + "…",
                 error: err,
             });
+            if (!this.isCurrentPrompt(sessionId, promptId))
+                return;
             this.activePrompts.delete(sessionId);
             this.syncBusy(sessionId);
         });

package/lib/session-state.js

@@ -1,12 +1,14 @@
 /**
  * Per-session runtime state: single source of truth for "what state is this
- * session in right now" (busy / streaming / pending permissions).
+ * session in right now" (busy / streaming / pending permissions / plan).
  *
  * The frontend fetches a full snapshot on connect / reconnect / after long
  * backgrounding, then applies incremental `state_patch` SSE events. This
  * replaces the old "replay history + reconcile" approach which repeatedly
  * grew one-off sync paths per state field.
  */
+import { log } from "./log.js";
+const clog = log.scope("cancel");
 function defaultState() {
     return {
         seq: 0,
@@ -14,6 +16,7 @@ function defaultState() {
             busy: null,
             pendingPermissions: [],
             streaming: { assistant: false, thinking: false },
+            plan: null,
         },
     };
 }
@@ -22,7 +25,10 @@ function busyEqual(a, b) {
         return true;
     if (a === null || b === null)
         return false;
-    return a.kind === b.kind && a.since === b.since && a.promptId === b.promptId;
+    return (a.kind === b.kind &&
+        a.since === b.since &&
+        a.promptId === b.promptId &&
+        (a.cancelStatus ?? null) === (b.cancelStatus ?? null));
 }
 function permsEqual(a, b) {
     if (a.length !== b.length)
@@ -43,6 +49,13 @@ function permsEqual(a, b) {
     }
     return true;
 }
+function plansEqual(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    if (a.length !== b.length)
+        return false;
+    return a.every((entry, index) => entry.status === b[index].status && entry.content === b[index].content);
+}
 /** True when the patch would change the current runtime state. */
 function hasRuntimeChanges(current, patch) {
     if (!patch)
@@ -53,6 +66,8 @@ function hasRuntimeChanges(current, patch) {
         patch.pendingPermissions &&
         !permsEqual(current.pendingPermissions, patch.pendingPermissions))
         return true;
+    if ("plan" in patch && !plansEqual(current.plan, patch.plan ?? null))
+        return true;
     if ("streaming" in patch && patch.streaming) {
         const s = patch.streaming;
         if (s.assistant !== undefined &&
@@ -76,6 +91,11 @@ export class SessionStateManager {
         }
         return s;
     }
+    /** Read streaming state without creating runtime state for an unseen session. */
+    peekStreaming(sessionId) {
+        const streaming = this.states.get(sessionId)?.runtime.streaming;
+        return streaming ? { ...streaming } : { assistant: false, thinking: false };
+    }
     /**
      * Merge a patch into the session's runtime state. Bumps seq and notifies
      * listeners only when the patch actually changes something (no-op patches
@@ -95,6 +115,10 @@ export class SessionStateManager {
                 state.runtime.pendingPermissions =
                     patch.runtime.pendingPermissions.slice();
             }
+            if ("plan" in patch.runtime) {
+                state.runtime.plan =
+                    patch.runtime.plan?.map((entry) => ({ ...entry })) ?? null;
+            }
             if ("streaming" in patch.runtime && patch.runtime.streaming) {
                 if (patch.runtime.streaming.assistant !== undefined) {
                     state.runtime.streaming.assistant = patch.runtime.streaming.assistant;
@@ -130,9 +154,30 @@ export class SessionStateManager {
             this.cancelTimers.delete(sessionId);
         }
     }
+    /** Clear current plans for every known session (used on bridge reload). */
+    clearPlans() {
+        for (const [sessionId, state] of this.states) {
+            if (state.runtime.plan !== null) {
+                this.patch(sessionId, { runtime: { plan: null } });
+            }
+        }
+    }
+    /** Clear active stream markers for every known session on bridge teardown. */
+    clearStreaming() {
+        for (const [sessionId, state] of this.states) {
+            if (state.runtime.streaming.assistant ||
+                state.runtime.streaming.thinking) {
+                this.patch(sessionId, {
+                    runtime: {
+                        streaming: { assistant: false, thinking: false },
+                    },
+                });
+            }
+        }
+    }
     /**
-     * Backend safety net for cancel: if busy is still set after `timeoutMs`,
-     * force-clear it. Replaces the old frontend cancel timer.
+     * Backend acknowledgement timer for cancel: if the same agent prompt is
+     * still pending after `timeoutMs`, mark the request unconfirmed.
      * A second arm on the same session replaces the existing timer.
      */
     armCancelSafety(sessionId, timeoutMs) {
@@ -143,12 +188,32 @@ export class SessionStateManager {
             clearTimeout(existing);
         const t = setTimeout(() => {
             this.cancelTimers.delete(sessionId);
-            this.patch(sessionId, { runtime: { busy: null } });
+            const busy = this.getState(sessionId).runtime.busy;
+            if (busy?.kind === "agent" && busy.cancelStatus === "requested") {
+                clog.warn("agent did not acknowledge", {
+                    sessionId: sessionId.slice(0, 8),
+                    promptId: busy.promptId,
+                });
+                this.patch(sessionId, {
+                    runtime: {
+                        busy: { ...busy, cancelStatus: "unconfirmed" },
+                    },
+                });
+            }
         }, timeoutMs);
         if (typeof t === "object" && "unref" in t)
             t.unref();
         this.cancelTimers.set(sessionId, t);
     }
+    /** Mark that a cancel notification was sent for the active agent prompt. */
+    markCancelRequested(sessionId) {
+        const busy = this.getState(sessionId).runtime.busy;
+        if (busy?.kind !== "agent")
+            return;
+        this.patch(sessionId, {
+            runtime: { busy: { ...busy, cancelStatus: "requested" } },
+        });
+    }
     /** Cancel the safety net timer (e.g. when prompt_done arrives naturally). */
     clearCancelSafety(sessionId) {
         const t = this.cancelTimers.get(sessionId);

package/lib/sse-manager.js

@@ -1,6 +1,8 @@
 import { randomBytes } from "node:crypto";
 import { reSignAttachmentUrlsInJson } from "./auth.js";
 import { enrichEventForDisplay } from "./attachment-labels.js";
+import { log } from "./log.js";
+const slog = log.scope("sse");
 /**
  * SSE heartbeat frame — a NAMED event so the frontend can hook
  * `es.addEventListener("heartbeat", ...)` and refresh its per-session
@@ -69,7 +71,7 @@ export class SseManager {
                     catch {
                         /* already torn down */
                     }
-                    this.remove(client.id);
+                    this.remove(client.id, "token-revoked");
                     continue;
                 }
                 client.res.write(SSE_HEARTBEAT_FRAME);
@@ -91,8 +93,13 @@ export class SseManager {
     /** Register a new SSE client connection. */
     add(client) {
         this.clients.set(client.id, client);
+        slog.info("connected", {
+            clientId: client.id,
+            sessionId: client.sessionId ?? "*",
+            clients: this.clients.size,
+        });
         client.res.on("close", () => {
-            this.remove(client.id);
+            this.remove(client.id, "closed");
         });
     }
     /** Write a single heartbeat frame to the given client. Used right after
@@ -109,9 +116,16 @@ export class SseManager {
             // socket already dead; res.on("close") will clean up
         }
     }
-    /** Remove a client by ID. */
-    remove(id) {
-        this.clients.delete(id);
+    /** Remove a client by ID. `reason` is recorded so an operator can tell an
+     *  ordinary disconnect apart from a write failure or a revoked token. */
+    remove(id, reason = "closed") {
+        if (this.clients.delete(id)) {
+            slog.info("disconnected", {
+                clientId: id,
+                reason,
+                clients: this.clients.size,
+            });
+        }
         this.onRemoveCallback?.(id);
     }
     /** Send an SSE event to a single client. */
@@ -138,10 +152,11 @@ export class SseManager {
         try {
             client.res.write(msg);
         }
-        catch {
+        catch (err) {
             // Socket torn down between writableEnded check and write.
             // Drop the client so we stop writing to it on every broadcast.
-            this.remove(client.id);
+            slog.warn("write failed", { clientId: client.id, err: String(err) });
+            this.remove(client.id, "write-failed");
         }
     }
     /**
@@ -159,6 +174,15 @@ export class SseManager {
             this.sendEvent(client, event);
         }
     }
+    /** Broadcast global application state regardless of a client's session filter. */
+    broadcastGlobal(event) {
+        const snapshot = [...this.clients.values()];
+        for (const client of snapshot) {
+            if (client.res.writableEnded)
+                continue;
+            this.sendEvent(client, event);
+        }
+    }
     /** Get count of connected clients. */
     get size() {
         return this.clients.size;

package/lib/store.js

@@ -1,6 +1,12 @@
 import Database from "better-sqlite3";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
+export class MessageNotFoundError extends Error {
+    constructor(messageId) {
+        super(`Message not found: ${messageId}`);
+        this.name = "MessageNotFoundError";
+    }
+}
 export class Store {
     db;
     constructor(dataDir) {
@@ -66,9 +72,9 @@ export class Store {
         }
         // messages — pending unbound notifications. POST /api/v1/messages with
         // `to = "user"` lands here; consumeMessageTx transactionally moves the
-        // content into a new session's events and deletes the row. Bound
-        // messages (to = session id) skip this table entirely and go straight
-        // to `events`.
+        // content into an existing ACP-backed session's events and deletes the
+        // row. Bound messages (to = session id) skip this table entirely and go
+        // straight to `events`.
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS messages (
         id              TEXT PRIMARY KEY,
@@ -506,6 +512,12 @@ export class Store {
             .prepare("SELECT * FROM messages ORDER BY created_at DESC")
             .all();
     }
+    countUnprocessed() {
+        const row = this.db
+            .prepare("SELECT COUNT(*) AS count FROM messages")
+            .get();
+        return row.count;
+    }
     deleteMessage(id) {
         const info = this.db.prepare("DELETE FROM messages WHERE id = ?").run(id);
         return info.changes;
@@ -529,29 +541,21 @@ export class Store {
             .get(to_ref, dedup_key);
     }
     /**
-     * Atomic consume: create a session, append a `message` event whose data
-     * includes `message_id`, and delete the messages row -- all in a single
-     * transaction. If the row is already gone, returns the prior session id
-     * by looking up the historic `message` event; callers can treat this as
-     * idempotent.
+     * Atomically move a pending message into an existing session. Session
+     * lifecycle belongs to SessionManager because ACP creation is asynchronous
+     * and cannot participate in this SQLite transaction.
      */
-    consumeMessageTx(messageId, opts) {
-        // Fast idempotency pre-check outside the tx to avoid the cost of
-        // opening one for an already-resolved message.
-        const existing = this.findMessageEventSession(messageId);
+    consumeMessageTx(messageId, sessionId) {
+        const existing = this.findConsumedMessageSession(messageId);
         if (existing) {
             return { sessionId: existing, alreadyConsumed: true };
         }
         const row = this.getMessage(messageId);
         if (!row) {
-            throw new Error(`consumeMessageTx: message not found (id=${messageId})`);
+            throw new MessageNotFoundError(messageId);
         }
         const tx = this.db.transaction(() => {
-            this.db
-                .prepare("INSERT INTO sessions (id, cwd, source) VALUES (?, ?, ?)")
-                .run(opts.sessionId, opts.cwd ?? row.cwd ?? "", "message");
-            // Append message event via saveEvent so seq logic applies.
-            this.saveEvent(opts.sessionId, "message", {
+            this.saveEvent(sessionId, "message", {
                 message_id: row.id,
                 from_ref: row.from_ref,
                 from_label: row.from_label,
@@ -563,15 +567,13 @@ export class Store {
                 .prepare("DELETE FROM messages WHERE id = ?")
                 .run(messageId);
             if (del.changes === 0) {
-                // Should never happen -- we just fetched the row above. If it does,
-                // roll back via throw.
-                throw new Error(`consumeMessageTx: row vanished mid-tx (id=${messageId})`);
+                throw new MessageNotFoundError(messageId);
             }
         });
         tx();
-        return { sessionId: opts.sessionId, alreadyConsumed: false };
+        return { sessionId, alreadyConsumed: false };
     }
-    findMessageEventSession(messageId) {
+    findConsumedMessageSession(messageId) {
         const row = this.db
             .prepare(`SELECT session_id FROM events
          WHERE type = 'message'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lelouchhe/webagent",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "A terminal-style web UI for ACP-compatible agents",
   "type": "module",
   "license": "MIT",