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

package/node_modules/@maka/runtime-host/dist/server/serial-outbound-writer.js

@@ -19,6 +19,22 @@
 import { encodeProtocolMessage, } from '../protocol/index.js';
 const MAX_QUEUED_FRAMES = 64;
 const MAX_QUEUED_BYTES = 2 * 1024 * 1024;
+function frameLane(frame) {
+    if ('operation' in frame) {
+        if (frame.operation === 'subscription.close')
+            return 'barrier';
+        if (frame.operation === 'session.transcript.page' ||
+            frame.operation === 'artifact.query' ||
+            frame.operation === 'runtime.resource.query')
+            return 'bulk';
+        return 'control';
+    }
+    if (frame.kind === 'subscription.closed')
+        return 'barrier';
+    if (frame.kind === 'subscription.runtime_resource_pty_data')
+        return 'pty';
+    return frame.kind.startsWith('subscription.') ? 'state' : 'control';
+}
 export class RuntimeHostOutboundQueueError extends Error {
     code;
     constructor(code) {
@@ -37,6 +53,8 @@ export class BoundedSerialOutboundWriter {
     #writing = false;
     #drainTask;
     #closed = false;
+    #controlBurst = 0;
+    #dataLane = 0;
     constructor(transport, onFailure) {
         this.#transport = transport;
         this.#onFailure = onFailure;
@@ -65,7 +83,7 @@ export class BoundedSerialOutboundWriter {
             throw failure;
         }
         const flushed = new Promise((resolve, reject) => {
-            this.#queue.push({ message, resolve, reject });
+            this.#queue.push({ message, lane: frameLane(frame), resolve, reject });
             this.#queuedBytes += message.byteLength;
             if (!this.#writing) {
                 this.#writing = true;
@@ -88,7 +106,7 @@ export class BoundedSerialOutboundWriter {
     async #drain() {
         try {
             while (!this.#closed) {
-                const queued = this.#queue[0];
+                const queued = this.#nextFrame();
                 if (!queued)
                     return;
                 try {
@@ -100,7 +118,7 @@ export class BoundedSerialOutboundWriter {
                 }
                 if (this.#closed)
                     return;
-                this.#queue.shift();
+                this.#queue.splice(this.#queue.indexOf(queued), 1);
                 this.#queuedBytes -= queued.message.byteLength;
                 queued.resolve();
             }
@@ -118,6 +136,30 @@ export class BoundedSerialOutboundWriter {
         this.close(error);
         this.#onFailure();
     }
+    #nextFrame() {
+        // Close acknowledgements are fences: no lower-priority subscription
+        // frames may arrive after a Client has retired their correlation ID.
+        const barrier = this.#queue.findIndex((frame) => frame.lane === 'barrier');
+        if (barrier === 0)
+            return this.#queue[0];
+        const eligible = barrier < 0 ? this.#queue : this.#queue.slice(0, barrier);
+        const control = eligible.find((frame) => frame.lane === 'control');
+        if (control && this.#controlBurst < 8) {
+            this.#controlBurst += 1;
+            return control;
+        }
+        const lanes = ['state', 'bulk', 'pty'];
+        for (let offset = 0; offset < lanes.length; offset += 1) {
+            const lane = (this.#dataLane + offset) % lanes.length;
+            const frame = eligible.find((candidate) => candidate.lane === lanes[lane]);
+            if (!frame)
+                continue;
+            this.#dataLane = (lane + 1) % lanes.length;
+            this.#controlBurst = 0;
+            return frame;
+        }
+        return control;
+    }
 }
 function asError(error) {
     return error instanceof Error ? error : new Error(String(error));

package/node_modules/@maka/runtime-host/dist/server/session-catalog-coordinator.js

@@ -25,10 +25,14 @@ import { executionBoundaryDisplayMode, } from '@maka/core/sandbox-boundary';
 import { DEFAULT_SESSION_NAME, normalizeUserSessionName } from '@maka/core/session-name';
 import { isSessionStartModeLabel as isExecutionSemanticLabel, sessionStartModeSpec, } from '@maka/core/session-start-mode';
 import { isWorkHubCoordinationSessionId, isWorkHubCoordinationSessionTarget, } from '@maka/core/session';
-import { isSessionNotFoundError, SessionMetadataConflictError, SessionMetadataVersionConflictError, SessionReadMarkerMessageNotFoundError, } from '@maka/storage/execution-stores';
+import { isSessionNotFoundError, SessionMetadataConflictError, SessionMetadataVersionConflictError, } from '@maka/storage/execution-stores';
+import { isVisibleSessionMessage } from '@maka/storage/session-message-projection';
 import { SessionConfigurationRevisionConflictError, SessionConfigurationTransitionError, } from '@maka/runtime/session-manager';
 import { decodeSessionCatalogProjection, decodeSharedSessionCatalogProjection, SESSION_CATALOG_LIVE_RUN_STATE_SCHEMA_VERSION, SESSION_CATALOG_LABEL_MAX_BYTES, SESSION_CATALOG_LABEL_MAX_ITEMS, SESSION_CATALOG_MODEL_MAX_BYTES, SESSION_CATALOG_PAGE_MAX_ITEMS, SESSION_CATALOG_RESULT_MAX_BYTES, SESSION_CATALOG_RUNNING_TURN_MAX_ITEMS, projectSessionTurnLandmarkForWire, SESSION_TURN_QUERY_RESULT_MAX_BYTES, projectSessionTurnContributionForWire, } from '../protocol/index.js';
 import { WorkspaceResolutionError } from './workspace-resolver.js';
+/** One page of the backwards scan a read marker walks to find the newest visible message. */
+const SESSION_READ_MARKER_TAIL_MAX_MESSAGES = 64;
+const SESSION_READ_MARKER_TAIL_MAX_BYTES = 256 * 1024;
 export class SessionOperationFailure extends Error {
     code;
     constructor(code, message) {
@@ -130,6 +134,7 @@ export class HostSessionCatalogCoordinator {
         'session.turns.query': (input) => this.#queryTurns(input),
     };
     #stores;
+    #turnIndex;
     #runtimePolicy;
     #manager;
     #admission;
@@ -139,6 +144,7 @@ export class HostSessionCatalogCoordinator {
     #sessionAccessAuthority;
     constructor(options) {
         this.#stores = options.stores;
+        this.#turnIndex = options.turnIndex;
         this.#runtimePolicy = options.runtimePolicy;
         this.#manager = options.manager;
         this.#admission = options.admission;
@@ -297,7 +303,7 @@ export class HostSessionCatalogCoordinator {
             let maxContributions = input.maxContributions;
             let throughSequence = input.throughSequence;
             while (true) {
-                const page = await this.#stores.readTurnContributionsSnapshot(input.sessionId, throughSequence, input.position, maxContributions);
+                const page = await this.#turnIndex.readDurableTurnContributions(input.sessionId, throughSequence, input.position, maxContributions);
                 throughSequence = page.throughSequence;
                 const result = {
                     sessionId: input.sessionId,
@@ -323,7 +329,7 @@ export class HostSessionCatalogCoordinator {
     }
     async #queryTurnLandmarks(input) {
         try {
-            const snapshot = await this.#stores.readTurnLandmarksSnapshot(input.sessionId, input.maxLandmarks);
+            const snapshot = await this.#turnIndex.readDurableTurnLandmarks(input.sessionId, input.maxLandmarks);
             return {
                 ok: true,
                 result: {
@@ -533,7 +539,7 @@ export class HostSessionCatalogCoordinator {
                 if (isWorkHubCoordinationSessionTarget(current.header)) {
                     return readMarkerFailure('operation_conflict', 'WorkHub Coordination Session read state requires WorkHub authority');
                 }
-                await this.#stores.markSessionReadThroughMessage(input.sessionId, input.readThroughMessageId);
+                await this.#clearUnreadAtTranscriptTail(current, input.readThroughMessageId);
                 await this.#continuity.refreshCanonical(input.sessionId, lease);
                 return {
                     ok: true,
@@ -543,9 +549,6 @@ export class HostSessionCatalogCoordinator {
             catch (error) {
                 if (isNotFound(error))
                     return readMarkerFailure('not_found', 'Session does not exist');
-                if (error instanceof SessionReadMarkerMessageNotFoundError) {
-                    return readMarkerFailure('invalid_request', error.message);
-                }
                 if (error instanceof SessionMetadataVersionConflictError) {
                     return readMarkerFailure('operation_conflict', 'Session changed while advancing the read marker');
                 }
@@ -554,6 +557,46 @@ export class HostSessionCatalogCoordinator {
             }
         });
     }
+    /**
+     * A Session is read once the client has caught up with the ledger's newest
+     * visible message. `hasUnread` is the only thing the marker decides and every
+     * Turn raises it again, so a client still behind the tail changes nothing.
+     */
+    async #clearUnreadAtTranscriptTail(record, readThroughMessageId) {
+        const latest = await this.#newestVisibleMessage(record.header.id);
+        if (latest?.id !== readThroughMessageId)
+            return;
+        if (record.header.lastReadMessageId === readThroughMessageId && !record.header.hasUnread) {
+            return;
+        }
+        await this.#stores.updateHeaderVersioned(record.header.id, { lastReadMessageId: readThroughMessageId, hasUnread: false }, record.revision);
+    }
+    /**
+     * The ledger's newest message a client can actually see. A Turn that ends on
+     * tool traffic can put more hidden records at the tail than one page holds,
+     * so the scan pages past them instead of reading the Session as never caught
+     * up and leaving it unread for good.
+     */
+    async #newestVisibleMessage(sessionId) {
+        let throughSequence;
+        let position;
+        while (true) {
+            const page = await this.#turnIndex.readDurableRecords(sessionId, {
+                direction: 'older',
+                maxMessages: SESSION_READ_MARKER_TAIL_MAX_MESSAGES,
+                maxStoredBytes: SESSION_READ_MARKER_TAIL_MAX_BYTES,
+                ...(throughSequence === undefined ? {} : { throughSequence }),
+                ...(position === undefined ? {} : { position }),
+            });
+            const visible = page.records.find(({ message }) => isVisibleSessionMessage(message));
+            if (visible)
+                return visible.message;
+            if (page.nextPosition === null)
+                return undefined;
+            throughSequence = page.throughSequence;
+            position = page.nextPosition;
+        }
+    }
     async #committedUpdate(sessionId, lease) {
         await this.#continuity.refreshCanonical(sessionId, lease);
         return {

package/node_modules/@maka/runtime-host/dist/server/session-continuity-coordinator.js

@@ -43,6 +43,21 @@ export class SessionContinuityCoordinator {
     onPublicationFailure;
     onCatalogChanged;
     handlers = {
+        'subscription.pty_interest.set': async (input, context) => {
+            const subscriber = this.#ownedSubscriber(context.connectionId, input.subscriptionId);
+            if (!subscriber || !this.#canObserve(subscriber, subscriber.sessionId)) {
+                return {
+                    ok: false,
+                    error: { code: 'not_found', message: 'Session subscription was not found' },
+                };
+            }
+            subscriber.ptyInterests = new Set(input.refs);
+            // An already writing frame may finish. Everything else belongs to the
+            // current visible set; reacquiring uses a fresh terminal snapshot.
+            subscriber.ptyQueue = subscriber.ptyQueue.filter((entry, index) => (index === 0 && subscriber.ptyPumping) || subscriber.ptyInterests.has(entry.frame.ref));
+            subscriber.ptyQueuedBytes = subscriber.ptyQueue.reduce((bytes, entry) => bytes + entry.encodedBytes, 0);
+            return { ok: true, result: { subscriptionId: input.subscriptionId } };
+        },
         'subscription.open': async (input, context) => {
             const result = await this.#open(context, input);
             return result.ok
@@ -267,35 +282,36 @@ export class SessionContinuityCoordinator {
             this.#scheduleSessionDomainChanges(sessionId, changes);
         }
     }
-    /** Publish live PTY bytes on the same ordered Session subscription as its durable projection. */
+    /** PTY congestion never consumes Session sequence numbers or its queue budget. */
     async enqueueRuntimeResourcePtyData(event) {
-        if (this.#closed ||
-            Buffer.byteLength(event.data, 'utf8') > SESSION_RUNTIME_RESOURCE_PTY_DATA_MAX_BYTES) {
+        if (this.#closed)
             return;
-        }
         try {
-            await this.sessionAdmission.enqueueDetached(event.sessionId, () => {
-                if (this.#closed)
-                    return;
-                const state = this.#sessions.get(event.sessionId);
-                if (!state)
-                    return;
-                for (const subscriber of state.subscribers.values()) {
-                    const frame = {
-                        kind: 'subscription.runtime_resource_pty_data',
-                        hostEpoch: this.#hostEpoch,
-                        subscriptionId: subscriber.subscriptionId,
-                        sequence: subscriber.nextSequence,
-                        sessionId: event.sessionId,
-                        ref: event.ref,
-                        ptySequence: event.sequence,
-                        data: event.data,
-                    };
-                    if (Buffer.byteLength(JSON.stringify(frame), 'utf8') <= SESSION_SUBSCRIPTION_FRAME_MAX_BYTES) {
-                        this.#enqueue(subscriber, frame);
-                    }
+            const state = this.#sessions.get(event.sessionId);
+            if (!state)
+                return;
+            for (const subscriber of state.subscribers.values()) {
+                if (!this.#canObserve(subscriber, event.sessionId)) {
+                    this.#closeSubscriber(subscriber, 'access_revoked');
+                    continue;
                 }
-            });
+                if (!subscriber.ptyInterests.has(event.ref))
+                    continue;
+                const frame = {
+                    kind: 'subscription.runtime_resource_pty_data',
+                    hostEpoch: this.#hostEpoch,
+                    subscriptionId: subscriber.subscriptionId,
+                    sessionId: event.sessionId,
+                    ref: event.ref,
+                    ptySequence: event.sequence,
+                    ...(Buffer.byteLength(event.data, 'utf8') > SESSION_RUNTIME_RESOURCE_PTY_DATA_MAX_BYTES
+                        ? { data: '', reset: true }
+                        : { data: event.data }),
+                };
+                if (Buffer.byteLength(JSON.stringify(frame), 'utf8') <= SESSION_SUBSCRIPTION_FRAME_MAX_BYTES) {
+                    this.#enqueuePty(subscriber, frame);
+                }
+            }
         }
         catch (error) {
             this.onPublicationFailure(error);
@@ -705,6 +721,10 @@ export class SessionContinuityCoordinator {
                                 nextSequence: 1,
                                 lastFlushedSequence: 0,
                                 queue: [],
+                                ptyQueue: [],
+                                ptyInterests: new Set(),
+                                ptyQueuedBytes: 0,
+                                ptyPumping: false,
                                 queuedBytes: 0,
                                 pumping: false,
                                 terminalQueued: false,
@@ -1073,6 +1093,7 @@ export class SessionContinuityCoordinator {
             return;
         subscriber.activated = true;
         this.#pump(subscriber);
+        this.#pumpPty(subscriber);
     }
     #abortSubscription(connectionId, subscriptionId) {
         const subscriber = this.#ownedSubscriber(connectionId, subscriptionId);
@@ -1164,6 +1185,45 @@ export class SessionContinuityCoordinator {
     #evictSlowSubscriber(subscriber) {
         this.#closeSubscriber(subscriber, 'slow_consumer');
     }
+    #enqueuePty(subscriber, frame) {
+        if (subscriber.phase !== 'open' || subscriber.terminalQueued)
+            return;
+        let encodedBytes = encodeProtocolMessage(frame).byteLength;
+        if (subscriber.ptyQueue.length >= 8 || subscriber.ptyQueuedBytes + encodedBytes > 128 * 1024) {
+            // Reset is session-wide for terminal consumers, so one marker covers
+            // every omitted resource without an unbounded per-resource dirty set.
+            const inFlight = subscriber.ptyPumping ? subscriber.ptyQueue[0] : undefined;
+            subscriber.ptyQueue = inFlight ? [inFlight] : [];
+            subscriber.ptyQueuedBytes = inFlight?.encodedBytes ?? 0;
+            frame = { ...frame, data: '', reset: true };
+            encodedBytes = encodeProtocolMessage(frame).byteLength;
+        }
+        subscriber.ptyQueue.push({ frame, encodedBytes });
+        subscriber.ptyQueuedBytes += encodedBytes;
+        this.#pumpPty(subscriber);
+    }
+    #pumpPty(subscriber) {
+        if (subscriber.ptyPumping || !subscriber.activated || subscriber.phase !== 'open')
+            return;
+        const queued = subscriber.ptyQueue[0];
+        if (!queued)
+            return;
+        subscriber.ptyPumping = true;
+        void Promise.resolve()
+            .then(() => {
+            if (subscriber.phase !== 'open')
+                return;
+            return subscriber.sink.send(queued.frame);
+        })
+            .then(() => {
+            subscriber.ptyPumping = false;
+            if (subscriber.ptyQueue[0] === queued) {
+                subscriber.ptyQueue.shift();
+                subscriber.ptyQueuedBytes -= queued.encodedBytes;
+            }
+            this.#pumpPty(subscriber);
+        }, () => this.#removeSubscriber(subscriber));
+    }
     #closeSubscriber(subscriber, reason) {
         if (subscriber.phase !== 'open')
             return;
@@ -1330,6 +1390,8 @@ export class SessionContinuityCoordinator {
         subscriber.phase = 'closed';
         subscriber.queue = [];
         subscriber.queuedBytes = 0;
+        subscriber.ptyQueue = [];
+        subscriber.ptyQueuedBytes = 0;
         const state = this.#sessions.get(subscriber.sessionId);
         const removed = state?.subscribers.delete(subscriber.subscriptionId);
         this.#subscriptions.delete(subscriber.subscriptionId);

package/node_modules/@maka/runtime-host/dist/server/session-retirement-coordinator.js

@@ -439,8 +439,11 @@ export class HostSessionRetirementCoordinator {
                 throw new SessionRetirementBusyError(`Session ${sessionId} has a live derived effect`);
             }
             const header = requireFamilyRecord(family, sessionId).header;
-            if (!header.subagentParent && (await this.#graph.hasLiveSessionState(sessionId))) {
-                throw new SessionRetirementBusyError(`Session ${sessionId} has a live Agent Graph`);
+            if (!header.subagentParent) {
+                const graph = await this.#graph.readRetirementDisposition(sessionId);
+                if (graph.kind === 'busy') {
+                    throw new SessionRetirementBusyError(`Session ${sessionId} has an Agent Graph that is ${graph.status}`);
+                }
             }
             if (!header.subagentParent && this.#graphWake.hasLiveSessionState(sessionId)) {
                 throw new SessionRetirementBusyError(`Session ${sessionId} has an active Agent Graph supervisor wake`);

package/node_modules/@maka/runtime-host/dist/server/session-revision-coordinator.js

@@ -407,10 +407,8 @@ export class HostSessionRevisionCoordinator {
                 // An empty copy carries no source state, including no in-progress Todo.
                 copyCurrent: kind === 'branch' && slice.beforeTs === undefined && input.sourceTurnId !== undefined,
             });
-            if (copiedMessages.length > 0) {
-                await this.#stores.sessionStore.appendMessages(input.targetSessionId, [...copiedMessages]);
-            }
-            await this.#stores.sessionStore.appendMessage(input.targetSessionId, conversationCopyStartNote(kind, input, createInput));
+            // `cloneConversationRuntimeLedger` already wrote the copy's own spine, and
+            // the copy reads back off that: nothing here writes a second transcript.
             await this.#stores.sessionStore.updateHeader(input.targetSessionId, {
                 conversationCopy: {
                     ...createInput.conversationCopy,
@@ -596,21 +594,13 @@ export class HostSessionRevisionCoordinator {
         }, header.id);
         await this.#stores.sessionStore.discardStableConversationCopy(header.id, copy.requestFingerprint);
     }
+    /**
+     * A revision copy that admitted a turn of its own. The admission ledger is
+     * the whole answer: a copy clones the source's history but never its
+     * admissions, so every row it holds was admitted on this session.
+     */
     async #hasAdmittedRevisionTurn(sessionId) {
-        if ((await this.#stores.agentRunStore.listRootTurnAdmissionsForRecovery(sessionId)).length > 0) {
-            return true;
-        }
-        const messages = await this.#stores.sessionStore.readMessagesForRecovery(sessionId);
-        let boundary = -1;
-        for (let index = 0; index < messages.length; index += 1) {
-            const message = messages[index];
-            if (message.type === 'system_note' &&
-                message.kind === 'session_start' &&
-                isRevisionStartData(message.data)) {
-                boundary = index;
-            }
-        }
-        return boundary >= 0 && messages.slice(boundary + 1).some((message) => message.type === 'user');
+        return ((await this.#stores.agentRunStore.listRootTurnAdmissionsForRecovery(sessionId)).length > 0);
     }
     async #hasCommittedConversationCopyDependent(sessionId) {
         return (await this.#stores.sessionStore.listHeaders()).some((header) => header.conversationCopy?.state === 'committed' &&
@@ -638,49 +628,12 @@ function conversationCopyFingerprint(kind, input) {
     ];
     return `sha256:${createHash('sha256').update(JSON.stringify(identity)).digest('hex')}`;
 }
-function conversationCopyStartNote(kind, input, createInput) {
-    const base = {
-        type: 'system_note',
-        id: randomUUID(),
-        ts: Date.now(),
-        kind: 'session_start',
-    };
-    if (kind !== 'revision') {
-        // Empty copies record provenance without a branch turn.
-        return {
-            ...base,
-            data: {
-                parentSessionId: input.sourceSessionId,
-                ...(input.sourceTurnId === undefined ? {} : { branchOfTurnId: input.sourceTurnId }),
-            },
-        };
-    }
-    if (input.sourceTurnId === undefined) {
-        throw new Error('Session revision copy requires a turn boundary');
-    }
-    return {
-        ...base,
-        data: {
-            revisionRootSessionId: createInput.revisionRootSessionId,
-            revisionParentSessionId: input.sourceSessionId,
-            revisionOfTurnId: input.sourceTurnId,
-            revisionIndex: createInput.revisionIndex,
-            revisionState: 'preparing',
-        },
-    };
-}
 function conversationCopySemanticKind(kind, input) {
     return kind === 'branch' && input.intent === 'side_conversation' ? input.intent : kind;
 }
 function persistedConversationCopyKind(kind) {
     return kind === 'revision' ? 'revision' : 'branch';
 }
-function isRevisionStartData(value) {
-    return (!!value &&
-        typeof value === 'object' &&
-        !Array.isArray(value) &&
-        'revisionRootSessionId' in value);
-}
 function collectArchivedToolResultPlaceholders(events, messages, copyTurnIds, operationalEvents) {
     const retainedTurnIds = new Set(copyTurnIds);
     const archives = new Map();
@@ -689,6 +642,8 @@ function collectArchivedToolResultPlaceholders(events, messages, copyTurnIds, op
             return true;
         if (!isArchivedToolResultPlaceholder(value))
             return false;
+        if (value.rewriteVersion === 2)
+            return true;
         addDescriptor(value);
         return true;
     };
@@ -731,6 +686,8 @@ function collectArchivedToolResultPlaceholders(events, messages, copyTurnIds, op
             continue;
         }
         if (message.content.kind === 'archived_tool_result') {
+            if (message.content.rewriteVersion === 2 && message.content.resourceRef)
+                continue;
             if (!message.content.artifactId && !message.content.bodySha256)
                 continue;
             if (!message.content.artifactId || !message.content.bodySha256)

package/node_modules/@maka/runtime-host/dist/server/session-sidecar-purge.js

@@ -16,26 +16,11 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-const CONTEXT_GARBAGE_BATCH_BLOBS = 64;
-async function retireContextSession(contextOffload, sessionId) {
-    await contextOffload.retireSession(sessionId);
-    for (;;) {
-        const collected = await contextOffload.collectGarbage({
-            olderThan: Number.MAX_SAFE_INTEGER,
-            maxBlobs: CONTEXT_GARBAGE_BATCH_BLOBS,
-            maxBytes: Number.MAX_SAFE_INTEGER,
-        });
-        if (!collected.hasMore)
-            return;
-    }
-}
 export async function purgeSessionSidecars(authority, sessionId) {
     const outcomes = await Promise.allSettled([
         authority.artifacts.purgeSessionArtifacts(sessionId),
         authority.sessionTodo.purgeSessionState(sessionId),
-        ...(authority.contextOffload
-            ? [retireContextSession(authority.contextOffload, sessionId)]
-            : []),
+        ...(authority.contextOffload ? [authority.contextOffload.retireSession(sessionId)] : []),
         authority.purgeOperationalState(sessionId),
     ]);
     const failures = outcomes.flatMap((outcome) => outcome.status === 'rejected' ? [outcome.reason] : []);

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

@@ -63,7 +63,6 @@ export async function createSessionTranscriptBootstrap(input) {
         });
         const bootstrap = {
             throughSequence: input.throughSequence,
-            durableCoverage: projection === 'shared' ? 'projected' : 'complete',
             overlayMessageCount: overlayMessages.length,
             durable: pageFromSelection(state, 'durable', 'older', rangeEdges.selected, input.throughSequence, rangeEdges.rangeBoundarySequence, rangeEdges.protectedTurnSequence),
             overlay: pageFromSelection(state, 'overlay', 'older', selectedOverlay),