Add explicit legacy session claim

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: gimenete

rust/src/lib.rs

@@ -2590,6 +2590,23 @@ impl Client {
         Ok(())
     }
 
+    /// Claim one quarantined legacy local session for the active store identity.
+    ///
+    /// The runtime atomically binds the claim to the identity most recently set
+    /// on this client connection through
+    /// [`set_session_store_identity`](Self::set_session_store_identity). Call
+    /// this only after explicit trusted-host user confirmation for the selected
+    /// session. The runtime rejects missing identities, conflicting ownership,
+    /// and sessions that are not eligible legacy local sessions.
+    pub async fn claim_legacy_session(&self, session_id: &SessionId) -> Result<()> {
+        self.call(
+            "sessionStore.claimLegacySession",
+            Some(serde_json::json!({ "sessionId": session_id })),
+        )
+        .await?;
+        Ok(())
+    }
+
     /// List persisted sessions, optionally filtered by working directory,
     /// repository, or git context.
     pub async fn list_sessions(

rust/tests/session_test.rs

@@ -2577,6 +2577,68 @@ async fn set_session_store_identity_sends_null_to_clear() {
     handle.await.unwrap().unwrap();
 }
 
+#[tokio::test]
+async fn claim_legacy_session_sends_exact_wire_shape() {
+    let (client, mut server_read, mut server_write) = make_client();
+
+    let handle = tokio::spawn({
+        let client = client.clone();
+        async move {
+            client
+                .claim_legacy_session(&SessionId::new("legacy-session"))
+                .await
+        }
+    });
+
+    let request = read_framed(&mut server_read).await;
+    assert_eq!(request["method"], "sessionStore.claimLegacySession");
+    assert_eq!(
+        request["params"],
+        serde_json::json!({ "sessionId": "legacy-session" })
+    );
+    let response = serde_json::json!({
+        "jsonrpc": "2.0",
+        "id": request["id"],
+        "result": {}
+    });
+    write_framed(&mut server_write, &serde_json::to_vec(&response).unwrap()).await;
+    handle.await.unwrap().unwrap();
+}
+
+#[tokio::test]
+async fn claim_legacy_session_propagates_rpc_errors() {
+    let (client, mut server_read, mut server_write) = make_client();
+
+    let handle = tokio::spawn({
+        let client = client.clone();
+        async move {
+            client
+                .claim_legacy_session(&SessionId::new("owned-session"))
+                .await
+        }
+    });
+
+    let request = read_framed(&mut server_read).await;
+    assert_eq!(request["method"], "sessionStore.claimLegacySession");
+    let response = serde_json::json!({
+        "jsonrpc": "2.0",
+        "id": request["id"],
+        "error": {
+            "code": -32000,
+            "message": "legacy session is not eligible for claim"
+        }
+    });
+    write_framed(&mut server_write, &serde_json::to_vec(&response).unwrap()).await;
+
+    let error = handle.await.unwrap().unwrap_err();
+    assert!(matches!(error.kind(), ErrorKind::Rpc { code: -32000 }));
+    assert!(
+        error
+            .to_string()
+            .contains("legacy session is not eligible for claim")
+    );
+}
+
 #[tokio::test]
 async fn list_sessions_serializes_typed_filter() {
     use github_copilot_sdk::SessionListFilter;