@mono-agent/web 0.20.11 → 0.21.0

package/dist/store.js

@@ -3,15 +3,20 @@ 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 { normalizeMonitorTerminalReply, hasMonitorReplyContent, monitorReplyText } from "./monitor-reply.js";
+import { AGENT_CONTEXT_IMPORT_SYSTEM_PROVENANCE, AGENT_LIVE_INPUT_MAX_CHARACTERS, AGENT_LIVE_INPUT_MAX_MESSAGES, MAX_AGENT_REPLY_PARTS, classifyNotifySuppression, NOTHING_TO_REPORT_SENTINEL, 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 { formatCronReplyContext } from "./cron-reply-context.js";
 import { WebConsoleError } from "./errors.js";
+import { runWebStorageMigrations, validateWebStorageMigrationRegistry, WEB_STORAGE_SCHEMA_VERSION } from "./store-migrations.js";
 import { webPushPreview } from "./push-preview.js";
 import { prepareWebStatePaths } from "./state-paths.js";
 /**
  * The searchable text of one message row, derived in SQL so the index cannot
  * drift from `parts_json`: every write path in this store goes through the
- * triggers below rather than remembering to maintain a second copy.
+ * triggers below rather than remembering to maintain a second copy. Legacy
+ * Monitor history gets an association-verified projection repair at open; its
+ * canonical parts remain untouched.
  *
  * Only `text` parts are indexed. Reasoning is the agent's working-out and tool
  * payloads are machine JSON; both would drown a search of what was actually
@@ -118,10 +123,26 @@ export function messageSearchMatchExpression(raw) {
 export function escapeLikeTerm(raw) {
     return raw.replaceAll(/[\\%_]/gu, (character) => `\\${character}`);
 }
-const WEB_STORAGE_SCHEMA_VERSION = 10;
 const MAX_REVISIONS_PER_THREAD = 1_000;
 export const WEB_THREAD_PAGE_MAX = 200;
+/**
+ * What one page is when the caller does not say.
+ *
+ * A sidebar shows a handful of conversations and pages from there, so both the
+ * bootstrap's bucket and the thread-list route answer with this rather than the
+ * whole per-bucket cap.
+ */
+export const WEB_THREAD_PAGE_DEFAULT = 50;
 export const WEB_MESSAGE_PAGE_MAX = 100;
+/**
+ * What one page of a transcript is when the caller does not say.
+ *
+ * A conversation read used to answer with the whole cap, which on a tool-heavy
+ * thread is hundreds of kilobytes the viewport never shows. The console renders
+ * the tail and pages backwards from `messagesNextCursor`, so the default is the
+ * screenful rather than the ceiling.
+ */
+export const WEB_MESSAGE_PAGE_DEFAULT = 30;
 const MAX_ACTIVE_PUSH_SUBSCRIPTIONS = 32;
 const MAX_PENDING_PUSH_DELIVERIES_PER_SUBSCRIPTION = 200;
 const PUSH_RETENTION_MS = 30 * 24 * 60 * 60 * 1_000;
@@ -133,6 +154,22 @@ 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();
+    /**
+     * `writeMessageParts` statements by the columns they assign. A streaming
+     * answer is written every ~50 ms and the SET list is one of a handful of
+     * shapes, so preparing each shape once keeps the hot path off the SQL
+     * compiler. Keyed by the generated SQL, which is derived solely from which
+     * columns the caller moves.
+     */
+    partsWriteStatements = new Map();
     constructor(database, paths, clock) {
         this.database = database;
         this.paths = paths;
@@ -166,6 +203,7 @@ export class WebStore {
             // After recovery, so anything the recovery settled is already indexed by
             // its own trigger and this only sweeps what genuinely stayed running.
             store.reindexUnsettledMessages();
+            store.reindexLegacyMonitorMessages();
             return store;
         }
         catch (error) {
@@ -177,54 +215,147 @@ export class WebStore {
         if (this.closed)
             return;
         this.closed = true;
+        // Drop the cached statements first: they hold native handles onto the
+        // connection this is about to close.
+        this.partsWriteStatements.clear();
         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) => {
+        // Presence is separate from reachability. An offline summary still belongs
+        // in the picker because discovery found its source; an omitted source does
+        // not, even when it was already offline before it disappeared.
+        const departed = current.some((agent) => !incomingIds.has(agent.sourceId));
+        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, runSettings: prior.runSettings };
+            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();
+            // Rows stay as foreign-key parents for retained conversations and
+            // delivery ledgers. Discovery presence controls whether they are part of
+            // the live console projection; it is restored by the upsert below when a
+            // source id returns.
+            this.database.prepare("UPDATE agents SET status = 'offline', discovered = 0 WHERE discovered = 1").run();
             const statement = this.database.prepare(`
         INSERT INTO agents (
-          source_id, label, status, health, supports_attachments, models_json,
+          source_id, label, status, discovered, health, supports_attachments, supports_provider_auth, 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 (?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(source_id) DO UPDATE SET
           label = excluded.label,
           status = excluded.status,
+          discovered = 1,
           health = excluded.health,
           supports_attachments = excluded.supports_attachments,
+          supports_provider_auth = excluded.supports_provider_auth,
           models_json = excluded.models_json,
           default_model = excluded.default_model,
           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, agent.supportsProviderAuth === true ? 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);
             }
         });
+        adoptGenerations();
+        return notable;
+    }
+    /**
+     * A failed registry walk is not an authoritative empty registry. Keep every
+     * currently discovered source in the console, but make its lack of a live
+     * connection explicit until a later successful discovery reconciles it.
+     */
+    markDiscoveredAgentsOffline() {
+        const changed = this.listAgents().some((agent) => agent.status !== "offline");
+        this.agentGenerations.clear();
+        if (!changed)
+            return false;
+        this.database.prepare(`
+      UPDATE agents SET status = 'offline'
+      WHERE discovered = 1 AND status != 'offline'
+    `).run();
         return true;
     }
     listAgents() {
-        const rows = this.database.prepare(agentSelectSql("ORDER BY pinned DESC, a.label COLLATE NOCASE, a.source_id")).all();
-        return rows.map(mapAgent);
+        const rows = this.database.prepare(agentSelectSql("WHERE a.discovered = 1 ORDER BY pinned DESC, a.label COLLATE NOCASE, a.source_id")).all();
+        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);
+        const row = this.database.prepare(agentSelectSql("WHERE a.source_id = ? AND a.discovered = 1")).get(sourceId);
+        return row === undefined ? undefined : this.withGeneration(mapAgent(row));
+    }
+    getStoredAgent(sourceId) {
+        const row = this.database.prepare(agentSelectSql("WHERE a.source_id = ?"))
+            .get(sourceId);
+        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) {
@@ -240,6 +371,30 @@ export class WebStore {
             throw new WebConsoleError("agent_not_found", "The selected agent is no longer available.", 404);
         return agent;
     }
+    setAgentRunOverride(sourceId, override) {
+        if (this.getAgent(sourceId) === undefined) {
+            throw new WebConsoleError("agent_not_found", "The selected agent is no longer available.", 404);
+        }
+        if (override.model === null && override.effort === null) {
+            throw new WebConsoleError("invalid_request", "Choose a model or effort override, or use Revert to config.", 400);
+        }
+        this.database.prepare(`
+      INSERT INTO agent_run_overrides (source_id, model, effort, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(source_id) DO UPDATE SET
+        model = excluded.model,
+        effort = excluded.effort,
+        updated_at = excluded.updated_at
+    `).run(sourceId, override.model, override.effort, this.now());
+        return this.getAgent(sourceId);
+    }
+    clearAgentRunOverride(sourceId) {
+        if (this.getAgent(sourceId) === undefined) {
+            throw new WebConsoleError("agent_not_found", "The selected agent is no longer available.", 404);
+        }
+        this.database.prepare("DELETE FROM agent_run_overrides WHERE source_id = ?").run(sourceId);
+        return this.getAgent(sourceId);
+    }
     reserveNotification(input) {
         if (this.getAgent(input.sourceId) === undefined) {
             throw new WebConsoleError("agent_not_found", "The notification agent is no longer available.", 404);
@@ -356,6 +511,14 @@ export class WebStore {
         let turnId = randomUUID();
         let assistantMessageId = randomUUID();
         let completedThreadId = existing.thread_id;
+        /**
+         * Whether this completion actually MOVED the assistant row.
+         *
+         * A notification that maps onto a cron run whose message already carries
+         * this text writes nothing at all, and naming the row anyway costs every
+         * subscribed console one message read for a transcript that did not change.
+         */
+        let wroteMessage = false;
         this.transaction(() => {
             const cronChannel = reservation.jobId === undefined
                 ? undefined
@@ -406,21 +569,26 @@ export class WebStore {
             id, thread_id, turn_id, role, parts_json, created_at, updated_at, status
           ) VALUES (?, ?, ?, 'assistant', ?, ?, ?, 'complete')
         `).run(assistantMessageId, completedThreadId, turnId, serializeParts([{ type: "text", text: reservation.text }]), now, now);
+                wroteMessage = true;
             }
             else {
                 turnId = mappedRun.turn_id;
                 assistantMessageId = mappedRun.message_id;
                 const message = this.database.prepare(`
-          SELECT parts_json FROM messages WHERE id = ? AND thread_id = ? AND turn_id = ?
+          SELECT parts_json, cron_suppressed FROM messages WHERE id = ? AND thread_id = ? AND turn_id = ?
         `).get(assistantMessageId, completedThreadId, turnId);
                 if (message === undefined) {
                     throw new WebConsoleError("storage_corrupt", "A cron run mapping is missing its message.", 500);
                 }
-                const parts = parseParts(message.parts_json);
-                if (!parts.some((part) => part.type === "text" && part.text === reservation.text)) {
+                const parts = parseParts(message.parts_json).filter((part) => !(part.type === "text" && isSyntheticCronStateText(part.text)))
+                    .map((part) => part.type === "telemetry" && part.event === "cron_run"
+                    ? { ...part, data: withoutCronSilentFlag(part.data) } : part);
+                if (!parts.some((part) => part.type === "text" && part.text === reservation.text))
                     parts.push({ type: "text", text: reservation.text });
-                    this.database.prepare("UPDATE messages SET parts_json = ?, updated_at = ? WHERE id = ?")
-                        .run(serializeParts(parts), now, assistantMessageId);
+                if (message.cron_suppressed === 1 || serializeParts(parts) !== message.parts_json) {
+                    this.database.prepare("UPDATE messages SET cron_suppressed = 0 WHERE id = ?").run(assistantMessageId);
+                    this.writeMessageParts(assistantMessageId, parts, now);
+                    wroteMessage = true;
                 }
             }
             this.database.prepare(`
@@ -431,7 +599,7 @@ export class WebStore {
         UPDATE notification_deliveries SET thread_id = ?, message_id = ?, completed_at = ?
         WHERE source_id = ? AND delivery_key = ? AND completed_at IS NULL
       `).run(completedThreadId, assistantMessageId, now, reservation.sourceId, reservation.deliveryKey);
-            const agent = this.getAgent(reservation.sourceId);
+            const agent = this.getStoredAgent(reservation.sourceId);
             this.enqueueWebPushEventInTransaction({
                 logicalKey: notificationPushLogicalKey(reservation.sourceId, reservation.deliveryKey),
                 kind: "response.ready",
@@ -443,7 +611,12 @@ export class WebStore {
                 notBefore: new Date(new Date(now).getTime() + 3_000).toISOString(),
             });
         });
-        return { thread: this.requireThread(completedThreadId), duplicate: false };
+        return {
+            thread: this.requireThread(completedThreadId),
+            duplicate: false,
+            // Only when there is a write to name. See `wroteMessage`.
+            ...(wroteMessage ? { messageId: assistantMessageId } : {}),
+        };
     }
     /** Persist an agent-authoritative overview without deriving scheduler facts in the console. */
     syncCronOverviewResult(overview) {
@@ -637,11 +810,184 @@ export class WebStore {
     storedCronRuns(sourceId, jobId, limit = 100) {
         const bounded = boundedPageLimit(limit, 100);
         const rows = this.database.prepare(`
-      SELECT payload_json FROM cron_run_messages
+      SELECT payload_json, message_id FROM cron_run_messages
       WHERE source_id = ? AND job_id = ?
       ORDER BY ordered_at DESC, sequence DESC, run_id DESC LIMIT ?
     `).all(sourceId, jobId, bounded);
-        return { runs: rows.map((row) => parseStoredCronRun(row.payload_json)) };
+        return {
+            runs: rows.map((row) => parseStoredCronRun(row.payload_json)),
+            messages: [...rows].reverse().flatMap((row) => {
+                const message = this.getMessage(row.message_id);
+                return message === undefined ? [] : [message];
+            }),
+        };
+    }
+    captureCronReplySnapshot(sourceId, jobId, runId, snapshotKind) {
+        const row = this.database.prepare(`
+      SELECT r.payload_json, m.parts_json, m.cron_suppressed,
+        t.text, t.error_code, t.error_message
+      FROM cron_run_messages r
+      JOIN cron_channels c ON c.source_id = r.source_id AND c.job_id = r.job_id AND c.thread_id = r.thread_id
+      JOIN messages m ON m.id = r.message_id AND m.thread_id = r.thread_id
+      JOIN turns t ON t.id = r.turn_id AND t.thread_id = r.thread_id
+      WHERE r.source_id = ? AND r.job_id = ? AND r.run_id = ?
+    `).get(sourceId, jobId, runId);
+        if (row === undefined) {
+            throw new WebConsoleError("cron_reply_run_not_found", "Cron run not found for this agent and job.", 404);
+        }
+        const run = parseStoredCronRun(row.payload_json);
+        if (run.jobId !== jobId || run.runId !== runId) {
+            throw new WebConsoleError("storage_corrupt", "Stored cron run identity is inconsistent.", 500);
+        }
+        if (row.cron_suppressed === 1 || !isTerminalCronRun(run.status)) {
+            throw new WebConsoleError("cron_reply_unavailable", "Only visible terminal cron results can be replied to.", 422);
+        }
+        if (snapshotKind === "summary") {
+            return {
+                sourceId,
+                jobId,
+                runId,
+                snapshotKind,
+                capturedAt: this.now(),
+                run,
+                text: run.text ?? "",
+                ...(run.failureKind === undefined ? {} : { errorCode: run.failureKind }),
+                ...(run.error === undefined ? {} : { errorMessage: run.error }),
+                sourceFieldsTruncated: run.fieldsTruncated ?? [],
+                sourceTruncationKnown: true,
+            };
+        }
+        const telemetry = parseParts(row.parts_json).find((part) => part.type === "telemetry" && part.event === "cron_run");
+        const data = record(telemetry?.data);
+        if (data?.activityLoaded !== true) {
+            throw new WebConsoleError("cron_reply_detail_unavailable", "Cron run detail was not loaded when Reply was activated.", 422);
+        }
+        const detailFields = Array.isArray(data.detailFieldsTruncated)
+            && data.detailFieldsTruncated.every((field) => typeof field === "string")
+            ? data.detailFieldsTruncated
+            : undefined;
+        return {
+            sourceId,
+            jobId,
+            runId,
+            snapshotKind,
+            capturedAt: this.now(),
+            run,
+            text: row.text,
+            ...(row.error_code === null ? {} : { errorCode: row.error_code }),
+            ...(row.error_message === null ? {} : { errorMessage: row.error_message }),
+            ...(detailFields === undefined ? {} : { sourceFieldsTruncated: detailFields }),
+            sourceTruncationKnown: detailFields !== undefined,
+        };
+    }
+    cronReplyOperation(operationId) {
+        return this.transaction(() => {
+            const row = this.database.prepare("SELECT * FROM cron_reply_operations WHERE operation_id = ?")
+                .get(operationId);
+            return row === undefined ? undefined : this.cronReplyState(row);
+        });
+    }
+    reserveCronReplyOperation(operationId, candidate) {
+        return this.transaction(() => {
+            const existing = this.database.prepare("SELECT * FROM cron_reply_operations WHERE operation_id = ?")
+                .get(operationId);
+            if (existing !== undefined) {
+                this.assertCronReplyIdentity(existing, candidate.sourceId, candidate.jobId, candidate.runId);
+                return this.cronReplyState(existing);
+            }
+            const pending = this.database.prepare(`
+        SELECT * FROM cron_reply_operations
+        WHERE source_id = ? AND job_id = ? AND run_id = ? AND state = 'pending'
+      `).get(candidate.sourceId, candidate.jobId, candidate.runId);
+            if (pending !== undefined)
+                return { kind: "pending", operation: mapCronReplyOperation(pending) };
+            // Revalidate only eligibility/identity. The candidate remains the exact
+            // activation snapshot and is never replaced by a later detail refresh.
+            const eligible = this.database.prepare(`
+        SELECT r.payload_json, m.cron_suppressed
+        FROM cron_run_messages r JOIN messages m ON m.id = r.message_id
+        WHERE r.source_id = ? AND r.job_id = ? AND r.run_id = ?
+      `).get(candidate.sourceId, candidate.jobId, candidate.runId);
+            if (eligible === undefined || eligible.cron_suppressed === 1
+                || !isTerminalCronRun(parseStoredCronRun(eligible.payload_json).status)) {
+                throw new WebConsoleError("cron_reply_unavailable", "This cron result is no longer eligible for Reply.", 422);
+            }
+            const threadId = randomUUID();
+            const conversationId = `web:${threadId}`;
+            const provenanceMessageId = randomUUID();
+            const resultMessageId = randomUUID();
+            const idempotencyKey = `web-cron-reply:v1:${createHash("sha256")
+                .update(`${candidate.sourceId}\0${candidate.jobId}\0${candidate.runId}\0${operationId}`)
+                .digest("hex")}`;
+            const snapshotText = formatCronReplyContext(candidate);
+            const snapshotSha256 = createHash("sha256").update(snapshotText).digest("hex");
+            const title = normalizeTitle(`Reply to ${candidate.jobId} · Run ${String(candidate.run.sequence)}`);
+            const override = this.database.prepare("SELECT model, effort FROM agent_run_overrides WHERE source_id = ?")
+                .get(candidate.sourceId);
+            this.database.prepare(`
+        INSERT INTO cron_reply_operations (
+          operation_id, source_id, job_id, run_id, thread_id, conversation_id,
+          provenance_message_id, result_message_id, idempotency_key, state, snapshot_kind,
+          snapshot_text, snapshot_sha256, title, run_model, run_effort, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?)
+      `).run(operationId, candidate.sourceId, candidate.jobId, candidate.runId, threadId, conversationId, provenanceMessageId, resultMessageId, idempotencyKey, candidate.snapshotKind, snapshotText, snapshotSha256, title, override?.model ?? null, override?.effort ?? null, candidate.capturedAt);
+            const row = this.requireCronReplyOperationRow(operationId);
+            return { kind: "reserved", operation: mapCronReplyOperation(row) };
+        });
+    }
+    completeCronReplyOperation(operationId, canonicalStatus) {
+        return this.transaction(() => {
+            const row = this.requireCronReplyOperationRow(operationId);
+            if (row.state !== "pending")
+                return this.cronReplyState(row);
+            if (row.snapshot_text === null || row.snapshot_sha256 === null || row.title === null
+                || row.provenance_message_id === null || row.result_message_id === null
+                || createHash("sha256").update(row.snapshot_text).digest("hex") !== row.snapshot_sha256) {
+                throw new WebConsoleError("storage_corrupt", "Cron reply reservation is incomplete or changed.", 500);
+            }
+            const now = this.now();
+            this.database.prepare(`
+        INSERT INTO threads (
+          id, source_id, conversation_id, title, title_manual, archived_at,
+          created_at, updated_at, run_model, run_effort, revision
+        ) VALUES (?, ?, ?, ?, 0, NULL, ?, ?, ?, ?, 1)
+      `).run(row.thread_id, row.source_id, row.conversation_id, row.title, now, now, row.run_model, row.run_effort);
+            this.database.prepare(`
+        INSERT INTO messages (id, thread_id, turn_id, role, parts_json, created_at, updated_at, status)
+        VALUES (?, ?, NULL, 'system', ?, ?, ?, 'complete')
+      `).run(row.provenance_message_id, row.thread_id, serializeParts([{ type: "text", text: AGENT_CONTEXT_IMPORT_SYSTEM_PROVENANCE }]), now, now);
+            this.database.prepare(`
+        INSERT INTO messages (id, thread_id, turn_id, role, parts_json, created_at, updated_at, status)
+        VALUES (?, ?, NULL, 'assistant', ?, ?, ?, 'complete')
+      `).run(row.result_message_id, row.thread_id, serializeParts([{ type: "text", text: row.snapshot_text }]), now, now);
+            this.database.prepare("INSERT INTO revisions (entity_kind, entity_id, revision, event, created_at) VALUES ('thread', ?, 1, 'cron_reply_imported', ?)")
+                .run(row.thread_id, now);
+            this.setSetting("current_thread_id", row.thread_id);
+            const settled = this.database.prepare(`
+        UPDATE cron_reply_operations
+        SET state = 'completed', canonical_status = ?, completed_at = ?
+        WHERE operation_id = ? AND state = 'pending'
+      `).run(canonicalStatus, now, operationId);
+            if (settled.changes !== 1)
+                return this.cronReplyState(this.requireCronReplyOperationRow(operationId));
+            return { kind: "completed", receipt: this.cronReplyReceipt(this.requireCronReplyOperationRow(operationId), false) };
+        });
+    }
+    failCronReplyOperation(operationId, reason) {
+        return this.transaction(() => {
+            const row = this.requireCronReplyOperationRow(operationId);
+            if (row.state !== "pending")
+                return this.cronReplyState(row);
+            const now = this.now();
+            this.database.prepare(`
+        UPDATE cron_reply_operations SET state = 'failed', provenance_message_id = NULL,
+          result_message_id = NULL, snapshot_text = NULL, snapshot_sha256 = NULL,
+          title = NULL, run_model = NULL, run_effort = NULL,
+          failure_reason = ?, failed_at = ?
+        WHERE operation_id = ? AND state = 'pending'
+      `).run(reason.slice(0, 128), now, operationId);
+            return this.cronReplyState(this.requireCronReplyOperationRow(operationId));
+        });
     }
     reconcileCronRuns(sourceId, jobId, runs) {
         return [...this.reconcileCronRunsResult(sourceId, jobId, runs).messages];
@@ -659,10 +1005,15 @@ export class WebStore {
             : parseStoredCronJob(jobRow.payload_json).conversationId;
         const ordered = [...runs].sort(compareCronRuns);
         if (ordered.length === 0)
-            return { messages: [], changed: false };
+            return { messages: [], changed: false, writtenMessageIds: [] };
         const now = this.now();
         const messageIds = [];
+        // Only the rows whose parts this run actually moved -- see
+        // {@link CronRunReconciliationResult.writtenMessageIds}.
+        const written = new Set();
         let changed = false;
+        let storedChanged = false;
+        let visibleActivityAt;
         this.transaction(() => {
             for (const run of ordered) {
                 if (run.jobId !== jobId) {
@@ -676,24 +1027,30 @@ export class WebStore {
                 if (mapped !== undefined && (mapped.ordered_at !== run.orderedAt || mapped.sequence !== run.sequence)) {
                     throw new WebConsoleError("invalid_cron_response", "Cron run ordering identity changed after admission.", 502);
                 }
-                const delivered = mapped === undefined
-                    ? this.database.prepare(`
+                const delivered = this.database.prepare(`
               SELECT d.message_id, m.turn_id
               FROM notification_deliveries d
               JOIN messages m ON m.id = d.message_id
               WHERE d.source_id = ? AND d.job_id = ? AND d.run_id = ?
                 AND d.thread_id = ? AND d.completed_at IS NOT NULL
+                AND (? IS NULL OR d.message_id = ?)
               ORDER BY d.completed_at DESC LIMIT 1
-            `).get(sourceId, jobId, run.runId, channel.thread_id)
-                    : undefined;
+            `).get(sourceId, jobId, run.runId, channel.thread_id, mapped?.message_id ?? null, mapped?.message_id ?? null);
                 const turnId = mapped?.turn_id ?? delivered?.turn_id ?? cronEntityId("turn", sourceId, jobId, run.runId);
                 const messageId = mapped?.message_id ?? delivered?.message_id ?? cronEntityId("message", sourceId, jobId, run.runId);
                 messageIds.push(messageId);
                 const prior = this.database.prepare(`
-          SELECT thread_id, turn_id, parts_json, created_at, status FROM messages WHERE id = ?
+          SELECT thread_id, turn_id, parts_json, created_at, status, cron_suppressed FROM messages WHERE id = ?
         `).get(messageId);
                 const priorParts = prior === undefined ? [] : parseParts(prior.parts_json);
-                const parts = cronRunParts(run, priorParts, conversationId);
+                let parts = cronRunParts(prior?.cron_suppressed === 1 && run.status === "succeeded" && run.fieldsTruncated?.includes("text") === true
+                    ? { ...run, text: NOTHING_TO_REPORT_SENTINEL } : run, priorParts, conversationId, delivered !== undefined);
+                const suppressed = delivered === undefined && !hasMeaningfulCronContent(parts)
+                    && this.database.prepare("SELECT 1 FROM attachments WHERE message_id = ? LIMIT 1").get(messageId) === undefined
+                    && (definitelySilentCronRun(run)
+                        || (run.status === "succeeded" && run.fieldsTruncated?.includes("text") === true && prior?.cron_suppressed === 1));
+                if (!suppressed)
+                    parts = parts.map(clearSilentCronPart);
                 const serializedParts = serializeParts(parts);
                 const status = cronMessageStatus(run.status);
                 const turnStatus = status === "running" ? "running" : status;
@@ -729,7 +1086,7 @@ export class WebStore {
               started_at, finished_at, error_code, error_message
             ) VALUES (?, ?, ?, ?, NULL, NULL, ?, ?, ?, ?, ?)
           `).run(turnId, channel.thread_id, turnStatus, turnText, messageId, run.orderedAt, finishedAt, turnErrorCode, turnErrorMessage);
-                    changed = true;
+                    storedChanged = true;
                 }
                 else if (existingTurn.thread_id !== channel.thread_id
                     || existingTurn.status !== turnStatus
@@ -744,26 +1101,39 @@ export class WebStore {
               started_at = ?, finished_at = ?, error_code = ?, error_message = ?
             WHERE id = ?
           `).run(channel.thread_id, turnStatus, turnText, messageId, run.orderedAt, finishedAt, turnErrorCode, turnErrorMessage, turnId);
-                    changed = true;
+                    storedChanged = true;
                 }
                 if (prior === undefined) {
                     this.database.prepare(`
             INSERT INTO messages (
-              id, thread_id, turn_id, role, parts_json, created_at, updated_at, status
-            ) VALUES (?, ?, ?, 'assistant', ?, ?, ?, ?)
-          `).run(messageId, channel.thread_id, turnId, serializedParts, run.orderedAt, now, status);
-                    changed = true;
+              id, thread_id, turn_id, role, parts_json, created_at, updated_at, status, cron_suppressed
+            ) VALUES (?, ?, ?, 'assistant', ?, ?, ?, ?, ?)
+          `).run(messageId, channel.thread_id, turnId, serializedParts, run.orderedAt, now, status, suppressed ? 1 : 0);
+                    written.add(messageId);
+                    storedChanged = true;
                 }
                 else if (prior.thread_id !== channel.thread_id
                     || prior.turn_id !== turnId
                     || prior.parts_json !== serializedParts
                     || prior.created_at !== run.orderedAt
-                    || prior.status !== status) {
-                    this.database.prepare(`
-            UPDATE messages SET thread_id = ?, turn_id = ?, parts_json = ?,
-              created_at = ?, updated_at = ?, status = ? WHERE id = ?
-          `).run(channel.thread_id, turnId, serializedParts, run.orderedAt, now, status, messageId);
+                    || prior.status !== status
+                    || prior.cron_suppressed !== Number(suppressed)) {
+                    this.writeMessageParts(messageId, parts, now, {
+                        threadId: channel.thread_id,
+                        turnId,
+                        createdAt: run.orderedAt,
+                        status,
+                    });
+                    this.database.prepare("UPDATE messages SET cron_suppressed = ? WHERE id = ?").run(Number(suppressed), messageId);
+                    written.add(messageId);
+                    storedChanged = true;
+                }
+                if (written.has(messageId) && (!suppressed || prior?.cron_suppressed === 0))
                     changed = true;
+                if (written.has(messageId) && !suppressed) {
+                    const activityAt = run.completedAt ?? run.startedAt ?? run.orderedAt;
+                    if (visibleActivityAt === undefined || activityAt > visibleActivityAt)
+                        visibleActivityAt = activityAt;
                 }
                 // Detail is a message projection, not a replacement for the compact
                 // page identity. Keeping the existing summary prevents the next
@@ -788,21 +1158,22 @@ export class WebStore {
               payload_json = excluded.payload_json,
               updated_at = excluded.updated_at
           `).run(sourceId, jobId, run.runId, channel.thread_id, turnId, messageId, run.orderedAt, run.sequence, serializedRun, now);
-                    changed = true;
+                    storedChanged = true;
                 }
             }
-            if (changed) {
-                const newest = ordered.at(-1);
-                this.database.prepare(`
-          UPDATE threads SET updated_at = MAX(updated_at, ?), revision = revision + 1 WHERE id = ?
-        `).run(newest.completedAt ?? newest.startedAt ?? newest.orderedAt, channel.thread_id);
-                this.recordThreadRevision(channel.thread_id, "cron_runs_reconciled", now);
+            if (storedChanged) {
+                if (changed) {
+                    this.database.prepare(`
+            UPDATE threads SET updated_at = MAX(updated_at, COALESCE(?, updated_at)), revision = revision + 1 WHERE id = ?
+          `).run(visibleActivityAt ?? null, channel.thread_id);
+                    this.recordThreadRevision(channel.thread_id, "cron_runs_reconciled", now);
+                }
                 const excess = this.database.prepare(`
           SELECT turn_id FROM (
-            SELECT turn_id, ROW_NUMBER() OVER (
-              PARTITION BY source_id, job_id ORDER BY ordered_at DESC, sequence DESC, run_id DESC
+            SELECT r.turn_id, ROW_NUMBER() OVER (
+              PARTITION BY r.source_id, r.job_id, m.cron_suppressed ORDER BY r.ordered_at DESC, r.sequence DESC, r.run_id DESC
             ) AS retained_row
-            FROM cron_run_messages WHERE source_id = ? AND job_id = ?
+            FROM cron_run_messages r JOIN messages m ON m.id = r.message_id WHERE r.source_id = ? AND r.job_id = ?
           ) WHERE retained_row > 500
         `).all(sourceId, jobId);
                 const remove = this.database.prepare("DELETE FROM turns WHERE id = ?");
@@ -811,8 +1182,12 @@ export class WebStore {
             }
         });
         return {
-            messages: [...new Set(messageIds)].map((messageId) => this.requireMessage(messageId)),
+            messages: [...new Set(messageIds)].flatMap((id) => { const message = this.getMessage(id); return message === undefined ? [] : [message]; }),
             changed,
+            writtenMessageIds: [...written].filter((id) => this.getMessage(id) !== undefined),
+            suppressedRunIds: runs.filter((run) => this.database.prepare(`SELECT 1 FROM cron_run_messages r
+        JOIN messages m ON m.id = r.message_id WHERE r.source_id = ? AND r.job_id = ? AND r.run_id = ? AND m.cron_suppressed = 1
+      `).get(sourceId, jobId, run.runId) !== undefined).map((run) => run.runId),
         };
     }
     /** Append or update exactly one retained card for a web-origin process job. */
@@ -857,7 +1232,7 @@ export class WebStore {
                     .run(now, input.threadId);
                 this.recordThreadRevision(input.threadId, "process_job_card_created", now);
             });
-            return { thread: this.requireThread(input.threadId), duplicate: false };
+            return { thread: this.requireThread(input.threadId), duplicate: false, messageId };
         }
         if (existing.thread_id !== input.threadId || existing.delivery_key !== input.deliveryKey) {
             throw new WebConsoleError("notification_idempotency_conflict", "The process job was already bound to a different web thread or delivery key.", 409);
@@ -897,12 +1272,10 @@ export class WebStore {
         if (existing.projection_sha256 === projectionSha256
             && responseText === (existing.response_text ?? undefined)
             && !replyPartsChanged) {
-            return { thread, duplicate: true };
+            return { thread, duplicate: true, messageId: existing.message_id };
         }
         this.transaction(() => {
-            this.database.prepare(`
-        UPDATE messages SET parts_json = ?, updated_at = ?, status = ? WHERE id = ?
-      `).run(serializeParts([processJobPart(projection, responseText), ...nextReplyParts]), now, isTerminalJobState(projection.state) ? "complete" : "running", existing.message_id);
+            this.writeMessageParts(existing.message_id, [processJobPart(projection, responseText), ...nextReplyParts], now, { status: isTerminalJobState(projection.state) ? "complete" : "running" });
             this.database.prepare(`
         UPDATE process_job_cards
         SET projection_sha256 = ?, response_text = ?, updated_at = ?
@@ -912,7 +1285,7 @@ export class WebStore {
                 .run(now, input.threadId);
             this.recordThreadRevision(input.threadId, "process_job_card_updated", now);
         });
-        return { thread: this.requireThread(input.threadId), duplicate: false };
+        return { thread: this.requireThread(input.threadId), duplicate: false, messageId: existing.message_id };
     }
     /** Durably claim one web process-job wake before touching the operator. */
     reserveProcessJobWake(input) {
@@ -943,6 +1316,11 @@ export class WebStore {
     `).run(input.sourceId, input.jobId, input.deliveryKey, input.threadId, now);
         return { kind: "new" };
     }
+    /**
+     * Confirm the wake's delivery path, independently of the associated turn's
+     * eventual outcome. `completed/follow_up` means the exact turn was durably
+     * admitted; it does not mean that turn completed successfully.
+     */
     completeProcessJobWake(input) {
         const result = this.database.prepare(`
       UPDATE process_job_wake_deliveries
@@ -952,13 +1330,220 @@ export class WebStore {
         if (result.changes !== 1) {
             throw new WebConsoleError("notification_reservation_lost", "The process-job wake reservation was lost.", 409);
         }
+        if (input.turnId !== undefined) {
+            const turn = this.requireTurn(input.turnId);
+            if (turn.status === "complete" && this.hasProcessJobTurnAssociation(input.turnId)) {
+                const message = this.requireMessage(turn.assistant_message_id);
+                const normalized = normalizeMonitorTerminalReply(message.parts, true);
+                if (normalized.changed)
+                    this.writeMessageParts(message.id, normalized.parts, this.now());
+                this.repairMonitorResponsePush(input.turnId, normalized.parts);
+                return normalized.changed ? this.requireMessage(message.id) : undefined;
+            }
+        }
+        return undefined;
     }
-    /** Release a reservation only while no operator delivery has begun. */
-    abandonProcessJobWake(input) {
+    /** Bind an accepted host wake to its exact follow-up before crossing the turn boundary. */
+    associateProcessJobWakeTurn(deliveryKey, turnId, pending = true) {
+        const result = this.database.prepare(`
+      UPDATE process_job_wake_deliveries SET turn_id = ?
+      WHERE delivery_key = ? AND state = 'accepted'
+        AND thread_id = (SELECT turns.thread_id FROM turns JOIN threads ON threads.id = turns.thread_id
+          WHERE turns.id = ? AND threads.source_id = process_job_wake_deliveries.source_id)
+    `).run(pending ? turnId : null, deliveryKey, turnId);
+        if (result.changes !== 1) {
+            throw new WebConsoleError("notification_reservation_lost", "The process-job wake turn association was lost.", 409);
+        }
+    }
+    hasProcessJobTurnAssociation(turnId, deliveryKey) {
+        return this.database.prepare(`
+      SELECT 1 FROM process_job_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.turn_id = turns.id AND
+        (deliveries.state = 'completed' OR (deliveries.state = 'accepted' AND deliveries.delivery_key = ?))
+    `).get(turnId, deliveryKey ?? null) !== undefined;
+    }
+    /** Release only a pending notification hold; the ambiguous delivery reservation remains durable. */
+    releaseProcessJobWakeTurn(deliveryKey, turnId) {
         this.database.prepare(`
+      UPDATE process_job_wake_deliveries SET turn_id = NULL
+      WHERE delivery_key = ? AND turn_id = ? AND state = 'accepted'
+    `).run(deliveryKey, turnId);
+    }
+    /** Release a reservation only while no operator delivery has begun, proving the exact claim was removed. */
+    abandonProcessJobWake(input) {
+        const result = this.database.prepare(`
       DELETE FROM process_job_wake_deliveries
       WHERE source_id = ? AND job_id = ? AND delivery_key = ? AND state = 'accepted'
     `).run(input.sourceId, input.jobId, input.deliveryKey);
+        return result.changes === 1;
+    }
+    /** 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" };
+    }
+    /** Hold terminal pushes while this exact turn's steering receipt is unresolved. */
+    setMonitorWakeSteeringTurn(sourceId, deliveryKey, turnId, pending) {
+        const turn = this.requireTurn(turnId);
+        const changed = this.database.prepare(`
+      UPDATE monitor_wake_deliveries SET turn_id = ?
+      WHERE source_id = ? AND delivery_key = ? AND thread_id = ? AND state = 'accepted'
+    `).run(pending ? turnId : null, sourceId, deliveryKey, turn.thread_id);
+        if (changed.changes !== 1) {
+            throw new WebConsoleError("notification_reservation_lost", "The Monitor steering reservation was lost.", 409);
+        }
+    }
+    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 raw = this.database.prepare("SELECT parts_json FROM messages WHERE id = ?")
+                .get(message.id);
+            const original = parseParts(raw.parts_json);
+            const normalized = turn.status === "complete" ? normalizeMonitorTerminalReply(original) : { parts: original, changed: false };
+            const parts = normalized.parts;
+            const activityChanged = upsertMonitorActivity(parts, projection, input.deliveryKey);
+            if (turn.status === "complete")
+                this.repairMonitorResponsePush(input.turnId, parts);
+            if (!activityChanged && !normalized.changed)
+                return;
+            this.writeMessageParts(message.id, parts, this.now());
+            messageId = message.id;
+        });
+        return messageId === undefined ? undefined : this.requireMessage(messageId);
+    }
+    hasMonitorTurnAssociation(turnId, deliveryKey) {
+        const rows = this.database.prepare(`
+      SELECT deliveries.delivery_key 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.state = 'completed' AND deliveries.turn_id = turns.id
+        AND deliveries.disposition IN ('steered', 'follow_up'))
+        OR (deliveries.state = 'accepted' AND deliveries.delivery_key = ?)
+    `).all(turnId, deliveryKey ?? null);
+        return rows.length > 0;
+    }
+    repairMonitorResponsePush(turnId, parts) {
+        const key = `turn:${turnId}:terminal`;
+        if (hasMonitorReplyContent(parts)) {
+            this.database.prepare("UPDATE push_events SET body = ? WHERE logical_key = ? AND kind = 'response.ready'")
+                .run(webPushPreview(monitorReplyText(parts)), key);
+        }
+        else {
+            const now = this.now();
+            this.database.prepare(`
+        UPDATE push_deliveries SET status = 'suppressed', updated_at = ?, finished_at = ?
+        WHERE status = 'pending' AND event_id IN (
+          SELECT id FROM push_events WHERE logical_key = ? AND kind = 'response.ready'
+        )
+      `).run(now, now, key);
+        }
+    }
+    /** 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);
+        }
+    }
+    /** Resolve only an exact process-job live-input receipt belonging to this turn. */
+    processJobWakeForTurn(turnId, deliveryKey) {
+        return this.database.prepare(`
+      SELECT cards.job_id AS jobId, cards.delivery_key AS deliveryKey
+      FROM process_job_cards AS cards
+      JOIN process_job_wake_deliveries AS deliveries
+        ON deliveries.source_id = cards.source_id
+        AND deliveries.job_id = cards.job_id
+        AND deliveries.delivery_key = cards.delivery_key
+      JOIN turns ON turns.id = ? AND turns.thread_id = cards.thread_id
+      JOIN threads ON threads.id = turns.thread_id AND threads.source_id = cards.source_id
+      WHERE cards.delivery_key = ? AND deliveries.turn_id = turns.id
+    `).get(turnId, deliveryKey);
+    }
+    /** 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) {
@@ -967,7 +1552,7 @@ export class WebStore {
       WHERE source_id = ? AND thread_id = ? AND job_id = ?
     `).get(sourceId, threadId, jobId) !== undefined;
     }
-    createThread(sourceId) {
+    createThread(sourceId, explicit = {}) {
         const agent = this.getAgent(sourceId);
         if (agent === undefined) {
             throw new WebConsoleError("agent_not_found", "The selected agent is no longer available.", 404);
@@ -975,35 +1560,23 @@ export class WebStore {
         const id = randomUUID();
         const now = this.now();
         this.transaction(() => {
+            const override = this.database.prepare(`
+        SELECT model, effort FROM agent_run_overrides WHERE source_id = ?
+      `).get(sourceId);
+            const model = explicit.model === undefined ? override?.model ?? null : explicit.model;
+            const effort = explicit.effort === undefined ? override?.effort ?? null : explicit.effort;
             this.database.prepare(`
         INSERT INTO threads (
           id, source_id, conversation_id, title, title_manual, archived_at,
-          created_at, updated_at, revision
-        ) VALUES (?, ?, ?, 'New conversation', 0, NULL, ?, ?, 1)
-      `).run(id, sourceId, `web:${id}`, now, now);
+          created_at, updated_at, run_model, run_effort, revision
+        ) VALUES (?, ?, ?, 'New conversation', 0, NULL, ?, ?, ?, ?, 1)
+      `).run(id, sourceId, `web:${id}`, now, now, model, effort);
             this.database.prepare("INSERT INTO revisions (entity_kind, entity_id, revision, event, created_at) VALUES ('thread', ?, 1, 'created', ?)")
                 .run(id, now);
             this.setSetting("current_thread_id", id);
         });
         return this.requireThread(id);
     }
-    /** Bounded bootstrap: at most one 200-row bucket per (source_id, archived). */
-    listThreads() {
-        const rows = this.database.prepare(threadSelectSql(`
-      WHERE t.id IN (
-        SELECT id FROM (
-          SELECT id,
-                 ROW_NUMBER() OVER (
-                   PARTITION BY source_id, CASE WHEN archived_at IS NULL THEN 0 ELSE 1 END
-                   ORDER BY updated_at DESC, id DESC
-                 ) AS bucket_row
-          FROM threads
-        ) WHERE bucket_row <= ${String(WEB_THREAD_PAGE_MAX)}
-      )
-      ORDER BY t.updated_at DESC, t.id DESC
-    `)).all();
-        return rows.map((row) => this.mapThread(row));
-    }
     listThreadsPage(input) {
         if (this.getAgent(input.sourceId) === undefined) {
             throw new WebConsoleError("agent_not_found", "Agent not found.", 404);
@@ -1059,7 +1632,7 @@ export class WebStore {
         FROM message_search
         JOIN messages m ON m.rowid = message_search.rowid
         JOIN threads t ON t.id = m.thread_id
-       WHERE message_search MATCH ? AND t.source_id = ?
+       WHERE message_search MATCH ? AND t.source_id = ? AND ${visibleMessageSql("m")}
        ORDER BY rank
        LIMIT ?
     `).all(WEB_SEARCH_HIGHLIGHT_OPEN, WEB_SEARCH_HIGHLIGHT_CLOSE, match, input.sourceId, MESSAGE_SEARCH_SCAN_LIMIT + 1);
@@ -1155,12 +1728,12 @@ export class WebStore {
         const row = this.database.prepare(threadSelectSql("WHERE t.id = ?")).get(resolved);
         return row === undefined ? undefined : this.mapThread(row);
     }
-    getThreadDetail(id) {
+    getThreadDetail(id, options = {}) {
         const resolved = this.resolveThreadId(id);
         const thread = this.getThread(resolved);
         if (thread === undefined)
             return undefined;
-        const page = this.listMessagesPage(resolved);
+        const page = this.listMessagesPage(resolved, { limit: options.limit ?? WEB_MESSAGE_PAGE_DEFAULT });
         return {
             thread,
             messages: page.messages,
@@ -1168,7 +1741,7 @@ export class WebStore {
         };
     }
     getMessage(id) {
-        const row = this.database.prepare("SELECT * FROM messages WHERE id = ?")
+        const row = this.database.prepare(`SELECT * FROM messages WHERE id = ? AND ${visibleMessageSql("messages")}`)
             .get(id);
         return row === undefined ? undefined : this.mapMessage(row);
     }
@@ -1193,10 +1766,11 @@ export class WebStore {
         }
         values.push(limit + 1);
         const rows = this.database.prepare(`
-      SELECT m.*, ${orderedAt} AS ordered_at, ${rank} AS role_rank, m.rowid AS storage_rowid
+      SELECT m.*, ${orderedAt} AS ordered_at, ${rank} AS role_rank, m.rowid AS storage_rowid,
+        t.finished_at AS turn_finished_at
       FROM messages m
       LEFT JOIN turns t ON t.id = m.turn_id
-      WHERE m.thread_id = ? ${beforeSql}
+      WHERE m.thread_id = ? AND ${visibleMessageSql("m")} ${beforeSql}
       ORDER BY ordered_at DESC, role_rank DESC, m.created_at DESC, storage_rowid DESC
       LIMIT ?
     `).all(...values);
@@ -1234,14 +1808,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 +1854,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. */
@@ -1287,7 +1912,7 @@ export class WebStore {
         });
         return changed ? this.requireThread(id) : undefined;
     }
-    async deleteArchivedThread(id) {
+    async deleteArchivedThread(id, options = {}) {
         id = this.resolveThreadId(id);
         const thread = this.requireThread(id);
         if (thread.archivedAt === null) {
@@ -1301,8 +1926,33 @@ export class WebStore {
         const attachments = this.database.prepare("SELECT * FROM attachments WHERE thread_id = ?")
             .all(id);
         this.transaction(() => {
+            if (options.emptyOnly === true) {
+                const hasContent = thread.trigger !== undefined || this.database.prepare(`
+          SELECT 1 FROM messages WHERE thread_id = ?
+          UNION ALL SELECT 1 FROM turns WHERE thread_id = ?
+          UNION ALL SELECT 1 FROM attachments WHERE thread_id = ?
+          UNION ALL SELECT 1 FROM live_inputs WHERE thread_id = ?
+          UNION ALL SELECT 1 FROM web_submissions WHERE thread_id = ?
+          UNION ALL SELECT 1 FROM cron_reply_operations WHERE thread_id = ? AND state = 'completed'
+          UNION ALL SELECT 1 FROM process_job_wake_deliveries WHERE thread_id = ?
+          UNION ALL SELECT 1 FROM monitor_wake_deliveries WHERE thread_id = ?
+          UNION ALL SELECT 1 FROM notification_deliveries WHERE thread_id = ?
+          UNION ALL SELECT 1 FROM push_events WHERE thread_id = ?
+          LIMIT 1
+        `).get(id, id, id, id, id, id, id, id, id, id) !== undefined;
+                if (hasContent) {
+                    throw new WebConsoleError("thread_not_empty", "The conversation now contains activity and was kept in Archived.", 409);
+                }
+            }
             const now = this.now();
             this.database.prepare(`
+        UPDATE cron_reply_operations SET state = 'tombstoned', provenance_message_id = NULL,
+          result_message_id = NULL, snapshot_text = NULL, snapshot_sha256 = NULL,
+          title = NULL, run_model = NULL, run_effort = NULL, completed_at = NULL,
+          failure_reason = 'thread_deleted', tombstoned_at = ?
+        WHERE thread_id = ? AND state = 'completed'
+      `).run(now, id);
+            this.database.prepare(`
         UPDATE push_deliveries SET status = 'dropped', updated_at = ?, finished_at = ?, last_error_code = 'thread_deleted'
         WHERE event_id IN (SELECT id FROM push_events WHERE thread_id = ?)
           AND status IN ('pending', 'sending')
@@ -1503,7 +2153,7 @@ export class WebStore {
             if (input.quote.text.trim().length === 0 || input.quote.messageId.trim().length === 0) {
                 throw new WebConsoleError("invalid_quote", "Quoted text and its source message are required.", 400);
             }
-            const source = this.database.prepare("SELECT id FROM messages WHERE id = ? AND thread_id = ?").get(input.quote.messageId, threadId);
+            const source = this.database.prepare(`SELECT id FROM messages WHERE id = ? AND thread_id = ? AND ${visibleMessageSql("messages")}`).get(input.quote.messageId, threadId);
             if (source === undefined) {
                 throw new WebConsoleError("invalid_quote", "The quoted message does not belong to this conversation.", 400);
             }
@@ -1515,10 +2165,10 @@ export class WebStore {
         this.transaction(() => {
             this.database.prepare(`
         INSERT INTO turns (
-          id, thread_id, status, text, model, effort, assistant_message_id,
+          id, thread_id, status, text, model, effort, requested_model, requested_effort, assistant_message_id,
           started_at, finished_at, error_code, error_message
-        ) VALUES (?, ?, 'running', ?, ?, ?, ?, ?, NULL, NULL, NULL)
-      `).run(turnId, threadId, input.text, input.model ?? null, input.effort ?? null, assistantMessageId, now);
+        ) VALUES (?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL)
+      `).run(turnId, threadId, input.text, input.model ?? null, input.effort ?? null, input.requestedModel ?? null, input.requestedEffort ?? null, assistantMessageId, now);
             const userParts = [
                 ...(input.quote === undefined
                     ? []
@@ -1584,17 +2234,38 @@ export class WebStore {
         const turnId = randomUUID();
         const assistantMessageId = randomUUID();
         const now = this.now();
+        if (input.processJobWake !== undefined) {
+            const card = this.database.prepare(`
+        SELECT 1 FROM process_job_cards AS cards
+        JOIN threads ON threads.id = cards.thread_id AND threads.source_id = cards.source_id
+        JOIN process_job_wake_deliveries AS deliveries
+          ON deliveries.source_id = cards.source_id
+          AND deliveries.job_id = cards.job_id
+          AND deliveries.delivery_key = cards.delivery_key
+        WHERE cards.thread_id = ? AND cards.job_id = ? AND cards.delivery_key = ?
+          AND deliveries.state = 'accepted' AND deliveries.turn_id IS NULL
+      `).get(threadId, input.processJobWake.jobId, input.processJobWake.deliveryKey);
+            if (card === undefined) {
+                throw new WebConsoleError("invalid_notification", "The process-job wake does not match its retained card.", 409);
+            }
+        }
+        const initialParts = input.processJobWake === undefined
+            ? []
+            : [{ type: "process-job-wake", ...input.processJobWake }];
         this.transaction(() => {
             this.database.prepare(`
         INSERT INTO turns (
-          id, thread_id, status, text, model, effort, assistant_message_id,
+          id, thread_id, status, text, model, effort, requested_model, requested_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);
+        ) VALUES (?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL)
+      `).run(turnId, threadId, input.storedPrompt ?? input.prompt, input.model ?? null, input.effort ?? null, input.requestedModel ?? null, input.requestedEffort ?? null, assistantMessageId, now);
             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);
+        VALUES (?, ?, ?, 'assistant', ?, ?, ?, 'running')
+      `).run(assistantMessageId, threadId, turnId, serializeParts(initialParts), now, now);
+            if (input.processJobWake !== undefined) {
+                this.associateProcessJobWakeTurn(input.processJobWake.deliveryKey, turnId);
+            }
             this.database.prepare("UPDATE threads SET updated_at = ?, revision = revision + 1 WHERE id = ?").run(now, threadId);
             this.recordThreadRevision(threadId, "background_follow_up_started", now);
             this.setSetting("current_thread_id", threadId);
@@ -1608,7 +2279,7 @@ export class WebStore {
             thread: this.requireThread(threadId),
         };
     }
-    reserveLiveInput(threadId, text) {
+    reserveLiveInput(threadId, text, quote, operatorText = text) {
         threadId = this.resolveThreadId(threadId);
         const thread = this.requireThread(threadId);
         if (thread.archivedAt !== null) {
@@ -1622,9 +2293,15 @@ export class WebStore {
         if (text.trim().length === 0) {
             throw new WebConsoleError("empty_turn", "Enter a message.", 400);
         }
-        if (text.length > AGENT_LIVE_INPUT_MAX_CHARACTERS) {
+        if (operatorText.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);
         }
+        if (quote !== undefined) {
+            const source = this.database.prepare(`SELECT id FROM messages WHERE id = ? AND thread_id = ? AND ${visibleMessageSql("messages")}`).get(quote.messageId, threadId);
+            if (quote.text.trim().length === 0 || source === undefined) {
+                throw new WebConsoleError("invalid_quote", "The quoted message does not belong to this conversation.", 400);
+            }
+        }
         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);
@@ -1634,8 +2311,18 @@ export class WebStore {
         const messageId = randomUUID();
         const now = this.now();
         const status = active === undefined ? "queued" : "offered";
+        // An idle forced steer becomes an ordinary turn, so freeze the thread's
+        // selected route now rather than consulting a potentially changed
+        // override when the queue drains. An active turn owns its own route,
+        // including explicit null/default values; never fall through from those
+        // nulls to the thread override.
+        const model = active === undefined ? thread.runModel : active.model;
+        const effort = active === undefined ? thread.runEffort : active.effort;
         const parts = [
             liveInputTelemetry(status === "offered" ? "pending" : "queued"),
+            ...(quote === undefined
+                ? []
+                : [{ type: "telemetry", event: QUOTE_TELEMETRY_EVENT, data: quote }]),
             { type: "text", text },
         ];
         this.transaction(() => {
@@ -1647,7 +2334,7 @@ export class WebStore {
         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);
+      `).run(id, threadId, messageId, active?.id ?? null, operatorText, model, effort, status, now, now);
             const title = deriveAutomaticTitle(text, []);
             this.database.prepare(`
         UPDATE threads
@@ -1673,8 +2360,7 @@ export class WebStore {
         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(serializeParts(withLiveInputStatus(message.parts, "applied")), now, row.message_id);
+            this.writeMessageParts(row.message_id, withLiveInputStatus(message.parts, "applied"), now);
             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);
@@ -1682,7 +2368,36 @@ export class WebStore {
         });
         return this.requireMessage(row.message_id);
     }
-    queueLiveInput(id) {
+    storedLiveInput(id) {
+        const row = this.getLiveInput(id);
+        return row === undefined ? undefined : mapLiveInput(row);
+    }
+    markLiveInputUncertain(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.writeMessageParts(row.message_id, withLiveInputStatus(message.parts, "uncertain"), now, { turnId: null });
+            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_uncertain", now);
+        });
+        return this.requireMessage(row.message_id);
+    }
+    markLiveInputDispatchStarted(id, activeTurnId) {
+        const now = this.now();
+        return this.transaction(() => {
+            const result = this.database.prepare(`
+        UPDATE live_inputs SET dispatch_started_at = ?, updated_at = ?
+        WHERE id = ? AND status = 'offered' AND active_turn_id = ? AND dispatch_started_at IS NULL
+      `).run(now, now, id, activeTurnId);
+            return result.changes === 1;
+        });
+    }
+    queueLiveInput(id, submissionReason) {
         const row = this.getLiveInput(id);
         if (row === undefined)
             return undefined;
@@ -1690,10 +2405,17 @@ export class WebStore {
         const now = this.now();
         this.transaction(() => {
             this.database.prepare(`
-        UPDATE live_inputs SET status = 'queued', active_turn_id = NULL, updated_at = ? WHERE id = ?
+        UPDATE live_inputs
+        SET status = 'queued', active_turn_id = NULL, dispatch_started_at = NULL, updated_at = ?
+        WHERE id = ?
       `).run(now, id);
-            this.database.prepare("UPDATE messages SET turn_id = NULL, parts_json = ?, updated_at = ? WHERE id = ?")
-                .run(serializeParts(withLiveInputStatus(message.parts, "queued")), now, row.message_id);
+            if (submissionReason !== undefined) {
+                this.database.prepare(`
+          UPDATE web_submissions SET reason = ?
+          WHERE input_id = ? AND outcome = 'live-input' AND reason IS NULL
+        `).run(submissionReason, id);
+            }
+            this.writeMessageParts(row.message_id, withLiveInputStatus(message.parts, "queued"), now, { turnId: null });
             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);
@@ -1707,8 +2429,7 @@ export class WebStore {
         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(serializeParts(withLiveInputStatus(message.parts, "cancelled")), now, row.message_id);
+            this.writeMessageParts(row.message_id, withLiveInputStatus(message.parts, "cancelled"), now, { turnId: null });
             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);
@@ -1723,15 +2444,16 @@ export class WebStore {
             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(serializeParts(withLiveInputStatus(message.parts, "cancelled")), now, row.message_id);
+                this.writeMessageParts(row.message_id, withLiveInputStatus(message.parts, row.dispatch_started_at === null ? "cancelled" : "uncertain"), now, { turnId: null });
             }
             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);
+            this.recordThreadRevision(threadId, rows.some((row) => row.dispatch_started_at !== null)
+                ? "live_inputs_cancelled_with_uncertainty"
+                : "live_inputs_cancelled", now);
         });
         return rows.map((row) => this.requireMessage(row.message_id));
     }
@@ -1763,12 +2485,11 @@ export class WebStore {
         this.transaction(() => {
             this.database.prepare(`
         INSERT INTO turns (
-          id, thread_id, status, text, model, effort, assistant_message_id,
+          id, thread_id, status, text, model, effort, requested_model, requested_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, serializeParts(withoutLiveInputTelemetry(userMessage.parts)), now, row.message_id);
+        ) VALUES (?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL)
+      `).run(turnId, threadId, row.text, row.model, row.effort, row.model, row.effort, assistantMessageId, now);
+            this.writeMessageParts(row.message_id, withoutLiveInputTelemetry(userMessage.parts), now, { turnId });
             this.database.prepare(`
         INSERT INTO messages (id, thread_id, turn_id, role, parts_json, created_at, updated_at, status)
         VALUES (?, ?, ?, 'assistant', '[]', ?, ?, 'running')
@@ -1788,55 +2509,131 @@ export class WebStore {
             thread: this.requireThread(threadId),
         };
     }
-    applyStreamFrame(turnId, frame) {
-        return this.applyStreamFrames(turnId, [frame]);
-    }
     applyStreamFrames(turnId, frames) {
         const turn = this.requireTurn(turnId);
+        // Nothing is written for a turn that already settled, so there is no
+        // version for a delta to name.
         if (turn.status !== "running")
-            return this.requireMessage(turn.assistant_message_id);
-        const message = this.requireMessage(turn.assistant_message_id);
-        const parts = [...message.parts];
-        let actualModel;
-        let actualEffort;
-        for (const frame of frames) {
-            if (frame.kind === "status") {
-                parts.push({ type: "telemetry", event: "status", data: { text: frame.text } });
-            }
-            else if (frame.kind === "append") {
-                appendTextPart(parts, "text", frame.delta);
-            }
-            else if (frame.kind === "replace") {
-                replaceWholeText(parts, frame.text);
-            }
-            else if (frame.kind === "event") {
-                applyEvent(parts, frame.event);
-                if (frame.event.type === "runtime_telemetry" && frame.event.kind === "run_config") {
-                    if (typeof frame.event.data?.model === "string")
-                        actualModel = frame.event.data.model;
-                    if (typeof frame.event.data?.effort === "string")
-                        actualEffort = frame.event.data.effort;
+            return { message: this.requireMessage(turn.assistant_message_id) };
+        // The base read, the frames applied to it and the write are ONE atomic
+        // span, as they already are on the finish path. A delta whose ops were
+        // diffed against a version other than the one its `baseSeq` names is
+        // self-consistent and WRONG -- the one corruption a sequence number cannot
+        // expose, because the console would apply it without complaint.
+        const write = this.transaction(() => {
+            const message = this.requireMessage(turn.assistant_message_id);
+            const parts = [...message.parts];
+            let actualModel;
+            let actualEffort;
+            let actualEffectiveEffort;
+            let clearEffort = false;
+            let clearEffectiveEffort = false;
+            let routing = parseRoutingState(turn.routing_json);
+            let attributionChanged = false;
+            for (const frame of frames) {
+                if (frame.kind === "status") {
+                    parts.push({ type: "telemetry", event: "status", data: { text: frame.text } });
+                }
+                else if (frame.kind === "append") {
+                    appendTextPart(parts, "text", frame.delta);
+                }
+                else if (frame.kind === "replace") {
+                    replaceWholeText(parts, frame.text);
+                }
+                else if (frame.kind === "event") {
+                    applyEvent(parts, frame.event, (deliveryKey) => this.monitorWakeProjection(turnId, deliveryKey), (deliveryKey) => this.processJobWakeForTurn(turnId, deliveryKey));
+                    if (frame.event.type === "runtime_telemetry" && frame.event.kind === "run_config") {
+                        const model = canonicalRouteString(frame.event.data?.model);
+                        const effort = canonicalRouteString(frame.event.data?.effort, 64);
+                        if (model !== undefined)
+                            actualModel = model;
+                        if (effort !== undefined) {
+                            actualEffort = effort;
+                            clearEffort = false;
+                        }
+                        attributionChanged ||= model !== undefined || effort !== undefined;
+                    }
+                    if (frame.event.type === "runtime_telemetry" && frame.event.kind === "provider_execution_config") {
+                        const model = canonicalRouteString(frame.event.data?.model);
+                        const effort = canonicalRouteString(frame.event.data?.effort, 64);
+                        const effectiveEffort = canonicalRouteString(frame.event.data?.effectiveEffort, 64);
+                        if (model !== undefined)
+                            actualModel = model;
+                        if (effort !== undefined)
+                            actualEffort = effort;
+                        if (effectiveEffort !== undefined)
+                            actualEffectiveEffort = effectiveEffort;
+                        clearEffort = effort === undefined;
+                        clearEffectiveEffort = effectiveEffort === undefined;
+                        attributionChanged ||= model !== undefined || effort !== undefined || effectiveEffort !== undefined;
+                    }
+                    if (frame.event.type === "provider_status") {
+                        if (frame.event.kind === "failover_started") {
+                            const from = canonicalRouteString(frame.event.from);
+                            const to = canonicalRouteString(frame.event.to);
+                            if (from !== undefined && to !== undefined) {
+                                const attemptIndex = canonicalRouteIndex(frame.event.attemptIndex);
+                                const reason = canonicalRouteString(frame.event.reason, 128);
+                                routing = appendRouteTransition(routing, {
+                                    from,
+                                    to,
+                                    ...(attemptIndex === undefined ? {} : { attemptIndex }),
+                                    ...(reason === undefined ? {} : { reason }),
+                                });
+                                actualModel = to;
+                                clearEffort = true;
+                                clearEffectiveEffort = true;
+                                attributionChanged = true;
+                            }
+                        }
+                        else if (frame.event.kind === "retry_started") {
+                            const model = canonicalRouteString(frame.event.model);
+                            const retryIndex = canonicalRouteIndex(frame.event.retryIndex);
+                            const reason = canonicalRouteString(frame.event.reason, 128);
+                            routing = appendRouteRetry(routing, {
+                                ...(model === undefined ? {} : { model }),
+                                ...(retryIndex === undefined ? {} : { retryIndex }),
+                                ...(reason === undefined ? {} : { reason }),
+                            });
+                            attributionChanged = true;
+                        }
+                        else if (frame.event.kind === "failover_completed") {
+                            const model = canonicalRouteString(frame.event.model);
+                            if (model !== undefined) {
+                                actualModel = model;
+                                attributionChanged = true;
+                            }
+                        }
+                        else if (frame.event.kind === "request_started") {
+                            const model = canonicalRouteString(frame.event.model);
+                            if (model !== undefined) {
+                                actualModel = model;
+                                attributionChanged = true;
+                            }
+                        }
+                    }
                 }
             }
-        }
-        const now = this.now();
-        this.transaction(() => {
-            this.database.prepare("UPDATE messages SET parts_json = ?, updated_at = ? WHERE id = ?")
-                .run(serializeParts(parts), now, message.id);
-            if (actualModel !== undefined || actualEffort !== undefined) {
+            if (actualModel !== undefined || actualEffort !== undefined || actualEffectiveEffort !== undefined || attributionChanged) {
                 this.database.prepare(`
           UPDATE turns SET
             model = CASE WHEN ? IS NULL THEN model ELSE ? END,
-            effort = CASE WHEN ? IS NULL THEN effort ELSE ? END
+            effort = CASE WHEN ? = 1 THEN NULL WHEN ? IS NULL THEN effort ELSE ? END,
+            effective_effort = CASE WHEN ? = 1 THEN NULL WHEN ? IS NULL THEN effective_effort ELSE ? END,
+            routing_json = ?
           WHERE id = ?
-        `).run(actualModel ?? null, actualModel ?? null, actualEffort ?? null, actualEffort ?? null, turnId);
+        `).run(actualModel ?? null, actualModel ?? null, clearEffort ? 1 : 0, actualEffort ?? null, actualEffort ?? null, clearEffectiveEffort ? 1 : 0, actualEffectiveEffort ?? null, actualEffectiveEffort ?? null, serializeRoutingState(routing), turnId);
             }
+            return {
+                delta: this.writeMessageDelta(message, parts, this.now()),
+                ...(attributionChanged ? { attributionChanged: true } : {}),
+            };
         });
-        return this.requireMessage(message.id);
+        return { message: this.requireMessage(turn.assistant_message_id), ...write };
     }
-    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, options.monitorWakeDeliveryKey);
     }
     failTurn(turnId, error) {
         return this.finishTurn(turnId, error.cancelled === true ? "cancelled" : "failed", undefined, error.code, error.message, undefined);
@@ -2069,6 +2866,16 @@ export class WebStore {
         JOIN push_events e ON e.id = d.event_id
         JOIN push_subscriptions s ON s.id = d.subscription_id
         WHERE d.status = 'pending' AND d.next_attempt_at <= ? AND e.expires_at > ? AND s.state = 'active'
+          AND NOT EXISTS (
+            SELECT 1 FROM monitor_wake_deliveries m
+            WHERE e.kind = 'response.ready' AND m.state = 'accepted' AND m.turn_id IS NOT NULL
+              AND e.logical_key = 'turn:' || m.turn_id || ':terminal'
+          )
+          AND NOT EXISTS (
+            SELECT 1 FROM process_job_wake_deliveries j
+            WHERE e.kind = 'response.ready' AND j.state = 'accepted' AND j.turn_id IS NOT NULL
+              AND e.logical_key = 'turn:' || j.turn_id || ':terminal'
+          )
         ORDER BY d.next_attempt_at, d.created_at, d.rowid
         LIMIT ?
       `).all(now, now, limit);
@@ -2191,6 +2998,7 @@ export class WebStore {
             if (versionRow.user_version < 0) {
                 throw new WebConsoleError("storage_corrupt", "Web state schema version is invalid.", 500);
             }
+            validateWebStorageMigrationRegistry();
             const migrating = versionRow.user_version < WEB_STORAGE_SCHEMA_VERSION;
             if (migrating)
                 this.database.exec("BEGIN IMMEDIATE");
@@ -2200,18 +3008,28 @@ export class WebStore {
         source_id TEXT PRIMARY KEY,
         label TEXT NOT NULL,
         status TEXT NOT NULL,
+        discovered INTEGER NOT NULL DEFAULT 1 CHECK (discovered IN (0, 1)),
         health TEXT,
         supports_attachments INTEGER NOT NULL DEFAULT 0,
+        supports_provider_auth INTEGER NOT NULL DEFAULT 0 CHECK (supports_provider_auth IN (0, 1)),
         models_json TEXT,
         default_model TEXT,
         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,
         updated_at TEXT NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS agent_run_overrides (
+        source_id TEXT PRIMARY KEY REFERENCES agents(source_id) ON DELETE CASCADE,
+        model TEXT,
+        effort TEXT,
+        updated_at TEXT NOT NULL,
+        CHECK (model IS NOT NULL OR effort IS NOT NULL)
+      );
       CREATE TABLE IF NOT EXISTS threads (
         id TEXT PRIMARY KEY,
         source_id TEXT NOT NULL REFERENCES agents(source_id),
@@ -2222,6 +3040,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 (
@@ -2231,6 +3051,10 @@ export class WebStore {
         text TEXT NOT NULL,
         model TEXT,
         effort TEXT,
+        requested_model TEXT,
+        requested_effort TEXT,
+        effective_effort TEXT,
+        routing_json TEXT NOT NULL DEFAULT '{"transitions":[],"retries":[]}',
         assistant_message_id TEXT NOT NULL,
         started_at TEXT NOT NULL,
         finished_at TEXT,
@@ -2239,6 +3063,7 @@ export class WebStore {
       );
       CREATE UNIQUE INDEX IF NOT EXISTS turns_one_active_per_thread
         ON turns(thread_id) WHERE status = 'running';
+      CREATE INDEX IF NOT EXISTS turns_by_thread_started ON turns(thread_id, started_at);
       CREATE TABLE IF NOT EXISTS messages (
         id TEXT PRIMARY KEY,
         thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
@@ -2247,9 +3072,11 @@ export class WebStore {
         parts_json TEXT NOT NULL,
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL,
-        status TEXT NOT NULL
+        status TEXT NOT NULL,
+        seq INTEGER NOT NULL DEFAULT 0
       );
       CREATE INDEX IF NOT EXISTS messages_by_thread ON messages(thread_id, created_at);
+      CREATE INDEX IF NOT EXISTS messages_by_turn ON messages(turn_id);
       CREATE TABLE IF NOT EXISTS live_inputs (
         id TEXT PRIMARY KEY,
         thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
@@ -2259,11 +3086,63 @@ export class WebStore {
         model TEXT,
         effort TEXT,
         status TEXT NOT NULL CHECK (status IN ('offered', 'queued')),
+        dispatch_started_at TEXT,
         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 web_submissions (
+        thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+        submission_id TEXT NOT NULL,
+        payload_sha256 TEXT NOT NULL,
+        outcome TEXT NOT NULL CHECK (outcome IN ('turn', 'live-input', 'rejected')),
+        reason TEXT CHECK (reason IN (
+          'active_attachments_unsupported', 'unsupported_targeting', 'closed_before_dispatch',
+          'operator_inactive', 'operator_unsupported', 'operator_too_large', 'operator_full', 'operator_invalid',
+          'mailbox_unsupported', 'mailbox_closed', 'mailbox_failed'
+        )),
+        message_id TEXT REFERENCES messages(id) ON DELETE SET NULL,
+        turn_id TEXT REFERENCES turns(id) ON DELETE SET NULL,
+        input_id TEXT REFERENCES live_inputs(id) ON DELETE SET NULL,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (thread_id, submission_id)
+      );
+      CREATE TABLE IF NOT EXISTS cron_reply_operations (
+        operation_id TEXT PRIMARY KEY,
+        source_id TEXT NOT NULL REFERENCES agents(source_id),
+        job_id TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL UNIQUE,
+        conversation_id TEXT NOT NULL UNIQUE,
+        provenance_message_id TEXT UNIQUE,
+        result_message_id TEXT UNIQUE,
+        idempotency_key TEXT NOT NULL UNIQUE,
+        state TEXT NOT NULL CHECK (state IN ('pending', 'completed', 'failed', 'tombstoned')),
+        snapshot_kind TEXT NOT NULL CHECK (snapshot_kind IN ('summary', 'detail')),
+        snapshot_text TEXT,
+        snapshot_sha256 TEXT,
+        title TEXT,
+        run_model TEXT,
+        run_effort TEXT,
+        canonical_status TEXT CHECK (canonical_status IN ('appended', 'duplicate')),
+        failure_reason TEXT,
+        created_at TEXT NOT NULL,
+        completed_at TEXT,
+        failed_at TEXT,
+        tombstoned_at TEXT,
+        CHECK (
+          (state IN ('pending', 'completed') AND snapshot_text IS NOT NULL AND snapshot_sha256 IS NOT NULL
+            AND title IS NOT NULL AND provenance_message_id IS NOT NULL AND result_message_id IS NOT NULL)
+          OR (state IN ('failed', 'tombstoned') AND snapshot_text IS NULL AND snapshot_sha256 IS NULL
+            AND title IS NULL AND provenance_message_id IS NULL AND result_message_id IS NULL)
+        ),
+        CHECK ((state = 'completed') = (completed_at IS NOT NULL)),
+        CHECK ((state = 'failed') = (failed_at IS NOT NULL)),
+        CHECK ((state = 'tombstoned') = (tombstoned_at IS NOT NULL))
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS cron_reply_operations_one_pending_run
+        ON cron_reply_operations(source_id, job_id, run_id) WHERE state = 'pending';
       CREATE TABLE IF NOT EXISTS attachments (
         id TEXT PRIMARY KEY,
         thread_id TEXT REFERENCES threads(id) ON DELETE CASCADE,
@@ -2324,11 +3203,27 @@ 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 cron_channels (
+      CREATE TABLE IF NOT EXISTS monitor_wake_deliveries (
         source_id TEXT NOT NULL REFERENCES agents(source_id),
-        job_id TEXT NOT NULL,
-        thread_id TEXT NOT NULL UNIQUE REFERENCES threads(id) ON DELETE CASCADE,
-        configured INTEGER NOT NULL CHECK (configured IN (0, 1)),
+        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,
+        thread_id TEXT NOT NULL UNIQUE REFERENCES threads(id) ON DELETE CASCADE,
+        configured INTEGER NOT NULL CHECK (configured IN (0, 1)),
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL,
         PRIMARY KEY (source_id, job_id)
@@ -2446,37 +3341,14 @@ export class WebStore {
         ON push_deliveries(status, next_attempt_at, created_at);
       ${MESSAGE_SEARCH_SCHEMA_SQL}
       `);
-                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 (versionRow.user_version < 5)
-                    this.migrateCronChannels();
-                if (versionRow.user_version < 6) {
-                    const columns = new Set(this.database.prepare("PRAGMA table_info(cron_overviews)").all()
-                        .map((column) => column.name));
-                    if (!columns.has("jobs_truncated")) {
-                        this.database.exec("ALTER TABLE cron_overviews ADD COLUMN jobs_truncated INTEGER NOT NULL DEFAULT 0 CHECK (jobs_truncated IN (0, 1))");
-                    }
-                }
-                // The search index derives from parts_json, so an existing database has
-                // to be swept once. Migration writes no message, so the triggers above
-                // cannot have fired yet; the clear-then-insert is a no-op on a fresh
-                // 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'))");
-                    }
-                }
+                runWebStorageMigrations({
+                    database: this.database,
+                    originalVersion: versionRow.user_version,
+                    migrateCronChannels: () => this.migrateCronChannels(),
+                    migrateMonitorWakeDeliveries: () => this.migrateMonitorWakeDeliveries(),
+                    suppressSilentCronHistory: () => this.suppressSilentCronHistory(),
+                    backfillMessageSearch: () => this.database.exec(MESSAGE_SEARCH_BACKFILL_SQL),
+                });
                 if (migrating)
                     this.database.exec(`PRAGMA user_version = ${WEB_STORAGE_SCHEMA_VERSION}; COMMIT`);
             }
@@ -2493,6 +3365,83 @@ export class WebStore {
             throw new WebConsoleError("storage_corrupt", `Unable to initialize web state: ${error instanceof Error ? error.message : String(error)}`, 500);
         }
     }
+    suppressSilentCronHistory() {
+        const affected = new Set();
+        let after = 0;
+        while (true) {
+            const rows = this.database.prepare(`
+        SELECT r.rowid AS cursor, r.*, m.parts_json, m.cron_suppressed
+        FROM cron_run_messages r JOIN messages m ON m.id = r.message_id
+        WHERE r.rowid > ? ORDER BY r.rowid LIMIT 100
+      `).all(after);
+            if (rows.length === 0)
+                break;
+            for (const row of rows) {
+                const run = parseStoredCronRun(row.payload_json);
+                const parts = parseParts(row.parts_json);
+                if (run.runId !== row.run_id || run.jobId !== row.job_id)
+                    throw new Error("Invalid cron mapping identity.");
+                const delivered = this.database.prepare(`SELECT 1 FROM notification_deliveries
+          WHERE source_id = ? AND job_id = ? AND run_id = ? AND message_id = ? AND completed_at IS NOT NULL
+        `).get(row.source_id, row.job_id, row.run_id, row.message_id);
+                const suppressed = definitelySilentCronRun(run) && delivered === undefined && !hasMeaningfulCronContent(parts)
+                    && this.database.prepare("SELECT 1 FROM attachments WHERE message_id = ? LIMIT 1").get(row.message_id) === undefined;
+                if (row.cron_suppressed === 0 && suppressed) {
+                    this.database.prepare("UPDATE messages SET cron_suppressed = 1 WHERE id = ?").run(row.message_id);
+                    affected.add(row.thread_id);
+                }
+                else if (!suppressed) {
+                    // Visible ambiguous/delivered rows must not be hidden by old browser
+                    // telemetry guards. Keep their content, remove only the stale flag.
+                    const visibleParts = parts.map(clearSilentCronPart);
+                    if (visibleParts.some((part, index) => part !== parts[index])) {
+                        this.database.prepare("UPDATE messages SET parts_json = ? WHERE id = ?").run(serializeParts(visibleParts), row.message_id);
+                        affected.add(row.thread_id);
+                    }
+                }
+                after = row.cursor;
+            }
+        }
+        for (const id of affected)
+            this.database.prepare("UPDATE threads SET revision = revision + 1 WHERE id = ?").run(id);
+    }
+    /** Preserve Monitor delivery tombstones while making deleted threads threadless. */
+    migrateMonitorWakeDeliveries() {
+        const foreignKeys = this.database.prepare("PRAGMA foreign_key_list(monitor_wake_deliveries)")
+            .all();
+        if (!foreignKeys.some((key) => key.from === "thread_id" && key.on_delete === "CASCADE"))
+            return;
+        const columns = this.database.prepare("PRAGMA table_info(monitor_wake_deliveries)")
+            .all();
+        const projection = columns.some((column) => column.name === "projection_json") ? "projection_json" : "NULL";
+        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, ${projection},
+        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
@@ -2634,6 +3583,7 @@ export class WebStore {
         }
         const requiredTables = new Set([
             "agents",
+            "agent_run_overrides",
             "threads",
             "turns",
             "messages",
@@ -2642,6 +3592,8 @@ export class WebStore {
             "revisions",
             "settings",
             "notification_deliveries",
+            "process_job_wake_deliveries",
+            "monitor_wake_deliveries",
             "cron_channels",
             "cron_channel_deletions",
             "cron_overviews",
@@ -2669,6 +3621,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
@@ -2680,6 +3647,46 @@ export class WebStore {
             this.database.exec(MESSAGE_SEARCH_UNSETTLED_SQL);
         });
     }
+    /** Repair only the derived search projection of verified legacy Monitor replies.
+     * New completions already normalize before the ordinary indexing triggers run.
+     * Page by rowid so opening a large retained history does not materialize it all.
+     */
+    reindexLegacyMonitorMessages() {
+        const select = this.database.prepare(`
+      SELECT m.rowid AS row_id, m.parts_json FROM messages m
+      JOIN turns ON turns.id = m.turn_id AND turns.thread_id = m.thread_id
+      JOIN threads ON threads.id = m.thread_id
+      WHERE m.rowid > ? AND m.role = 'assistant' AND m.status = 'complete'
+        AND EXISTS (
+          SELECT 1 FROM monitor_wake_deliveries d
+          WHERE d.turn_id = turns.id AND d.thread_id = turns.thread_id
+            AND d.source_id = threads.source_id AND d.state = 'completed'
+            AND d.disposition IN ('steered', 'follow_up')
+        )
+      ORDER BY m.rowid LIMIT 100
+    `);
+        const remove = this.database.prepare("DELETE FROM message_search WHERE rowid = ?");
+        const insert = this.database.prepare(`
+      INSERT INTO message_search(rowid, body)
+      SELECT ?, (${messageSearchBody("m")}) FROM (SELECT ? AS parts_json) m
+    `);
+        let after = 0;
+        while (true) {
+            const rows = select.all(after);
+            if (rows.length === 0)
+                return;
+            this.transaction(() => {
+                for (const row of rows) {
+                    const normalized = normalizeMonitorTerminalReply(parseParts(row.parts_json));
+                    if (!normalized.changed)
+                        continue;
+                    remove.run(row.row_id);
+                    insert.run(row.row_id, serializeParts(normalized.parts));
+                }
+            });
+            after = rows[rows.length - 1].row_id;
+        }
+    }
     recoverInterruptedTurns() {
         const active = this.listActiveTurnIds();
         for (const turnId of active) {
@@ -2700,17 +3707,28 @@ export class WebStore {
         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 = ?
+        UPDATE live_inputs
+        SET status = 'queued', active_turn_id = NULL, dispatch_started_at = 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(serializeParts(withLiveInputStatus(parseParts(persisted.parts_json), "queued")), now, row.message_id);
+                if (row.dispatch_started_at === null) {
+                    updateInput.run(now, row.id);
+                    this.database.prepare(`
+            UPDATE web_submissions SET reason = 'closed_before_dispatch'
+            WHERE input_id = ? AND outcome = 'live-input' AND reason IS NULL
+          `).run(row.id);
+                    this.writeMessageParts(row.message_id, withLiveInputStatus(parseParts(persisted.parts_json), "queued"), now, { turnId: null });
+                }
+                else {
+                    this.writeMessageParts(row.message_id, withLiveInputStatus(parseParts(persisted.parts_json), "uncertain"), now, { turnId: null });
+                    this.database.prepare("DELETE FROM live_inputs WHERE id = ?").run(row.id);
+                }
             }
             for (const threadId of threadIds) {
                 this.database.prepare("UPDATE threads SET updated_at = ?, revision = revision + 1 WHERE id = ?")
@@ -2726,20 +3744,21 @@ 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, monitorWakeDeliveryKey) {
         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);
-        });
-        return this.requireThreadDetail(turn.thread_id);
+        const write = this.transaction(() => this.finishTurnInTransaction(turnId, status, finalText, errorCode, errorMessage, runtime, replyParts, suppressResponsePush, monitorWakeDeliveryKey));
+        return {
+            ...this.requireThreadDetail(turn.thread_id),
+            ...(write === undefined ? {} : { write }),
+        };
     }
-    finishTurnInTransaction(turnId, status, finalText, errorCode, errorMessage, runtime, replyParts) {
+    finishTurnInTransaction(turnId, status, finalText, errorCode, errorMessage, runtime, replyParts, suppressResponsePush = false, monitorWakeDeliveryKey) {
         const turn = this.requireTurn(turnId);
         if (turn.status !== "running")
-            return;
+            return undefined;
         const existing = this.requireMessage(turn.assistant_message_id);
         let parts = [...existing.parts];
         if (finalText !== undefined && finalText.length > 0)
@@ -2749,17 +3768,30 @@ export class WebStore {
         if (errorMessage !== undefined) {
             parts.push({ type: "error", ...(errorCode === undefined ? {} : { code: errorCode }), message: errorMessage });
         }
+        const monitorAssociated = status === "complete" && this.hasMonitorTurnAssociation(turnId, monitorWakeDeliveryKey);
+        const processJobAssociated = status === "complete" && this.hasProcessJobTurnAssociation(turnId, monitorWakeDeliveryKey);
+        if (processJobAssociated) {
+            parts = normalizeMonitorTerminalReply(parts, true).parts;
+            suppressResponsePush = !hasMonitorReplyContent(parts);
+        }
+        if (monitorAssociated) {
+            const normalized = normalizeMonitorTerminalReply(parts);
+            parts = normalized.parts;
+            // A suppressed callback may still have streamed the sentinel. Preserve a
+            // preceding answer and rich output even when its terminal reply was empty.
+            suppressResponsePush = !hasMonitorReplyContent(parts);
+        }
         const now = this.now();
         const thread = this.requireThread(turn.thread_id);
-        const agent = this.getAgent(thread.sourceId);
+        const agent = this.getStoredAgent(thread.sourceId);
         this.database.prepare(`
         UPDATE turns SET status = ?, finished_at = ?, error_code = ?, error_message = ?,
           model = CASE WHEN ? IS NULL THEN model ELSE ? END,
-          effort = CASE WHEN ? IS NULL THEN effort ELSE ? END
+          effort = CASE WHEN ? IS NULL THEN effort ELSE ? END,
+          effective_effort = CASE WHEN ? IS NULL THEN effective_effort ELSE ? END
         WHERE id = ?
-    `).run(status, now, errorCode ?? null, errorMessage ?? null, runtime?.model ?? null, runtime?.model ?? null, runtime?.effort ?? null, runtime?.effort ?? null, turnId);
-        this.database.prepare("UPDATE messages SET parts_json = ?, status = ?, updated_at = ? WHERE id = ?")
-            .run(serializeParts(parts), status, now, existing.id);
+    `).run(status, now, errorCode ?? null, errorMessage ?? null, runtime?.model ?? null, runtime?.model ?? null, runtime?.effort ?? null, runtime?.effort ?? null, runtime?.effectiveEffort ?? null, runtime?.effectiveEffort ?? null, turnId);
+        const delta = this.writeMessageDelta(existing, parts, now, { status });
         this.database.prepare("UPDATE threads SET updated_at = ?, revision = revision + 1 WHERE id = ?")
             .run(now, turn.thread_id);
         this.recordThreadRevision(turn.thread_id, `turn_${status}`, now);
@@ -2768,7 +3800,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"
@@ -2778,7 +3812,7 @@ export class WebStore {
                         : "run.failed";
             const label = agent?.label ?? "mono-agent";
             const body = status === "complete"
-                ? parts.filter((part) => part.type === "text")
+                ? monitorAssociated ? monitorReplyText(parts) : parts.filter((part) => part.type === "text")
                     .map((part) => part.text)
                     .join(" ")
                 : status === "cancelled"
@@ -2803,10 +3837,14 @@ export class WebStore {
                 notBefore: new Date(new Date(now).getTime() + 3_000).toISOString(),
             });
         }
+        // Re-read rather than reuse `existing`: the settled row is what Task 6
+        // pushes beside the delta, and it carries the turn's finish stamp.
+        return { message: this.requireMessage(existing.id), delta };
     }
     mapThread(row) {
         const runState = this.latestRunState(row.id);
         const preview = this.lastMessagePreview(row.id);
+        const jobActivity = this.jobActivity(row.id);
         return {
             id: row.id,
             sourceId: row.source_id,
@@ -2829,63 +3867,268 @@ export class WebStore {
             ...(preview === undefined ? {} : { lastMessagePreview: preview }),
             messageCount: row.message_count,
             runState,
+            ...(jobActivity === undefined ? {} : { jobActivity }),
             canSend: row.can_send === 1,
             canUpload: row.can_upload === 1,
+            runModel: row.run_model,
+            runEffort: row.run_effort,
+        };
+    }
+    /**
+     * The ONE statement that persists a message's parts.
+     *
+     * Every parts write bumps `seq`, and that count is what makes a content
+     * delta safe to apply: a console holding version N can tell the write that
+     * follows it from one that skipped ahead, and re-read the message instead of
+     * guessing. A write that went straight to `parts_json` would mint content no
+     * delta describes and no sequence number covers, so this is the only place in
+     * the store that names the column. A caller that also moves the row passes
+     * the columns it changes here rather than issuing a second statement.
+     *
+     * Only the two paths a console watches live -- streaming frames and the write
+     * that settles a turn -- go on to build a {@link WebMessageDelta} from this.
+     * Every other caller (a live-input transition, restart recovery, and the
+     * notification, cron-run, process-job and Monitor reconciliations) bumps the
+     * version without describing the change: those writes reach the browser as an
+     * invalidation it answers by re-reading the message, and the new `seq` is what
+     * tells it the re-read is newer than the delta stream it was applying.
+     *
+     * EVERY caller here owes its console a message event -- a delta, or the
+     * `message.changed` naming this row. A subscribed console no longer answers a
+     * conversation summary by re-reading the transcript, so a write announced
+     * only as a summary is one it never sees. `recoverLiveInputs` is the single
+     * exception, and only because it runs at open with no subscriber to tell.
+     */
+    writeMessageParts(id, parts, now, columns = {}) {
+        const assignments = [];
+        const values = [];
+        if (columns.threadId !== undefined) {
+            assignments.push("thread_id = ?");
+            values.push(columns.threadId);
+        }
+        if (columns.turnId !== undefined) {
+            assignments.push("turn_id = ?");
+            values.push(columns.turnId);
+        }
+        assignments.push("parts_json = ?");
+        values.push(serializeParts(parts));
+        if (columns.createdAt !== undefined) {
+            assignments.push("created_at = ?");
+            values.push(columns.createdAt);
+        }
+        assignments.push("updated_at = ?");
+        values.push(now);
+        if (columns.status !== undefined) {
+            assignments.push("status = ?");
+            values.push(columns.status);
+        }
+        const sql = `UPDATE messages SET ${assignments.join(", ")}, seq = seq + 1 WHERE id = ? RETURNING seq`;
+        let statement = this.partsWriteStatements.get(sql);
+        if (statement === undefined) {
+            statement = this.database.prepare(sql);
+            this.partsWriteStatements.set(sql, statement);
+        }
+        const row = statement.get(...values, id);
+        if (row === undefined) {
+            throw new WebConsoleError("storage_corrupt", `Message ${id} is missing from this conversation.`, 500);
+        }
+        return { baseSeq: row.seq - 1, seq: row.seq };
+    }
+    /**
+     * Persist a message's parts and describe the write as a content delta.
+     *
+     * `message` must be the message the new parts were DERIVED from: the diff
+     * compares by reference, so a delta computed against any other read of the
+     * same row would call every part changed.
+     */
+    writeMessageDelta(message, parts, now, columns = {}) {
+        const { baseSeq, seq } = this.writeMessageParts(message.id, parts, now, columns);
+        // The ops describe `message.parts`; `baseSeq` is what the row actually held
+        // when this statement ran. Every caller reads and writes inside one
+        // transaction on a single-writer database, so these agree -- and if they
+        // ever stopped agreeing, the delta would be a self-consistent description
+        // of a version that never existed, which a console applies in silence.
+        // Refusing here turns that into a failure the caller can see.
+        if (baseSeq !== message.seq) {
+            throw new WebConsoleError("storage_corrupt", `Message ${message.id} moved from ${String(message.seq)} to ${String(baseSeq)} while its delta was built.`, 500);
+        }
+        const attribution = message.turnId === undefined
+            ? undefined
+            : runAttribution(this.requireTurn(message.turnId));
+        return {
+            messageId: message.id,
+            baseSeq,
+            seq,
+            status: columns.status ?? message.status,
+            updatedAt: now,
+            ...(attribution === undefined ? {} : { attribution }),
+            ops: diffParts(message.parts, parts),
         };
     }
     mapMessage(row) {
         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 rawParts = parseParts(row.parts_json);
+        const storedParts = row.role === "assistant" && row.status === "complete" && row.turn_id !== null
+            && this.hasMonitorTurnAssociation(row.turn_id)
+            ? normalizeMonitorTerminalReply(rawParts).parts : rawParts;
         const quote = quoteFromParts(storedParts);
         const liveInputStatus = liveInputStatusFromParts(storedParts);
+        const role = normalizeRole(row.role);
+        const finishedAt = role === "assistant" ? this.turnFinishedAt(row) : undefined;
+        const attribution = role === "assistant" && row.turn_id !== null
+            ? runAttribution(this.requireTurn(row.turn_id))
+            : undefined;
         return {
             id: row.id,
             threadId: row.thread_id,
             ...(row.turn_id === null ? {} : { turnId: row.turn_id }),
-            role: normalizeRole(row.role),
+            role,
             ...(quote === undefined ? {} : { quote }),
             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,
+            ...(finishedAt === undefined ? {} : { finishedAt }),
             status: normalizeMessageStatus(row.status),
             ...(liveInputStatus === undefined ? {} : { liveInputStatus }),
+            ...(attribution === undefined ? {} : { attribution }),
+            seq: row.seq,
         };
     }
+    /**
+     * The turn's terminal stamp, which `finishTurnInTransaction` writes with the
+     * message status. A page query projects it from its own join; only a
+     * single-row read pays for a lookup.
+     */
+    turnFinishedAt(row) {
+        if (row.turn_id === null)
+            return undefined;
+        if (row.turn_finished_at !== undefined)
+            return row.turn_finished_at ?? undefined;
+        const turn = this.database.prepare("SELECT finished_at FROM turns WHERE id = ?")
+            .get(row.turn_id);
+        return turn?.finished_at ?? undefined;
+    }
     latestRunState(threadId) {
         const row = this.database.prepare("SELECT * FROM turns WHERE thread_id = ? ORDER BY started_at DESC, rowid DESC LIMIT 1")
             .get(threadId);
         if (row === undefined)
             return { status: "idle" };
         const status = normalizeRunStatus(row.status);
+        const attribution = runAttribution(row);
+        // Successful assistant-only turns without visible reply content are host
+        // no-ops, not a new conversation outcome. Keep their real run state while
+        // projecting the prior meaningful outcome for status priority. Derive this
+        // from retained provenance/normalized parts so old stores need no migration.
+        // Match hasMonitorReplyContent without loading transcript bodies into lists.
+        const candidates = status === "complete" ? this.database.prepare(`
+      SELECT t.id, t.status, t.finished_at, t.assistant_message_id,
+        EXISTS (SELECT 1 FROM messages m WHERE m.turn_id = t.id AND m.role = 'user') AS has_user
+      FROM turns t
+      WHERE t.thread_id = ? AND t.status <> 'running' AND (
+        t.status <> 'complete'
+        OR EXISTS (SELECT 1 FROM messages m WHERE m.turn_id = t.id AND m.role = 'user')
+        OR EXISTS (
+          SELECT 1 FROM messages m, json_each(m.parts_json) p
+          WHERE m.id = t.assistant_message_id AND (
+            json_extract(p.value, '$.type') IN ('attachment', 'mcp_app', 'failure')
+            OR (json_extract(p.value, '$.type') = 'text'
+              AND length(trim(json_extract(p.value, '$.text'), ?)) > 0)
+          )
+        )
+      ) ORDER BY t.started_at DESC, t.rowid DESC
+    `).iterate(threadId, "\u0009\u000a\u000b\u000c\u000d\u0020\u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000\ufeff") : [];
+        let outcome;
+        for (const rawCandidate of candidates) {
+            const candidate = rawCandidate;
+            // Legacy Monitor rows retain raw sentinel bytes and normalize only on
+            // read. Inspect one associated candidate at a time, never materialize the
+            // transcript or rewrite history merely to derive sidebar status.
+            if (candidate.status === "complete" && candidate.has_user === 0 && this.hasMonitorTurnAssociation(candidate.id)) {
+                const message = this.database.prepare("SELECT parts_json FROM messages WHERE id = ?")
+                    .get(candidate.assistant_message_id);
+                if (!hasMonitorReplyContent(normalizeMonitorTerminalReply(parseParts(message.parts_json)).parts))
+                    continue;
+            }
+            outcome = candidate;
+            break;
+        }
+        const lastOutcome = status !== "complete" || outcome?.id === row.id ? undefined
+            : outcome === undefined ? null : {
+                status: normalizeRunStatus(outcome.status),
+                ...(outcome.finished_at === null ? {} : { finishedAt: outcome.finished_at }),
+            };
         return {
             id: row.id,
             status,
             startedAt: row.started_at,
+            ...(lastOutcome === undefined ? {} : { lastOutcome }),
             ...(row.finished_at === null ? {} : { finishedAt: row.finished_at }),
             ...(row.error_message === null
                 ? {}
                 : { error: { ...(row.error_code === null ? {} : { code: row.error_code }), message: row.error_message } }),
             ...(row.model === null ? {} : { model: row.model }),
             ...(row.effort === null ? {} : { effort: row.effort }),
+            ...(attribution === undefined ? {} : { attribution }),
         };
     }
     lastMessagePreview(threadId) {
-        const row = this.database.prepare("SELECT parts_json FROM messages WHERE thread_id = ? ORDER BY created_at DESC, rowid DESC LIMIT 1")
+        const row = this.database.prepare(`SELECT * FROM messages WHERE thread_id = ? AND ${visibleMessageSql("messages")} ORDER BY created_at DESC, rowid DESC LIMIT 1`)
             .get(threadId);
         if (row === undefined)
             return undefined;
-        const text = parseParts(row.parts_json)
-            .filter((part) => part.type === "text" || part.type === "reasoning")
-            .map((part) => part.text)
+        const text = this.mapMessage(row).parts
+            .flatMap((part) => part.type === "text" ? [part.text]
+            : part.type === "process-job" && part.responseText !== undefined ? [part.responseText] : [])
             .join(" ")
             .replace(/\s+/gu, " ")
             .trim();
         return text.length === 0 ? undefined : text.slice(0, 160);
     }
+    jobActivity(threadId) {
+        // Read only retained job cards, including those behind the message page.
+        // Aggregate in SQLite so neither transcripts nor output tails are loaded
+        // into the listing. These rows already advance the thread's revision.
+        const row = this.database.prepare(`
+      WITH jobs AS (
+        SELECT json_extract(part.value, '$.job.state') AS state,
+               json_extract(part.value, '$.job.timestamps.completedAt') AS completed_at,
+               c.response_text, m.rowid AS ordinal
+        FROM messages m
+        JOIN process_job_cards c ON c.message_id = m.id AND c.thread_id = m.thread_id
+        JOIN json_each(m.parts_json) part
+        WHERE m.thread_id = ? AND json_extract(part.value, '$.type') = 'process-job'
+      )
+      SELECT count(*) AS total,
+             count(*) FILTER (WHERE state = 'queued') AS queued,
+             count(*) FILTER (WHERE state = 'starting') AS starting,
+             count(*) FILTER (WHERE state = 'running') AS running,
+             (SELECT json_object('state', state, 'completedAt', completed_at, 'reply', response_text)
+              FROM jobs WHERE completed_at IS NOT NULL
+              ORDER BY julianday(completed_at) DESC, (state <> 'succeeded') DESC, ordinal DESC
+              LIMIT 1) AS latest_terminal
+      FROM jobs
+    `).get(threadId);
+        if (row.total === 0)
+            return undefined;
+        const terminal = row.latest_terminal === null ? undefined : JSON.parse(row.latest_terminal);
+        const replyPreview = terminal?.reply?.replace(/\s+/gu, " ").trim().slice(0, 160);
+        return {
+            queued: row.queued,
+            starting: row.starting,
+            running: row.running,
+            ...(terminal === undefined ? {} : {
+                latestTerminal: {
+                    state: terminal.state,
+                    completedAt: terminal.completedAt,
+                    ...(replyPreview ? { replyPreview } : {}),
+                },
+            }),
+        };
+    }
     cronChannel(sourceId, jobId) {
         return this.database.prepare(`
       SELECT * FROM cron_channels WHERE source_id = ? AND job_id = ?
@@ -3031,8 +4274,85 @@ export class WebStore {
         this.database.prepare("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
             .run(key, value);
     }
+    transactionDepth = 0;
+    claimWebSubmission(input) {
+        return this.transaction(() => {
+            const threadId = this.resolveThreadId(input.threadId);
+            this.requireThread(threadId);
+            const existing = this.database.prepare("SELECT * FROM web_submissions WHERE thread_id = ? AND submission_id = ?").get(threadId, input.submissionId);
+            if (existing !== undefined) {
+                if (existing.payload_sha256 !== input.payloadSha256) {
+                    throw new WebConsoleError("submission_conflict", "Submission id was already used for different content.", 409);
+                }
+                return { created: false, submission: mapWebSubmission(existing) };
+            }
+            const created = input.create();
+            const now = this.now();
+            this.database.prepare(`
+        INSERT INTO web_submissions (
+          thread_id, submission_id, payload_sha256, outcome, reason, message_id, turn_id, input_id, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(threadId, input.submissionId, input.payloadSha256, created.outcome, created.reason ?? null, created.messageId ?? null, created.turnId ?? null, created.inputId ?? null, now);
+            return {
+                created: true,
+                submission: mapWebSubmission(this.database.prepare("SELECT * FROM web_submissions WHERE thread_id = ? AND submission_id = ?").get(threadId, input.submissionId)),
+            };
+        });
+    }
+    webSubmission(threadId, submissionId) {
+        threadId = this.resolveThreadId(threadId);
+        this.requireThread(threadId);
+        const row = this.database.prepare("SELECT * FROM web_submissions WHERE thread_id = ? AND submission_id = ?").get(threadId, submissionId);
+        return row === undefined ? undefined : mapWebSubmission(row);
+    }
+    requireCronReplyOperationRow(operationId) {
+        const row = this.database.prepare("SELECT * FROM cron_reply_operations WHERE operation_id = ?")
+            .get(operationId);
+        if (row === undefined) {
+            throw new WebConsoleError("cron_reply_operation_not_found", "Cron reply operation not found.", 404);
+        }
+        return row;
+    }
+    assertCronReplyIdentity(row, sourceId, jobId, runId) {
+        if (row.source_id !== sourceId || row.job_id !== jobId || row.run_id !== runId) {
+            throw new WebConsoleError("cron_reply_operation_conflict", "Cron reply operation id was used for another run.", 409);
+        }
+    }
+    cronReplyState(row) {
+        if (row.state === "completed") {
+            return { kind: "completed", receipt: this.cronReplyReceipt(row, true) };
+        }
+        if (row.state === "failed")
+            return { kind: "failed", operation: mapCronReplyOperation(row) };
+        if (row.state === "tombstoned")
+            return { kind: "tombstoned", operation: mapCronReplyOperation(row) };
+        return { kind: "pending", operation: mapCronReplyOperation(row) };
+    }
+    cronReplyReceipt(row, duplicate) {
+        if (row.provenance_message_id === null || row.result_message_id === null) {
+            throw new WebConsoleError("storage_corrupt", "Completed cron reply is missing its projected messages.", 500);
+        }
+        const thread = this.getThread(row.thread_id);
+        const provenance = this.getMessage(row.provenance_message_id);
+        const result = this.getMessage(row.result_message_id);
+        if (thread === undefined || provenance === undefined || result === undefined) {
+            throw new WebConsoleError("storage_corrupt", "Completed cron reply projection is missing.", 500);
+        }
+        return {
+            operationId: row.operation_id,
+            sourceId: row.source_id,
+            jobId: row.job_id,
+            runId: row.run_id,
+            duplicate,
+            thread,
+            messages: [provenance, result],
+        };
+    }
     transaction(operation) {
+        if (this.transactionDepth > 0)
+            return operation();
         this.database.exec("BEGIN IMMEDIATE");
+        this.transactionDepth += 1;
         try {
             const result = operation();
             this.database.exec("COMMIT");
@@ -3042,11 +4362,42 @@ export class WebStore {
             this.database.exec("ROLLBACK");
             throw error;
         }
+        finally {
+            this.transactionDepth -= 1;
+        }
     }
     now() {
         return this.clock().toISOString();
     }
 }
+function mapWebSubmission(row) {
+    return {
+        threadId: row.thread_id,
+        submissionId: row.submission_id,
+        payloadSha256: row.payload_sha256,
+        outcome: row.outcome,
+        ...(row.reason === null ? {} : { reason: row.reason }),
+        ...(row.message_id === null ? {} : { messageId: row.message_id }),
+        ...(row.turn_id === null ? {} : { turnId: row.turn_id }),
+        ...(row.input_id === null ? {} : { inputId: row.input_id }),
+    };
+}
+function mapCronReplyOperation(row) {
+    return {
+        operationId: row.operation_id,
+        sourceId: row.source_id,
+        jobId: row.job_id,
+        runId: row.run_id,
+        threadId: row.thread_id,
+        conversationId: row.conversation_id,
+        idempotencyKey: row.idempotency_key,
+        state: row.state,
+        snapshotKind: row.snapshot_kind,
+        ...(row.snapshot_text === null ? {} : { snapshotText: row.snapshot_text }),
+        ...(row.snapshot_sha256 === null ? {} : { snapshotSha256: row.snapshot_sha256 }),
+        ...(row.failure_reason === null ? {} : { failureReason: row.failure_reason }),
+    };
+}
 function mapPushSubscriptionStatus(row) {
     const state = row.state === "disabled" || row.state === "expired"
         ? row.state
@@ -3124,12 +4475,13 @@ 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,
            CASE WHEN t.trigger_kind = 'cron' THEN 0
                 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
+           (SELECT COUNT(*) FROM messages m WHERE m.thread_id = t.id AND ${visibleMessageSql("m")}) AS message_count
     FROM threads t JOIN agents a ON a.source_id = t.source_id
     LEFT JOIN cron_channels cc ON cc.thread_id = t.id
     ${suffix}
@@ -3138,11 +4490,14 @@ function threadSelectSql(suffix) {
 function agentSelectSql(suffix) {
     return `
     SELECT a.*,
+           o.model AS override_model,
+           o.effort AS override_effort,
            CASE WHEN EXISTS (
              SELECT 1 FROM settings s
              WHERE s.key = 'agent_pin:' || a.source_id AND s.value = '1'
            ) THEN 1 ELSE 0 END AS pinned
     FROM agents a
+    LEFT JOIN agent_run_overrides o ON o.source_id = a.source_id
     ${suffix}
   `;
 }
@@ -3224,8 +4579,36 @@ function cronMessageStatus(status) {
         return "cancelled";
     return "complete";
 }
-function cronRunParts(run, prior, conversationId) {
-    const silent = run.status === "succeeded" && classifyNotifySuppression(run.text) !== "none";
+function isTerminalCronRun(status) {
+    return status === "succeeded"
+        || status === "failed"
+        || status === "cancelled"
+        || status === "skipped_overlap"
+        || status === "dropped";
+}
+/** Presentation queries only; storage validation/recovery and retention stay raw. */
+function visibleMessageSql(alias) { return `${alias}.cron_suppressed = 0`; }
+function withoutCronSilentFlag(data) {
+    const { silent: _silent, ...rest } = record(data) ?? {};
+    return rest;
+}
+function clearSilentCronPart(part) {
+    return part.type === "telemetry" && part.event === "cron_run" && record(part.data)?.silent === true
+        ? { ...part, data: withoutCronSilentFlag(part.data) } : part;
+}
+function definitelySilentCronRun(run) {
+    return run.status === "succeeded" && run.fieldsTruncated?.includes("text") !== true
+        && classifyNotifySuppression(run.text) !== "none";
+}
+function hasMeaningfulCronContent(parts) {
+    return parts.some((part) => part.type === "text"
+        ? !isSyntheticCronStateText(part.text) && classifyNotifySuppression(part.text) === "none"
+        : part.type === "attachment" || part.type === "error" || part.type === "mcp_app"
+            || part.type === "failure" || part.type === "process-job" || part.type === "process-job-wake"
+            || part.type === "monitor-activity");
+}
+function cronRunParts(run, prior, conversationId, notificationBacked = false) {
+    const silent = definitelySilentCronRun(run);
     const priorCron = prior.find((part) => part.type === "telemetry" && part.event === "cron_run");
     const priorCronData = record(priorCron?.data);
     const priorActivityLoaded = priorCronData?.activityLoaded === true;
@@ -3235,6 +4618,10 @@ function cronRunParts(run, prior, conversationId) {
     const priorActivityEventCount = Number.isSafeInteger(priorCronData?.activityEventCount)
         ? Number(priorCronData?.activityEventCount)
         : priorLoadedEventCount;
+    const priorDetailFieldsTruncated = Array.isArray(priorCronData?.detailFieldsTruncated)
+        && priorCronData.detailFieldsTruncated.every((field) => typeof field === "string")
+        ? priorCronData.detailFieldsTruncated
+        : undefined;
     const activityLoaded = run.projection === "detail"
         || (priorActivityLoaded && priorActivityEventCount === run.eventCount);
     const activityStale = run.projection === "summary"
@@ -3247,10 +4634,12 @@ function cronRunParts(run, prior, conversationId) {
     // synthetic state/identity before rebuilding it, while retaining a genuine
     // notification text that arrived before the operator run projection.
     const retained = prior.filter((part) => !(part.type === "telemetry" && part.event === "cron_run")
-        && !(part.type === "text" && isSyntheticCronStateText(part.text)));
+        && !(part.type === "text" && !notificationBacked && isSyntheticCronStateText(part.text)));
     const parts = run.projection === "summary"
         ? [...retained]
-        : retained.filter((part) => part.type === "text" || part.type === "error");
+        : retained.filter((part) => part.type === "text" || part.type === "error" || part.type === "attachment"
+            || part.type === "mcp_app" || part.type === "failure" || part.type === "process-job"
+            || part.type === "process-job-wake" || part.type === "monitor-activity");
     for (const event of run.projection === "detail" ? run.events : [])
         applyEvent(parts, event);
     const preserveLoadedText = run.projection === "summary"
@@ -3260,7 +4649,7 @@ function cronRunParts(run, prior, conversationId) {
         && priorActivityLoaded
         && (run.fieldsTruncated?.includes("error") === true
             || run.fieldsTruncated?.includes("failureKind") === true);
-    if (!silent && !preserveLoadedText && run.text !== undefined && run.text.length > 0) {
+    if (!notificationBacked && !silent && !preserveLoadedText && run.text !== undefined && run.text.length > 0) {
         reconcileFinalText(parts, run.text);
     }
     const hasText = parts.some((part) => part.type === "text" && part.text.trim().length > 0);
@@ -3304,7 +4693,7 @@ function cronRunParts(run, prior, conversationId) {
             sequence: run.sequence,
             trigger: run.trigger,
             status: run.status,
-            ...(silent ? { silent: true } : {}),
+            ...(silent && !hasMeaningfulCronContent(parts) ? { silent: true } : {}),
             ...(run.startedAt === undefined ? {} : { startedAt: run.startedAt }),
             ...(run.completedAt === undefined ? {} : { completedAt: run.completedAt }),
             ...(run.artifactRunId === undefined ? {} : { artifactRunId: run.artifactRunId }),
@@ -3319,6 +4708,9 @@ function cronRunParts(run, prior, conversationId) {
                 : {}),
             ...(activityStale ? { activityStale: true, loadedEventCount: priorLoadedEventCount } : {}),
             ...(eventsTruncated ? { eventsTruncated: true } : {}),
+            ...(run.projection === "detail"
+                ? { detailFieldsTruncated: run.fieldsTruncated ?? [] }
+                : priorDetailFieldsTruncated === undefined ? {} : { detailFieldsTruncated: priorDetailFieldsTruncated }),
             ...(run.fieldsTruncated === undefined ? {} : { fieldsTruncated: run.fieldsTruncated }),
         },
     });
@@ -3390,7 +4782,9 @@ function parseStoredCronRun(serialized) {
             ...(legacyEvents === undefined ? {} : { eventsTruncated: true }),
         }
         : raw);
-    if (run.projection !== "summary"
+    if ((run.text !== undefined && typeof run.text !== "string")
+        || (run.fieldsTruncated !== undefined && (!Array.isArray(run.fieldsTruncated) || run.fieldsTruncated.some((field) => typeof field !== "string")))
+        || run.projection !== "summary"
         || typeof run.runId !== "string"
         || typeof run.jobId !== "string"
         || typeof run.scheduledAt !== "string"
@@ -3460,6 +4854,8 @@ 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);
+    const runSettings = agentRunSettings(row);
     return {
         sourceId: row.source_id,
         label: row.label,
@@ -3467,11 +4863,14 @@ function mapAgent(row) {
         pinned: row.pinned === 1,
         ...(row.health === null ? {} : { health: row.health }),
         supportsAttachments: row.supports_attachments === 1,
+        ...(row.supports_provider_auth === 1 ? { supportsProviderAuth: true } : {}),
         ...(models === undefined ? {} : { models }),
         ...(row.default_model === null ? {} : { defaultModel: row.default_model }),
         ...(row.default_effort === null ? {} : { defaultEffort: row.default_effort }),
         ...(efforts === undefined ? {} : { efforts }),
         ...(modelOptions === undefined ? {} : { modelOptions }),
+        runSettings,
+        ...(providers === undefined ? {} : { providers }),
         ...(row.cron_read === 1
             ? { cron: { read: true, actions: row.cron_actions === 1 } }
             : {}),
@@ -3479,6 +4878,30 @@ function mapAgent(row) {
         updatedAt: row.updated_at,
     };
 }
+function agentRunSettings(row) {
+    const effectiveModel = row.override_model ?? row.default_model;
+    const effectiveEffort = row.override_effort ?? row.default_effort;
+    const config = {
+        ...(row.default_model === null ? {} : { model: row.default_model }),
+        ...(row.default_effort === null ? {} : { effort: row.default_effort }),
+    };
+    const override = row.override_model === null && row.override_effort === null
+        ? null
+        : {
+            ...(row.override_model === null ? {} : { model: row.override_model }),
+            ...(row.override_effort === null ? {} : { effort: row.override_effort }),
+        };
+    return {
+        config,
+        override,
+        effective: {
+            ...(effectiveModel === null ? {} : { model: effectiveModel }),
+            modelSource: row.override_model === null ? "config" : "override",
+            ...(effectiveEffort === null ? {} : { effort: effectiveEffort }),
+            effortSource: row.override_effort === null ? "config" : "override",
+        },
+    };
+}
 function mapStoredAttachment(row) {
     return {
         id: row.id,
@@ -3519,12 +4942,28 @@ 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, resolveProcessJobWake) {
     if (event.type === "assistant_thought") {
         appendTextPart(parts, "reasoning", event.text);
         return;
     }
     if (event.type === "tool_call_started") {
+        if (appliedMonitorWake(event, resolveMonitorWake) !== undefined)
+            return;
+        if (appliedProcessJobWake(event, resolveProcessJobWake) !== undefined)
+            return;
         const historyUpdate = canonicalEventHistoryUpdate(event.history);
         const subagent = subagentOf(event);
         if (subagent !== undefined) {
@@ -3566,6 +5005,19 @@ 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 processJobWake = appliedProcessJobWake(event, resolveProcessJobWake);
+        if (processJobWake !== undefined) {
+            if (!parts.some((part) => part.type === "process-job-wake"
+                && part.deliveryKey === processJobWake.deliveryKey)) {
+                parts.push({ type: "process-job-wake", ...processJobWake, disposition: "steered" });
+            }
+            return;
+        }
         const status = event.isError === true ? "failed" : "complete";
         const historyUpdate = canonicalEventHistoryUpdate(event.history);
         const executionMs = canonicalExecutionMs(event.executionMs);
@@ -3578,6 +5030,7 @@ function applyEvent(parts, event) {
                     status,
                     ...(executionMs === undefined ? {} : { executionMs }),
                     ...(subagent.costUsd === undefined ? {} : { costUsd: subagent.costUsd }),
+                    ...(subagent.attribution === undefined ? {} : { attribution: subagent.attribution }),
                 }, historyUpdate));
                 return;
             }
@@ -3610,10 +5063,10 @@ function applyEvent(parts, event) {
             toolName: event.name ?? existingToolName(parts, event.id) ?? "Tool",
             ...(event.arguments === undefined ? {} : { args: event.arguments }),
             ...(event.content === undefined ? {} : { result: event.content }),
-            // `result` is the model-facing text and cannot answer "what did this tool
-            // actually decide". The AskUser card needs `interactionId`/`answered` to
-            // re-render an answered question after a reload, so keep the structured
-            // payload beside the prose rather than reparsing the sentence.
+            // `result` is model-facing and cannot answer "what did this tool actually
+            // decide". Keep bounded MCP and canonical host outcomes beside the prose:
+            // AskUser needs its answer identity after reload, and process-job launches
+            // need their exact causal receipt rather than reparsing a sentence.
             ...(event.structuredContent === undefined ? {} : { structuredResult: event.structuredContent }),
             ...(executionMs === undefined ? {} : { executionMs }),
             status,
@@ -3626,6 +5079,42 @@ function applyEvent(parts, event) {
     }
     parts.push({ type: "telemetry", event: event.type, data: event });
 }
+function appliedProcessJobWake(event, resolveProcessJobWake) {
+    if (resolveProcessJobWake === undefined
+        || event.metadata?.liveInput !== true
+        || event.metadata?.synthetic !== true
+        || typeof event.metadata.inputId !== "string") {
+        return undefined;
+    }
+    return resolveProcessJobWake(event.metadata.inputId);
+}
+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;
@@ -3697,11 +5186,13 @@ function subagentOf(event) {
     const costUsd = typeof record.costUsd === "number" && Number.isFinite(record.costUsd) && record.costUsd > 0
         ? record.costUsd
         : undefined;
+    const attribution = canonicalRunAttribution(record.attribution);
     return {
         id: canonicalId,
         name: name.length === 0 ? "subagent" : name,
         ...(label.length === 0 ? {} : { label }),
         ...(costUsd === undefined ? {} : { costUsd }),
+        ...(attribution === undefined ? {} : { attribution }),
     };
 }
 /** Drop the `<profile>▸` prefix: the group header already names the profile. */
@@ -3781,19 +5272,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`.
@@ -3812,7 +5310,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;
@@ -3922,6 +5420,81 @@ function replaceWholeText(parts, text) {
             parts.splice(index, 1);
     }
 }
+/**
+ * The ops that turn `prev` into `next`.
+ *
+ * Parts are compared by REFERENCE, which is sound only because every helper
+ * above replaces the slot it touches with a new object instead of editing the
+ * one already there — `store.test.ts` freezes a write path's previous parts to
+ * keep it that way. A truncate leads, so no later op can name an index the
+ * shortened array no longer has; the rest ascend, so a replay that walks them
+ * in order only ever extends the array by one slot at a time.
+ */
+export function diffParts(prev, next) {
+    const ops = [];
+    if (next.length < prev.length)
+        ops.push({ op: "truncate", length: next.length });
+    for (let index = 0; index < next.length; index += 1) {
+        const after = next[index];
+        if (after === undefined)
+            continue;
+        const before = prev[index];
+        if (before === after)
+            continue;
+        // A streaming answer grows by its tail, which is the whole point of the
+        // exercise: sending the delta rather than the message again is what takes
+        // a long answer's per-frame cost off the wire.
+        if (before !== undefined
+            && (after.type === "text" || after.type === "reasoning")
+            && before.type === after.type
+            && after.text.startsWith(before.text)) {
+            const delta = after.text.slice(before.text.length);
+            if (delta.length > 0)
+                ops.push({ op: "append", index, delta });
+            continue;
+        }
+        ops.push({ op: "set", index, part: after });
+    }
+    return ops;
+}
+/**
+ * Replay `ops` onto `parts`, the exact inverse of {@link diffParts}.
+ *
+ * This is the shared definition of what an op MEANS, so the console can apply a
+ * delta without inventing its own reading of one. Anything the ops cannot mean
+ * against these parts throws rather than producing a plausible transcript: a
+ * client that lands here has missed a write and must re-read the message.
+ *
+ * The throws are plain `RangeError`/`TypeError` rather than `WebConsoleError`:
+ * this is a pure function that runs on both sides of the wire, so it has no
+ * request to answer and no HTTP status to pick. Its caller re-reads the message
+ * rather than mapping a code.
+ */
+export function applyDeltaOps(parts, ops) {
+    let next = [...parts];
+    for (const op of ops) {
+        if (op.op === "truncate") {
+            if (!Number.isInteger(op.length) || op.length < 0 || op.length > next.length) {
+                throw new RangeError(`A message delta truncates to ${String(op.length)} parts, which is out of range for ${String(next.length)}.`);
+            }
+            next = next.slice(0, op.length);
+            continue;
+        }
+        if (!Number.isInteger(op.index) || op.index < 0 || op.index > next.length) {
+            throw new RangeError(`A message delta names part ${String(op.index)}, which is out of range for ${String(next.length)}.`);
+        }
+        if (op.op === "set") {
+            next[op.index] = op.part;
+            continue;
+        }
+        const target = next[op.index];
+        if (target === undefined || (target.type !== "text" && target.type !== "reasoning")) {
+            throw new TypeError(`A message delta appends to part ${String(op.index)}, which cannot be appended to.`);
+        }
+        next[op.index] = { type: target.type, text: `${target.text}${op.delta}` };
+    }
+    return next;
+}
 function deriveAutomaticTitle(text, attachments) {
     const candidate = text.trim().length > 0 ? text : attachments[0]?.name ?? "New conversation";
     return normalizeTitle(candidate.replace(/\s+/gu, " ").slice(0, 80));
@@ -4230,6 +5803,13 @@ 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);
+    }
+    const wakeKeys = parts.flatMap((part) => part.type === "process-job-wake" ? [part.deliveryKey] : []);
+    if (new Set(wakeKeys).size !== wakeKeys.length) {
+        throw new WebConsoleError("storage_corrupt", "Persisted process-job wake activity is duplicated.", 500);
+    }
     quoteFromParts(parts);
     return parts;
 }
@@ -4256,7 +5836,7 @@ function liveInputStatusFromParts(parts) {
         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") {
+    if (status !== "pending" && status !== "applied" && status !== "queued" && status !== "cancelled" && status !== "uncertain") {
         throw new WebConsoleError("storage_corrupt", "Persisted live-input status is invalid.", 500);
     }
     return status;
@@ -4309,7 +5889,9 @@ function canonicalSessionToolHistoryMetadata(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return undefined;
     const history = value;
-    const valid = (history.persistence === "persisted" || history.persistence === "failed")
+    const valid = (history.persistence === "persisted"
+        || history.persistence === "deferred"
+        || history.persistence === "failed")
         && history.untrusted === true
         && (history.recordId === undefined || boundedHistoryString(history.recordId, 4_096))
         && (history.sequence === undefined || positiveSafeInteger(history.sequence))
@@ -4376,8 +5958,11 @@ function canonicalizePersistedPartHistory(value) {
     if (part.type !== "subagent")
         return value;
     const canonicalPart = canonicalizePersistedObjectHistory(part);
+    const { attribution: _rawAttribution, ...withoutAttribution } = canonicalPart;
+    const attribution = canonicalRunAttribution(part.attribution);
     return {
-        ...canonicalPart,
+        ...withoutAttribution,
+        ...(attribution === undefined ? {} : { attribution }),
         ...(Array.isArray(part.calls)
             ? { calls: part.calls.map((call) => canonicalizePersistedHistoryRecord(call)) }
             : {}),
@@ -4435,6 +6020,7 @@ function isWebMessagePart(value) {
             && (part.label === undefined || typeof part.label === "string")
             && (part.executionMs == null || typeof part.executionMs === "number")
             && (part.costUsd === undefined || typeof part.costUsd === "number")
+            && (part.attribution === undefined || canonicalRunAttribution(part.attribution) !== undefined)
             && (part.history === undefined || isSessionToolHistoryMetadata(part.history))
             && isWebToolCallStatus(part.status)
             && Array.isArray(part.calls)
@@ -4453,6 +6039,59 @@ function isWebMessagePart(value) {
             return false;
         }
     }
+    if (part.type === "process-job-wake") {
+        return hasOnlyKeys(part, new Set(["type", "jobId", "deliveryKey", "disposition"]))
+            && validRichId(part.jobId)
+            && typeof part.deliveryKey === "string"
+            && part.deliveryKey.length > 0
+            && part.deliveryKey.length <= 1_024
+            && !/[\u0000-\u001f\u007f]/u.test(part.deliveryKey)
+            && (part.disposition === "steered" || part.disposition === "follow_up");
+    }
+    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")
@@ -4575,6 +6214,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;
@@ -4604,16 +6275,187 @@ function normalizeRunStatus(value) {
         ? value
         : "complete";
 }
+const WEB_ROUTE_HISTORY_MAX_ENTRIES = 32;
+function canonicalRouteString(value, maxCharacters = 256) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().slice(0, maxCharacters);
+    return normalized.length === 0 ? undefined : normalized;
+}
+function canonicalRouteIndex(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : undefined;
+}
+function canonicalRouteTransition(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const from = canonicalRouteString(record.from);
+    const to = canonicalRouteString(record.to);
+    if (from === undefined || to === undefined)
+        return undefined;
+    const attemptIndex = canonicalRouteIndex(record.attemptIndex);
+    const reason = canonicalRouteString(record.reason, 128);
+    return {
+        from,
+        to,
+        ...(attemptIndex === undefined ? {} : { attemptIndex }),
+        ...(reason === undefined ? {} : { reason }),
+    };
+}
+function canonicalRouteRetry(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const model = canonicalRouteString(record.model);
+    const retryIndex = canonicalRouteIndex(record.retryIndex);
+    const attempts = canonicalRouteIndex(record.attempts);
+    const reason = canonicalRouteString(record.reason, 128);
+    return {
+        ...(model === undefined ? {} : { model }),
+        ...(retryIndex === undefined ? {} : { retryIndex }),
+        ...(attempts === undefined ? {} : { attempts }),
+        ...(reason === undefined ? {} : { reason }),
+    };
+}
+function boundedRouteEntries(entries) {
+    if (entries.length <= WEB_ROUTE_HISTORY_MAX_ENTRIES)
+        return { entries, truncated: false };
+    return {
+        entries: [entries[0], ...entries.slice(-(WEB_ROUTE_HISTORY_MAX_ENTRIES - 1))],
+        truncated: true,
+    };
+}
+function canonicalRoutingState(value) {
+    const record = typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+    const transitions = boundedRouteEntries((Array.isArray(record.transitions) ? record.transitions : [])
+        .map(canonicalRouteTransition)
+        .filter((entry) => entry !== undefined));
+    const retries = boundedRouteEntries((Array.isArray(record.retries) ? record.retries : [])
+        .map(canonicalRouteRetry)
+        .filter((entry) => entry !== undefined));
+    return {
+        transitions: transitions.entries,
+        retries: retries.entries,
+        ...(record.truncated === true || transitions.truncated || retries.truncated ? { truncated: true } : {}),
+    };
+}
+function parseRoutingState(value) {
+    try {
+        return canonicalRoutingState(JSON.parse(value));
+    }
+    catch {
+        throw new WebConsoleError("storage_corrupt", "Persisted turn routing metadata is not valid JSON.", 500);
+    }
+}
+function serializeRoutingState(value) {
+    return JSON.stringify(canonicalRoutingState(value));
+}
+function appendRouteTransition(state, entry) {
+    const bounded = boundedRouteEntries([...state.transitions, entry]);
+    return {
+        ...state,
+        transitions: bounded.entries,
+        ...(state.truncated === true || bounded.truncated ? { truncated: true } : {}),
+    };
+}
+function appendRouteRetry(state, entry) {
+    const bounded = boundedRouteEntries([...state.retries, entry]);
+    return {
+        ...state,
+        retries: bounded.entries,
+        ...(state.truncated === true || bounded.truncated ? { truncated: true } : {}),
+    };
+}
+function canonicalRunSelection(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const model = canonicalRouteString(record.model);
+    const effort = canonicalRouteString(record.effort, 64);
+    return {
+        ...(model === undefined ? {} : { model }),
+        ...(effort === undefined ? {} : { effort }),
+    };
+}
+function canonicalRunExecution(value) {
+    const selection = canonicalRunSelection(value);
+    if (selection === undefined)
+        return undefined;
+    const effectiveEffort = canonicalRouteString(value.effectiveEffort, 64);
+    return {
+        ...selection,
+        ...(effectiveEffort === undefined ? {} : { effectiveEffort }),
+    };
+}
+function canonicalRunAttribution(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const requested = canonicalRunSelection(record.requested);
+    if (requested === undefined
+        || (record.disposition !== "requested" && record.disposition !== "fallback" && record.disposition !== "unknown")) {
+        return undefined;
+    }
+    const attempted = canonicalRunExecution(record.attempted);
+    const executed = canonicalRunExecution(record.executed);
+    const routing = canonicalRoutingState(record);
+    return {
+        requested,
+        ...(attempted === undefined ? {} : { attempted }),
+        ...(executed === undefined ? {} : { executed }),
+        disposition: record.disposition,
+        transitions: routing.transitions,
+        retries: routing.retries,
+        ...(record.truncated === true || routing.truncated === true ? { truncated: true } : {}),
+    };
+}
+function runAttribution(row) {
+    const requestedModel = canonicalRouteString(row.requested_model);
+    const requestedEffort = canonicalRouteString(row.requested_effort, 64);
+    const requested = {
+        ...(requestedModel === undefined ? {} : { model: requestedModel }),
+        ...(requestedEffort === undefined ? {} : { effort: requestedEffort }),
+    };
+    const attemptedModel = canonicalRouteString(row.model);
+    const attemptedEffort = canonicalRouteString(row.effort, 64);
+    const effectiveEffort = canonicalRouteString(row.effective_effort, 64);
+    const attempted = {
+        ...(attemptedModel === undefined ? {} : { model: attemptedModel }),
+        ...(attemptedEffort === undefined ? {} : { effort: attemptedEffort }),
+        ...(effectiveEffort === undefined ? {} : { effectiveEffort }),
+    };
+    const routing = parseRoutingState(row.routing_json);
+    const hasRequested = requested.model !== undefined || requested.effort !== undefined;
+    const hasAttempted = attempted.model !== undefined || attempted.effort !== undefined || attempted.effectiveEffort !== undefined;
+    if (!hasRequested && !hasAttempted && routing.transitions.length === 0 && routing.retries.length === 0)
+        return undefined;
+    const executed = row.status === "complete" && hasAttempted ? attempted : undefined;
+    const fallback = routing.transitions.length > 0
+        || (executed?.model !== undefined && requested.model !== undefined && executed.model !== requested.model);
+    return {
+        requested,
+        ...(hasAttempted ? { attempted } : {}),
+        ...(executed === undefined ? {} : { executed }),
+        disposition: requested.model === undefined ? "unknown" : fallback ? "fallback" : "requested",
+        transitions: routing.transitions,
+        retries: routing.retries,
+        ...(routing.truncated === true ? { truncated: true } : {}),
+    };
+}
 function runtimeMetadata(metadata) {
     const runtime = metadata?.runtime;
     if (typeof runtime !== "object" || runtime === null || Array.isArray(runtime))
         return undefined;
     const record = runtime;
-    const model = typeof record.model === "string" ? record.model : undefined;
-    const effort = typeof record.effort === "string" ? record.effort : undefined;
-    return model === undefined && effort === undefined ? undefined : {
+    const model = canonicalRouteString(record.model);
+    const effort = canonicalRouteString(record.effort, 64);
+    const effectiveEffort = canonicalRouteString(record.effectiveEffort, 64);
+    return model === undefined && effort === undefined && effectiveEffort === undefined ? undefined : {
         ...(model === undefined ? {} : { model }),
         ...(effort === undefined ? {} : { effort }),
+        ...(effectiveEffort === undefined ? {} : { effectiveEffort }),
     };
 }
 function ignoreMissing(error) {