clear pairings when gateway stops

When a gateway is stopped (stop_gateway or stop_all), all pairings
for that platform are removed from the database. Users must re-pair
on next start. Makes sense for Telegram where pairings are tied to
a running goose session.

Author: michaelneale

crates/goose-server/src/gateway/manager.rs

@@ -122,7 +122,7 @@ impl GatewayManager {
         Ok(())
     }
 
-    /// Stop a gateway and remove its persisted config.
+    /// Stop a gateway, clear its pairings, and remove its persisted config.
     pub async fn stop_gateway(&self, gateway_type: &str) -> anyhow::Result<()> {
         let instance = self
             .gateways
@@ -134,6 +134,20 @@ impl GatewayManager {
         instance.cancel.cancel();
         let _ = instance.handle.await;
 
+        match self
+            .pairing_store
+            .remove_all_for_platform(gateway_type)
+            .await
+        {
+            Ok(count) if count > 0 => {
+                tracing::info!(gateway = %gateway_type, count, "cleared pairings on stop");
+            }
+            Err(e) => {
+                tracing::warn!(gateway = %gateway_type, error = %e, "failed to clear pairings on stop");
+            }
+            _ => {}
+        }
+
         Self::remove_saved_config(gateway_type);
         tracing::info!(gateway = %gateway_type, "gateway stopped");
         Ok(())
@@ -188,6 +202,13 @@ impl GatewayManager {
         for (gateway_type, instance) in instances {
             instance.cancel.cancel();
             let _ = instance.handle.await;
+            if let Err(e) = self
+                .pairing_store
+                .remove_all_for_platform(&gateway_type)
+                .await
+            {
+                tracing::warn!(gateway = %gateway_type, error = %e, "failed to clear pairings on stop");
+            }
             tracing::info!(gateway = %gateway_type, "gateway stopped");
         }
     }

crates/goose-server/src/gateway/pairing.rs

@@ -255,6 +255,20 @@ impl PairingStore {
             .collect()
     }
 
+    pub async fn remove_all_for_platform(&self, platform: &str) -> anyhow::Result<usize> {
+        let pool = self.ensure_initialized().await?;
+
+        let result = sqlx::query("DELETE FROM gateway_pairings WHERE platform = ?")
+            .bind(platform)
+            .execute(pool)
+            .await?;
+
+        let mut pairings = self.pairings.write().await;
+        pairings.retain(|user, _| user.platform != platform);
+
+        Ok(result.rows_affected() as usize)
+    }
+
     pub async fn list_paired_users(
         &self,
         gateway_type: &str,
@@ -433,4 +447,43 @@ mod tests {
             other => panic!("Expected Paired, got {:?}", other),
         }
     }
+
+    #[tokio::test]
+    async fn test_remove_all_for_platform() {
+        let tmp = TempDir::new().unwrap();
+        let store = PairingStore::new(&tmp.path().join("test.db"));
+
+        let tg1 = test_user("telegram", "111");
+        let tg2 = test_user("telegram", "222");
+        let discord = test_user("discord", "333");
+
+        for user in [&tg1, &tg2, &discord] {
+            store
+                .set(
+                    user,
+                    PairingState::Paired {
+                        session_id: format!("s-{}", user.user_id),
+                        paired_at: 1000,
+                    },
+                )
+                .await
+                .unwrap();
+        }
+
+        let removed = store.remove_all_for_platform("telegram").await.unwrap();
+        assert_eq!(removed, 2);
+
+        assert!(matches!(
+            store.get(&tg1).await.unwrap(),
+            PairingState::Unpaired
+        ));
+        assert!(matches!(
+            store.get(&tg2).await.unwrap(),
+            PairingState::Unpaired
+        ));
+        assert!(matches!(
+            store.get(&discord).await.unwrap(),
+            PairingState::Paired { .. }
+        ));
+    }
 }