@pasko70/pibo 1.8.0 → 1.8.2

package/dist/core/runtime-telemetry.js

@@ -8,6 +8,7 @@ export class PiboRuntimeTelemetryRecorder {
     telemetry;
     providerEventMode;
     progressFlushIntervalMs;
+    writer;
     pendingProviderProgress = new Map();
     providerRequestCache = new Map();
     lastProviderFlushAtMs = new Map();
@@ -17,6 +18,7 @@ export class PiboRuntimeTelemetryRecorder {
         this.onError = onError;
         this.telemetry = new BestEffortTelemetryService(store, onError);
         this.providerEventMode = options.providerEventMode ?? "aggregate";
+        this.writer = options.writer;
         const progressFlushIntervalMs = options.progressFlushIntervalMs;
         this.progressFlushIntervalMs = typeof progressFlushIntervalMs === "number" && Number.isFinite(progressFlushIntervalMs) && progressFlushIntervalMs >= 0
             ? progressFlushIntervalMs
@@ -25,31 +27,43 @@ export class PiboRuntimeTelemetryRecorder {
     recordOutput(event, context = {}) {
         if (!this.store)
             return;
-        try {
-            this.recordOutputUnsafe(event, context);
-        }
-        catch (error) {
-            this.onError?.(error);
-        }
+        const captured = captureTelemetryContext(context);
+        const capturedEvent = telemetryOutputEventSnapshot(event);
+        this.schedule(() => this.recordOutputUnsafe(capturedEvent, captured));
     }
     recordPiEvent(piboSessionId, event, context = {}) {
         if (!this.store)
             return;
-        try {
-            this.recordPiEventUnsafe(piboSessionId, event, context);
-        }
-        catch (error) {
-            this.onError?.(error);
-        }
+        const summary = providerEventSummaryForPiEvent(event);
+        if (!summary)
+            return;
+        const captured = captureTelemetryContext(context);
+        this.schedule(() => this.recordPiEventSummaryUnsafe(piboSessionId, summary, captured));
     }
     recordMessagesInterrupted(messages, context = {}, reason = "message interrupted") {
         if (!this.store)
             return;
-        for (const message of messages) {
-            if (!message.id)
-                continue;
-            this.recordTurnTerminal({ piboSessionId: message.piboSessionId, eventId: message.id }, context, "aborted", "abort", reason, "runtime_abort");
-        }
+        const captured = captureTelemetryContext(context);
+        const interrupted = messages.flatMap((message) => message.id ? [{ piboSessionId: message.piboSessionId, eventId: message.id }] : []);
+        this.schedule(() => {
+            for (const message of interrupted) {
+                this.recordTurnTerminal(message, captured, "aborted", "abort", reason, "runtime_abort");
+            }
+        });
+    }
+    schedule(write) {
+        const guarded = () => {
+            try {
+                write();
+            }
+            catch (error) {
+                this.onError?.(error);
+            }
+        };
+        if (this.writer)
+            this.writer.enqueue(guarded, this.onError);
+        else
+            guarded();
     }
     recordOutputUnsafe(event, context) {
         switch (event.type) {
@@ -77,7 +91,7 @@ export class PiboRuntimeTelemetryRecorder {
             case "thinking_finished": {
                 this.recordProviderStreamProgress(event, context, "reasoning", "reasoning finished", true);
                 const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
-                this.finishOpenPhasesByName(turn?.turnId, "reasoning", "ok");
+                this.finishOpenPhasesByName(turn?.turnId, "reasoning", "ok", telemetryTimestamp(context));
                 return;
             }
             case "tool_call":
@@ -104,23 +118,21 @@ export class PiboRuntimeTelemetryRecorder {
                 return;
         }
     }
-    recordPiEventUnsafe(piboSessionId, event, context) {
-        const summary = providerEventSummaryForPiEvent(event);
-        if (!summary)
-            return;
+    recordPiEventSummaryUnsafe(piboSessionId, summary, context) {
         const turn = context.activeEventId
             ? this.progressTurnContextForEvent(piboSessionId, context.activeEventId, context)
             : this.activeTurnContext(piboSessionId, context);
         if (!turn)
             return;
-        const now = new Date().toISOString();
+        const now = telemetryTimestamp(context);
+        const nowMs = telemetryTimestampMs(context);
         if (summary.assistantEventType === "start") {
-            this.flushProviderProgress(turn.turnId, now, { force: true, includeLatest: true });
+            this.flushProviderProgress(turn.turnId, now, { force: true, includeLatest: true, nowMs });
             this.clearProviderProgress(turn.turnId);
         }
         const providerRequest = this.providerEventMode === "detailed"
             ? this.providerRequestForTurn(turn.turnId, { includeLatest: summary.messageEnded, refresh: summary.messageEnded })
-            : this.accumulateProviderEvent(turn, summary, now);
+            : this.accumulateProviderEvent(turn, summary, now, nowMs);
         if (!providerRequest) {
             if (summary.messageEnded)
                 this.clearProviderProgress(turn.turnId);
@@ -146,11 +158,11 @@ export class PiboRuntimeTelemetryRecorder {
         }
         if (summary.toolCallId && summary.assistantEventType?.startsWith("toolcall_")) {
             const forceToolProgress = summary.assistantEventType !== "toolcall_delta";
-            if (this.shouldPersistProgress(`${turn.turnId}:tool_args:${summary.toolCallId}`, forceToolProgress)) {
+            if (this.shouldPersistProgress(`${turn.turnId}:tool_args:${summary.toolCallId}`, forceToolProgress, nowMs)) {
                 this.recordPiToolCallProgress(turn, providerRequest.providerRequestId, summary, now);
             }
         }
-        if (!summary.messageEnded && !isTerminalProviderStatus(providerRequest.status) && !summary.normalizedType && this.shouldPersistProgress(`${turn.turnId}:provider_stream:${providerRequest.providerRequestId}`)) {
+        if (!summary.messageEnded && !isTerminalProviderStatus(providerRequest.status) && !summary.normalizedType && this.shouldPersistProgress(`${turn.turnId}:provider_stream:${providerRequest.providerRequestId}`, false, nowMs)) {
             this.startOrProgressPhase(turn, "provider_stream", now, "provider event metadata", { providerRequestId: providerRequest.providerRequestId });
         }
         if (summary.messageEnded)
@@ -160,7 +172,7 @@ export class PiboRuntimeTelemetryRecorder {
         const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, event.source, context);
         if (!turn)
             return;
-        const now = new Date().toISOString();
+        const now = telemetryTimestamp(context);
         const queueDepth = event.queuedMessages;
         this.telemetry.upsertTurn({
             turnId: turn.turnId,
@@ -197,7 +209,7 @@ export class PiboRuntimeTelemetryRecorder {
         const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, event.source, context);
         if (!turn)
             return;
-        const now = new Date().toISOString();
+        const now = telemetryTimestamp(context);
         this.telemetry.finishPhase(phaseId(turn.turnId, "queued"), { status: "ok", endedAt: now, lastProgressAt: now });
         this.telemetry.upsertPhase({
             phaseId: phaseId(turn.turnId, "message_started"),
@@ -244,10 +256,10 @@ export class PiboRuntimeTelemetryRecorder {
             : this.activeTurnContext(event.piboSessionId, context);
         if (!turn)
             return;
-        const now = new Date().toISOString();
-        const providerRequest = this.accumulateNormalizedProviderProgress(turn, now, force);
+        const now = telemetryTimestamp(context);
+        const providerRequest = this.accumulateNormalizedProviderProgress(turn, now, force, telemetryTimestampMs(context));
         const progressKey = `${turn.turnId}:${phaseName}:${providerRequest?.providerRequestId ?? "none"}`;
-        if (!this.shouldPersistProgress(progressKey, force))
+        if (!this.shouldPersistProgress(progressKey, force, telemetryTimestampMs(context)))
             return;
         const storedTurn = this.store?.getTurn(turn.turnId);
         if (storedTurn && TERMINAL_TURN_STATUSES.has(storedTurn.status)) {
@@ -256,7 +268,7 @@ export class PiboRuntimeTelemetryRecorder {
         }
         this.closeOpenPhasesByName(turn.turnId, "message_started", "ok", now);
         const providerStreamKey = `${turn.turnId}:provider_stream:${providerRequest?.providerRequestId ?? "none"}`;
-        if ((!providerRequest || !isTerminalProviderStatus(providerRequest.status)) && this.shouldPersistProgress(providerStreamKey, force)) {
+        if ((!providerRequest || !isTerminalProviderStatus(providerRequest.status)) && this.shouldPersistProgress(providerStreamKey, force, telemetryTimestampMs(context))) {
             this.startOrProgressPhase(turn, "provider_stream", now, "normalized provider stream progress", { providerRequestId: providerRequest?.providerRequestId });
         }
         this.startOrProgressPhase(turn, phaseName, now, summary, { updateTurn: true, providerRequestId: providerRequest?.providerRequestId });
@@ -265,11 +277,11 @@ export class PiboRuntimeTelemetryRecorder {
         const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
         if (!turn)
             return;
-        const now = new Date().toISOString();
+        const now = telemetryTimestamp(context);
         this.closeOpenPhasesByName(turn.turnId, "message_started", "ok", now);
         this.closeOpenPhasesByName(turn.turnId, "assistant_text", "ok", now);
         this.closeOpenPhasesByName(turn.turnId, "reasoning", "ok", now);
-        const providerRequest = this.accumulateNormalizedProviderProgress(turn, now, true)
+        const providerRequest = this.accumulateNormalizedProviderProgress(turn, now, true, telemetryTimestampMs(context))
             ?? this.providerRequestForTurn(turn.turnId, { includeLatest: true });
         this.upsertToolCallArgs(turn, {
             toolCallId: event.toolCallId,
@@ -295,14 +307,14 @@ export class PiboRuntimeTelemetryRecorder {
             : this.activeTurnContext(event.piboSessionId, context);
         if (!turn)
             return;
-        if (!this.shouldPersistProgress(`${turn.turnId}:tool_execution:${event.toolCallId}`, force))
+        if (!this.shouldPersistProgress(`${turn.turnId}:tool_execution:${event.toolCallId}`, force, telemetryTimestampMs(context)))
             return;
         const storedTurn = this.store?.getTurn(turn.turnId);
         if (storedTurn && TERMINAL_TURN_STATUSES.has(storedTurn.status)) {
             this.clearTurnProgress(turn.turnId);
             return;
         }
-        const now = new Date().toISOString();
+        const now = telemetryTimestamp(context);
         const existing = this.store?.getToolCall(event.toolCallId);
         const args = toolArgsMetadata(event.args, true);
         const providerRequestId = existing?.providerRequestId ?? this.latestProviderRequestForTurn(turn.turnId)?.providerRequestId;
@@ -336,7 +348,7 @@ export class PiboRuntimeTelemetryRecorder {
         const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
         if (!turn)
             return;
-        const now = new Date().toISOString();
+        const now = telemetryTimestamp(context);
         const existing = this.store?.getToolCall(event.toolCallId);
         const executionStartedAt = existing?.executionStartedAt;
         this.telemetry.upsertToolCall({
@@ -425,8 +437,8 @@ export class PiboRuntimeTelemetryRecorder {
             this.clearTurnProgress(turn.turnId);
             return;
         }
-        const now = new Date().toISOString();
-        this.flushProviderProgress(turn.turnId, now, { force: true, includeLatest: true });
+        const now = telemetryTimestamp(context);
+        this.flushProviderProgress(turn.turnId, now, { force: true, includeLatest: true, nowMs: telemetryTimestampMs(context) });
         this.finishOpenPhases(turn.turnId, terminalPhaseStatus(status), now);
         this.finishActiveProviderRequests(turn.turnId, providerStatusForTurnStatus(status), now, summary, errorCategory);
         this.finishActiveToolCalls(turn.turnId, status, now, summary);
@@ -540,7 +552,7 @@ export class PiboRuntimeTelemetryRecorder {
             this.providerRequestCache.delete(turnId);
         return request;
     }
-    accumulateProviderEvent(turn, summary, now) {
+    accumulateProviderEvent(turn, summary, now, nowMs) {
         const pending = this.pendingProviderProgress.get(turn.turnId) ?? emptyPendingProviderProgress();
         pending.lastRawEventAt = now;
         pending.upstreamResponseId = summary.upstreamResponseId ?? pending.upstreamResponseId;
@@ -554,9 +566,10 @@ export class PiboRuntimeTelemetryRecorder {
             force: summary.messageEnded,
             includeLatest: summary.messageEnded,
             refresh: summary.messageEnded,
+            nowMs,
         });
     }
-    accumulateNormalizedProviderProgress(turn, now, force = false) {
+    accumulateNormalizedProviderProgress(turn, now, force = false, nowMs = Date.now()) {
         const request = this.providerRequestForTurn(turn.turnId, { includeLatest: force });
         if (!request)
             return undefined;
@@ -565,14 +578,14 @@ export class PiboRuntimeTelemetryRecorder {
         pending.normalizedEventCount += 1;
         this.pendingProviderProgress.set(turn.turnId, pending);
         const flushNow = force || request.status === "started" || request.status === "headers";
-        return this.flushProviderProgress(turn.turnId, now, { force: flushNow, includeLatest: force }) ?? request;
+        return this.flushProviderProgress(turn.turnId, now, { force: flushNow, includeLatest: force, nowMs }) ?? request;
     }
     flushProviderProgress(turnId, now, options = {}) {
         const pending = this.pendingProviderProgress.get(turnId);
         const request = this.providerRequestForTurn(turnId, options);
         if (!pending)
             return request;
-        const nowMs = Date.now();
+        const nowMs = options.nowMs ?? Date.now();
         const lastFlushAtMs = this.lastProviderFlushAtMs.get(turnId);
         if (!options.force && lastFlushAtMs !== undefined && nowMs - lastFlushAtMs < this.progressFlushIntervalMs)
             return request;
@@ -602,8 +615,7 @@ export class PiboRuntimeTelemetryRecorder {
             this.providerRequestCache.set(turnId, updated);
         return updated ?? request;
     }
-    shouldPersistProgress(key, force = false) {
-        const nowMs = Date.now();
+    shouldPersistProgress(key, force = false, nowMs = Date.now()) {
         const lastWriteAtMs = this.lastProgressWriteAtMs.get(key);
         if (!force && lastWriteAtMs !== undefined && nowMs - lastWriteAtMs < this.progressFlushIntervalMs)
             return false;
@@ -960,6 +972,32 @@ function safeJsonByteSize(value) {
 function utf8Bytes(value) {
     return Buffer.byteLength(value, "utf8");
 }
+function telemetryOutputEventSnapshot(event) {
+    if (event.type === "tool_execution_updated")
+        return { ...event, partialResult: undefined };
+    if (event.type === "tool_execution_finished")
+        return { ...event, result: event.isError ? safeErrorMessage(event.result) : undefined };
+    if (event.type === "execution_result")
+        return { ...event, result: undefined };
+    return { ...event };
+}
+function captureTelemetryContext(context) {
+    const parsedAtMs = context.at ? Date.parse(context.at) : Number.NaN;
+    const atMs = context.atMs ?? (Number.isFinite(parsedAtMs) ? parsedAtMs : Date.now());
+    return {
+        ...context,
+        session: context.session ? { ...context.session, metadata: context.session.metadata ? { ...context.session.metadata } : undefined } : undefined,
+        status: context.status ? { ...context.status, activeTools: [...context.status.activeTools], enabledTools: [...context.status.enabledTools] } : undefined,
+        at: context.at ?? new Date(atMs).toISOString(),
+        atMs,
+    };
+}
+function telemetryTimestamp(context) {
+    return context.at ?? new Date().toISOString();
+}
+function telemetryTimestampMs(context) {
+    return context.atMs ?? Date.now();
+}
 export function turnIdForEvent(eventId) {
     return `turn_${eventId}`;
 }

package/dist/core/runtime.js

@@ -166,9 +166,9 @@ function getBuiltinToolAllowlist(profile, customTools) {
         return undefined;
     return [...selectedBuiltinTools, ...customTools.map((tool) => tool.name)];
 }
-function getProfileExtensionFactories(profile, extensionFactories, contextGuardRecovery) {
+function getProfileExtensionFactories(profile, extensionFactories, contextGuardRecovery, getSettingsManager) {
     const piboPromptTemplateExtension = createPiboSystemPromptTemplateExtension();
-    const piboCompactionPromptExtension = createPiboCompactionPromptExtension();
+    const piboCompactionPromptExtension = createPiboCompactionPromptExtension({ getSettingsManager });
     const piboContextGuardExtension = createPiboAssistantContextGuardExtension({}, contextGuardRecovery);
     const providerToolExtensions = profile.tools
         .filter((tool) => tool.enabled !== false)
@@ -241,6 +241,7 @@ export async function createPiboRuntime(options = {}) {
         const mcpAgentContextFile = await getMcpAgentContextFile(profile.mcpServers);
         const skillPaths = getEnabledSkillPaths(runtimeCwd, profile);
         const piPackageOptions = getPiPackageRuntimeOptions(runtimeCwd, profile);
+        let runtimeSettingsManager;
         const services = await createAgentSessionServices({
             cwd: runtimeCwd,
             agentDir: runtimeAgentDir,
@@ -248,7 +249,7 @@ export async function createPiboRuntime(options = {}) {
             resourceLoaderOptions: {
                 ...piPackageOptions.resourceLoaderOptions,
                 additionalSkillPaths: skillPaths,
-                extensionFactories: getProfileExtensionFactories(profile, options.extensionFactories, contextGuardRecovery),
+                extensionFactories: getProfileExtensionFactories(profile, options.extensionFactories, contextGuardRecovery, () => runtimeSettingsManager),
                 noExtensions: true,
                 noSkills: true,
                 noPromptTemplates: true,
@@ -265,6 +266,7 @@ export async function createPiboRuntime(options = {}) {
                 }),
             },
         });
+        runtimeSettingsManager = services.settingsManager;
         applyPiboRuntimeRetryDefaults(services.settingsManager, options.retryDefaults);
         registerOpenAiGpt56Models(services.modelRegistry);
         registerMiniMaxProvider(services.modelRegistry);

package/dist/core/session-errors.js

@@ -10,6 +10,11 @@ const PROVIDER_NETWORK_ERROR_MARKERS = [
     "reset before headers",
     "socket hang up",
     "socket connection was closed",
+    "eai_again",
+    "enotfound",
+    "econnreset",
+    "econnrefused",
+    "etimedout",
 ];
 export function classifySessionErrorMessage(message, options = {}) {
     const normalized = message.toLowerCase();
@@ -20,7 +25,15 @@ export function classifySessionErrorMessage(message, options = {}) {
         return { category: "provider_transport", errorClass: "provider_transport", code: "websocket_error", origin: "provider", retryable: true, userMessage: "The provider WebSocket connection failed." };
     }
     if (normalized.includes("request was aborted") || normalized.includes("aborted")) {
-        return { category: "runtime_abort", errorClass: "runtime_abort", code: "request_aborted", origin: "runtime", retryable: true, userMessage: "The active model request was aborted." };
+        return { category: "runtime_abort", errorClass: "runtime_abort", code: "request_aborted", origin: "runtime", retryable: false, userMessage: "The active model request was aborted." };
+    }
+    if (normalized.includes("insufficient_quota")
+        || normalized.includes("quota exceeded")
+        || normalized.includes("out of budget")
+        || normalized.includes("billing")
+        || normalized.includes("usage limit")
+        || normalized.includes("available balance")) {
+        return { category: "quota_exhausted", errorClass: "provider_rate_limit", code: "quota_exhausted", origin: "provider", retryable: false, userMessage: "The provider quota or billing limit was reached." };
     }
     if (normalized.includes("rate limit") || normalized.includes("429")) {
         return { category: "rate_limit", errorClass: "provider_rate_limit", code: "rate_limited", origin: "provider", retryable: true, userMessage: "The provider rate limit was reached." };

package/dist/core/session-router.js

@@ -19,6 +19,7 @@ import { assertGatewayResourceAvailableForWork } from "./gateway-resource-guard.
 import { withWorkflowSessionKind } from "../sessions/workflow-session-kind.js";
 import { PiboRuntimeTelemetryRecorder } from "./runtime-telemetry.js";
 import { createPiboProviderTelemetryExtension } from "./provider-telemetry.js";
+import { AsyncTelemetryWriter } from "../data/telemetry-writer.js";
 const DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
 const DEFAULT_ROUTED_SESSION_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 export const RALPH_RUNTIME_RETRY_DEFAULTS = {
@@ -140,14 +141,21 @@ export class PiboSessionRouter {
     sessionStore;
     reliabilityStore;
     telemetryStore;
+    telemetryWriter;
     telemetryRecorder;
+    disposePromise;
+    closing = false;
     constructor(options = {}) {
         this.options = options;
         this.pluginRegistry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
         this.sessionStore = options.sessionStore ?? new InMemoryPiboSessionStore();
         this.telemetryStore = options.telemetryStore ?? telemetryStoreFromSessionStore(this.sessionStore);
+        this.telemetryWriter = this.telemetryStore ? new AsyncTelemetryWriter(this.telemetryStore) : undefined;
         this.telemetryRecorder = this.telemetryStore
-            ? new PiboRuntimeTelemetryRecorder(this.telemetryStore, undefined, { providerEventMode: providerEventTelemetryModeFromEnv() })
+            ? new PiboRuntimeTelemetryRecorder(this.telemetryStore, undefined, {
+                providerEventMode: providerEventTelemetryModeFromEnv(),
+                writer: this.telemetryWriter,
+            })
             : undefined;
         const idleTimeoutMs = options.routedSessionIdleTimeoutMs;
         this.routedSessionIdleTimeoutMs = idleTimeoutMs === false
@@ -173,6 +181,8 @@ export class PiboSessionRouter {
         };
     }
     async emit(event) {
+        if (this.closing)
+            throw new Error("Pibo session router is disposed.");
         const session = await this.getOrCreateSession(event.piboSessionId);
         this.clearIdleSessionTimer(event.piboSessionId);
         try {
@@ -229,8 +239,13 @@ export class PiboSessionRouter {
                 sessions.push(cached);
             this.sessions.delete(id);
         }
-        await Promise.all(ids.map((id) => this.runtimeRegistry.closeControllerSessions(id, { force: true })));
-        await Promise.all(sessions.map((session) => session.dispose()));
+        try {
+            await Promise.all(ids.map((id) => this.runtimeRegistry.closeControllerSessions(id, { force: true })));
+            await Promise.all(sessions.map((session) => session.dispose()));
+        }
+        finally {
+            await this.telemetryWriter?.flush();
+        }
         for (const id of ids) {
             this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason });
         }
@@ -319,6 +334,8 @@ export class PiboSessionRouter {
         const eventWithId = { ...event, id: event.id ?? randomUUID() };
         return await new Promise((resolve, reject) => {
             let settled = false;
+            let lastAssistantMessage;
+            let timeout;
             const unsubscribe = this.subscribe((output) => {
                 if (output.piboSessionId !== eventWithId.piboSessionId ||
                     !("eventId" in output) ||
@@ -326,20 +343,21 @@ export class PiboSessionRouter {
                     return;
                 }
                 if (output.type === "assistant_message") {
-                    finish(output);
+                    lastAssistantMessage = output;
+                }
+                else if (output.type === "message_finished") {
+                    finish(lastAssistantMessage ?? new Error(`Pibo session "${eventWithId.piboSessionId}" finished without an assistant reply`));
                 }
                 else if (output.type === "session_error") {
                     finish(new Error(output.error));
                 }
             });
-            const timeout = setTimeout(() => {
-                finish(new Error(`Timed out waiting for assistant reply from Pibo session "${eventWithId.piboSessionId}"`));
-            }, timeoutMs);
             const finish = (result) => {
                 if (settled)
                     return;
                 settled = true;
-                clearTimeout(timeout);
+                if (timeout)
+                    clearTimeout(timeout);
                 unsubscribe();
                 if (result instanceof Error) {
                     reject(result);
@@ -348,21 +366,48 @@ export class PiboSessionRouter {
                     resolve(result);
                 }
             };
+            timeout = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                unsubscribe();
+                const timeoutError = new Error(`Timed out waiting for assistant reply from Pibo session "${eventWithId.piboSessionId}"`);
+                reject(timeoutError);
+                void this.emit({
+                    type: "execution",
+                    piboSessionId: eventWithId.piboSessionId,
+                    action: "abort",
+                    id: randomUUID(),
+                }).catch(() => { });
+            }, timeoutMs);
             this.emit(eventWithId).catch(finish);
         });
     }
     async disposeAll() {
-        const sessions = [...this.sessions.values()];
-        this.sessions.clear();
-        for (const timer of this.idleSessionTimers.values())
-            clearTimeout(timer);
-        this.idleSessionTimers.clear();
-        this.runRegistry.cancelAll("Pibo session router was disposed.");
-        for (const session of sessions)
-            this.signalRegistry.project({ type: "session_disposed", piboSessionId: session.getStatus().piboSessionId, reason: "router disposed" });
-        this.scheduledRunReminders.clear();
-        await this.runtimeRegistry.closeAll({ force: true });
-        await Promise.all(sessions.map((session) => session.dispose()));
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.closing = true;
+        this.disposePromise = this.disposeAllUnsafe();
+        return this.disposePromise;
+    }
+    async disposeAllUnsafe() {
+        try {
+            await Promise.allSettled([...this.pendingSessions.values()]);
+            const sessions = [...this.sessions.values()];
+            this.sessions.clear();
+            for (const timer of this.idleSessionTimers.values())
+                clearTimeout(timer);
+            this.idleSessionTimers.clear();
+            this.runRegistry.cancelAll("Pibo session router was disposed.");
+            for (const session of sessions)
+                this.signalRegistry.project({ type: "session_disposed", piboSessionId: session.getStatus().piboSessionId, reason: "router disposed" });
+            this.scheduledRunReminders.clear();
+            await this.runtimeRegistry.closeAll({ force: true });
+            await Promise.all(sessions.map((session) => session.dispose()));
+        }
+        finally {
+            await this.telemetryWriter?.dispose();
+        }
     }
     clearIdleSessionTimer(piboSessionId) {
         const timer = this.idleSessionTimers.get(piboSessionId);
@@ -407,6 +452,8 @@ export class PiboSessionRouter {
         await this.resetCachedSession(piboSessionId, "routed runtime idle timeout");
     }
     async getOrCreateSession(piboSessionId) {
+        if (this.closing)
+            throw new Error("Pibo session router is disposed.");
         const existing = this.sessions.get(piboSessionId);
         if (existing) {
             this.clearIdleSessionTimer(piboSessionId);
@@ -436,7 +483,7 @@ export class PiboSessionRouter {
         const initialThinkingLevel = resolvePiboSessionInitialThinkingLevel(piboSession);
         const userSettings = loadPiboUserSettings();
         const telemetryExtension = this.telemetryStore
-            ? createPiboProviderTelemetryExtension({ store: this.telemetryStore, session: piboSession, model: activeModel })
+            ? createPiboProviderTelemetryExtension({ store: this.telemetryStore, writer: this.telemetryWriter, session: piboSession, model: activeModel })
             : undefined;
         const runtime = await createPiboRuntime({
             cwd: piboSession.workspace ?? this.options.cwd,
@@ -532,8 +579,13 @@ export class PiboSessionRouter {
         const cached = this.sessions.get(piboSessionId);
         this.clearIdleSessionTimer(piboSessionId);
         this.sessions.delete(piboSessionId);
-        await this.runtimeRegistry.closeControllerSessions(piboSessionId, { force: true });
-        await cached?.dispose();
+        try {
+            await this.runtimeRegistry.closeControllerSessions(piboSessionId, { force: true });
+            await cached?.dispose();
+        }
+        finally {
+            await this.telemetryWriter?.flush();
+        }
         if (reason)
             this.signalRegistry.project({ type: "session_disposed", piboSessionId, reason });
     }

package/dist/data/telemetry-writer.js

@@ -0,0 +1,114 @@
+const DEFAULT_FLUSH_INTERVAL_MS = 25;
+const DEFAULT_MAX_PENDING_OPERATIONS = 1_024;
+/**
+ * Gateway-scoped, ordered telemetry writer.
+ *
+ * Normal writes are deferred briefly so telemetry from multiple routed sessions
+ * shares one SQLite transaction. The queue never drops lifecycle events: when
+ * the hard bound is reached, it drains immediately in the caller instead.
+ */
+export class AsyncTelemetryWriter {
+    store;
+    options;
+    flushIntervalMs;
+    maxPendingOperations;
+    pending = [];
+    flushTimer;
+    flushing = false;
+    closed = false;
+    constructor(store, options = {}) {
+        this.store = store;
+        this.options = options;
+        this.flushIntervalMs = nonNegativeFinite(options.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS);
+        this.maxPendingOperations = positiveInteger(options.maxPendingOperations, DEFAULT_MAX_PENDING_OPERATIONS);
+    }
+    enqueue(write, onError) {
+        if (this.closed) {
+            this.reportError(new Error("Telemetry writer is closed."), onError);
+            return false;
+        }
+        this.pending.push({ write, onError });
+        if (this.pending.length >= this.maxPendingOperations) {
+            this.flushNow();
+        }
+        else {
+            this.scheduleFlush();
+        }
+        return true;
+    }
+    async flush() {
+        this.flushNow();
+    }
+    async dispose() {
+        if (this.closed)
+            return;
+        this.flushNow();
+        this.closed = true;
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = undefined;
+            this.flushNow();
+        }, this.flushIntervalMs);
+        this.flushTimer.unref();
+    }
+    flushNow() {
+        if (this.flushing)
+            return;
+        if (this.flushTimer)
+            clearTimeout(this.flushTimer);
+        this.flushTimer = undefined;
+        this.flushing = true;
+        try {
+            while (this.pending.length > 0) {
+                const batch = this.pending;
+                this.pending = [];
+                try {
+                    this.store.transaction(() => {
+                        for (const operation of batch) {
+                            try {
+                                operation.write();
+                            }
+                            catch (error) {
+                                this.reportError(error, operation.onError);
+                            }
+                        }
+                    });
+                }
+                catch (error) {
+                    for (const operation of batch)
+                        this.reportError(error, operation.onError);
+                }
+            }
+        }
+        finally {
+            this.flushing = false;
+            if (!this.closed && this.pending.length > 0)
+                this.scheduleFlush();
+        }
+    }
+    reportError(error, operationHandler) {
+        try {
+            operationHandler?.(error);
+        }
+        catch {
+            // Telemetry error reporting must not affect runtime work.
+        }
+        if (operationHandler === this.options.onError)
+            return;
+        try {
+            this.options.onError?.(error);
+        }
+        catch {
+            // Telemetry error reporting must not affect runtime work.
+        }
+    }
+}
+function nonNegativeFinite(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function positiveInteger(value, fallback) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}