maka-agent 0.2.0-dev.23.20260906 → 0.2.0-dev.25.20260908

package/node_modules/@maka/runtime-host/dist/server/session-transcript-reader.js

@@ -16,27 +16,104 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { affectsRuntimeEventStoredMessageProjection, isHardRuntimeEventReadModelDiagnostic, projectRuntimeEventsToStoredMessages, } from '@maka/runtime/runtime-event-read-model';
+import { readRunInvocation } from '@maka/core/runtime-event-store';
+import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
+import { readLogicalRuntimeExecution } from '@maka/core/runtime-logical-execution';
+import { WORKHUB_COORDINATION_SESSION_ID } from '@maka/core/session';
+import { activePresentationRuntimeEvents, affectsRuntimeEventStoredMessageProjection, isHardRuntimeEventReadModelDiagnostic, projectRuntimeEventsToStoredMessages, projectRuntimeEventUserMessage, } from '@maka/runtime/runtime-event-read-model';
+import { foldTurnContribution } from '@maka/storage/session-message-projection';
 import { SESSION_TRANSCRIPT_OVERLAY_MAX_MESSAGES } from '../protocol/index.js';
 const PERMISSION_OUTCOME_READ_CONCURRENCY = 8;
+/** One event can emit content, a permission, usage, and terminal/notice rows. */
+const EVENT_SEQUENCE_STRIDE = 8;
 export const ACTIVE_TRANSCRIPT_OVERLAY_MAX_MESSAGES = SESSION_TRANSCRIPT_OVERLAY_MAX_MESSAGES;
 export const ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES = 16 * 1024 * 1024;
 const ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS = ACTIVE_TRANSCRIPT_OVERLAY_MAX_MESSAGES * 2;
 const ACTIVE_TRANSCRIPT_SCAN_BATCH_MAX_BYTES = 256 * 1024;
+/**
+ * What one durable page may read of a Turn, matching the bound the live
+ * overlay already holds for a run. A Turn past it is refused rather than
+ * half-projected: a prefix of a Turn is not a smaller transcript of it.
+ */
+const DURABLE_TRANSCRIPT_TURN_MAX_EVENTS = ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS;
+const DURABLE_TRANSCRIPT_TURN_MAX_BYTES = ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES;
+/** Turns per storage round trip: one, so a page loads no Turn it cannot use. */
+const TRANSCRIPT_TURN_SCAN_LIMIT = 1;
+/**
+ * How far back the live-to-durable handoff looks for a message id. The ids come
+ * from assistant streams the subscriber is still watching, so they are in the
+ * newest Turn or the one it continued from; an id that is in neither is treated
+ * as absent rather than searched for down the Session.
+ */
+const TRANSCRIPT_LOOKUP_MAX_TURNS = 2;
+/** One storage round trip of Coordination rows, sized like one ledger Turn. */
+const COORDINATION_TRANSCRIPT_SCAN_LIMIT = 64;
+const COORDINATION_TRANSCRIPT_SCAN_MAX_BYTES = DURABLE_TRANSCRIPT_TURN_MAX_BYTES;
 export function createSessionTranscriptReader(input) {
+    const ledger = createDurableLedgerTranscriptReader(input);
+    const coordination = createCoordinationTranscriptReader(input.stores);
+    const isCoordination = (sessionId) => sessionId === WORKHUB_COORDINATION_SESSION_ID;
+    // Only a ledger-backed Session has a conversion; the Coordination Session's
+    // rows are the transcript, not something a run left behind.
+    const prepared = async (sessionId) => {
+        if (isCoordination(sessionId))
+            return coordination;
+        await input.ensureTranscriptLedger?.(sessionId);
+        return ledger;
+    };
     return {
-        readDurableHighWater: (sessionId) => input.stores.sessionStore.readTranscriptHighWaterSnapshot(sessionId),
-        readDurablePage: (sessionId, request) => input.stores.sessionStore.readTranscriptPageSnapshot(sessionId, request),
-        readDurableRecords: (sessionId, request) => input.stores.sessionStore.readTranscriptRecordsSnapshot(sessionId, request),
-        readDurableMessagesById: (sessionId, request) => input.stores.sessionStore.readTranscriptMessagesSnapshot(sessionId, request),
+        readDurableHighWater: async (sessionId) => (await prepared(sessionId)).readHighWater(sessionId),
+        readDurablePage: async (sessionId, request) => (await prepared(sessionId)).readPage(sessionId, request),
+        readDurableRecords: async (sessionId, request) => (await prepared(sessionId)).readRecords(sessionId, request),
+        readDurableMessagesById: async (sessionId, request) => (await prepared(sessionId)).readMessagesById(sessionId, request),
+        readDurableTurnContributions: async (sessionId, throughSequence, position, maxContributions) => (await prepared(sessionId)).readTurnContributions(sessionId, throughSequence, position, maxContributions),
+        readDurableTurnLandmarks: async (sessionId, maxLandmarks) => (await prepared(sessionId)).readTurnLandmarks(sessionId, maxLandmarks),
         readActiveOverlay: async (sessionId, rootTurn) => {
             if (!rootTurn || isTerminalTurn(rootTurn))
                 return [];
-            const invocations = await input.stores.runtimeEventStore.listSessionInvocations(sessionId);
-            const events = await readActiveProjectionEvents(input.stores, sessionId, rootTurn.runId);
+            const store = input.stores.runtimeEventStore;
+            const root = await readRunInvocation(store, sessionId, rootTurn.runId);
+            if (!root)
+                return [];
+            const budget = { events: 0, bytes: 0 };
+            const scanned = new Map();
+            const invocations = new Map([[root.runId, root]]);
+            const readEvents = async (runId) => {
+                const cached = scanned.get(runId);
+                if (cached)
+                    return cached;
+                const events = await readActiveRuntimeEvents(input.stores, sessionId, runId, budget);
+                scanned.set(runId, events);
+                return events;
+            };
+            let runIds = [root.runId];
+            if (root.terminalEvent && runtimeHandoffPause(root.terminalEvent)) {
+                const logical = await readLogicalRuntimeExecution({
+                    ...store,
+                    readRunInvocation: async (id, runId) => {
+                        const run = await readRunInvocation(store, id, runId);
+                        if (run)
+                            invocations.set(runId, run);
+                        return run;
+                    },
+                    // Authenticate only after the same bounded scan used for presentation.
+                    // Sealed prefixes cannot grow between this check and digest verification.
+                    readImmutableRuntimeEvents: async (_id, runId) => (await readEvents(runId)).filter((event) => !event.partial),
+                    readImmutableRuntimePrefix: async (prefix) => {
+                        await readEvents(prefix.runId);
+                        return store.readImmutableRuntimePrefix(prefix);
+                    },
+                }, { sessionId, turnId: rootTurn.turnId, runId: rootTurn.runId }, root);
+                if (!logical)
+                    return [];
+                runIds = logical.runIds;
+            }
+            const events = [];
+            for (const runId of runIds)
+                events.push(...(await readEvents(runId)).filter(affectsRuntimeEventStoredMessageProjection));
             const canonicalPermissionOutcomes = await readCanonicalPermissionOutcomes(events, input.canonicalPermissionOutcomes);
-            const projected = projectRuntimeEventsToStoredMessages(activePresentationEvents(events), {
-                invocations: invocations.filter((invocation) => invocation.runId === rootTurn.runId),
+            const projected = projectRuntimeEventsToStoredMessages(activePresentationRuntimeEvents(events), {
+                invocations: runIds.map((runId) => invocations.get(runId)),
                 canonicalPermissionOutcomes,
             });
             if (projected.diagnostics.some(isHardRuntimeEventReadModelDiagnostic)) {
@@ -47,6 +124,373 @@ export function createSessionTranscriptReader(input) {
         },
     };
 }
+/**
+ * Pages seek immutable Session event ordinals before decoding payloads. One
+ * Turn is projected at a time, so a page costs one Turn rather than the
+ * Session. The low sequence bits distinguish the few rows one event emits.
+ *
+ * What an event becomes is asked only of the read model. Storage selects Turns
+ * by ordinal and hands over their events; it never classifies one.
+ */
+function createDurableLedgerTranscriptReader(input) {
+    const store = input.stores.runtimeEventStore;
+    const highWater = async (sessionId) => {
+        const ordinal = await store.readTranscriptHighWater(sessionId);
+        return ordinal === null ? null : ordinal * EVENT_SEQUENCE_STRIDE + EVENT_SEQUENCE_STRIDE - 1;
+    };
+    /** One Turn's rows, each at the sequence its own event sits at. */
+    const projectTurn = async (turn) => {
+        const events = turn.events.map((entry) => entry.event);
+        const projected = projectRuntimeEventsToStoredMessages(events, {
+            invocations: [turn.invocation],
+            canonicalPermissionOutcomes: await readCanonicalPermissionOutcomes(events, input.canonicalPermissionOutcomes),
+        });
+        if (projected.diagnostics.some(isHardRuntimeEventReadModelDiagnostic)) {
+            throw new Error('Durable RuntimeEvent transcript projection is incomplete');
+        }
+        const ordinals = new Map(turn.events.map((entry) => [entry.event.id, entry.ordinal]));
+        const emitted = new Map();
+        return projected.messages.map((message, index) => {
+            const ordinal = ordinals.get(projected.sourceEventIds[index]);
+            if (ordinal === undefined) {
+                throw new Error('Durable transcript message has no source RuntimeEvent');
+            }
+            const offset = emitted.get(ordinal) ?? 0;
+            if (offset >= EVENT_SEQUENCE_STRIDE) {
+                throw new Error('RuntimeEvent exceeds its transcript sequence stride');
+            }
+            emitted.set(ordinal, offset + 1);
+            return { sequence: ordinal * EVENT_SEQUENCE_STRIDE + offset, message };
+        });
+    };
+    const readTurns = async (sessionId, request) => store.readTranscriptInvocations(sessionId, {
+        ...request,
+        limit: TRANSCRIPT_TURN_SCAN_LIMIT,
+        maxEvents: DURABLE_TRANSCRIPT_TURN_MAX_EVENTS,
+        maxBytes: DURABLE_TRANSCRIPT_TURN_MAX_BYTES,
+    });
+    const scan = async function* (sessionId, request) {
+        const throughSequence = request.throughSequence === undefined ? await highWater(sessionId) : request.throughSequence;
+        if (throughSequence === null)
+            return;
+        const position = request.position ?? (request.direction === 'older' ? throughSequence : 0);
+        const throughOrdinal = ordinalOf(throughSequence);
+        const older = request.direction === 'older';
+        const readTurnAt = async (at) => at < 0 || at > throughOrdinal
+            ? undefined
+            : (await readTurns(sessionId, {
+                direction: request.direction,
+                throughOrdinal,
+                position: at,
+            }))[0];
+        let ordinal = ordinalOf(position);
+        let walked = 0;
+        let carried;
+        while (ordinal >= 0 && ordinal <= throughOrdinal) {
+            const first = carried ?? (await readTurnAt(ordinal));
+            carried = undefined;
+            if (first === undefined)
+                return;
+            if (request.maxTurns !== undefined && walked >= request.maxTurns)
+                return;
+            // A page resumes from one record's sequence and drops everything the other
+            // side of it, so what this yields has to be monotone in sequence. Turns
+            // whose ordinal ranges overlap — a nested run inside its parent — are
+            // therefore drained together instead of one after the other.
+            const cluster = [first];
+            let low = first.firstOrdinal;
+            let high = first.lastOrdinal;
+            for (;;) {
+                const next = await readTurnAt(older ? low - 1 : high + 1);
+                if (next === undefined)
+                    break;
+                if (older ? next.lastOrdinal < low : next.firstOrdinal > high) {
+                    carried = next;
+                    break;
+                }
+                cluster.push(next);
+                low = Math.min(low, next.firstOrdinal);
+                high = Math.max(high, next.lastOrdinal);
+            }
+            walked += cluster.length;
+            const records = (await Promise.all(cluster.map(projectTurn)))
+                .flat()
+                .filter(({ sequence }) => sequence <= throughSequence && (older ? sequence <= position : sequence >= position))
+                .sort((a, b) => (older ? b.sequence - a.sequence : a.sequence - b.sequence));
+            yield* records;
+            ordinal = older ? low - 1 : high + 1;
+        }
+    };
+    return {
+        readHighWater: highWater,
+        ...pagedTranscriptReads({ readHighWater: highWater, scan }),
+        /** One row per Turn, folded from the Turn's own projected messages. */
+        async readTurnContributions(sessionId, throughSequence, position, maxContributions) {
+            const watermark = throughSequence ?? (await highWater(sessionId));
+            if (watermark === null) {
+                return { throughSequence: null, contributions: [], nextPosition: null };
+            }
+            const turns = await store.readTranscriptInvocations(sessionId, {
+                direction: 'newer',
+                throughOrdinal: ordinalOf(watermark),
+                position: ordinalOf(position),
+                limit: maxContributions + 1,
+                maxEvents: DURABLE_TRANSCRIPT_TURN_MAX_EVENTS,
+                maxBytes: DURABLE_TRANSCRIPT_TURN_MAX_BYTES,
+            });
+            const contributions = [];
+            for (const turn of turns.slice(0, maxContributions)) {
+                // Folded from the Turn's own rows, so `firstSequence` lands on its first
+                // row rather than on the opening fact, which has no row at all.
+                let contribution;
+                for (const { sequence, message } of await projectTurn(turn)) {
+                    if (sequence < position || sequence > watermark)
+                        continue;
+                    contribution = foldTurnContribution(contribution, turn.invocation.turnId, sequence, message);
+                }
+                if (contribution)
+                    contributions.push(contribution);
+            }
+            const next = turns[maxContributions];
+            return {
+                throughSequence: watermark,
+                contributions,
+                nextPosition: next ? next.firstOrdinal * EVENT_SEQUENCE_STRIDE : null,
+            };
+        },
+        /** Evenly spaced Turn starts, selected in SQL before loading their prompts. */
+        async readTurnLandmarks(sessionId, maxLandmarks) {
+            const throughSequence = await highWater(sessionId);
+            if (throughSequence === null)
+                return { throughSequence: null, landmarks: [] };
+            const turns = await store.readTranscriptLandmarks(sessionId, ordinalOf(throughSequence), maxLandmarks);
+            const landmarks = [];
+            for (const turn of turns) {
+                if (!turn.prompt)
+                    continue;
+                const message = projectRuntimeEventUserMessage(turn.prompt.event, turn.prompt.event.id);
+                const label = (message?.displayText ?? message?.text ?? '').trim();
+                if (!label)
+                    continue;
+                landmarks.push({
+                    turnId: turn.invocation.turnId,
+                    sequence: turn.prompt.ordinal * EVENT_SEQUENCE_STRIDE,
+                    label,
+                });
+            }
+            return { throughSequence, landmarks };
+        },
+    };
+}
+/**
+ * The reads that are the same whatever produces the records: a byte-bounded
+ * page, a record scan, and a lookup by message id. Each walks one source's
+ * ordered records and never asks where they came from.
+ */
+function pagedTranscriptReads(source) {
+    return {
+        async readPage(sessionId, request) {
+            const throughSequence = request.throughSequence === undefined
+                ? await source.readHighWater(sessionId)
+                : request.throughSequence;
+            if (throughSequence === null) {
+                return { throughSequence: null, fragments: [], rawBytes: 0, next: null };
+            }
+            const fragments = [];
+            let rawBytes = 0;
+            let next = null;
+            let truncated = false;
+            for await (const record of source.scan(sessionId, { ...request, throughSequence })) {
+                if (fragments.length >= request.maxMessages || rawBytes >= request.maxBytes) {
+                    truncated = true;
+                    next = { position: record.sequence, byteOffset: null };
+                    break;
+                }
+                const data = Buffer.from(JSON.stringify(record.message), 'utf8');
+                // A message larger than the remaining budget is served in byte slices,
+                // from the edge the traversal is moving away from, so the next page
+                // resumes inside the same record instead of skipping it.
+                const continued = record.sequence === request.position && request.byteOffset !== undefined;
+                const edge = continued
+                    ? request.byteOffset
+                    : request.direction === 'older'
+                        ? data.byteLength
+                        : 0;
+                const available = request.maxBytes - rawBytes;
+                const byteOffset = request.direction === 'older' ? Math.max(0, edge - available) : edge;
+                const end = request.direction === 'older' ? edge : Math.min(data.byteLength, edge + available);
+                fragments.push({
+                    sequence: record.sequence,
+                    byteOffset,
+                    totalBytes: data.byteLength,
+                    payloadDigest: null,
+                    data: data.subarray(byteOffset, end),
+                });
+                rawBytes += end - byteOffset;
+                const complete = request.direction === 'older' ? byteOffset === 0 : end === data.byteLength;
+                if (!complete) {
+                    truncated = true;
+                    next = {
+                        position: record.sequence,
+                        byteOffset: request.direction === 'older' ? byteOffset : end,
+                    };
+                    break;
+                }
+            }
+            if (!truncated)
+                next = null;
+            return { throughSequence, fragments, rawBytes, next };
+        },
+        async readRecords(sessionId, request) {
+            const throughSequence = request.throughSequence === undefined
+                ? await source.readHighWater(sessionId)
+                : request.throughSequence;
+            if (throughSequence === null) {
+                return { throughSequence: null, records: [], nextPosition: null };
+            }
+            const records = [];
+            let storedBytes = 0;
+            let nextPosition = null;
+            for await (const record of source.scan(sessionId, { ...request, throughSequence })) {
+                if (records.length >= request.maxMessages || storedBytes >= request.maxStoredBytes) {
+                    nextPosition = record.sequence;
+                    break;
+                }
+                records.push(record);
+                storedBytes += Buffer.byteLength(JSON.stringify(record.message), 'utf8');
+            }
+            return { throughSequence, records, nextPosition };
+        },
+        /**
+         * The durable rows behind a set of message ids.
+         *
+         * The ids come from the assistant streams a subscriber is still watching,
+         * so they belong to the Session's newest Turns. The scan walks back from
+         * the watermark a Turn at a time and stops as soon as every id is found,
+         * rather than keeping an index from message id to event. An id that is not
+         * there stops the walk after the newest Turns instead of reading the
+         * Session: the handoff shows what the tail holds, not everything it could.
+         */
+        async readMessagesById(sessionId, request) {
+            if (request.throughSequence === null || request.messageIds.length === 0)
+                return [];
+            const wanted = new Set(request.messageIds);
+            const found = [];
+            let bytes = 0;
+            for await (const record of source.scan(sessionId, {
+                direction: 'older',
+                throughSequence: request.throughSequence,
+                maxTurns: TRANSCRIPT_LOOKUP_MAX_TURNS,
+            })) {
+                if (!wanted.delete(record.message.id))
+                    continue;
+                bytes += Buffer.byteLength(JSON.stringify(record.message), 'utf8');
+                if (found.length >= request.maxMessages || bytes > request.maxBytes)
+                    break;
+                found.push(record);
+                if (wanted.size === 0)
+                    break;
+            }
+            return found.sort((a, b) => a.sequence - b.sequence).map((record) => record.message);
+        },
+    };
+}
+/**
+ * The WorkHub Coordination Session's transcript, read from the rows the WorkHub
+ * writes.
+ *
+ * Every other Session's transcript is what its runs did, so the ledger holds
+ * all of it. The Coordination Session's is not: a delegation, a stop and a
+ * routing summary are appended under a Turn id that no root Turn admission ever
+ * minted, so there is no invocation for the ledger to hang them on and no
+ * conversion that could lift them. `workhub.coordination.answer` is the one
+ * path that would admit a real Turn and nothing in the renderer calls it.
+ *
+ * Delete this source once the WorkHub admits a Coordination Turn for every
+ * action, which its own ADR already requires (#3492,
+ * `docs/architecture/workhub-coordination-session-adr.md`): the Session then
+ * reads like any other and this reader has nothing left to do.
+ */
+function createCoordinationTranscriptReader(stores) {
+    const store = stores.sessionStore;
+    const highWater = (sessionId) => store.readTranscriptHighWaterSnapshot(sessionId);
+    const scan = async function* (sessionId, request) {
+        const throughSequence = request.throughSequence === undefined ? await highWater(sessionId) : request.throughSequence;
+        if (throughSequence === null)
+            return;
+        const older = request.direction === 'older';
+        const position = request.position ?? (older ? throughSequence : 0);
+        let cursor = older ? Math.min(position, throughSequence) + 1 : position - 1;
+        for (;;) {
+            const page = await store.readMessagesAfter(sessionId, {
+                ...(older ? { beforeSequence: cursor } : { afterSequence: cursor }),
+                maxMessages: COORDINATION_TRANSCRIPT_SCAN_LIMIT,
+                maxStoredBytes: COORDINATION_TRANSCRIPT_SCAN_MAX_BYTES,
+            });
+            if (page.records.length === 0)
+                return;
+            for (const record of page.records) {
+                if (!older && record.sequence > throughSequence)
+                    return;
+                yield record;
+            }
+            cursor = page.records.at(-1).sequence;
+        }
+    };
+    const source = { readHighWater: highWater, scan };
+    return {
+        readHighWater: highWater,
+        ...pagedTranscriptReads(source),
+        /** Folded from the rows themselves; these Turns have nothing else. */
+        async readTurnContributions(sessionId, throughSequence, position, maxContributions) {
+            const watermark = throughSequence ?? (await highWater(sessionId));
+            if (watermark === null) {
+                return { throughSequence: null, contributions: [], nextPosition: null };
+            }
+            const byTurn = new Map();
+            let nextPosition = null;
+            for await (const { sequence, message } of scan(sessionId, {
+                direction: 'newer',
+                throughSequence: watermark,
+                position,
+            })) {
+                const turnId = message.turnId;
+                if (turnId === undefined)
+                    continue;
+                if (!byTurn.has(turnId) && byTurn.size === maxContributions) {
+                    nextPosition = sequence;
+                    break;
+                }
+                byTurn.set(turnId, foldTurnContribution(byTurn.get(turnId), turnId, sequence, message));
+            }
+            return { throughSequence: watermark, contributions: [...byTurn.values()], nextPosition };
+        },
+        /** Every prompt, in order: this transcript has no index to sample from. */
+        async readTurnLandmarks(sessionId, maxLandmarks) {
+            const throughSequence = await highWater(sessionId);
+            if (throughSequence === null)
+                return { throughSequence: null, landmarks: [] };
+            const landmarks = [];
+            for await (const { sequence, message } of scan(sessionId, {
+                direction: 'newer',
+                throughSequence,
+            })) {
+                if (message.type !== 'user' || message.turnId === undefined)
+                    continue;
+                const label = (message.displayText ?? message.text ?? '').trim();
+                if (!label)
+                    continue;
+                landmarks.push({ turnId: message.turnId, sequence, label });
+                if (landmarks.length === maxLandmarks)
+                    break;
+            }
+            return { throughSequence, landmarks };
+        },
+    };
+}
+function ordinalOf(sequence) {
+    return Math.floor(sequence / EVENT_SEQUENCE_STRIDE);
+}
 function assertActiveOverlayBounded(messages) {
     if (messages.length > ACTIVE_TRANSCRIPT_OVERLAY_MAX_MESSAGES) {
         throw new Error('Active Session transcript overlay exceeds its message limit');
@@ -84,41 +528,8 @@ async function readCanonicalPermissionOutcomes(events, reader) {
     }
     return outcomes;
 }
-function activePresentationEvents(events) {
-    const textMessages = new Set();
-    const lastThinkingByMessage = new Map();
-    for (const event of events) {
-        const content = event.content;
-        if (event.role !== 'model' || (content?.kind !== 'text' && content?.kind !== 'thinking')) {
-            continue;
-        }
-        const messageKey = activeMessageKey(event);
-        if (content.kind === 'text')
-            textMessages.add(messageKey);
-        else
-            lastThinkingByMessage.set(messageKey, event);
-    }
-    const syntheticAfter = new Map();
-    for (const [messageKey, thinking] of lastThinkingByMessage) {
-        if (textMessages.has(messageKey))
-            continue;
-        const existing = syntheticAfter.get(thinking) ?? [];
-        existing.push(emptyAssistantText(thinking));
-        syntheticAfter.set(thinking, existing);
-    }
-    const presented = [];
-    for (const event of events) {
-        presented.push(presentationEvent(event));
-        const synthetic = syntheticAfter.get(event);
-        if (synthetic)
-            presented.push(...synthetic);
-    }
-    return presented;
-}
-async function readActiveProjectionEvents(stores, sessionId, runId) {
+async function readActiveRuntimeEvents(stores, sessionId, runId, budget) {
     const events = [];
-    let retainedEvents = 0;
-    let retainedBytes = 0;
     const result = await stores.runtimeEventStore.scanRuntimeEvents(sessionId, runId, {
         maxBatchBytes: ACTIVE_TRANSCRIPT_SCAN_BATCH_MAX_BYTES,
         maxRecordBytes: ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES,
@@ -127,44 +538,23 @@ async function readActiveProjectionEvents(stores, sessionId, runId) {
         maxPartialRecords: ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS,
         maxPartialBytes: ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES,
     }, (batch) => {
-        const relevant = batch.filter(affectsRuntimeEventStoredMessageProjection);
-        for (const event of relevant) {
-            retainedEvents += 1;
-            retainedBytes += Buffer.byteLength(JSON.stringify(event), 'utf8');
-            if (retainedEvents > ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS) {
+        for (const event of batch) {
+            budget.events += 1;
+            budget.bytes += Buffer.byteLength(JSON.stringify(event), 'utf8');
+            if (budget.events > ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS) {
                 throw new Error('Active RuntimeEvent transcript exceeds its event limit');
             }
-            if (retainedBytes > ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES) {
+            if (budget.bytes > ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES) {
                 throw new Error('Active RuntimeEvent transcript exceeds its byte limit');
             }
         }
-        events.push(...relevant);
+        events.push(...batch);
     });
     if (result.status === 'limit_exceeded') {
         throw new Error('Active RuntimeEvent transcript exceeds its storage scan limit');
     }
     return events;
 }
-function activeMessageKey(event) {
-    const messageId = event.refs?.providerEventId ?? event.refs?.storedMessageId ?? event.id;
-    return `${event.runId}\0${messageId}`;
-}
-function presentationEvent(event) {
-    const content = event.content;
-    return event.partial &&
-        event.role === 'model' &&
-        (content?.kind === 'text' || content?.kind === 'thinking')
-        ? { ...event, partial: false }
-        : event;
-}
-function emptyAssistantText(thinking) {
-    return {
-        ...thinking,
-        id: `${thinking.id}:active-transcript-empty-text`,
-        partial: false,
-        content: { kind: 'text', text: '' },
-    };
-}
 function isTerminalTurn(turn) {
     return turn.status === 'completed' || turn.status === 'failed' || turn.status === 'cancelled';
 }

package/node_modules/@maka/runtime-host/dist/server/shared-session-transcript.js

@@ -119,7 +119,7 @@ export function projectSharedSessionTranscriptMessage(message, sessionId) {
                 ...(message.abortedAt === undefined ? {} : { abortedAt: message.abortedAt }),
                 ...(message.abortSource === undefined ? {} : { abortSource: message.abortSource }),
                 ...(message.errorClass === undefined ? {} : { errorClass: message.errorClass }),
-                partialOutputRetained: message.partialOutputRetained,
+                ...(message.retry === undefined ? {} : { retry: message.retry }),
             };
         case 'token_usage':
             return {