@pasko70/pibo 3.4.4 → 3.5.1

package/dist/apps/chat/web-app.js

@@ -1,3 +1,11 @@
+import { Readable } from "node:stream";
+import { BoundedEventStream } from "./bounded-event-stream.js";
+import { boundedMessageBytes } from "../../data/bounded-worker-client.js";
+import { TraceResponseCache } from "./trace-response-cache.js";
+import { AsyncChatReadQueries } from "../../data/async-chat-reads.js";
+import { MessageCommandDispatcher } from "./message-command-dispatcher.js";
+import { piboHomePath } from "../../core/pibo-home.js";
+import { AsyncChatStorage } from "../../data/async-chat-storage.js";
 import { createHash, randomUUID } from "node:crypto";
 import os from "node:os";
 import { dirname, join } from "node:path";
@@ -25,7 +33,7 @@ import { loadPiboModelDefaults, } from "../../core/model-defaults.js";
 import { inspectPiboContextBuild } from "../../core/context-build.js";
 import { isPiboThinkingLevel } from "../../core/thinking.js";
 import { loadPiboUserSettings, updateTelemetryRetentionLastPrunedAt } from "../../core/user-settings.js";
-import { isTelemetryRetentionMaintenanceDue, maybeRunTelemetryRetentionMaintenance } from "./telemetry-retention-service.js";
+import { disposeTelemetryRetentionMaintenance, isTelemetryRetentionMaintenanceDue, maybeRunTelemetryRetentionMaintenance } from "./telemetry-retention-service.js";
 import { loadModelCatalog } from "./model-catalog.js";
 import { createCustomAgentProfileDefinition, createCustomAgentRuntimeValidationProfile } from "./agent-profiles.js";
 import { createDefaultPiboReliabilityStore, PiboReliabilityStore } from "../../reliability/store.js";
@@ -33,7 +41,7 @@ import { listMcpServerInfos } from "../../mcp/agent-context.js";
 import { getDefaultPiboWorkspace } from "../../core/workspace.js";
 import { findPiPackage, listPiPackages } from "../../pi-packages/store.js";
 import { ScopedUserSkillManager } from "../../user-skills/manager.js";
-import { ChatDataIngestService, outputIdempotencyKey, outputPersistenceDeliveryKey, outputPersistenceErrorIsRetryable } from "../../data/ingest-service.js";
+import { ChatDataIngestService, legacyOutputIdempotencyKey, outputIdempotencyKey, outputPersistenceDeliveryKey, outputPersistenceErrorIsRetryable } from "../../data/ingest-service.js";
 import { ChatEventCommandService } from "./data/event-command-service.js";
 import { ChatReadStateService } from "./data/read-state-service.js";
 import { ChatRoomService, PiboRoomHierarchyCycleError } from "./data/room-service.js";
@@ -114,20 +122,28 @@ const RELIABILITY_INLINE_PAYLOAD_MAX_BYTES = 64 * 1024;
 const RESOURCE_WARNING_RING_MAX = 25;
 function writeSse(controller, event, payload, id) {
     const encoder = new TextEncoder();
-    if (id)
-        controller.enqueue(encoder.encode(`id: ${id}\n`));
-    controller.enqueue(encoder.encode(`event: ${event}\n`));
-    controller.enqueue(encoder.encode(`data: ${JSON.stringify(payload)}\n\n`));
+    try {
+        boundedMessageBytes(payload, 2 * 1024 * 1024 - 1024);
+    }
+    catch {
+        controller.error(Error("Oversized SSE frame requires cursor replay"));
+        return;
+    }
+    controller.enqueue(encoder.encode(`${id ? `id: ${id}\n` : ""}event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`));
 }
 function writeSseComment(controller, comment) {
     controller.enqueue(new TextEncoder().encode(`: ${comment}\n\n`));
 }
 function writeJsonSse(controller, event, payload, id) {
     const encoder = new TextEncoder();
-    if (id)
-        controller.enqueue(encoder.encode(`id: ${id}\n`));
-    controller.enqueue(encoder.encode(`event: ${event}\n`));
-    controller.enqueue(encoder.encode(`data: ${JSON.stringify(payload)}\n\n`));
+    try {
+        boundedMessageBytes(payload, 2 * 1024 * 1024 - 1024);
+    }
+    catch {
+        controller.error(Error("Oversized SSE frame requires cursor replay"));
+        return;
+    }
+    controller.enqueue(encoder.encode(`${id ? `id: ${id}\n` : ""}event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`));
 }
 function compactSignalStatusPatch(patch) {
     return {
@@ -321,7 +337,12 @@ function serializeGatewayResourceDiagnostics(state) {
             maxMs: Number.isFinite(state.eventLoopDelay.max) ? state.eventLoopDelay.max / 1_000_000 : 0,
             p95Ms: state.eventLoopDelay.percentile(95) / 1_000_000,
         },
+        readWorker: state.readQueries?.status(),
         streams: {
+            boundedConnections: state.boundedStreams.size,
+            queuedBytes: [...state.boundedStreams].reduce((sum, stream) => sum + stream.status().bytes, 0),
+            oldestQueuedAgeMs: Math.max(0, ...[...state.boundedStreams].map(stream => stream.status().oldestAgeMs)),
+            budgetDisconnects: state.boundedStreamDisconnects,
             liveListeners: state.liveListeners.size,
             activeEventStreams,
             activeTraceSessions: state.activeTraceSessions.size,
@@ -391,6 +412,8 @@ function createFastTraceV2Version(input) {
         },
         productHistory: {
             messageCount: input.productHistory?.messageCount ?? 0,
+            revision: input.productHistory?.revision ?? 0,
+            complete: input.productHistory?.complete ?? true,
             firstEventSequence: input.productHistory?.firstEventSequence ?? null,
             lastEventSequence: input.productHistory?.lastEventSequence ?? null,
             lastCreatedAt: input.productHistory?.lastCreatedAt ?? null,
@@ -401,7 +424,7 @@ function createFastTraceV2Version(input) {
         .digest("hex");
 }
 function ensureEventIndexing(state, context) {
-    if (state.subscribedContext === context && state.unsubscribe)
+    if (state.subscribedContext?.channelContext === context.channelContext && state.unsubscribe)
         return;
     state.unsubscribe?.();
     state.subscribedContext = context;
@@ -487,7 +510,7 @@ function createWebOutputPersistenceJob(input) {
         onDeadLetter: input.onDeadLetter,
     };
 }
-function deliverWebOutputPersistenceState(state, context, retryContext) {
+async function deliverWebOutputPersistenceState(state, context, retryContext) {
     const persistenceState = parseWebOutputPersistenceState(retryContext.payload);
     if (!persistenceState)
         throw new Error("Invalid durable web output persistence state");
@@ -507,29 +530,37 @@ function deliverWebOutputPersistenceState(state, context, retryContext) {
         try {
             if (!delivery.v2) {
                 const createdAt = new Date().toISOString();
-                const ingested = state.ingestService.ingestOutputEvent({
+                const ingestInput = {
                     session,
                     roomId: persistenceState.roomId,
                     actorId: persistenceState.actorId ?? session.id,
                     event: delivery.event,
                     createdAt,
-                });
-                const storedEvent = state.dataStore.eventLog.findByIdempotencyKey(delivery.deliveryId);
-                if (!storedEvent || storedEvent.streamId !== ingested.streamId) {
+                    persistenceProvenance: {
+                        producer: "chat-web",
+                        projection: "product-history",
+                        phase: retryContext.attempt > 1 ? "durable-replay" : "live",
+                    },
+                };
+                const asyncIngested = state.asyncStorage ? await state.asyncStorage.ingestOutput(ingestInput) : undefined;
+                const ingested = asyncIngested ?? state.ingestService.ingestOutputEvent(ingestInput);
+                const storedEvent = asyncIngested?.stored ?? state.dataStore.eventLog.findByIdempotencyKey(delivery.deliveryId);
+                if (!storedEvent || (!asyncIngested && "streamId" in storedEvent && storedEvent.streamId !== ingested.streamId)) {
                     throw new Error(`Missing V2 event ${ingested.streamId} for ${delivery.deliveryId}`);
                 }
                 delivery.v2 = {
                     streamId: ingested.streamId,
                     createdAt: storedEvent.createdAt,
-                    eventId: eventIdentityForDelivery(delivery.event),
+                    eventId: asyncIngested?.stored.eventId ?? eventIdentityForDelivery(delivery.event),
                     duplicate: ingested.duplicate,
                 };
                 checkpoint();
             }
+            state.commandDispatcher?.outputPersisted(delivery.event);
             if (!delivery.reliabilityDelivered) {
                 if (delivery.reliabilityPayload === undefined) {
                     delivery.reliabilityPayload = boundedReliabilityOutputPayload(state, delivery.event);
-                    checkpoint();
+                    // Preparation is replayable; checkpoint together with the confirmed append below.
                 }
                 const deliveryKey = delivery.deliveryId;
                 state.reliabilityStore.appendOnce({
@@ -545,10 +576,19 @@ function deliverWebOutputPersistenceState(state, context, retryContext) {
             }
             if (!delivery.sideEffectsDelivered && state.reliabilityStore.hasDeliveryReceipt(delivery.deliveryId, "chat-web-observable-v1")) {
                 delivery.sideEffectsDelivered = true;
-                checkpoint();
+                // The durable receipt is authoritative; the job can now finish without another payload rewrite.
             }
             else if (!delivery.sideEffectsDelivered) {
-                const stored = storedChatEventForDelivery(persistenceState, delivery);
+                let stored = storedChatEventForDelivery(persistenceState, delivery);
+                try {
+                    boundedMessageBytes(stored.payload, 64 * 1024);
+                }
+                catch {
+                    const [persisted] = await (state.readQueries?.timeline ?? state.timelineQuery).listEvents({ piboSessionId: stored.piboSessionId, afterStreamId: stored.streamId - 1, limit: 1 });
+                    if (!persisted || persisted.streamId !== stored.streamId)
+                        throw new Error("Persisted output unavailable for live delivery");
+                    stored = persisted;
+                }
                 if (delivery.event.type === "assistant_message" || delivery.event.type === "message_finished" || delivery.event.type === "session_error") {
                     markActiveSessionRead(state, delivery.event.piboSessionId, stored.streamId);
                 }
@@ -566,7 +606,7 @@ function deliverWebOutputPersistenceState(state, context, retryContext) {
                 // recording before sends would trade duplicates for silent loss.
                 state.reliabilityStore.recordDeliveryReceipt(delivery.deliveryId, "chat-web-observable-v1");
                 delivery.sideEffectsDelivered = true;
-                checkpoint();
+                // The durable receipt is authoritative; the job can now finish without another payload rewrite.
             }
         }
         catch (error) {
@@ -625,7 +665,7 @@ function parseWebOutputPersistenceState(value) {
         if (!isPiboOutputEvent(delivery.event) || !outputIdempotencyKey(delivery.event))
             return undefined;
         const deliveryId = outputPersistenceDeliveryKey(delivery.event);
-        if (delivery.deliveryId !== undefined && delivery.deliveryId !== deliveryId)
+        if (delivery.deliveryId !== undefined && delivery.deliveryId !== deliveryId && delivery.deliveryId !== legacyOutputIdempotencyKey(delivery.event))
             return undefined;
         const v2 = delivery.v2;
         if (v2 !== undefined && (!v2 || typeof v2 !== "object" || Array.isArray(v2)
@@ -754,12 +794,45 @@ function markActiveSessionRead(state, piboSessionId, streamId) {
         return;
     state.readState.markSessionRead(piboSessionId, streamId);
 }
+async function readNavigationIndex(state, roomId) {
+    if (!state.readQueries)
+        return state.sessionQuery.listSessions(roomId);
+    const items = [];
+    let afterId;
+    for (;;) {
+        const page = await state.readQueries.navigation.sessionIndexPage({ roomId, afterId, limit: 500 });
+        items.push(...page);
+        if (page.length < 500)
+            break;
+        afterId = page.at(-1).piboSessionId;
+    }
+    return items;
+}
+const sharedSessionSnapshots = new Map();
 function listSharedSessions(context) {
-    const sessions = context.channelContext.listSessions?.() ?? context.channelContext.findSessions({});
+    const revision = context.channelContext.getSessionStructureRevision?.();
     const profiles = context.channelContext.getProfiles?.();
-    return sessions
-        .map((session) => canonicalizeSessionProfile(context, session, profiles))
-        .sort(compareChatWebSessionsBySidebarOrder);
+    const profileKey = JSON.stringify(profiles?.map(profile => [profile.name, profile.aliases]) ?? []);
+    const cached = sharedSessionSnapshots.get(context.channelContext);
+    if (revision !== undefined && cached?.revision === revision && cached.profiles === profileKey)
+        return cached.sessions.slice();
+    const sessions = (context.channelContext.listSessions?.() ?? context.channelContext.findSessions({})).map(session => canonicalizeSessionProfile(context, session, profiles)).sort(compareChatWebSessionsBySidebarOrder);
+    if (revision !== undefined) {
+        sharedSessionSnapshots.delete(context.channelContext);
+        try {
+            let bytes = 16;
+            for (const session of sessions) {
+                bytes += boundedMessageBytes(session, 16 * 1024 * 1024 - bytes);
+                if (bytes > 16 * 1024 * 1024)
+                    throw Error("Session snapshot budget exceeded");
+            }
+            sharedSessionSnapshots.set(context.channelContext, { revision: context.channelContext.getSessionStructureRevision?.() ?? revision, profiles: profileKey, sessions, bytes });
+            while (sharedSessionSnapshots.size > 4 || [...sharedSessionSnapshots.values()].reduce((total, item) => total + item.bytes, 0) > 16 * 1024 * 1024)
+                sharedSessionSnapshots.delete(sharedSessionSnapshots.keys().next().value);
+        }
+        catch { }
+    }
+    return sessions.slice();
 }
 function canonicalizeSessionProfile(context, session, profiles = context.channelContext.getProfiles?.()) {
     const canonicalProfile = canonicalProfileName(profiles, session.profile);
@@ -2798,23 +2871,29 @@ function sessionSubtree(sessions, rootSessionId) {
     }
     return [...subtree.values()];
 }
-function buildSessionUnreadCounts(state, sessions) {
+async function buildSessionUnreadCounts(state, sessions) {
     const sessionsById = new Map(sessions.map((session) => [session.id, session]));
     const visibleSessionIds = sessions
         .filter((session) => !hasArchivedSessionInPath(session, sessionsById))
         .map((session) => session.id);
+    if (state.readQueries)
+        return new Map(await state.readQueries.navigation.unreadCountsPage({ piboSessionIds: visibleSessionIds }));
     return state.readState.countUnreadMessagesBySession({
         piboSessionIds: visibleSessionIds,
     });
 }
-function hasUnreadInSessionSubtree(sessions, sessionUnreadCounts, rootSessionId) {
-    return sessionSubtree(sessions, rootSessionId).some((session) => (sessionUnreadCounts.get(session.id) ?? 0) > 0);
+function buildSessionUnreadErrors(state, sessions) {
+    const sessionsById = new Map(sessions.map((session) => [session.id, session]));
+    const visibleSessionIds = sessions
+        .filter((session) => !hasArchivedSessionInPath(session, sessionsById))
+        .map((session) => session.id);
+    return state.readState.hasUnreadErrorsBySession({ piboSessionIds: visibleSessionIds });
 }
-function sessionIdsWithUnreadInSubtree(sessions, sessionUnreadCounts) {
+function sessionIdsWithUnreadInSubtree(sessions, unreadSessionIds) {
     const sessionsById = new Map(sessions.map((session) => [session.id, session]));
     const result = new Set();
     for (const session of sessions) {
-        if ((sessionUnreadCounts.get(session.id) ?? 0) <= 0)
+        if (!unreadSessionIds.has(session.id))
             continue;
         let current = session;
         const visited = new Set();
@@ -2827,11 +2906,7 @@ function sessionIdsWithUnreadInSubtree(sessions, sessionUnreadCounts) {
     return result;
 }
 function signalStatusHasUnreadError(options, piboSessionId) {
-    if (options.sessionIdsWithUnreadInSubtree)
-        return options.sessionIdsWithUnreadInSubtree.has(piboSessionId);
-    return options.sessions && options.sessionUnreadCounts
-        ? hasUnreadInSessionSubtree(options.sessions, options.sessionUnreadCounts, piboSessionId)
-        : true;
+    return options.sessionIdsWithUnreadErrorInSubtree?.has(piboSessionId) ?? true;
 }
 function signalStatusFromSnapshot(snapshot, piboSessionId, options = {}) {
     const session = snapshot?.sessions[piboSessionId];
@@ -2853,19 +2928,19 @@ function signalStatusFromSummary(summary, piboSessionId, options = {}) {
         return { status: "error", updatedAt: summary.updatedAt };
     return { status: "idle", updatedAt: summary.updatedAt };
 }
-function sessionIndexItemsWithSignalState(context, sessions, indexItems, sessionUnreadCounts = new Map()) {
+function sessionIndexItemsWithSignalState(context, sessions, indexItems, sessionUnreadErrors = new Set()) {
     const snapshotSignalStatuses = context.channelContext.snapshotSignalStatuses;
     const signalStatuses = snapshotSignalStatuses?.().sessions;
     const snapshotSignalSession = context.channelContext.snapshotSignalSession;
     if (!signalStatuses && !snapshotSignalSession)
         return [...indexItems];
     const bySessionId = new Map(indexItems.map((item) => [item.piboSessionId, item]));
-    const unreadSessionSubtreeIds = sessionIdsWithUnreadInSubtree(sessions, sessionUnreadCounts);
+    const unreadErrorSubtreeIds = sessionIdsWithUnreadInSubtree(sessions, sessionUnreadErrors);
     for (const session of sessions) {
         const existing = bySessionId.get(session.id);
         const signal = signalStatuses
-            ? signalStatusFromSummary(signalStatuses[session.id], session.id, { sessionIdsWithUnreadInSubtree: unreadSessionSubtreeIds })
-            : signalStatusFromSnapshot(snapshotSignalSession?.(session.id), session.id, { sessionIdsWithUnreadInSubtree: unreadSessionSubtreeIds });
+            ? signalStatusFromSummary(signalStatuses[session.id], session.id, { sessionIdsWithUnreadErrorInSubtree: unreadErrorSubtreeIds })
+            : signalStatusFromSnapshot(snapshotSignalSession?.(session.id), session.id, { sessionIdsWithUnreadErrorInSubtree: unreadErrorSubtreeIds });
         if (!signal?.status)
             continue;
         if (signal.status === "idle" && existing?.status !== "running" && existing?.status !== "error")
@@ -2893,7 +2968,7 @@ function buildRoomUnreadCounts(sessions, sessionUnreadCounts, defaultRoomId) {
     const counts = new Map();
     const sessionsById = new Map(sessions.map((session) => [session.id, session]));
     for (const session of sessions) {
-        if (hasArchivedSessionInPath(session, sessionsById))
+        if (session.parentId || hasArchivedSessionInPath(session, sessionsById))
             continue;
         const unreadCount = sessionUnreadCounts.get(session.id) ?? 0;
         if (unreadCount <= 0)
@@ -3141,10 +3216,30 @@ function writeChatEventFrames(controller, event, state, cursor, options = { mode
         return;
     if (options.mode === "summary" && isLiveOnlyOutputEvent(event.payload))
         return;
+    if (isLiveOnlyOutputEvent(event.payload)) {
+        try {
+            boundedMessageBytes(event.payload, 1024 * 1024);
+        }
+        catch {
+            return;
+        }
+    }
     const piboSessionId = event.piboSessionId ?? event.payload.piboSessionId;
     const streamId = "streamId" in event ? event.streamId : undefined;
     const createdAt = chatLiveEventCreatedAt(event);
-    const frames = chatStreamFramesFromOutputEvent(event.payload, state, {
+    const ref = "storedPayloadRef" in event ? event.storedPayloadRef : undefined;
+    let payload = event.payload;
+    if (ref && ref.byteLength > 64 * 1024) {
+        if (payload.type === "assistant_message" || payload.type === "thinking_finished")
+            payload = { ...payload, text: ref.preview };
+        else if (payload.type === "tool_execution_finished")
+            payload = { ...payload, result: null };
+        else if (payload.type === "tool_execution_updated")
+            payload = { ...payload, partialResult: null };
+        else if (payload.type === "tool_call" || payload.type === "tool_execution_started")
+            payload = { ...payload, args: {} };
+    }
+    const frames = chatStreamFramesFromOutputEvent(payload, state, {
         includeRawEvent: streamId !== undefined && isPersistableOutputEvent(event.payload),
     });
     for (let index = 0; index < frames.length; index += 1) {
@@ -3153,6 +3248,7 @@ function writeChatEventFrames(controller, event, state, cursor, options = { mode
         const frameId = streamId === undefined ? nextTransientChatStreamFrameId(state) : `${streamId}:${index}`;
         writeSse(controller, "pibo", {
             ...frames[index],
+            ...("storedPayloadRef" in event && event.storedPayloadRef ? { storedPayloadRef: event.storedPayloadRef } : {}),
             piboSessionId,
             ...(createdAt ? { createdAt } : {}),
             ...(!("streamId" in event) && event.replaySequence !== undefined ? { liveReplayId: event.replaySequence } : {}),
@@ -3167,81 +3263,124 @@ function chatLiveEventCreatedAt(event) {
     }
     return undefined;
 }
+function trackedEventStream(state, onClose) {
+    const stream = new BoundedEventStream(reason => { state.boundedStreams.delete(stream); if (reason.startsWith("slow") || reason === "error")
+        state.boundedStreamDisconnects++; onClose(); });
+    state.boundedStreams.add(stream);
+    return stream;
+}
 function createEventStream(input) {
     let unsubscribe;
     let heartbeat;
     let registeredLiveObserver = false;
     const streamId = randomUUID();
-    const stream = new ReadableStream({
-        start(controller) {
-            if (input.mode === "live" && input.activePiboSessionId) {
-                markEventStreamConnected(input.state, input.activePiboSessionId, streamId);
-                registeredLiveObserver = true;
+    const stream = trackedEventStream(input.state, () => {
+        unsubscribe?.();
+        unsubscribe = undefined;
+        if (heartbeat)
+            clearInterval(heartbeat);
+        heartbeat = undefined;
+        if (registeredLiveObserver && input.activePiboSessionId) {
+            markEventStreamDisconnected({ state: input.state, piboSessionId: input.activePiboSessionId, streamId });
+            registeredLiveObserver = false;
+        }
+    });
+    const controller = stream.writer;
+    const streamState = createChatStreamState();
+    let replaying = true;
+    let lastReplayedStreamId = -1;
+    const pendingLive = [];
+    let pendingLiveBytes = 0;
+    const listener = (event) => {
+        if (!liveEventMatches(event, input) || stream.closed)
+            return;
+        if ("streamId" in event && typeof event.streamId === "number" && event.streamId <= lastReplayedStreamId)
+            return;
+        if (replaying) {
+            try {
+                pendingLiveBytes += boundedMessageBytes(event, 1024 * 1024);
+                if (pendingLive.length >= 128 || pendingLiveBytes > 1024 * 1024)
+                    throw Error("Replay race buffer full");
+                pendingLive.push(event);
             }
-            const streamState = createChatStreamState();
-            const transientReplay = input.mode === "live" ? collectTransientReplayEvents(input.state, {
-                roomId: input.roomId,
-                piboSessionId: input.piboSessionId,
-                afterReplaySequence: input.transientReplayCursor,
-            }) : undefined;
-            writeSse(controller, "pibo", {
-                type: "ready",
-                piboSessionId: input.piboSessionId ?? "",
-                ...(transientReplay?.status ? { liveReplay: transientReplay.status } : {}),
-            });
-            for (const stored of input.state.timelineQuery.listEvents({
-                roomId: input.roomId,
-                piboSessionId: input.piboSessionId,
-                afterStreamId: input.cursor ? Math.max(0, input.cursor.streamId - 1) : undefined,
-                limit: 1000,
-            })) {
-                writeChatEventFrames(controller, stored, streamState, input.cursor, { mode: input.mode });
+            catch {
+                stream.fail();
             }
-            if (input.mode === "live" && input.piboSessionId) {
-                if (input.transientReplayCursor === undefined) {
-                    for (const snapshot of input.state.outputCompactor.snapshotsForSession(input.piboSessionId)) {
-                        writeChatEventFrames(controller, { piboSessionId: snapshot.piboSessionId, eventType: snapshot.type, payload: snapshot }, streamState, undefined, { mode: input.mode });
-                    }
-                }
-                for (const replay of transientReplay?.events ?? []) {
-                    writeChatEventFrames(controller, replay, streamState, undefined, { mode: input.mode });
+        }
+        else
+            writeChatEventFrames(controller, event, streamState, undefined, { mode: input.mode });
+    };
+    input.state.liveListeners.add(listener);
+    unsubscribe = () => input.state.liveListeners.delete(listener);
+    if (input.mode === "live" && input.activePiboSessionId) {
+        markEventStreamConnected(input.state, input.activePiboSessionId, streamId);
+        registeredLiveObserver = true;
+    }
+    const initialSnapshots = input.mode === "live" && input.piboSessionId ? input.state.outputCompactor.snapshotsForSession(input.piboSessionId) : [];
+    void (async () => {
+        const transientReplay = input.mode === "live" ? collectTransientReplayEvents(input.state, { roomId: input.roomId, piboSessionId: input.piboSessionId, afterReplaySequence: input.transientReplayCursor }) : undefined;
+        writeSse(controller, "pibo", { type: "ready", piboSessionId: input.piboSessionId ?? "", ...(transientReplay?.status ? { liveReplay: transientReplay.status } : {}) });
+        let afterStreamId = input.cursor ? Math.max(0, input.cursor.streamId - 1) : undefined;
+        let replayed = 0;
+        let pageSize = 16;
+        while (!stream.closed) {
+            if (!await stream.waitForCapacity())
+                return;
+            let events;
+            try {
+                events = await (input.state.readQueries?.timeline ?? input.state.timelineQuery).listEvents({ roomId: input.roomId, piboSessionId: input.piboSessionId, afterStreamId, limit: pageSize });
+            }
+            catch (error) {
+                if (pageSize > 1 && error && typeof error === "object" && "code" in error && error.code === "storage_payload_limit") {
+                    pageSize = Math.max(1, Math.floor(pageSize / 2));
+                    continue;
                 }
+                throw error;
             }
-            const listener = (event) => {
-                if (!liveEventMatches(event, input))
+            for (const stored of events) {
+                if (!await stream.waitForCapacity())
                     return;
-                writeChatEventFrames(controller, event, streamState, undefined, { mode: input.mode });
-            };
-            input.state.liveListeners.add(listener);
-            unsubscribe = () => {
-                input.state.liveListeners.delete(listener);
-            };
-            heartbeat = setInterval(() => writeSseComment(controller, "heartbeat"), 25000);
-        },
-        cancel() {
-            unsubscribe?.();
-            unsubscribe = undefined;
-            if (heartbeat)
-                clearInterval(heartbeat);
-            heartbeat = undefined;
-            if (registeredLiveObserver && input.activePiboSessionId) {
-                markEventStreamDisconnected({
-                    state: input.state,
-                    piboSessionId: input.activePiboSessionId,
-                    streamId,
-                });
-                registeredLiveObserver = false;
+                writeChatEventFrames(controller, stored, streamState, input.cursor, { mode: input.mode });
+                afterStreamId = stored.streamId;
+                lastReplayedStreamId = stored.streamId;
+                replayed++;
             }
-        },
-    });
-    return new Response(stream, {
-        headers: {
-            "content-type": "text/event-stream; charset=utf-8",
-            "cache-control": "no-cache, no-transform",
-            "x-accel-buffering": "no",
-            connection: "keep-alive",
-        },
-    });
+            if (events.length < pageSize)
+                break;
+            if (replayed >= 1000) {
+                stream.finish();
+                return;
+            }
+        }
+        if (stream.closed)
+            return;
+        if (input.mode === "live" && input.piboSessionId) {
+            if (input.transientReplayCursor === undefined)
+                for (const snapshot of initialSnapshots) {
+                    if (!await stream.waitForCapacity())
+                        return;
+                    writeChatEventFrames(controller, { piboSessionId: snapshot.piboSessionId, eventType: snapshot.type, payload: snapshot }, streamState, undefined, { mode: input.mode });
+                }
+            for (const replay of transientReplay?.events ?? []) {
+                if (!await stream.waitForCapacity())
+                    return;
+                writeChatEventFrames(controller, replay, streamState, undefined, { mode: input.mode });
+            }
+        }
+        for (const event of pendingLive) {
+            if ("streamId" in event && typeof event.streamId === "number" && event.streamId <= lastReplayedStreamId)
+                continue;
+            if (!await stream.waitForCapacity())
+                return;
+            writeChatEventFrames(controller, event, streamState, undefined, { mode: input.mode });
+        }
+        pendingLive.length = 0;
+        pendingLiveBytes = 0;
+        replaying = false;
+        if (!stream.closed)
+            heartbeat = setInterval(() => writeSseComment(controller, "heartbeat"), 25000);
+    })().catch(() => stream.fail());
+    return new Response(stream.stream, { headers: { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-cache, no-transform", "x-accel-buffering": "no", connection: "keep-alive" } });
 }
 function enrichWorkflowSession(state, workflowSession) {
     const snapshot = state.workflowService.getWorkflowSessionSnapshotForSession(workflowSession.piboSessionId);
@@ -3422,116 +3561,201 @@ function startChatStreamingFixture(input) {
         },
     });
 }
-async function sendChatMessage(input) {
-    const text = normalizeMessageText(input.body.text);
-    const delivery = normalizeMessageDelivery(input.body.delivery);
-    const clientTxnId = normalizeClientTxnId(input.body.clientTxnId);
-    const requestedRoomId = input.forcedRoomId ?? (typeof input.body.roomId === "string" ? input.body.roomId : undefined);
-    const selectedSession = resolveRequestedSession(input.state, input.context, input.webSession, input.defaultProfile, typeof input.body.piboSessionId === "string" ? input.body.piboSessionId : undefined, requestedRoomId);
-    const room = ensureSessionRoom(input.state, input.context, selectedSession, input.webSession);
-    if (requestedRoomId && room.id !== requestedRoomId) {
-        throw new PiboWebHttpError("Session is not available in this room", 404);
-    }
+async function resolveAdmissionSession(storage, context, webSession, defaultProfile, piboSessionId, requestedRoomId) {
+    if (piboSessionId) {
+        const found = context.channelContext.getSession(piboSessionId);
+        if (!found)
+            throw new PiboWebHttpError("Session not found", 404);
+        const session = canonicalizeSessionProfile(context, found);
+        const roomId = chatRoomIdFromMetadata(session.metadata);
+        const room = await storage.resolveRoom(roomId);
+        if (requestedRoomId && requestedRoomId !== room.id)
+            throw new PiboWebHttpError("Session is not available in this room", 404);
+        if (!roomId)
+            context.channelContext.updateSession?.(session.id, { metadata: withChatRoomId(session.metadata, room.id) });
+        return { session: { ...session, metadata: withChatRoomId(session.metadata, room.id) }, room };
+    }
+    const room = await storage.resolveRoom(requestedRoomId, Boolean(requestedRoomId));
+    const candidates = listSharedSessions(context);
+    const existing = candidates.find(session => !session.parentId && !isChatWebSessionArchived(session) && chatRoomIdFromMetadata(session.metadata) === room.id);
+    if (existing)
+        return { session: existing, room };
     if (isPiboRoomArchived(room)) {
-        throw new PiboWebHttpError("Archived rooms are read-only", 403);
+        const archived = candidates.find(session => !session.parentId && chatRoomIdFromMetadata(session.metadata) === room.id);
+        if (archived)
+            return { session: archived, room };
+        throw new PiboWebHttpError("Archived room has no sessions", 404);
     }
-    input.state.sessionQuery.upsertSession(selectedSession);
-    const actorId = auditActorIdFor(input.webSession);
-    const duplicate = clientTxnId ? input.state.eventCommands.findByClientTxn(room.id, actorId, clientTxnId) : undefined;
-    if (duplicate)
-        return responseJson({ duplicate: true, event: duplicate });
-    const webAnnotationContext = prepareWebAnnotationAttachments({
-        piboSessionId: selectedSession.id,
-        messageText: text,
-        attachmentIds: input.body.webAnnotationIds,
-    });
-    const fileAttachmentContext = prepareChatFileAttachments({
-        messageText: webAnnotationContext.messageText,
-        attachmentPaths: input.body.fileAttachmentPaths,
-    });
-    const accepted = input.state.eventCommands.appendEvent({
-        roomId: room.id,
-        piboSessionId: selectedSession.id,
-        eventType: "user.message.accepted",
-        actorType: "user",
-        actorId,
-        clientTxnId,
-        retentionClass: "chat_message",
-        payload: {
-            type: "user.message.accepted",
-            piboSessionId: selectedSession.id,
-            roomId: room.id,
-            text: fileAttachmentContext.messageText,
-            delivery,
-            ...(webAnnotationContext.attachments.length ? {
-                webAnnotationIds: webAnnotationContext.ids,
-                webAnnotationAttachments: webAnnotationContext.attachments,
-                webAnnotationContext: webAnnotationContext.modelContext,
-            } : {}),
-            ...(fileAttachmentContext.attachments.length ? {
-                fileAttachmentPaths: fileAttachmentContext.paths,
-                fileAttachments: fileAttachmentContext.attachments,
-                fileAttachmentContext: fileAttachmentContext.modelContext,
-            } : {}),
-            ...(clientTxnId ? { clientTxnId } : {}),
-        },
-    });
+    return { session: createSharedChatSession(context, webSession, defaultProfile, room), room };
+}
+async function sendChatMessage(input) {
     try {
-        input.state.ingestService?.ingestUserMessageAccepted({
-            session: selectedSession,
-            roomId: room.id,
-            actorId,
-            text: fileAttachmentContext.messageText,
-            clientTxnId,
-            legacyEvent: accepted,
+        const startedAt = performance.now();
+        const timings = [];
+        const timedResponse = (value, status = 200) => responseJson(value, {
+            status,
+            headers: { "server-timing": [...timings, `chat_ack;dur=${(performance.now() - startedAt).toFixed(2)}`].join(", ") },
         });
-    }
-    catch (error) {
-        console.warn("V2 chat data shadow ingest failed", error);
-    }
-    for (const listener of input.state.liveListeners)
-        listener(accepted);
-    const messageId = clientTxnId ?? randomUUID();
-    let output;
-    try {
-        output = await input.context.channelContext.emit({
-            type: "message",
+        const durable = input.body.admissionVersion === 2;
+        if (input.body.admissionVersion !== undefined && !durable)
+            throw new PiboWebHttpError("Unsupported message admission version", 400);
+        if (durable && !input.state.asyncStorage)
+            throw new PiboWebHttpError("Durable admission requires file-backed storage", 503);
+        const text = normalizeMessageText(input.body.text);
+        const delivery = normalizeMessageDelivery(input.body.delivery);
+        const clientTxnId = normalizeClientTxnId(input.body.clientTxnId);
+        const requestedRoomId = input.forcedRoomId ?? (typeof input.body.roomId === "string" ? input.body.roomId : undefined);
+        const requestedSessionId = typeof input.body.piboSessionId === "string" ? input.body.piboSessionId : undefined;
+        const resolved = input.state.asyncStorage
+            ? await resolveAdmissionSession(input.state.asyncStorage, input.context, input.webSession, input.defaultProfile, requestedSessionId, requestedRoomId)
+            : undefined;
+        const selectedSession = resolved?.session ?? resolveRequestedSession(input.state, input.context, input.webSession, input.defaultProfile, requestedSessionId, requestedRoomId);
+        const room = resolved?.room ?? ensureSessionRoom(input.state, input.context, selectedSession, input.webSession);
+        if (requestedRoomId && room.id !== requestedRoomId) {
+            throw new PiboWebHttpError("Session is not available in this room", 404);
+        }
+        if (isPiboRoomArchived(room)) {
+            throw new PiboWebHttpError("Archived rooms are read-only", 403);
+        }
+        if (!input.state.asyncStorage)
+            input.state.sessionQuery.upsertSession(selectedSession);
+        const actorId = auditActorIdFor(input.webSession);
+        const lookupStartedAt = performance.now();
+        const duplicate = clientTxnId && !input.state.asyncStorage ? input.state.eventCommands.findByClientTxn(room.id, actorId, clientTxnId) : undefined;
+        timings.push(`chat_lookup;dur=${(performance.now() - lookupStartedAt).toFixed(2)}`);
+        if (duplicate)
+            return timedResponse({ duplicate: true, event: duplicate });
+        const webAnnotationContext = prepareWebAnnotationAttachments({
             piboSessionId: selectedSession.id,
-            id: messageId,
-            text: fileAttachmentContext.messageText,
-            delivery,
-            source: "user",
+            messageText: text,
+            attachmentIds: input.body.webAnnotationIds,
         });
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        if (!(error instanceof PiboSteeringUnavailableError)) {
-            input.context.channelContext.reportSessionError?.(selectedSession.id, errorMessage, { eventId: messageId, source: "pibo" });
-        }
-        const failed = input.state.eventCommands.appendEvent({
+        const fileAttachmentContext = prepareChatFileAttachments({
+            messageText: webAnnotationContext.messageText,
+            attachmentPaths: input.body.fileAttachmentPaths,
+        });
+        const appendStartedAt = performance.now();
+        const appendInput = {
             roomId: room.id,
             piboSessionId: selectedSession.id,
-            eventType: "user.message.failed",
-            actorType: "system",
+            eventType: "user.message.accepted",
+            actorType: "user",
             actorId,
-            retentionClass: "audit_event",
+            clientTxnId,
+            retentionClass: "chat_message",
             payload: {
-                type: "user.message.failed",
+                type: "user.message.accepted",
                 piboSessionId: selectedSession.id,
                 roomId: room.id,
+                text: fileAttachmentContext.messageText,
+                delivery,
+                ...(webAnnotationContext.attachments.length ? {
+                    webAnnotationIds: webAnnotationContext.ids,
+                    webAnnotationAttachments: webAnnotationContext.attachments,
+                    webAnnotationContext: webAnnotationContext.modelContext,
+                } : {}),
+                ...(fileAttachmentContext.attachments.length ? {
+                    fileAttachmentPaths: fileAttachmentContext.paths,
+                    fileAttachments: fileAttachmentContext.attachments,
+                    fileAttachmentContext: fileAttachmentContext.modelContext,
+                } : {}),
                 ...(clientTxnId ? { clientTxnId } : {}),
-                message: errorMessage,
             },
-        });
+        };
+        const messageId = clientTxnId ?? randomUUID();
+        const admission = input.state.asyncStorage ? await input.state.asyncStorage.admit(appendInput, selectedSession, fileAttachmentContext.messageText, durable ? { eventId: messageId, delivery } : undefined) : undefined;
+        const accepted = admission?.event ?? input.state.eventCommands.appendEvent(appendInput);
+        if (admission && !admission.created)
+            return timedResponse({ duplicate: true, event: accepted, ...(admission.receipt ? { receipt: admission.receipt, admissionVersion: 2, statusPath: `${CHAT_WEB_API_PREFIX}/message-receipts/${admission.receipt.id}` } : {}) }, durable ? 202 : 200);
+        timings.push(`chat_append;dur=${(performance.now() - appendStartedAt).toFixed(2)}`);
+        const ingestStartedAt = performance.now();
+        try {
+            if (!input.state.asyncStorage)
+                input.state.ingestService?.ingestUserMessageAccepted({
+                    session: selectedSession,
+                    roomId: room.id,
+                    actorId,
+                    text: fileAttachmentContext.messageText,
+                    clientTxnId,
+                    legacyEvent: accepted,
+                });
+        }
+        catch (error) {
+            console.warn("V2 chat data shadow ingest failed", error);
+        }
+        timings.push(`chat_ingest;dur=${(performance.now() - ingestStartedAt).toFixed(2)}`);
         for (const listener of input.state.liveListeners)
-            listener(failed);
-        if (error instanceof PiboSteeringUnavailableError || error instanceof AgentRuntimeBindingMissingError) {
-            throw new PiboWebHttpError(error.message, 409);
+            listener(accepted);
+        if (durable && admission?.receipt) {
+            input.state.commandDispatcher ??= new MessageCommandDispatcher(input.state.asyncStorage, input.context.channelContext);
+            input.state.commandDispatcher.wake();
+            markWebAnnotationsAttached(webAnnotationContext);
+            return timedResponse({ admissionVersion: 2, receipt: admission.receipt, event: accepted, statusPath: `${CHAT_WEB_API_PREFIX}/message-receipts/${admission.receipt.id}` }, 202);
+        }
+        const emitStartedAt = performance.now();
+        let output;
+        try {
+            output = await input.context.channelContext.emit({
+                type: "message",
+                piboSessionId: selectedSession.id,
+                id: messageId,
+                text: fileAttachmentContext.messageText,
+                delivery,
+                source: "user",
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (!(error instanceof PiboSteeringUnavailableError)) {
+                input.context.channelContext.reportSessionError?.(selectedSession.id, errorMessage, { eventId: messageId, source: "pibo" });
+            }
+            const failedInput = {
+                roomId: room.id,
+                piboSessionId: selectedSession.id,
+                eventType: "user.message.failed",
+                actorType: "system",
+                actorId,
+                retentionClass: "audit_event",
+                payload: {
+                    type: "user.message.failed",
+                    piboSessionId: selectedSession.id,
+                    roomId: room.id,
+                    ...(clientTxnId ? { clientTxnId } : {}),
+                    message: errorMessage,
+                },
+            };
+            const failed = input.state.asyncStorage ? (await input.state.asyncStorage.append(failedInput)).event : input.state.eventCommands.appendEvent(failedInput);
+            for (const listener of input.state.liveListeners)
+                listener(failed);
+            if (error instanceof PiboSteeringUnavailableError || error instanceof AgentRuntimeBindingMissingError) {
+                throw new PiboWebHttpError(error.message, 409);
+            }
+            throw error;
+        }
+        timings.push(`chat_emit;dur=${(performance.now() - emitStartedAt).toFixed(2)}`);
+        markWebAnnotationsAttached(webAnnotationContext);
+        return timedResponse({ output, event: accepted });
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+        if (code === "command_conflict")
+            return responseJson({ error: "Transaction conflicts with an existing message.", code }, { status: 409 });
+        if (code === "command_too_large")
+            return responseJson({ error: "Message exceeds the durable command limit.", code }, { status: 413 });
+        if (code === "command_reconciliation_required") {
+            const details = error;
+            return responseJson({ error: "A previous interrupted message requires review before this session can accept more messages.", code, retryable: false, scope: details.scope ?? "session", blockingCommandId: details.blockingCommandId, blockedSince: details.blockedSince, oldestWaitAgeMs: details.oldestWaitAgeMs, nextAction: details.nextAction }, { status: 409 });
         }
+        if (code === "command_overloaded")
+            return responseJson({ error: "Message queue capacity reached.", code, retryable: true, scope: "capacity" }, { status: 429, headers: { "retry-after": "1" } });
+        if (code === "room_not_found")
+            throw new PiboWebHttpError("Room not found", 404);
+        if (code === "room_read_only")
+            throw new PiboWebHttpError("Archived rooms are read-only", 403);
+        if (code.startsWith("storage_"))
+            return responseJson({ error: "Storage unavailable; retry with the same client transaction ID.", code, acceptanceUnknown: code === "storage_unknown" || code === "storage_operation_failed" }, { status: 503, headers: { "retry-after": "1" } });
         throw error;
     }
-    markWebAnnotationsAttached(webAnnotationContext);
-    return responseJson({ output, event: accepted });
 }
 export function createChatWebApp(options = {}) {
     const integrations = resolveChatWebIntegrations(options);
@@ -3550,6 +3774,9 @@ export function createChatWebApp(options = {}) {
     const state = {
         sessionQuery: new ChatSessionQueryService(dataStore),
         timelineQuery: new ChatTimelineQueryService(dataStore),
+        boundedStreams: new Set(),
+        boundedStreamDisconnects: 0,
+        readQueries: dataStore.path === ":memory:" ? undefined : new AsyncChatReadQueries(dataStore.path, options.dataPayloadRootDir ?? piboHomePath("payloads")),
         historyQuery: new ChatHistoryQueryService(dataStore),
         eventCommands: new ChatEventCommandService(dataStore),
         readState: new ChatReadStateService(dataStore),
@@ -3560,6 +3787,7 @@ export function createChatWebApp(options = {}) {
         cronStore: createDefaultPiboCronStore({ path: options.cronStorePath }),
         loopStore: createDefaultPiboLoopStore({ path: options.ralphStorePath }),
         dataStore,
+        asyncStorage: dataStore.path === ":memory:" ? undefined : new AsyncChatStorage(dataStore.path, options.dataPayloadRootDir ?? piboHomePath("payloads")),
         ingestService: new ChatDataIngestService(dataStore),
         traceCache: new Map(),
         traceTimelinePageCache: new Map(),
@@ -3589,30 +3817,59 @@ export function createChatWebApp(options = {}) {
         telemetryRetentionMaintenance: {},
         integrations,
     };
+    const earlyTraceCache = new TraceResponseCache();
     let disposed = false;
     const requireSession = (request, context) => context.requireSession({
         request,
     });
-    return {
+    const application = {
         name: CHAT_WEB_APP_NAME,
         mountPath: CHAT_WEB_MOUNT_PATH,
         apiPrefix: CHAT_WEB_API_PREFIX,
-        dispose() {
+        initialize(context) {
+            ensureCustomAgentProfiles(state, context);
+            ensureEventIndexing(state, context);
+            if (state.asyncStorage)
+                state.commandDispatcher ??= new MessageCommandDispatcher(state.asyncStorage, context.channelContext);
+        },
+        async gatewayStatus() {
+            if (!state.asyncStorage)
+                return { durableMessageQueue: { status: "ambiguous", storage: { available: false, error: "Durable message storage is not file-backed." }, degradedReasons: ["durable message storage unavailable"] } };
+            try {
+                return { durableMessageQueue: await state.asyncStorage.durableQueueHealth() };
+            }
+            catch (error) {
+                return { durableMessageQueue: { status: "ambiguous", storage: { available: false, error: error instanceof Error ? error.message : "Storage unavailable" }, degradedReasons: ["durable message queue storage read failed"] } };
+            }
+        },
+        async drain() {
+            await state.outputPersistenceRetries.drain();
+        },
+        async dispose() {
             if (disposed)
                 return;
             disposed = true;
+            earlyTraceCache.clear();
             state.unsubscribe?.();
             state.unsubscribe = undefined;
+            if (state.subscribedContext)
+                sharedSessionSnapshots.delete(state.subscribedContext.channelContext);
             state.subscribedContext = undefined;
             state.eventLoopDelay.disable();
+            await state.commandDispatcher?.dispose();
+            await disposeTelemetryRetentionMaintenance(state.telemetryRetentionMaintenance);
             state.outputPersistenceRetries.dispose();
             state.workflowService.close();
             state.agentStore.close();
             state.reliabilityStore.close();
             state.cronStore.close();
             state.loopStore.close();
+            for (const stream of state.boundedStreams)
+                stream.fail();
             state.outputCompactor.disposeAll();
             state.outputRenderSequencer.disposeAll();
+            await state.asyncStorage?.close();
+            await state.readQueries?.close();
             state.dataStore.close();
         },
         async handleRequest(request, context) {
@@ -3678,7 +3935,7 @@ export function createChatWebApp(options = {}) {
                     if (!nodeId || parsed.nodeId !== nodeId || parsed.payloadKind !== "output")
                         throw new PiboWebHttpError("Trace image node does not match the payload ref", 400);
                     resolveRequestedSession(state, context, webSession, defaultProfile, parsed.piboSessionId);
-                    if (!state.timelineQuery.isPayloadAttachedToTraceNode({
+                    if (!await (state.readQueries?.timeline ?? state.timelineQuery).isPayloadAttachedToTraceNode({
                         piboSessionId: parsed.piboSessionId,
                         payloadId: parsed.payloadId,
                         nodeId,
@@ -3758,6 +4015,7 @@ export function createChatWebApp(options = {}) {
                 const requestedRoomId = url.searchParams.get("roomId") || undefined;
                 const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, url.searchParams.get("piboSessionId") || undefined, requestedRoomId);
                 const selectedRoomId = selectedRoomIdForSession(state, context, selectedSession);
+                const structuralRevision = context.channelContext.getSessionStructureRevision?.();
                 const ownedSessions = listSharedSessions(context);
                 const roomSessions = visibleSessionsInRoom({
                     state,
@@ -3769,9 +4027,15 @@ export function createChatWebApp(options = {}) {
                     includeArchived,
                 });
                 const defaultRoom = state.roomService.ensureDefaultRoom();
-                indexSharedSessions(state.sessionQuery, roomSessions);
-                const sessionUnreadCounts = buildSessionUnreadCounts(state, ownedSessions);
-                const sessions = await buildSessionNodes(roomSessions, sessionIndexItemsWithSignalState(context, roomSessions, state.sessionQuery.listSessions(), sessionUnreadCounts), process.cwd(), sessionUnreadCounts, { skipPiMetadataFallback: true });
+                const indexKey = JSON.stringify([structuralRevision, selectedRoomId, includeArchived, selectedSession.id]);
+                if (structuralRevision === undefined || state.navigationIndexed?.context !== context.channelContext || state.navigationIndexed.key !== indexKey) {
+                    indexSharedSessions(state.sessionQuery, roomSessions);
+                    if (structuralRevision !== undefined)
+                        state.navigationIndexed = { context: context.channelContext, key: indexKey };
+                }
+                const sessionUnreadCounts = await buildSessionUnreadCounts(state, ownedSessions);
+                const sessionUnreadErrors = buildSessionUnreadErrors(state, ownedSessions);
+                const sessions = await buildSessionNodes(roomSessions, sessionIndexItemsWithSignalState(context, roomSessions, await readNavigationIndex(state, selectedRoomId), sessionUnreadErrors), process.cwd(), sessionUnreadCounts, { skipPiMetadataFallback: true });
                 const roomTree = state.roomService.listRoomTree();
                 const roomUnreadCounts = buildRoomUnreadCounts(ownedSessions, sessionUnreadCounts, defaultRoom.id);
                 const rooms = roomsWithUnreadCounts(roomTree, roomUnreadCounts);
@@ -3783,7 +4047,7 @@ export function createChatWebApp(options = {}) {
                     defaultRoomId: defaultRoom.id,
                     selectedRoomId,
                     selectedPiboSessionId: selectedSession.id,
-                    latestRoomStreamId: state.timelineQuery.getLatestStreamId({ roomId: selectedRoomId }),
+                    latestRoomStreamId: await (state.readQueries?.timeline ?? state.timelineQuery).getLatestStreamId({ roomId: selectedRoomId }),
                     rooms,
                     sessions,
                 }, { headers: { "server-timing": "navigation;desc=\"no_catalog_no_jsonl\"" } });
@@ -3795,6 +4059,7 @@ export function createChatWebApp(options = {}) {
                 const requestedRoomId = url.searchParams.get("roomId") || undefined;
                 const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, url.searchParams.get("piboSessionId") || undefined, requestedRoomId);
                 const selectedRoomId = selectedRoomIdForSession(state, context, selectedSession);
+                const structuralRevision = context.channelContext.getSessionStructureRevision?.();
                 const ownedSessions = listSharedSessions(context);
                 const roomSessions = visibleSessionsInRoom({
                     state,
@@ -3809,10 +4074,16 @@ export function createChatWebApp(options = {}) {
                 if (markRead) {
                     markSessionsRead(state, sessionSubtree(ownedSessions, selectedSession.id));
                 }
-                indexSharedSessions(state.sessionQuery, roomSessions);
-                const sessionUnreadCounts = buildSessionUnreadCounts(state, ownedSessions);
+                const indexKey = JSON.stringify([structuralRevision, selectedRoomId, includeArchived, selectedSession.id]);
+                if (structuralRevision === undefined || state.navigationIndexed?.context !== context.channelContext || state.navigationIndexed.key !== indexKey) {
+                    indexSharedSessions(state.sessionQuery, roomSessions);
+                    if (structuralRevision !== undefined)
+                        state.navigationIndexed = { context: context.channelContext, key: indexKey };
+                }
+                const sessionUnreadCounts = await buildSessionUnreadCounts(state, ownedSessions);
+                const sessionUnreadErrors = buildSessionUnreadErrors(state, ownedSessions);
                 const [sessions, catalog] = await Promise.all([
-                    buildSessionNodes(roomSessions, sessionIndexItemsWithSignalState(context, roomSessions, state.sessionQuery.listSessions(), sessionUnreadCounts), process.cwd(), sessionUnreadCounts, sessionNodeHistoryOptions(context)),
+                    buildSessionNodes(roomSessions, sessionIndexItemsWithSignalState(context, roomSessions, await readNavigationIndex(state, selectedRoomId), sessionUnreadErrors), process.cwd(), sessionUnreadCounts, sessionNodeHistoryOptions(context)),
                     loadBootstrapCatalog(state, context, webSession),
                 ]);
                 const roomTree = state.roomService.listRoomTree();
@@ -3825,7 +4096,7 @@ export function createChatWebApp(options = {}) {
                     room: state.roomService.getRoom(selectedRoomId),
                     selectedRoomId,
                     selectedPiboSessionId: selectedSession.id,
-                    latestRoomStreamId: state.timelineQuery.getLatestStreamId({ roomId: selectedRoomId }),
+                    latestRoomStreamId: await (state.readQueries?.timeline ?? state.timelineQuery).getLatestStreamId({ roomId: selectedRoomId }),
                     rooms,
                     sessions,
                     ...catalog,
@@ -3943,29 +4214,32 @@ export function createChatWebApp(options = {}) {
                 let unsubscribe;
                 let heartbeat;
                 let closed = false;
-                const stream = new ReadableStream({
-                    start: (controller) => {
-                        writeJsonSse(controller, "signal_status_snapshot", context.channelContext.snapshotSignalStatuses());
-                        unsubscribe = context.channelContext.subscribeSignalStatuses((patch) => {
-                            if (closed)
-                                return;
-                            const statusPatch = compactSignalStatusPatch(patch);
-                            writeJsonSse(controller, "signal_status_patch", statusPatch, `${patch.rootPiboSessionId}:${patch.toVersion}`);
-                        });
-                        heartbeat = setInterval(() => {
-                            if (!closed)
-                                writeSseComment(controller, "heartbeat");
-                        }, 25_000);
-                    },
-                    cancel: () => {
-                        closed = true;
-                        unsubscribe?.();
-                        unsubscribe = undefined;
-                        if (heartbeat)
-                            clearInterval(heartbeat);
-                        heartbeat = undefined;
-                    },
-                });
+                const cleanup = () => {
+                    closed = true;
+                    unsubscribe?.();
+                    unsubscribe = undefined;
+                    if (heartbeat)
+                        clearInterval(heartbeat);
+                    heartbeat = undefined;
+                };
+                const bounded = trackedEventStream(state, cleanup);
+                {
+                    const controller = bounded.writer;
+                    writeJsonSse(controller, "signal_status_snapshot", context.channelContext.snapshotSignalStatuses());
+                    unsubscribe = context.channelContext.subscribeSignalStatuses((patch) => {
+                        if (closed)
+                            return;
+                        const statusPatch = compactSignalStatusPatch(patch);
+                        writeJsonSse(controller, "signal_status_patch", statusPatch, `${patch.rootPiboSessionId}:${patch.toVersion}`);
+                    });
+                    heartbeat = setInterval(() => {
+                        if (!closed)
+                            writeSseComment(controller, "heartbeat");
+                    }, 25_000);
+                }
+                if (closed)
+                    cleanup();
+                const stream = bounded.stream;
                 return new Response(stream, {
                     headers: signalSseHeaders(),
                 });
@@ -3997,38 +4271,41 @@ export function createChatWebApp(options = {}) {
                 let unsubscribeStatuses;
                 let heartbeat;
                 let closed = false;
-                const stream = new ReadableStream({
-                    start: (controller) => {
-                        writeJsonSse(controller, "signal_snapshot", context.channelContext.snapshotSignalTree(rootPiboSessionId));
-                        unsubscribeTree = context.channelContext.subscribeSignalTree(rootPiboSessionId, (patch) => {
-                            if (!closed)
-                                writeJsonSse(controller, "signal_patch", patch, String(patch.toVersion));
+                const cleanup = () => {
+                    closed = true;
+                    unsubscribeTree?.();
+                    unsubscribeTree = undefined;
+                    unsubscribeStatuses?.();
+                    unsubscribeStatuses = undefined;
+                    if (heartbeat)
+                        clearInterval(heartbeat);
+                    heartbeat = undefined;
+                };
+                const bounded = trackedEventStream(state, cleanup);
+                {
+                    const controller = bounded.writer;
+                    writeJsonSse(controller, "signal_snapshot", context.channelContext.snapshotSignalTree(rootPiboSessionId));
+                    unsubscribeTree = context.channelContext.subscribeSignalTree(rootPiboSessionId, (patch) => {
+                        if (!closed)
+                            writeJsonSse(controller, "signal_patch", patch, String(patch.toVersion));
+                    });
+                    if (includeStatuses) {
+                        writeJsonSse(controller, "signal_status_snapshot", context.channelContext.snapshotSignalStatuses());
+                        unsubscribeStatuses = context.channelContext.subscribeSignalStatuses((patch) => {
+                            if (closed)
+                                return;
+                            const statusPatch = compactSignalStatusPatch(patch);
+                            writeJsonSse(controller, "signal_status_patch", statusPatch, `${patch.rootPiboSessionId}:${patch.toVersion}`);
                         });
-                        if (includeStatuses) {
-                            writeJsonSse(controller, "signal_status_snapshot", context.channelContext.snapshotSignalStatuses());
-                            unsubscribeStatuses = context.channelContext.subscribeSignalStatuses((patch) => {
-                                if (closed)
-                                    return;
-                                const statusPatch = compactSignalStatusPatch(patch);
-                                writeJsonSse(controller, "signal_status_patch", statusPatch, `${patch.rootPiboSessionId}:${patch.toVersion}`);
-                            });
-                        }
-                        heartbeat = setInterval(() => {
-                            if (!closed)
-                                writeSseComment(controller, "heartbeat");
-                        }, 25_000);
-                    },
-                    cancel: () => {
-                        closed = true;
-                        unsubscribeTree?.();
-                        unsubscribeTree = undefined;
-                        unsubscribeStatuses?.();
-                        unsubscribeStatuses = undefined;
-                        if (heartbeat)
-                            clearInterval(heartbeat);
-                        heartbeat = undefined;
-                    },
-                });
+                    }
+                    heartbeat = setInterval(() => {
+                        if (!closed)
+                            writeSseComment(controller, "heartbeat");
+                    }, 25_000);
+                }
+                if (closed)
+                    cleanup();
+                const stream = bounded.stream;
                 return new Response(stream, {
                     headers: signalSseHeaders(),
                 });
@@ -4653,13 +4930,22 @@ export function createChatWebApp(options = {}) {
                 const webSession = await requireSession(request, context);
                 requireRoom(state, roomResource.roomId, webSession, "read");
                 const cursor = parseSseCursor(url.searchParams.get("since"));
-                return responseJson({
-                    events: state.timelineQuery.listEvents({
-                        roomId: roomResource.roomId,
-                        afterStreamId: cursor?.streamId,
-                        limit: 1000,
-                    }),
-                });
+                let limit = 1000;
+                for (;;) {
+                    try {
+                        const events = await (state.readQueries?.timeline ?? state.timelineQuery).listEvents({
+                            roomId: roomResource.roomId,
+                            afterStreamId: cursor?.streamId,
+                            limit,
+                        });
+                        return responseJson({ events });
+                    }
+                    catch (error) {
+                        if (limit <= 1 || !error || typeof error !== "object" || !("code" in error) || error.code !== "storage_payload_limit")
+                            throw error;
+                        limit = Math.max(1, Math.floor(limit / 2));
+                    }
+                }
             }
             if (roomResource && roomResource.child === "messages" && request.method === "POST") {
                 requireSameOriginJsonRequest(request);
@@ -4861,16 +5147,16 @@ export function createChatWebApp(options = {}) {
                 const startedAt = performance.now();
                 const webSession = await requireSession(request, context);
                 const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, url.searchParams.get("piboSessionId") || undefined);
-                state.sessionQuery.upsertSession(selectedSession);
+                state.sessionQuery.upsertSessionsIfChanged([selectedSession]);
                 const indexedSession = state.sessionQuery.getSession(selectedSession.id);
                 const historyStartedAt = performance.now();
-                const productHistory = state.historyQuery.getProductHistoryCoverage(selectedSession.id);
+                const productHistory = await (state.readQueries?.history ?? state.historyQuery).getProductHistoryCoverage(selectedSession.id);
                 const historyInspection = requiresNativeHistoryCompatibility(selectedSession) && context.channelContext.inspectSessionRuntimeHistory
                     ? await context.channelContext.inspectSessionRuntimeHistory(selectedSession.id).catch(() => undefined)
                     : undefined;
                 const historyMs = performance.now() - historyStartedAt;
-                const lastEventSequence = state.timelineQuery.getLatestEventSequence(selectedSession.id);
-                const latestStreamId = state.timelineQuery.getLatestStreamId({ piboSessionId: selectedSession.id });
+                const lastEventSequence = await (state.readQueries?.timeline ?? state.timelineQuery).getLatestEventSequence(selectedSession.id);
+                const latestStreamId = await (state.readQueries?.timeline ?? state.timelineQuery).getLatestStreamId({ piboSessionId: selectedSession.id });
                 const version = createFastTraceV2Version({
                     session: selectedSession,
                     sessions: listSharedSessions(context),
@@ -4914,14 +5200,14 @@ export function createChatWebApp(options = {}) {
                 const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, url.searchParams.get("piboSessionId") || undefined);
                 if (timelineCursor.kind === "history")
                     validateRuntimeHistoryCursor(selectedSession, timelineCursor);
-                state.sessionQuery.upsertSession(selectedSession);
+                state.sessionQuery.upsertSessionsIfChanged([selectedSession]);
                 const ownedSessions = listSharedSessions(context);
                 const indexedSession = state.sessionQuery.getSession(selectedSession.id);
                 let historyMs = 0;
-                const productHistory = state.historyQuery.getProductHistoryCoverage(selectedSession.id);
-                const lastEventSequence = state.timelineQuery.getLatestEventSequence(selectedSession.id);
-                const latestStreamId = state.timelineQuery.getLatestStreamId({ piboSessionId: selectedSession.id });
-                const turnTimingScan = state.timelineQuery.scanMessageTurnTimings(selectedSession.id);
+                const productHistory = await (state.readQueries?.history ?? state.historyQuery).getProductHistoryCoverage(selectedSession.id);
+                const lastEventSequence = await (state.readQueries?.timeline ?? state.timelineQuery).getLatestEventSequence(selectedSession.id);
+                const latestStreamId = await (state.readQueries?.timeline ?? state.timelineQuery).getLatestStreamId({ piboSessionId: selectedSession.id });
+                const turnTimingScan = await (state.readQueries?.timeline ?? state.timelineQuery).scanMessageTurnTimings(selectedSession.id);
                 const turnTimings = turnTimingScan.timings;
                 const liveSnapshots = timelineCursor.kind === "tail" ? state.outputCompactor.snapshotsForSession(selectedSession.id) : [];
                 const runtimeStatus = context.channelContext.getSessionRuntimeStatus
@@ -5023,7 +5309,7 @@ export function createChatWebApp(options = {}) {
                         };
                     }
                     else {
-                        const events = state.timelineQuery.listTraceEvents({
+                        const events = await (state.readQueries?.timeline ?? state.timelineQuery).listTraceEvents({
                             piboSessionId: selectedSession.id,
                             limit,
                             ...(beforeSequence !== undefined ? { beforeSequence } : {}),
@@ -5041,7 +5327,7 @@ export function createChatWebApp(options = {}) {
                         }
                         const historyEntries = nativeHistory?.entries.length
                             ? nativeHistory.entries
-                            : state.historyQuery.listProductHistoryEntries({
+                            : await (state.readQueries?.history ?? state.historyQuery).listProductHistoryEntries({
                                 piboSessionId: selectedSession.id,
                                 limit: Math.min(limit * 2, 500),
                                 ...(beforeSequence !== undefined ? { beforeSequence } : {}),
@@ -5124,9 +5410,19 @@ export function createChatWebApp(options = {}) {
                 if (!parsed)
                     throw new PiboWebHttpError("Invalid trace payload ref", 400);
                 resolveRequestedSession(state, context, webSession, defaultProfile, parsed.piboSessionId);
+                if (url.searchParams.get("download") === "1") {
+                    const payload = state.dataStore.payloads.getPayload(parsed.payloadId);
+                    if (!payload)
+                        throw new PiboWebHttpError("Trace payload not found", 404);
+                    const body = Readable.toWeb(state.dataStore.payloads.openPayloadStream(parsed.payloadId));
+                    return new Response(body, { headers: {
+                            "content-type": "application/octet-stream", "content-disposition": 'attachment; filename="message-content.txt"',
+                            "content-length": String(payload.byteSize), "cache-control": "no-store", "x-content-type-options": "nosniff",
+                        } });
+                }
                 const offset = parseNonNegativeIntSearchParam(url, "offset", 0, Number.MAX_SAFE_INTEGER);
                 const limit = parsePositiveIntSearchParam(url, "limit", TRACE_V2_PAYLOAD_DEFAULT_LIMIT_BYTES, TRACE_V2_PAYLOAD_MAX_LIMIT_BYTES);
-                const chunk = readTracePayloadChunk({ payloadStore: state.dataStore.payloads, ref, offset, limit });
+                const chunk = await readTracePayloadChunk({ payloadStore: state.dataStore.payloads, ref, offset, limit });
                 if (!chunk)
                     throw new PiboWebHttpError("Trace payload not found", 404);
                 return responseJson(chunk, { headers: { "cache-control": "no-store" } });
@@ -5139,7 +5435,7 @@ export function createChatWebApp(options = {}) {
                 const beforeSequence = rawCursor.kind === "event" ? rawCursor.beforeSequence : undefined;
                 const limit = parsePositiveIntSearchParam(url, "limit", TRACE_V2_RAW_EVENTS_DEFAULT_LIMIT, TRACE_V2_RAW_EVENTS_MAX_LIMIT);
                 const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, url.searchParams.get("piboSessionId") || undefined);
-                const events = state.timelineQuery.listTraceEvents({
+                const events = await (state.readQueries?.timeline ?? state.timelineQuery).listTraceEvents({
                     piboSessionId: selectedSession.id,
                     limit,
                     ...(beforeSequence !== undefined ? { beforeSequence } : {}),
@@ -5161,11 +5457,11 @@ export function createChatWebApp(options = {}) {
                     ? parsePositiveIntSearchParam(url, "pageSize", DEFAULT_TRACE_EVENTS_PAGE_SIZE, TRACE_V1_COMPAT_MAX_EVENTS_PER_REQUEST)
                     : parsePositiveIntSearchParam(url, "eventLimit", DEFAULT_TRACE_EVENTS_PAGE_SIZE, TRACE_V1_COMPAT_MAX_EVENTS_PER_REQUEST);
                 const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, url.searchParams.get("piboSessionId") || undefined);
-                state.sessionQuery.upsertSession(selectedSession);
+                state.sessionQuery.upsertSessionsIfChanged([selectedSession]);
                 const ownedSessions = listSharedSessions(context);
                 const indexedSession = state.sessionQuery.getSession(selectedSession.id);
                 let historyMs = 0;
-                const productHistory = state.historyQuery.getProductHistoryCoverage(selectedSession.id);
+                const productHistory = await (state.readQueries?.history ?? state.historyQuery).getProductHistoryCoverage(selectedSession.id);
                 let nativeHistory;
                 if (beforeSequence === undefined
                     && requiresNativeHistoryCompatibility(selectedSession)
@@ -5175,9 +5471,9 @@ export function createChatWebApp(options = {}) {
                     nativeHistory = await context.channelContext.readSessionRuntimeHistory(selectedSession.id, { limit: Math.min(eventLimit * 4, 500) }).catch(() => undefined);
                     historyMs += performance.now() - historyStartedAt;
                 }
-                const lastEventSequence = state.timelineQuery.getLatestEventSequence(selectedSession.id);
-                const latestStreamId = state.timelineQuery.getLatestStreamId({ piboSessionId: selectedSession.id });
-                const turnTimingScan = state.timelineQuery.scanMessageTurnTimings(selectedSession.id);
+                const lastEventSequence = await (state.readQueries?.timeline ?? state.timelineQuery).getLatestEventSequence(selectedSession.id);
+                const latestStreamId = await (state.readQueries?.timeline ?? state.timelineQuery).getLatestStreamId({ piboSessionId: selectedSession.id });
+                const turnTimingScan = await (state.readQueries?.timeline ?? state.timelineQuery).scanMessageTurnTimings(selectedSession.id);
                 const turnTimings = turnTimingScan.timings;
                 const liveSnapshots = beforeSequence === undefined ? state.outputCompactor.snapshotsForSession(selectedSession.id) : [];
                 const runtimeStatus = context.channelContext.getSessionRuntimeStatus
@@ -5214,7 +5510,7 @@ export function createChatWebApp(options = {}) {
                 let trace = cached;
                 let eventCount = 0;
                 if (!trace) {
-                    const events = state.timelineQuery.listTraceEvents({
+                    const events = await (state.readQueries?.timeline ?? state.timelineQuery).listTraceEvents({
                         piboSessionId: selectedSession.id,
                         limit: eventLimit,
                         ...(beforeSequence !== undefined ? { beforeSequence } : {}),
@@ -5222,7 +5518,7 @@ export function createChatWebApp(options = {}) {
                     eventCount = events.length;
                     const historyEntries = nativeHistory?.entries.length
                         ? nativeHistory.entries
-                        : state.historyQuery.listProductHistoryEntries({
+                        : await (state.readQueries?.history ?? state.historyQuery).listProductHistoryEntries({
                             piboSessionId: selectedSession.id,
                             limit: Math.min(eventLimit * 2, 1000),
                             ...(beforeSequence !== undefined ? { beforeSequence } : {}),
@@ -5261,7 +5557,7 @@ export function createChatWebApp(options = {}) {
                     }, { status: 413, headers: { ...baseHeaders, "x-pibo-trace-v1-deprecated": "true", ...serverTiming(cached ? "hit" : "miss", eventCount) } });
                 }
                 if (includeRawEvents) {
-                    const rawEvents = state.timelineQuery.listTraceEvents({
+                    const rawEvents = await (state.readQueries?.timeline ?? state.timelineQuery).listTraceEvents({
                         piboSessionId: selectedSession.id,
                         limit: rawEventsLimit,
                         ...(beforeSequence !== undefined ? { beforeSequence } : {}),
@@ -5281,7 +5577,10 @@ export function createChatWebApp(options = {}) {
             }
             if (url.pathname === `${CHAT_WEB_API_PREFIX}/debug/resources` && request.method === "GET") {
                 await requireSession(request, context);
-                return responseJson({ gateway: serializeGatewayResourceDiagnostics(state) }, { headers: { "cache-control": "no-store" } });
+                return responseJson({
+                    gateway: serializeGatewayResourceDiagnostics(state),
+                    storage: state.asyncStorage?.status() ?? { ready: true, mode: "in-process" },
+                }, { headers: { "cache-control": "no-store" } });
             }
             if (url.pathname === `${CHAT_WEB_API_PREFIX}/debug/trace-at-sequence` && request.method === "POST") {
                 requireSameOriginJsonRequest(request);
@@ -5297,12 +5596,12 @@ export function createChatWebApp(options = {}) {
                     throw new PiboWebHttpError("Session not found", 404);
                 const ownedSessions = listSharedSessions(context);
                 const indexedSession = state.sessionQuery.getSession(piboSessionId);
-                const turnTimingScan = state.timelineQuery.scanMessageTurnTimings(piboSessionId);
+                const turnTimingScan = await (state.readQueries?.timeline ?? state.timelineQuery).scanMessageTurnTimings(piboSessionId);
                 const trace = await buildTraceView({
                     session,
                     sessions: ownedSessions,
-                    events: state.timelineQuery.listTraceEvents({ piboSessionId, beforeOrAtSequence: eventSequence, limit: DEFAULT_TRACE_EVENTS_PAGE_SIZE }),
-                    historyEntries: state.historyQuery.listProductHistoryEntries({
+                    events: await (state.readQueries?.timeline ?? state.timelineQuery).listTraceEvents({ piboSessionId, beforeOrAtSequence: eventSequence, limit: DEFAULT_TRACE_EVENTS_PAGE_SIZE }),
+                    historyEntries: await (state.readQueries?.history ?? state.historyQuery).listProductHistoryEntries({
                         piboSessionId,
                         limit: DEFAULT_TRACE_EVENTS_PAGE_SIZE,
                         beforeSequence: eventSequence + 1,
@@ -5319,6 +5618,23 @@ export function createChatWebApp(options = {}) {
                 const body = await readJsonBody(request);
                 return startChatStreamingFixture({ state, context, webSession, defaultProfile, body });
             }
+            if (url.pathname === `${CHAT_WEB_API_PREFIX}/message-receipts` && request.method === "GET") {
+                const webSession = await requireSession(request, context);
+                const sessionId = url.searchParams.get("piboSessionId") ?? "";
+                if (!sessionId)
+                    throw new PiboWebHttpError("Session ID required", 400);
+                resolveRequestedSession(state, context, webSession, defaultProfile, sessionId);
+                return responseJson(await state.asyncStorage?.commandReceiptPage(sessionId) ?? { receipts: [] }, { headers: { "cache-control": "no-store" } });
+            }
+            if (url.pathname.startsWith(`${CHAT_WEB_API_PREFIX}/message-receipts/`) && request.method === "GET") {
+                const webSession = await requireSession(request, context);
+                const id = decodeURIComponent(url.pathname.slice(`${CHAT_WEB_API_PREFIX}/message-receipts/`.length));
+                const receipt = await state.asyncStorage?.commandReceipt(id);
+                if (!receipt)
+                    throw new PiboWebHttpError("Message receipt not found", 404);
+                resolveRequestedSession(state, context, webSession, defaultProfile, receipt.sessionId, receipt.roomId);
+                return responseJson({ receipt }, { headers: { "cache-control": "no-store" } });
+            }
             if (url.pathname === `${CHAT_WEB_API_PREFIX}/message` && request.method === "POST") {
                 requireSameOriginJsonRequest(request);
                 const webSession = await requireSession(request, context);
@@ -5359,7 +5675,7 @@ export function createChatWebApp(options = {}) {
                 if (!context.channelContext.getSessionStatusSnapshot) {
                     throw new PiboWebHttpError("Session status snapshots are not available", 501);
                 }
-                state.sessionQuery.upsertSession(selectedSession);
+                state.sessionQuery.upsertSessionsIfChanged([selectedSession]);
                 const snapshot = await context.channelContext.getSessionStatusSnapshot(selectedSession.id, url.searchParams.get("activate") === "false" ? { activate: false } : undefined);
                 return responseJson(snapshot ?? { piboSessionId: selectedSession.id, runtimeActive: false }, {
                     headers: { "cache-control": "no-store" },
@@ -5407,12 +5723,14 @@ export function createChatWebApp(options = {}) {
                 if (isPiboRoomArchived(room)) {
                     throw new PiboWebHttpError("Archived rooms are read-only", 403);
                 }
-                state.sessionQuery.upsertSession(selectedSession);
+                state.sessionQuery.upsertSessionsIfChanged([selectedSession]);
+                const cancelledPending = body.action === "clear_queue" ? await state.asyncStorage?.cancelPendingCommands(selectedSession.id) ?? 0 : 0;
                 const output = await context.channelContext.emit({
                     type: "execution",
                     piboSessionId: selectedSession.id,
                     id: randomUUID(),
                     action: body.action,
+                    ...(cancelledPending ? { clearedBeforeRuntime: cancelledPending } : {}),
                     ...(body.params === undefined ? {} : { params: body.params }),
                 });
                 return responseJson(output);
@@ -5442,4 +5760,34 @@ export function createChatWebApp(options = {}) {
             return undefined;
         },
     };
+    const uncachedHandle = application.handleRequest.bind(application);
+    application.handleRequest = async (request, context) => {
+        const url = new URL(request.url);
+        const sid = url.searchParams.get("piboSessionId");
+        const structure = context.channelContext.getSessionStructureRevision?.();
+        if (request.method !== "GET" || !sid || structure === undefined || ![`${CHAT_WEB_API_PREFIX}/trace`, `${CHAT_WEB_API_PREFIX}/trace/summary`, `${CHAT_WEB_API_PREFIX}/trace/timeline`].includes(url.pathname))
+            return uncachedHandle(request, context);
+        const webSession = await requireSession(request, context);
+        const selected = resolveRequestedSession(state, context, webSession, defaultProfile, sid);
+        if (requiresNativeHistoryCompatibility(selected))
+            return uncachedHandle(request, context);
+        url.searchParams.sort();
+        const fingerprint = () => {
+            const session = context.channelContext.getSession(sid);
+            const revision = state.dataStore.db.prepare("SELECT revision FROM chat_trace_revisions WHERE session_id=?").get(sid);
+            const history = state.dataStore.db.prepare("SELECT revision FROM chat_history_counts WHERE session_id=?").get(sid);
+            const backfill = state.dataStore.db.prepare("SELECT cursor,target FROM chat_read_backfill WHERE id=1").get();
+            const runtime = context.channelContext.getSessionRuntimeStatus?.(sid);
+            return JSON.stringify({ url: url.href, user: webSession.authSession.identity.userId, encoding: request.headers.get("accept-encoding"), structure: context.channelContext.getSessionStructureRevision?.(), session, revision, history, backfill, live: state.outputCompactor.versionForSession(sid), runtime: runtime ? { processing: runtime.processing, streaming: runtime.streaming, queuedMessages: runtime.queuedMessages } : null });
+        };
+        const key = fingerprint();
+        const cached = earlyTraceCache.get(key, request);
+        if (cached)
+            return cached;
+        const response = await uncachedHandle(request, context);
+        if (response && fingerprint() === key)
+            await earlyTraceCache.set(key, response);
+        return response;
+    };
+    return application;
 }