@pasko70/pibo 1.7.12 → 1.8.0

package/dist/core/context-guard.js

@@ -1,7 +1,92 @@
 import { DEFAULT_COMPACTION_SETTINGS, buildSessionContext, estimateTokens, } from "@earendil-works/pi-coding-agent";
 export const PIBO_CONTEXT_GUARD_NOTICE = "Context safety interrupted this response before adding it to long-term context. Pibo is compacting the session before continuing.";
+export const PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE = "pibo-context-guard-resume";
+export const PIBO_CONTEXT_GUARD_RESUME_PROMPT = "Continue the interrupted task autonomously from the compacted context. Do not wait for additional user input and do not repeat the context-safety notice.";
 const DEFAULT_MIN_COMPACTION_RESERVE_TOKENS = 1024;
 const FALLBACK_CONTEXT_WINDOW = 0;
+const MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS = 3;
+const contextGuardRecoveries = new WeakMap();
+export function createPiboAssistantContextGuardRecovery() {
+    let pending;
+    let claimed = false;
+    let cancelError;
+    let cancelHandler;
+    return {
+        begin() {
+            if (pending && !pending.settled)
+                return;
+            cancelError = undefined;
+            let resolve;
+            const promise = new Promise((done) => {
+                resolve = done;
+            });
+            pending = { promise, resolve, settled: false };
+        },
+        complete() {
+            if (!pending || pending.settled)
+                return;
+            pending.settled = true;
+            pending.resolve({ ok: true });
+        },
+        fail(error) {
+            if (!pending || pending.settled)
+                return;
+            pending.settled = true;
+            pending.resolve({ ok: false, error });
+        },
+        cancel(error) {
+            cancelError = error;
+            if (pending && !pending.settled) {
+                pending.settled = true;
+                pending.resolve({ ok: false, error });
+            }
+            cancelHandler?.();
+        },
+        claim() {
+            claimed = true;
+        },
+        isClaimed() {
+            return claimed;
+        },
+        isPending() {
+            return pending !== undefined && !pending.settled;
+        },
+        onCancel(handler) {
+            cancelHandler = handler;
+        },
+        async wait() {
+            const current = pending;
+            if (!current)
+                return false;
+            const outcome = await current.promise;
+            const cancelled = cancelError;
+            if (pending === current) {
+                pending = undefined;
+                cancelError = undefined;
+            }
+            if (cancelled)
+                throw cancelled;
+            if (!outcome.ok)
+                throw outcome.error;
+            return true;
+        },
+    };
+}
+export function registerPiboAssistantContextGuardRecovery(session, recovery) {
+    contextGuardRecoveries.set(session, recovery);
+}
+export function claimPiboAssistantContextGuardRecovery(session) {
+    contextGuardRecoveries.get(session)?.claim();
+}
+export function cancelPiboAssistantContextGuardRecovery(session, error) {
+    contextGuardRecoveries.get(session)?.cancel(error);
+}
+export function isPiboAssistantContextGuardRecoveryPending(session) {
+    return contextGuardRecoveries.get(session)?.isPending() ?? false;
+}
+export async function waitForPiboAssistantContextGuardRecovery(session) {
+    return await contextGuardRecoveries.get(session)?.wait() ?? false;
+}
 function textTokensByLength(length) {
     return Math.ceil(length / 4);
 }
@@ -79,15 +164,43 @@ function compactionInstructions(projection) {
         : "";
     return `Pibo interrupted the previous assistant response before persisting the full output because it would exceed the safe context budget.${usage} Summarize the durable conversation up to the guard notice, preserve the user's current task and important recent facts, and leave enough context budget for the next response.`;
 }
-export function createPiboAssistantContextGuardExtension(options = {}) {
+export function createPiboAssistantContextGuardExtension(options = {}, recovery = createPiboAssistantContextGuardRecovery()) {
     return (pi) => {
-        const state = { deltaChars: 0, tripped: false, compactQueued: false };
+        const state = {
+            deltaChars: 0,
+            tripped: false,
+            compactQueued: false,
+            resumeRequested: false,
+            resumeInProgress: false,
+            resumeSettling: false,
+            recoveryAttempts: 0,
+        };
         function resetAssistantState() {
             state.deltaChars = 0;
             state.tripped = false;
             state.compactQueued = false;
             state.lastProjection = undefined;
         }
+        function clearResumeStartTimer() {
+            if (state.resumeStartTimer === undefined)
+                return;
+            clearTimeout(state.resumeStartTimer);
+            state.resumeStartTimer = undefined;
+        }
+        function resetRecoveryState() {
+            clearResumeStartTimer();
+            state.tripped = false;
+            state.compactQueued = false;
+            state.resumeRequested = false;
+            state.resumeInProgress = false;
+            state.resumeSettling = false;
+            state.recoveryAttempts = 0;
+        }
+        function failRecovery(error) {
+            resetRecoveryState();
+            recovery.fail(error);
+        }
+        recovery.onCancel(resetRecoveryState);
         function tripIfNeeded(ctx, assistantTokens) {
             const projection = projectAssistantContextGuard(ctx, assistantTokens, options);
             state.lastProjection = projection;
@@ -96,6 +209,20 @@ export function createPiboAssistantContextGuardExtension(options = {}) {
             state.tripped = true;
             return true;
         }
+        pi.on("agent_start", () => {
+            if (!state.resumeRequested)
+                return;
+            clearResumeStartTimer();
+            state.resumeRequested = false;
+            state.resumeInProgress = true;
+        });
+        pi.on("agent_settled", () => {
+            if (!state.resumeSettling)
+                return;
+            state.resumeSettling = false;
+            state.recoveryAttempts = 0;
+            recovery.complete();
+        });
         pi.on("message_start", (event) => {
             if (event.message.role === "assistant")
                 resetAssistantState();
@@ -117,10 +244,50 @@ export function createPiboAssistantContextGuardExtension(options = {}) {
             return { message: replacementAssistantMessage(event.message) };
         });
         pi.on("agent_end", (_event, ctx) => {
-            if (!state.tripped || state.compactQueued)
+            if (state.tripped && !state.compactQueued) {
+                if (state.recoveryAttempts >= MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS) {
+                    failRecovery(new Error(`Context guard recovery exceeded ${MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS} compaction attempts`));
+                    return;
+                }
+                state.compactQueued = true;
+                state.recoveryAttempts++;
+                recovery.begin();
+                let callbackHandled = false;
+                ctx.compact({
+                    customInstructions: compactionInstructions(state.lastProjection),
+                    onComplete: () => {
+                        if (callbackHandled || !recovery.isPending())
+                            return;
+                        callbackHandled = true;
+                        state.tripped = false;
+                        state.compactQueued = false;
+                        state.resumeRequested = true;
+                        if (recovery.isClaimed()) {
+                            recovery.complete();
+                            return;
+                        }
+                        state.resumeStartTimer = setTimeout(() => {
+                            failRecovery(new Error("Context guard continuation did not start"));
+                        }, 5000);
+                        pi.sendMessage({
+                            customType: PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE,
+                            content: [{ type: "text", text: PIBO_CONTEXT_GUARD_RESUME_PROMPT }],
+                            display: false,
+                        }, { triggerTurn: true });
+                    },
+                    onError: (error) => {
+                        if (callbackHandled || !recovery.isPending())
+                            return;
+                        callbackHandled = true;
+                        failRecovery(error);
+                    },
+                });
+                return;
+            }
+            if (!state.resumeInProgress)
                 return;
-            state.compactQueued = true;
-            ctx.compact({ customInstructions: compactionInstructions(state.lastProjection) });
+            state.resumeInProgress = false;
+            state.resumeSettling = true;
         });
     };
 }

package/dist/core/provider-telemetry.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { BestEffortTelemetryService, } from "../data/telemetry.js";
+import { normalizeSessionErrorDetails } from "./session-errors.js";
 export class PiboProviderTelemetryRecorder {
     options;
     telemetry;
@@ -16,6 +17,9 @@ export class PiboProviderTelemetryRecorder {
             if (!turn)
                 return undefined;
             const now = options.at ?? new Date().toISOString();
+            if (this.activeProviderRequest()) {
+                this.finishActiveProviderRequest("aborted", now, "provider request superseded", undefined, "provider_superseded");
+            }
             const model = modelInfo(options.model, this.options.model, payload);
             const providerRequestId = `pr_${randomUUID()}`;
             const phaseId = this.nextPhaseId(turn.turnId, "provider_request");
@@ -83,7 +87,7 @@ export class PiboProviderTelemetryRecorder {
                 lastProgressAt: now,
                 summary: "provider response received",
             });
-            const streamPhaseId = `${request.turnId}:provider_stream:${request.providerRequestId}`;
+            const streamPhaseId = providerStreamPhaseId(request);
             this.telemetry.upsertPhase({
                 phaseId: streamPhaseId,
                 turnId: request.turnId,
@@ -122,6 +126,56 @@ export class PiboProviderTelemetryRecorder {
             return undefined;
         }
     }
+    // The assistant message boundary ends the provider stream even when the wider
+    // Pibo turn continues with a long-running tool or another provider request.
+    recordMessageEnd(message, options = {}) {
+        if (!this.options.store || !isAssistantMessage(message))
+            return undefined;
+        const status = providerStatusForMessage(message);
+        const summary = providerSummaryForStatus(status);
+        const errorMessage = safeMessageError(message);
+        const errorDetails = status === "error"
+            ? normalizeSessionErrorDetails(errorMessage ?? "Provider request failed.", {
+                api: optionalString(message.api),
+                provider: optionalString(message.provider),
+                model: optionalString(message.model),
+            })
+            : undefined;
+        return this.finishActiveProviderRequest(status, options.at ?? new Date().toISOString(), summary, errorMessage, errorDetails?.category ?? errorDetails?.errorClass);
+    }
+    recordShutdown(reason, at = new Date().toISOString()) {
+        return this.finishActiveProviderRequest("aborted", at, reason, undefined, "runtime_abort");
+    }
+    finishActiveProviderRequest(status, now, summary, errorMessage, errorCategory) {
+        if (!this.options.store)
+            return undefined;
+        try {
+            const request = this.activeProviderRequest();
+            if (!request)
+                return undefined;
+            const phaseStatus = status === "completed" ? "ok" : status;
+            const requestPhaseId = request.phaseId ?? `${request.turnId}:provider_request`;
+            if (this.options.store.getPhase(requestPhaseId)?.status === "open") {
+                this.telemetry.finishPhase(requestPhaseId, { status: phaseStatus, endedAt: now, lastProgressAt: now, summary });
+            }
+            const streamPhaseId = providerStreamPhaseId(request);
+            if (this.options.store.getPhase(streamPhaseId)?.status === "open") {
+                this.telemetry.finishPhase(streamPhaseId, { status: phaseStatus, endedAt: now, lastProgressAt: now, summary });
+            }
+            const updated = this.updateProviderRequest(request, {
+                status,
+                completedAt: now,
+                errorCategory: status === "error" ? errorCategory ?? "provider_error" : status === "aborted" ? errorCategory ?? "runtime_abort" : undefined,
+                errorMessage,
+            });
+            this.activeProviderRequestId = undefined;
+            return updated;
+        }
+        catch (error) {
+            this.options.onError?.(error);
+            return undefined;
+        }
+    }
     activeTurn() {
         const detail = this.options.store?.getSessionTelemetry(this.options.session.id, { limit: 10 });
         const active = detail?.activeTurn;
@@ -138,11 +192,10 @@ export class PiboProviderTelemetryRecorder {
         const turn = this.activeTurn();
         if (!turn)
             return undefined;
-        const timeline = this.options.store?.getTurnTimeline(turn.turnId, { limit: 100 });
-        return [...(timeline?.providerRequests ?? [])].reverse().find((request) => !isTerminalProviderStatus(request.status));
+        return this.options.store?.getActiveProviderRequestForTurn(turn.turnId);
     }
     nextPhaseId(turnId, phaseName) {
-        const count = this.options.store?.getTurnTimeline(turnId, { limit: 100 })?.phases.filter((phase) => phase.name === phaseName).length ?? 0;
+        const count = this.options.store?.countPhasesForTurn(turnId, phaseName) ?? 0;
         return count === 0 ? `${turnId}:${phaseName}` : `${turnId}:${phaseName}:${count + 1}`;
     }
     updateProviderRequest(existing, input) {
@@ -162,12 +215,18 @@ export class PiboProviderTelemetryRecorder {
             responseHeadersAt: input.responseHeadersAt,
             firstByteAt: input.firstByteAt,
             httpStatus: input.httpStatus,
+            completedAt: input.completedAt,
             rawEventCount: existing.rawEventCount,
             normalizedEventCount: existing.normalizedEventCount,
             parseErrorCount: existing.parseErrorCount,
             unknownEventCount: existing.unknownEventCount,
             bytesReceived: existing.bytesReceived,
             eventTypeCounts: existing.eventTypeCounts,
+            eventStreamId: existing.eventStreamId,
+            eventId: existing.eventId,
+            payloadRef: existing.payloadRef,
+            errorCategory: input.errorCategory,
+            errorMessage: input.errorMessage,
             captureMode: existing.captureMode,
             retentionClass: existing.retentionClass,
         });
@@ -182,11 +241,45 @@ export function createPiboProviderTelemetryExtension(options) {
         pi.on("after_provider_response", (event) => {
             recorder.recordResponse({ status: event.status, headers: event.headers });
         });
+        pi.on("message_end", (event) => {
+            recorder.recordMessageEnd(event.message);
+        });
+        pi.on("session_shutdown", (event) => {
+            recorder.recordShutdown(`provider session shutdown: ${event.reason}`);
+        });
     };
 }
 export function isTerminalProviderStatus(status) {
     return status === "completed" || status === "error" || status === "aborted" || status === "timeout";
 }
+function isAssistantMessage(message) {
+    return Boolean(message && typeof message === "object" && message.role === "assistant");
+}
+function providerStatusForMessage(message) {
+    if (message.stopReason === "error")
+        return "error";
+    if (message.stopReason === "aborted")
+        return "aborted";
+    return "completed";
+}
+function providerSummaryForStatus(status) {
+    if (status === "error")
+        return "provider stream failed";
+    if (status === "aborted")
+        return "provider stream aborted";
+    return "provider stream completed";
+}
+function providerStreamPhaseId(request) {
+    return `${request.turnId}:provider_stream:${request.providerRequestId}`;
+}
+function safeMessageError(message) {
+    return typeof message.errorMessage === "string" && message.errorMessage.trim().length > 0
+        ? message.errorMessage.replace(/\s+/g, " ").trim().slice(0, 512)
+        : undefined;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
 function modelInfo(primary, fallback, payload) {
     const payloadModel = modelIdFromPayload(payload);
     return {

package/dist/core/routed-session.js

@@ -2,6 +2,7 @@ import { SessionManager, shouldCompact } from "@earendil-works/pi-coding-agent";
 import { getOpenAiCodexProviderUsageForActiveModel } from "../auth/openai-codex-usage.js";
 import { normalizeSessionErrorDetails, runtimeSessionErrorDetails } from "./session-errors.js";
 import { expandInlineSkills } from "./skill-expansion.js";
+import { PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE, PIBO_CONTEXT_GUARD_RESUME_PROMPT, cancelPiboAssistantContextGuardRecovery, claimPiboAssistantContextGuardRecovery, waitForPiboAssistantContextGuardRecovery, } from "./context-guard.js";
 const FAST_SERVICE_TIER = "priority";
 function modelSupportsFastServiceTier(model) {
     if (!model)
@@ -21,6 +22,9 @@ function withFastServiceTierOption(options) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function isAssistantMessage(message) {
+    return Boolean(message && typeof message === "object" && message.role === "assistant");
+}
 function numberValue(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
@@ -388,6 +392,7 @@ export class RoutedSession {
     onSessionOperation;
     onKillChildren;
     onStateChange;
+    onMessagesInterrupted;
     queue = [];
     processing = false;
     disposed = false;
@@ -398,9 +403,12 @@ export class RoutedSession {
     nextAssistantIndex = 0;
     activeThinkingIndex;
     nextThinkingIndex = 0;
+    pendingAssistantError;
+    activeMessageFailed = false;
     unsubscribe;
+    recoverySession;
     isContinuePatched = false;
-    constructor(piboSessionId, runtime, emit, pluginRegistry, forwardPiEvents, onPiEventTelemetry, initialFastMode, onSessionOperation, onKillChildren, onStateChange) {
+    constructor(piboSessionId, runtime, emit, pluginRegistry, forwardPiEvents, onPiEventTelemetry, initialFastMode, onSessionOperation, onKillChildren, onStateChange, onMessagesInterrupted) {
         this.piboSessionId = piboSessionId;
         this.runtime = runtime;
         this.emit = emit;
@@ -410,6 +418,7 @@ export class RoutedSession {
         this.onSessionOperation = onSessionOperation;
         this.onKillChildren = onKillChildren;
         this.onStateChange = onStateChange;
+        this.onMessagesInterrupted = onMessagesInterrupted;
         this.fastMode = initialFastMode && this.fastModeSupported();
         this.bindRuntimeSession();
         this.patchFastModeProviderRequest();
@@ -485,19 +494,44 @@ export class RoutedSession {
     }
     bindRuntimeSession() {
         this.unsubscribe?.();
-        this.unsubscribe = this.runtime.session.subscribe((event) => {
+        const session = this.runtime.session;
+        if (this.recoverySession && this.recoverySession !== session) {
+            cancelPiboAssistantContextGuardRecovery(this.recoverySession, new Error("Context guard recovery cancelled because the Pi session changed"));
+        }
+        this.recoverySession = session;
+        claimPiboAssistantContextGuardRecovery(session);
+        this.unsubscribe = session.subscribe((event) => {
             this.onPiEventTelemetry?.(this.piboSessionId, event, { status: this.getStatus(), activeEventId: this.activeMessage?.id });
             const model = this.runtime.session.model;
             const normalized = normalizePiEvent(this.piboSessionId, event, { contextWindow: numberValue(model?.contextWindow) });
-            if (normalized) {
-                this.emit(this.withActiveMessage(normalized));
+            const candidate = event && typeof event === "object" ? event : undefined;
+            const assistantMessageEnded = candidate?.type === "message_end" && isAssistantMessage(candidate.message);
+            // Pi may recover an assistant error through retry or compaction. Publish it only
+            // after agent_settled confirms that no automatic continuation remains.
+            if (assistantMessageEnded && normalized?.type === "session_error") {
+                this.pendingAssistantError = this.withActiveMessage(normalized);
+            }
+            else {
+                if (assistantMessageEnded)
+                    this.pendingAssistantError = undefined;
+                if (normalized)
+                    this.emit(this.withActiveMessage(normalized));
             }
+            if (candidate?.type === "agent_settled")
+                this.flushPendingAssistantError();
             if (this.forwardPiEvents) {
                 this.emit({ type: "pi_event", piboSessionId: this.piboSessionId, event });
             }
             this.handleCompactionEvent(event);
         });
     }
+    flushPendingAssistantError() {
+        if (!this.pendingAssistantError)
+            return;
+        this.activeMessageFailed = true;
+        this.emit(this.pendingAssistantError);
+        this.pendingAssistantError = undefined;
+    }
     handleCompactionEvent(event) {
         if (!event || typeof event !== "object")
             return;
@@ -602,15 +636,17 @@ export class RoutedSession {
     }
     removeQueuedMessages(predicate) {
         this.assertActive();
-        let removed = 0;
+        const removedMessages = [];
         for (let index = this.queue.length - 1; index >= 0; index -= 1) {
             const item = this.queue[index];
             if (item.kind !== "message" || !predicate(item.event))
                 continue;
             this.queue.splice(index, 1);
-            removed += 1;
+            removedMessages.push(item.event);
         }
-        return removed;
+        removedMessages.reverse();
+        this.notifyMessagesInterrupted(removedMessages, "queued message removed");
+        return removedMessages.length;
     }
     getCurrentSession() {
         return this.createSessionSnapshot();
@@ -733,16 +769,23 @@ export class RoutedSession {
     async dispose() {
         if (this.disposed)
             return;
+        this.notifyMessagesInterrupted(this.activeAndQueuedMessages(), "session disposed");
         this.queue.length = 0;
         this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: true });
         this.unsubscribe?.();
         this.unsubscribe = undefined;
+        if (this.recoverySession) {
+            this.cancelContextGuardRecovery("Context guard recovery cancelled because the routed session was disposed");
+            this.recoverySession = undefined;
+        }
         this.disposed = true;
         await this.runtime.dispose();
     }
     async kill() {
+        this.notifyMessagesInterrupted(this.activeAndQueuedMessages(), "session killed");
         this.queue.length = 0;
         this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
+        this.cancelContextGuardRecovery("Context guard recovery cancelled because the routed session was killed");
         await this.runtime.session.abort();
         return this.piboSessionId;
     }
@@ -750,11 +793,15 @@ export class RoutedSession {
         this.assertActive();
         const queuedIndex = this.queue.findIndex((item) => item.event.id === eventId);
         if (queuedIndex >= 0) {
-            this.queue.splice(queuedIndex, 1);
+            const [removed] = this.queue.splice(queuedIndex, 1);
+            if (removed?.kind === "message")
+                this.notifyMessagesInterrupted([removed.event], "message cancelled");
             this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
             return true;
         }
         if (this.activeMessage?.id === eventId) {
+            this.notifyMessagesInterrupted([this.activeMessage], "message cancelled");
+            this.cancelContextGuardRecovery("Context guard recovery cancelled with the active message");
             await this.runtime.session.abort();
             return true;
         }
@@ -792,18 +839,37 @@ export class RoutedSession {
         });
         try {
             this.activeMessage = event;
+            this.pendingAssistantError = undefined;
+            this.activeMessageFailed = false;
             this.activeAssistantIndex = undefined;
             this.nextAssistantIndex = 0;
             this.activeThinkingIndex = undefined;
             this.nextThinkingIndex = 0;
-            const expandedText = expandInlineSkills(event.text, this.runtime.session.resourceLoader.getSkills().skills);
-            await this.runtime.session.prompt(expandedText, { source: promptSource(event.source) });
-            this.emit({
-                type: "message_finished",
-                piboSessionId: this.piboSessionId,
-                eventId: event.id,
-                source: event.source,
-            });
+            const session = this.runtime.session;
+            const expandedText = expandInlineSkills(event.text, session.resourceLoader.getSkills().skills);
+            await session.prompt(expandedText, { source: promptSource(event.source) });
+            while (await waitForPiboAssistantContextGuardRecovery(session)) {
+                try {
+                    await session.sendCustomMessage({
+                        customType: PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE,
+                        content: [{ type: "text", text: PIBO_CONTEXT_GUARD_RESUME_PROMPT }],
+                        display: false,
+                    }, { triggerTurn: true });
+                }
+                catch (error) {
+                    const resumeError = error instanceof Error ? error : new Error(String(error));
+                    cancelPiboAssistantContextGuardRecovery(session, resumeError);
+                    throw resumeError;
+                }
+            }
+            if (!this.activeMessageFailed) {
+                this.emit({
+                    type: "message_finished",
+                    piboSessionId: this.piboSessionId,
+                    eventId: event.id,
+                    source: event.source,
+                });
+            }
         }
         catch (error) {
             const message = errorMessage(error);
@@ -817,6 +883,8 @@ export class RoutedSession {
         }
         finally {
             this.activeMessage = undefined;
+            this.pendingAssistantError = undefined;
+            this.activeMessageFailed = false;
             this.activeAssistantIndex = undefined;
             this.nextAssistantIndex = 0;
             this.activeThinkingIndex = undefined;
@@ -873,6 +941,9 @@ export class RoutedSession {
             getProviderUsage: () => this.getProviderUsage(),
             clearQueue: () => this.clearQueue(),
             abort: async () => {
+                if (this.activeMessage)
+                    this.notifyMessagesInterrupted([this.activeMessage], "abort requested");
+                this.cancelContextGuardRecovery("Context guard recovery cancelled by abort");
                 await this.runtime.session.abort();
             },
             dispose: () => this.dispose(),
@@ -913,6 +984,11 @@ export class RoutedSession {
             },
         }, event);
     }
+    cancelContextGuardRecovery(message) {
+        const session = this.recoverySession ?? this.runtime.session;
+        cancelPiboAssistantContextGuardRecovery(session, new Error(message));
+        session.abortCompaction?.();
+    }
     assertActive() {
         if (this.disposed) {
             throw new Error(`Session "${this.piboSessionId}" has been disposed`);
@@ -934,10 +1010,21 @@ export class RoutedSession {
     }
     clearQueue() {
         const cleared = this.queue.length;
+        const removedMessages = this.queue.flatMap((item) => item.kind === "message" ? [item.event] : []);
         this.queue.length = 0;
+        this.notifyMessagesInterrupted(removedMessages, "queue cleared");
         this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
         return cleared;
     }
+    activeAndQueuedMessages() {
+        const messages = this.queue.flatMap((item) => item.kind === "message" ? [item.event] : []);
+        return this.activeMessage ? [this.activeMessage, ...messages] : messages;
+    }
+    notifyMessagesInterrupted(messages, reason) {
+        if (messages.length === 0)
+            return;
+        this.onMessagesInterrupted?.(messages, reason);
+    }
     createSessionSnapshot() {
         const session = this.runtime.session;
         const manager = session.sessionManager;