maka-agent 0.2.0-dev.4.20260830 → 0.2.0-dev.40.20260917

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

@@ -19,30 +19,35 @@
 import { randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { projectToolArgsPreview } from '@maka/core/tool-quiet-preview';
+import { resolveReadInput } from '@maka/runtime/read-page';
 import { decodeRuntimeResourceRef, encodeProtocolMessage, RUNTIME_HOST_MAX_MESSAGE_BYTES, SESSION_LIVE_DELTA_MAX_BYTES, SESSION_RUNTIME_RESOURCE_PTY_DATA_MAX_BYTES, SESSION_RUNTIME_RESOURCE_CHANGES_MAX, SESSION_SUBSCRIPTION_FRAME_MAX_BYTES, SUBSCRIPTION_OPEN_RESULT_MAX_BYTES, SESSION_TOOL_ARGS_PREVIEW_MAX_BYTES, SESSION_TOOL_INTENT_MAX_BYTES, SESSION_TOOL_NAME_MAX_BYTES, } from '../protocol/index.js';
 import { createSessionContinuitySnapshot, } from './canonical-session-projection.js';
-import { createSessionTranscriptBootstrap, prepareSessionTranscriptOverlay, readSessionTranscriptPage, TranscriptPageRequestError, updateSubscriberTranscriptHighWater, } from './session-transcript-pager.js';
-import { ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES, } from './session-transcript-reader.js';
+import { createSessionTranscriptBootstrap, readSessionTranscriptPage, TranscriptPageRequestError, updateSubscriberTranscriptHighWater, } from './session-transcript-pager.js';
 import { projectSharedSessionMessageContent } from './shared-session-transcript.js';
 const MAX_CONNECTION_SUBSCRIPTIONS = 16;
 const MAX_SUBSCRIBER_QUEUED_FRAMES = 32;
 const MAX_SUBSCRIBER_QUEUED_BYTES = 256 * 1024;
-const MAX_RETAINED_TRANSCRIPT_OVERLAY_BYTES = 64 * 1024 * 1024;
-const MAX_TRANSCRIPT_OVERLAY_PREPARATION_WAITERS = 64;
-// Preparation can retain the active projection, durable reconciliation, and
-// final encoded snapshot at the same time; charge all three to the Host budget.
-const MAX_TRANSCRIPT_OVERLAY_PREPARATION_BYTES = ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES * 3;
-class TranscriptOverlayCapacityError extends Error {
-    name = 'TranscriptOverlayCapacityError';
-}
-class TranscriptOverlayPreparationRequired extends Error {
-    name = 'TranscriptOverlayPreparationRequired';
-}
+const ASSISTANT_BACKLOG_CHUNK_CHARACTERS = 8 * 1024;
 export class SessionContinuityCoordinator {
     sessionAdmission;
     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
@@ -58,22 +63,17 @@ export class SessionContinuityCoordinator {
                     error: { code: 'not_found', message: 'Session subscription was not found' },
                 };
         },
-        'session.transcript.page': (input, context) => this.#readTranscriptPage(context.connectionId, input),
-        'session.transcript.overlay.release': async (input, context) => {
-            const existing = this.#subscriptions.get(input.subscriptionId);
-            if (!existing) {
-                return { ok: true, result: { subscriptionId: input.subscriptionId } };
-            }
-            const subscriber = this.#ownedSubscriber(context.connectionId, input.subscriptionId);
-            if (!subscriber) {
+        'subscription.ready': async (input, context) => {
+            if (!this.#ownedSubscriber(context.connectionId, input.subscriptionId)) {
                 return {
                     ok: false,
                     error: { code: 'not_found', message: 'Session subscription was not found' },
                 };
             }
-            this.#releaseSubscriberTranscriptOverlay(subscriber);
+            this.#activate(context.connectionId, input.subscriptionId);
             return { ok: true, result: { subscriptionId: input.subscriptionId } };
         },
+        'session.transcript.page': (input, context) => this.#readTranscriptPage(context.connectionId, input),
     };
     #connections = new Map();
     #sessions = new Map();
@@ -81,14 +81,11 @@ export class SessionContinuityCoordinator {
     #pendingRefreshes = new Map();
     #pendingAgentGraphChanges = new Map();
     #pendingSessionDomainChanges = new Map();
-    #retainedTranscriptOverlays = new Map();
-    #transcriptOverlayPreparationWaiters = [];
+    #pendingTranscriptAdvances = new Map();
     #hostEpoch;
     #readCanonical;
     #transcriptReader;
     #closed = false;
-    #preparingTranscriptOverlayBytes = 0;
-    #retainedTranscriptOverlayBytes = 0;
     #sessionAccessAuthority;
     #unsubscribeGrantRevocations;
     constructor(hostEpoch, readCanonical, sessionAdmission, onPublicationFailure = () => undefined, transcriptReader, onCatalogChanged = () => undefined, sessionAccessAuthority) {
@@ -116,20 +113,13 @@ export class SessionContinuityCoordinator {
         if (this.#connections.has(connectionId)) {
             throw new Error(`Duplicate Runtime Host connection: ${connectionId}`);
         }
-        const closed = signal();
         this.#connections.set(connectionId, {
             sink,
             subscriptionIds: new Set(),
             pendingOpenCount: 0,
-            closed: closed.promise,
-            resolveClosed: closed.resolve,
         });
         let attached = true;
         return {
-            activate: (subscriptionId) => {
-                if (attached)
-                    this.#activate(connectionId, subscriptionId);
-            },
             abort: (subscriptionId) => {
                 if (attached)
                     this.#abortSubscription(connectionId, subscriptionId);
@@ -150,7 +140,6 @@ export class SessionContinuityCoordinator {
             const state = this.#sessions.get(sessionId);
             if (!state || (state.subscribers.size === 0 && !state.terminalPublicationFence))
                 return;
-            this.#invalidateTranscriptOverlay(state);
             const canonical = await this.#readCanonicalProjection(sessionId);
             if (this.#closed || !canonical)
                 return;
@@ -190,6 +179,46 @@ export class SessionContinuityCoordinator {
             this.onPublicationFailure(error);
         });
     }
+    /** Safe for synchronous commit hooks: publishes the transcript high water after RuntimeEvents commit. */
+    enqueueTranscriptAdvanced(sessionId) {
+        if (this.#closed || !this.#sessions.has(sessionId))
+            return;
+        const pending = this.#pendingTranscriptAdvances.get(sessionId);
+        if (pending) {
+            if (pending.inFlight)
+                pending.dirty = true;
+            return;
+        }
+        const advance = { dirty: false, inFlight: false };
+        this.#pendingTranscriptAdvances.set(sessionId, advance);
+        const run = async () => {
+            if (this.#closed)
+                return;
+            const state = this.#sessions.get(sessionId);
+            // A fenced terminal publication advances the transcript together with
+            // the terminal projection, so a turn_state row never outruns its Turn.
+            if (!state || state.terminalPublicationFence)
+                return;
+            await this.#refreshTranscriptHighWater(sessionId, state);
+        };
+        void this.sessionAdmission
+            .enqueueDetached(sessionId, async () => {
+            advance.inFlight = true;
+            await run();
+            if (!advance.dirty)
+                return;
+            advance.dirty = false;
+            await run();
+        })
+            .then(() => {
+            this.#pendingTranscriptAdvances.delete(sessionId);
+            if (advance.dirty)
+                this.enqueueTranscriptAdvanced(sessionId);
+        }, (error) => {
+            this.#pendingTranscriptAdvances.delete(sessionId);
+            this.onPublicationFailure(error);
+        });
+    }
     /** Coalesce process-local graph invalidations onto the root Session sequence. */
     enqueueAgentGraphChanged(event) {
         if (this.#closed)
@@ -267,35 +296,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);
@@ -404,17 +434,33 @@ export class SessionContinuityCoordinator {
             await this.#refreshTranscriptHighWater(sessionId, state);
             const nextRevision = state.revision + 1;
             const snapshot = createSessionContinuitySnapshot(canonical, nextRevision);
-            this.#invalidateTranscriptOverlay(state);
             state.canonical = canonical;
             state.revision = nextRevision;
             delete state.terminalPublicationFence;
+            // A subscriber still being paid a stream's prefix has not seen the end
+            // of it. The Turn ending does not make that text untrue, so each
+            // backlog keeps its own copy of the stream and finishes paying it; the
+            // terminal projection queues behind that, never over it.
+            for (const subscriber of state.subscribers.values()) {
+                for (const [key, backlog] of subscriber.assistantBacklog) {
+                    if (backlog.completion)
+                        continue;
+                    const stream = state.assistantStreams.get(key);
+                    if (!stream) {
+                        subscriber.assistantBacklog.delete(key);
+                        continue;
+                    }
+                    backlog.completion = { runId: rootTurn.runId, stream: { ...stream } };
+                }
+            }
             state.assistantStreams.clear();
             state.toolResultPreviews.clear();
             this.#broadcastProjection(state, snapshot);
-            if (state.subscribers.size === 0) {
-                this.#invalidateTranscriptOverlay(state);
-                this.#sessions.delete(sessionId);
+            for (const subscriber of state.subscribers.values()) {
+                this.#payAssistantBacklog(subscriber, state);
             }
+            if (state.subscribers.size === 0)
+                this.#sessions.delete(sessionId);
         }, admission);
     }
     async acceptRuntimeEvent(sessionId, runId, event) {
@@ -435,7 +481,6 @@ export class SessionContinuityCoordinator {
                     throw new Error('Runtime event belongs to a missing Session');
                 state = this.#commitCanonical(sessionId, canonical).state;
             }
-            this.#invalidateTranscriptOverlay(state);
             const rootTurn = state.canonical.rootTurn;
             if (!rootTurn ||
                 rootTurn.sessionId !== sessionId ||
@@ -462,7 +507,14 @@ export class SessionContinuityCoordinator {
                     text: (current?.text ?? '') + event.text,
                 });
                 for (const subscriber of state.subscribers.values()) {
-                    this.#enqueueAssistantDelta(subscriber, sessionId, runId, event, kind, startOffset);
+                    if (subscriber.assistantBacklog.has(prefixKey)) {
+                        // This text is part of the prefix still being paid out; the payout
+                        // reads the accumulated stream, so it carries this delta already.
+                        this.#payAssistantBacklog(subscriber, state);
+                    }
+                    else {
+                        this.#deliverInOrder(subscriber, () => this.#enqueueAssistantDelta(subscriber, sessionId, runId, event, kind, startOffset));
+                    }
                 }
                 return;
             }
@@ -484,13 +536,13 @@ export class SessionContinuityCoordinator {
                 if (thinking) {
                     const finalThinking = thinking.completedParts?.join('') ?? thinking.text;
                     for (const subscriber of state.subscribers.values()) {
-                        this.#enqueueAssistantCompletion(subscriber, sessionId, runId, thinking, 'thinking', finalThinking);
+                        this.#completeAssistantStream(subscriber, state, runId, thinkingKey, thinking, finalThinking);
                     }
                     state.assistantStreams.delete(thinkingKey);
                 }
                 const textKey = assistantStreamKey('text', event.messageId);
                 const text = state.assistantStreams.get(textKey);
-                if (text || event.text.length > 0) {
+                if (text || event.text.length > 0 || event.interrupted) {
                     const current = text ??
                         {
                             kind: 'text',
@@ -499,7 +551,7 @@ export class SessionContinuityCoordinator {
                             text: '',
                         };
                     for (const subscriber of state.subscribers.values()) {
-                        this.#enqueueAssistantCompletion(subscriber, sessionId, runId, current, 'text', event.text);
+                        this.#completeAssistantStream(subscriber, state, runId, textKey, current, event.text, event.interrupted);
                     }
                     state.assistantStreams.delete(textKey);
                 }
@@ -534,7 +586,6 @@ export class SessionContinuityCoordinator {
                 for (const subscriber of state.subscribers.values()) {
                     this.#enqueueSessionRemoved(subscriber);
                 }
-                this.#invalidateTranscriptOverlay(state);
                 this.#sessions.delete(sessionId);
             }, admission);
         }
@@ -544,14 +595,12 @@ export class SessionContinuityCoordinator {
             return;
         this.#closed = true;
         this.#unsubscribeGrantRevocations?.();
-        this.#cancelTranscriptOverlayPreparationWaiters();
         for (const connectionId of [...this.#connections.keys()])
             this.#closeConnection(connectionId);
-        for (const state of this.#sessions.values())
-            this.#invalidateTranscriptOverlay(state);
         this.#sessions.clear();
         this.#subscriptions.clear();
         this.#pendingRefreshes.clear();
+        this.#pendingTranscriptAdvances.clear();
         this.#pendingAgentGraphChanges.clear();
         this.#pendingSessionDomainChanges.clear();
     }
@@ -574,206 +623,67 @@ export class SessionContinuityCoordinator {
             };
         }
         connection.pendingOpenCount += 1;
-        let preparationPermit;
-        let retryAfterCapacity = false;
         try {
-            for (;;) {
-                try {
-                    return await this.sessionAdmission.run(sessionId, async () => {
-                        if (this.#connections.get(connectionId) !== connection) {
-                            throw new Error('Runtime Host connection closed during subscription open');
-                        }
-                        const canonical = await this.#readCanonicalProjection(sessionId);
-                        if (this.#connections.get(connectionId) !== connection) {
-                            throw new Error('Runtime Host connection closed during subscription open');
-                        }
-                        if (!canonical) {
-                            return {
-                                ok: false,
-                                code: 'not_found',
-                                message: 'Session was not found',
-                            };
-                        }
-                        const committed = this.#commitCanonical(sessionId, canonical);
-                        if (committed.changed) {
-                            this.#invalidateTranscriptOverlay(committed.state);
-                            this.#broadcastProjection(committed.state, committed.value);
-                        }
-                        if (this.#connections.get(connectionId) !== connection) {
-                            this.#scheduleInactiveStateCleanup(sessionId, committed.state);
-                            throw new Error('Runtime Host connection closed during subscription open');
-                        }
-                        const subscriptionId = randomUUID();
-                        const activeAssistantStreams = [...committed.state.assistantStreams.values()].map(({ kind, turnId, messageId }) => ({ kind, turnId, messageId }));
-                        let transcript;
-                        let retainedTranscriptOverlay;
-                        let cachedTranscriptOverlay;
-                        let transcriptSubscriberInstalled = false;
-                        let transcriptBootstrap = null;
-                        try {
-                            if (input.transcript.kind === 'tail') {
-                                if (!this.#transcriptReader) {
-                                    return {
-                                        ok: false,
-                                        code: 'operation_unavailable',
-                                        message: 'Session transcript is unavailable',
-                                    };
-                                }
-                                try {
-                                    const throughSequence = await this.#transcriptReader.readDurableHighWater(sessionId);
-                                    cachedTranscriptOverlay = this.#prepareTranscriptOverlay(committed.state, sessionId, throughSequence, preparationPermit);
-                                    cachedTranscriptOverlay.pendingConsumers += 1;
-                                    retainedTranscriptOverlay = await Promise.race([
-                                        cachedTranscriptOverlay.prepared,
-                                        connection.closed.then(() => {
-                                            throw new Error('Runtime Host connection closed during subscription open');
-                                        }),
-                                    ]);
-                                    const snapshot = projectSessionSnapshot(committed.value, identity.principalKind);
-                                    const created = await createSessionTranscriptBootstrap({
-                                        reader: this.#transcriptReader,
-                                        sessionId,
-                                        subscriptionId,
-                                        throughSequence,
-                                        rootTurn: committed.state.canonical.rootTurn,
-                                        activeAssistantStreams: committed.state.assistantStreams.values(),
-                                        maxBytes: input.transcript.maxBytes,
-                                        preparedOverlayMessages: retainedTranscriptOverlay.messages,
-                                        projection: identity.principalKind === 'session_guest' ? 'shared' : 'owner',
-                                        maxEncodedBytes: subscriptionOpenTranscriptBudget({
-                                            hostEpoch: this.#hostEpoch,
-                                            subscriptionId,
-                                            nextSequence: 1,
-                                            snapshot,
-                                            activeAssistantStreams,
-                                            transcript: null,
-                                        }),
-                                    });
-                                    transcript = created.state;
-                                    transcriptBootstrap = created.bootstrap;
-                                }
-                                catch (error) {
-                                    if (error instanceof TranscriptOverlayPreparationRequired)
-                                        throw error;
-                                    return {
-                                        ok: false,
-                                        code: error instanceof TranscriptOverlayCapacityError
-                                            ? 'operation_unavailable'
-                                            : 'persistence_failed',
-                                        message: error instanceof TranscriptOverlayCapacityError
-                                            ? 'Runtime Host transcript overlay capacity reached'
-                                            : 'Session transcript is unavailable',
-                                    };
-                                }
-                            }
-                            if (this.#connections.get(connectionId) !== connection) {
-                                this.#scheduleInactiveStateCleanup(sessionId, committed.state);
-                                throw new Error('Runtime Host connection closed during subscription open');
-                            }
-                            const openValue = {
-                                hostEpoch: this.#hostEpoch,
-                                subscriptionId,
-                                nextSequence: 1,
-                                snapshot: projectSessionSnapshot(committed.value, identity.principalKind),
-                                activeAssistantStreams,
-                                transcript: transcriptBootstrap,
-                            };
-                            if (Buffer.byteLength(JSON.stringify(openValue), 'utf8') >
-                                SUBSCRIPTION_OPEN_RESULT_MAX_BYTES) {
-                                return {
-                                    ok: false,
-                                    code: 'operation_unavailable',
-                                    message: 'Session subscription state exceeds the transport limit',
-                                };
-                            }
-                            if (!this.#canObserve(identity, sessionId)) {
-                                return {
-                                    ok: false,
-                                    code: 'not_found',
-                                    message: 'Session was not found',
-                                };
-                            }
-                            const subscriber = {
-                                connectionId,
-                                principalId: identity.principalId,
-                                principalKind: identity.principalKind,
-                                sessionId,
-                                subscriptionId,
-                                sink: connection.sink,
-                                phase: 'open',
-                                activated: false,
-                                nextSequence: 1,
-                                lastFlushedSequence: 0,
-                                queue: [],
-                                queuedBytes: 0,
-                                pumping: false,
-                                terminalQueued: false,
-                                ...(transcript ? { transcript } : {}),
-                                ...(retainedTranscriptOverlay ? { retainedTranscriptOverlay } : {}),
-                            };
-                            if (subscriber.retainedTranscriptOverlay)
-                                this.#retainTranscriptOverlay(subscriber.retainedTranscriptOverlay);
-                            committed.state.subscribers.set(subscriptionId, subscriber);
-                            this.#subscriptions.set(subscriptionId, subscriber);
-                            connection.subscriptionIds.add(subscriptionId);
-                            transcriptSubscriberInstalled = subscriber.retainedTranscriptOverlay !== undefined;
-                            // Client expects the first delivered frame at nextSequence from the open
-                            // result. Capture that before enqueueing retained previews — each
-                            // #enqueue advances nextSequence.
-                            const firstSequence = subscriber.nextSequence;
-                            // Seed retained live previews so a mid-turn rejoin still has Open facts.
-                            const rootTurn = committed.state.canonical.rootTurn;
-                            if (rootTurn && !isTerminalTurn(rootTurn)) {
-                                for (const preview of committed.state.toolResultPreviews.values()) {
-                                    if (preview.turnId !== rootTurn.turnId)
-                                        continue;
-                                    const frame = {
-                                        kind: 'subscription.session_event',
-                                        hostEpoch: this.#hostEpoch,
-                                        subscriptionId: subscriber.subscriptionId,
-                                        sequence: subscriber.nextSequence,
-                                        sessionId,
-                                        runId: rootTurn.runId,
-                                        event: projectSessionEvent(preview, sessionId, subscriber.principalKind === 'session_guest'),
-                                    };
-                                    this.#enqueue(subscriber, frame);
-                                }
-                            }
-                            return {
-                                ok: true,
-                                value: { ...openValue, nextSequence: firstSequence },
-                            };
-                        }
-                        finally {
-                            if (cachedTranscriptOverlay)
-                                cachedTranscriptOverlay.pendingConsumers -= 1;
-                            if (cachedTranscriptOverlay &&
-                                !transcriptSubscriberInstalled &&
-                                cachedTranscriptOverlay.pendingConsumers === 0 &&
-                                !this.#hasTranscriptOverlayConsumer(committed.state)) {
-                                this.#invalidateTranscriptOverlay(committed.state, cachedTranscriptOverlay);
-                            }
-                        }
-                    });
+            return await this.sessionAdmission.run(sessionId, async () => {
+                if (this.#connections.get(connectionId) !== connection) {
+                    throw new Error('Runtime Host connection closed during subscription open');
+                }
+                const canonical = await this.#readCanonicalProjection(sessionId);
+                if (this.#connections.get(connectionId) !== connection) {
+                    throw new Error('Runtime Host connection closed during subscription open');
+                }
+                if (!canonical) {
+                    return {
+                        ok: false,
+                        code: 'not_found',
+                        message: 'Session was not found',
+                    };
                 }
-                catch (error) {
-                    if (!(error instanceof TranscriptOverlayPreparationRequired))
-                        throw error;
-                    if (retryAfterCapacity) {
+                const committed = this.#commitCanonical(sessionId, canonical);
+                if (committed.changed)
+                    this.#broadcastProjection(committed.state, committed.value);
+                if (this.#connections.get(connectionId) !== connection) {
+                    this.#scheduleInactiveStateCleanup(sessionId, committed.state);
+                    throw new Error('Runtime Host connection closed during subscription open');
+                }
+                const subscriptionId = randomUUID();
+                const activeAssistantStreams = [...committed.state.assistantStreams.values()].map(({ kind, turnId, messageId }) => ({ kind, turnId, messageId }));
+                let transcript;
+                let transcriptBootstrap = null;
+                if (input.transcript.kind === 'tail') {
+                    if (!this.#transcriptReader) {
                         return {
                             ok: false,
                             code: 'operation_unavailable',
-                            message: 'Runtime Host transcript overlay capacity reached',
+                            message: 'Session transcript is unavailable',
                         };
                     }
                     try {
-                        preparationPermit = await this.#acquireTranscriptOverlayPreparation(connection);
+                        const throughSequence = await this.#transcriptReader.readDurableHighWater(sessionId);
+                        const snapshot = projectSessionSnapshot(committed.value, identity.principalKind);
+                        const created = await createSessionTranscriptBootstrap({
+                            reader: this.#transcriptReader,
+                            sessionId,
+                            subscriptionId,
+                            throughSequence,
+                            maxBytes: input.transcript.maxBytes,
+                            projection: identity.principalKind === 'session_guest' ? 'shared' : 'owner',
+                            maxEncodedBytes: subscriptionOpenTranscriptBudget({
+                                hostEpoch: this.#hostEpoch,
+                                subscriptionId,
+                                nextSequence: 1,
+                                snapshot,
+                                activeAssistantStreams,
+                                transcript: null,
+                            }),
+                        });
+                        transcript = created.state;
+                        transcriptBootstrap = created.bootstrap;
                     }
-                    catch (acquireError) {
-                        if (acquireError instanceof TranscriptOverlayCapacityError) {
-                            retryAfterCapacity = true;
-                            continue;
-                        }
+                    catch (error) {
+                        // The client can only retry, but a projection that outgrew its
+                        // bounds is a Host defect and has to leave a trace here.
+                        this.onPublicationFailure(error);
                         return {
                             ok: false,
                             code: 'persistence_failed',
@@ -781,10 +691,88 @@ export class SessionContinuityCoordinator {
                         };
                     }
                 }
-            }
+                if (this.#connections.get(connectionId) !== connection) {
+                    this.#scheduleInactiveStateCleanup(sessionId, committed.state);
+                    throw new Error('Runtime Host connection closed during subscription open');
+                }
+                const openValue = {
+                    hostEpoch: this.#hostEpoch,
+                    subscriptionId,
+                    nextSequence: 1,
+                    snapshot: projectSessionSnapshot(committed.value, identity.principalKind),
+                    activeAssistantStreams,
+                    transcript: transcriptBootstrap,
+                };
+                if (Buffer.byteLength(JSON.stringify(openValue), 'utf8') > SUBSCRIPTION_OPEN_RESULT_MAX_BYTES) {
+                    return {
+                        ok: false,
+                        code: 'operation_unavailable',
+                        message: 'Session subscription state exceeds the transport limit',
+                    };
+                }
+                if (!this.#canObserve(identity, sessionId)) {
+                    return {
+                        ok: false,
+                        code: 'not_found',
+                        message: 'Session was not found',
+                    };
+                }
+                const subscriber = {
+                    connectionId,
+                    principalId: identity.principalId,
+                    principalKind: identity.principalKind,
+                    sessionId,
+                    subscriptionId,
+                    sink: connection.sink,
+                    phase: 'open',
+                    activated: false,
+                    nextSequence: 1,
+                    lastFlushedSequence: 0,
+                    queue: [],
+                    ptyQueue: [],
+                    ptyInterests: new Set(),
+                    ptyQueuedBytes: 0,
+                    ptyPumping: false,
+                    queuedBytes: 0,
+                    pumping: false,
+                    terminalQueued: false,
+                    assistantBacklog: new Map([...committed.state.assistantStreams.keys()].map((key) => [key, { sent: 0 }])),
+                    deferred: [],
+                    ...(transcript ? { transcript } : {}),
+                };
+                committed.state.subscribers.set(subscriptionId, subscriber);
+                this.#subscriptions.set(subscriptionId, subscriber);
+                connection.subscriptionIds.add(subscriptionId);
+                // Client expects the first delivered frame at nextSequence from the open
+                // result. Capture that before enqueueing retained previews — each
+                // #enqueue advances nextSequence.
+                const firstSequence = subscriber.nextSequence;
+                // Seed retained live previews so a mid-turn rejoin still has Open facts.
+                const rootTurn = committed.state.canonical.rootTurn;
+                if (rootTurn && !isTerminalTurn(rootTurn)) {
+                    for (const preview of committed.state.toolResultPreviews.values()) {
+                        if (preview.turnId !== rootTurn.turnId)
+                            continue;
+                        const frame = {
+                            kind: 'subscription.session_event',
+                            hostEpoch: this.#hostEpoch,
+                            subscriptionId: subscriber.subscriptionId,
+                            sequence: subscriber.nextSequence,
+                            sessionId,
+                            runId: rootTurn.runId,
+                            event: projectSessionEvent(preview, sessionId, subscriber.principalKind === 'session_guest'),
+                        };
+                        this.#enqueue(subscriber, frame);
+                    }
+                }
+                this.#payAssistantBacklog(subscriber, committed.state);
+                return {
+                    ok: true,
+                    value: { ...openValue, nextSequence: firstSequence },
+                };
+            });
         }
         finally {
-            preparationPermit?.release();
             connection.pendingOpenCount -= 1;
         }
     }
@@ -841,209 +829,6 @@ export class SessionContinuityCoordinator {
             }
         });
     }
-    #prepareTranscriptOverlay(state, sessionId, throughSequence, permit) {
-        if (!this.#transcriptReader)
-            throw new Error('Session transcript is unavailable');
-        const cached = state.transcriptOverlay;
-        if (cached?.throughSequence === throughSequence)
-            return cached;
-        if (cached)
-            this.#invalidateTranscriptOverlay(state, cached);
-        if (!state.canonical.rootTurn || isTerminalTurn(state.canonical.rootTurn)) {
-            const prepared = Promise.resolve(this.#registerTranscriptOverlay([]));
-            const entry = {
-                throughSequence,
-                prepared,
-                pendingConsumers: 0,
-                cancelPreparation: () => { },
-            };
-            state.transcriptOverlay = entry;
-            return entry;
-        }
-        if (!permit)
-            throw new TranscriptOverlayPreparationRequired();
-        const release = permit.take();
-        const prepared = (async () => {
-            try {
-                if (permit.waiter.cancelled) {
-                    throw new Error('Session transcript overlay preparation was cancelled');
-                }
-                const messages = await prepareSessionTranscriptOverlay({
-                    reader: this.#transcriptReader,
-                    sessionId,
-                    throughSequence,
-                    rootTurn: state.canonical.rootTurn,
-                    activeAssistantStreams: state.assistantStreams.values(),
-                });
-                return this.#registerTranscriptOverlay(messages);
-            }
-            finally {
-                release();
-            }
-        })();
-        const entry = {
-            throughSequence,
-            prepared,
-            pendingConsumers: 0,
-            cancelPreparation: () => this.#cancelTranscriptOverlayPreparation(permit.waiter),
-        };
-        state.transcriptOverlay = entry;
-        void prepared.catch(() => {
-            if (state.transcriptOverlay === entry)
-                state.transcriptOverlay = undefined;
-        });
-        return entry;
-    }
-    async #acquireTranscriptOverlayPreparation(connection) {
-        const ticket = this.#queueTranscriptOverlayPreparation();
-        let release;
-        try {
-            release = await Promise.race([
-                ticket.ready,
-                connection.closed.then(() => {
-                    throw new Error('Runtime Host connection closed during subscription open');
-                }),
-            ]);
-        }
-        catch (error) {
-            this.#cancelTranscriptOverlayPreparation(ticket.waiter);
-            throw error;
-        }
-        let available = true;
-        return {
-            waiter: ticket.waiter,
-            take: () => {
-                if (!available) {
-                    throw new Error('Session transcript overlay preparation permit is unavailable');
-                }
-                available = false;
-                return release;
-            },
-            release: () => {
-                if (!available)
-                    return;
-                available = false;
-                release();
-            },
-        };
-    }
-    #queueTranscriptOverlayPreparation() {
-        if (this.#transcriptOverlayPreparationWaiters.length >= MAX_TRANSCRIPT_OVERLAY_PREPARATION_WAITERS) {
-            throw new TranscriptOverlayCapacityError('Runtime Host transcript overlay preparation queue reached its limit');
-        }
-        let resolve;
-        let reject;
-        const ready = new Promise((resolveReady, rejectReady) => {
-            resolve = resolveReady;
-            reject = rejectReady;
-        });
-        const waiter = {
-            cancelled: false,
-            granted: false,
-            resolve,
-            reject,
-        };
-        this.#transcriptOverlayPreparationWaiters.push(waiter);
-        this.#drainTranscriptOverlayPreparationWaiters();
-        return { waiter, ready };
-    }
-    #releaseTranscriptOverlayPreparation() {
-        this.#preparingTranscriptOverlayBytes -= MAX_TRANSCRIPT_OVERLAY_PREPARATION_BYTES;
-        this.#drainTranscriptOverlayPreparationWaiters();
-    }
-    #drainTranscriptOverlayPreparationWaiters() {
-        if (this.#closed)
-            return;
-        while (this.#transcriptOverlayPreparationWaiters.length > 0) {
-            const waiter = this.#transcriptOverlayPreparationWaiters[0];
-            if (waiter.cancelled) {
-                this.#transcriptOverlayPreparationWaiters.shift();
-                continue;
-            }
-            if (this.#retainedTranscriptOverlayBytes + MAX_TRANSCRIPT_OVERLAY_PREPARATION_BYTES >
-                MAX_RETAINED_TRANSCRIPT_OVERLAY_BYTES) {
-                if (this.#preparingTranscriptOverlayBytes > 0)
-                    return;
-                this.#transcriptOverlayPreparationWaiters.shift();
-                waiter.cancelled = true;
-                waiter.reject(new TranscriptOverlayCapacityError('Runtime Host transcript overlay capacity reached'));
-                continue;
-            }
-            if (this.#retainedTranscriptOverlayBytes +
-                this.#preparingTranscriptOverlayBytes +
-                MAX_TRANSCRIPT_OVERLAY_PREPARATION_BYTES >
-                MAX_RETAINED_TRANSCRIPT_OVERLAY_BYTES) {
-                return;
-            }
-            this.#transcriptOverlayPreparationWaiters.shift();
-            waiter.granted = true;
-            this.#preparingTranscriptOverlayBytes += MAX_TRANSCRIPT_OVERLAY_PREPARATION_BYTES;
-            let released = false;
-            waiter.resolve(() => {
-                if (released)
-                    return;
-                released = true;
-                this.#releaseTranscriptOverlayPreparation();
-            });
-        }
-    }
-    #cancelTranscriptOverlayPreparation(waiter) {
-        if (waiter.cancelled)
-            return;
-        waiter.cancelled = true;
-        if (!waiter.granted) {
-            const index = this.#transcriptOverlayPreparationWaiters.indexOf(waiter);
-            if (index >= 0)
-                this.#transcriptOverlayPreparationWaiters.splice(index, 1);
-            waiter.reject(new Error('Session transcript overlay preparation was cancelled'));
-            this.#drainTranscriptOverlayPreparationWaiters();
-        }
-    }
-    #cancelTranscriptOverlayPreparationWaiters() {
-        for (const waiter of this.#transcriptOverlayPreparationWaiters.splice(0)) {
-            waiter.cancelled = true;
-            waiter.reject(new Error('Session continuity coordinator is closed'));
-        }
-    }
-    #registerTranscriptOverlay(messages) {
-        const bytes = messages.reduce((total, message) => total + message.byteLength, 0);
-        if (this.#retainedTranscriptOverlayBytes + bytes > MAX_RETAINED_TRANSCRIPT_OVERLAY_BYTES) {
-            throw new TranscriptOverlayCapacityError('Runtime Host transcript overlay capacity reached');
-        }
-        const retained = { messages, bytes, references: 1 };
-        this.#retainedTranscriptOverlays.set(messages, retained);
-        this.#retainedTranscriptOverlayBytes += bytes;
-        return retained;
-    }
-    #retainTranscriptOverlay(retained) {
-        if (retained.references < 1 ||
-            this.#retainedTranscriptOverlays.get(retained.messages) !== retained) {
-            throw new Error('Session transcript overlay is no longer retained');
-        }
-        retained.references += 1;
-    }
-    #releaseTranscriptOverlay(retained) {
-        if (retained.references < 1)
-            return;
-        retained.references -= 1;
-        if (retained.references > 0)
-            return;
-        this.#retainedTranscriptOverlays.delete(retained.messages);
-        this.#retainedTranscriptOverlayBytes -= retained.bytes;
-        this.#drainTranscriptOverlayPreparationWaiters();
-    }
-    #invalidateTranscriptOverlay(state, expected) {
-        const cached = state.transcriptOverlay;
-        if (!cached || (expected && cached !== expected))
-            return;
-        state.transcriptOverlay = undefined;
-        cached.cancelPreparation();
-        void cached.prepared.then((retained) => this.#releaseTranscriptOverlay(retained), () => undefined);
-    }
-    #hasTranscriptOverlayConsumer(state) {
-        return ((state.transcriptOverlay?.pendingConsumers ?? 0) > 0 ||
-            [...state.subscribers.values()].some((subscriber) => subscriber.retainedTranscriptOverlay !== undefined));
-    }
     async #refreshTranscriptHighWater(sessionId, state) {
         if (!this.#transcriptReader || state.subscribers.size === 0)
             return;
@@ -1073,6 +858,7 @@ export class SessionContinuityCoordinator {
             return;
         subscriber.activated = true;
         this.#pump(subscriber);
+        this.#pumpPty(subscriber);
     }
     #abortSubscription(connectionId, subscriptionId) {
         const subscriber = this.#ownedSubscriber(connectionId, subscriptionId);
@@ -1097,7 +883,6 @@ export class SessionContinuityCoordinator {
         const connection = this.#connections.get(connectionId);
         if (!connection)
             return;
-        connection.resolveClosed();
         for (const subscriptionId of [...connection.subscriptionIds]) {
             const subscriber = this.#ownedSubscriber(connectionId, subscriptionId);
             if (subscriber)
@@ -1164,6 +949,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;
@@ -1198,7 +1022,7 @@ export class SessionContinuityCoordinator {
     #enqueueAssistantDelta(subscriber, sessionId, runId, event, kind, startOffset) {
         this.#enqueueAssistantText(subscriber, sessionId, runId, event, kind, startOffset, event.text);
     }
-    #enqueueAssistantCompletion(subscriber, sessionId, runId, current, kind, finalText) {
+    #enqueueAssistantCompletion(subscriber, sessionId, runId, current, kind, finalText, interrupted) {
         const extendsPrefix = finalText.startsWith(current.text);
         const suffix = extendsPrefix ? finalText.slice(current.text.length) : finalText;
         if (suffix) {
@@ -1221,6 +1045,7 @@ export class SessionContinuityCoordinator {
                 text: '',
                 ...(!extendsPrefix && finalText.length === 0 ? { reset: true } : {}),
                 complete: true,
+                ...(interrupted ? { interrupted: true } : {}),
             },
         });
     }
@@ -1321,6 +1146,11 @@ export class SessionContinuityCoordinator {
                 this.#removeSubscriber(subscriber);
                 return;
             }
+            if (subscriber.assistantBacklog.size > 0) {
+                const state = this.#sessions.get(subscriber.sessionId);
+                if (state)
+                    this.#payAssistantBacklog(subscriber, state);
+            }
             this.#pump(subscriber);
         }, () => this.#removeSubscriber(subscriber));
     }
@@ -1330,33 +1160,66 @@ 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);
         this.#connections
             .get(subscriber.connectionId)
             ?.subscriptionIds.delete(subscriber.subscriptionId);
-        this.#releaseSubscriberTranscriptOverlay(subscriber);
-        if (!this.#closed && state && removed) {
-            if (!this.#hasTranscriptOverlayConsumer(state))
-                this.#invalidateTranscriptOverlay(state);
-            if (state.subscribers.size === 0) {
-                this.#scheduleInactiveStateCleanup(subscriber.sessionId, state);
+        subscriber.assistantBacklog.clear();
+        subscriber.deferred = [];
+        if (!this.#closed && state && removed && state.subscribers.size === 0) {
+            this.#scheduleInactiveStateCleanup(subscriber.sessionId, state);
+        }
+    }
+    /**
+     * Sends a subscriber the in-flight assistant text it joined too late to see,
+     * one frame at a time while its queue has room. Live deltas for such a stream
+     * are withheld until the backlog catches up, so offsets stay contiguous.
+     */
+    #payAssistantBacklog(subscriber, state) {
+        const rootTurn = state.canonical.rootTurn;
+        for (const [key, backlog] of subscriber.assistantBacklog) {
+            const { completion } = backlog;
+            const stream = completion?.stream ?? state.assistantStreams.get(key);
+            const runId = completion?.runId ?? rootTurn?.runId;
+            if (!stream || !runId || (!completion && stream.turnId !== rootTurn?.turnId)) {
+                subscriber.assistantBacklog.delete(key);
+                continue;
+            }
+            while (backlog.sent < stream.text.length) {
+                if (subscriber.phase !== 'open' ||
+                    subscriber.queue.length >= MAX_SUBSCRIBER_QUEUED_FRAMES / 2 ||
+                    subscriber.queuedBytes >= MAX_SUBSCRIBER_QUEUED_BYTES / 2) {
+                    return;
+                }
+                const chunk = stream.text.slice(backlog.sent, backlog.sent + ASSISTANT_BACKLOG_CHUNK_CHARACTERS);
+                this.#enqueueAssistantText(subscriber, subscriber.sessionId, runId, stream, stream.kind, backlog.sent, chunk);
+                backlog.sent += chunk.length;
+            }
+            subscriber.assistantBacklog.delete(key);
+            if (completion) {
+                this.#enqueueAssistantCompletion(subscriber, subscriber.sessionId, runId, stream, stream.kind, stream.text, completion.interrupted);
             }
         }
+        this.#drainDeferred(subscriber);
     }
-    #releaseSubscriberTranscriptOverlay(subscriber) {
-        if (subscriber.transcript)
-            subscriber.transcript.overlayMessages = undefined;
-        const retained = subscriber.retainedTranscriptOverlay;
-        if (!retained)
+    #completeAssistantStream(subscriber, state, runId, key, stream, finalText, interrupted) {
+        const backlog = subscriber.assistantBacklog.get(key);
+        const held = backlog ? stream.text.slice(0, backlog.sent) : stream.text;
+        if (backlog && finalText.startsWith(held)) {
+            backlog.completion = {
+                runId,
+                stream: { ...stream, text: finalText },
+                ...(interrupted ? { interrupted } : {}),
+            };
+            this.#payAssistantBacklog(subscriber, state);
             return;
-        subscriber.retainedTranscriptOverlay = undefined;
-        this.#releaseTranscriptOverlay(retained);
-        const state = this.#sessions.get(subscriber.sessionId);
-        if (state && !this.#hasTranscriptOverlayConsumer(state)) {
-            this.#invalidateTranscriptOverlay(state);
         }
+        subscriber.assistantBacklog.delete(key);
+        this.#deliverInOrder(subscriber, () => this.#enqueueAssistantCompletion(subscriber, subscriber.sessionId, runId, { ...stream, text: held }, stream.kind, finalText, interrupted));
     }
     #ownedSubscriber(connectionId, subscriptionId) {
         const connection = this.#connections.get(connectionId);
@@ -1374,7 +1237,6 @@ export class SessionContinuityCoordinator {
                 state.subscribers.size === 0 &&
                 !state.terminalPublicationFence &&
                 (!state.canonical.rootTurn || isTerminalTurn(state.canonical.rootTurn))) {
-                this.#invalidateTranscriptOverlay(state);
                 this.#sessions.delete(sessionId);
             }
         });
@@ -1437,15 +1299,36 @@ export class SessionContinuityCoordinator {
     }
     #broadcastProjection(state, snapshot) {
         for (const subscriber of state.subscribers.values()) {
-            this.#enqueue(subscriber, {
-                kind: 'subscription.session_projection',
-                hostEpoch: this.#hostEpoch,
-                subscriptionId: subscriber.subscriptionId,
-                sequence: subscriber.nextSequence,
-                snapshot: projectSessionSnapshot(snapshot, subscriber.principalKind),
+            this.#deliverInOrder(subscriber, () => {
+                this.#enqueue(subscriber, {
+                    kind: 'subscription.session_projection',
+                    hostEpoch: this.#hostEpoch,
+                    subscriptionId: subscriber.subscriptionId,
+                    sequence: subscriber.nextSequence,
+                    snapshot: projectSessionSnapshot(snapshot, subscriber.principalKind),
+                });
             });
         }
     }
+    /**
+     * Runs `work` now, or behind whatever this subscriber is still catching up
+     * on. Every assistant frame and projection goes through here, so the order a
+     * subscriber sees is the order the Host produced.
+     */
+    #deliverInOrder(subscriber, work) {
+        if (subscriber.assistantBacklog.size === 0 && subscriber.deferred.length === 0) {
+            work();
+            return;
+        }
+        subscriber.deferred.push(work);
+    }
+    #drainDeferred(subscriber) {
+        while (subscriber.assistantBacklog.size === 0 &&
+            subscriber.deferred.length > 0 &&
+            subscriber.phase === 'open') {
+            subscriber.deferred.shift()?.();
+        }
+    }
     #runInSessionLane(sessionId, operation, admission) {
         return admission
             ? this.sessionAdmission.runAdmitted(sessionId, admission, operation)
@@ -1721,21 +1604,16 @@ function toolStartShellRunRef(event) {
     if (event.toolName !== 'Read' && event.toolName !== 'StopBackgroundTask')
         return undefined;
     const ref = event.args !== null && typeof event.args === 'object'
-        ? event.args.ref
+        ? event.toolName === 'Read'
+            ? event.args.path
+            : event.args.ref
         : undefined;
     if (typeof ref !== 'string')
         return undefined;
     try {
-        return decodeRuntimeResourceRef(ref);
+        return decodeRuntimeResourceRef(resolveReadInput({ path: ref }).path);
     }
     catch {
         return undefined;
     }
 }
-function signal() {
-    let resolve;
-    const promise = new Promise((settle) => {
-        resolve = settle;
-    });
-    return { promise, resolve };
-}