fix(sessions): re-check queue membership after cloud edit normalization

updateQueuedMessage awaited resolveCloudPrompt before writing to the store.
If the message drained during that await (a turn completed and sent it), the
store update became a no-op but the method still returned true, so the caller
treated the edit as saved and never fell back to sending it as a fresh
message -- losing the edit. Re-read fresh session state after the await and
return false if the target is no longer queued. Also read fresh state for the
edit-hold clear, since the pre-await snapshot may be stale.

Generated-By: PostHog Code
Task-Id: 5cf31c6c-1ba0-4137-88c1-3a369f3acf36

Author: gantoine

packages/core/src/sessions/sessionService.ts

@@ -2728,6 +2728,13 @@ export class SessionService {
 
     if (session.isCloud) {
       const normalizedPrompt = await this.resolveCloudPrompt(prompt);
+      // Cloud normalization awaits, during which the message may have drained
+      // (a turn completed and sent it). Re-check against fresh state: without
+      // this, the store update below is a silent no-op yet we'd still report a
+      // successful save, so the caller wouldn't fall back to sending the edit
+      // as a fresh message and the edit would be lost.
+      const fresh = this.d.store.getSessionByTaskId(taskId);
+      if (!fresh?.messageQueue.some((m) => m.id === messageId)) return false;
       const transport = this.d.h.getCloudPromptTransport(normalizedPrompt);
       this.d.store.updateQueuedMessage(taskId, messageId, {
         content: transport.promptText,
@@ -2739,7 +2746,10 @@ export class SessionService {
       });
     }
 
-    if (session.editingQueuedId === messageId) {
+    // Read fresh: the cloud path awaited above, so the pre-await `session`
+    // snapshot may be stale for the edit-hold decision.
+    const latest = this.d.store.getSessionByTaskId(taskId);
+    if (latest?.editingQueuedId === messageId) {
       this.d.store.clearEditingQueuedMessage(taskId);
     }
     this.flushQueuedMessagesIfIdle(taskId);

packages/ui/src/features/sessions/sessionServiceHost.test.ts

@@ -5223,6 +5223,75 @@ describe("SessionService", () => {
     });
   });
 
+  describe("updateQueuedMessage cloud normalization race", () => {
+    const cloudSession = (
+      overrides: Partial<AgentSession> = {},
+    ): AgentSession =>
+      createMockSession({
+        isCloud: true,
+        cloudStatus: "in_progress",
+        status: "connected",
+        isPromptPending: true,
+        messageQueue: [
+          {
+            id: "q-1",
+            content: "old",
+            rawPrompt: [{ type: "text", text: "old" }],
+            queuedAt: 1,
+          },
+        ],
+        editingQueuedId: "q-1",
+        ...overrides,
+      });
+
+    it("returns false when the message drains while cloud normalization awaits", async () => {
+      const service = getSessionService();
+      // Present for the initial membership check, gone for the post-await
+      // re-check (a turn completed and drained it during normalization).
+      mockSessionStoreSetters.getSessionByTaskId
+        .mockReturnValueOnce(cloudSession())
+        .mockReturnValue(
+          cloudSession({ messageQueue: [], editingQueuedId: undefined }),
+        );
+
+      const updated = await service.updateQueuedMessage(
+        "task-123",
+        "q-1",
+        "edited",
+      );
+
+      // No-op store write must not be reported as a save, so the caller falls
+      // back to sending the edit as a fresh message instead of losing it.
+      expect(updated).toBe(false);
+      expect(
+        mockSessionStoreSetters.updateQueuedMessage,
+      ).not.toHaveBeenCalled();
+      expect(
+        mockSessionStoreSetters.clearEditingQueuedMessage,
+      ).not.toHaveBeenCalled();
+    });
+
+    it("updates in place when the message is still queued after normalization", async () => {
+      const service = getSessionService();
+      mockSessionStoreSetters.getSessionByTaskId.mockReturnValue(
+        cloudSession(),
+      );
+
+      const updated = await service.updateQueuedMessage(
+        "task-123",
+        "q-1",
+        "edited",
+      );
+
+      expect(updated).toBe(true);
+      expect(mockSessionStoreSetters.updateQueuedMessage).toHaveBeenCalledWith(
+        "task-123",
+        "q-1",
+        expect.objectContaining({ content: expect.any(String) }),
+      );
+    });
+  });
+
   describe("cancelPrompt", () => {
     it("returns false if no session exists", async () => {
       const service = getSessionService();