fix(session-ref): preserve stable session ref on provider re-emit

- Only update sessionRef if provider session ID changes, not on metadata updates
- Add stableSessionRef tracking to ACP session to maintain original discovery timestamp
- Implement currentSessionRef() method to return stable refs without recreation

Author: SDSLeon

src/renderer/state/appStore.test.ts

@@ -497,6 +497,43 @@ describe("appStore runtime config sync", () => {
     expect(useAppStore.getState().threads[0]?.status).toBe("idle");
   });
 
+  it("preserves the stored session ref when runtime re-emits the same provider id", () => {
+    const project = useAppStore.getState().addProject({
+      kind: "windows",
+      path: "C:\\repo",
+    });
+    const thread = useAppStore.getState().createThread({
+      projectId: project.id,
+      agentKind: "gemini",
+      config: { model: "gemini-test" },
+      prompt: "a",
+    });
+
+    useAppStore.getState().updateThreadRuntime(thread.id, {
+      status: "idle",
+      attention: "none",
+      canResumeWithConfig: true,
+      sessionRef: {
+        providerSessionId: "gemini-session-1",
+        discoveredAt: "2026-05-01T12:00:00.000Z",
+      },
+    });
+    useAppStore.getState().updateThreadRuntime(thread.id, {
+      status: "idle",
+      attention: "none",
+      canResumeWithConfig: true,
+      sessionRef: {
+        providerSessionId: "gemini-session-1",
+        discoveredAt: "2026-05-01T12:05:00.000Z",
+      },
+    });
+
+    expect(useAppStore.getState().threads[0]?.sessionRef).toEqual({
+      providerSessionId: "gemini-session-1",
+      discoveredAt: "2026-05-01T12:00:00.000Z",
+    });
+  });
+
   it("openThread on finished thread transitions to idle", () => {
     const project = useAppStore.getState().addProject({
       kind: "windows",

src/renderer/state/slices/threadSlice.ts

@@ -387,8 +387,9 @@ export const createThreadSlice: SliceCreator<ThreadSlice> = (set) => ({
 
         const sessionRefChanged =
           input.sessionRef !== undefined &&
-          (thread.sessionRef?.providerSessionId !== input.sessionRef.providerSessionId ||
-            thread.sessionRef?.discoveredAt !== input.sessionRef.discoveredAt);
+          thread.sessionRef?.providerSessionId !== input.sessionRef.providerSessionId;
+        const nextSessionRef =
+          input.sessionRef && sessionRefChanged ? input.sessionRef : thread.sessionRef;
 
         const statusSourceMatch =
           input.threadStatusSource === undefined ||
@@ -439,7 +440,7 @@ export const createThreadSlice: SliceCreator<ThreadSlice> = (set) => ({
           ...(input.threadStatusSource !== undefined
             ? { threadStatusSource: input.threadStatusSource }
             : {}),
-          ...(input.sessionRef ? { sessionRef: input.sessionRef } : {}),
+          ...(nextSessionRef ? { sessionRef: nextSessionRef } : {}),
           ...(input.slashCommands !== undefined ? { slashCommands: input.slashCommands } : {}),
           ...(input.status === "working" && thread.status !== "working"
             ? { updatedAt: nowIso }

src/supervisor/agents/acp/session.test.ts

@@ -477,6 +477,21 @@ describe("ACP turn config sync", () => {
     expect(listener.onUpdate).not.toHaveBeenCalled();
   });
 
+  it("continues suppressing late Gemini loadSession history replay after the RPC resolves", () => {
+    const { listener, session } = makeConfigSyncSession();
+    (session as unknown as Record<string, unknown>)["replayHistoryUntil"] = Date.now() + 500;
+
+    session.handleSessionUpdate({
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "restored assistant message" },
+      },
+    });
+
+    expect(listener.onRuntimeEvent).not.toHaveBeenCalled();
+    expect(listener.onUpdate).not.toHaveBeenCalled();
+  });
+
   it("surfaces available ACP slash commands from session updates", () => {
     const { listener, session } = makeConfigSyncSession();
 

src/supervisor/agents/acp/session.ts

@@ -601,6 +601,7 @@ export class AcpStructuredSession implements StructuredSessionHandle {
   private currentAttention: ThreadAttention = "none";
   private spawnReady: Promise<void> = Promise.resolve();
   private currentTurnId: string | undefined;
+  private stableSessionRef: SessionRef | undefined;
   /**
    * True while a `connection.prompt()` call is in flight (between issue and
    * resolution). Used together with `pendingPromptInterrupt` to close the
@@ -635,6 +636,7 @@ export class AcpStructuredSession implements StructuredSessionHandle {
    * and let normal mapping resume once the load completes.
    */
   private isReplayingHistory = false;
+  private replayHistoryUntil = 0;
 
   private constructor(
     child: ChildProcess,
@@ -677,11 +679,12 @@ export class AcpStructuredSession implements StructuredSessionHandle {
   }
 
   private emitCurrentState(listener: StructuredSessionListener): void {
+    const sessionRef = this.currentSessionRef();
     listener.onUpdate({
       status: this.currentStatus,
       attention: this.currentAttention,
       ...(this.currentConfig ? { config: this.currentConfig } : {}),
-      ...(this.sessionId ? { sessionRef: createKnownSessionRef(this.sessionId) } : {}),
+      ...(sessionRef ? { sessionRef } : {}),
       ...(this.currentSlashCommands !== undefined
         ? { slashCommands: this.currentSlashCommands }
         : {}),
@@ -693,15 +696,29 @@ export class AcpStructuredSession implements StructuredSessionHandle {
       return;
     }
     this.currentSlashCommands = commands;
+    const sessionRef = this.currentSessionRef();
     this.emitListenerUpdate({
       status: this.currentStatus,
       attention: this.currentAttention,
       ...(this.currentConfig ? { config: this.currentConfig } : {}),
-      ...(this.sessionId ? { sessionRef: createKnownSessionRef(this.sessionId) } : {}),
+      ...(sessionRef ? { sessionRef } : {}),
       slashCommands: commands,
     });
   }
 
+  private currentSessionRef(): SessionRef | undefined {
+    if (!this.sessionId) return undefined;
+    if (this.stableSessionRef?.providerSessionId !== this.sessionId) {
+      this.stableSessionRef = createKnownSessionRef(this.sessionId);
+    }
+    return this.stableSessionRef;
+  }
+
+  private adoptSessionRef(sessionRef: SessionRef): void {
+    this.sessionId = sessionRef.providerSessionId;
+    this.stableSessionRef = sessionRef;
+  }
+
   private rememberSessionOptions(availableModeIds: string[], configOptions: unknown): void {
     this.availableModeIds = availableModeIds;
     this.currentConfigOptions = Array.isArray(configOptions) ? configOptions : [];
@@ -976,17 +993,19 @@ export class AcpStructuredSession implements StructuredSessionHandle {
     if (sessionRef) {
       console.log("[acp] loading session:", sessionRef.providerSessionId);
       this.isReplayingHistory = true;
+      this.replayHistoryUntil = Infinity;
       try {
         const result = await this.connection.loadSession({
           sessionId: sessionRef.providerSessionId,
           cwd: this.cwd,
           mcpServers: [],
         });
-        this.sessionId = sessionRef.providerSessionId;
+        this.adoptSessionRef(sessionRef);
         availableModeIds = result.modes?.availableModes?.map((m) => m.id) ?? [];
         configOptions = result.configOptions ?? [];
       } finally {
         this.isReplayingHistory = false;
+        this.replayHistoryUntil = Date.now() + 500;
       }
     } else {
       console.log("[acp] creating new session in", this.cwd);
@@ -995,6 +1014,7 @@ export class AcpStructuredSession implements StructuredSessionHandle {
         mcpServers: [],
       });
       this.sessionId = result.sessionId;
+      this.stableSessionRef = createKnownSessionRef(result.sessionId);
       availableModeIds = result.modes?.availableModes?.map((m) => m.id) ?? [];
       configOptions = result.configOptions ?? [];
       console.log("[acp] session created:", this.sessionId, "modes:", availableModeIds);
@@ -1003,7 +1023,9 @@ export class AcpStructuredSession implements StructuredSessionHandle {
     this.rememberSessionOptions(availableModeIds, configOptions);
     await this.applyTurnConfig(config);
 
-    this.launchOptions = { ...this.launchOptions, resumeThreadId: this.sessionId };
+    if (this.sessionId) {
+      this.launchOptions = { ...this.launchOptions, resumeThreadId: this.sessionId };
+    }
     return this.sessionId!;
   }
 
@@ -1306,7 +1328,7 @@ export class AcpStructuredSession implements StructuredSessionHandle {
     // `session/update` notifications. Lightcode already has those messages
     // in its own DB, so we skip canonical mapping for the replay window to
     // avoid duplicating every message in the chat pane.
-    if (!this.isReplayingHistory) {
+    if (!this.isReplayingHistory && Date.now() >= (this.replayHistoryUntil || 0)) {
       const events = mapAcpSessionUpdate(params, this.ensureMapperState());
       if (events.length > 0) this.emitRuntimeEvents(events);
     } else {
@@ -1358,14 +1380,15 @@ export class AcpStructuredSession implements StructuredSessionHandle {
           const nextConfig = applyAcpModeUpdateToConfig(this.currentConfig, update.currentModeId);
           if (!isThreadConfigEqual(this.currentConfig, nextConfig)) {
             this.currentConfig = nextConfig;
+            const sessionRef = this.currentSessionRef();
             // Mode-change confirmations are metadata, not turn boundaries —
             // preserve the live status so the renderer's working-time clock
             // doesn't reset when the agent echoes back a setSessionMode call.
             this.emitListenerUpdate({
               status: this.currentStatus,
               attention: this.currentAttention,
               config: nextConfig,
-              ...(this.sessionId ? { sessionRef: createKnownSessionRef(this.sessionId) } : {}),
+              ...(sessionRef ? { sessionRef } : {}),
             });
           }
         }
@@ -1381,11 +1404,12 @@ export class AcpStructuredSession implements StructuredSessionHandle {
           ) {
             const nextConfig = { ...this.currentConfig, effort: thoughtLevelConfig.currentValue };
             this.currentConfig = nextConfig;
+            const sessionRef = this.currentSessionRef();
             this.emitListenerUpdate({
               status: this.currentStatus,
               attention: this.currentAttention,
               config: nextConfig,
-              ...(this.sessionId ? { sessionRef: createKnownSessionRef(this.sessionId) } : {}),
+              ...(sessionRef ? { sessionRef } : {}),
             });
           }
         }