@rynx-ai/server 0.1.11-beta.32 → 0.1.11-beta.34

package/dist/direct-runtime-server.js

@@ -1,7 +1,7 @@
 import { createServer, } from "node:http";
 import { decodeDirectRuntimeFrame, DIRECT_RUNTIME_CLOSE_CODE, DIRECT_RUNTIME_BROWSER_INSPECT_PATH, DIRECT_RUNTIME_BROWSER_SURFACE_PATH, DIRECT_RUNTIME_CONTROL_PATH, DIRECT_RUNTIME_MAX_HANDSHAKE_FRAME_BYTES, encodeDirectRuntimeFrame, parseServerAccepted, parseServerHello, } from "@rynx-ai/protocol/direct-runtime";
 import { createServerE2EEChannel, DIRECT_RUNTIME_E2EE_MAX_ENVELOPE_BYTES, } from "@rynx-ai/remote-runtime-e2ee";
-import { encodeRemoteRuntimeSessionEventsFrame, encodeRemoteRuntimeSessionTerminalServerFrame, encodeRemoteRuntimeRpcResponse, parseRemoteRuntimeRpcFrame, parseRemoteRuntimeSessionEventsFrame, parseRemoteRuntimeSessionTerminalClientFrame, REMOTE_RUNTIME_SESSION_TERMINAL_MAX_DATA_BYTES, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES, REMOTE_RUNTIME_RPC_MAX_ID_CHARS, REMOTE_RUNTIME_RPC_METHOD_METADATA, } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { encodeRemoteRuntimeSessionEventsFrame, encodeRemoteRuntimeSessionTerminalServerFrame, encodeRemoteRuntimeRpcResponse, parseRemoteRuntimeRpcFrame, parseRemoteRuntimeSessionEventsFrame, parseRemoteRuntimeSessionTerminalClientFrame, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES, REMOTE_RUNTIME_RPC_MAX_ID_CHARS, REMOTE_RUNTIME_RPC_METHOD_METADATA, } from "@rynx-ai/protocol/remote-runtime-rpc";
 import { encodeRuntimeEmulatorSurfaceServerFrame, parseRuntimeEmulatorSurfaceClientFrame, RUNTIME_EMULATOR_SURFACE_CHUNK_BYTES, RUNTIME_EMULATOR_SURFACE_MAX_FRAME_BYTES, } from "@rynx-ai/protocol/runtime-emulator-surface";
 import { WebSocket, WebSocketServer } from "ws";
 import { attachDirectRuntimeBrowserSurfaceServer, } from "./direct-runtime-browser-surface-server.js";
@@ -400,6 +400,9 @@ export async function startDirectRuntimeServer(options) {
             return;
         }
         if (frame.type === "session.terminal.open" ||
+            frame.type === "session.terminal.seed.read" ||
+            frame.type === "session.terminal.start" ||
+            frame.type === "session.terminal.read" ||
             frame.type === "session.terminal.input" ||
             frame.type === "session.terminal.resize" ||
             frame.type === "session.terminal.close") {
@@ -1032,66 +1035,153 @@ export async function startDirectRuntimeServer(options) {
             }
             const terminal = connection.terminal;
             if (terminal?.attachmentId === frame.attachmentId) {
-                finishTerminal(connection, terminal, "client_closed", undefined, true);
+                finishTerminal(connection, terminal, "client_closed");
             }
             else if (!connection.seenTerminalAttachmentIds.has(frame.attachmentId)) {
                 connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal attachment id is unknown");
             }
             return;
         }
-        if (frame.type === "session.terminal.input" || frame.type === "session.terminal.resize") {
-            const terminal = connection.terminal;
-            if (!terminal || terminal.attachmentId !== frame.attachmentId || terminal.finishing) {
-                connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal attachment is not active");
+        if (frame.type === "session.terminal.open") {
+            await openTerminal(connection, frame, peer);
+            return;
+        }
+        const terminal = connection.terminal;
+        if (!terminal || terminal.attachmentId !== frame.attachmentId || terminal.finishing) {
+            connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal attachment is not active");
+            return;
+        }
+        if (terminal.seenRequestIds.has(frame.requestId)) {
+            connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal request id was already used");
+            return;
+        }
+        if (terminal.seenRequestIds.size >= limits.maxRequestIds) {
+            connection.close(CLOSE_CAPACITY, "Direct Runtime terminal request id capacity reached");
+            return;
+        }
+        terminal.seenRequestIds.add(frame.requestId);
+        let active = false;
+        try {
+            active = await options.isPeerActive(peer);
+        }
+        catch (error) {
+            options.onError?.(error, "Direct Runtime terminal peer activity check");
+        }
+        if (!active) {
+            finishTerminal(connection, terminal, "unauthorized");
+            connection.close(CLOSE_UNAUTHORIZED, "Remote Runtime grant is not active");
+            return;
+        }
+        if (frame.type === "session.terminal.seed.read" || frame.type === "session.terminal.read") {
+            const kind = frame.type === "session.terminal.seed.read" ? "seed" : "live";
+            if (terminal.pendingPull ||
+                (kind === "seed" && terminal.phase !== "prepared") ||
+                (kind === "live" && terminal.phase !== "started")) {
+                connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal pull is out of order");
                 return;
             }
-            const control = terminal.controlTail.then(async () => {
-                if (terminal.finishing)
+            terminal.pendingPull = { requestId: frame.requestId, kind };
+            const reading = kind === "seed"
+                ? terminal.attachment.readSeed(frame.offset, frame.maxBytes)
+                : terminal.attachment.read(frame.offset, frame.maxBytes);
+            void reading.then(async (result) => {
+                if (terminal.finishing || terminal.pendingPull?.requestId !== frame.requestId)
                     return;
-                let active = false;
-                try {
-                    active = await options.isPeerActive(peer);
-                }
-                catch (error) {
-                    options.onError?.(error, "Direct Runtime terminal peer activity check");
-                }
-                if (!active) {
-                    finishTerminal(connection, terminal, "unauthorized", undefined, true);
-                    connection.close(CLOSE_UNAUTHORIZED, "Remote Runtime grant is not active");
-                    return;
-                }
-                try {
-                    if (frame.type === "session.terminal.input") {
-                        if (terminal.attachment.role === "owner") {
-                            await terminal.attachment.write(Uint8Array.from(Buffer.from(frame.data, "base64")));
-                        }
-                    }
-                    else {
-                        await terminal.attachment.resize(frame.cols, frame.rows);
-                    }
-                }
-                catch (error) {
-                    options.onError?.(error, "Remote Session terminal control");
-                    finishTerminal(connection, terminal, "internal", "Remote Session terminal control failed", true);
-                }
+                terminal.pendingPull = undefined;
+                await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+                    type: kind === "seed" ? "session.terminal.seed.chunk" : "session.terminal.chunk",
+                    attachmentId: terminal.attachmentId,
+                    requestId: frame.requestId,
+                    data: Buffer.from(result.data).toString("base64"),
+                    nextOffset: result.nextOffset,
+                    done: result.done,
+                    ...(result.finalOffset === undefined ? {} : { finalOffset: result.finalOffset }),
+                }), limits.maxBufferedBytes);
+            }).catch((error) => {
+                options.onError?.(error, "Remote Session terminal pull");
+                finishTerminal(connection, terminal, "internal", "Remote Session terminal pull failed");
             });
-            terminal.controlTail = control.catch(() => undefined);
-            await control;
             return;
         }
+        if (frame.type === "session.terminal.start") {
+            if (terminal.phase !== "prepared") {
+                connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal start is out of order");
+                return;
+            }
+            terminal.phase = "starting";
+            try {
+                await terminal.attachment.start();
+                terminal.phase = "started";
+                await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+                    type: "session.terminal.started",
+                    attachmentId: terminal.attachmentId,
+                    requestId: frame.requestId,
+                }), limits.maxBufferedBytes);
+                void terminal.attachment.closed.then(async (closed) => {
+                    if (terminal.finishing)
+                        return;
+                    await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+                        type: "session.terminal.reader.done",
+                        attachmentId: terminal.attachmentId,
+                        finalOffset: closed.finalOffset ?? 0,
+                        reason: closed.reason === "terminal_exited" ||
+                            closed.reason === "client_closed" ||
+                            closed.reason === "backpressure"
+                            ? closed.reason
+                            : "internal",
+                        exitCode: closed.exitCode ?? 0,
+                    }), limits.maxBufferedBytes);
+                }).catch((error) => {
+                    options.onError?.(error, "Remote Session terminal reader completion");
+                    finishTerminal(connection, terminal, "internal");
+                });
+            }
+            catch (error) {
+                options.onError?.(error, "Remote Session terminal start");
+                finishTerminal(connection, terminal, "internal", "Remote Session terminal start failed");
+            }
+            return;
+        }
+        if (terminal.phase !== "started") {
+            connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal control is not writable");
+            return;
+        }
+        const control = terminal.controlTail.then(async () => {
+            if (terminal.finishing)
+                return;
+            if (frame.type === "session.terminal.input") {
+                if (terminal.attachment.role === "owner") {
+                    await terminal.attachment.write(Uint8Array.from(Buffer.from(frame.data, "base64")));
+                }
+            }
+            else {
+                await terminal.attachment.resize(frame.cols, frame.rows);
+            }
+            await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+                type: frame.type === "session.terminal.input"
+                    ? "session.terminal.input.ack"
+                    : "session.terminal.resize.ack",
+                attachmentId: terminal.attachmentId,
+                requestId: frame.requestId,
+            }), limits.maxBufferedBytes);
+        });
+        terminal.controlTail = control.catch(() => undefined);
+        await control.catch((error) => {
+            options.onError?.(error, "Remote Session terminal control");
+            finishTerminal(connection, terminal, "internal", "Remote Session terminal control failed");
+        });
+    }
+    async function openTerminal(connection, frame, peer) {
         let admissionFailure;
         let pending;
-        if (connection.seenTerminalAttachmentIds.has(frame.attachmentId)) {
+        if (connection.seenTerminalAttachmentIds.has(frame.attachmentId))
             admissionFailure = "duplicate";
-        }
-        else if (connection.seenTerminalAttachmentIds.size >= limits.maxRequestIds) {
+        else if (connection.seenTerminalAttachmentIds.size >= limits.maxRequestIds)
             admissionFailure = "id_capacity";
-        }
         else {
             connection.seenTerminalAttachmentIds.add(frame.attachmentId);
-            if (connection.pendingTerminal || connection.terminal) {
+            if (connection.pendingTerminal || connection.terminal)
                 admissionFailure = "attachment_capacity";
-            }
             else {
                 pending = {
                     attachmentId: frame.attachmentId,
@@ -1100,32 +1190,9 @@ export async function startDirectRuntimeServer(options) {
                     cancelRequested: false,
                     closeFrameClaimed: false,
                 };
-                // Reserve the id before awaiting peer status or application open. A
-                // following close can now tombstone this pending attach and abort it.
                 connection.pendingTerminal = pending;
             }
         }
-        let active = false;
-        try {
-            active = await options.isPeerActive(peer);
-        }
-        catch (error) {
-            options.onError?.(error, "Direct Runtime terminal peer activity check");
-        }
-        if (!active) {
-            if (pending) {
-                connection.pendingTerminal = undefined;
-                pending.cancelRequested = true;
-                pending.abortController.abort(new Error("Remote Runtime grant is not active"));
-            }
-            if (!pending?.closeFrameClaimed) {
-                if (pending)
-                    pending.closeFrameClaimed = true;
-                await sendTerminalClosed(connection, frame.attachmentId, "unauthorized");
-            }
-            connection.close(CLOSE_UNAUTHORIZED, "Remote Runtime grant is not active");
-            return;
-        }
         if (admissionFailure === "duplicate") {
             await sendTerminalClosed(connection, frame.attachmentId, "capacity", "Remote Session terminal attachment id was already used");
             return;
@@ -1135,13 +1202,28 @@ export async function startDirectRuntimeServer(options) {
             return;
         }
         if (admissionFailure === "attachment_capacity") {
-            await sendTerminalClosed(connection, frame.attachmentId, "capacity", "Direct Runtime V1 admits one Session terminal per connection");
+            await sendTerminalClosed(connection, frame.attachmentId, "capacity", "Direct Runtime admits one Session terminal per connection");
             return;
         }
         if (!pending) {
             connection.close(CLOSE_INTERNAL, "Remote Session pending terminal is unavailable");
             return;
         }
+        let active = false;
+        try {
+            active = await options.isPeerActive(peer);
+        }
+        catch (error) {
+            options.onError?.(error, "Direct Runtime terminal peer activity check");
+        }
+        if (!active) {
+            connection.pendingTerminal = undefined;
+            pending.cancelRequested = true;
+            pending.abortController.abort(new Error("Remote Runtime grant is not active"));
+            await sendTerminalClosed(connection, frame.attachmentId, "unauthorized");
+            connection.close(CLOSE_UNAUTHORIZED, "Remote Runtime grant is not active");
+            return;
+        }
         let opened;
         try {
             opened = await options.dispatcher.openSessionTerminal(frame.sessionId, { role: frame.role, cols: frame.cols, rows: frame.rows }, { subject: peer.subject, signal: pending.abortController.signal });
@@ -1160,14 +1242,10 @@ export async function startDirectRuntimeServer(options) {
             await sendTerminalClosed(connection, frame.attachmentId, remoteTerminalOpenCloseReason(error));
             return;
         }
-        if (pending.cancelRequested ||
-            isConnectionClosed(connection) ||
-            connection.pendingTerminal !== pending) {
+        if (pending.cancelRequested || isConnectionClosed(connection) || connection.pendingTerminal !== pending) {
             if (connection.pendingTerminal === pending)
                 connection.pendingTerminal = undefined;
-            await opened.close().catch((error) => {
-                options.onError?.(error, "Remote Session late terminal detach");
-            });
+            await opened.close().catch(() => undefined);
             if (!pending.closeFrameClaimed && !isConnectionClosed(connection)) {
                 pending.closeFrameClaimed = true;
                 await sendTerminalClosed(connection, frame.attachmentId, "client_closed");
@@ -1184,86 +1262,40 @@ export async function startDirectRuntimeServer(options) {
             attachmentId: frame.attachmentId,
             sessionId: frame.sessionId,
             attachment: opened,
-            output: new BoundedTextQueue(limits.maxQueuedTerminalOutputFrames, limits.maxQueuedTerminalOutputBytes),
+            seenRequestIds: new Set(),
+            phase: "prepared",
             controlTail: Promise.resolve(),
             finishing: false,
         };
         connection.pendingTerminal = undefined;
         connection.terminal = terminal;
-        // Drain into the bounded application queue before awaiting the opened send;
-        // output can begin synchronously with the runner attach.
-        void readTerminalOutput(connection, terminal);
-        try {
-            await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
-                type: "session.terminal.opened",
-                attachmentId: terminal.attachmentId,
-                sessionId: terminal.sessionId,
-                role: opened.role,
-            }), limits.maxBufferedBytes);
-            void writeTerminalOutput(connection, terminal);
-        }
-        catch (error) {
-            finishTerminal(connection, terminal, undefined, undefined, true);
-            throw error;
-        }
-    }
-    async function readTerminalOutput(connection, terminal) {
-        try {
-            for await (const data of terminal.attachment) {
-                if (terminal.finishing)
-                    return;
-                for (let offset = 0; offset < data.byteLength; offset += REMOTE_RUNTIME_SESSION_TERMINAL_MAX_DATA_BYTES) {
-                    const chunk = data.subarray(offset, Math.min(offset + REMOTE_RUNTIME_SESSION_TERMINAL_MAX_DATA_BYTES, data.byteLength));
-                    if (chunk.byteLength === 0)
-                        continue;
-                    const encoded = encodeRemoteRuntimeSessionTerminalServerFrame({
-                        type: "session.terminal.output",
-                        attachmentId: terminal.attachmentId,
-                        data: Buffer.from(chunk).toString("base64"),
-                    });
-                    if (!terminal.output.push(encoded)) {
-                        finishTerminal(connection, terminal, "backpressure", "Remote Session terminal consumer is too slow", true);
-                        return;
-                    }
-                }
-            }
-            if (terminal.finishing)
+        let lastDimensions = opened.dimensions;
+        opened.onResize?.(({ cols, rows }) => {
+            if (terminal.finishing || terminal.phase !== "started")
                 return;
-            const closed = await terminal.attachment.closed;
-            const reason = closed.reason === "terminal_exited"
-                ? "terminal_exited"
-                : closed.reason === "backpressure"
-                    ? "backpressure"
-                    : "internal";
-            finishTerminal(connection, terminal, reason, undefined, reason !== "terminal_exited", closed.exitCode);
-        }
-        catch (error) {
-            if (terminal.finishing)
+            if (lastDimensions?.cols === cols && lastDimensions.rows === rows)
                 return;
-            options.onError?.(error, "Remote Session terminal output");
-            finishTerminal(connection, terminal, "internal", "Remote Session terminal output failed", true);
-        }
-    }
-    async function writeTerminalOutput(connection, terminal) {
-        try {
-            for (;;) {
-                const frame = await terminal.output.shift();
-                if (frame === undefined)
-                    return;
-                await sendText(connection, frame, limits.maxBufferedBytes);
-            }
-        }
-        catch (error) {
-            if (!isConnectionClosed(connection)) {
-                options.onError?.(error, "Remote Session terminal delivery");
-                connection.close(CLOSE_INTERNAL, "Remote Session terminal delivery failed");
-            }
-        }
-        finally {
-            finishTerminal(connection, terminal, undefined, undefined, true);
-        }
+            lastDimensions = { cols, rows };
+            void sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+                type: "session.terminal.dimensions",
+                attachmentId: terminal.attachmentId,
+                cols,
+                rows,
+            }), limits.maxBufferedBytes).catch((error) => {
+                options.onError?.(error, "Remote Session terminal dimensions");
+                finishTerminal(connection, terminal, "internal");
+            });
+        });
+        await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+            type: "session.terminal.prepared",
+            attachmentId: terminal.attachmentId,
+            sessionId: terminal.sessionId,
+            role: opened.role,
+            seedBytes: opened.seedBytes,
+            ...(opened.dimensions ?? {}),
+        }), limits.maxBufferedBytes);
     }
-    function finishTerminal(connection, terminal, reason, message, discardPending, exitCode) {
+    function finishTerminal(connection, terminal, reason, message, exitCode) {
         if (terminal.finishing)
             return;
         terminal.finishing = true;
@@ -1272,19 +1304,17 @@ export async function startDirectRuntimeServer(options) {
         void terminal.attachment.close().catch((error) => {
             options.onError?.(error, "Remote Session terminal detach");
         });
-        const finalFrame = reason === undefined
-            ? undefined
-            : encodeRemoteRuntimeSessionTerminalServerFrame({
+        if (reason !== undefined && !isConnectionClosed(connection)) {
+            void sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
                 type: "session.terminal.closed",
                 attachmentId: terminal.attachmentId,
                 reason,
                 ...(exitCode === undefined ? {} : { exitCode }),
                 ...(message === undefined ? {} : { message }),
+            }), limits.maxBufferedBytes).catch((error) => {
+                options.onError?.(error, "Remote Session terminal close delivery");
             });
-        if (discardPending)
-            terminal.output.replaceAndFinish(finalFrame);
-        else
-            terminal.output.finish(finalFrame);
+        }
     }
     async function sendTerminalClosed(connection, attachmentId, reason, message) {
         await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
@@ -1336,6 +1366,7 @@ export async function startDirectRuntimeServer(options) {
             const accepted = parseServerAccepted(result.accepted);
             assertAuthenticationResult(serverHello, authenticate, result.peer, accepted);
             connection.peer = result.peer;
+            connection.coreProtocolVersion = accepted.coreProtocolVersion;
             const registration = connectionHub.registerWithinLimit(result.peer.grantId, connection, limits.maxConnectionsPerGrant);
             if (registration === "revoked") {
                 connection.close(CLOSE_UNAUTHORIZED, "Remote Runtime grant is not active");
@@ -1385,7 +1416,7 @@ export async function startDirectRuntimeServer(options) {
             connection.pendingTerminal = undefined;
         }
         if (connection.terminal) {
-            finishTerminal(connection, connection.terminal, undefined, undefined, true);
+            finishTerminal(connection, connection.terminal, undefined);
         }
         finalizeConnectionEmulatorSurface(connection, reason);
         if (connection.ws.readyState === WebSocket.OPEN) {
@@ -1422,7 +1453,7 @@ export async function startDirectRuntimeServer(options) {
             connection.pendingTerminal = undefined;
         }
         if (connection.terminal) {
-            finishTerminal(connection, connection.terminal, undefined, undefined, true);
+            finishTerminal(connection, connection.terminal, undefined);
         }
         finalizeConnectionEmulatorSurface(connection, "Direct Runtime connection closed");
         releaseUnauthenticatedConnection(connection);
@@ -1559,6 +1590,9 @@ function parseAuthenticatedClientFrame(bytes) {
         return frame;
     }
     if (type === "session.terminal.open" ||
+        type === "session.terminal.seed.read" ||
+        type === "session.terminal.start" ||
+        type === "session.terminal.read" ||
         type === "session.terminal.input" ||
         type === "session.terminal.resize" ||
         type === "session.terminal.close") {

package/dist/machine-session-service.d.ts

@@ -285,7 +285,9 @@ export interface MachineSessionMessageInput {
     execution?: MachineSessionRunExecutionSelection;
 }
 export interface StartedMachineSessionRun {
-    responseId: string;
+    /** Native identity when admission can return it synchronously. Transcript-
+     * backed runtimes publish it later on the canonical event stream. */
+    responseId?: string;
     provider: SessionProviderId;
     model: string | null;
     authSource: AuditAuthSource;

package/dist/machine-session-service.js

@@ -529,21 +529,19 @@ export class MachineSessionService {
                 const result = await this.sendMessageAdmitted(sessionId, messageInput, options.signal, activateTurn, true, options.collaborationMode
                     ? { collaborationMode: options.collaborationMode }
                     : undefined);
-                if (!result.responseId) {
-                    throw new MachineSessionServiceFailure("outcome_unknown", "run was already accepted but its response stream is unavailable");
-                }
-                const responseId = result.responseId;
-                const replayItems = result.replayed
-                    ? (await this.ports.log.snapshot(sessionId)).filter((item) => item.responseId === responseId)
+                const initialResponseId = result.responseId;
+                const pendingId = result.pendingId;
+                const replayItems = result.replayed && initialResponseId
+                    ? (await this.ports.log.snapshot(sessionId)).filter((item) => item.responseId === initialResponseId)
                     : [];
                 const replayedItemIds = new Set(replayItems.map((item) => item.id));
-                const replayWasActive = this.ports.runtimeState
-                    .snapshot(sessionId)
-                    .activeResponseIds.includes(responseId);
-                if (result.replayed && !replayWasActive) {
+                const replayWasActive = initialResponseId
+                    ? this.ports.runtimeState.snapshot(sessionId).activeResponseIds.includes(initialResponseId)
+                    : false;
+                if (result.replayed && initialResponseId && !replayWasActive) {
                     throw new MachineSessionServiceFailure("outcome_unknown", "run was already accepted but its terminal event is no longer available");
                 }
-                if (result.replayed) {
+                if (result.replayed && (initialResponseId || pendingId)) {
                     activateTurn();
                     if (options.signal?.aborted) {
                         await this.ports.interruption.interrupt(sessionId).catch(() => false);
@@ -555,9 +553,32 @@ export class MachineSessionService {
                     reasoningEffort: meta.execution.reasoningEffort,
                 };
                 const model = runExecution.model;
+                // After a daemon restart an already-injected transcript-backed
+                // operation has neither a process-live pending id nor a replayable
+                // response id. Its delivery is still successful and must never be
+                // repeated. End this caller's projection without claiming a different
+                // future Turn; the transcript remains independently visible on the
+                // Session stream.
+                if (result.replayed && !initialResponseId && !pendingId) {
+                    options.signal?.removeEventListener("abort", interrupt);
+                    await subscription.return?.();
+                    const provider = meta.execution.provider;
+                    return {
+                        provider,
+                        model: runExecution.model,
+                        authSource: provider === "traex"
+                            ? "traex_cli"
+                            : provider === "claude"
+                                ? "claude_cli"
+                                : "codex_cli",
+                        generator: (async function* () { })(),
+                    };
+                }
                 const generator = (async function* () {
+                    let responseId = initialResponseId;
+                    const beforeIdentity = new Map();
                     try {
-                        if (result.replayed) {
+                        if (result.replayed && responseId) {
                             yield {
                                 type: "response.created",
                                 sessionId,
@@ -572,13 +593,39 @@ export class MachineSessionService {
                             if (next.done)
                                 return;
                             const event = next.value;
+                            if (!responseId) {
+                                const eventResponseId = sessionEventResponseId(event);
+                                if (eventResponseId) {
+                                    const buffered = beforeIdentity.get(eventResponseId) ?? [];
+                                    buffered.push(event);
+                                    beforeIdentity.set(eventResponseId, buffered);
+                                }
+                                const lateResponseId = pendingId
+                                    ? responseIdForClearedPending(event, pendingId)
+                                    : event.type === "response.created"
+                                        ? event.responseId
+                                        : undefined;
+                                if (!lateResponseId)
+                                    continue;
+                                responseId = lateResponseId;
+                                for (const buffered of beforeIdentity.get(responseId) ?? []) {
+                                    const itemId = sessionEventItemId(buffered);
+                                    if (itemId && replayedItemIds.has(itemId))
+                                        continue;
+                                    yield buffered;
+                                    if (isTerminalResponseEvent(buffered))
+                                        return;
+                                }
+                                beforeIdentity.clear();
+                                continue;
+                            }
                             if (sessionEventResponseId(event) !== responseId)
                                 continue;
                             const itemId = sessionEventItemId(event);
                             if (itemId && replayedItemIds.has(itemId))
                                 continue;
                             yield event;
-                            if (event.type === "response.completed" || event.type === "response.failed")
+                            if (isTerminalResponseEvent(event))
                                 return;
                         }
                     }
@@ -590,7 +637,7 @@ export class MachineSessionService {
                 })();
                 const provider = meta.execution.provider;
                 return {
-                    responseId,
+                    ...(initialResponseId ? { responseId: initialResponseId } : {}),
                     provider,
                     model: runExecution.model,
                     authSource: provider === "traex"
@@ -1534,6 +1581,16 @@ function sessionEventItemId(event) {
         ? event.item.id
         : undefined;
 }
+function responseIdForClearedPending(event, pendingId) {
+    return event.type === "session.input.consumed" && event.clearedPendingId === pendingId
+        ? event.item.responseId
+        : undefined;
+}
+function isTerminalResponseEvent(event) {
+    return event.type === "response.completed" ||
+        event.type === "response.failed" ||
+        event.type === "session.interrupted";
+}
 function replaySessionItem(item) {
     if (item.type === "message" && item.data.role === "user") {
         return { type: "session.input.consumed", item };