@mono-agent/web 0.13.0 → 0.15.0

package/dist/store.js

@@ -1,8 +1,9 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { chmod, lstat, readdir, unlink } from "node:fs/promises";
 import { resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { WEB_MAX_FILES_PER_TURN, WEB_MAX_TURN_ATTACHMENT_BYTES, } from "./contracts.js";
+import { AGENT_LIVE_INPUT_MAX_CHARACTERS, } from "@mono-agent/agent-contracts";
+import { WEB_MAX_FILES_PER_TURN, WEB_MAX_LIVE_INPUTS_PER_THREAD, WEB_MAX_TURN_ATTACHMENT_BYTES, WEB_MAX_TURN_TEXT_CHARACTERS, } from "./contracts.js";
 import { WebConsoleError } from "./errors.js";
 import { prepareWebStatePaths } from "./state-paths.js";
 export class WebStore {
@@ -38,6 +39,7 @@ export class WebStore {
                 chmod(`${paths.database}-shm`, 0o600).catch(ignoreMissing),
             ]);
             store.recoverInterruptedTurns();
+            store.recoverLiveInputs();
             return store;
         }
         catch (error) {
@@ -98,6 +100,89 @@ export class WebStore {
             throw new WebConsoleError("agent_not_found", "The selected agent is no longer available.", 404);
         return agent;
     }
+    reserveNotification(input) {
+        if (this.getAgent(input.sourceId) === undefined) {
+            throw new WebConsoleError("agent_not_found", "The notification agent is no longer available.", 404);
+        }
+        if (input.deliveryKey.length === 0 || input.deliveryKey.length > 1_024) {
+            throw new WebConsoleError("invalid_notification", "Notification deliveryKey must contain 1 to 1024 characters.", 400);
+        }
+        if (input.text.trim().length === 0) {
+            throw new WebConsoleError("invalid_notification", "Notification text cannot be empty.", 400);
+        }
+        const threadId = notificationThreadId(input.sourceId, input.deliveryKey);
+        const payloadSha256 = notificationPayloadSha256(input.triggerKind, input.text);
+        const existing = this.database.prepare(`
+      SELECT * FROM notification_deliveries WHERE source_id = ? AND delivery_key = ?
+    `).get(input.sourceId, input.deliveryKey);
+        if (existing !== undefined) {
+            if (existing.thread_id !== threadId
+                || existing.trigger_kind !== input.triggerKind
+                || existing.payload_sha256 !== payloadSha256) {
+                throw new WebConsoleError("notification_idempotency_conflict", "The notification delivery key was already used with different content.", 409);
+            }
+            if (existing.completed_at !== null && this.getThread(existing.thread_id) === undefined) {
+                throw new WebConsoleError("storage_corrupt", "A completed notification is missing its conversation.", 500);
+            }
+            return { ...input, threadId, payloadSha256, duplicate: existing.completed_at !== null };
+        }
+        const now = this.now();
+        this.database.prepare(`
+      INSERT INTO notification_deliveries (
+        source_id, delivery_key, thread_id, trigger_kind, payload_sha256, created_at, completed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, NULL)
+    `).run(input.sourceId, input.deliveryKey, threadId, input.triggerKind, payloadSha256, now);
+        return { ...input, threadId, payloadSha256, duplicate: false };
+    }
+    completeNotification(reservation) {
+        const existing = this.database.prepare(`
+      SELECT * FROM notification_deliveries WHERE source_id = ? AND delivery_key = ?
+    `).get(reservation.sourceId, reservation.deliveryKey);
+        if (existing === undefined
+            || existing.thread_id !== reservation.threadId
+            || existing.trigger_kind !== reservation.triggerKind
+            || existing.payload_sha256 !== reservation.payloadSha256) {
+            throw new WebConsoleError("notification_reservation_lost", "The notification reservation is no longer valid.", 409);
+        }
+        if (existing.completed_at !== null) {
+            return { thread: this.requireThread(existing.thread_id), duplicate: true };
+        }
+        const now = this.now();
+        const turnId = randomUUID();
+        const assistantMessageId = randomUUID();
+        const title = reservation.triggerKind === "cron" ? "Cron notification" : "Webhook notification";
+        this.transaction(() => {
+            if (this.getThread(reservation.threadId) !== undefined) {
+                throw new WebConsoleError("notification_idempotency_conflict", "The notification conversation already exists.", 409);
+            }
+            this.database.prepare(`
+        INSERT INTO threads (
+          id, source_id, conversation_id, title, title_manual, trigger_kind, archived_at,
+          created_at, updated_at, revision
+        ) VALUES (?, ?, ?, ?, 0, ?, NULL, ?, ?, 1)
+      `).run(reservation.threadId, reservation.sourceId, `web:${reservation.threadId}`, title, reservation.triggerKind, now, now);
+            this.database.prepare(`
+        INSERT INTO turns (
+          id, thread_id, status, text, model, effort, assistant_message_id,
+          started_at, finished_at, error_code, error_message
+        ) VALUES (?, ?, 'complete', '', NULL, NULL, ?, ?, ?, NULL, NULL)
+      `).run(turnId, reservation.threadId, assistantMessageId, now, now);
+            this.database.prepare(`
+        INSERT INTO messages (
+          id, thread_id, turn_id, role, parts_json, created_at, updated_at, status
+        ) VALUES (?, ?, ?, 'assistant', ?, ?, ?, 'complete')
+      `).run(assistantMessageId, reservation.threadId, turnId, JSON.stringify([{ type: "text", text: reservation.text }]), now, now);
+            this.database.prepare(`
+        INSERT INTO revisions (entity_kind, entity_id, revision, event, created_at)
+        VALUES ('thread', ?, 1, 'notification_created', ?)
+      `).run(reservation.threadId, now);
+            this.database.prepare(`
+        UPDATE notification_deliveries SET completed_at = ?
+        WHERE source_id = ? AND delivery_key = ? AND completed_at IS NULL
+      `).run(now, reservation.sourceId, reservation.deliveryKey);
+        });
+        return { thread: this.requireThread(reservation.threadId), duplicate: false };
+    }
     createThread(sourceId) {
         const agent = this.getAgent(sourceId);
         if (agent === undefined) {
@@ -130,7 +215,17 @@ export class WebStore {
         const thread = this.getThread(id);
         if (thread === undefined)
             return undefined;
-        const rows = this.database.prepare("SELECT * FROM messages WHERE thread_id = ? ORDER BY created_at, rowid").all(id);
+        const rows = this.database.prepare(`
+      SELECT m.* FROM messages m
+      LEFT JOIN turns t ON t.id = m.turn_id
+      WHERE m.thread_id = ?
+      ORDER BY COALESCE(t.started_at, m.created_at),
+        CASE WHEN m.turn_id IS NOT NULL AND m.role = 'user' THEN 0
+             WHEN m.turn_id IS NOT NULL AND m.role = 'system' THEN 1
+             WHEN m.turn_id IS NOT NULL THEN 2
+             ELSE 3 END,
+        m.created_at, m.rowid
+    `).all(id);
         return { thread, messages: rows.map((row) => this.mapMessage(row)) };
     }
     currentThreadId() {
@@ -168,6 +263,28 @@ export class WebStore {
         });
         return { ...this.requireThread(id), sourceId: current.sourceId };
     }
+    async deleteArchivedThread(id) {
+        const thread = this.requireThread(id);
+        if (thread.archivedAt === null) {
+            throw new WebConsoleError("thread_not_archived", "Archive the conversation before deleting it.", 409);
+        }
+        const attachments = this.database.prepare("SELECT * FROM attachments WHERE thread_id = ?")
+            .all(id);
+        this.transaction(() => {
+            this.database.prepare("DELETE FROM notification_deliveries WHERE thread_id = ?").run(id);
+            this.database.prepare("DELETE FROM revisions WHERE entity_kind = 'thread' AND entity_id = ?").run(id);
+            this.database.prepare("DELETE FROM threads WHERE id = ?").run(id);
+            this.database.prepare("DELETE FROM settings WHERE key = 'current_thread_id' AND value = ?").run(id);
+        });
+        let orphanedFiles = 0;
+        for (const row of attachments) {
+            await unlink(this.attachmentPath(mapStoredAttachment(row))).catch((error) => {
+                if (error.code !== "ENOENT")
+                    orphanedFiles += 1;
+            });
+        }
+        return { orphanedFiles };
+    }
     createUpload(input) {
         const id = randomUUID();
         const now = this.now();
@@ -252,6 +369,23 @@ export class WebStore {
         }
         return removed;
     }
+    async purgeUnreferencedAttachmentFiles() {
+        const referenced = new Set(this.database.prepare("SELECT storage_name FROM attachments").all()
+            .map((row) => row.storage_name));
+        const entries = await readdir(this.paths.uploads, { withFileTypes: true });
+        let removed = 0;
+        for (const entry of entries) {
+            if (!/^[0-9a-f-]{36}\.bin$/iu.test(entry.name) || referenced.has(entry.name))
+                continue;
+            const path = resolve(this.paths.uploads, entry.name);
+            const info = await lstat(path);
+            if (!info.isFile() || info.isSymbolicLink())
+                continue;
+            await unlink(path);
+            removed += 1;
+        }
+        return removed;
+    }
     beginTurn(input) {
         const thread = this.requireThread(input.threadId);
         if (thread.archivedAt !== null) {
@@ -347,6 +481,181 @@ export class WebStore {
             thread: this.requireThread(input.threadId),
         };
     }
+    reserveLiveInput(threadId, text) {
+        const thread = this.requireThread(threadId);
+        if (thread.archivedAt !== null) {
+            throw new WebConsoleError("thread_archived", "Unarchive this conversation before sending another message.", 409);
+        }
+        if (!thread.canSend) {
+            throw new WebConsoleError("agent_offline", "This agent is offline. The conversation remains available read-only.", 409);
+        }
+        if (text.trim().length === 0) {
+            throw new WebConsoleError("empty_turn", "Enter a message.", 400);
+        }
+        if (text.length > AGENT_LIVE_INPUT_MAX_CHARACTERS) {
+            throw new WebConsoleError("turn_text_too_large", `A live follow-up may contain at most ${AGENT_LIVE_INPUT_MAX_CHARACTERS} characters.`, 413);
+        }
+        const usage = this.database.prepare("SELECT COUNT(*) AS count FROM live_inputs WHERE thread_id = ?").get(threadId);
+        if (usage.count >= WEB_MAX_LIVE_INPUTS_PER_THREAD) {
+            throw new WebConsoleError("live_input_queue_full", "Too many follow-up messages are waiting.", 429);
+        }
+        const active = this.database.prepare("SELECT id, model, effort FROM turns WHERE thread_id = ? AND status = 'running'").get(threadId);
+        const id = randomUUID();
+        const messageId = randomUUID();
+        const now = this.now();
+        const status = active === undefined ? "queued" : "offered";
+        const parts = [
+            liveInputTelemetry(status === "offered" ? "pending" : "queued"),
+            { type: "text", text },
+        ];
+        this.transaction(() => {
+            this.database.prepare(`
+        INSERT INTO messages (id, thread_id, turn_id, role, parts_json, created_at, updated_at, status)
+        VALUES (?, ?, ?, 'user', ?, ?, ?, 'complete')
+      `).run(messageId, threadId, active?.id ?? null, JSON.stringify(parts), now, now);
+            this.database.prepare(`
+        INSERT INTO live_inputs (
+          id, thread_id, message_id, active_turn_id, text, model, effort, status, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, threadId, messageId, active?.id ?? null, text, active?.model ?? null, active?.effort ?? null, status, now, now);
+            const title = deriveAutomaticTitle(text, []);
+            this.database.prepare(`
+        UPDATE threads
+        SET title = CASE WHEN title_manual = 0 AND title = 'New conversation' THEN ? ELSE title END,
+            updated_at = ?, revision = revision + 1
+        WHERE id = ?
+      `).run(title, now, threadId);
+            this.recordThreadRevision(threadId, "live_input_received", now);
+            this.setSetting("current_thread_id", threadId);
+        });
+        const stored = this.requireLiveInput(id);
+        return {
+            input: mapLiveInput(stored),
+            message: this.requireMessage(messageId),
+            thread: this.requireThread(threadId),
+            offered: status === "offered",
+        };
+    }
+    markLiveInputApplied(id) {
+        const row = this.getLiveInput(id);
+        if (row === undefined)
+            return undefined;
+        const message = this.requireMessage(row.message_id);
+        const now = this.now();
+        this.transaction(() => {
+            this.database.prepare("UPDATE messages SET parts_json = ?, updated_at = ? WHERE id = ?")
+                .run(JSON.stringify(withLiveInputStatus(message.parts, "applied")), now, row.message_id);
+            this.database.prepare("DELETE FROM live_inputs WHERE id = ?").run(id);
+            this.database.prepare("UPDATE threads SET updated_at = ?, revision = revision + 1 WHERE id = ?")
+                .run(now, row.thread_id);
+            this.recordThreadRevision(row.thread_id, "live_input_applied", now);
+        });
+        return this.requireMessage(row.message_id);
+    }
+    queueLiveInput(id) {
+        const row = this.getLiveInput(id);
+        if (row === undefined)
+            return undefined;
+        const message = this.requireMessage(row.message_id);
+        const now = this.now();
+        this.transaction(() => {
+            this.database.prepare(`
+        UPDATE live_inputs SET status = 'queued', active_turn_id = NULL, updated_at = ? WHERE id = ?
+      `).run(now, id);
+            this.database.prepare("UPDATE messages SET turn_id = NULL, parts_json = ?, updated_at = ? WHERE id = ?")
+                .run(JSON.stringify(withLiveInputStatus(message.parts, "queued")), now, row.message_id);
+            this.database.prepare("UPDATE threads SET updated_at = ?, revision = revision + 1 WHERE id = ?")
+                .run(now, row.thread_id);
+            this.recordThreadRevision(row.thread_id, "live_input_queued", now);
+        });
+        return this.requireMessage(row.message_id);
+    }
+    cancelLiveInput(id) {
+        const row = this.getLiveInput(id);
+        if (row === undefined)
+            return undefined;
+        const message = this.requireMessage(row.message_id);
+        const now = this.now();
+        this.transaction(() => {
+            this.database.prepare("UPDATE messages SET turn_id = NULL, parts_json = ?, updated_at = ? WHERE id = ?")
+                .run(JSON.stringify(withLiveInputStatus(message.parts, "cancelled")), now, row.message_id);
+            this.database.prepare("DELETE FROM live_inputs WHERE id = ?").run(id);
+            this.database.prepare("UPDATE threads SET updated_at = ?, revision = revision + 1 WHERE id = ?")
+                .run(now, row.thread_id);
+            this.recordThreadRevision(row.thread_id, "live_input_cancelled", now);
+        });
+        return this.requireMessage(row.message_id);
+    }
+    cancelLiveInputs(threadId) {
+        const rows = this.database.prepare("SELECT * FROM live_inputs WHERE thread_id = ? ORDER BY created_at, rowid").all(threadId);
+        if (rows.length === 0)
+            return [];
+        const now = this.now();
+        this.transaction(() => {
+            const update = this.database.prepare("UPDATE messages SET turn_id = NULL, parts_json = ?, updated_at = ? WHERE id = ?");
+            for (const row of rows) {
+                const message = this.requireMessage(row.message_id);
+                update.run(JSON.stringify(withLiveInputStatus(message.parts, "cancelled")), now, row.message_id);
+            }
+            this.database.prepare("DELETE FROM live_inputs WHERE thread_id = ?").run(threadId);
+            this.database.prepare("UPDATE threads SET updated_at = ?, revision = revision + 1 WHERE id = ?")
+                .run(now, threadId);
+            this.recordThreadRevision(threadId, "live_inputs_cancelled", now);
+        });
+        return rows.map((row) => this.requireMessage(row.message_id));
+    }
+    queuedLiveInputThreadIds() {
+        return this.database.prepare(`
+      SELECT thread_id FROM live_inputs WHERE status = 'queued'
+      GROUP BY thread_id ORDER BY MIN(created_at), thread_id
+    `).all().map((row) => row.thread_id);
+    }
+    promoteNextQueuedLiveInput(threadId) {
+        const active = this.database.prepare("SELECT id FROM turns WHERE thread_id = ? AND status = 'running'").get(threadId);
+        if (active !== undefined)
+            return undefined;
+        const row = this.database.prepare(`
+      SELECT * FROM live_inputs
+      WHERE thread_id = ? AND status = 'queued'
+      ORDER BY created_at, rowid LIMIT 1
+    `).get(threadId);
+        if (row === undefined)
+            return undefined;
+        const thread = this.requireThread(threadId);
+        if (!thread.canSend || thread.archivedAt !== null)
+            return undefined;
+        const turnId = randomUUID();
+        const assistantMessageId = randomUUID();
+        const now = this.now();
+        const userMessage = this.requireMessage(row.message_id);
+        this.transaction(() => {
+            this.database.prepare(`
+        INSERT INTO turns (
+          id, thread_id, status, text, model, effort, assistant_message_id,
+          started_at, finished_at, error_code, error_message
+        ) VALUES (?, ?, 'running', ?, ?, ?, ?, ?, NULL, NULL, NULL)
+      `).run(turnId, threadId, row.text, row.model, row.effort, assistantMessageId, now);
+            this.database.prepare("UPDATE messages SET turn_id = ?, parts_json = ?, updated_at = ? WHERE id = ?")
+                .run(turnId, JSON.stringify(withoutLiveInputTelemetry(userMessage.parts)), now, row.message_id);
+            this.database.prepare(`
+        INSERT INTO messages (id, thread_id, turn_id, role, parts_json, created_at, updated_at, status)
+        VALUES (?, ?, ?, 'assistant', '[]', ?, ?, 'running')
+      `).run(assistantMessageId, threadId, turnId, now, now);
+            this.database.prepare("DELETE FROM live_inputs WHERE id = ?").run(row.id);
+            this.database.prepare("UPDATE threads SET updated_at = ?, revision = revision + 1 WHERE id = ?")
+                .run(now, threadId);
+            this.recordThreadRevision(threadId, "turn_started", now);
+        });
+        return {
+            turnId,
+            conversationId: `web:${threadId}`,
+            text: row.text,
+            userMessageId: row.message_id,
+            assistantMessageId,
+            attachments: [],
+            thread: this.requireThread(threadId),
+        };
+    }
     applyStreamFrame(turnId, frame) {
         return this.applyStreamFrames(turnId, [frame]);
     }
@@ -419,13 +728,17 @@ export class WebStore {
         try {
             this.database.exec("PRAGMA foreign_keys = ON; PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;");
             const versionRow = this.database.prepare("PRAGMA user_version").get();
-            if (versionRow.user_version > 1) {
-                throw new WebConsoleError("unsupported_storage_schema", `Web state schema ${versionRow.user_version} is newer than supported schema 1.`, 500);
+            if (versionRow.user_version > 3) {
+                throw new WebConsoleError("unsupported_storage_schema", `Web state schema ${versionRow.user_version} is newer than supported schema 3.`, 500);
             }
             if (versionRow.user_version < 0) {
                 throw new WebConsoleError("storage_corrupt", "Web state schema version is invalid.", 500);
             }
-            this.database.exec(`
+            const migrating = versionRow.user_version < 3;
+            if (migrating)
+                this.database.exec("BEGIN IMMEDIATE");
+            try {
+                this.database.exec(`
       CREATE TABLE IF NOT EXISTS agents (
         source_id TEXT PRIMARY KEY,
         label TEXT NOT NULL,
@@ -445,6 +758,7 @@ export class WebStore {
         conversation_id TEXT NOT NULL UNIQUE,
         title TEXT NOT NULL,
         title_manual INTEGER NOT NULL DEFAULT 0,
+        trigger_kind TEXT CHECK (trigger_kind IN ('cron', 'webhook')),
         archived_at TEXT,
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL,
@@ -476,6 +790,20 @@ export class WebStore {
         status TEXT NOT NULL
       );
       CREATE INDEX IF NOT EXISTS messages_by_thread ON messages(thread_id, created_at);
+      CREATE TABLE IF NOT EXISTS live_inputs (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+        message_id TEXT NOT NULL UNIQUE REFERENCES messages(id) ON DELETE CASCADE,
+        active_turn_id TEXT REFERENCES turns(id) ON DELETE SET NULL,
+        text TEXT NOT NULL,
+        model TEXT,
+        effort TEXT,
+        status TEXT NOT NULL CHECK (status IN ('offered', 'queued')),
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS live_inputs_by_thread
+        ON live_inputs(thread_id, status, created_at);
       CREATE TABLE IF NOT EXISTS attachments (
         id TEXT PRIMARY KEY,
         thread_id TEXT REFERENCES threads(id) ON DELETE CASCADE,
@@ -504,9 +832,31 @@ export class WebStore {
         key TEXT PRIMARY KEY,
         value TEXT NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS notification_deliveries (
+        source_id TEXT NOT NULL REFERENCES agents(source_id),
+        delivery_key TEXT NOT NULL,
+        thread_id TEXT NOT NULL UNIQUE,
+        trigger_kind TEXT NOT NULL CHECK (trigger_kind IN ('cron', 'webhook')),
+        payload_sha256 TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        completed_at TEXT,
+        PRIMARY KEY (source_id, delivery_key)
+      );
       `);
-            if (versionRow.user_version === 0)
-                this.database.exec("PRAGMA user_version = 1");
+                if (versionRow.user_version === 1) {
+                    const columns = this.database.prepare("PRAGMA table_info(threads)").all();
+                    if (!columns.some((column) => column.name === "trigger_kind")) {
+                        this.database.exec("ALTER TABLE threads ADD COLUMN trigger_kind TEXT CHECK (trigger_kind IN ('cron', 'webhook'))");
+                    }
+                }
+                if (migrating)
+                    this.database.exec("PRAGMA user_version = 3; COMMIT");
+            }
+            catch (error) {
+                if (this.database.isTransaction)
+                    this.database.exec("ROLLBACK");
+                throw error;
+            }
             this.validateStorage();
         }
         catch (error) {
@@ -520,7 +870,17 @@ export class WebStore {
         if (check === undefined || !Object.values(check).includes("ok")) {
             throw new WebConsoleError("storage_corrupt", "Web state failed SQLite integrity validation.", 500);
         }
-        const requiredTables = new Set(["agents", "threads", "turns", "messages", "attachments", "revisions", "settings"]);
+        const requiredTables = new Set([
+            "agents",
+            "threads",
+            "turns",
+            "messages",
+            "live_inputs",
+            "attachments",
+            "revisions",
+            "settings",
+            "notification_deliveries",
+        ]);
         const tables = this.database.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all();
         for (const table of tables)
             requiredTables.delete(table.name);
@@ -543,6 +903,33 @@ export class WebStore {
             this.interruptTurn(turnId, "The web service restarted before this turn completed.");
         }
     }
+    recoverLiveInputs() {
+        const rows = this.database.prepare("SELECT * FROM live_inputs WHERE status = 'offered' ORDER BY created_at, rowid").all();
+        if (rows.length === 0)
+            return;
+        const now = this.now();
+        const threadIds = new Set(rows.map((row) => row.thread_id));
+        this.transaction(() => {
+            const updateInput = this.database.prepare(`
+        UPDATE live_inputs SET status = 'queued', active_turn_id = NULL, updated_at = ? WHERE id = ?
+      `);
+            const updateMessage = this.database.prepare("UPDATE messages SET turn_id = NULL, parts_json = ?, updated_at = ? WHERE id = ?");
+            for (const row of rows) {
+                const persisted = this.database.prepare("SELECT parts_json FROM messages WHERE id = ?")
+                    .get(row.message_id);
+                if (persisted === undefined) {
+                    throw new WebConsoleError("storage_corrupt", `Live input ${row.id} has no message.`, 500);
+                }
+                updateInput.run(now, row.id);
+                updateMessage.run(JSON.stringify(withLiveInputStatus(parseParts(persisted.parts_json), "queued")), now, row.message_id);
+            }
+            for (const threadId of threadIds) {
+                this.database.prepare("UPDATE threads SET updated_at = ?, revision = revision + 1 WHERE id = ?")
+                    .run(now, threadId);
+                this.recordThreadRevision(threadId, "live_inputs_recovered", now);
+            }
+        });
+    }
     finishTurn(turnId, status, finalText, errorCode, errorMessage, runtime) {
         const turn = this.requireTurn(turnId);
         const existing = this.requireMessage(turn.assistant_message_id);
@@ -582,6 +969,9 @@ export class WebStore {
             createdAt: row.created_at,
             updatedAt: row.updated_at,
             revision: row.revision,
+            ...(row.trigger_kind === "cron" || row.trigger_kind === "webhook"
+                ? { trigger: { kind: row.trigger_kind } }
+                : {}),
             ...(preview === undefined ? {} : { lastMessagePreview: preview }),
             messageCount: row.message_count,
             runState,
@@ -594,17 +984,20 @@ export class WebStore {
             .all(row.id);
         const storedParts = parseParts(row.parts_json);
         const quote = quoteFromParts(storedParts);
+        const liveInputStatus = liveInputStatusFromParts(storedParts);
         return {
             id: row.id,
             threadId: row.thread_id,
             ...(row.turn_id === null ? {} : { turnId: row.turn_id }),
             role: normalizeRole(row.role),
             ...(quote === undefined ? {} : { quote }),
-            parts: storedParts.filter((part) => part.type !== "telemetry" || part.event !== QUOTE_TELEMETRY_EVENT),
+            parts: storedParts.filter((part) => part.type !== "telemetry"
+                || (part.event !== QUOTE_TELEMETRY_EVENT && part.event !== LIVE_INPUT_TELEMETRY_EVENT)),
             attachments: attachments.map((attachment) => toWebAttachment(mapStoredAttachment(attachment))),
             createdAt: row.created_at,
             updatedAt: row.updated_at,
             status: normalizeMessageStatus(row.status),
+            ...(liveInputStatus === undefined ? {} : { liveInputStatus }),
         };
     }
     latestRunState(threadId) {
@@ -662,6 +1055,16 @@ export class WebStore {
             throw new WebConsoleError("message_not_found", "Message not found.", 404);
         return this.mapMessage(row);
     }
+    getLiveInput(id) {
+        return this.database.prepare("SELECT * FROM live_inputs WHERE id = ?")
+            .get(id);
+    }
+    requireLiveInput(id) {
+        const row = this.getLiveInput(id);
+        if (row === undefined)
+            throw new WebConsoleError("live_input_not_found", "Live input not found.", 404);
+        return row;
+    }
     requireStoredAttachment(id) {
         const attachment = this.getStoredAttachment(id);
         if (attachment === undefined)
@@ -695,7 +1098,7 @@ export class WebStore {
 }
 function threadSelectSql(suffix) {
     return `
-    SELECT t.id, t.source_id, t.title, t.archived_at, t.created_at, t.updated_at, t.revision,
+    SELECT t.id, t.source_id, t.title, t.trigger_kind, t.archived_at, t.created_at, t.updated_at, t.revision,
            CASE WHEN a.status = 'online' OR a.status = 'degraded' THEN 1 ELSE 0 END AS can_send,
            CASE WHEN (a.status = 'online' OR a.status = 'degraded') AND a.supports_attachments = 1 THEN 1 ELSE 0 END AS can_upload,
            (SELECT COUNT(*) FROM messages m WHERE m.thread_id = t.id) AS message_count
@@ -717,6 +1120,22 @@ function agentSelectSql(suffix) {
 function agentPinSettingKey(sourceId) {
     return `agent_pin:${sourceId}`;
 }
+function notificationThreadId(sourceId, deliveryKey) {
+    const digest = createHash("sha256")
+        .update(sourceId)
+        .update("\0")
+        .update(deliveryKey)
+        .digest("hex")
+        .slice(0, 32);
+    return `notification-${digest}`;
+}
+function notificationPayloadSha256(kind, text) {
+    return createHash("sha256")
+        .update(kind)
+        .update("\0")
+        .update(text)
+        .digest("hex");
+}
 function mapAgent(row) {
     const models = parseStringArray(row.models_json);
     const efforts = parseStringArray(row.efforts_json);
@@ -752,6 +1171,16 @@ function mapStoredAttachment(row) {
         updatedAt: row.updated_at,
     };
 }
+function mapLiveInput(row) {
+    return {
+        id: row.id,
+        threadId: row.thread_id,
+        messageId: row.message_id,
+        text: row.text,
+        status: row.status,
+        createdAt: row.created_at,
+    };
+}
 export function toWebAttachment(attachment) {
     return {
         id: attachment.id,
@@ -801,8 +1230,37 @@ function applyEvent(parts, event) {
         });
         return;
     }
+    if (event.type === "runtime_telemetry" && event.kind === "context_compaction") {
+        upsertContextCompaction(parts, event);
+        return;
+    }
     parts.push({ type: "telemetry", event: event.type, data: event });
 }
+function contextCompactionOperationId(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const event = value;
+    if (event.type !== "runtime_telemetry" || event.kind !== "context_compaction")
+        return undefined;
+    const data = event.data;
+    if (data === null || typeof data !== "object" || Array.isArray(data))
+        return undefined;
+    const operationId = data.operationId;
+    return typeof operationId === "string" && operationId.length > 0 ? operationId : undefined;
+}
+function upsertContextCompaction(parts, event) {
+    const operationId = contextCompactionOperationId(event);
+    const next = { type: "telemetry", event: event.type, data: event };
+    if (operationId === undefined) {
+        parts.push(next);
+        return;
+    }
+    const index = parts.findIndex((part) => part.type === "telemetry" && contextCompactionOperationId(part.data) === operationId);
+    if (index < 0)
+        parts.push(next);
+    else
+        parts[index] = next;
+}
 function existingToolName(parts, id) {
     const existing = parts.find((part) => part.type === "tool-call" && part.toolCallId === id);
     return existing?.type === "tool-call" ? existing.toolName : undefined;
@@ -897,6 +1355,33 @@ function parseParts(value) {
     return parsed;
 }
 const QUOTE_TELEMETRY_EVENT = "quote";
+const LIVE_INPUT_TELEMETRY_EVENT = "live_input";
+function liveInputTelemetry(status) {
+    return { type: "telemetry", event: LIVE_INPUT_TELEMETRY_EVENT, data: { status } };
+}
+function withoutLiveInputTelemetry(parts) {
+    return parts.filter((part) => part.type !== "telemetry" || part.event !== LIVE_INPUT_TELEMETRY_EVENT);
+}
+function withLiveInputStatus(parts, status) {
+    return [liveInputTelemetry(status), ...withoutLiveInputTelemetry(parts)];
+}
+function liveInputStatusFromParts(parts) {
+    const markers = parts.filter((part) => part.type === "telemetry" && part.event === LIVE_INPUT_TELEMETRY_EVENT);
+    if (markers.length === 0)
+        return undefined;
+    if (markers.length !== 1) {
+        throw new WebConsoleError("storage_corrupt", "Persisted live-input metadata is duplicated.", 500);
+    }
+    const data = markers[0]?.data;
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        throw new WebConsoleError("storage_corrupt", "Persisted live-input metadata is invalid.", 500);
+    }
+    const status = data.status;
+    if (status !== "pending" && status !== "applied" && status !== "queued" && status !== "cancelled") {
+        throw new WebConsoleError("storage_corrupt", "Persisted live-input status is invalid.", 500);
+    }
+    return status;
+}
 function quoteFromParts(parts) {
     const markers = parts.filter((part) => part.type === "telemetry" && part.event === QUOTE_TELEMETRY_EVENT);
     if (markers.length === 0)