@pasko70/pibo 1.9.9 → 1.9.11

package/dist/data/telemetry.js

@@ -0,0 +1,471 @@
+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;
+    }
+    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);
+    }
+    getSessionTelemetry(piboSessionId, input = {}) {
+        return getTelemetrySessionDetail(this.db, piboSessionId, input);
+    }
+    getTurnTimeline(turnIdOrEventId, input = {}) {
+        return getTelemetryTurnTimeline(this.db, turnIdOrEventId, input);
+    }
+    getOpenPhaseForTurn(turnId, name) {
+        const row = this.db.prepare(`
+			SELECT * FROM telemetry_phases
+			WHERE turn_id = ? AND name = ? AND status = 'open'
+			ORDER BY COALESCE(last_progress_at, started_at) DESC, created_at DESC
+			LIMIT 1
+		`).get(turnId, name);
+        return row ? phaseFromRow(row) : undefined;
+    }
+    countPhasesForTurn(turnId, name) {
+        const row = this.db.prepare("SELECT COUNT(*) AS count FROM telemetry_phases WHERE turn_id = ? AND name = ?").get(turnId, name);
+        return Number(row.count);
+    }
+    listOpenPhasesForTurn(turnId) {
+        const rows = this.db.prepare(`
+			SELECT * FROM telemetry_phases
+			WHERE turn_id = ? AND status = 'open'
+			ORDER BY started_at ASC, created_at ASC
+		`).all(turnId);
+        return rows.map(phaseFromRow);
+    }
+    getLatestProviderRequestForTurn(turnId) {
+        const row = this.db.prepare(`
+			SELECT * FROM telemetry_provider_requests
+			WHERE turn_id = ?
+			ORDER BY started_at DESC, created_at DESC
+			LIMIT 1
+		`).get(turnId);
+        return row ? providerRequestFromRow(row) : undefined;
+    }
+    getActiveProviderRequestForTurn(turnId) {
+        const row = this.db.prepare(`
+			SELECT * FROM telemetry_provider_requests
+			WHERE turn_id = ? AND status NOT IN ('completed', 'error', 'aborted', 'timeout')
+			ORDER BY started_at DESC, created_at DESC
+			LIMIT 1
+		`).get(turnId);
+        return row ? providerRequestFromRow(row) : undefined;
+    }
+    listActiveProviderRequestsForTurn(turnId) {
+        const rows = this.db.prepare(`
+			SELECT * FROM telemetry_provider_requests
+			WHERE turn_id = ? AND status NOT IN ('completed', 'error', 'aborted', 'timeout')
+			ORDER BY started_at ASC, created_at ASC
+		`).all(turnId);
+        return rows.map(providerRequestFromRow);
+    }
+    listActiveToolCallsForTurn(turnId) {
+        const rows = this.db.prepare(`
+			SELECT * FROM telemetry_tool_calls
+			WHERE turn_id = ? AND status NOT IN ('ok', 'error', 'aborted', 'timeout')
+			ORDER BY created_at ASC
+		`).all(turnId);
+        return rows.map(toolCallFromRow);
+    }
+    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}`);
+    }
+    recordProviderEventSummary(input) {
+        const now = input.updatedAt ?? new Date().toISOString();
+        const receivedAt = input.receivedAt ?? now;
+        const byteSize = input.byteSize ?? 0;
+        const parseStatus = input.parseStatus ?? "ok";
+        const normalizedDelta = input.normalizedEventDelta ?? (input.normalizedType ? 1 : 0);
+        this.incrementProviderCounters(input.providerRequestId, input.eventType, receivedAt, byteSize, parseStatus, normalizedDelta);
+    }
+    recordProviderProgress(input) {
+        const existing = this.getProviderRequest(input.providerRequestId);
+        if (!existing)
+            return undefined;
+        const eventTypeCounts = { ...existing.eventTypeCounts };
+        for (const [eventType, delta] of Object.entries(input.eventTypeCounts ?? {})) {
+            if (!Number.isFinite(delta) || delta <= 0)
+                continue;
+            const current = typeof eventTypeCounts[eventType] === "number" ? eventTypeCounts[eventType] : 0;
+            eventTypeCounts[eventType] = current + delta;
+        }
+        const rawEventCount = Math.max(0, input.rawEventCount ?? 0);
+        const normalizedEventCount = Math.max(0, input.normalizedEventCount ?? 0);
+        const parseErrorCount = Math.max(0, input.parseErrorCount ?? 0);
+        const unknownEventCount = Math.max(0, input.unknownEventCount ?? 0);
+        const bytesReceived = Math.max(0, input.bytesReceived ?? 0);
+        const updatedAt = input.updatedAt ?? input.lastNormalizedEventAt ?? input.lastRawEventAt ?? new Date().toISOString();
+        this.db.prepare(`
+			UPDATE telemetry_provider_requests SET
+				status = CASE WHEN status IN ('completed', 'error', 'aborted', 'timeout') THEN status ELSE COALESCE(?, status) END,
+				last_raw_event_at = COALESCE(?, last_raw_event_at),
+				last_normalized_event_at = COALESCE(?, last_normalized_event_at),
+				upstream_response_id = COALESCE(?, upstream_response_id),
+				raw_event_count = raw_event_count + ?,
+				normalized_event_count = normalized_event_count + ?,
+				parse_error_count = parse_error_count + ?,
+				unknown_event_count = unknown_event_count + ?,
+				bytes_received = CASE WHEN ? = 0 THEN bytes_received ELSE COALESCE(bytes_received, 0) + ? END,
+				event_type_counts_json = ?,
+				updated_at = ?
+			WHERE provider_request_id = ?
+		`).run(input.status ?? null, input.lastRawEventAt ?? null, input.lastNormalizedEventAt ?? null, input.upstreamResponseId ?? null, rawEventCount, normalizedEventCount, parseErrorCount, unknownEventCount, bytesReceived, bytesReceived, JSON.stringify(eventTypeCounts), updatedAt, input.providerRequestId);
+        return {
+            ...existing,
+            status: isTerminalProviderRequestStatus(existing.status) ? existing.status : input.status ?? existing.status,
+            lastRawEventAt: input.lastRawEventAt ?? existing.lastRawEventAt,
+            lastNormalizedEventAt: input.lastNormalizedEventAt ?? existing.lastNormalizedEventAt,
+            upstreamResponseId: input.upstreamResponseId ?? existing.upstreamResponseId,
+            rawEventCount: existing.rawEventCount + rawEventCount,
+            normalizedEventCount: existing.normalizedEventCount + normalizedEventCount,
+            parseErrorCount: existing.parseErrorCount + parseErrorCount,
+            unknownEventCount: existing.unknownEventCount + unknownEventCount,
+            bytesReceived: bytesReceived > 0 ? (existing.bytesReceived ?? 0) + bytesReceived : existing.bytesReceived,
+            eventTypeCounts,
+            updatedAt,
+        };
+    }
+    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) {
+        this.recordProviderProgress({
+            providerRequestId,
+            lastRawEventAt: receivedAt,
+            rawEventCount: 1,
+            normalizedEventCount: normalizedDelta,
+            parseErrorCount: parseStatus === "invalid_json" ? 1 : 0,
+            unknownEventCount: parseStatus === "unknown_type" ? 1 : 0,
+            bytesReceived: byteSize,
+            eventTypeCounts: { [eventType]: 1 },
+            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));
+    }
+    recordProviderEventSummary(input) {
+        this.safe(() => this.store?.recordProviderEventSummary(input));
+    }
+    recordProviderProgress(input) {
+        return this.safe(() => this.store?.recordProviderProgress(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 isTerminalProviderRequestStatus(status) {
+    return status === "completed" || status === "error" || status === "aborted" || status === "timeout";
+}
+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);
+}