@pasko70/pibo 1.8.1 → 1.8.2

package/dist/core/provider-telemetry.js

@@ -10,6 +10,10 @@ export class PiboProviderTelemetryRecorder {
         this.telemetry = new BestEffortTelemetryService(options.store, options.onError);
     }
     recordRequestStart(payload, options = {}) {
+        const capturedOptions = { ...options, at: options.at ?? new Date().toISOString() };
+        return this.schedule(() => this.recordRequestStartNow(providerPayloadSnapshot(payload), capturedOptions));
+    }
+    recordRequestStartNow(payload, options) {
         if (!this.options.store)
             return undefined;
         try {
@@ -74,6 +78,10 @@ export class PiboProviderTelemetryRecorder {
         }
     }
     recordResponse(input) {
+        const captured = { status: input.status, at: input.at ?? new Date().toISOString() };
+        return this.schedule(() => this.recordResponseNow(captured));
+    }
+    recordResponseNow(input) {
         if (!this.options.store)
             return undefined;
         try {
@@ -129,7 +137,14 @@ export class PiboProviderTelemetryRecorder {
     // 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))
+        if (!isAssistantMessage(message))
+            return undefined;
+        const captured = providerAssistantMessageSnapshot(message);
+        const capturedOptions = { ...options, at: options.at ?? new Date().toISOString() };
+        return this.schedule(() => this.recordMessageEndNow(captured, capturedOptions));
+    }
+    recordMessageEndNow(message, options) {
+        if (!this.options.store)
             return undefined;
         const status = providerStatusForMessage(message);
         const summary = providerSummaryForStatus(status);
@@ -144,7 +159,14 @@ export class PiboProviderTelemetryRecorder {
         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");
+        return this.schedule(() => this.finishActiveProviderRequest("aborted", at, reason, undefined, "runtime_abort"));
+    }
+    schedule(write) {
+        if (this.options.writer) {
+            this.options.writer.enqueue(write, this.options.onError);
+            return undefined;
+        }
+        return write();
     }
     finishActiveProviderRequest(status, now, summary, errorMessage, errorCategory) {
         if (!this.options.store)
@@ -301,6 +323,22 @@ function modelFromContext(ctx) {
     const api = typeof candidate.api === "string" && candidate.api.length > 0 ? candidate.api : undefined;
     return provider && id ? { provider, id, api } : undefined;
 }
+function providerAssistantMessageSnapshot(message) {
+    return {
+        role: message.role,
+        stopReason: message.stopReason,
+        errorMessage: message.errorMessage,
+        api: message.api,
+        provider: message.provider,
+        model: message.model,
+    };
+}
+function providerPayloadSnapshot(payload) {
+    return {
+        model: modelIdFromPayload(payload),
+        service_tier: serviceTierFromPayload(payload),
+    };
+}
 function modelIdFromPayload(payload) {
     if (!payload || typeof payload !== "object" || Array.isArray(payload))
         return undefined;

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/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 });
         }
@@ -369,17 +384,30 @@ export class PiboSessionRouter {
         });
     }
     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);
@@ -424,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);
@@ -453,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,
@@ -549,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;
+}

package/dist/data/telemetry.js

@@ -8,6 +8,20 @@ export class TelemetryStore {
     constructor(db) {
         this.db = db;
     }
+    transaction(action) {
+        if (this.db.isTransaction)
+            return action();
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const result = action();
+            this.db.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
     listSessions(input = {}) {
         return listTelemetrySessions(this.db, input);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"