Fix Cursor ACP session replay on resume

Author: tarik02

apps/server/src/provider/acp/AcpSessionRuntime.test.ts

@@ -0,0 +1,88 @@
+import { assert, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Ref from "effect/Ref";
+import type * as EffectAcpSchema from "effect-acp/schema";
+
+import { handleSessionUpdateForTest } from "./AcpSessionRuntime.ts";
+import type {
+  AcpParsedSessionEvent,
+  AcpSessionModeState,
+  AcpToolCallState,
+} from "./AcpRuntimeModel.ts";
+
+it.effect("suppresses loaded-session replay updates until the first live prompt", () =>
+  Effect.gen(function* () {
+    const queue = yield* Queue.unbounded<AcpParsedSessionEvent>();
+    const modeStateRef = yield* Ref.make<AcpSessionModeState | undefined>({
+      currentModeId: "ask",
+      availableModes: [
+        { id: "ask", name: "Ask" },
+        { id: "code", name: "Code" },
+      ],
+    });
+    const toolCallsRef = yield* Ref.make(new Map<string, AcpToolCallState>());
+    const assistantSegmentRef = yield* Ref.make({ nextSegmentIndex: 0 });
+    const suppressSessionUpdatesRef = yield* Ref.make(true);
+
+    const handle = (params: EffectAcpSchema.SessionNotification) =>
+      handleSessionUpdateForTest({
+        queue,
+        modeStateRef,
+        toolCallsRef,
+        assistantSegmentRef,
+        suppressSessionUpdatesRef,
+        params,
+      });
+
+    yield* handle({
+      sessionId: "cursor-session",
+      update: {
+        sessionUpdate: "current_mode_update",
+        currentModeId: "code",
+      },
+    });
+    yield* handle({
+      sessionId: "cursor-session",
+      update: {
+        sessionUpdate: "plan",
+        entries: [{ content: "Old replayed plan", priority: "high", status: "completed" }],
+      },
+    });
+    yield* handle({
+      sessionId: "cursor-session",
+      update: {
+        sessionUpdate: "user_message_chunk",
+        content: { type: "text", text: "old replayed user prompt" },
+      },
+    });
+    yield* handle({
+      sessionId: "cursor-session",
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "old replayed assistant text" },
+      },
+    });
+
+    assert.equal(yield* Queue.size(queue), 0);
+    assert.equal((yield* Ref.get(modeStateRef))?.currentModeId, "code");
+
+    yield* Ref.set(suppressSessionUpdatesRef, false);
+    yield* handle({
+      sessionId: "cursor-session",
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "new assistant text" },
+      },
+    });
+
+    const started = yield* Queue.take(queue);
+    const delta = yield* Queue.take(queue);
+    assert.equal(started._tag, "AssistantItemStarted");
+    assert.equal(delta._tag, "ContentDelta");
+    if (delta._tag === "ContentDelta") {
+      assert.equal(delta.text, "new assistant text");
+    }
+    assert.equal(yield* Queue.size(queue), 0);
+  }),
+);

apps/server/src/provider/acp/AcpSessionRuntime.ts

@@ -50,6 +50,7 @@ export interface AcpSessionRuntimeOptions {
   };
   readonly authMethodId: string;
   readonly mcpServers?: ReadonlyArray<EffectAcpSchema.McpServer>;
+  readonly suppressSessionUpdatesUntilPrompt?: boolean;
   readonly requestLogger?: (event: AcpSessionRequestLogEvent) => Effect.Effect<void, never>;
   readonly protocolLogging?: {
     readonly logIncoming?: boolean;
@@ -171,6 +172,9 @@ const makeAcpSessionRuntime = (
     const assistantSegmentRef = yield* Ref.make<AcpAssistantSegmentState>({ nextSegmentIndex: 0 });
     const configOptionsRef = yield* Ref.make(sessionConfigOptionsFromSetup(undefined));
     const startStateRef = yield* Ref.make<AcpStartState>({ _tag: "NotStarted" });
+    const suppressSessionUpdatesRef = yield* Ref.make(
+      options.suppressSessionUpdatesUntilPrompt === true,
+    );
 
     const logRequest = (event: AcpSessionRequestLogEvent) =>
       options.requestLogger ? options.requestLogger(event) : Effect.void;
@@ -249,6 +253,7 @@ const makeAcpSessionRuntime = (
         modeStateRef,
         toolCallsRef,
         assistantSegmentRef,
+        suppressSessionUpdatesRef,
         params: notification,
       }),
     );
@@ -518,10 +523,13 @@ const makeAcpSessionRuntime = (
               sessionId: started.sessionId,
               ...payload,
             } satisfies EffectAcpSchema.PromptRequest;
-            return closeActiveAssistantSegment({
-              queue: eventQueue,
-              assistantSegmentRef,
-            }).pipe(
+            return Ref.set(suppressSessionUpdatesRef, false).pipe(
+              Effect.andThen(
+                closeActiveAssistantSegment({
+                  queue: eventQueue,
+                  assistantSegmentRef,
+                }),
+              ),
               Effect.andThen(
                 runLoggedRequest(
                   "session/prompt",
@@ -608,12 +616,14 @@ const handleSessionUpdate = ({
   modeStateRef,
   toolCallsRef,
   assistantSegmentRef,
+  suppressSessionUpdatesRef,
   params,
 }: {
   readonly queue: Queue.Queue<AcpParsedSessionEvent>;
   readonly modeStateRef: Ref.Ref<AcpSessionModeState | undefined>;
   readonly toolCallsRef: Ref.Ref<Map<string, AcpToolCallState>>;
   readonly assistantSegmentRef: Ref.Ref<AcpAssistantSegmentState>;
+  readonly suppressSessionUpdatesRef: Ref.Ref<boolean>;
   readonly params: EffectAcpSchema.SessionNotification;
 }): Effect.Effect<void> =>
   Effect.gen(function* () {
@@ -623,6 +633,9 @@ const handleSessionUpdate = ({
         current === undefined ? current : updateModeState(current, parsed.modeId!),
       );
     }
+    if (yield* Ref.get(suppressSessionUpdatesRef)) {
+      return;
+    }
     for (const event of parsed.events) {
       if (event._tag === "ToolCallUpdated") {
         yield* closeActiveAssistantSegment({
@@ -672,6 +685,8 @@ const handleSessionUpdate = ({
     }
   });
 
+export const handleSessionUpdateForTest = handleSessionUpdate;
+
 function updateModeState(modeState: AcpSessionModeState, nextModeId: string): AcpSessionModeState {
   const normalized = nextModeId.trim();
   if (!normalized) {

apps/server/src/provider/acp/CursorAcpSupport.ts

@@ -60,6 +60,8 @@ export const makeCursorAcpRuntime = (
         spawn: buildCursorAcpSpawnInput(input.cursorSettings, input.cwd, input.environment),
         authMethodId: "cursor_login",
         clientCapabilities: CURSOR_PARAMETERIZED_MODEL_PICKER_CAPABILITIES,
+        suppressSessionUpdatesUntilPrompt:
+          input.suppressSessionUpdatesUntilPrompt ?? input.resumeSessionId !== undefined,
       }).pipe(
         Layer.provide(
           Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, input.childProcessSpawner),