@pasko70/pibo 1.1.0 → 1.2.0

package/dist/data/telemetry.js

@@ -0,0 +1,357 @@
+import { randomUUID } from "node:crypto";
+import { getTelemetrySessionDetail, getTelemetryTurnTimeline, listTelemetryProviderEventsPage, listTelemetrySessions, listTelemetryStaleWork, } from "./telemetry-queries.js";
+import { getTelemetryRetentionStats, pruneTelemetryRetention, } from "./telemetry-retention.js";
+import { phaseFromRow, providerEventFromRow, providerRequestFromRow, toolCallFromRow, turnFromRow, } from "./telemetry-rows.js";
+export { createTelemetryBoundedPreview, telemetrySafeJsonObject, telemetrySafeTopLevelKeys } from "./telemetry-preview.js";
+export class TelemetryStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    listSessions(input = {}) {
+        return listTelemetrySessions(this.db, input);
+    }
+    getSessionTelemetry(piboSessionId, input = {}) {
+        return getTelemetrySessionDetail(this.db, piboSessionId, input);
+    }
+    getTurnTimeline(turnIdOrEventId, input = {}) {
+        return getTelemetryTurnTimeline(this.db, turnIdOrEventId, input);
+    }
+    listProviderEventsPage(providerRequestId, input = {}) {
+        return listTelemetryProviderEventsPage(this.db, providerRequestId, input);
+    }
+    listStaleWork(input = {}) {
+        return listTelemetryStaleWork(this.db, input);
+    }
+    getStats() {
+        return getTelemetryRetentionStats(this.db);
+    }
+    prune(input) {
+        return pruneTelemetryRetention(this.db, input);
+    }
+    upsertTurn(input) {
+        const now = input.updatedAt ?? new Date().toISOString();
+        const turnId = input.turnId ?? `turn_${randomUUID()}`;
+        const existing = input.turnId ? this.getTurn(input.turnId) : undefined;
+        const queuedAt = input.queuedAt ?? existing?.queuedAt ?? now;
+        this.db.prepare(`
+			INSERT INTO telemetry_turns (
+				turn_id, pibo_session_id, root_session_id, room_id, input_event_id, event_id, event_stream_id,
+				payload_ref, run_id, source, status, current_phase, queued_at, started_at, completed_at,
+				last_progress_at, queued_behind, queue_depth, summary, retention_class, created_at, updated_at, metadata_json
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+			ON CONFLICT(turn_id) DO UPDATE SET
+				pibo_session_id = excluded.pibo_session_id,
+				root_session_id = COALESCE(excluded.root_session_id, telemetry_turns.root_session_id),
+				room_id = COALESCE(excluded.room_id, telemetry_turns.room_id),
+				input_event_id = COALESCE(excluded.input_event_id, telemetry_turns.input_event_id),
+				event_id = COALESCE(excluded.event_id, telemetry_turns.event_id),
+				event_stream_id = COALESCE(excluded.event_stream_id, telemetry_turns.event_stream_id),
+				payload_ref = COALESCE(excluded.payload_ref, telemetry_turns.payload_ref),
+				run_id = COALESCE(excluded.run_id, telemetry_turns.run_id),
+				source = excluded.source,
+				status = excluded.status,
+				current_phase = COALESCE(excluded.current_phase, telemetry_turns.current_phase),
+				started_at = COALESCE(excluded.started_at, telemetry_turns.started_at),
+				completed_at = COALESCE(excluded.completed_at, telemetry_turns.completed_at),
+				last_progress_at = COALESCE(excluded.last_progress_at, telemetry_turns.last_progress_at),
+				queued_behind = COALESCE(excluded.queued_behind, telemetry_turns.queued_behind),
+				queue_depth = COALESCE(excluded.queue_depth, telemetry_turns.queue_depth),
+				summary = COALESCE(excluded.summary, telemetry_turns.summary),
+				retention_class = excluded.retention_class,
+				updated_at = excluded.updated_at,
+				metadata_json = COALESCE(excluded.metadata_json, telemetry_turns.metadata_json)
+		`).run(turnId, input.piboSessionId, input.rootSessionId ?? null, input.roomId ?? null, input.inputEventId ?? null, input.eventId ?? null, input.eventStreamId ?? null, input.payloadRef ?? null, input.runId ?? null, input.source ?? existing?.source ?? "user", input.status ?? existing?.status ?? "queued", input.currentPhase ?? null, queuedAt, input.startedAt ?? null, input.completedAt ?? null, input.lastProgressAt ?? null, input.queuedBehind ?? null, input.queueDepth ?? null, input.summary ?? null, input.retentionClass ?? existing?.retentionClass ?? "diagnostic", input.createdAt ?? existing?.createdAt ?? now, now, JSON.stringify(input.metadata ?? existing?.metadata ?? {}));
+        return this.getTurn(turnId) ?? fail(`Failed to upsert telemetry turn ${turnId}`);
+    }
+    upsertPhase(input) {
+        const now = input.updatedAt ?? new Date().toISOString();
+        const phaseId = input.phaseId ?? `phase_${randomUUID()}`;
+        const existing = input.phaseId ? this.getPhase(input.phaseId) : undefined;
+        const startedAt = input.startedAt ?? existing?.startedAt ?? now;
+        this.db.prepare(`
+			INSERT INTO telemetry_phases (
+				phase_id, turn_id, pibo_session_id, root_session_id, room_id, name, status, started_at, ended_at,
+				last_progress_at, duration_ms, provider_request_id, tool_call_id, event_stream_id, event_id,
+				payload_ref, run_id, counters_json, summary, retention_class, created_at, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+			ON CONFLICT(phase_id) DO UPDATE SET
+				turn_id = excluded.turn_id,
+				pibo_session_id = excluded.pibo_session_id,
+				root_session_id = COALESCE(excluded.root_session_id, telemetry_phases.root_session_id),
+				room_id = COALESCE(excluded.room_id, telemetry_phases.room_id),
+				name = excluded.name,
+				status = excluded.status,
+				ended_at = COALESCE(excluded.ended_at, telemetry_phases.ended_at),
+				last_progress_at = COALESCE(excluded.last_progress_at, telemetry_phases.last_progress_at),
+				duration_ms = COALESCE(excluded.duration_ms, telemetry_phases.duration_ms),
+				provider_request_id = COALESCE(excluded.provider_request_id, telemetry_phases.provider_request_id),
+				tool_call_id = COALESCE(excluded.tool_call_id, telemetry_phases.tool_call_id),
+				event_stream_id = COALESCE(excluded.event_stream_id, telemetry_phases.event_stream_id),
+				event_id = COALESCE(excluded.event_id, telemetry_phases.event_id),
+				payload_ref = COALESCE(excluded.payload_ref, telemetry_phases.payload_ref),
+				run_id = COALESCE(excluded.run_id, telemetry_phases.run_id),
+				counters_json = COALESCE(excluded.counters_json, telemetry_phases.counters_json),
+				summary = COALESCE(excluded.summary, telemetry_phases.summary),
+				retention_class = excluded.retention_class,
+				updated_at = excluded.updated_at
+		`).run(phaseId, input.turnId, input.piboSessionId, input.rootSessionId ?? null, input.roomId ?? null, input.name, input.status ?? existing?.status ?? "open", startedAt, input.endedAt ?? null, input.lastProgressAt ?? null, input.durationMs ?? null, input.providerRequestId ?? null, input.toolCallId ?? null, input.eventStreamId ?? null, input.eventId ?? null, input.payloadRef ?? null, input.runId ?? null, JSON.stringify(input.counters ?? existing?.counters ?? {}), input.summary ?? null, input.retentionClass ?? existing?.retentionClass ?? "diagnostic", input.createdAt ?? existing?.createdAt ?? now, now);
+        return this.getPhase(phaseId) ?? fail(`Failed to upsert telemetry phase ${phaseId}`);
+    }
+    finishPhase(phaseId, input = {}) {
+        const existing = this.getPhase(phaseId);
+        if (!existing)
+            return undefined;
+        const endedAt = input.endedAt ?? new Date().toISOString();
+        return this.upsertPhase({
+            phaseId,
+            turnId: existing.turnId,
+            piboSessionId: existing.piboSessionId,
+            rootSessionId: existing.rootSessionId,
+            roomId: existing.roomId,
+            name: existing.name,
+            status: input.status ?? "ok",
+            endedAt,
+            lastProgressAt: input.lastProgressAt ?? endedAt,
+            durationMs: input.durationMs ?? Math.max(0, Date.parse(endedAt) - Date.parse(existing.startedAt)),
+            summary: input.summary,
+            retentionClass: existing.retentionClass,
+        });
+    }
+    upsertProviderRequest(input) {
+        const now = input.updatedAt ?? new Date().toISOString();
+        const providerRequestId = input.providerRequestId ?? `pr_${randomUUID()}`;
+        const existing = input.providerRequestId ? this.getProviderRequest(input.providerRequestId) : undefined;
+        const startedAt = input.startedAt ?? existing?.startedAt ?? now;
+        this.db.prepare(`
+			INSERT INTO telemetry_provider_requests (
+				provider_request_id, pibo_session_id, root_session_id, room_id, turn_id, phase_id, provider, api, model,
+				transport, service_tier, status, started_at, response_headers_at, first_byte_at, last_raw_event_at,
+				last_normalized_event_at, completed_at, http_status, upstream_response_id, raw_event_count,
+				normalized_event_count, parse_error_count, unknown_event_count, bytes_received, event_type_counts_json,
+				event_stream_id, event_id, payload_ref, error_category, error_message, capture_mode, retention_class,
+				created_at, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+			ON CONFLICT(provider_request_id) DO UPDATE SET
+				pibo_session_id = excluded.pibo_session_id,
+				root_session_id = COALESCE(excluded.root_session_id, telemetry_provider_requests.root_session_id),
+				room_id = COALESCE(excluded.room_id, telemetry_provider_requests.room_id),
+				turn_id = excluded.turn_id,
+				phase_id = COALESCE(excluded.phase_id, telemetry_provider_requests.phase_id),
+				provider = excluded.provider,
+				api = excluded.api,
+				model = excluded.model,
+				transport = excluded.transport,
+				service_tier = COALESCE(excluded.service_tier, telemetry_provider_requests.service_tier),
+				status = excluded.status,
+				response_headers_at = COALESCE(excluded.response_headers_at, telemetry_provider_requests.response_headers_at),
+				first_byte_at = COALESCE(excluded.first_byte_at, telemetry_provider_requests.first_byte_at),
+				last_raw_event_at = COALESCE(excluded.last_raw_event_at, telemetry_provider_requests.last_raw_event_at),
+				last_normalized_event_at = COALESCE(excluded.last_normalized_event_at, telemetry_provider_requests.last_normalized_event_at),
+				completed_at = COALESCE(excluded.completed_at, telemetry_provider_requests.completed_at),
+				http_status = COALESCE(excluded.http_status, telemetry_provider_requests.http_status),
+				upstream_response_id = COALESCE(excluded.upstream_response_id, telemetry_provider_requests.upstream_response_id),
+				raw_event_count = excluded.raw_event_count,
+				normalized_event_count = excluded.normalized_event_count,
+				parse_error_count = excluded.parse_error_count,
+				unknown_event_count = excluded.unknown_event_count,
+				bytes_received = COALESCE(excluded.bytes_received, telemetry_provider_requests.bytes_received),
+				event_type_counts_json = excluded.event_type_counts_json,
+				event_stream_id = COALESCE(excluded.event_stream_id, telemetry_provider_requests.event_stream_id),
+				event_id = COALESCE(excluded.event_id, telemetry_provider_requests.event_id),
+				payload_ref = COALESCE(excluded.payload_ref, telemetry_provider_requests.payload_ref),
+				error_category = COALESCE(excluded.error_category, telemetry_provider_requests.error_category),
+				error_message = COALESCE(excluded.error_message, telemetry_provider_requests.error_message),
+				capture_mode = excluded.capture_mode,
+				retention_class = excluded.retention_class,
+				updated_at = excluded.updated_at
+		`).run(providerRequestId, input.piboSessionId, input.rootSessionId ?? null, input.roomId ?? null, input.turnId, input.phaseId ?? null, input.provider, input.api, input.model, input.transport ?? existing?.transport ?? "unknown", input.serviceTier ?? null, input.status ?? existing?.status ?? "started", startedAt, input.responseHeadersAt ?? null, input.firstByteAt ?? null, input.lastRawEventAt ?? null, input.lastNormalizedEventAt ?? null, input.completedAt ?? null, input.httpStatus ?? null, input.upstreamResponseId ?? null, input.rawEventCount ?? existing?.rawEventCount ?? 0, input.normalizedEventCount ?? existing?.normalizedEventCount ?? 0, input.parseErrorCount ?? existing?.parseErrorCount ?? 0, input.unknownEventCount ?? existing?.unknownEventCount ?? 0, input.bytesReceived ?? existing?.bytesReceived ?? null, JSON.stringify(input.eventTypeCounts ?? existing?.eventTypeCounts ?? {}), input.eventStreamId ?? null, input.eventId ?? null, input.payloadRef ?? null, input.errorCategory ?? null, input.errorMessage ?? null, input.captureMode ?? existing?.captureMode ?? "metadata_only", input.retentionClass ?? existing?.retentionClass ?? "diagnostic", input.createdAt ?? existing?.createdAt ?? now, now);
+        return this.getProviderRequest(providerRequestId) ?? fail(`Failed to upsert telemetry provider request ${providerRequestId}`);
+    }
+    appendProviderEventSummary(input) {
+        const now = input.updatedAt ?? new Date().toISOString();
+        const receivedAt = input.receivedAt ?? now;
+        const rawEventId = input.rawEventId ?? `raw_${randomUUID()}`;
+        const existingEvent = this.getProviderEvent(rawEventId);
+        const sequence = input.sequence ?? existingEvent?.sequence ?? this.nextProviderEventSequence(input.providerRequestId);
+        const byteSize = input.byteSize ?? 0;
+        const parseStatus = input.parseStatus ?? "ok";
+        this.db.prepare(`
+			INSERT INTO telemetry_provider_events (
+				raw_event_id, provider_request_id, pibo_session_id, turn_id, phase_id, sequence, received_at,
+				event_type, byte_size, parse_status, normalized_type, event_stream_id, event_id, item_id,
+				tool_call_id, payload_ref, payload_preview_ref, safe_fields_json, retention_class, created_at, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+			ON CONFLICT(raw_event_id) DO UPDATE SET
+				provider_request_id = excluded.provider_request_id,
+				pibo_session_id = COALESCE(excluded.pibo_session_id, telemetry_provider_events.pibo_session_id),
+				turn_id = COALESCE(excluded.turn_id, telemetry_provider_events.turn_id),
+				phase_id = COALESCE(excluded.phase_id, telemetry_provider_events.phase_id),
+				sequence = excluded.sequence,
+				received_at = excluded.received_at,
+				event_type = excluded.event_type,
+				byte_size = excluded.byte_size,
+				parse_status = excluded.parse_status,
+				normalized_type = COALESCE(excluded.normalized_type, telemetry_provider_events.normalized_type),
+				event_stream_id = COALESCE(excluded.event_stream_id, telemetry_provider_events.event_stream_id),
+				event_id = COALESCE(excluded.event_id, telemetry_provider_events.event_id),
+				item_id = COALESCE(excluded.item_id, telemetry_provider_events.item_id),
+				tool_call_id = COALESCE(excluded.tool_call_id, telemetry_provider_events.tool_call_id),
+				payload_ref = COALESCE(excluded.payload_ref, telemetry_provider_events.payload_ref),
+				payload_preview_ref = COALESCE(excluded.payload_preview_ref, telemetry_provider_events.payload_preview_ref),
+				safe_fields_json = excluded.safe_fields_json,
+				retention_class = excluded.retention_class,
+				updated_at = excluded.updated_at
+		`).run(rawEventId, input.providerRequestId, input.piboSessionId ?? null, input.turnId ?? null, input.phaseId ?? null, sequence, receivedAt, input.eventType, byteSize, parseStatus, input.normalizedType ?? null, input.eventStreamId ?? null, input.eventId ?? null, input.itemId ?? null, input.toolCallId ?? null, input.payloadRef ?? null, input.payloadPreviewRef ?? null, JSON.stringify(input.safeFields ?? {}), input.retentionClass ?? "provider_event", input.createdAt ?? now, now);
+        const normalizedDelta = input.normalizedEventDelta ?? (input.normalizedType ? 1 : 0);
+        if (!existingEvent)
+            this.incrementProviderCounters(input.providerRequestId, input.eventType, receivedAt, byteSize, parseStatus, normalizedDelta);
+        return this.getProviderEvent(rawEventId) ?? fail(`Failed to append telemetry provider event ${rawEventId}`);
+    }
+    upsertToolCall(input) {
+        const now = input.updatedAt ?? new Date().toISOString();
+        const existing = this.getToolCall(input.toolCallId);
+        this.db.prepare(`
+			INSERT INTO telemetry_tool_calls (
+				tool_call_id, pibo_session_id, root_session_id, room_id, turn_id, provider_request_id, provider_item_id,
+				output_index, tool_name, status, args_started_at, first_delta_at, last_delta_at, args_completed_at,
+				execution_started_at, execution_ended_at, duration_ms, args_bytes, parse_status, safe_arg_keys_json,
+				event_stream_id, event_id, payload_ref, run_id, error_category, error_message, retention_class, created_at, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+			ON CONFLICT(tool_call_id) DO UPDATE SET
+				pibo_session_id = excluded.pibo_session_id,
+				root_session_id = COALESCE(excluded.root_session_id, telemetry_tool_calls.root_session_id),
+				room_id = COALESCE(excluded.room_id, telemetry_tool_calls.room_id),
+				turn_id = excluded.turn_id,
+				provider_request_id = COALESCE(excluded.provider_request_id, telemetry_tool_calls.provider_request_id),
+				provider_item_id = COALESCE(excluded.provider_item_id, telemetry_tool_calls.provider_item_id),
+				output_index = COALESCE(excluded.output_index, telemetry_tool_calls.output_index),
+				tool_name = excluded.tool_name,
+				status = excluded.status,
+				args_started_at = COALESCE(excluded.args_started_at, telemetry_tool_calls.args_started_at),
+				first_delta_at = COALESCE(excluded.first_delta_at, telemetry_tool_calls.first_delta_at),
+				last_delta_at = COALESCE(excluded.last_delta_at, telemetry_tool_calls.last_delta_at),
+				args_completed_at = COALESCE(excluded.args_completed_at, telemetry_tool_calls.args_completed_at),
+				execution_started_at = COALESCE(excluded.execution_started_at, telemetry_tool_calls.execution_started_at),
+				execution_ended_at = COALESCE(excluded.execution_ended_at, telemetry_tool_calls.execution_ended_at),
+				duration_ms = COALESCE(excluded.duration_ms, telemetry_tool_calls.duration_ms),
+				args_bytes = excluded.args_bytes,
+				parse_status = excluded.parse_status,
+				safe_arg_keys_json = excluded.safe_arg_keys_json,
+				event_stream_id = COALESCE(excluded.event_stream_id, telemetry_tool_calls.event_stream_id),
+				event_id = COALESCE(excluded.event_id, telemetry_tool_calls.event_id),
+				payload_ref = COALESCE(excluded.payload_ref, telemetry_tool_calls.payload_ref),
+				run_id = COALESCE(excluded.run_id, telemetry_tool_calls.run_id),
+				error_category = COALESCE(excluded.error_category, telemetry_tool_calls.error_category),
+				error_message = COALESCE(excluded.error_message, telemetry_tool_calls.error_message),
+				retention_class = excluded.retention_class,
+				updated_at = excluded.updated_at
+		`).run(input.toolCallId, input.piboSessionId, input.rootSessionId ?? null, input.roomId ?? null, input.turnId, input.providerRequestId ?? null, input.providerItemId ?? null, input.outputIndex ?? null, input.toolName, input.status ?? existing?.status ?? "args_started", input.argsStartedAt ?? null, input.firstDeltaAt ?? null, input.lastDeltaAt ?? null, input.argsCompletedAt ?? null, input.executionStartedAt ?? null, input.executionEndedAt ?? null, input.durationMs ?? null, input.argsBytes ?? existing?.argsBytes ?? 0, input.parseStatus ?? existing?.parseStatus ?? "empty", JSON.stringify(input.safeArgKeys ?? existing?.safeArgKeys ?? []), input.eventStreamId ?? null, input.eventId ?? null, input.payloadRef ?? null, input.runId ?? null, input.errorCategory ?? null, input.errorMessage ?? null, input.retentionClass ?? existing?.retentionClass ?? "diagnostic", input.createdAt ?? existing?.createdAt ?? now, now);
+        return this.getToolCall(input.toolCallId) ?? fail(`Failed to upsert telemetry tool call ${input.toolCallId}`);
+    }
+    getTurn(turnId) {
+        const row = this.db.prepare("SELECT * FROM telemetry_turns WHERE turn_id = ?").get(turnId);
+        return row ? turnFromRow(row) : undefined;
+    }
+    getPhase(phaseId) {
+        const row = this.db.prepare("SELECT * FROM telemetry_phases WHERE phase_id = ?").get(phaseId);
+        return row ? phaseFromRow(row) : undefined;
+    }
+    getProviderRequest(providerRequestId) {
+        const row = this.db.prepare("SELECT * FROM telemetry_provider_requests WHERE provider_request_id = ?").get(providerRequestId);
+        return row ? providerRequestFromRow(row) : undefined;
+    }
+    getProviderEvent(rawEventId) {
+        const row = this.db.prepare("SELECT * FROM telemetry_provider_events WHERE raw_event_id = ?").get(rawEventId);
+        return row ? providerEventFromRow(row) : undefined;
+    }
+    listProviderEvents(providerRequestId, input = {}) {
+        return this.listProviderEventsPage(providerRequestId, input).rows;
+    }
+    getToolCall(toolCallId) {
+        const row = this.db.prepare("SELECT * FROM telemetry_tool_calls WHERE tool_call_id = ?").get(toolCallId);
+        return row ? toolCallFromRow(row) : undefined;
+    }
+    getPayloadPreview(_previewRef, _maxBytes = 2048) {
+        return {
+            status: "disabled",
+            reason: "preview_capture_disabled",
+            captureMode: "disabled",
+            message: "Telemetry payload previews are disabled in V1; summaries store metadata and links only.",
+        };
+    }
+    nextProviderEventSequence(providerRequestId) {
+        const row = this.db.prepare("SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence FROM telemetry_provider_events WHERE provider_request_id = ?").get(providerRequestId);
+        return row.next_sequence;
+    }
+    incrementProviderCounters(providerRequestId, eventType, receivedAt, byteSize, parseStatus, normalizedDelta) {
+        const existing = this.getProviderRequest(providerRequestId);
+        if (!existing)
+            return;
+        const eventTypeCounts = { ...existing.eventTypeCounts };
+        const currentCount = typeof eventTypeCounts[eventType] === "number" ? eventTypeCounts[eventType] : 0;
+        eventTypeCounts[eventType] = currentCount + 1;
+        this.upsertProviderRequest({
+            providerRequestId,
+            piboSessionId: existing.piboSessionId,
+            rootSessionId: existing.rootSessionId,
+            roomId: existing.roomId,
+            turnId: existing.turnId,
+            phaseId: existing.phaseId,
+            provider: existing.provider,
+            api: existing.api,
+            model: existing.model,
+            transport: existing.transport,
+            serviceTier: existing.serviceTier,
+            status: existing.status,
+            lastRawEventAt: receivedAt,
+            rawEventCount: existing.rawEventCount + 1,
+            normalizedEventCount: existing.normalizedEventCount + normalizedDelta,
+            parseErrorCount: existing.parseErrorCount + (parseStatus === "invalid_json" ? 1 : 0),
+            unknownEventCount: existing.unknownEventCount + (parseStatus === "unknown_type" ? 1 : 0),
+            bytesReceived: (existing.bytesReceived ?? 0) + byteSize,
+            eventTypeCounts,
+            captureMode: existing.captureMode,
+            retentionClass: existing.retentionClass,
+            updatedAt: receivedAt,
+        });
+    }
+}
+export class BestEffortTelemetryService {
+    store;
+    onError;
+    constructor(store, onError) {
+        this.store = store;
+        this.onError = onError;
+    }
+    upsertTurn(input) {
+        return this.safe(() => this.store?.upsertTurn(input));
+    }
+    upsertPhase(input) {
+        return this.safe(() => this.store?.upsertPhase(input));
+    }
+    finishPhase(phaseId, input = {}) {
+        return this.safe(() => this.store?.finishPhase(phaseId, input));
+    }
+    upsertProviderRequest(input) {
+        return this.safe(() => this.store?.upsertProviderRequest(input));
+    }
+    appendProviderEventSummary(input) {
+        return this.safe(() => this.store?.appendProviderEventSummary(input));
+    }
+    upsertToolCall(input) {
+        return this.safe(() => this.store?.upsertToolCall(input));
+    }
+    safe(action) {
+        try {
+            return action();
+        }
+        catch (error) {
+            this.onError?.(error);
+            return undefined;
+        }
+    }
+}
+function fail(message) {
+    throw new Error(message);
+}

package/dist/debug/delta-compaction.js

@@ -0,0 +1,99 @@
+import { existsSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+import { resolveDebugStore } from "./stores.js";
+const LIVE_ONLY_TYPES = ["assistant_delta", "thinking_delta", "tool_execution_updated"];
+export function runDeltaCompaction(options) {
+    const names = options.store ? [options.store] : ["pibo-data", "reliability"];
+    return { results: names.map((name) => inspectStore(name, options)) };
+}
+export function formatDeltaCompaction(result) {
+    return [
+        "store\tpath\tstatus\tliveOnlyRows\tplannedDeletes\tdeleted\tbyType",
+        ...result.results.map((item) => [
+            item.store,
+            item.path,
+            item.status,
+            item.liveOnlyRows,
+            item.plannedDeletes,
+            item.deleted,
+            item.byType.map((row) => `${row.type}:${row.count}`).join(","),
+        ].join("\t")),
+    ].join("\n");
+}
+function inspectStore(name, options) {
+    const resolved = resolveDebugStore(name === "read-model" ? "chat" : name);
+    if (!resolved.exists || !existsSync(resolved.path)) {
+        return emptyResult(name, resolved.path, "missing");
+    }
+    const db = new DatabaseSync(resolved.path);
+    try {
+        if (name === "reliability")
+            return inspectReliability(db, name, resolved.path, options);
+        return inspectChat(db, name, resolved.path, options);
+    }
+    finally {
+        db.close();
+    }
+}
+function inspectChat(db, store, path, options) {
+    const byType = tableExists(db, "event_log")
+        ? countRows(db, "event_log", "type", "session_id", options.session)
+        : [];
+    const liveOnlyRows = byType.reduce((sum, row) => sum + row.count, 0);
+    let deleted = 0;
+    if (options.apply && liveOnlyRows > 0 && tableExists(db, "event_log")) {
+        deleted += deleteRows(db, "event_log", "type", "session_id", options.session);
+    }
+    return { store, path, exists: true, liveOnlyRows, byType, plannedDeletes: liveOnlyRows, deleted, status: options.apply ? "applied" : "dry-run" };
+}
+function inspectReliability(db, store, path, options) {
+    if (!tableExists(db, "pibo_event_stream"))
+        return emptyResult(store, path, options.apply ? "applied" : "dry-run");
+    const clauses = ["topic = 'pibo.output'", liveOnlyPredicate("json_extract(payload_json, '$.type')")];
+    const values = [];
+    if (options.session) {
+        clauses.push("key = ?");
+        values.push(options.session);
+    }
+    const byType = db
+        .prepare(`SELECT json_extract(payload_json, '$.type') AS type, COUNT(*) AS count FROM pibo_event_stream WHERE ${clauses.join(" AND ")} GROUP BY type ORDER BY type`)
+        .all(...values).map((row) => ({ type: row.type, count: Number(row.count) }));
+    const liveOnlyRows = byType.reduce((sum, row) => sum + row.count, 0);
+    let deleted = 0;
+    if (options.apply && liveOnlyRows > 0) {
+        const result = db.prepare(`DELETE FROM pibo_event_stream WHERE ${clauses.join(" AND ")}`).run(...values);
+        deleted = Number(result.changes ?? 0);
+    }
+    return { store, path, exists: true, liveOnlyRows, byType, plannedDeletes: liveOnlyRows, deleted, status: options.apply ? "applied" : "dry-run" };
+}
+function countRows(db, table, typeColumn, sessionColumn, session) {
+    const clauses = [liveOnlyPredicate(typeColumn)];
+    const values = [];
+    if (session) {
+        clauses.push(`${sessionColumn} = ?`);
+        values.push(session);
+    }
+    return db
+        .prepare(`SELECT ${typeColumn} AS type, COUNT(*) AS count FROM ${table} WHERE ${clauses.join(" AND ")} GROUP BY ${typeColumn} ORDER BY ${typeColumn}`)
+        .all(...values).map((row) => ({ type: row.type, count: Number(row.count) }));
+}
+function deleteRows(db, table, typeColumn, sessionColumn, session) {
+    const clauses = [liveOnlyPredicate(typeColumn)];
+    const values = [];
+    if (session) {
+        clauses.push(`${sessionColumn} = ?`);
+        values.push(session);
+    }
+    const result = db.prepare(`DELETE FROM ${table} WHERE ${clauses.join(" AND ")}`).run(...values);
+    return Number(result.changes ?? 0);
+}
+function liveOnlyPredicate(column) {
+    return `${column} IN (${LIVE_ONLY_TYPES.map((type) => `'${type}'`).join(", ")})`;
+}
+function tableExists(db, table) {
+    const row = db.prepare("SELECT 1 AS found FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
+    return Boolean(row);
+}
+function emptyResult(store, path, status) {
+    return { store, path, exists: status !== "missing", liveOnlyRows: 0, byType: [], plannedDeletes: 0, deleted: 0, status };
+}

package/dist/debug/detail-format.js

@@ -0,0 +1,86 @@
+export const DEFAULT_DETAIL_BYTES = 8 * 1024;
+export const DEFAULT_TOOL_BYTES = 4 * 1024;
+export function parseByteOption(value, name) {
+    if (value === undefined)
+        return undefined;
+    const number = Number(value);
+    if (!Number.isInteger(number) || number < 0)
+        throw new Error(`${name} must be a non-negative integer`);
+    return number;
+}
+export function sliceTextByBytes(text, options = {}, defaultBytes = DEFAULT_DETAIL_BYTES) {
+    const totalBytes = Buffer.byteLength(text, "utf8");
+    const requestedFrom = parseByteOption(options.from, "--from") ?? 0;
+    const from = Math.min(requestedFrom, totalBytes);
+    const byteBudget = options.noTruncate ? undefined : (parseByteOption(options.bytes, "--bytes") ?? parseByteOption(options.maxBytes, "--max-bytes") ?? defaultBytes);
+    if (byteBudget === undefined) {
+        return {
+            text: sliceByByteRange(text, from, totalBytes).text,
+            totalBytes,
+            from,
+            bytesShown: Math.max(0, totalBytes - from),
+            truncatedBefore: from > 0,
+            truncatedAfter: false,
+        };
+    }
+    const range = sliceByByteRange(text, from, from + byteBudget);
+    return {
+        text: range.text,
+        totalBytes,
+        from: range.actualStart,
+        bytesShown: range.bytesShown,
+        truncatedBefore: range.actualStart > 0,
+        truncatedAfter: range.actualEnd < totalBytes,
+    };
+}
+export function formatTruncationFooter(slice, commands = {}) {
+    if (!slice.truncatedBefore && !slice.truncatedAfter)
+        return [];
+    const lines = [`[truncated: showing ${slice.bytesShown} of ${slice.totalBytes} bytes from ${slice.from}]`];
+    if (slice.truncatedAfter && commands.nextChunk) {
+        lines.push("Next chunk:");
+        lines.push(`  ${commands.nextChunk}`);
+    }
+    if (commands.full) {
+        lines.push("Full:");
+        lines.push(`  ${commands.full}`);
+    }
+    return lines;
+}
+export function byteLength(value) {
+    return Buffer.byteLength(value, "utf8");
+}
+function sliceByByteRange(text, startByte, endByte) {
+    let currentByte = 0;
+    let output = "";
+    let actualStart;
+    let actualEnd;
+    for (const char of text) {
+        const charBytes = Buffer.byteLength(char, "utf8");
+        const charStart = currentByte;
+        const charEnd = currentByte + charBytes;
+        currentByte = charEnd;
+        if (charEnd <= startByte)
+            continue;
+        if (charStart < startByte)
+            continue;
+        if (charEnd > endByte)
+            break;
+        if (actualStart === undefined)
+            actualStart = charStart;
+        actualEnd = charEnd;
+        output += char;
+    }
+    const normalizedStart = actualStart ?? Math.min(startByte, currentByte);
+    const normalizedEnd = actualEnd ?? normalizedStart;
+    return { text: output, actualStart: normalizedStart, actualEnd: normalizedEnd, bytesShown: normalizedEnd - normalizedStart };
+}
+export function formatPrimitive(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "object")
+        return JSON.stringify(value, null, 2);
+    return String(value);
+}