Re-read session id at reconnect ready-time to avoid stale reload

Re-initialization after a reconnect is async; capturing session_id up front could reload a session that was replaced during the window, clobbering newer state. Read it inside the when_ready callback so the current session is reloaded instead.

Author: schmoelder

lua/agentic/session_manager.lua

@@ -1392,8 +1392,6 @@ end
 --- Note: the agent process is shared per provider, so this also resets other
 --- tabs' sessions on the same provider; they re-establish on their next use.
 function SessionManager:reconnect()
-    local session_id = self.session_id
-
     -- Reset the local UI immediately. The respawn also drains the dead request
     -- callbacks, but don't make the user wait for that to see the spinner stop.
     self.is_generating = false
@@ -1404,6 +1402,11 @@ function SessionManager:reconnect()
     self.agent:reconnect()
 
     self.agent:when_ready(function()
+        -- Re-read the session at ready-time rather than capturing it earlier:
+        -- re-initialization is async, so the current session may have changed
+        -- meanwhile and a captured id could be stale. Reloading whatever is
+        -- current avoids clobbering a newer session.
+        local session_id = self.session_id
         local caps = self.agent.agent_capabilities
         if session_id and caps and caps.loadSession then
             self:load_acp_session(session_id)

lua/agentic/session_manager.test.lua

@@ -1826,5 +1826,39 @@ describe("agentic.SessionManager", function()
             assert.is_nil(calls.loaded_with)
             assert.is_true(calls.new)
         end)
+
+        it(
+            "reloads the current session, not a stale one, when ready fires late",
+            function()
+                local calls = { loaded_with = nil }
+                local ready_cb
+                local session = {
+                    session_id = "sess-old",
+                    is_generating = true,
+                    status_animation = { stop = function() end },
+                    agent = {
+                        reconnect = function() end,
+                        -- Defer the ready callback so the session can change
+                        -- before re-initialization completes.
+                        when_ready = function(_self, cb)
+                            ready_cb = cb
+                        end,
+                        agent_capabilities = { loadSession = true },
+                    },
+                    reconnect = SessionManager.reconnect,
+                    load_acp_session = function(_self, id)
+                        calls.loaded_with = id
+                    end,
+                    new_session = function() end,
+                } --[[@as agentic.SessionManager]]
+
+                session:reconnect()
+                -- The session is swapped while the agent is still re-initializing.
+                session.session_id = "sess-new"
+                ready_cb()
+
+                assert.equal("sess-new", calls.loaded_with)
+            end
+        )
     end)
 end)