@mono-agent/web 0.20.10 → 0.20.14

package/dist/store.js

@@ -3,7 +3,7 @@ import { chmod, lstat, readdir, unlink } from "node:fs/promises";
 import { resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { isDeepStrictEqual } from "node:util";
-import { AGENT_LIVE_INPUT_MAX_CHARACTERS, MAX_AGENT_REPLY_PARTS, classifyNotifySuppression, parseProcessJobProjection, } from "@mono-agent/agent-contracts";
+import { AGENT_LIVE_INPUT_MAX_CHARACTERS, AGENT_LIVE_INPUT_MAX_MESSAGES, MAX_AGENT_REPLY_PARTS, classifyNotifySuppression, parseMonitorProjection, parseProcessJobProjection, } 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 { webPushPreview } from "./push-preview.js";
@@ -118,7 +118,7 @@ export function messageSearchMatchExpression(raw) {
 export function escapeLikeTerm(raw) {
     return raw.replaceAll(/[\\%_]/gu, (character) => `\\${character}`);
 }
-const WEB_STORAGE_SCHEMA_VERSION = 9;
+const WEB_STORAGE_SCHEMA_VERSION = 15;
 const MAX_REVISIONS_PER_THREAD = 1_000;
 export const WEB_THREAD_PAGE_MAX = 200;
 export const WEB_MESSAGE_PAGE_MAX = 100;
@@ -133,6 +133,14 @@ export class WebStore {
     database;
     clock;
     closed = false;
+    /**
+     * The agent PROCESS generation each live summary was built from, by source
+     * id. Deliberately not a column: it describes the process behind a source id
+     * right now, so a value read back from disk after a console restart would be
+     * a claim about a process nobody probed. `replaceAgents` is the only writer,
+     * and it drops ids discovery no longer reports.
+     */
+    agentGenerations = new Map();
     constructor(database, paths, clock) {
         this.database = database;
         this.paths = paths;
@@ -179,24 +187,77 @@ export class WebStore {
         this.closed = true;
         this.database.close();
     }
+    /**
+     * Persist the discovered agent list. Returns whether the change is worth
+     * telling clients about.
+     *
+     * `updatedAt` is a heartbeat timestamp that moves on every discovery poll, so
+     * comparing it made this return `true` roughly once every five seconds. At the
+     * time, `agents.changed` carried the whole agent list, every model, every model
+     * option and every provider. Measured against a 67-agent fleet that was 60 KB
+     * per event and 99.5% of all SSE traffic: ~42 MiB/hour to an idle console with
+     * nobody using it. The event is now a compact invalidation, but a heartbeat is
+     * still not a state change worth making every browser re-bootstrap for.
+     *
+     * So the two questions are separated. Any difference at all is still written,
+     * because the store should hold the freshest heartbeat; only a difference that
+     * survives normalizing `updatedAt` is broadcast. Nothing in the console reads
+     * an agent's `updatedAt` --- it stays on the wire for clients that want it, it
+     * just no longer triggers a fleet-sized frame on its own. `agentGeneration()`
+     * already excludes it for the same reason.
+     */
     replaceAgents(agents) {
         const current = this.listAgents();
         const currentById = new Map(current.map((agent) => [agent.sourceId, agent]));
         const incomingIds = new Set(agents.map((agent) => agent.sourceId));
-        const changed = agents.some((agent) => {
+        const departed = current.some((agent) => !incomingIds.has(agent.sourceId) && agent.status !== "offline");
+        const differs = (agent, ignoreHeartbeat) => {
             const prior = currentById.get(agent.sourceId);
-            return prior === undefined || !isDeepStrictEqual(prior, { ...agent, pinned: prior.pinned });
-        }) || current.some((agent) => !incomingIds.has(agent.sourceId) && agent.status !== "offline");
-        if (!changed)
+            if (prior === undefined)
+                return true;
+            // `pinned` is store-owned and never arrives from discovery; normalizing it
+            // keeps a locally pinned agent from looking like an incoming change.
+            const next = { ...agent, pinned: prior.pinned };
+            if (!ignoreHeartbeat)
+                return !isDeepStrictEqual(prior, next);
+            return !isDeepStrictEqual({ ...prior, updatedAt: "" }, { ...next, updatedAt: "" });
+        };
+        const changed = agents.some((agent) => differs(agent, false)) || departed;
+        const notable = agents.some((agent) => differs(agent, true)) || departed;
+        // After `current` is read (it carries the PREVIOUS generations) and after
+        // both comparisons, so a restart behind an otherwise identical summary
+        // still reads as a change and still reaches the browser.
+        //
+        // And only once the row it describes is actually on disk. Advancing before
+        // the transaction made the map a claim the database had not agreed to: a
+        // transaction that threw left the NEW generation stitched onto the OLD row,
+        // so the retry compared the new summary against a prior that already
+        // carried its generation, found only `updatedAt` different, and returned
+        // `notable === false`. The restart broadcast was then lost permanently ---
+        // not deferred --- and an open console stayed stale until it reconnected.
+        const adoptGenerations = () => {
+            this.agentGenerations.clear();
+            for (const agent of agents) {
+                if (agent.generation !== undefined)
+                    this.agentGenerations.set(agent.sourceId, agent.generation);
+            }
+        };
+        if (!changed) {
+            // Nothing to persist, so there is nothing for the adoption to outrun:
+            // every incoming generation already equals the one it is replacing, or
+            // `changed` would be true. The map is still swept so a departed agent
+            // does not leave one behind.
+            adoptGenerations();
             return false;
+        }
         this.transaction(() => {
             this.database.prepare("UPDATE agents SET status = 'offline'").run();
             const statement = this.database.prepare(`
         INSERT INTO agents (
           source_id, label, status, health, supports_attachments, models_json,
           default_model, default_effort, efforts_json, model_options_json,
-          cron_read, cron_actions, ask_by_id, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          providers_json, cron_read, cron_actions, ask_by_id, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(source_id) DO UPDATE SET
           label = excluded.label,
           status = excluded.status,
@@ -207,24 +268,31 @@ export class WebStore {
           default_effort = excluded.default_effort,
           efforts_json = excluded.efforts_json,
           model_options_json = excluded.model_options_json,
+          providers_json = excluded.providers_json,
           cron_read = excluded.cron_read,
           cron_actions = excluded.cron_actions,
           ask_by_id = excluded.ask_by_id,
           updated_at = excluded.updated_at
       `);
             for (const agent of agents) {
-                statement.run(agent.sourceId, agent.label, agent.status, agent.health ?? null, agent.supportsAttachments ? 1 : 0, stringifyOptional(agent.models), agent.defaultModel ?? null, agent.defaultEffort ?? null, stringifyOptional(agent.efforts), stringifyOptional(agent.modelOptions), agent.cron?.read === true ? 1 : 0, agent.cron?.actions === true ? 1 : 0, agent.supportsAskById === true ? 1 : 0, agent.updatedAt);
+                statement.run(agent.sourceId, agent.label, agent.status, agent.health ?? null, agent.supportsAttachments ? 1 : 0, stringifyOptional(agent.models), agent.defaultModel ?? null, agent.defaultEffort ?? null, stringifyOptional(agent.efforts), stringifyOptional(agent.modelOptions), stringifyOptional(agent.providers), agent.cron?.read === true ? 1 : 0, agent.cron?.actions === true ? 1 : 0, agent.supportsAskById === true ? 1 : 0, agent.updatedAt);
             }
         });
-        return true;
+        adoptGenerations();
+        return notable;
     }
     listAgents() {
         const rows = this.database.prepare(agentSelectSql("ORDER BY pinned DESC, a.label COLLATE NOCASE, a.source_id")).all();
-        return rows.map(mapAgent);
+        return rows.map((row) => this.withGeneration(mapAgent(row)));
     }
     getAgent(sourceId) {
         const row = this.database.prepare(agentSelectSql("WHERE a.source_id = ?")).get(sourceId);
-        return row === undefined ? undefined : mapAgent(row);
+        return row === undefined ? undefined : this.withGeneration(mapAgent(row));
+    }
+    /** Stitch the live generation onto a row read back from disk. */
+    withGeneration(agent) {
+        const generation = this.agentGenerations.get(agent.sourceId);
+        return generation === undefined ? agent : { ...agent, generation };
     }
     setAgentPinned(sourceId, pinned) {
         if (this.getAgent(sourceId) === undefined) {
@@ -960,6 +1028,115 @@ export class WebStore {
       WHERE source_id = ? AND job_id = ? AND delivery_key = ? AND state = 'accepted'
     `).run(input.sourceId, input.jobId, input.deliveryKey);
     }
+    /** Durably claim one Monitor wake before touching the operator. */
+    reserveMonitorWake(input) {
+        const monitor = parseMonitorProjection(input.monitor);
+        if (monitor.monitorId !== input.monitorId) {
+            throw new WebConsoleError("invalid_notification", "The Monitor projection does not match its delivery identity.", 409);
+        }
+        const thread = this.database.prepare("SELECT source_id, archived_at, trigger_kind FROM threads WHERE id = ?")
+            .get(input.threadId);
+        if (thread === undefined || thread.source_id !== input.sourceId) {
+            throw new WebConsoleError("invalid_notification", "The Monitor wake does not match its web thread.", 409);
+        }
+        if (thread.archived_at !== null || thread.trigger_kind !== null) {
+            throw new WebConsoleError("thread_archived", "The Monitor wake destination is not an active web conversation.", 409);
+        }
+        const existing = this.database.prepare(`
+      SELECT monitor_id, thread_id, payload_sha256, state, disposition
+      FROM monitor_wake_deliveries WHERE source_id = ? AND delivery_key = ?
+    `).get(input.sourceId, input.deliveryKey);
+        if (existing !== undefined) {
+            if (existing.monitor_id !== input.monitorId
+                || existing.thread_id !== input.threadId
+                || existing.payload_sha256 !== input.payloadSha256) {
+                throw new WebConsoleError("notification_idempotency_conflict", "The Monitor delivery key was already used for a different wake.", 409);
+            }
+            if (existing.state === "completed"
+                && (existing.disposition === "steered" || existing.disposition === "follow_up")) {
+                return { kind: "completed", disposition: existing.disposition };
+            }
+            return { kind: "uncertain" };
+        }
+        this.database.prepare(`
+      INSERT INTO monitor_wake_deliveries (
+        source_id, monitor_id, delivery_key, thread_id, payload_sha256, projection_json,
+        state, disposition, turn_id, created_at, completed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, 'accepted', NULL, NULL, ?, NULL)
+    `).run(input.sourceId, input.monitorId, input.deliveryKey, input.threadId, input.payloadSha256, JSON.stringify(monitor), this.now());
+        return { kind: "new" };
+    }
+    completeMonitorWake(input) {
+        let messageId;
+        this.transaction(() => {
+            const result = this.database.prepare(`
+        UPDATE monitor_wake_deliveries
+        SET state = 'completed', disposition = ?, turn_id = ?, completed_at = ?
+        WHERE source_id = ? AND monitor_id = ? AND delivery_key = ? AND state = 'accepted'
+      `).run(input.disposition, input.turnId ?? null, this.now(), input.sourceId, input.monitorId, input.deliveryKey);
+            if (result.changes !== 1) {
+                throw new WebConsoleError("notification_reservation_lost", "The Monitor wake reservation was lost.", 409);
+            }
+            if (input.turnId === undefined)
+                return;
+            const turn = this.requireTurn(input.turnId);
+            const reservation = this.database.prepare(`
+        SELECT thread_id, projection_json FROM monitor_wake_deliveries
+        WHERE source_id = ? AND monitor_id = ? AND delivery_key = ?
+      `).get(input.sourceId, input.monitorId, input.deliveryKey);
+            if (reservation?.thread_id !== turn.thread_id) {
+                throw new WebConsoleError("monitor_origin_mismatch", "The Monitor activity does not belong to this turn.", 409);
+            }
+            if (reservation.projection_json === null)
+                return;
+            let projection;
+            try {
+                projection = parseMonitorProjection(JSON.parse(reservation.projection_json));
+                if (projection.monitorId !== input.monitorId)
+                    throw new TypeError("Monitor identity mismatch.");
+            }
+            catch {
+                throw new WebConsoleError("storage_corrupt", "A retained Monitor wake projection is invalid.", 500);
+            }
+            const message = this.requireMessage(turn.assistant_message_id);
+            const parts = [...message.parts];
+            if (!upsertMonitorActivity(parts, projection, input.deliveryKey))
+                return;
+            const now = this.now();
+            this.database.prepare("UPDATE messages SET parts_json = ?, updated_at = ? WHERE id = ?")
+                .run(serializeParts(parts), now, message.id);
+            messageId = message.id;
+        });
+        return messageId === undefined ? undefined : this.requireMessage(messageId);
+    }
+    /** Resolve only an exact Monitor live-input receipt belonging to this turn. */
+    monitorWakeProjection(turnId, deliveryKey) {
+        const row = this.database.prepare(`
+      SELECT deliveries.monitor_id, deliveries.projection_json
+      FROM monitor_wake_deliveries AS deliveries
+      JOIN turns ON turns.id = ? AND turns.thread_id = deliveries.thread_id
+      JOIN threads ON threads.id = turns.thread_id AND threads.source_id = deliveries.source_id
+      WHERE deliveries.delivery_key = ?
+    `).get(turnId, deliveryKey);
+        if (row === undefined || row.projection_json === null)
+            return undefined;
+        try {
+            const projection = parseMonitorProjection(JSON.parse(row.projection_json));
+            if (projection.monitorId !== row.monitor_id)
+                throw new TypeError("Monitor identity mismatch.");
+            return projection;
+        }
+        catch {
+            throw new WebConsoleError("storage_corrupt", "A retained Monitor wake projection is invalid.", 500);
+        }
+    }
+    /** Release a Monitor reservation only before any operator delivery begins. */
+    abandonMonitorWake(input) {
+        this.database.prepare(`
+      DELETE FROM monitor_wake_deliveries
+      WHERE source_id = ? AND monitor_id = ? AND delivery_key = ? AND state = 'accepted'
+    `).run(input.sourceId, input.monitorId, input.deliveryKey);
+    }
     /** Exact retained binding used before proxying a single operator job. */
     processJobCardBelongsToThread(sourceId, threadId, jobId) {
         return this.database.prepare(`
@@ -1234,14 +1411,44 @@ export class WebStore {
         this.setSetting("current_thread_id", resolved);
     }
     patchThread(id, patch) {
+        return this.transaction(() => this.writeThreadPatch(id, patch));
+    }
+    /**
+     * Compare-and-set: apply `patch` only while the conversation still carries no
+     * run override, and report which way it went.
+     *
+     * The console's one-time adoption of a browser-local override is the caller.
+     * Read and write are ONE `BEGIN IMMEDIATE` here rather than two statements
+     * either side of a service-level check: the process lease
+     * (`state-paths.ts`) is held on a different database file for the service
+     * lifetime, so it makes this process the only *service* writing, not this
+     * statement the only writer of `web.sqlite`. Any other connection to the
+     * state DB -- a maintenance script, a second console pointed at the same
+     * state dir -- could land between a bare read and a bare write, and did in a
+     * probe.
+     */
+    patchThreadIfRunConfigUnset(id, patch) {
+        return this.transaction(() => {
+            const resolved = this.resolveThreadId(id);
+            const current = this.requireThread(resolved);
+            if (current.runModel !== null || current.runEffort !== null) {
+                return { applied: false, thread: { ...current, sourceId: current.sourceId } };
+            }
+            return { applied: true, thread: this.writeThreadPatch(resolved, patch) };
+        });
+    }
+    /** The body of {@link patchThread}. Assumes an open transaction. */
+    writeThreadPatch(id, patch) {
         id = this.resolveThreadId(id);
         const current = this.requireThread(id);
         const now = this.now();
         const title = patch.title === undefined ? undefined : normalizeTitle(patch.title);
         const archivedAt = patch.archived === undefined ? undefined : patch.archived ? now : null;
-        this.transaction(() => {
-            const sets = ["updated_at = ?", "revision = revision + 1"];
-            const values = [now];
+        const runModel = patch.model === undefined ? undefined : patch.model;
+        const runEffort = patch.effort === undefined ? undefined : patch.effort;
+        {
+            const sets = [];
+            const values = [];
             if (title !== undefined) {
                 sets.push("title = ?", "title_manual = 1");
                 values.push(title);
@@ -1250,13 +1457,34 @@ export class WebStore {
                 sets.push("archived_at = ?");
                 values.push(archivedAt);
             }
+            if (runModel !== undefined) {
+                sets.push("run_model = ?");
+                values.push(runModel);
+            }
+            if (runEffort !== undefined) {
+                sets.push("run_effort = ?");
+                values.push(runEffort);
+            }
+            // A model/effort-only patch must not reorder the sidebar, so `updated_at`
+            // only advances when title or archived state actually changes.
+            if (title !== undefined || archivedAt !== undefined) {
+                sets.push("updated_at = ?");
+                values.push(now);
+            }
+            sets.push("revision = revision + 1");
             values.push(id);
             this.database.prepare(`UPDATE threads SET ${sets.join(", ")} WHERE id = ?`).run(...values);
-            this.recordThreadRevision(id, title !== undefined ? "title_changed" : patch.archived ? "archived" : "unarchived", now);
+            this.recordThreadRevision(id, title !== undefined
+                ? "title_changed"
+                : archivedAt !== undefined
+                    ? patch.archived
+                        ? "archived"
+                        : "unarchived"
+                    : "run_config_changed", now);
             if (patch.archived === true && this.currentThreadId() === id) {
                 this.database.prepare("DELETE FROM settings WHERE key = 'current_thread_id'").run();
             }
-        });
+        }
         return { ...this.requireThread(id), sourceId: current.sourceId };
     }
     /** Whether the current interactive thread still accepts agent-proposed titles. */
@@ -1361,6 +1589,34 @@ export class WebStore {
         const row = this.database.prepare("SELECT * FROM attachments WHERE id = ?").get(id);
         return row === undefined ? undefined : mapStoredAttachment(row);
     }
+    /**
+     * Durable copies are keyed by the part that produced them, so re-observing a
+     * message — a reconnect, a replay, a second read of the same thread — cannot
+     * store the same image twice.
+     */
+    static replyAttachmentId(messageId, partId) {
+        return `reply:${encodeURIComponent(messageId)}:${encodeURIComponent(partId)}`;
+    }
+    storedReplyAttachment(messageId, partId) {
+        const attachment = this.getStoredAttachment(WebStore.replyAttachmentId(messageId, partId));
+        return attachment?.origin === "reply" ? attachment : undefined;
+    }
+    /**
+     * Records an already-written durable copy. Committed on arrival and bound to
+     * its thread, so the staged-upload purge and the staged-only delete route both
+     * pass it over, while the thread's own delete cascade still reclaims it.
+     */
+    recordReplyAttachment(input) {
+        const id = WebStore.replyAttachmentId(input.messageId, input.partId);
+        const now = this.now();
+        this.database.prepare(`
+      INSERT INTO attachments (
+        id, thread_id, message_id, name, content_type, size_bytes, kind,
+        status, uploaded, origin, storage_name, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, 'image', 'committed', 1, 'reply', ?, ?, ?)
+    `).run(id, input.threadId, input.messageId, input.name, input.contentType, input.sizeBytes, input.storageName, now, now);
+        return this.requireStoredAttachment(id);
+    }
     stagedUploadUsage() {
         const row = this.database.prepare(`
       SELECT COUNT(*) AS count, COALESCE(SUM(size_bytes), 0) AS bytes
@@ -1562,7 +1818,7 @@ export class WebStore {
           id, thread_id, status, text, model, effort, assistant_message_id,
           started_at, finished_at, error_code, error_message
         ) VALUES (?, ?, 'running', ?, NULL, NULL, ?, ?, NULL, NULL, NULL)
-      `).run(turnId, threadId, input.prompt, assistantMessageId, now);
+      `).run(turnId, threadId, input.storedPrompt ?? input.prompt, assistantMessageId, now);
             this.database.prepare(`
         INSERT INTO messages (id, thread_id, turn_id, role, parts_json, created_at, updated_at, status)
         VALUES (?, ?, ?, 'assistant', '[]', ?, ?, 'running')
@@ -1782,7 +2038,7 @@ export class WebStore {
                 replaceWholeText(parts, frame.text);
             }
             else if (frame.kind === "event") {
-                applyEvent(parts, frame.event);
+                applyEvent(parts, frame.event, (deliveryKey) => this.monitorWakeProjection(turnId, deliveryKey));
                 if (frame.event.type === "runtime_telemetry" && frame.event.kind === "run_config") {
                     if (typeof frame.event.data?.model === "string")
                         actualModel = frame.event.data.model;
@@ -1806,9 +2062,9 @@ export class WebStore {
         });
         return this.requireMessage(message.id);
     }
-    completeTurn(turnId, finalText, metadata, replyParts) {
+    completeTurn(turnId, finalText, metadata, replyParts, options = {}) {
         const runtime = runtimeMetadata(metadata);
-        return this.finishTurn(turnId, "complete", finalText, undefined, undefined, runtime, replyParts);
+        return this.finishTurn(turnId, "complete", finalText, undefined, undefined, runtime, replyParts, options.suppressResponsePush === true);
     }
     failTurn(turnId, error) {
         return this.finishTurn(turnId, error.cancelled === true ? "cancelled" : "failed", undefined, error.code, error.message, undefined);
@@ -2179,6 +2435,7 @@ export class WebStore {
         default_effort TEXT,
         efforts_json TEXT,
         model_options_json TEXT,
+        providers_json TEXT,
         cron_read INTEGER NOT NULL DEFAULT 0,
         cron_actions INTEGER NOT NULL DEFAULT 0,
         ask_by_id INTEGER NOT NULL DEFAULT 0,
@@ -2194,6 +2451,8 @@ export class WebStore {
         archived_at TEXT,
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL,
+        run_model TEXT,
+        run_effort TEXT,
         revision INTEGER NOT NULL DEFAULT 1
       );
       CREATE TABLE IF NOT EXISTS turns (
@@ -2246,6 +2505,7 @@ export class WebStore {
         kind TEXT NOT NULL,
         status TEXT NOT NULL,
         uploaded INTEGER NOT NULL DEFAULT 0,
+        origin TEXT NOT NULL DEFAULT 'upload' CHECK (origin IN ('upload', 'reply')),
         storage_name TEXT NOT NULL UNIQUE,
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL
@@ -2295,6 +2555,22 @@ export class WebStore {
       );
       CREATE INDEX IF NOT EXISTS process_job_wake_deliveries_by_thread
         ON process_job_wake_deliveries(thread_id, created_at);
+      CREATE TABLE IF NOT EXISTS monitor_wake_deliveries (
+        source_id TEXT NOT NULL REFERENCES agents(source_id),
+        monitor_id TEXT NOT NULL,
+        delivery_key TEXT NOT NULL,
+        thread_id TEXT REFERENCES threads(id) ON DELETE SET NULL,
+        payload_sha256 TEXT NOT NULL,
+        projection_json TEXT,
+        state TEXT NOT NULL CHECK (state IN ('accepted', 'completed')),
+        disposition TEXT CHECK (disposition IN ('steered', 'follow_up')),
+        turn_id TEXT REFERENCES turns(id) ON DELETE SET NULL,
+        created_at TEXT NOT NULL,
+        completed_at TEXT,
+        PRIMARY KEY (source_id, delivery_key)
+      );
+      CREATE INDEX IF NOT EXISTS monitor_wake_deliveries_by_thread
+        ON monitor_wake_deliveries(thread_id, created_at);
       CREATE TABLE IF NOT EXISTS cron_channels (
         source_id TEXT NOT NULL REFERENCES agents(source_id),
         job_id TEXT NOT NULL,
@@ -2438,6 +2714,51 @@ export class WebStore {
                 // database and idempotent if the sweep is ever re-run.
                 if (versionRow.user_version < 9)
                     this.database.exec(MESSAGE_SEARCH_BACKFILL_SQL);
+                // Durable copies of agent-published images share the upload table so that
+                // thread deletion, archival file cleanup, and every existing purge surface
+                // reach them without a second store to keep in sync.
+                if (versionRow.user_version < 10) {
+                    const columns = new Set(this.database.prepare("PRAGMA table_info(attachments)").all()
+                        .map((column) => column.name));
+                    if (!columns.has("origin")) {
+                        this.database.exec("ALTER TABLE attachments ADD COLUMN origin TEXT NOT NULL DEFAULT 'upload' CHECK (origin IN ('upload', 'reply'))");
+                    }
+                }
+                // Per-conversation model/effort overrides are server-persisted columns.
+                // Guard on PRAGMA table_info so the ALTER is skipped when the columns
+                // already exist, keeping the migration re-runnable.
+                if (versionRow.user_version < 11) {
+                    const columns = new Set(this.database.prepare("PRAGMA table_info(threads)").all()
+                        .map((column) => column.name));
+                    if (!columns.has("run_model")) {
+                        this.database.exec("ALTER TABLE threads ADD COLUMN run_model TEXT");
+                    }
+                    if (!columns.has("run_effort")) {
+                        this.database.exec("ALTER TABLE threads ADD COLUMN run_effort TEXT");
+                    }
+                }
+                // The provider summary an agent advertises. Guarded on PRAGMA
+                // table_info so the ALTER is skipped when the column already exists,
+                // keeping the migration re-runnable after an interrupted upgrade.
+                if (versionRow.user_version < 12) {
+                    const columns = new Set(this.database.prepare("PRAGMA table_info(agents)").all()
+                        .map((column) => column.name));
+                    if (!columns.has("providers_json")) {
+                        this.database.exec("ALTER TABLE agents ADD COLUMN providers_json TEXT");
+                    }
+                }
+                // Schema v13 tied the Monitor idempotency ledger to the conversation
+                // with ON DELETE CASCADE. That erased the tombstone and allowed a
+                // delivery key to name different content after thread deletion.
+                if (versionRow.user_version === 13)
+                    this.migrateMonitorWakeDeliveries();
+                if (versionRow.user_version < 15) {
+                    const columns = new Set(this.database.prepare("PRAGMA table_info(monitor_wake_deliveries)").all()
+                        .map((column) => column.name));
+                    if (!columns.has("projection_json")) {
+                        this.database.exec("ALTER TABLE monitor_wake_deliveries ADD COLUMN projection_json TEXT");
+                    }
+                }
                 if (migrating)
                     this.database.exec(`PRAGMA user_version = ${WEB_STORAGE_SCHEMA_VERSION}; COMMIT`);
             }
@@ -2454,6 +2775,36 @@ export class WebStore {
             throw new WebConsoleError("storage_corrupt", `Unable to initialize web state: ${error instanceof Error ? error.message : String(error)}`, 500);
         }
     }
+    /** Preserve Monitor delivery tombstones while making deleted threads threadless. */
+    migrateMonitorWakeDeliveries() {
+        this.database.exec(`
+      CREATE TABLE monitor_wake_deliveries_v14 (
+        source_id TEXT NOT NULL REFERENCES agents(source_id),
+        monitor_id TEXT NOT NULL,
+        delivery_key TEXT NOT NULL,
+        thread_id TEXT REFERENCES threads(id) ON DELETE SET NULL,
+        payload_sha256 TEXT NOT NULL,
+        projection_json TEXT,
+        state TEXT NOT NULL CHECK (state IN ('accepted', 'completed')),
+        disposition TEXT CHECK (disposition IN ('steered', 'follow_up')),
+        turn_id TEXT REFERENCES turns(id) ON DELETE SET NULL,
+        created_at TEXT NOT NULL,
+        completed_at TEXT,
+        PRIMARY KEY (source_id, delivery_key)
+      );
+      INSERT INTO monitor_wake_deliveries_v14 (
+        source_id, monitor_id, delivery_key, thread_id, payload_sha256, projection_json,
+        state, disposition, turn_id, created_at, completed_at
+      ) SELECT
+        source_id, monitor_id, delivery_key, thread_id, payload_sha256, NULL,
+        state, disposition, turn_id, created_at, completed_at
+      FROM monitor_wake_deliveries;
+      DROP TABLE monitor_wake_deliveries;
+      ALTER TABLE monitor_wake_deliveries_v14 RENAME TO monitor_wake_deliveries;
+      CREATE INDEX monitor_wake_deliveries_by_thread
+        ON monitor_wake_deliveries(thread_id, created_at);
+    `);
+    }
     /**
      * Schema-v5 adoption runs after every older fixup inside the same
      * BEGIN IMMEDIATE transaction. Each operation is guarded by the resulting
@@ -2603,6 +2954,8 @@ export class WebStore {
             "revisions",
             "settings",
             "notification_deliveries",
+            "process_job_wake_deliveries",
+            "monitor_wake_deliveries",
             "cron_channels",
             "cron_channel_deletions",
             "cron_overviews",
@@ -2630,6 +2983,21 @@ export class WebStore {
                 throw new WebConsoleError("storage_corrupt", `Message ${message.id} contains invalid persisted parts.`, 500);
             }
         }
+        const monitorProjections = this.database.prepare(`
+      SELECT monitor_id, projection_json
+      FROM monitor_wake_deliveries
+      WHERE projection_json IS NOT NULL
+    `).all();
+        for (const row of monitorProjections) {
+            try {
+                const projection = parseMonitorProjection(JSON.parse(row.projection_json));
+                if (projection.monitorId !== row.monitor_id)
+                    throw new TypeError("Monitor identity mismatch.");
+            }
+            catch {
+                throw new WebConsoleError("storage_corrupt", "A retained Monitor wake projection is invalid.", 500);
+            }
+        }
     }
     /**
      * Index the messages the streaming gate skipped and nothing settled — the
@@ -2687,17 +3055,17 @@ export class WebStore {
       WHERE status = 'sending'
     `).run(now, now);
     }
-    finishTurn(turnId, status, finalText, errorCode, errorMessage, runtime, replyParts) {
+    finishTurn(turnId, status, finalText, errorCode, errorMessage, runtime, replyParts, suppressResponsePush = false) {
         const turn = this.requireTurn(turnId);
         if (turn.status !== "running") {
             return this.requireThreadDetail(turn.thread_id);
         }
         this.transaction(() => {
-            this.finishTurnInTransaction(turnId, status, finalText, errorCode, errorMessage, runtime, replyParts);
+            this.finishTurnInTransaction(turnId, status, finalText, errorCode, errorMessage, runtime, replyParts, suppressResponsePush);
         });
         return this.requireThreadDetail(turn.thread_id);
     }
-    finishTurnInTransaction(turnId, status, finalText, errorCode, errorMessage, runtime, replyParts) {
+    finishTurnInTransaction(turnId, status, finalText, errorCode, errorMessage, runtime, replyParts, suppressResponsePush = false) {
         const turn = this.requireTurn(turnId);
         if (turn.status !== "running")
             return;
@@ -2729,7 +3097,9 @@ export class WebStore {
         // Projected cron turns are agent-owned scheduler state. Restart recovery
         // still settles the local projection, but only web-owned turns may emit a
         // Web Push terminal notification from this service.
-        if (thread.trigger?.kind !== "cron" && recentEnoughForRecoveredInterruption) {
+        if (thread.trigger?.kind !== "cron"
+            && recentEnoughForRecoveredInterruption
+            && !(status === "complete" && suppressResponsePush)) {
             const kind = status === "complete"
                 ? "response.ready"
                 : status === "cancelled"
@@ -2792,10 +3162,13 @@ export class WebStore {
             runState,
             canSend: row.can_send === 1,
             canUpload: row.can_upload === 1,
+            runModel: row.run_model,
+            runEffort: row.run_effort,
         };
     }
     mapMessage(row) {
-        const attachments = this.database.prepare("SELECT * FROM attachments WHERE message_id = ? ORDER BY created_at, id")
+        const attachments = this.database
+            .prepare("SELECT * FROM attachments WHERE message_id = ? AND origin = 'upload' ORDER BY created_at, id")
             .all(row.id);
         const storedParts = parseParts(row.parts_json);
         const quote = quoteFromParts(storedParts);
@@ -3084,6 +3457,7 @@ function isValidVapidKeyPair(publicKey, privateKey) {
 function threadSelectSql(suffix) {
     return `
     SELECT t.id, t.source_id, t.title, t.title_manual, t.trigger_kind, t.archived_at, t.created_at, t.updated_at, t.revision,
+           t.run_model, t.run_effort,
            cc.job_id AS cron_job_id, cc.configured AS cron_configured,
            CASE WHEN t.trigger_kind = 'cron' THEN 0
                 WHEN a.status = 'online' OR a.status = 'degraded' THEN 1 ELSE 0 END AS can_send,
@@ -3420,6 +3794,7 @@ function mapAgent(row) {
     const models = parseStringArray(row.models_json);
     const efforts = parseStringArray(row.efforts_json);
     const modelOptions = parseRecord(row.model_options_json);
+    const providers = parseProviderSummary(row.providers_json);
     return {
         sourceId: row.source_id,
         label: row.label,
@@ -3432,6 +3807,7 @@ function mapAgent(row) {
         ...(row.default_effort === null ? {} : { defaultEffort: row.default_effort }),
         ...(efforts === undefined ? {} : { efforts }),
         ...(modelOptions === undefined ? {} : { modelOptions }),
+        ...(providers === undefined ? {} : { providers }),
         ...(row.cron_read === 1
             ? { cron: { read: true, actions: row.cron_actions === 1 } }
             : {}),
@@ -3450,6 +3826,7 @@ function mapStoredAttachment(row) {
         kind: row.kind === "image" ? "image" : "document",
         status: row.status === "committed" ? "committed" : "staged",
         uploaded: row.uploaded === 1,
+        origin: row.origin === "reply" ? "reply" : "upload",
         storageName: row.storage_name,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
@@ -3478,12 +3855,26 @@ export function toWebAttachment(attachment) {
         ...(attachment.uploaded ? { contentUrl: `/api/v1/uploads/${encodeURIComponent(attachment.id)}/content` } : {}),
     };
 }
-function applyEvent(parts, event) {
+function appliedMonitorWake(event, resolveMonitorWake) {
+    if (resolveMonitorWake === undefined
+        || event.metadata?.liveInput !== true
+        || event.metadata?.synthetic !== true
+        || typeof event.metadata.inputId !== "string") {
+        return undefined;
+    }
+    const projection = resolveMonitorWake(event.metadata.inputId);
+    return projection === undefined
+        ? undefined
+        : { deliveryKey: event.metadata.inputId, projection };
+}
+function applyEvent(parts, event, resolveMonitorWake) {
     if (event.type === "assistant_thought") {
         appendTextPart(parts, "reasoning", event.text);
         return;
     }
     if (event.type === "tool_call_started") {
+        if (appliedMonitorWake(event, resolveMonitorWake) !== undefined)
+            return;
         const historyUpdate = canonicalEventHistoryUpdate(event.history);
         const subagent = subagentOf(event);
         if (subagent !== undefined) {
@@ -3525,6 +3916,11 @@ function applyEvent(parts, event) {
         return;
     }
     if (event.type === "tool_call_completed") {
+        const monitorWake = appliedMonitorWake(event, resolveMonitorWake);
+        if (monitorWake !== undefined) {
+            upsertMonitorActivity(parts, monitorWake.projection, monitorWake.deliveryKey);
+            return;
+        }
         const status = event.isError === true ? "failed" : "complete";
         const historyUpdate = canonicalEventHistoryUpdate(event.history);
         const executionMs = canonicalExecutionMs(event.executionMs);
@@ -3585,6 +3981,33 @@ function applyEvent(parts, event) {
     }
     parts.push({ type: "telemetry", event: event.type, data: event });
 }
+function upsertMonitorActivity(parts, projection, deliveryKey) {
+    const index = parts.findIndex((part) => part.type === "monitor-activity");
+    const previous = index < 0 ? undefined : parts[index];
+    const monitors = previous?.monitors ?? [];
+    const monitorIndex = monitors.findIndex((entry) => entry.projection.monitorId === projection.monitorId);
+    const prior = monitorIndex < 0 ? undefined : monitors[monitorIndex];
+    // The stream receipt and the durable delivery settlement can race. Once an
+    // exact key is present, settlement is bookkeeping only: replacing its newer
+    // projection with the reservation's older snapshot would make the activity
+    // row move backwards and emit a duplicate invalidation.
+    if (prior?.deliveryKeys.includes(deliveryKey) === true)
+        return false;
+    const deliveryKeys = prior === undefined ? [deliveryKey] : [...prior.deliveryKeys, deliveryKey];
+    const entry = { projection, deliveryKeys };
+    const nextMonitors = monitorIndex < 0
+        ? [...monitors, entry]
+        : monitors.map((value, at) => at === monitorIndex ? entry : value);
+    const next = { type: "monitor-activity", monitors: nextMonitors };
+    if (index < 0) {
+        parts.push(next);
+        return true;
+    }
+    if (isDeepStrictEqual(previous, next))
+        return false;
+    parts[index] = next;
+    return true;
+}
 function contextCompactionOperationId(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         return undefined;
@@ -3740,19 +4163,26 @@ function upsertToolCall(parts, next, historyUpdate) {
         parts[index] = updated;
 }
 /**
- * Whether a stored part reaches the transcript at all. The console renders
- * exactly one kind of telemetry — context compaction — and drops the rest in
- * `convertPart`, so every other telemetry part is invisible between two runs of
- * prose.
+ * Whether a stored part marks a semantic boundary between streamed text runs.
+ * Most telemetry remains invisible; compaction and the content-free assistant
+ * message marker intentionally keep adjacent provider responses separate.
  */
-function isRenderedPart(part) {
+function separatesStreamedText(part) {
+    // A Monitor acknowledgement may arrive while the provider is still flushing
+    // the preceding message's final text delta. Its compact activity row must not
+    // split that word; the explicit message boundary below separates responses.
+    if (part.type === "monitor-activity")
+        return false;
     if (part.type !== "telemetry")
         return true;
     const event = part.data;
     if (event === null || typeof event !== "object" || Array.isArray(event))
         return false;
     const record = event;
-    return record.type === "runtime_telemetry" && record.kind === "context_compaction";
+    return record.type === "runtime_telemetry"
+        && (record.kind === "context_compaction"
+            || record.kind === "context_usage"
+            || record.kind === "assistant_message_boundary");
 }
 /**
  * Append a streamed delta to the trailing run of `type`.
@@ -3771,7 +4201,7 @@ function appendTextPart(parts, type, delta) {
         const part = parts[index];
         if (part === undefined)
             break;
-        if (!isRenderedPart(part))
+        if (!separatesStreamedText(part))
             continue;
         if (part.type !== type)
             break;
@@ -4189,6 +4619,9 @@ function parseParts(value) {
     if (!Array.isArray(parts) || !parts.every(isWebMessagePart)) {
         throw new WebConsoleError("storage_corrupt", "Persisted message parts have an invalid shape.", 500);
     }
+    if (parts.filter((part) => part.type === "monitor-activity").length > 1) {
+        throw new WebConsoleError("storage_corrupt", "Persisted Monitor activity is duplicated.", 500);
+    }
     quoteFromParts(parts);
     return parts;
 }
@@ -4412,6 +4845,50 @@ function isWebMessagePart(value) {
             return false;
         }
     }
+    if (part.type === "monitor-activity") {
+        if (!hasOnlyKeys(part, new Set(["type", "monitors"]))
+            || !Array.isArray(part.monitors)
+            || part.monitors.length === 0
+            || part.monitors.length > AGENT_LIVE_INPUT_MAX_MESSAGES) {
+            return false;
+        }
+        const monitorIds = new Set();
+        let deliveryCount = 0;
+        for (const raw of part.monitors) {
+            if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+                return false;
+            const entry = raw;
+            if (!hasOnlyKeys(entry, new Set(["projection", "deliveryKeys"])) || !Array.isArray(entry.deliveryKeys)) {
+                return false;
+            }
+            let projection;
+            try {
+                projection = parseMonitorProjection(entry.projection);
+            }
+            catch {
+                return false;
+            }
+            if (monitorIds.has(projection.monitorId)
+                || entry.deliveryKeys.length === 0
+                || entry.deliveryKeys.length > AGENT_LIVE_INPUT_MAX_MESSAGES) {
+                return false;
+            }
+            monitorIds.add(projection.monitorId);
+            const keys = new Set();
+            for (const key of entry.deliveryKeys) {
+                if (typeof key !== "string"
+                    || key.length === 0
+                    || key.length > 1_024
+                    || /[\u0000-\u001f\u007f]/u.test(key)
+                    || keys.has(key)) {
+                    return false;
+                }
+                keys.add(key);
+            }
+            deliveryCount += entry.deliveryKeys.length;
+        }
+        return deliveryCount <= AGENT_LIVE_INPUT_MAX_MESSAGES;
+    }
     if (part.type === "telemetry")
         return typeof part.event === "string";
     if (part.type === "error")
@@ -4534,6 +5011,38 @@ function parseStringArray(value) {
         return undefined;
     }
 }
+/**
+ * Malformed stored JSON must degrade to "this agent advertises no providers",
+ * never throw: `mapAgent` runs on every bootstrap and discovery read, so a
+ * throw here would take the whole console down over one bad row.
+ */
+function parseProviderSummary(value) {
+    if (value === null)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+    if (!Array.isArray(parsed))
+        return undefined;
+    const result = [];
+    for (const raw of parsed) {
+        if (typeof raw !== "object" || raw === null)
+            continue;
+        const entry = raw;
+        if (typeof entry.id !== "string" || entry.id.length === 0)
+            continue;
+        result.push({
+            id: entry.id,
+            label: typeof entry.label === "string" && entry.label.length > 0 ? entry.label : entry.id,
+            ...(entry.configured === true ? { configured: true } : {}),
+        });
+    }
+    return result.length === 0 ? undefined : result;
+}
 function parseRecord(value) {
     if (value === null)
         return undefined;