@pasko70/pibo 3.0.1 → 3.1.0

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

@@ -2,6 +2,8 @@ import { createHash, randomUUID } from "node:crypto";
 import os from "node:os";
 import { monitorEventLoopDelay } from "node:perf_hooks";
 import { PiboSteeringUnavailableError } from "../../core/events.js";
+import { OutputRenderSequencer } from "../../core/output-render-sequence.js";
+import { OutputPersistenceRetryQueue, } from "../../core/output-persistence-retry.js";
 import { PI_AGENT_RUNTIME_CAPABILITIES, PI_PROTOCOL_VERSION, } from "../../agent-runtimes/pi/adapter.js";
 import { AgentRuntimeBindingMissingError } from "../../agent-runtime/errors.js";
 import { buildPortableRuntimeContextSnapshot, profileWithRuntimeInstance, uniqueRuntimeDiagnostics, } from "../../agent-runtime/context-build.js";
@@ -9,7 +11,7 @@ import { PiboRuntimeResourceService } from "../../agent-runtime/resource-service
 import { summarizeSessionSignalStatus } from "../../signals/status.js";
 import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
 import { OutputCompactor } from "./output-compactor.js";
-import { isLiveOnlyOutputEvent, isPersistableOutputEvent } from "./output-event-policy.js";
+import { isLiveOnlyOutputEvent, isPersistableOutputEvent, isPiboOutputEvent } from "./output-event-policy.js";
 import { chatRoomIdFromMetadata, isDefaultPiboRoom, isPiboRoomArchived, roomWorkspaceFromMetadata, withChatRoomId, withPiboRoomWorkspace, } from "./types/rooms.js";
 import { chatStreamFramesFromOutputEvent, createChatStreamState, nextTransientChatStreamFrameId } from "./stream.js";
 import { buildSessionNodes, buildTraceView } from "./trace.js";
@@ -17,7 +19,7 @@ import { DEFAULT_TRACE_EVENTS_PAGE_SIZE, annotateTracePage, etagForVersion, esti
 import { TRACE_V2_DEFAULT_TIMELINE_LIMIT, TRACE_V2_MAX_TIMELINE_LIMIT, TRACE_V2_PAYLOAD_DEFAULT_LIMIT_BYTES, TRACE_V2_PAYLOAD_MAX_LIMIT_BYTES, TRACE_V2_RAW_EVENTS_DEFAULT_LIMIT, TRACE_V2_RAW_EVENTS_MAX_LIMIT, TRACE_V2_TIMELINE_HARD_BYTES, TRACE_IMAGE_MAX_COUNT, parseTracePayloadRef, readTraceImagePayload, readTracePayloadChunk, traceRawEventsPageFromEvents, traceTimelinePageFromView, } from "./trace-v2.js";
 import { isChatWebSessionArchived } from "./session-metadata.js";
 import { withWorkflowSessionKind } from "../../sessions/workflow-session-kind.js";
-import { CustomAgentStore, createDefaultCustomAgentStore, previewCustomAgentCreate, previewCustomAgentUpdate, } from "./agent-store.js";
+import { CustomAgentTargetReferenceError, CustomAgentStore, createDefaultCustomAgentStore, previewCustomAgentCreate, previewCustomAgentUpdate, } from "./agent-store.js";
 import { loadPiboModelDefaults, } from "../../core/model-defaults.js";
 import { inspectPiboContextBuild } from "../../core/context-build.js";
 import { isPiboThinkingLevel } from "../../core/thinking.js";
@@ -30,10 +32,10 @@ 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 } from "../../data/ingest-service.js";
+import { ChatDataIngestService, outputIdempotencyKey, outputPersistenceDeliveryKey } from "../../data/ingest-service.js";
 import { ChatEventCommandService } from "./data/event-command-service.js";
 import { ChatReadStateService } from "./data/read-state-service.js";
-import { ChatRoomService } from "./data/room-service.js";
+import { ChatRoomService, PiboRoomHierarchyCycleError } from "./data/room-service.js";
 import { ChatSessionQueryService } from "./data/session-query-service.js";
 import { ChatTimelineQueryService } from "./data/timeline-query-service.js";
 import { ChatHistoryQueryService } from "./data/history-query-service.js";
@@ -55,7 +57,7 @@ import { chatSettingsRoute, chatSettingsRouteInvalidatesBootstrapCatalog, chatSe
 import { chatCapabilityRoute, chatCapabilityRouteRequiresSameOrigin, handleChatCapabilityRoute, } from "./chat-capability-routes.js";
 import { chatUserSkillRoute, chatUserSkillRouteRequiresSameOrigin, handleChatUserSkillRoute, syncChatUserSkills, } from "./chat-user-skill-routes.js";
 import { CHAT_WEB_API_PREFIX, agentFolderResourceId, agentResourceId, projectResourcePath, projectSessionResourceId, projectWorkflowHumanActionsResource, projectWorkflowSessionStartResource, roomResourcePath, sessionActionResource, sessionResourceId, signalResource, workflowArchiveResourceId, workflowCatalogResourceId, workflowDraftActionResource, workflowDraftManualTriggerRunResource, workflowDraftResourceId, workflowDuplicateResourceId, workflowNextDraftResourceId, workflowPickerKind, workflowPromptAssetResourceId, workflowVersionResource, } from "./chat-api-routes.js";
-import { assertProjectSessionPatchFields, buildStreamingFixtureSchedule, createAgentInput, createAgentUpdate, createRoomUpdate, createSessionUpdate, normalizeAgentArchived, normalizeAgentFolderName, normalizeClientTxnId, normalizeMessageDelivery, normalizeMessageText, normalizeParentRoomId, normalizeProjectArchived, normalizeProjectDescription, normalizeProjectPath, normalizeProjectSessionArchived, normalizeRoomDeleteConfirmation, normalizeRoomName, normalizeRoomTopic, normalizeRoomType, normalizeRoomWorkspace, normalizeSessionDeleteConfirmation, normalizeSessionTitle, normalizeStreamingFixtureCadenceMs, normalizeStreamingFixtureDeltas, normalizeStreamingFixtureMix, normalizeStreamingFixturePreludeMessages, normalizeStreamingFixturePreludeOnly, normalizeStreamingFixtureProfile, normalizeStreamingFixtureSuppressLiveDeltas, normalizeStreamingFixtureTraceSnapshots, resolveCreateSessionProfile, } from "./chat-request-normalizers.js";
+import { assertProjectSessionPatchFields, buildStreamingFixtureSchedule, createAgentInput, createAgentUpdate, createRoomUpdate, createSessionUpdate, normalizeAgentArchived, normalizeAgentFolderName, normalizeClientTxnId, normalizeMessageDelivery, normalizeMessageText, normalizeParentRoomId, normalizeProjectArchived, normalizeProjectDescription, normalizeProjectPath, normalizeProjectSessionArchived, normalizeRoomDeleteConfirmation, normalizeRoomName, normalizeRoomTopic, normalizeRoomType, normalizeRoomWorkspace, normalizeSessionDeleteConfirmation, normalizeSessionTitle, normalizeStreamingFixtureCadenceMs, normalizeStreamingFixtureDeltas, normalizeStreamingFixtureMix, normalizeStreamingFixturePreludeMessages, normalizeStreamingFixturePreludeOnly, normalizeStreamingFixtureProfile, normalizeStreamingFixtureSuppressLiveDeltas, normalizeStreamingFixtureTraceSnapshots, normalizeStreamingFixtureToolInterleaving, resolveCreateSessionProfile, } from "./chat-request-normalizers.js";
 import { ChatWorkflowArchiveStore, ChatWorkflowDraftStore, ChatWorkflowLifecycleEventStore, ChatWorkflowPromptAssetStore, ChatWorkflowPublishedVersionStore, ChatWorkflowTombstoneStore, hashWorkflowDefinitionJson, normalizeWorkflowPromptAssetLabel, sanitizeWorkflowDiagnostics, } from "./workflow-persistence.js";
 import { normalizeProjectWorkflowHumanActionBody, projectWorkflowHumanActionDiagnosticResponse, projectWorkflowHumanActionLifecyclePayload, projectWorkflowHumanActionRuntimeDiagnostic, projectWorkflowHumanActionSubmittedLifecyclePayload, projectWorkflowPendingHumanActionFromToken, validateProjectWorkflowHumanActionRequest, } from "./project-workflow-human-actions.js";
 import { createProjectWorkflowRunCurrent, createProjectWorkflowSessionSnapshot, normalizeProjectWorkflowSessionConfiguration, workflowVersionFromSnapshot, } from "./project-workflow-sessions.js";
@@ -396,80 +398,210 @@ function ensureEventIndexing(state, context) {
     state.subscribedContext = context;
     state.unsubscribe = context.channelContext.subscribe((event) => {
         const startedAt = performance.now();
+        let prepared;
         try {
-            state.activeTraceSessions.add(event.piboSessionId);
-            const session = context.channelContext.getSession(event.piboSessionId);
+            if (!isPiboOutputEvent(event)) {
+                state.outputPersistenceRetries.quarantine("runtime_output_event_invalid");
+                recordPersistenceError(state.persistenceMetrics, new Error("runtime_output_event_invalid"));
+                return;
+            }
+            const positionedEvent = state.outputRenderSequencer.position(event);
+            state.activeTraceSessions.add(positionedEvent.piboSessionId);
+            const session = context.channelContext.getSession(positionedEvent.piboSessionId);
             const room = session ? ensureSessionRoom(state, context, session) : undefined;
-            const result = state.outputCompactor.compact(event);
+            const result = state.outputCompactor.prepare(positionedEvent);
+            prepared = result;
             for (const liveEvent of result.liveEvents) {
                 if (isPersistableOutputEvent(liveEvent))
                     continue;
-                state.sessionQuery.recordEvent(liveEvent, session);
                 const transient = recordTransientReplayEvent(state, { roomId: room?.id, piboSessionId: liveEvent.piboSessionId, eventType: liveEvent.type, payload: liveEvent });
+                state.sessionQuery.recordEvent(liveEvent, session, undefined, new Date(transient.createdAtMs).toISOString());
                 if (isLiveOnlyOutputEvent(liveEvent) && !hasLiveObserver(state, liveEvent.piboSessionId))
                     continue;
                 for (const listener of state.liveListeners) {
                     listener(transient);
                 }
             }
-            for (const persistableEvent of result.persistedEvents) {
-                if (!isPersistableOutputEvent(persistableEvent))
-                    continue;
-                let stored = state.eventCommands.appendOutputEvent(persistableEvent, {
+            const persistableEvents = result.persistedEvents.filter(isPersistableOutputEvent);
+            if (persistableEvents.length === 0) {
+                result.ack();
+            }
+            else {
+                const persistenceState = {
+                    version: 1,
+                    piboSessionId: positionedEvent.piboSessionId,
                     roomId: room?.id,
                     actorId: session?.id,
-                });
-                if (!stored && session) {
-                    try {
-                        const createdAt = new Date().toISOString();
-                        const ingested = state.ingestService.ingestOutputEvent({
-                            session,
-                            roomId: room?.id,
-                            actorId: session.id,
-                            event: persistableEvent,
-                            createdAt,
-                        });
-                        stored = {
-                            streamId: ingested.streamId,
-                            roomId: room?.id,
-                            piboSessionId: persistableEvent.piboSessionId,
-                            eventId: "eventId" in persistableEvent && typeof persistableEvent.eventId === "string" ? persistableEvent.eventId : `pibo.output:${persistableEvent.type}:${ingested.streamId}`,
-                            eventType: persistableEvent.type,
-                            actorType: "assistant",
-                            actorId: session.id,
-                            createdAt,
-                            retentionClass: reliabilityRetentionClassForOutputEvent(persistableEvent),
-                            payload: persistableEvent,
-                        };
-                    }
-                    catch (error) {
-                        console.warn("[chat-web] failed to write output event into V2", error);
-                    }
-                }
-                if (!stored)
-                    continue;
-                if (persistableEvent.type === "assistant_message" || persistableEvent.type === "message_finished" || persistableEvent.type === "session_error") {
-                    markActiveSessionRead(state, persistableEvent.piboSessionId, stored.streamId);
-                }
-                state.sessionQuery.recordEvent(persistableEvent, session, stored.streamId);
-                state.reliabilityStore.append({
-                    topic: "pibo.output",
-                    key: persistableEvent.piboSessionId,
-                    eventId: `pibo.output:${persistableEvent.piboSessionId}:${persistableEvent.type}:${randomUUID()}`,
-                    retentionClass: reliabilityRetentionClassForOutputEvent(persistableEvent),
-                    payload: boundedReliabilityOutputPayload(state, persistableEvent),
-                });
-                for (const listener of state.liveListeners)
-                    listener(stored);
+                    deliveries: persistableEvents.map((persistableEvent) => ({
+                        deliveryId: outputPersistenceDeliveryKey(persistableEvent),
+                        event: persistableEvent,
+                    })),
+                };
+                state.outputPersistenceRetries.enqueue(createWebOutputPersistenceJob({
+                    state,
+                    context,
+                    persistenceState,
+                    onSuccess: result.ack,
+                    onDeadLetter: (error) => {
+                        result.rollback();
+                        recordPersistenceError(state.persistenceMetrics, error);
+                    },
+                }));
             }
             recordPersistenceDuration(state.persistenceMetrics, performance.now() - startedAt);
         }
         catch (error) {
+            prepared?.rollback();
             recordPersistenceError(state.persistenceMetrics, error);
             console.error("[chat-web] failed to index router event", error);
-            throw error;
         }
     });
+    state.outputPersistenceRetries.recover((job) => {
+        const persistenceState = parseWebOutputPersistenceState(job.payload);
+        if (!persistenceState)
+            throw new Error(`Invalid durable output persistence job ${job.key}`);
+        return createWebOutputPersistenceJob({ state, context, persistenceState });
+    });
+}
+function createWebOutputPersistenceJob(input) {
+    const firstEvent = input.persistenceState.deliveries[0]?.event;
+    return {
+        key: JSON.stringify(input.persistenceState.deliveries.map((delivery) => outputPersistenceDeliveryKey(delivery.event))),
+        piboSessionId: input.persistenceState.piboSessionId,
+        eventId: firstEvent ? outputPersistenceDeliveryKey(firstEvent) : undefined,
+        payload: input.persistenceState,
+        run: (retryContext) => deliverWebOutputPersistenceState(input.state, input.context, retryContext),
+        onSuccess: input.onSuccess,
+        onDeadLetter: input.onDeadLetter,
+    };
+}
+function deliverWebOutputPersistenceState(state, context, retryContext) {
+    const persistenceState = parseWebOutputPersistenceState(retryContext.payload);
+    if (!persistenceState)
+        throw new Error("Invalid durable web output persistence state");
+    const session = context.channelContext.getSession(persistenceState.piboSessionId);
+    if (!session)
+        throw new Error(`No session available for ${persistenceState.piboSessionId}`);
+    for (const delivery of persistenceState.deliveries) {
+        if (!delivery.v2) {
+            const createdAt = new Date().toISOString();
+            const ingested = state.ingestService.ingestOutputEvent({
+                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) {
+                throw new Error(`Missing V2 event ${ingested.streamId} for ${delivery.deliveryId}`);
+            }
+            delivery.v2 = {
+                streamId: ingested.streamId,
+                createdAt: storedEvent.createdAt,
+                eventId: eventIdentityForDelivery(delivery.event),
+                duplicate: ingested.duplicate,
+            };
+            retryContext.updatePayload(persistenceState);
+        }
+        if (!delivery.reliabilityDelivered) {
+            if (delivery.reliabilityPayload === undefined) {
+                delivery.reliabilityPayload = boundedReliabilityOutputPayload(state, delivery.event);
+                retryContext.updatePayload(persistenceState);
+            }
+            const deliveryKey = delivery.deliveryId;
+            state.reliabilityStore.appendOnce({
+                topic: "pibo.output",
+                key: delivery.event.piboSessionId,
+                eventId: deliveryKey,
+                idempotencyKey: deliveryKey,
+                retentionClass: reliabilityRetentionClassForOutputEvent(delivery.event),
+                payload: delivery.reliabilityPayload,
+            });
+            delivery.reliabilityDelivered = true;
+            retryContext.updatePayload(persistenceState);
+        }
+        if (!delivery.sideEffectsDelivered && state.reliabilityStore.hasDeliveryReceipt(delivery.deliveryId, "chat-web-observable-v1")) {
+            delivery.sideEffectsDelivered = true;
+            retryContext.updatePayload(persistenceState);
+        }
+        else if (!delivery.sideEffectsDelivered) {
+            const stored = storedChatEventForDelivery(persistenceState, delivery);
+            if (delivery.event.type === "assistant_message" || delivery.event.type === "message_finished" || delivery.event.type === "session_error") {
+                markActiveSessionRead(state, delivery.event.piboSessionId, stored.streamId);
+            }
+            state.sessionQuery.recordEvent(delivery.event, session, stored.streamId, stored.createdAt);
+            for (const listener of state.liveListeners) {
+                try {
+                    listener(stored);
+                }
+                catch (error) {
+                    console.error("[chat-web] live listener failed", error);
+                }
+            }
+            // This receipt is deliberately recorded after projection and live sends.
+            // A crash before it replays the same deliveryId/streamId at least once;
+            // recording before sends would trade duplicates for silent loss.
+            state.reliabilityStore.recordDeliveryReceipt(delivery.deliveryId, "chat-web-observable-v1");
+            delivery.sideEffectsDelivered = true;
+            retryContext.updatePayload(persistenceState);
+        }
+    }
+}
+function storedChatEventForDelivery(persistenceState, delivery) {
+    if (!delivery.v2)
+        throw new Error(`Missing V2 phase for ${outputPersistenceDeliveryKey(delivery.event)}`);
+    return {
+        streamId: delivery.v2.streamId,
+        ...(persistenceState.roomId ? { roomId: persistenceState.roomId } : {}),
+        piboSessionId: persistenceState.piboSessionId,
+        eventId: delivery.v2.eventId,
+        eventType: delivery.event.type,
+        actorType: "assistant",
+        ...(persistenceState.actorId ? { actorId: persistenceState.actorId } : {}),
+        createdAt: delivery.v2.createdAt,
+        retentionClass: reliabilityRetentionClassForOutputEvent(delivery.event),
+        payload: delivery.event,
+    };
+}
+function eventIdentityForDelivery(event) {
+    return "eventId" in event && typeof event.eventId === "string"
+        ? event.eventId
+        : outputPersistenceDeliveryKey(event);
+}
+function parseWebOutputPersistenceState(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    if (candidate.version !== 1 || typeof candidate.piboSessionId !== "string" || !Array.isArray(candidate.deliveries))
+        return undefined;
+    const deliveries = [];
+    for (const rawDelivery of candidate.deliveries) {
+        if (!rawDelivery || typeof rawDelivery !== "object" || Array.isArray(rawDelivery))
+            return undefined;
+        const delivery = rawDelivery;
+        if (!isPiboOutputEvent(delivery.event) || !outputIdempotencyKey(delivery.event))
+            return undefined;
+        const deliveryId = outputPersistenceDeliveryKey(delivery.event);
+        if (delivery.deliveryId !== undefined && delivery.deliveryId !== deliveryId)
+            return undefined;
+        const v2 = delivery.v2;
+        if (v2 !== undefined && (!v2 || typeof v2 !== "object" || Array.isArray(v2)
+            || !Number.isSafeInteger(v2.streamId)
+            || typeof v2.createdAt !== "string"
+            || typeof v2.eventId !== "string"))
+            return undefined;
+        deliveries.push({ ...rawDelivery, deliveryId });
+    }
+    if (!deliveries.length)
+        return undefined;
+    return {
+        version: 1,
+        piboSessionId: candidate.piboSessionId,
+        ...(typeof candidate.roomId === "string" ? { roomId: candidate.roomId } : {}),
+        ...(typeof candidate.actorId === "string" ? { actorId: candidate.actorId } : {}),
+        deliveries,
+    };
 }
 function reliabilityRetentionClassForOutputEvent(event) {
     if (event.type === "assistant_delta" || event.type === "thinking_delta" || event.type === "tool_execution_updated")
@@ -943,6 +1075,7 @@ function ensureCustomAgentProfiles(state, context) {
 function serializeCustomAgent(agent, context) {
     return {
         ...agent,
+        brokenNativeTools: listBrokenNativeTools(agent.nativeTools, context),
         brokenContextFiles: listBrokenContextFiles(agent.contextFiles, context),
     };
 }
@@ -976,6 +1109,7 @@ const RUNTIME_PROFILE_UPDATE_FIELDS = new Set([
     "mcpServers",
     "piPackages",
     "mainModel",
+    "mainModelFallbacks",
     "subagentModel",
     "thinkingLevel",
     "mainThinkingLevel",
@@ -1040,6 +1174,13 @@ async function requireValidCustomAgentRuntime(agent, context) {
         return;
     throw new PiboWebHttpError(`Agent runtime selection is invalid: ${errors.map((diagnostic) => diagnostic.message).join(" ")}`, 400);
 }
+function listBrokenNativeTools(names, context) {
+    const catalog = context.channelContext.getCapabilityCatalog?.();
+    if (!catalog)
+        return [];
+    const knownNames = new Set(catalog.nativeTools.map((tool) => tool.name));
+    return names.filter((name) => !knownNames.has(name));
+}
 function listBrokenContextFiles(keys, context) {
     const catalog = context.channelContext.getCapabilityCatalog?.();
     if (!catalog)
@@ -2211,6 +2352,17 @@ function normalizeAgentDeleteConfirmation(value) {
     }
     return value.trim();
 }
+function requireCustomAgentNotTargeted(state, agent, options = {}) {
+    const dependents = state.agentStore.listReferencingAgents(agent.id)
+        .filter((dependent) => !options.activeOnly || !dependent.archivedAt);
+    if (dependents.length === 0)
+        return;
+    const error = new CustomAgentTargetReferenceError(agent.profileName, dependents.map((dependent) => dependent.profileName));
+    const message = options.activeOnly
+        ? error.message.replace("targeted by custom agents", "targeted by active custom agents")
+        : error.message;
+    throw new PiboWebHttpError(message, 409);
+}
 async function deleteSessionsForAgentProfile(state, context, webSession, profileNames) {
     const deleteSession = context.channelContext.deleteSession;
     if (!deleteSession)
@@ -2230,10 +2382,13 @@ async function deleteSessionsForAgentProfile(state, context, webSession, profile
         }
     }
     const orderedIds = [...ids].sort((left, right) => sessionDepth(sessionsById.get(right), sessionsById) - sessionDepth(sessionsById.get(left), sessionsById));
+    for (const id of orderedIds) {
+        await state.projectService.deleteProjectSessionWithCanonicalDelete(id, () => deleteSession(id));
+        state.sessionQuery.deleteSessions([id]);
+        state.eventCommands.deleteSessions([id]);
+    }
     for (const id of orderedIds)
-        await deleteSession(id);
-    state.sessionQuery.deleteSessions(orderedIds);
-    state.eventCommands.deleteSessions(orderedIds);
+        disposeSessionStreamState(state, id);
     return orderedIds;
 }
 async function deleteSessionSubtree(state, context, webSession, rootSession) {
@@ -2254,10 +2409,13 @@ async function deleteSessionSubtree(state, context, webSession, rootSession) {
         }
     }
     const orderedIds = [...ids].sort((left, right) => sessionDepth(sessionsById.get(right), sessionsById) - sessionDepth(sessionsById.get(left), sessionsById));
+    for (const id of orderedIds) {
+        await state.projectService.deleteProjectSessionWithCanonicalDelete(id, () => deleteSession(id));
+        state.sessionQuery.deleteSessions([id]);
+        state.eventCommands.deleteSessions([id]);
+    }
     for (const id of orderedIds)
-        await deleteSession(id);
-    state.sessionQuery.deleteSessions(orderedIds);
-    state.eventCommands.deleteSessions(orderedIds);
+        disposeSessionStreamState(state, id);
     return orderedIds;
 }
 async function deleteRoomTree(state, context, webSession, room, confirmName) {
@@ -2292,15 +2450,23 @@ async function deleteRoomTree(state, context, webSession, room, confirmName) {
         }
     }
     const orderedSessionIds = [...ids].sort((left, right) => sessionDepth(sessionsById.get(right), sessionsById) - sessionDepth(sessionsById.get(left), sessionsById));
+    for (const id of orderedSessionIds) {
+        await state.projectService.deleteProjectSessionWithCanonicalDelete(id, () => deleteSession(id));
+        state.sessionQuery.deleteSessions([id]);
+        state.eventCommands.deleteSessions([id]);
+    }
     for (const id of orderedSessionIds)
-        await deleteSession(id);
-    state.sessionQuery.deleteSessions(orderedSessionIds);
-    state.eventCommands.deleteSessions(orderedSessionIds);
+        disposeSessionStreamState(state, id);
     state.eventCommands.deleteRooms(roomIds);
     const orderedRoomIds = [...roomIds].reverse();
     state.roomService.deleteRooms(orderedRoomIds);
     return { deletedRoomIds: orderedRoomIds, deletedSessionIds: orderedSessionIds };
 }
+function disposeSessionStreamState(state, piboSessionId) {
+    state.outputCompactor.disposeSession(piboSessionId);
+    state.outputRenderSequencer.disposeSession(piboSessionId);
+    state.activeTraceSessions.delete(piboSessionId);
+}
 function sessionDepth(session, sessionsById) {
     let depth = 0;
     let current = session;
@@ -2652,9 +2818,6 @@ function parseEventStreamMode(value, fallback) {
         return value;
     return fallback;
 }
-function isPiboOutputEvent(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value) && typeof value.type === "string";
-}
 function liveEventMatches(event, input) {
     if (input.roomId && event.roomId !== input.roomId)
         return false;
@@ -3236,21 +3399,23 @@ function startChatStreamingFixture(input) {
     const deltas = normalizeStreamingFixtureDeltas(input.body.deltas, mix);
     const traceSnapshots = normalizeStreamingFixtureTraceSnapshots(input.body.traceSnapshots);
     const suppressLiveDeltas = normalizeStreamingFixtureSuppressLiveDeltas(input.body.suppressLiveDeltas);
+    const toolInterleaving = normalizeStreamingFixtureToolInterleaving(input.body.toolInterleaving);
     const scheduleMs = buildStreamingFixtureSchedule(deltas.length, cadenceMs, profile);
     const reasoningDeltas = mix === "reasoning-text" ? [" think", " plan", " check", " answer"] : [];
     const reasoningScheduleMs = reasoningDeltas.map((_, index) => Math.max(10, Math.round(((index + 1) * cadenceMs) / 2)));
     const eventId = `streaming-fixture-${randomUUID()}`;
     const emit = (event) => {
-        if (traceSnapshots && (event.type === "assistant_delta" || event.type === "assistant_message" || event.type === "message_finished")) {
-            input.state.outputCompactor.compact(event);
+        const positionedEvent = input.state.outputRenderSequencer.position(event);
+        if (traceSnapshots && (positionedEvent.type === "assistant_delta" || positionedEvent.type === "assistant_message" || positionedEvent.type === "message_finished")) {
+            input.state.outputCompactor.compact(positionedEvent);
         }
-        if (suppressLiveDeltas && event.type === "assistant_delta")
+        if (suppressLiveDeltas && positionedEvent.type === "assistant_delta")
             return;
         const liveEvent = recordTransientReplayEvent(input.state, {
             roomId: room.id,
             piboSessionId: selectedSession.id,
-            eventType: event.type,
-            payload: event,
+            eventType: positionedEvent.type,
+            payload: positionedEvent,
         });
         for (const listener of input.state.liveListeners)
             listener(liveEvent);
@@ -3277,6 +3442,17 @@ function startChatStreamingFixture(input) {
         });
     }
     emit({ type: "message_started", piboSessionId: selectedSession.id, eventId, text: "Streaming benchmark fixture", source: "service" });
+    const toolBase = {
+        piboSessionId: selectedSession.id,
+        eventId,
+        toolCallId: "streaming-fixture-reused-tool",
+        toolName: "read",
+    };
+    if (toolInterleaving) {
+        emit({ ...toolBase, type: "tool_call", args: { path: "README.md" }, argsComplete: true });
+        emitAt(Math.max(10, Math.round(cadenceMs / 3)), { ...toolBase, type: "tool_execution_started", args: { path: "README.md" } });
+        emitAt(Math.max(20, Math.round(cadenceMs * 1.5)), { ...toolBase, type: "tool_execution_updated", args: { path: "README.md" }, partialResult: "Streaming fixture tool update" });
+    }
     if (reasoningDeltas.length) {
         emit({ type: "thinking_started", piboSessionId: selectedSession.id, eventId, thinkingIndex: 0 });
         reasoningDeltas.forEach((delta, index) => {
@@ -3290,6 +3466,9 @@ function startChatStreamingFixture(input) {
     const finalText = deltas.join("");
     const finalReasoning = reasoningDeltas.join("");
     const finishDelayMs = Math.max(scheduleMs[scheduleMs.length - 1] ?? 0, reasoningScheduleMs[reasoningScheduleMs.length - 1] ?? 0) + cadenceMs;
+    if (toolInterleaving) {
+        emitAt(Math.max(30, finishDelayMs - Math.max(10, Math.round(cadenceMs / 2))), { ...toolBase, type: "tool_execution_finished", result: "Streaming fixture tool result", isError: false });
+    }
     emitAt(finishDelayMs, { type: "assistant_message", piboSessionId: selectedSession.id, eventId, assistantIndex: 0, text: finalText });
     emitAt(finishDelayMs, { type: "message_finished", piboSessionId: selectedSession.id, eventId, source: "service" });
     return responseJson({
@@ -3304,6 +3483,7 @@ function startChatStreamingFixture(input) {
             preludeMessages,
             traceSnapshots,
             suppressLiveDeltas,
+            toolInterleaving,
             scheduleMs,
             reasoningScheduleMs,
             reasoningDeltaCount: reasoningDeltas.length,
@@ -3428,6 +3608,7 @@ export function createChatWebApp(options = {}) {
     ensurePrivateChatUploadDirectory();
     const defaultProfile = options.defaultProfile ?? "base";
     const dataStore = createDataStore(options);
+    const reliabilityStore = createReliabilityStore(options.reliabilityStorePath);
     const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
     eventLoopDelay.enable();
     const state = {
@@ -3439,7 +3620,7 @@ export function createChatWebApp(options = {}) {
         roomService: new ChatRoomService(dataStore),
         projectService: new ChatProjectService(options.projectStorePath),
         agentStore: createAgentStore(options.agentStorePath),
-        reliabilityStore: createReliabilityStore(options.reliabilityStorePath),
+        reliabilityStore,
         cronStore: createDefaultPiboCronStore({ path: options.cronStorePath }),
         loopStore: createDefaultPiboLoopStore({ path: options.ralphStorePath }),
         dataStore,
@@ -3447,6 +3628,8 @@ export function createChatWebApp(options = {}) {
         traceCache: new Map(),
         traceTimelinePageCache: new Map(),
         outputCompactor: new OutputCompactor(),
+        outputPersistenceRetries: new OutputPersistenceRetryQueue({ durableStore: reliabilityStore }),
+        outputRenderSequencer: new OutputRenderSequencer(),
         liveListeners: new Set(),
         transientReplaySequence: 0,
         transientReplayBuffer: [],
@@ -3486,11 +3669,14 @@ export function createChatWebApp(options = {}) {
             state.unsubscribe = undefined;
             state.subscribedContext = undefined;
             state.eventLoopDelay.disable();
+            state.outputPersistenceRetries.dispose();
             state.projectService.close();
             state.agentStore.close();
             state.reliabilityStore.close();
             state.cronStore.close();
             state.loopStore.close();
+            state.outputCompactor.disposeAll();
+            state.outputRenderSequencer.disposeAll();
             state.dataStore.close();
         },
         async handleRequest(request, context) {
@@ -3789,7 +3975,9 @@ export function createChatWebApp(options = {}) {
                 const webSession = await requireSession(request, context);
                 const body = await readJsonBody(request);
                 try {
-                    requireSharedProject(state, webSession, projectResource.projectId, { includeArchived: true });
+                    const existingProject = requireSharedProject(state, webSession, projectResource.projectId, { includeArchived: true });
+                    if (existingProject.metadata.default === true)
+                        throw new PiboWebHttpError("Project Manager cannot be changed", 400);
                     const project = state.projectService.updateProject(projectResource.projectId, {
                         ...(body.name !== undefined ? { name: normalizeRoomName(body.name) } : {}),
                         ...(body.description !== undefined ? { description: normalizeProjectDescription(body.description) ?? null } : {}),
@@ -3810,7 +3998,9 @@ export function createChatWebApp(options = {}) {
                 const webSession = await requireSession(request, context);
                 const body = await readJsonBody(request);
                 try {
-                    requireSharedProject(state, webSession, projectResource.projectId, { includeArchived: true });
+                    const project = requireSharedProject(state, webSession, projectResource.projectId, { includeArchived: true });
+                    if (project.metadata.default === true)
+                        throw new PiboWebHttpError("Project Manager cannot be deleted", 400);
                     return responseJson(state.projectService.deleteProject(projectResource.projectId, {
                         confirmName: normalizeRoomDeleteConfirmation(body.confirmName),
                         deleteFiles: body.deleteFiles === true,
@@ -4100,22 +4290,43 @@ export function createChatWebApp(options = {}) {
                 if (!rootPiboSessionId)
                     throw new PiboWebHttpError("rootPiboSessionId is required", 400);
                 requireSharedSession(context, rootPiboSessionId);
-                if (!context.channelContext.snapshotSignalTree || !context.channelContext.subscribeSignalTree) {
+                const includeStatuses = parseBooleanSearchParam(url, "includeStatuses");
+                if (!context.channelContext.snapshotSignalTree
+                    || !context.channelContext.subscribeSignalTree
+                    || (includeStatuses && (!context.channelContext.snapshotSignalStatuses || !context.channelContext.subscribeSignalStatuses))) {
                     throw new PiboWebHttpError("Signal registry is not available", 503);
                 }
-                let unsubscribe;
+                let unsubscribeTree;
+                let unsubscribeStatuses;
                 let heartbeat;
+                let closed = false;
                 const stream = new ReadableStream({
                     start: (controller) => {
                         writeJsonSse(controller, "signal_snapshot", context.channelContext.snapshotSignalTree(rootPiboSessionId));
-                        unsubscribe = context.channelContext.subscribeSignalTree(rootPiboSessionId, (patch) => {
-                            writeJsonSse(controller, "signal_patch", patch, String(patch.toVersion));
+                        unsubscribeTree = context.channelContext.subscribeSignalTree(rootPiboSessionId, (patch) => {
+                            if (!closed)
+                                writeJsonSse(controller, "signal_patch", patch, String(patch.toVersion));
                         });
-                        heartbeat = setInterval(() => writeSseComment(controller, "heartbeat"), 25_000);
+                        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: () => {
-                        unsubscribe?.();
-                        unsubscribe = undefined;
+                        closed = true;
+                        unsubscribeTree?.();
+                        unsubscribeTree = undefined;
+                        unsubscribeStatuses?.();
+                        unsubscribeStatuses = undefined;
                         if (heartbeat)
                             clearInterval(heartbeat);
                         heartbeat = undefined;
@@ -4519,6 +4730,9 @@ export function createChatWebApp(options = {}) {
                 if (customAgentUpdateAffectsRuntime(update)) {
                     await requireValidCustomAgentRuntime(previewCustomAgentUpdate(existing, update), context);
                 }
+                if (archived === true && !existing.archivedAt) {
+                    requireCustomAgentNotTargeted(state, existing, { activeOnly: true });
+                }
                 const updated = Object.keys(update).length ? state.agentStore.update(patchAgentId, update) : existing;
                 const afterUpdate = requireSharedAgent(updated);
                 const agent = archived === undefined ? afterUpdate : state.agentStore.setArchived(patchAgentId, archived);
@@ -4545,8 +4759,16 @@ export function createChatWebApp(options = {}) {
                 if (confirmName !== agent.profileName) {
                     throw new PiboWebHttpError(`Type "${agent.profileName}" to permanently delete this agent and its sessions.`, 400);
                 }
+                requireCustomAgentNotTargeted(state, agent);
                 const deletedSessionIds = await deleteSessionsForAgentProfile(state, context, webSession, [agent.profileName, ...agent.profileAliases]);
-                state.agentStore.delete(agent.id);
+                try {
+                    state.agentStore.delete(agent.id);
+                }
+                catch (error) {
+                    if (error instanceof CustomAgentTargetReferenceError)
+                        throw new PiboWebHttpError(error.message, 409);
+                    throw error;
+                }
                 context.channelContext.removeProfile?.(agent.profileName);
                 invalidateBootstrapCatalogCache(state);
                 return responseJson({ deletedAgentId: agent.id, deletedSessionIds });
@@ -4657,7 +4879,16 @@ export function createChatWebApp(options = {}) {
                 const update = createRoomUpdate(existingRoom, body);
                 if (update.parentRoomId)
                     requireRoom(state, update.parentRoomId, webSession, "admin");
-                const room = state.roomService.updateRoom(roomResource.roomId, update);
+                let room;
+                try {
+                    room = state.roomService.updateRoom(roomResource.roomId, update);
+                }
+                catch (error) {
+                    if (error instanceof PiboRoomHierarchyCycleError) {
+                        throw new PiboWebHttpError(error.message, 400);
+                    }
+                    throw error;
+                }
                 if (!room)
                     throw new PiboWebHttpError("Room not found", 404);
                 return responseJson({ room });