@osolmaz/pi-workflows 0.15.2 → 0.16.0

package/dist/workflows/store.js

@@ -16,6 +16,35 @@ export const SESSION_BINDING_SCHEMA = "pi-workflows.session-binding.v1";
 export const SESSION_EVENT_SCHEMA = "pi-workflows.session-event.v1";
 export const SESSION_CAPTURE_SCHEMA = "pi-workflows.session-capture.v1";
 export const SESSION_EVENT_MAX_BYTES = 1024 * 1024;
+const STEP_ROW_SELECT = `
+  SELECT s.step_index AS stepIndex, a.attempt_id AS attemptId, a.node_id AS nodeId,
+         a.node_type AS nodeType, a.status,
+         a.prompt_hash AS promptHash, a.output_hash AS outputHash,
+         s.output_override_hash AS outputOverrideHash,
+         a.receipt_hash AS receiptHash, a.error_hash AS errorHash,
+         prompt_entry.entry_hash AS promptEntryHash,
+         response_entry.entry_hash AS responseEntryHash,
+         first_link.entry_id AS firstEntryId, last_link.entry_id AS lastEntryId,
+         a.settings_scope_id AS settingsScopeId,
+         a.settings_change_number AS settingsChangeNumber,
+         a.settings_hash AS settingsHash,
+         a.started_at AS startedAt, a.finished_at AS finishedAt
+  FROM run_steps s
+  JOIN node_attempts a ON a.attempt_id = s.attempt_id
+  LEFT JOIN attempt_entries prompt_link
+    ON prompt_link.attempt_id = a.attempt_id AND prompt_link.role = 'prompt'
+  LEFT JOIN session_entries prompt_entry
+    ON prompt_entry.segment_id = prompt_link.segment_id
+   AND prompt_entry.entry_id = prompt_link.entry_id
+  LEFT JOIN attempt_entries response_link
+    ON response_link.attempt_id = a.attempt_id AND response_link.role = 'response'
+  LEFT JOIN session_entries response_entry
+    ON response_entry.segment_id = response_link.segment_id
+   AND response_entry.entry_id = response_link.entry_id
+  LEFT JOIN attempt_entries first_link
+    ON first_link.attempt_id = a.attempt_id AND first_link.role = 'first'
+  LEFT JOIN attempt_entries last_link
+    ON last_link.attempt_id = a.attempt_id AND last_link.role = 'last'`;
 const FOLLOW_UP_ROW_SELECT = `
   SELECT f.follow_up_id AS followUpId, f.resource_id AS resourceId,
          f.queue_resource_id AS queueResourceId, f.run_id AS runId,
@@ -435,6 +464,22 @@ export class WorkflowRunStore {
             .filter(isSettingsScopeRow)
             .map((row) => this.settingsScopeRecord(row));
     }
+    readSettingsScopeRange(runId, range) {
+        const originRunId = this.logicalOriginRunId(runId);
+        return this.state.connection
+            .prepare(`SELECT s.scope_id AS scopeId, s.resource_id AS resourceId,
+                s.origin_run_id AS originRunId, s.active_run_id AS activeRunId,
+                s.mount_path AS mountPath, s.invocation,
+                s.current_hash AS currentHash, r.revision,
+                s.created_at AS createdAt, s.updated_at AS updatedAt
+         FROM workflow_settings s
+         JOIN resources r ON r.resource_id = s.resource_id
+         WHERE s.origin_run_id = ? OR s.active_run_id = ?
+         ORDER BY s.mount_path, s.invocation LIMIT ? OFFSET ?`)
+            .all(originRunId, runId, range.limit, range.start)
+            .filter(isSettingsScopeRow)
+            .map((row) => this.settingsScopeRecord(row));
+    }
     findSettingsScope(runId, mountPath, invocation) {
         const row = this.state.connection
             .prepare(`SELECT s.scope_id AS scopeId, s.resource_id AS resourceId,
@@ -666,6 +711,31 @@ export class WorkflowRunStore {
             followUps,
         };
     }
+    readFollowUpQueueRange(runId, range) {
+        const queue = this.followUpQueueRow(runId);
+        if (queue === undefined)
+            return null;
+        const followUps = this.state.connection
+            .prepare(`${FOLLOW_UP_ROW_SELECT} WHERE f.run_id = ? ORDER BY f.order_number LIMIT ? OFFSET ?`)
+            .all(runId, range.limit, range.start)
+            .filter(isFollowUpRow)
+            .map((row) => this.followUpRecord(row));
+        return {
+            runId,
+            ...(queue.originSessionId !== null ? { originSessionId: queue.originSessionId } : {}),
+            presentationState: assertPresentationState(queue.presentationState),
+            ...(queue.presentationEntryId !== null
+                ? { presentationEntryId: queue.presentationEntryId }
+                : {}),
+            ...(queue.presentationAssistantEntryId !== null
+                ? { presentationAssistantEntryId: queue.presentationAssistantEntryId }
+                : {}),
+            ...(queue.presentationReasonHash !== null
+                ? { presentationReason: this.readText(queue.presentationReasonHash) }
+                : {}),
+            followUps,
+        };
+    }
     listPendingPresentations(targetSessionId) {
         return this.state.connection
             .prepare(`SELECT run_id AS runId FROM workflow_follow_up_queues
@@ -1368,6 +1438,177 @@ export class WorkflowRunStore {
             followUpQueue: this.readFollowUpQueue(runId) ?? null,
         };
     }
+    readRunViewCounts(runId) {
+        const row = this.readRunRow(runId);
+        if (row === undefined)
+            return null;
+        const segment = this.segmentRow(segmentIdFor(runId));
+        const settingsOrigin = this.logicalOriginRunId(runId);
+        const scalar = (sql, ...params) => {
+            const count = this.state.connection.prepare(sql).get(...params);
+            return isCountRow(count) ? count.count : 0;
+        };
+        return {
+            steps: scalar("SELECT count(*) AS count FROM run_steps WHERE run_id = ?", runId),
+            trace: scalar("SELECT count(*) AS count FROM events WHERE resource_id = ?", row.resourceId),
+            sessionEntries: segment?.entryCount ?? 0,
+            sessionEvents: segment?.eventCount ?? 0,
+            settings: scalar(`SELECT count(*) AS count FROM workflow_settings
+         WHERE origin_run_id = ? OR active_run_id = ?`, settingsOrigin, runId),
+            followUps: scalar("SELECT count(*) AS count FROM workflow_follow_ups WHERE run_id = ?", runId),
+            updates: scalar(`SELECT count(*) AS count FROM (
+           SELECT 1 FROM workflow_updates u
+           JOIN node_attempts a ON a.attempt_id = u.attempt_id
+           WHERE a.run_id = ? GROUP BY u.update_type, u.update_key
+         )`, runId),
+        };
+    }
+    readRunView(runId, options) {
+        const row = this.readRunRow(runId);
+        if (row === undefined)
+            return null;
+        const snapshot = this.readDefinition(row.definitionHash);
+        const steps = this.readStepRange(runId, options.steps);
+        const visibleUpdates = this.readCurrentUpdates(runId, options.updates);
+        const state = this.buildRunState(row, snapshot, this.readLatestSteps(runId), steps, visibleUpdates);
+        const segment = this.segmentRow(segmentIdFor(runId));
+        const loadedSegment = segment === undefined
+            ? emptySegment()
+            : this.loadSegment(segment, state, {
+                entries: options.sessionEntries,
+                events: options.sessionEvents,
+            });
+        return {
+            runId,
+            state,
+            snapshot,
+            traceEvents: this.traceEvents(row, options.trace),
+            sessionBinding: loadedSegment.binding,
+            sessionEntries: loadedSegment.entries,
+            sessionEvents: loadedSegment.events,
+            sessionCapture: loadedSegment.capture,
+            sessionIntegrity: loadedSegment.integrity,
+            settingsScopes: this.readSettingsScopeRange(runId, options.settings),
+            followUpQueue: this.readFollowUpQueueRange(runId, options.followUps),
+            graphSteps: this.readLatestSteps(runId, options.graphCursor),
+            takenTransitions: this.readTakenTransitions(runId, options.graphCursor),
+        };
+    }
+    traceCursorForStep(runId, stepCursor, traceTotal) {
+        const step = this.state.connection
+            .prepare(`SELECT a.attempt_id AS attemptId, a.node_id AS nodeId
+         FROM run_steps s JOIN node_attempts a ON a.attempt_id = s.attempt_id
+         WHERE s.run_id = ? AND s.step_index = ?`)
+            .get(runId, stepCursor);
+        if (!isRecord(step) || typeof step.attemptId !== "string" || typeof step.nodeId !== "string") {
+            return Math.min(stepCursor, Math.max(0, traceTotal - 1));
+        }
+        const run = this.readRunRow(runId);
+        if (run === undefined)
+            return 0;
+        const exactAttempt = this.state.connection
+            .prepare(`SELECT e.resource_revision AS revision FROM events e
+         JOIN blobs b ON b.blob_hash = e.payload_hash
+         WHERE e.resource_id = ?
+           AND json_extract(CAST(b.content AS TEXT), '$.attemptId') = ?
+         ORDER BY e.resource_revision DESC LIMIT 1`)
+            .get(run.resourceId, step.attemptId);
+        const matched = isRevisionRow(exactAttempt)
+            ? exactAttempt
+            : this.state.connection
+                .prepare(`SELECT e.resource_revision AS revision FROM events e
+             JOIN blobs b ON b.blob_hash = e.payload_hash
+             WHERE e.resource_id = ?
+               AND json_extract(CAST(b.content AS TEXT), '$.nodeId') = ?
+             ORDER BY e.resource_revision DESC LIMIT 1`)
+                .get(run.resourceId, step.nodeId);
+        if (!isRevisionRow(matched))
+            return Math.min(stepCursor, Math.max(0, traceTotal - 1));
+        const index = this.state.connection
+            .prepare(`SELECT count(*) - 1 AS count FROM events
+         WHERE resource_id = ? AND resource_revision <= ?`)
+            .get(run.resourceId, matched.revision);
+        return isCountRow(index) ? Math.max(0, index.count) : 0;
+    }
+    persistViewContent(runId, content, mediaType) {
+        if (this.readRunRow(runId) === undefined)
+            throw new Error(`Workflow run not found: ${runId}`);
+        return this.state.transaction(() => {
+            const hash = createHash("sha256").update(content).digest();
+            this.state.connection
+                .prepare(`INSERT INTO run_view_content(
+             run_id, content_hash, media_type, byte_length, content, created_at
+           ) VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT(run_id, content_hash, media_type) DO NOTHING`)
+                .run(runId, hash, mediaType, content.byteLength, content, Date.now());
+            const stored = this.state.connection
+                .prepare(`SELECT media_type AS mediaType, byte_length AS byteLength, content
+           FROM run_view_content
+           WHERE run_id = ? AND content_hash = ? AND media_type = ?`)
+                .get(runId, hash, mediaType);
+            if (!isRecord(stored) ||
+                stored.mediaType !== mediaType ||
+                stored.byteLength !== content.byteLength ||
+                !Buffer.isBuffer(stored.content) ||
+                !stored.content.equals(content)) {
+                throw new Error("Run-scoped view content conflict");
+            }
+            return hash.toString("hex");
+        });
+    }
+    readContentBlob(runId, digest, mediaType) {
+        if (!/^[0-9a-f]{64}$/u.test(digest))
+            return undefined;
+        const stored = this.state.connection
+            .prepare(`SELECT media_type AS mediaType, byte_length AS byteLength, content
+         FROM run_view_content
+         WHERE run_id = ? AND content_hash = ? AND media_type = ?`)
+            .get(runId, Buffer.from(digest, "hex"), mediaType);
+        if (!isRecord(stored) ||
+            stored.mediaType !== mediaType ||
+            typeof stored.byteLength !== "number" ||
+            !Buffer.isBuffer(stored.content) ||
+            stored.content.byteLength !== stored.byteLength) {
+            return undefined;
+        }
+        return { mediaType, content: stored.content };
+    }
+    readDisplayState(runId) {
+        const row = this.readRunRow(runId);
+        if (row === undefined)
+            return null;
+        return {
+            status: row.status,
+            paused: row.paused === 1,
+            error: row.errorHash === null ? null : this.readText(row.errorHash),
+        };
+    }
+    readSessionReplayCheckpoint(runId, throughSequence) {
+        if (!Number.isSafeInteger(throughSequence) || throughSequence < 0) {
+            throw new Error("Session replay checkpoint sequence must be a non-negative integer");
+        }
+        if (throughSequence === 0)
+            return null;
+        const row = this.state.connection
+            .prepare(`SELECT event_seq AS eventSeq, state_hash AS stateHash
+         FROM viewer_session_checkpoints
+         WHERE run_id = ? AND event_seq <= ? ORDER BY event_seq DESC LIMIT 1`)
+            .get(runId, throughSequence);
+        let checkpoint = reduceSessionEvents([], [], 0);
+        if (isViewerSessionCheckpointRow(row)) {
+            const saved = this.state.readJson(row.stateHash);
+            if (!isTemporalSessionState(saved) || saved.throughSeq !== row.eventSeq) {
+                throw new Error(`Viewer session checkpoint is invalid for ${runId}`);
+            }
+            checkpoint = saved;
+        }
+        if (checkpoint.throughSeq < throughSequence) {
+            const events = this.sessionEventRecords(runId, checkpoint.throughSeq, throughSequence + 1);
+            checkpoint = reduceSessionEventsFromCheckpoint([], events, throughSequence, checkpoint);
+            checkpoint = boundedTemporalCheckpoint(checkpoint);
+        }
+        return parseJson(canonicalJson(checkpoint));
+    }
     listRuns(options = {}) {
         const rows = this.state.connection
             .prepare("SELECT run_id AS runId FROM runs ORDER BY created_at DESC, run_id DESC")
@@ -2192,13 +2433,16 @@ export class WorkflowRunStore {
     }
     readRunState(row, snapshot) {
         const steps = this.readSteps(row.runId);
+        return this.buildRunState(row, snapshot, steps, steps, this.readUpdates(row.runId).updates ?? []);
+    }
+    buildRunState(row, snapshot, projectionSteps, visibleSteps, visibleUpdates) {
         const sources = this.readRunSources(row.runId, snapshot);
         const carriedStepCount = this.carriedStepCount(row.runId);
         const activeAttempt = row.status === "running" ? this.readActiveAttempt(row.runId) : undefined;
         const humanDecision = this.readHumanDecisionReceipt(row.runId);
         const outputs = {};
         const results = {};
-        for (const step of steps) {
+        for (const step of projectionSteps) {
             const result = resultForStep(step);
             results[step.nodeId] = result;
             if (step.outcome === "ok")
@@ -2235,8 +2479,8 @@ export class WorkflowRunStore {
             input: this.state.readJson(row.inputHash),
             outputs,
             results,
-            steps,
-            ...this.readUpdates(row.runId),
+            steps: visibleSteps,
+            ...(visibleUpdates.length === 0 ? {} : { updates: visibleUpdates }),
             ...(activeAttempt === undefined ? {} : { currentNode: activeAttempt.nodeId }),
             ...(activeAttempt === undefined ? {} : { currentAttemptId: activeAttempt.attemptId }),
             ...(activeAttempt?.startedAt === null || activeAttempt === undefined
@@ -2253,8 +2497,8 @@ export class WorkflowRunStore {
             ...(row.statusDetail === null ? {} : { statusDetail: row.statusDetail }),
             ...(humanDecision === undefined ? {} : { humanDecision }),
             ...(row.paused === 0 ? {} : { paused: true }),
-            ...(row.status === "waiting" && steps.at(-1) !== undefined
-                ? { waitingOn: steps.at(-1)?.nodeId }
+            ...(row.status === "waiting" && projectionSteps.at(-1) !== undefined
+                ? { waitingOn: projectionSteps.at(-1)?.nodeId }
                 : {}),
             ...(row.finalOutputHash === null
                 ? {}
@@ -2264,39 +2508,50 @@ export class WorkflowRunStore {
     }
     readSteps(runId) {
         const rows = this.state.connection
-            .prepare(`SELECT s.step_index AS stepIndex, a.attempt_id AS attemptId, a.node_id AS nodeId,
-                a.node_type AS nodeType, a.status,
-                a.prompt_hash AS promptHash, a.output_hash AS outputHash,
-                s.output_override_hash AS outputOverrideHash,
-                a.receipt_hash AS receiptHash, a.error_hash AS errorHash,
-                prompt_entry.entry_hash AS promptEntryHash,
-                response_entry.entry_hash AS responseEntryHash,
-                first_link.entry_id AS firstEntryId, last_link.entry_id AS lastEntryId,
-                a.settings_scope_id AS settingsScopeId,
-                a.settings_change_number AS settingsChangeNumber,
-                a.settings_hash AS settingsHash,
-                a.started_at AS startedAt, a.finished_at AS finishedAt
-         FROM run_steps s
-         JOIN node_attempts a ON a.attempt_id = s.attempt_id
-         LEFT JOIN attempt_entries prompt_link
-           ON prompt_link.attempt_id = a.attempt_id AND prompt_link.role = 'prompt'
-         LEFT JOIN session_entries prompt_entry
-           ON prompt_entry.segment_id = prompt_link.segment_id
-          AND prompt_entry.entry_id = prompt_link.entry_id
-         LEFT JOIN attempt_entries response_link
-           ON response_link.attempt_id = a.attempt_id AND response_link.role = 'response'
-         LEFT JOIN session_entries response_entry
-           ON response_entry.segment_id = response_link.segment_id
-          AND response_entry.entry_id = response_link.entry_id
-         LEFT JOIN attempt_entries first_link
-           ON first_link.attempt_id = a.attempt_id AND first_link.role = 'first'
-         LEFT JOIN attempt_entries last_link
-           ON last_link.attempt_id = a.attempt_id AND last_link.role = 'last'
-         WHERE s.run_id = ? ORDER BY s.step_index`)
+            .prepare(`${STEP_ROW_SELECT} WHERE s.run_id = ? ORDER BY s.step_index`)
             .all(runId)
             .filter(isStepRow);
+        return this.mapStepRows(runId, rows, 0);
+    }
+    readStepRange(runId, range) {
+        const rows = this.state.connection
+            .prepare(`${STEP_ROW_SELECT} WHERE s.run_id = ? ORDER BY s.step_index LIMIT ? OFFSET ?`)
+            .all(runId, range.limit, range.start)
+            .filter(isStepRow);
+        return this.mapStepRows(runId, rows, range.start);
+    }
+    readLatestSteps(runId, through) {
+        const throughClause = through === undefined ? "" : " AND s2.step_index <= ?";
+        const params = through === undefined ? [runId, runId] : [runId, runId, through];
+        const rows = this.state.connection
+            .prepare(`${STEP_ROW_SELECT}
+         WHERE s.run_id = ? AND s.step_index IN (
+           SELECT max(s2.step_index) FROM run_steps s2
+           JOIN node_attempts a2 ON a2.attempt_id = s2.attempt_id
+           WHERE s2.run_id = ?${throughClause} GROUP BY a2.node_id
+         ) ORDER BY s.step_index`)
+            .all(...params)
+            .filter(isStepRow);
+        return this.mapStepRows(runId, rows);
+    }
+    readTakenTransitions(runId, through) {
+        const rows = this.state.connection
+            .prepare(`WITH ordered AS (
+           SELECT s.step_index, a.node_id AS nodeId,
+                  lag(a.node_id) OVER (ORDER BY s.step_index) AS previousNodeId
+           FROM run_steps s JOIN node_attempts a ON a.attempt_id = s.attempt_id
+           WHERE s.run_id = ? AND s.step_index <= ?
+         )
+         SELECT DISTINCT previousNodeId, nodeId FROM ordered
+         WHERE previousNodeId IS NOT NULL ORDER BY previousNodeId, nodeId`)
+            .all(runId, through);
+        return rows.flatMap((row) => isRecord(row) && typeof row.previousNodeId === "string" && typeof row.nodeId === "string"
+            ? [`${row.previousNodeId}->${row.nodeId}`]
+            : []);
+    }
+    mapStepRows(runId, rows, expectedStart) {
         return rows.map((row, index) => {
-            if (row.stepIndex !== index)
+            if (expectedStart !== undefined && row.stepIndex !== expectedStart + index)
                 throw new Error(`Workflow run step sequence has a gap: ${runId}`);
             const receipt = row.receiptHash === null ? {} : this.readJsonAs(row.receiptHash);
             const prompt = row.promptEntryHash !== null
@@ -2441,6 +2696,38 @@ export class WorkflowRunStore {
         }
         return updates === undefined ? {} : { updates };
     }
+    readCurrentUpdates(runId, range) {
+        const rangeClause = range === undefined ? "" : " LIMIT ? OFFSET ?";
+        const params = range === undefined ? [runId] : [runId, range.limit, range.start];
+        const rows = this.state.connection
+            .prepare(`WITH ranked AS (
+           SELECT u.update_id AS updateId, u.run_revision AS runRevision,
+                  a.node_id AS nodeId, u.attempt_id AS attemptId,
+                  u.update_type AS updateType, u.update_key AS updateKey,
+                  u.data_hash AS dataHash, u.recorded_at AS recordedAt,
+                  row_number() OVER (
+                    PARTITION BY u.update_type, u.update_key ORDER BY u.run_revision DESC
+                  ) AS rank
+           FROM workflow_updates u
+           JOIN node_attempts a ON a.attempt_id = u.attempt_id
+           WHERE a.run_id = ?
+         )
+         SELECT updateId, runRevision, nodeId, attemptId, updateType, updateKey, dataHash, recordedAt
+         FROM ranked WHERE rank = 1 ORDER BY runRevision${rangeClause}`)
+            .all(...params)
+            .filter(isUpdateRow);
+        return rows.map((row) => ({
+            updateId: row.updateId,
+            seq: row.runRevision,
+            at: new Date(row.recordedAt).toISOString(),
+            runId,
+            nodeId: row.nodeId,
+            attemptId: row.attemptId,
+            type: row.updateType,
+            key: row.updateKey,
+            data: this.readJsonAs(row.dataHash),
+        }));
+    }
     readJsonAs(hash) {
         return this.state.readJson(hash);
     }
@@ -2458,12 +2745,14 @@ export class WorkflowRunStore {
         }
         return value;
     }
-    traceEvents(run) {
+    traceEvents(run, range) {
+        const rangeClause = range === undefined ? "" : " LIMIT ? OFFSET ?";
+        const params = range === undefined ? [run.resourceId] : [run.resourceId, range.limit, range.start];
         const rows = this.state.connection
             .prepare(`SELECT resource_revision AS resourceRevision, event_type AS eventType,
                 payload_hash AS payloadHash, recorded_at AS recordedAt
-         FROM events WHERE resource_id = ? ORDER BY resource_revision`)
-            .all(run.resourceId);
+         FROM events WHERE resource_id = ? ORDER BY resource_revision${rangeClause}`)
+            .all(...params);
         const events = [];
         for (const row of rows) {
             /* istanbul ignore if -- exact schema and internal query shape */
@@ -2512,14 +2801,16 @@ export class WorkflowRunStore {
             throw new Error(`Session capture segment is missing: ${segmentId}`);
         return row;
     }
-    loadSegment(segment, runState) {
+    loadSegment(segment, runState, ranges) {
         const binding = segment.bindingHash === null
             ? null
             : this.state.readJson(segment.bindingHash);
         const entries = this.state.connection
             .prepare(`SELECT entry_seq AS entrySeq, entry_hash AS entryHash, recorded_at AS recordedAt
-         FROM session_entries WHERE segment_id = ? ORDER BY entry_seq`)
-            .all(segment.segmentId)
+         FROM session_entries WHERE segment_id = ? ORDER BY entry_seq${ranges === undefined ? "" : " LIMIT ? OFFSET ?"}`)
+            .all(...(ranges === undefined
+            ? [segment.segmentId]
+            : [segment.segmentId, ranges.entries.limit, ranges.entries.start]))
             .filter(isSessionEntryRow)
             .map((row) => ({
             seq: row.entrySeq,
@@ -2531,8 +2822,10 @@ export class WorkflowRunStore {
                 attempt_id AS attemptId, turn_id AS turnId, message_id AS messageId,
                 tool_call_id AS toolCallId, payload_hash AS payloadHash,
                 recorded_at AS recordedAt
-         FROM session_events WHERE segment_id = ? ORDER BY event_seq`)
-            .all(segment.segmentId)
+         FROM session_events WHERE segment_id = ? ORDER BY event_seq${ranges === undefined ? "" : " LIMIT ? OFFSET ?"}`)
+            .all(...(ranges === undefined
+            ? [segment.segmentId]
+            : [segment.segmentId, ranges.events.limit, ranges.events.start]))
             .filter(isSessionEventRow)
             .map((row) => ({
             seq: row.eventSeq,
@@ -2558,7 +2851,14 @@ export class WorkflowRunStore {
             ...(failure === undefined ? {} : { failure }),
         };
         const diagnostics = [];
-        if (entries.length !== segment.entryCount || events.length !== segment.eventCount) {
+        const durableCounts = ranges === undefined
+            ? { entries: entries.length, events: events.length }
+            : {
+                entries: sessionRecordCount(this.state, "session_entries", segment.segmentId),
+                events: sessionRecordCount(this.state, "session_events", segment.segmentId),
+            };
+        if (durableCounts.entries !== segment.entryCount ||
+            durableCounts.events !== segment.eventCount) {
             diagnostics.push("session capture counts do not match durable rows");
         }
         if (runState.status !== "running" && segment.status === "recording") {
@@ -2847,6 +3147,12 @@ function workflowSourceFromRow(row) {
         ? { kind: "builtin", id: row.sourceRef, revision: row.sourceRevision }
         : { kind: "file", path: row.sourceRef, hash: row.sourceRevision };
 }
+function sessionRecordCount(state, table, segmentId) {
+    const row = state.connection
+        .prepare(`SELECT count(*) AS count FROM ${table} WHERE segment_id = ?`)
+        .get(segmentId);
+    return isCountRow(row) ? row.count : 0;
+}
 function segmentIdFor(runId, attemptId) {
     return `segment-${createHash("sha256")
         .update(`${runId}\0${attemptId ?? ""}`)