maka-agent 0.2.0-dev.22.20260905 → 0.2.0-dev.24.20260907

package/node_modules/@maka/storage/dist/sqlite-session-metadata-store.js

@@ -36,15 +36,12 @@ import { messageContentDigest, messageContentsEqual, normalizeMessageContent, }
 import { AGENT_GRAPH_SUPERVISOR_WAKE_SCHEMA_VERSION, } from '@maka/core/agent-graph-supervisor-wake';
 import { assertSafeSessionId, decodePersistedSessionHeader, normalizeSessionHeader, SessionNotFoundError, } from './session-store.js';
 import { isDiscardableConversationCopy, isValidConversationCopyTransition, } from './session-conversation-copy.js';
-import { catalogPreviewForUserMessage } from './session-message-projection.js';
+import { projectSessionCatalogMessages } from './session-message-projection.js';
 import { configureSqliteSessionMetadataDatabase, migrateSqliteSessionMetadataDatabase, readSqliteSessionMetadataSchemaVersion, SQLITE_AGENT_GRAPH_CONTROL_TABLES, SQLITE_SESSION_MESSAGE_CHUNK_BYTES, SQLITE_SESSION_MESSAGE_CHUNK_MARKER, } from './sqlite-session-metadata-schema.js';
 import { buildSqliteSessionCatalogPageQuery, } from './sqlite-session-catalog-query.js';
 import { sqliteOrdinarySessionRolePredicate, sqliteRecoverableSessionRolePredicate, } from './sqlite-session-role-scope.js';
 export { SQLITE_SESSION_METADATA_SCHEMA_VERSION } from './sqlite-session-metadata-schema.js';
 const SQLITE_TRANSCRIPT_MESSAGE_LOOKUP_BATCH_SIZE = 256;
-const SQLITE_TURN_CONTRIBUTION_MAX_SOURCE_MESSAGES = 1_024;
-const SQLITE_TURN_CONTRIBUTION_MAX_SOURCE_BYTES = 4 * 1024 * 1024;
-const SQLITE_TURN_LANDMARK_LEGACY_NEIGHBOR_MESSAGES = 32;
 // Each target Session binds three parameters in the linkage query. Stay well
 // inside SQLite's bound-parameter limit.
 const WORKHUB_TARGET_LINKAGE_MAX_SESSIONS = 256;
@@ -351,6 +348,32 @@ export class SqliteSessionMetadataStore {
             return rows.map(decodeSandboxBoundaryRequestRow);
         });
     }
+    async hasExplicitSandboxBoundaryDenial(identities) {
+        this.assertOpen();
+        const query = this.db.prepare(`
+      SELECT
+        MAX(CASE WHEN outcome_reason = 'client_denied' THEN 1 ELSE 0 END) AS explicit,
+        MAX(CASE WHEN outcome_reason IN ('client_denied', 'turn_stopped', 'turn_terminal', 'host_restarted')
+          THEN 0 ELSE 1 END) AS ambiguous
+      FROM sandbox_boundary_log
+      WHERE session_id = ? AND run_id = ? AND turn_id = ?
+        AND entry_kind = 'expansion_request' AND status = 'denied'
+    `);
+        let denied = false;
+        for (const identity of identities) {
+            assertSafeSessionId(identity.sessionId);
+            assertSandboxBoundaryProvenanceId(identity.runId, 'run id');
+            assertSandboxBoundaryProvenanceId(identity.turnId, 'turn id');
+            const evidence = query.get(identity.sessionId, identity.runId, identity.turnId);
+            // Legacy NULL also meant internal cleanup. Do not invent a user decision
+            // or erase a possible denial; ambiguous provenance blocks this continuation.
+            if (evidence.ambiguous === 1) {
+                throw new Error('Historical sandbox denial cannot be attributed safely; start a new user Turn.');
+            }
+            denied ||= evidence.explicit === 1;
+        }
+        return denied;
+    }
     async settleSandboxBoundaryRequest(input) {
         this.assertOpen();
         assertSafeSessionId(input.sessionId);
@@ -378,7 +401,7 @@ export class SqliteSessionMetadataStore {
                     sessionId: input.sessionId,
                     requestId: input.requestId,
                     status: 'denied',
-                    ...(input.closureReason ? { outcomeReason: input.closureReason } : {}),
+                    outcomeReason: input.closureReason ?? 'client_denied',
                     settledAt,
                 });
                 return {
@@ -908,6 +931,10 @@ export class SqliteSessionMetadataStore {
                 .run(sessionId);
         });
     }
+    /**
+     * Session records in catalog order, each carrying the projection the Session
+     * list shows.
+     */
     async list(filter, roleScope) {
         this.assertOpen();
         const { where, parameters } = buildSessionListPredicate(filter ?? {});
@@ -923,17 +950,21 @@ export class SqliteSessionMetadataStore {
         }
         const rows = this.db
             .prepare(`
-        SELECT session_id, payload_json, metadata_version, committed_at
+        SELECT
+          metadata.session_id,
+          metadata.payload_json,
+          metadata.metadata_version,
+          metadata.committed_at,
+          COALESCE(projection.activity_at, 0) AS activity_at,
+          projection.last_message_preview
         FROM session_metadata metadata
+        LEFT JOIN session_catalog_projection projection
+          ON projection.session_id = metadata.session_id
         ${where.length > 0 ? `WHERE ${where.join(' AND ')}` : ''}
-        ORDER BY (
-          SELECT activity_at
-          FROM session_catalog_projection projection
-          WHERE projection.session_id = metadata.session_id
-        ) DESC, session_id ASC
+        ORDER BY activity_at DESC, metadata.session_id ASC
       `)
             .all(...parameters);
-        return rows.map(decodeRecord);
+        return rows.map(decodeCatalogRecord);
     }
     async listCatalogPage(filter, cursor, limit) {
         this.assertOpen();
@@ -1495,11 +1526,12 @@ export class SqliteSessionMetadataStore {
             return [];
         return this.readTransaction(() => {
             const list = targets.map(() => '?').join(', ');
-            // One Message moves between these lifecycle tables. Combine every target's
-            // identities once, then resolve activity from the canonical Coordination
-            // ledger in this same read transaction. That avoids rebuilding the target
-            // set once per page or once per candidate, without introducing another
-            // durable representation.
+            // One Message moves between these lifecycle tables — pending, admitted
+            // into a Turn, cancelled. Combine every target's identities once, then
+            // resolve activity from the canonical Coordination ledger in this same
+            // read transaction. That avoids rebuilding the target set once per page
+            // or once per candidate, without introducing another durable
+            // representation.
             const rows = this.db
                 .prepare(`
           WITH target_messages(session_id, message_id) AS (
@@ -1510,7 +1542,7 @@ export class SqliteSessionMetadataStore {
               AND length(message_id) = 52
             UNION
             SELECT session_id, message_id
-            FROM session_messages
+            FROM core_root_source_message_proofs
             WHERE session_id IN (${list})
               AND message_id GLOB 'whm_*'
               AND length(message_id) = 52
@@ -1613,19 +1645,6 @@ export class SqliteSessionMetadataStore {
             provenSteeringMessages.set(normalized.messageId, normalized);
         }
         this.transaction(() => {
-            const lastSequenceRow = this.db
-                .prepare('SELECT COALESCE(MAX(sequence), -1) AS last_sequence FROM session_messages WHERE session_id = ?')
-                .get(input.sessionId);
-            if (typeof lastSequenceRow.last_sequence !== 'number' ||
-                !Number.isSafeInteger(lastSequenceRow.last_sequence) ||
-                lastSequenceRow.last_sequence < -1) {
-                throw new SessionMetadataConflictError('Invalid Session message sequence');
-            }
-            const lastSequence = lastSequenceRow.last_sequence;
-            const historicalMissingMessages = new Map();
-            const ordinaryMissingMessages = new Map();
-            const historicalMessageIdSet = new Set();
-            const existingSequences = new Map();
             for (const messageId of unique) {
                 const fallback = provenRootMessages.get(messageId);
                 const steeringProof = provenSteeringMessages.get(messageId);
@@ -1662,69 +1681,14 @@ export class SqliteSessionMetadataStore {
                     !messageContentsEqual(admission.content, fallback.content)) {
                     throw new SessionMetadataConflictError('Message admission fallback content conflict');
                 }
-                if (admission === undefined && fallback !== undefined) {
-                    historicalMessageIdSet.add(messageId);
-                }
                 if (!admission &&
                     this.db
                         .prepare('SELECT 1 AS present FROM cancelled_message_admissions WHERE session_id = ? AND message_id = ?')
                         .get(input.sessionId, messageId)) {
                     throw new SessionMetadataConflictError('Message admission is already cancelled');
                 }
-                const rows = this.db
-                    .prepare(`
-            SELECT message.sequence, message.record_json, payload.record_bytes, payload.sha256
-            FROM session_messages AS message
-            LEFT JOIN session_message_payloads AS payload
-              ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-            WHERE message.session_id = ? AND message.message_id = ?
-          `)
-                    .all(input.sessionId, messageId);
-                if (rows.length > 1) {
-                    throw new SessionMetadataConflictError('Message admission transcript identity is ambiguous');
-                }
-                if (rows.length === 0) {
-                    const source = admission ?? fallback;
-                    if (!source)
-                        throw new SessionMetadataConflictError('Message admission does not exist');
-                    const message = decodeCanonicalMessage({
-                        type: 'user',
-                        id: messageId,
-                        turnId: input.turnId,
-                        ts: steeringProof?.eventTs ?? source.admittedAt,
-                        ...source.content,
-                        steeringEventId: steeringProof?.eventId ?? messageId,
-                    });
-                    const json = JSON.stringify(message);
-                    (historicalMessageIdSet.has(messageId)
-                        ? historicalMissingMessages
-                        : ordinaryMissingMessages).set(messageId, { message, json });
-                }
-                else {
-                    const sequence = rows[0]?.sequence;
-                    if (typeof sequence !== 'number' || !Number.isSafeInteger(sequence)) {
-                        throw new SessionMetadataConflictError('Invalid Message transcript sequence');
-                    }
-                    const row = rows[0];
-                    const recordJson = readStoredMessageRecordJson(this.db, input.sessionId, sequence, row);
-                    const message = decodeStoredMessage(JSON.parse(recordJson));
-                    const expectedSource = admission ?? fallback ?? steeringProof;
-                    if (message.type !== 'user' ||
-                        message.id !== messageId ||
-                        (expectedSource !== undefined &&
-                            !messageContentsEqual(normalizeMessageContent(message), expectedSource.content))) {
-                        throw new SessionMetadataConflictError('Message admission transcript identity conflict');
-                    }
-                    if (message.turnId !== input.turnId) {
-                        throw new SessionMetadataConflictError('Message admission transcript Turn conflict');
-                    }
-                    if (steeringProof !== undefined &&
-                        (message.ts !== steeringProof.eventTs ||
-                            message.turnId !== steeringProof.executionTurnId ||
-                            message.steeringEventId !== steeringProof.eventId)) {
-                        throw new SessionMetadataConflictError('Proven steering transcript identity conflict');
-                    }
-                    existingSequences.set(messageId, sequence);
+                if (admission === undefined && fallback === undefined && steeringProof === undefined) {
+                    throw new SessionMetadataConflictError('Message admission does not exist');
                 }
                 if (admission) {
                     const deleted = this.db
@@ -1735,94 +1699,21 @@ export class SqliteSessionMetadataStore {
                     }
                 }
             }
-            let tailLatest;
-            if (historicalMessageIdSet.size > 0) {
-                const transcript = this.readSessionMessageOrderingSync(input.sessionId);
-                let previousExistingSequence = -1;
-                const historicalMessageIds = unique.filter((messageId) => historicalMessageIdSet.has(messageId));
-                for (const messageId of historicalMessageIds) {
-                    const sequence = existingSequences.get(messageId);
-                    if (sequence === undefined)
-                        continue;
-                    const admittedAt = provenRootMessages.get(messageId).admittedAt;
-                    const blockingRow = transcript.find(({ sequence: candidateSequence, message }) => candidateSequence > previousExistingSequence &&
-                        candidateSequence < sequence &&
-                        !historicalMessageIdSet.has(message.id) &&
-                        (message.turnId === input.turnId || message.ts >= admittedAt));
-                    if (sequence <= previousExistingSequence || blockingRow !== undefined) {
-                        throw new SessionMetadataConflictError('Message admission transcript source order conflict');
-                    }
-                    previousExistingSequence = sequence;
-                }
-                const insertionGroups = [];
-                let pending = [];
-                let previousAnchor = -1;
-                for (const messageId of historicalMessageIds) {
-                    const missing = historicalMissingMessages.get(messageId);
-                    if (missing) {
-                        pending.push(missing);
-                        continue;
-                    }
-                    const boundary = existingSequences.get(messageId);
-                    if (pending.length > 0 && boundary !== undefined) {
-                        const admittedAt = Math.min(...pending.map(({ message }) => message.ts));
-                        const earlierBoundary = transcript.find(({ sequence, message }) => sequence > previousAnchor &&
-                            sequence < boundary &&
-                            !historicalMessageIdSet.has(message.id) &&
-                            (message.turnId === input.turnId || message.ts >= admittedAt));
-                        if (earlierBoundary) {
-                            throw new SessionMetadataConflictError('Message admission transcript source order conflict');
-                        }
-                        insertionGroups.push({ boundary, entries: pending });
-                        pending = [];
-                    }
-                    if (boundary !== undefined)
-                        previousAnchor = boundary;
-                }
-                if (pending.length > 0) {
-                    const admittedAt = Math.min(...pending.map(({ message }) => message.ts));
-                    const repairBoundary = transcript.find(({ sequence, message }) => sequence > previousAnchor &&
-                        !historicalMessageIdSet.has(message.id) &&
-                        (message.turnId === input.turnId || message.ts >= admittedAt))?.sequence;
-                    insertionGroups.push({
-                        boundary: repairBoundary ?? lastSequence + 1,
-                        entries: pending,
-                    });
-                }
-                for (const group of insertionGroups.reverse()) {
-                    this.shiftSessionMessageSuffixSync(input.sessionId, group.boundary, group.entries.length);
-                    this.insertSessionMessagesSync(input.sessionId, group.boundary, group.entries);
-                    if (group.boundary === lastSequence + 1) {
-                        tailLatest = group.entries.at(-1)?.message;
-                    }
-                }
-            }
-            if (ordinaryMissingMessages.size > 0) {
-                const ordinaryEntries = unique.flatMap((messageId) => {
-                    const entry = ordinaryMissingMessages.get(messageId);
-                    return entry ? [entry] : [];
-                });
-                const currentLastSequenceRow = this.db
-                    .prepare('SELECT COALESCE(MAX(sequence), -1) AS last_sequence FROM session_messages WHERE session_id = ?')
-                    .get(input.sessionId);
-                const currentLastSequence = currentLastSequenceRow.last_sequence;
-                if (typeof currentLastSequence !== 'number' ||
-                    !Number.isSafeInteger(currentLastSequence) ||
-                    currentLastSequence < -1) {
-                    throw new SessionMetadataConflictError('Invalid Session message sequence');
-                }
-                this.insertSessionMessagesSync(input.sessionId, currentLastSequence + 1, ordinaryEntries);
-                tailLatest = ordinaryEntries.at(-1)?.message;
-            }
-            if (tailLatest?.type === 'user') {
-                this.updateCatalogProjectionSync(input.sessionId, {
-                    lastMessageAt: tailLatest.ts,
-                    lastMessagePreview: catalogPreviewForUserMessage(tailLatest),
-                }, false, true);
-            }
-            else if (historicalMissingMessages.size > 0 || ordinaryMissingMessages.size > 0) {
-                this.updateCatalogProjectionSync(input.sessionId, {}, false, true);
-            }
+        });
+    }
+    /**
+     * The catalog facts a durable message carries, committed without a transcript
+     * row to carry them: the Session list's preview line, its time, and the
+     * connection lock a Session takes on its first user message.
+     */
+    async commitMessageCatalogProjection(sessionId, message) {
+        this.assertOpen();
+        assertSafeSessionId(sessionId);
+        this.transaction(() => {
+            const record = this.readRecordSync(sessionId);
+            if (!record)
+                throw new SessionNotFoundError(sessionId);
+            this.updateCatalogProjectionSync(sessionId, projectSessionCatalogMessages([message]), false, message.type === 'user' && !record.header.connectionLocked);
         });
     }
     async updateMessageAdmission(admission) {
@@ -1937,112 +1828,57 @@ export class SqliteSessionMetadataStore {
     async readMessages(sessionId) {
         return this.readMessagesWith(sessionId, decodeStoredMessage);
     }
-    async readTranscriptPage(sessionId, request) {
+    async readMessagesAfter(sessionId, request) {
         this.assertOpen();
         assertSafeSessionId(sessionId);
-        assertTranscriptPageRequest(request);
+        if (!Number.isSafeInteger(request.maxMessages) || request.maxMessages < 1) {
+            throw new Error('Invalid Session message count limit');
+        }
+        if (!Number.isSafeInteger(request.maxStoredBytes) || request.maxStoredBytes < 1) {
+            throw new Error('Invalid Session message byte limit');
+        }
+        if (request.afterSequence !== undefined && request.beforeSequence !== undefined) {
+            throw new Error('Invalid Session message scan bounds');
+        }
+        const backward = request.beforeSequence !== undefined;
         return this.readTransaction(() => {
             if (!this.readRecordSync(sessionId))
                 throw new SessionNotFoundError(sessionId);
-            const highWaterRow = this.db
-                .prepare('SELECT MAX(sequence) AS high_water FROM session_messages WHERE session_id = ?')
-                .get(sessionId);
-            const actualHighWater = nullableStoredMessageSequence(highWaterRow.high_water, sessionId);
-            const throughSequence = request.throughSequence === undefined ? actualHighWater : request.throughSequence;
-            if (throughSequence === null) {
-                return {
-                    throughSequence: null,
-                    fragments: [],
-                    rawBytes: 0,
-                    next: null,
-                };
-            }
-            if (actualHighWater === null || throughSequence > actualHighWater) {
-                throw new Error(`Session transcript watermark is ahead of durable storage: ${sessionId}`);
-            }
-            const position = request.position ?? (request.direction === 'older' ? throughSequence : 0);
-            const comparison = request.direction === 'older' ? '<=' : '>=';
-            const order = request.direction === 'older' ? 'DESC' : 'ASC';
             const rows = this.db
                 .prepare(`
-          SELECT message.sequence,
-            coalesce(payload.record_bytes, length(CAST(message.record_json AS BLOB))) AS total_bytes,
-            payload.record_bytes IS NOT NULL AS chunked,
-            payload.sha256 AS payload_sha256
+          SELECT message.sequence, message.record_json, payload.record_bytes, payload.sha256
           FROM session_messages AS message
           LEFT JOIN session_message_payloads AS payload
             ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-          WHERE message.session_id = ?
-            AND message.sequence <= ?
-            AND message.sequence ${comparison} ?
-          ORDER BY message.sequence ${order}
+          WHERE message.session_id = ? AND message.sequence ${backward ? '<' : '>'} ?
+          ORDER BY message.sequence ${backward ? 'DESC' : 'ASC'}
           LIMIT ?
         `)
-                .all(sessionId, throughSequence, position, request.maxMessages + 1);
-            const slices = [];
-            let rawBytes = 0;
-            let next = null;
+                .all(sessionId, backward ? request.beforeSequence : (request.afterSequence ?? -1), request.maxMessages);
+            const records = [];
+            let storedBytes = 0;
             for (const row of rows) {
-                if (slices.length >= request.maxMessages || rawBytes >= request.maxBytes)
-                    break;
                 const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-                const totalBytes = requireTranscriptRecordByteLength(row.total_bytes, sessionId, sequence);
-                const chunked = row.chunked === 1;
-                const payloadDigest = chunked
-                    ? requireTranscriptPayloadDigest(row.payload_sha256, sessionId, sequence)
-                    : null;
-                const continued = sequence === position && request.byteOffset !== undefined;
-                const edge = continued
-                    ? request.byteOffset
-                    : request.direction === 'older'
-                        ? totalBytes
-                        : 0;
-                if ((request.direction === 'older' && (edge < 1 || edge > totalBytes)) ||
-                    (request.direction === 'newer' && (edge < 0 || edge >= totalBytes))) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-                }
-                const available = request.maxBytes - rawBytes;
-                const byteOffset = request.direction === 'older' ? Math.max(0, edge - available) : edge;
-                const byteLength = request.direction === 'older'
-                    ? edge - byteOffset
-                    : Math.min(totalBytes - edge, available);
-                const complete = request.direction === 'older' ? byteOffset === 0 : byteOffset + byteLength === totalBytes;
-                slices.push({
+                // A record too large for one row is stored in chunks, with only a
+                // marker inline; its size is the chunk total, not the marker's.
+                const recordBytes = typeof row.record_bytes === 'number' ? row.record_bytes : String(row.record_json).length;
+                // The first record of a page is always taken, so a single row larger
+                // than the budget still makes progress instead of stalling the scan.
+                if (records.length > 0 && storedBytes + recordBytes > request.maxStoredBytes)
+                    break;
+                storedBytes += recordBytes;
+                records.push({
                     sequence,
-                    byteOffset,
-                    totalBytes,
-                    byteLength,
-                    chunked,
-                    payloadDigest,
+                    message: decodeStoredMessageRecordRow(this.db, sessionId, row),
                 });
-                rawBytes += byteLength;
-                if (!complete) {
-                    next = {
-                        position: sequence,
-                        byteOffset: request.direction === 'older' ? byteOffset : byteOffset + byteLength,
-                    };
-                    break;
-                }
             }
-            if (next === null && slices.length > 0 && slices.length < rows.length) {
-                const sequence = slices.at(-1).sequence;
-                next = {
-                    position: sequence + (request.direction === 'older' ? -1 : 1),
-                    byteOffset: null,
-                };
-            }
-            const dataBySequence = readTranscriptSlices(this.db, sessionId, slices);
-            const fragments = slices.map(({ sequence, byteOffset, totalBytes, byteLength, payloadDigest }) => {
-                const data = dataBySequence.get(sequence);
-                if (!data || data.byteLength !== byteLength) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-                }
-                if (byteOffset === 0 && byteLength === totalBytes) {
-                    validateTranscriptRecord(data, sessionId, sequence);
-                }
-                return { sequence, byteOffset, totalBytes, payloadDigest, data };
-            });
-            return { throughSequence, fragments, rawBytes, next };
+            const highWater = this.db
+                .prepare('SELECT MAX(sequence) AS high_water FROM session_messages WHERE session_id = ?')
+                .get(sessionId);
+            return {
+                records,
+                highWaterSequence: nullableStoredMessageSequence(highWater.high_water, sessionId),
+            };
         });
     }
     async readTranscriptMessages(sessionId, request) {
@@ -2129,80 +1965,6 @@ export class SqliteSessionMetadataStore {
             return messages;
         });
     }
-    async readTranscriptRecords(sessionId, request) {
-        this.assertOpen();
-        assertSafeSessionId(sessionId);
-        assertTranscriptRecordScanRequest(request);
-        return this.readTransaction(() => {
-            if (!this.readRecordSync(sessionId))
-                throw new SessionNotFoundError(sessionId);
-            const highWaterRow = this.db
-                .prepare('SELECT MAX(sequence) AS high_water FROM session_messages WHERE session_id = ?')
-                .get(sessionId);
-            const actualHighWater = nullableStoredMessageSequence(highWaterRow.high_water, sessionId);
-            const throughSequence = request.throughSequence === undefined ? actualHighWater : request.throughSequence;
-            if (throughSequence === null) {
-                return { throughSequence: null, records: [], nextPosition: null };
-            }
-            if (actualHighWater === null || throughSequence > actualHighWater) {
-                throw new Error(`Session transcript watermark is ahead of durable storage: ${sessionId}`);
-            }
-            const position = request.position ?? (request.direction === 'older' ? throughSequence : 0);
-            const comparison = request.direction === 'older' ? '<=' : '>=';
-            const order = request.direction === 'older' ? 'DESC' : 'ASC';
-            const rows = this.db
-                .prepare(`
-          SELECT message.sequence,
-            coalesce(payload.record_bytes, length(CAST(message.record_json AS BLOB))) AS stored_bytes
-          FROM session_messages AS message
-          LEFT JOIN session_message_payloads AS payload
-            ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-          WHERE message.session_id = ?
-            AND message.sequence <= ?
-            AND message.sequence ${comparison} ?
-          ORDER BY message.sequence ${order}
-          LIMIT ?
-        `)
-                .all(sessionId, throughSequence, position, request.maxMessages + 1);
-            const selected = [];
-            let storedBytes = 0;
-            for (const row of rows) {
-                if (selected.length >= request.maxMessages)
-                    break;
-                const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-                const bytes = requireTranscriptRecordByteLength(row.stored_bytes, sessionId, sequence);
-                if (selected.length > 0 && storedBytes + bytes > request.maxStoredBytes)
-                    break;
-                selected.push(sequence);
-                storedBytes += bytes;
-            }
-            const decoded = new Map();
-            for (const row of readStoredMessageRows(this.db, sessionId, selected)) {
-                try {
-                    decoded.set(row.sequence, decodeStoredMessage(JSON.parse(row.recordJson)));
-                }
-                catch (error) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, row.sequence, {
-                        cause: error,
-                    });
-                }
-            }
-            const records = selected.map((sequence) => {
-                const message = decoded.get(sequence);
-                if (!message)
-                    throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-                return { sequence, message };
-            });
-            const last = selected.at(-1);
-            return {
-                throughSequence,
-                records,
-                nextPosition: last !== undefined && rows.length > selected.length
-                    ? last + (request.direction === 'older' ? -1 : 1)
-                    : null,
-            };
-        });
-    }
     async readTranscriptHighWater(sessionId) {
         this.assertOpen();
         assertSafeSessionId(sessionId);
@@ -2213,295 +1975,6 @@ export class SqliteSessionMetadataStore {
             .get(sessionId);
         return nullableStoredMessageSequence(row.high_water, sessionId);
     }
-    async readTurnContributions(sessionId, throughSequence, position, maxContributions) {
-        this.assertOpen();
-        assertSafeSessionId(sessionId);
-        if ((throughSequence !== null &&
-            (!Number.isSafeInteger(throughSequence) || throughSequence < 0)) ||
-            !Number.isSafeInteger(position) ||
-            position < 0 ||
-            !Number.isSafeInteger(maxContributions) ||
-            maxContributions < 1 ||
-            maxContributions > 128) {
-            throw new Error('Invalid Session turn contribution request');
-        }
-        return this.readTransaction(() => {
-            if (!this.readRecordSync(sessionId))
-                throw new SessionNotFoundError(sessionId);
-            const highWaterRow = this.db
-                .prepare('SELECT MAX(sequence) AS high_water FROM session_messages WHERE session_id = ?')
-                .get(sessionId);
-            const actualHighWater = nullableStoredMessageSequence(highWaterRow.high_water, sessionId);
-            const fixedThrough = throughSequence ?? actualHighWater;
-            if (fixedThrough === null) {
-                return { throughSequence: null, contributions: [], nextPosition: null };
-            }
-            if (actualHighWater === null || fixedThrough > actualHighWater) {
-                throw new Error(`Session turn watermark is ahead of durable storage: ${sessionId}`);
-            }
-            const contributions = new Map();
-            let nextPosition = position;
-            let sourceMessages = 0;
-            let sourceBytes = 0;
-            while (nextPosition <= fixedThrough) {
-                const rows = this.db
-                    .prepare(`
-            SELECT message.sequence, message.record_json, payload.record_bytes, payload.sha256
-            FROM session_messages AS message
-            LEFT JOIN session_message_payloads AS payload
-              ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-            WHERE message.session_id = ?
-              AND message.sequence >= ?
-              AND message.sequence <= ?
-            ORDER BY message.sequence ASC
-            LIMIT 128
-          `)
-                    .all(sessionId, nextPosition, fixedThrough);
-                if (rows.length === 0) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, nextPosition);
-                }
-                for (const row of rows) {
-                    const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-                    const recordBytes = storedMessageRecordBytes(row, sessionId, sequence);
-                    if (sourceMessages > 0 &&
-                        (sourceMessages >= SQLITE_TURN_CONTRIBUTION_MAX_SOURCE_MESSAGES ||
-                            sourceBytes + recordBytes > SQLITE_TURN_CONTRIBUTION_MAX_SOURCE_BYTES)) {
-                        return {
-                            throughSequence: fixedThrough,
-                            contributions: [...contributions.values()],
-                            nextPosition: sequence,
-                        };
-                    }
-                    const message = decodeStoredMessageRecordRow(this.db, sessionId, row);
-                    sourceMessages += 1;
-                    sourceBytes += recordBytes;
-                    if (!('turnId' in message) || typeof message.turnId !== 'string') {
-                        nextPosition = sequence + 1;
-                        continue;
-                    }
-                    const turnId = message.turnId;
-                    if (turnId && !contributions.has(turnId) && contributions.size >= maxContributions) {
-                        nextPosition = sequence;
-                        return {
-                            throughSequence: fixedThrough,
-                            contributions: [...contributions.values()],
-                            nextPosition,
-                        };
-                    }
-                    contributions.set(turnId, foldTurnContribution(contributions.get(turnId), turnId, sequence, message));
-                    nextPosition = sequence + 1;
-                }
-            }
-            return {
-                throughSequence: fixedThrough,
-                contributions: [...contributions.values()],
-                nextPosition: null,
-            };
-        });
-    }
-    async readTurnLandmarks(sessionId, maxLandmarks) {
-        this.assertOpen();
-        assertSafeSessionId(sessionId);
-        if (!Number.isSafeInteger(maxLandmarks) || maxLandmarks < 1 || maxLandmarks > 64) {
-            throw new Error('Invalid Session turn landmark limit');
-        }
-        return this.readTransaction(() => {
-            if (!this.readRecordSync(sessionId))
-                throw new SessionNotFoundError(sessionId);
-            const throughRow = this.db
-                .prepare(`
-          SELECT sequence AS through_sequence
-          FROM session_messages
-          WHERE session_id = ?
-          ORDER BY sequence DESC
-          LIMIT 1
-        `)
-                .get(sessionId);
-            const throughSequence = nullableStoredMessageSequence(throughRow?.through_sequence, sessionId);
-            if (throughSequence === null) {
-                return { throughSequence: null, landmarks: [] };
-            }
-            const promptRows = this.db
-                .prepare(`
-          SELECT admission.admitted_at, message.sequence
-          FROM core_root_turn_admissions AS admission
-          JOIN session_messages AS message
-            ON message.session_id = admission.session_id
-            AND message.message_id = json_extract(admission.record_json, '$.userMessageId')
-          LEFT JOIN session_message_payloads AS payload
-            ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-          WHERE admission.session_id = ? AND payload.sequence IS NULL
-          ORDER BY admission.admitted_at ASC, admission.turn_id ASC
-          LIMIT ?
-        `)
-                .all(sessionId, maxLandmarks + 1);
-            const selected = new Set();
-            if (promptRows.length <= maxLandmarks) {
-                for (const row of promptRows) {
-                    selected.add(requireStoredMessageSequence(row.sequence, sessionId));
-                }
-            }
-            const forward = this.db.prepare(`
-        SELECT admission.admitted_at, message.sequence
-        FROM core_root_turn_admissions AS admission
-        JOIN session_messages AS message
-          ON message.session_id = admission.session_id
-          AND message.message_id = json_extract(admission.record_json, '$.userMessageId')
-        LEFT JOIN session_message_payloads AS payload
-          ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-        WHERE admission.session_id = ? AND admission.admitted_at >= ? AND payload.sequence IS NULL
-        ORDER BY admission.admitted_at ASC, admission.turn_id ASC
-        LIMIT 1
-      `);
-            const backward = this.db.prepare(`
-        SELECT admission.admitted_at, message.sequence
-        FROM core_root_turn_admissions AS admission
-        JOIN session_messages AS message
-          ON message.session_id = admission.session_id
-          AND message.message_id = json_extract(admission.record_json, '$.userMessageId')
-        LEFT JOIN session_message_payloads AS payload
-          ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-        WHERE admission.session_id = ? AND admission.admitted_at < ? AND payload.sequence IS NULL
-        ORDER BY admission.admitted_at DESC, admission.turn_id DESC
-        LIMIT 1
-      `);
-            if (promptRows.length > maxLandmarks) {
-                const firstAdmittedAt = requireTurnLandmarkAdmittedAt(promptRows[0]?.admitted_at);
-                const lastRow = this.db
-                    .prepare(`
-            SELECT admitted_at
-            FROM core_root_turn_admissions
-            WHERE session_id = ?
-            ORDER BY admitted_at DESC, turn_id DESC
-            LIMIT 1
-          `)
-                    .get(sessionId);
-                const lastAdmittedAt = requireTurnLandmarkAdmittedAt(lastRow?.admitted_at);
-                for (let index = 0; index < maxLandmarks; index += 1) {
-                    const target = maxLandmarks === 1
-                        ? lastAdmittedAt
-                        : firstAdmittedAt +
-                            Math.floor(((lastAdmittedAt - firstAdmittedAt) * index) / (maxLandmarks - 1));
-                    const candidates = [
-                        ...forward.all(sessionId, target),
-                        ...backward.all(sessionId, target),
-                    ];
-                    let nearest;
-                    for (const candidate of candidates) {
-                        const admittedAt = requireTurnLandmarkAdmittedAt(candidate.admitted_at);
-                        if (nearest === undefined ||
-                            Math.abs(admittedAt - target) <
-                                Math.abs(requireTurnLandmarkAdmittedAt(nearest.admitted_at) - target)) {
-                            nearest = candidate;
-                        }
-                    }
-                    if (nearest)
-                        selected.add(requireStoredMessageSequence(nearest.sequence, sessionId));
-                }
-            }
-            const firstIndexedSequence = promptRows.length > 0
-                ? requireStoredMessageSequence(promptRows[0]?.sequence, sessionId)
-                : null;
-            const legacyThrough = firstIndexedSequence === null ? throughSequence : firstIndexedSequence - 1;
-            if (legacyThrough >= 0) {
-                const firstRow = this.db
-                    .prepare(`
-            SELECT sequence AS first_sequence
-            FROM session_messages
-            WHERE session_id = ?
-            ORDER BY sequence ASC
-            LIMIT 1
-          `)
-                    .get(sessionId);
-                const firstSequence = nullableStoredMessageSequence(firstRow?.first_sequence, sessionId);
-                if (firstSequence === null || firstSequence > legacyThrough) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, legacyThrough);
-                }
-                const forwardLegacy = this.db.prepare(`
-          SELECT message.sequence, message.message_type, payload.sequence AS payload_sequence
-          FROM session_messages AS message
-          LEFT JOIN session_message_payloads AS payload
-            ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-          WHERE message.session_id = ? AND message.sequence >= ? AND message.sequence <= ?
-          ORDER BY message.sequence ASC
-          LIMIT ${SQLITE_TURN_LANDMARK_LEGACY_NEIGHBOR_MESSAGES}
-        `);
-                const backwardLegacy = this.db.prepare(`
-          SELECT message.sequence, message.message_type, payload.sequence AS payload_sequence
-          FROM session_messages AS message
-          LEFT JOIN session_message_payloads AS payload
-            ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-          WHERE message.session_id = ? AND message.sequence < ? AND message.sequence >= ?
-          ORDER BY message.sequence DESC
-          LIMIT ${SQLITE_TURN_LANDMARK_LEGACY_NEIGHBOR_MESSAGES}
-        `);
-                const targetCount = Math.min(maxLandmarks, legacyThrough - firstSequence + 1);
-                for (let index = 0; index < targetCount; index += 1) {
-                    const target = targetCount === 1
-                        ? legacyThrough
-                        : firstSequence +
-                            Math.floor(((legacyThrough - firstSequence) * index) / (targetCount - 1));
-                    const candidates = [
-                        ...forwardLegacy.all(sessionId, target, legacyThrough),
-                        ...backwardLegacy.all(sessionId, target, firstSequence),
-                    ];
-                    let nearest;
-                    for (const candidate of candidates) {
-                        const sequence = requireStoredMessageSequence(candidate.sequence, sessionId);
-                        if (candidate.message_type !== 'user' || candidate.payload_sequence !== null)
-                            continue;
-                        if (nearest === undefined || Math.abs(sequence - target) < Math.abs(nearest - target)) {
-                            nearest = sequence;
-                        }
-                    }
-                    if (nearest !== undefined)
-                        selected.add(nearest);
-                }
-            }
-            const selectedSequences = [...selected].sort((left, right) => left - right);
-            const sampledSequences = selectedSequences.length <= maxLandmarks
-                ? selectedSequences
-                : Array.from({ length: maxLandmarks }, (_, index) => selectedSequences[maxLandmarks === 1
-                    ? selectedSequences.length - 1
-                    : Math.floor(((selectedSequences.length - 1) * index) / (maxLandmarks - 1))]);
-            const landmarks = readStoredMessageRows(this.db, sessionId, sampledSequences).flatMap(({ sequence, recordJson }) => {
-                let message;
-                try {
-                    message = decodeStoredMessage(JSON.parse(recordJson));
-                }
-                catch (error) {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, sequence, { cause: error });
-                }
-                if (message.type !== 'user') {
-                    throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-                }
-                const label = (message.displayText ?? message.text).trim();
-                return label ? [{ turnId: message.turnId, sequence, label }] : [];
-            });
-            return { throughSequence, landmarks };
-        });
-    }
-    async readMessagesForRecovery(sessionId) {
-        return this.readMessagesWith(sessionId, decodeStoredMessage);
-    }
-    async readPreviewMessages(sessionId, limit = 10) {
-        this.assertOpen();
-        assertSafeSessionId(sessionId);
-        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 128) {
-            throw new Error('Session message preview limit must be between 1 and 128');
-        }
-        if (!this.readRecordSync(sessionId))
-            throw new SessionNotFoundError(sessionId);
-        const sequences = this.db
-            .prepare(`
-          SELECT sequence FROM session_messages
-          WHERE session_id = ? ORDER BY sequence DESC LIMIT ?
-        `)
-            .all(sessionId, limit)
-            .map((row) => requireStoredMessageSequence(row.sequence, sessionId))
-            .reverse();
-        return readStoredMessageRows(this.db, sessionId, sequences, sequences.map(() => '?').join(', ')).map((row) => decodeStoredMessageRow({ sequence: row.sequence, record_json: row.recordJson }, sessionId));
-    }
     async beginCatalogProjectionWrite() {
         this.assertOpen();
         this.transaction(() => {
@@ -4022,64 +3495,6 @@ export class SqliteSessionMetadataStore {
             .get(sessionId, messageId);
         return row ? decodeStoredMessageRecordRow(this.db, sessionId, row) : undefined;
     }
-    readSessionMessageOrderingSync(sessionId) {
-        const rows = this.db
-            .prepare(`
-        SELECT message.sequence, message.record_json, payload.record_bytes, payload.sha256
-        FROM session_messages AS message
-        LEFT JOIN session_message_payloads AS payload
-          ON payload.session_id = message.session_id AND payload.sequence = message.sequence
-        WHERE message.session_id = ?
-        ORDER BY message.sequence
-      `)
-            .all(sessionId);
-        return rows.map((row) => {
-            const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-            const recordJson = readStoredMessageRecordJson(this.db, sessionId, sequence, row);
-            return {
-                sequence,
-                message: decodeStoredMessage(JSON.parse(recordJson)),
-            };
-        });
-    }
-    shiftSessionMessageSuffixSync(sessionId, firstSequence, amount) {
-        if (!Number.isSafeInteger(firstSequence) || firstSequence < 0) {
-            throw new SessionMetadataConflictError('Invalid transcript insertion sequence');
-        }
-        if (!Number.isSafeInteger(amount) || amount < 1) {
-            throw new SessionMetadataConflictError('Invalid transcript insertion size');
-        }
-        const sequences = this.db
-            .prepare(`
-          SELECT sequence
-          FROM session_messages
-          WHERE session_id = ? AND sequence >= ?
-          ORDER BY sequence DESC
-        `)
-            .all(sessionId, firstSequence).map((row) => requireStoredMessageSequence(row.sequence, sessionId));
-        const highest = sequences[0];
-        if (highest !== undefined && highest > Number.MAX_SAFE_INTEGER - amount) {
-            throw new SessionMetadataConflictError('Session message sequence overflow');
-        }
-        if (sequences.length === 0)
-            return;
-        this.db.exec('PRAGMA defer_foreign_keys = ON');
-        const moveChunks = this.db.prepare('UPDATE session_message_chunks SET sequence = ? WHERE session_id = ? AND sequence = ?');
-        const movePayload = this.db.prepare('UPDATE session_message_payloads SET sequence = ? WHERE session_id = ? AND sequence = ?');
-        const moveMessage = this.db.prepare('UPDATE session_messages SET sequence = ? WHERE session_id = ? AND sequence = ?');
-        for (const sequence of sequences) {
-            const shifted = sequence + amount;
-            moveChunks.run(shifted, sessionId, sequence);
-            const payload = movePayload.run(shifted, sessionId, sequence);
-            if (payload.changes !== 0 && payload.changes !== 1) {
-                throw new SessionMetadataConflictError('Message payload sequence is ambiguous');
-            }
-            const message = moveMessage.run(shifted, sessionId, sequence);
-            if (message.changes !== 1) {
-                throw new SessionMetadataConflictError('Message transcript sequence changed during repair');
-            }
-        }
-    }
     insertSessionMessagesSync(sessionId, firstSequence, entries) {
         if (!Number.isSafeInteger(firstSequence) ||
             firstSequence < 0 ||
@@ -4180,12 +3595,19 @@ export class SqliteSessionMetadataStore {
         if (!current)
             throw new SessionNotFoundError(sessionId);
         const lastMessageAt = maxTimestamp(current.header.lastMessageAt, projection.lastMessageAt);
+        // The preview refuses to move backwards for the same reason the timestamp
+        // does: a message older than the one on show is a repair of something the
+        // catalog already passed, and recovery replays exactly those.
+        const stale = !replacePreview &&
+            projection.lastMessageAt !== undefined &&
+            current.header.lastMessageAt !== undefined &&
+            projection.lastMessageAt < current.header.lastMessageAt;
         this.updateHeaderSync(sessionId, {
             ...(lockConnection ? { connectionLocked: true } : {}),
             ...(lastMessageAt === undefined ? {} : { lastMessageAt }),
         }, {
             skipNoop: true,
-            ...(replacePreview || projection.lastMessagePreview !== undefined
+            ...(!stale && (replacePreview || projection.lastMessagePreview !== undefined)
                 ? {
                     catalogPreview: {
                         kind: 'replace',
@@ -5105,22 +4527,6 @@ function decodeStoredMessageRow(row, sessionId) {
         });
     }
 }
-function requireTurnLandmarkAdmittedAt(value) {
-    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
-        throw new Error('Invalid root Turn admission timestamp');
-    }
-    return value;
-}
-function storedMessageRecordBytes(row, sessionId, sequence) {
-    if (row.record_bytes !== null) {
-        return requireTranscriptRecordByteLength(row.record_bytes, sessionId, sequence);
-    }
-    if (typeof row.record_json !== 'string' ||
-        row.record_json === SQLITE_SESSION_MESSAGE_CHUNK_MARKER) {
-        throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-    }
-    return Buffer.byteLength(row.record_json, 'utf8');
-}
 function decodeStoredMessageRecordRow(db, sessionId, row) {
     const sequence = requireStoredMessageSequence(row.sequence, sessionId);
     return decodeStoredMessageRow({
@@ -5183,31 +4589,6 @@ function sameWorkHubAssignmentRequest(existing, requested) {
         replacesDelegationId: requested.replacesDelegationId,
     });
 }
-function foldTurnContribution(current, turnId, sequence, message) {
-    const contribution = current ?? {
-        turnId,
-        firstSequence: sequence,
-        latestState: null,
-        userPromptPreview: null,
-        hasAssistantMessage: false,
-        hasAssistantOutput: false,
-        hasToolResult: false,
-        hasFailedToolResult: false,
-        hasAbortNote: false,
-    };
-    const userPrompt = message.type === 'user' ? (message.displayText ?? message.text).trim() : '';
-    return {
-        ...contribution,
-        latestState: message.type === 'turn_state' ? { sequence, message } : contribution.latestState,
-        userPromptPreview: contribution.userPromptPreview ?? (userPrompt || null),
-        hasAssistantMessage: contribution.hasAssistantMessage || message.type === 'assistant',
-        hasAssistantOutput: contribution.hasAssistantOutput ||
-            (message.type === 'assistant' && message.text.trim().length > 0),
-        hasToolResult: contribution.hasToolResult || message.type === 'tool_result',
-        hasFailedToolResult: contribution.hasFailedToolResult || (message.type === 'tool_result' && message.isError),
-        hasAbortNote: contribution.hasAbortNote || (message.type === 'system_note' && message.kind === 'abort'),
-    };
-}
 function readStoredMessageRows(db, sessionId, sequences, placeholders = sequences.map(() => '?').join(', ')) {
     if (sequences.length === 0)
         return [];
@@ -5274,173 +4655,9 @@ function nullableStoredMessageSequence(value, sessionId) {
         return null;
     return requireStoredMessageSequence(value, sessionId);
 }
-function requireTranscriptPayloadDigest(value, sessionId, sequence) {
-    if (typeof value !== 'string' || !/^[0-9a-f]{64}$/.test(value)) {
-        throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-    }
-    return `sha256:${value}`;
-}
 function requireTranscriptRecordByteLength(value, sessionId, sequence) {
     if (!Number.isSafeInteger(value) || value < 1) {
         throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
     }
     return value;
 }
-function readTranscriptSlices(db, sessionId, slices) {
-    if (slices.length === 0)
-        return new Map();
-    const chunkedSlices = slices.filter((slice) => slice.chunked);
-    const values = chunkedSlices.map(() => '(?, ?, ?)').join(', ');
-    const parameters = chunkedSlices.flatMap((slice) => [
-        slice.sequence,
-        Math.floor(slice.byteOffset / SQLITE_SESSION_MESSAGE_CHUNK_BYTES),
-        Math.floor((slice.byteOffset + slice.byteLength - 1) / SQLITE_SESSION_MESSAGE_CHUNK_BYTES),
-    ]);
-    const rows = chunkedSlices.length === 0
-        ? []
-        : db
-            .prepare(`
-        WITH requested(sequence, first_chunk, last_chunk) AS (VALUES ${values})
-        SELECT requested.sequence, chunk.chunk_index, chunk.data, chunk.sha256
-        FROM requested
-        INNER JOIN session_message_chunks AS chunk
-          ON chunk.session_id = ?
-          AND chunk.sequence = requested.sequence
-          AND chunk.chunk_index BETWEEN requested.first_chunk AND requested.last_chunk
-        ORDER BY requested.sequence, chunk.chunk_index
-      `)
-            .all(...parameters, sessionId);
-    const rowsBySequence = new Map();
-    for (const row of rows) {
-        const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-        const grouped = rowsBySequence.get(sequence);
-        if (grouped)
-            grouped.push(row);
-        else
-            rowsBySequence.set(sequence, [row]);
-    }
-    const result = new Map();
-    for (const slice of slices) {
-        if (!slice.chunked)
-            continue;
-        const selected = rowsBySequence.get(slice.sequence) ?? [];
-        const firstChunk = Math.floor(slice.byteOffset / SQLITE_SESSION_MESSAGE_CHUNK_BYTES);
-        const lastChunk = Math.floor((slice.byteOffset + slice.byteLength - 1) / SQLITE_SESSION_MESSAGE_CHUNK_BYTES);
-        if (selected.length !== lastChunk - firstChunk + 1) {
-            throw new StoredSessionMessageIncompatibleError(sessionId, slice.sequence);
-        }
-        const chunks = [];
-        for (let index = 0; index < selected.length; index += 1) {
-            const row = selected[index];
-            if (row.chunk_index !== firstChunk + index ||
-                !(row.data instanceof Uint8Array) ||
-                typeof row.sha256 !== 'string') {
-                throw new StoredSessionMessageIncompatibleError(sessionId, slice.sequence);
-            }
-            const chunk = Buffer.from(row.data);
-            if (createHash('sha256').update(chunk).digest('hex') !== row.sha256) {
-                throw new StoredSessionMessageIncompatibleError(sessionId, slice.sequence);
-            }
-            chunks.push(chunk);
-        }
-        const joined = Buffer.concat(chunks);
-        const start = slice.byteOffset - firstChunk * SQLITE_SESSION_MESSAGE_CHUNK_BYTES;
-        const data = joined.subarray(start, start + slice.byteLength);
-        if (data.byteLength !== slice.byteLength) {
-            throw new StoredSessionMessageIncompatibleError(sessionId, slice.sequence);
-        }
-        result.set(slice.sequence, data);
-    }
-    const inlineSlices = slices.filter((slice) => !slice.chunked);
-    if (inlineSlices.length > 0) {
-        const inlineValues = inlineSlices.map(() => '(?, ?, ?)').join(', ');
-        const inlineParameters = inlineSlices.flatMap((slice) => [
-            slice.sequence,
-            slice.byteOffset + 1,
-            slice.byteLength,
-        ]);
-        const inlineRows = db
-            .prepare(`
-          WITH requested(sequence, byte_start, byte_length) AS (VALUES ${inlineValues})
-          SELECT requested.sequence,
-            substr(CAST(message.record_json AS BLOB), requested.byte_start, requested.byte_length)
-              AS data
-          FROM requested
-          INNER JOIN session_messages AS message
-            ON message.session_id = ? AND message.sequence = requested.sequence
-        `)
-            .all(...inlineParameters, sessionId);
-        for (const row of inlineRows) {
-            const sequence = requireStoredMessageSequence(row.sequence, sessionId);
-            if (!(row.data instanceof Uint8Array)) {
-                throw new StoredSessionMessageIncompatibleError(sessionId, sequence);
-            }
-            result.set(sequence, Buffer.from(row.data));
-        }
-    }
-    return result;
-}
-function validateTranscriptRecord(data, sessionId, sequence) {
-    try {
-        decodeStoredMessage(markPersisted(JSON.parse(typeof data === 'string' ? data : data.toString('utf8'))));
-    }
-    catch (error) {
-        throw new StoredSessionMessageIncompatibleError(sessionId, sequence, {
-            cause: error,
-        });
-    }
-}
-function assertTranscriptPageRequest(request) {
-    if (request.direction !== 'older' && request.direction !== 'newer') {
-        throw new Error('Invalid Session transcript page direction');
-    }
-    if (request.throughSequence !== undefined &&
-        request.throughSequence !== null &&
-        (!Number.isSafeInteger(request.throughSequence) || request.throughSequence < 0)) {
-        throw new Error('Invalid Session transcript watermark');
-    }
-    if (request.position !== undefined &&
-        (!Number.isSafeInteger(request.position) || request.position < 0)) {
-        throw new Error('Invalid Session transcript position');
-    }
-    if (request.byteOffset !== undefined &&
-        (request.position === undefined ||
-            !Number.isSafeInteger(request.byteOffset) ||
-            request.byteOffset < 0)) {
-        throw new Error('Invalid Session transcript byte offset');
-    }
-    if (!Number.isSafeInteger(request.maxBytes) ||
-        request.maxBytes < 1 ||
-        request.maxBytes > 1024 * 1024) {
-        throw new Error('Session transcript page byte limit must be between 1 and 1048576');
-    }
-    if (!Number.isSafeInteger(request.maxMessages) ||
-        request.maxMessages < 1 ||
-        request.maxMessages > 256) {
-        throw new Error('Session transcript page message limit must be between 1 and 256');
-    }
-}
-function assertTranscriptRecordScanRequest(request) {
-    if (request.direction !== 'older' && request.direction !== 'newer') {
-        throw new Error('Invalid Session transcript record direction');
-    }
-    if (request.throughSequence !== undefined &&
-        request.throughSequence !== null &&
-        (!Number.isSafeInteger(request.throughSequence) || request.throughSequence < 0)) {
-        throw new Error('Invalid Session transcript watermark');
-    }
-    if (request.position !== undefined &&
-        (!Number.isSafeInteger(request.position) || request.position < 0)) {
-        throw new Error('Invalid Session transcript position');
-    }
-    if (!Number.isSafeInteger(request.maxStoredBytes) ||
-        request.maxStoredBytes < 1 ||
-        request.maxStoredBytes > 16 * 1024 * 1024) {
-        throw new Error('Invalid Session transcript record byte limit');
-    }
-    if (!Number.isSafeInteger(request.maxMessages) ||
-        request.maxMessages < 1 ||
-        request.maxMessages > 256) {
-        throw new Error('Invalid Session transcript record count limit');
-    }
-}