@markusylisiurunen/tau 0.3.34 → 0.3.35

package/dist/host/session_protocol_handler.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { createSessionProtocolErrorResponse, createSessionProtocolPendingUserMessagesMessage, createSessionProtocolReadyMessage, createSessionProtocolSuccessResponse, SESSION_PROTOCOL_ERROR_CODES, SESSION_PROTOCOL_METHODS, SESSION_PROTOCOL_VERSION, } from "../protocol/session_protocol.js";
-import { EphemeralThreadBusyError, SessionExecBusyError, } from "./session_host.js";
+import { EphemeralThreadBusyError, SessionExecBusyError, SessionRetryUnavailableError, } from "./session_host.js";
 function isAbortError(error) {
     return error instanceof Error && error.name === "AbortError";
 }
@@ -12,29 +12,30 @@ function getSessionLiveState(session) {
         state = {
             interrupting: false,
             revision: 1,
-            pendingSteeringSubmits: [],
-            pendingQueuedSubmits: [],
+            pendingSubmissions: [],
             listeners: new Set(),
         };
         sessionLiveStates.set(session, state);
     }
     return state;
 }
+function pendingSubmissionsInDeliveryOrder(state) {
+    return [
+        ...state.pendingSubmissions.filter((pending) => pending.delivery === "turn-boundary"),
+        ...state.pendingSubmissions.filter((pending) => pending.delivery === "when-idle"),
+    ];
+}
+function toPendingUserMessage(pending) {
+    return {
+        id: pending.id,
+        mode: pending.request.method === "session.queue" ? "queue" : "steer",
+        text: pending.request.params.text,
+    };
+}
 function buildPendingUserMessagesState(state) {
     return {
         revision: state.revision,
-        messages: [
-            ...state.pendingSteeringSubmits.map((pending) => ({
-                id: pending.id,
-                mode: pending.mode,
-                text: pending.request.params.text,
-            })),
-            ...state.pendingQueuedSubmits.map((pending) => ({
-                id: pending.id,
-                mode: pending.mode,
-                text: pending.request.params.text,
-            })),
-        ],
+        messages: pendingSubmissionsInDeliveryOrder(state).map(toPendingUserMessage),
     };
 }
 function publishPendingUserMessages(session, state) {
@@ -44,7 +45,12 @@ function publishPendingUserMessages(session, state) {
         state: buildPendingUserMessagesState(state),
     });
     for (const listener of [...state.listeners]) {
-        listener(message);
+        try {
+            listener(message);
+        }
+        catch {
+            // Pending-message observers must not be able to fail shared session work.
+        }
     }
 }
 function getSessionMutationQueueState(session) {
@@ -124,6 +130,15 @@ export class SessionProtocolHandler {
                 case "session.snapshot":
                     await this.handleSnapshot(request);
                     return;
+                case "session.startGoal":
+                    await this.handleStartGoal(request);
+                    return;
+                case "session.resumeGoal":
+                    await this.handleResumeGoal(request);
+                    return;
+                case "session.clearGoal":
+                    await this.handleClearGoal(request);
+                    return;
                 case "session.setReasoning":
                     await this.handleSetReasoning(request);
                     return;
@@ -239,33 +254,15 @@ export class SessionProtocolHandler {
         this.sendMessage(createSessionProtocolSuccessResponse(request.id, "session.clientTool.result", { accepted }));
     }
     async handleSubmit(request) {
-        const state = await this.getSessionState(request.params.sessionId);
-        if (!state) {
-            this.sendSessionNotFound(request.id, request.params.sessionId);
-            return;
-        }
-        if (this.getPendingMutationCount(state) > 0) {
-            this.sendSubmitBusy(state, request.id);
-            return;
-        }
-        const startedSubmit = await this.enqueueMutation(state, () => this.startUserMessageTurn(state, request));
-        if (!startedSubmit) {
-            return;
-        }
-        const { activeSubmit } = startedSubmit;
-        try {
-            await activeSubmit.promise;
-        }
-        finally {
-            await this.enqueueMutation(state, () => {
-                if (state.live.activeSubmit === activeSubmit) {
-                    state.live.activeSubmit = undefined;
-                }
-            });
-            this.schedulePendingSubmitDrains(state);
-        }
+        await this.handleUserSubmission(request);
     }
     async handleQueue(request) {
+        await this.handleUserSubmission(request);
+    }
+    async handleSteer(request) {
+        await this.handleUserSubmission(request);
+    }
+    async handleUserSubmission(request) {
         const state = await this.getSessionState(request.params.sessionId);
         if (!state) {
             this.sendSessionNotFound(request.id, request.params.sessionId);
@@ -275,128 +272,103 @@ export class SessionProtocolHandler {
             this.sendSubmitBusy(state, request.id);
             return;
         }
-        const startedSubmit = await this.enqueueMutation(state, () => {
-            if (state.live.activeSubmit || state.session.isTurnRunning) {
-                state.live.pendingQueuedSubmits.push({
-                    id: randomUUID(),
-                    mode: "queue",
-                    handler: this,
-                    request,
-                });
-                publishPendingUserMessages(state.session, state.live);
-                return undefined;
-            }
-            return this.startUserMessageTurn(state, request);
-        });
-        if (!startedSubmit) {
+        const action = await this.enqueueMutation(state, () => this.dispatchUserSubmission(state, request));
+        if (action.type === "busy") {
+            this.sendSubmitBusy(state, request.id);
             return;
         }
-        const { activeSubmit } = startedSubmit;
-        try {
-            await activeSubmit.promise;
-        }
-        finally {
-            await this.enqueueMutation(state, () => {
-                if (state.live.activeSubmit === activeSubmit) {
-                    state.live.activeSubmit = undefined;
-                }
-            });
-            this.schedulePendingSubmitDrains(state);
-        }
-    }
-    async handleSteer(request) {
-        const state = await this.getSessionState(request.params.sessionId);
-        if (!state) {
-            this.sendSessionNotFound(request.id, request.params.sessionId);
+        if (action.type === "pending") {
             return;
         }
-        if (this.getPendingMutationCount(state) > 0) {
-            this.sendSubmitBusy(state, request.id);
+        if (action.type === "started") {
+            await this.finishActiveSubmit(state, action.activeSubmit);
             return;
         }
-        const action = await this.enqueueMutation(state, async () => {
+        await this.finishBoundarySteering(state, action.pending, action.submission);
+    }
+    async dispatchUserSubmission(state, request) {
+        if (request.method === "session.steer") {
             if (state.live.interrupting) {
                 return { type: "busy" };
             }
-            if (state.session.isTurnRunning) {
+            if (state.session.canAcceptSteering) {
                 const submission = state.session.steer(request.params.text);
                 const pending = {
                     id: randomUUID(),
-                    mode: "steer",
+                    delivery: "turn-boundary",
                     steeringId: submission.id,
                     handler: this,
                     request,
                 };
-                state.live.pendingSteeringSubmits.push(pending);
-                publishPendingUserMessages(state.session, state.live);
-                return { type: "steer", pending, submission };
-            }
-            if (state.live.activeSubmit) {
-                state.live.pendingQueuedSubmits.push({
-                    id: randomUUID(),
-                    mode: "steer",
-                    handler: this,
-                    request,
-                });
-                publishPendingUserMessages(state.session, state.live);
-                return { type: "queued" };
+                this.addPendingSubmission(state, pending);
+                return { type: "boundary", pending, submission };
             }
-            return {
-                type: "submit",
-                started: await this.startUserMessageTurn(state, request),
-            };
-        });
-        if (action.type === "busy") {
-            this.sendSubmitBusy(state, request.id);
-            return;
         }
-        if (action.type === "queued") {
-            return;
-        }
-        if (action.type === "submit") {
-            const started = await action.started;
-            if (!started)
-                return;
-            try {
-                await started.activeSubmit.promise;
-            }
-            finally {
-                await this.enqueueMutation(state, () => {
-                    if (state.live.activeSubmit === started.activeSubmit) {
-                        state.live.activeSubmit = undefined;
-                    }
-                });
-                this.schedulePendingSubmitDrains(state);
+        if (state.live.activeSubmit || state.session.isTurnRunning) {
+            if (request.method === "session.submit") {
+                return { type: "busy" };
             }
-            return;
+            const pending = {
+                id: randomUUID(),
+                delivery: "when-idle",
+                handler: this,
+                request,
+            };
+            this.addPendingSubmission(state, pending);
+            return { type: "pending" };
         }
+        return {
+            type: "started",
+            activeSubmit: await this.startUserMessageTurn(state, request),
+        };
+    }
+    async finishBoundarySteering(state, pending, submission) {
         let applied = false;
-        void action.submission.result.catch(() => { });
+        void submission.result.catch(() => { });
         try {
-            await action.submission.applied;
+            await submission.applied;
             applied = true;
-            await this.enqueueMutation(state, () => {
-                const index = state.live.pendingSteeringSubmits.indexOf(action.pending);
-                if (index >= 0)
-                    state.live.pendingSteeringSubmits.splice(index, 1);
-                publishPendingUserMessages(state.session, state.live);
-            });
-            const result = await action.submission.result;
-            this.sendMessage(createSessionProtocolSuccessResponse(request.id, "session.steer", result));
+            await this.enqueueMutation(state, () => this.removePendingSubmission(state, pending));
+            const result = await submission.result;
+            this.sendMessage(createSessionProtocolSuccessResponse(pending.request.id, "session.steer", result));
         }
         catch (error) {
-            if (applied || state.live.pendingSteeringSubmits.includes(action.pending)) {
-                this.sendMessage(createSessionProtocolErrorResponse(request.id, SESSION_PROTOCOL_ERROR_CODES.internalError, "steering turn failed", { cause: error instanceof Error ? error.message : String(error) }));
+            if (applied || state.live.pendingSubmissions.includes(pending)) {
+                this.sendMessage(createSessionProtocolErrorResponse(pending.request.id, SESSION_PROTOCOL_ERROR_CODES.internalError, "steering turn failed", { cause: error instanceof Error ? error.message : String(error) }));
             }
         }
+        finally {
+            await this.enqueueMutation(state, () => this.removePendingSubmission(state, pending));
+        }
+    }
+    addPendingSubmission(state, pending) {
+        state.live.pendingSubmissions.push(pending);
+        publishPendingUserMessages(state.session, state.live);
+    }
+    removePendingSubmission(state, pending) {
+        return this.removePendingSubmissions(state, [pending]);
+    }
+    removePendingSubmissions(state, pending) {
+        const removed = new Set(pending);
+        const remaining = state.live.pendingSubmissions.filter((submission) => !removed.has(submission));
+        if (remaining.length === state.live.pendingSubmissions.length) {
+            return false;
+        }
+        state.live.pendingSubmissions = remaining;
+        publishPendingUserMessages(state.session, state.live);
+        return true;
+    }
+    async finishActiveSubmit(state, activeSubmit) {
+        try {
+            await activeSubmit.promise;
+        }
         finally {
             await this.enqueueMutation(state, () => {
-                const index = state.live.pendingSteeringSubmits.indexOf(action.pending);
-                if (index >= 0) {
-                    state.live.pendingSteeringSubmits.splice(index, 1);
-                    publishPendingUserMessages(state.session, state.live);
+                if (state.live.activeSubmit === activeSubmit) {
+                    state.live.activeSubmit = undefined;
                 }
             });
+            this.schedulePendingSubmissionDrain(state);
         }
     }
     async handleCancelPendingMessages(request) {
@@ -407,21 +379,15 @@ export class SessionProtocolHandler {
         }
         const cancelled = await this.enqueueMutation(state, () => {
             const cancelledSteeringIds = new Set(state.session.cancelSteering().map((submission) => submission.id));
-            const cancelledSteering = state.live.pendingSteeringSubmits.filter((pending) => cancelledSteeringIds.has(pending.steeringId));
-            state.live.pendingSteeringSubmits = state.live.pendingSteeringSubmits.filter((pending) => !cancelledSteeringIds.has(pending.steeringId));
-            const pending = [...cancelledSteering, ...state.live.pendingQueuedSubmits.splice(0)];
+            const pending = pendingSubmissionsInDeliveryOrder(state.live).filter((submission) => submission.delivery === "when-idle" || cancelledSteeringIds.has(submission.steeringId));
             if (pending.length === 0) {
                 return [];
             }
-            publishPendingUserMessages(state.session, state.live);
+            this.removePendingSubmissions(state, pending);
             for (const item of pending) {
                 item.handler.sendMessage(createSessionProtocolErrorResponse(item.request.id, SESSION_PROTOCOL_ERROR_CODES.cancelled, "pending user message was cancelled"));
             }
-            return pending.map((item) => ({
-                id: item.id,
-                mode: item.mode,
-                text: item.request.params.text,
-            }));
+            return pending.map(toPendingUserMessage);
         });
         this.sendMessage(createSessionProtocolSuccessResponse(request.id, "session.cancelPendingMessages", {
             cancelled,
@@ -489,21 +455,9 @@ export class SessionProtocolHandler {
             this.sendSubmitBusy(state, request.id);
             return;
         }
-        const startedRetry = await this.enqueueMutation(state, () => this.startRetry(state, request));
-        if (!startedRetry) {
-            return;
-        }
-        const { activeSubmit } = startedRetry;
-        try {
-            await activeSubmit.promise;
-        }
-        finally {
-            await this.enqueueMutation(state, () => {
-                if (state.live.activeSubmit === activeSubmit) {
-                    state.live.activeSubmit = undefined;
-                }
-            });
-            this.schedulePendingSubmitDrains(state);
+        const activeSubmit = await this.enqueueMutation(state, () => this.startRetry(state, request));
+        if (activeSubmit) {
+            await this.finishActiveSubmit(state, activeSubmit);
         }
     }
     async handleCreate(request) {
@@ -584,10 +538,6 @@ export class SessionProtocolHandler {
         });
     }
     async startUserMessageTurn(state, request) {
-        if (state.live.activeSubmit || state.session.isTurnRunning) {
-            this.sendSubmitBusy(state, request.id);
-            return undefined;
-        }
         const addOptions = request.method !== "session.steer" && request.params.historyEntryId
             ? { historyEntryId: request.params.historyEntryId }
             : undefined;
@@ -595,67 +545,59 @@ export class SessionProtocolHandler {
             text: request.params.text,
             ...(addOptions ? { historyEntryId: addOptions.historyEntryId } : {}),
         });
-        const submitPromise = this.executeSubmit(state, request.id, request.method, userHistoryEntryId);
-        const activeSubmit = { requestId: request.id, promise: submitPromise };
-        state.live.activeSubmit = activeSubmit;
-        return {
-            activeSubmit,
+        const activeSubmit = {
+            promise: this.executeSubmit(state, request.id, request.method, userHistoryEntryId),
         };
+        state.live.activeSubmit = activeSubmit;
+        return activeSubmit;
     }
     startRetry(state, request) {
         if (state.live.activeSubmit || state.session.isTurnRunning) {
             this.sendSubmitBusy(state, request.id);
             return undefined;
         }
-        const retryPromise = this.executeRetry(state, request.id);
-        const activeSubmit = { requestId: request.id, promise: retryPromise };
-        state.live.activeSubmit = activeSubmit;
-        return {
-            activeSubmit,
+        const activeSubmit = {
+            promise: this.executeRetry(state, request.id),
         };
+        state.live.activeSubmit = activeSubmit;
+        return activeSubmit;
     }
-    schedulePendingSubmitDrains(state) {
-        void this.drainPendingQueuedSubmits(state).catch((error) => {
-            this.failPendingUserMessageRequests(state, error);
+    schedulePendingSubmissionDrain(state) {
+        void this.drainPendingIdleSubmissions(state).catch((error) => {
+            this.failPendingIdleSubmissions(state, error);
         });
     }
-    async drainPendingQueuedSubmits(state) {
-        const next = await this.enqueueMutation(state, async () => {
-            if (state.live.pendingQueuedSubmits.length === 0 ||
-                state.live.activeSubmit ||
-                state.session.isTurnRunning) {
-                return undefined;
+    async drainPendingIdleSubmissions(state) {
+        const action = await this.enqueueMutation(state, async () => {
+            const pendingIndex = state.live.pendingSubmissions.findIndex((pending) => pending.delivery === "when-idle");
+            if (pendingIndex < 0 || state.live.activeSubmit || state.session.isTurnRunning) {
+                return { type: "idle" };
             }
-            const pending = state.live.pendingQueuedSubmits.shift();
+            const [pending] = state.live.pendingSubmissions.splice(pendingIndex, 1);
             publishPendingUserMessages(state.session, state.live);
             try {
-                return await pending.handler.startUserMessageTurn(state, pending.request);
+                return {
+                    type: "started",
+                    activeSubmit: await pending.handler.startUserMessageTurn(state, pending.request),
+                };
             }
             catch (error) {
                 this.sendUserMessageDrainFailure([pending], error);
-                return undefined;
+                return { type: "failed", error };
             }
         });
-        if (!next) {
+        if (action.type === "idle") {
             return;
         }
-        try {
-            await next.activeSubmit.promise;
-        }
-        finally {
-            await this.enqueueMutation(state, () => {
-                if (state.live.activeSubmit === next.activeSubmit) {
-                    state.live.activeSubmit = undefined;
-                }
-            });
-            this.schedulePendingSubmitDrains(state);
+        if (action.type === "failed") {
+            this.failPendingIdleSubmissions(state, action.error);
+            return;
         }
+        await this.finishActiveSubmit(state, action.activeSubmit);
     }
-    failPendingUserMessageRequests(state, error) {
-        const pending = state.live.pendingQueuedSubmits.splice(0);
-        if (pending.length > 0) {
-            publishPendingUserMessages(state.session, state.live);
-        }
+    failPendingIdleSubmissions(state, error) {
+        const pending = state.live.pendingSubmissions.filter((submission) => submission.delivery === "when-idle");
+        this.removePendingSubmissions(state, pending);
         this.sendUserMessageDrainFailure(pending, error);
     }
     sendUserMessageDrainFailure(requests, error) {
@@ -663,7 +605,7 @@ export class SessionProtocolHandler {
             handler.sendMessage(createSessionProtocolErrorResponse(request.id, SESSION_PROTOCOL_ERROR_CODES.internalError, "failed to drain pending user message", { cause: error instanceof Error ? error.message : String(error) }));
         }
     }
-    async executeSubmit(state, requestId, method, userHistoryEntryId, responseRequests) {
+    async executeSubmit(state, requestId, method, userHistoryEntryId) {
         try {
             const turnResult = await state.session.runTurn();
             await state.session.snapshot();
@@ -671,25 +613,11 @@ export class SessionProtocolHandler {
                 userHistoryEntryId,
                 turn: turnResult,
             };
-            if (responseRequests) {
-                for (const { handler, request } of responseRequests) {
-                    handler.sendMessage(createSessionProtocolSuccessResponse(request.id, method, result));
-                }
-            }
-            else {
-                this.sendMessage(createSessionProtocolSuccessResponse(requestId, method, result));
-            }
+            this.sendMessage(createSessionProtocolSuccessResponse(requestId, method, result));
         }
         catch (error) {
             await this.snapshotAfterFailedSubmit(state);
-            if (responseRequests) {
-                for (const { handler, request } of responseRequests) {
-                    handler.sendMessage(createSessionProtocolErrorResponse(request.id, SESSION_PROTOCOL_ERROR_CODES.internalError, "failed to run session turn", { cause: error instanceof Error ? error.message : String(error) }));
-                }
-            }
-            else {
-                this.sendMessage(createSessionProtocolErrorResponse(requestId, SESSION_PROTOCOL_ERROR_CODES.internalError, "failed to run session turn", { cause: error instanceof Error ? error.message : String(error) }));
-            }
+            this.sendMessage(createSessionProtocolErrorResponse(requestId, SESSION_PROTOCOL_ERROR_CODES.internalError, "failed to run session turn", { cause: error instanceof Error ? error.message : String(error) }));
         }
     }
     async snapshotAfterFailedSubmit(state) {
@@ -703,7 +631,7 @@ export class SessionProtocolHandler {
     }
     async executeRetry(state, requestId) {
         try {
-            const turnResult = await state.session.runTurn();
+            const turnResult = await state.session.retryTurn();
             await state.session.snapshot();
             const result = {
                 turn: turnResult,
@@ -711,7 +639,12 @@ export class SessionProtocolHandler {
             this.sendMessage(createSessionProtocolSuccessResponse(requestId, "session.retry", result));
         }
         catch (error) {
-            this.sendMessage(createSessionProtocolErrorResponse(requestId, SESSION_PROTOCOL_ERROR_CODES.internalError, "failed to run session turn", { cause: error instanceof Error ? error.message : String(error) }));
+            const retryUnavailable = error instanceof SessionRetryUnavailableError;
+            this.sendMessage(createSessionProtocolErrorResponse(requestId, retryUnavailable
+                ? SESSION_PROTOCOL_ERROR_CODES.invalidRequest
+                : SESSION_PROTOCOL_ERROR_CODES.internalError, retryUnavailable ? error.message : "failed to run session turn", retryUnavailable
+                ? undefined
+                : { cause: error instanceof Error ? error.message : String(error) }));
         }
     }
     execKey(sessionId, execId) {
@@ -783,7 +716,7 @@ export class SessionProtocolHandler {
             if (interrupted) {
                 state.live.interrupting = true;
             }
-            this.rejectPendingSteeringSubmits(state, "session was interrupted");
+            this.rejectPendingBoundarySubmissions(state, "session was interrupted");
             return {
                 interrupted,
                 isTurnRunning: state.session.isTurnRunning || interrupted,
@@ -808,6 +741,95 @@ export class SessionProtocolHandler {
         }
         this.sendMessage(createSessionProtocolSuccessResponse(request.id, "session.snapshot", await state.session.snapshot()));
     }
+    async handleStartGoal(request) {
+        await this.handleGoalTurn(request);
+    }
+    async handleResumeGoal(request) {
+        await this.handleGoalTurn(request);
+    }
+    async handleGoalTurn(request) {
+        const state = await this.getSessionState(request.params.sessionId);
+        if (!state) {
+            this.sendSessionNotFound(request.id, request.params.sessionId);
+            return;
+        }
+        if (this.getPendingMutationCount(state) > 0) {
+            this.sendSubmitBusy(state, request.id);
+            return;
+        }
+        const started = await this.enqueueMutation(state, () => {
+            if (state.live.activeSubmit || state.session.isTurnRunning) {
+                this.sendSubmitBusy(state, request.id);
+                return undefined;
+            }
+            const promise = this.executeGoalTurn(state, request);
+            const activeSubmit = { requestId: request.id, promise };
+            state.live.activeSubmit = activeSubmit;
+            return { activeSubmit };
+        });
+        if (!started)
+            return;
+        try {
+            await started.activeSubmit.promise;
+        }
+        finally {
+            await this.enqueueMutation(state, () => {
+                if (state.live.activeSubmit === started.activeSubmit) {
+                    state.live.activeSubmit = undefined;
+                }
+            });
+            this.schedulePendingSubmissionDrain(state);
+        }
+    }
+    async executeGoalTurn(state, request) {
+        try {
+            if (request.method === "session.startGoal") {
+                const result = await state.session.startGoal(request.params.objective);
+                await state.session.snapshot();
+                this.sendMessage(createSessionProtocolSuccessResponse(request.id, "session.startGoal", result));
+            }
+            else {
+                const result = await state.session.resumeGoal();
+                await state.session.snapshot();
+                this.sendMessage(createSessionProtocolSuccessResponse(request.id, "session.resumeGoal", result));
+            }
+        }
+        catch (error) {
+            await this.snapshotAfterFailedSubmit(state);
+            this.sendMessage(createSessionProtocolErrorResponse(request.id, SESSION_PROTOCOL_ERROR_CODES.internalError, "failed to run session goal", { cause: error instanceof Error ? error.message : String(error) }));
+        }
+    }
+    async handleClearGoal(request) {
+        const state = await this.getSessionState(request.params.sessionId);
+        if (!state) {
+            this.sendSessionNotFound(request.id, request.params.sessionId);
+            return;
+        }
+        if (!state.session.getGoal()) {
+            this.sendMessage(createSessionProtocolErrorResponse(request.id, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "no goal exists"));
+            return;
+        }
+        await this.runSessionMutation(state, async () => {
+            if (this.closed) {
+                return;
+            }
+            if (state.session.sessionId !== request.params.sessionId) {
+                this.sendSessionNotFound(request.id, request.params.sessionId);
+                return;
+            }
+            if (!state.session.getGoal()) {
+                this.sendMessage(createSessionProtocolErrorResponse(request.id, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "no goal exists"));
+                return;
+            }
+            await this.interruptAndWaitForActiveSubmit(state);
+            this.rejectPendingBoundarySubmissions(state, "session goal cleared");
+            this.rejectPendingIdleSubmissions(state, "session goal cleared");
+            const snapshot = state.session.getGoal()
+                ? await state.session.clearGoal()
+                : await state.session.snapshot();
+            this.sendMessage(createSessionProtocolSuccessResponse(request.id, "session.clearGoal", snapshot));
+        });
+    }
     async handleSetReasoning(request) {
         const state = await this.getSessionState(request.params.sessionId);
         if (!state) {
@@ -869,8 +891,7 @@ export class SessionProtocolHandler {
         await this.withNonInterruptingSessionMutation(request, async (state) => {
             if (state.live.activeSubmit ||
                 state.session.isTurnRunning ||
-                state.live.pendingSteeringSubmits.length > 0 ||
-                state.live.pendingQueuedSubmits.length > 0) {
+                state.live.pendingSubmissions.length > 0) {
                 this.sendMessage(createSessionProtocolErrorResponse(request.id, SESSION_PROTOCOL_ERROR_CODES.busy, "cannot rewind while session work is active or pending"));
                 return;
             }
@@ -945,8 +966,8 @@ export class SessionProtocolHandler {
                 return;
             }
             await this.interruptAndWaitForActiveSubmit(state);
-            this.rejectPendingSteeringSubmits(state, queuedSteeringRejectionMessage);
-            this.rejectPendingQueuedSubmits(state, queuedSteeringRejectionMessage);
+            this.rejectPendingBoundarySubmissions(state, queuedSteeringRejectionMessage);
+            this.rejectPendingIdleSubmissions(state, queuedSteeringRejectionMessage);
             await handler(state);
         });
     }
@@ -967,23 +988,19 @@ export class SessionProtocolHandler {
             await handler(state);
         });
     }
-    rejectPendingSteeringSubmits(state, message) {
+    rejectPendingBoundarySubmissions(state, message) {
         const cancelledIds = new Set(state.session.cancelSteering().map((submission) => submission.id));
-        const requests = state.live.pendingSteeringSubmits.filter((pending) => cancelledIds.has(pending.steeringId));
-        state.live.pendingSteeringSubmits = state.live.pendingSteeringSubmits.filter((pending) => !cancelledIds.has(pending.steeringId));
-        if (requests.length > 0) {
-            publishPendingUserMessages(state.session, state.live);
-        }
-        for (const { handler, request } of requests) {
-            handler.sendMessage(createSessionProtocolErrorResponse(request.id, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, message));
-        }
+        this.rejectPendingSubmissions(state, state.live.pendingSubmissions.filter((pending) => pending.delivery === "turn-boundary" && cancelledIds.has(pending.steeringId)), message);
     }
-    rejectPendingQueuedSubmits(state, message) {
-        const requests = state.live.pendingQueuedSubmits.splice(0);
-        if (requests.length > 0) {
-            publishPendingUserMessages(state.session, state.live);
+    rejectPendingIdleSubmissions(state, message) {
+        this.rejectPendingSubmissions(state, state.live.pendingSubmissions.filter((pending) => pending.delivery === "when-idle"), message);
+    }
+    rejectPendingSubmissions(state, pending, message) {
+        if (pending.length === 0) {
+            return;
         }
-        for (const { handler, request } of requests) {
+        this.removePendingSubmissions(state, pending);
+        for (const { handler, request } of pending) {
             handler.sendMessage(createSessionProtocolErrorResponse(request.id, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, message));
         }
     }