add jetstream cursor tracking, update atproto libs to 0.13

api/.env.example

···
 # Authentication service base URL
 AUTH_BASE_URL=http://localhost:8081
 
-# AT Protocol relay endpoint for syncing data
+# AT Protocol relay endpoint for backfill
 RELAY_ENDPOINT=https://relay1.us-west.bsky.network
+
+# AT Protocol Jetstream hostname
+JETSTREAM_HOSTNAME=jetstream2.us-west.bsky.network
 
 # System slice URI
 SYSTEM_SLICE_URI=at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z

api/Cargo.lock

···
 
 [[package]]
 name = "atproto-client"
-version = "0.11.2"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "188c4bae6a3260c4d57149e7061415d440422ef11d68a16f581422ff181a66d9"
+checksum = "c34ed7ebeec01cd7775c1c7841838c142d123d403983ed7179b31850435b5c7c"
 dependencies = [
  "anyhow",
  "atproto-identity",
···
 
 [[package]]
 name = "atproto-identity"
-version = "0.11.2"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4bf47131d663bcb76feaeb9403c09e12f00e5a2e0a7d805bd8caf4c6fdf01fa"
+checksum = "b956c07726fce812630be63c5cb31b1961cbb70f0a05614278523102d78c3a48"
 dependencies = [
  "anyhow",
  "async-trait",
···
  "thiserror 2.0.14",
  "tokio",
  "tracing",
+ "urlencoding",
 ]
 
 [[package]]
 name = "atproto-jetstream"
-version = "0.11.2"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "178b4af2b79ee11f25e69bca5c12907d0699843a4a847d737827dcff68a20af4"
+checksum = "7b1897fb2f7c6d02d46f7b8d25d653c141cee4a68a10efd135d46201a95034db"
 dependencies = [
  "anyhow",
  "async-trait",
···
 
 [[package]]
 name = "atproto-oauth"
-version = "0.11.2"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "919d64f13696fb700ed604b09c526b223f6bf063eb35f46d691198079cfbc789"
+checksum = "3ea205901c33d074a1b498591d0511bcd788b6772ec0ca6e09a92c4327ddbdff"
 dependencies = [
  "anyhow",
  "async-trait",
···
 
 [[package]]
 name = "atproto-record"
-version = "0.11.2"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "623f3eb1ba1e7b99903dc525f8b115ea8b6439b0d598507201f1f88aa6a37646"
+checksum = "0550f74423ca745132dc07ba1cb01f2f08243a7bf7497f5c3f2185a774c92ca2"
 dependencies = [
  "anyhow",
  "atproto-identity",

api/Cargo.toml

···
 async-trait = "0.1"
 
 # AT Protocol client
-atproto-client = "0.11.2"
-atproto-identity = "0.11.2"
-atproto-oauth = "0.11.2"
-atproto-jetstream = "0.11.2"
+atproto-client = "0.13.0"
+atproto-identity = "0.13.0"
+atproto-oauth = "0.13.0"
+atproto-jetstream = "0.13.0"
 
 
 # Middleware for HTTP requests with retry logic

api/migrations/011_jetstream_cursor.sql

···
+-- Add jetstream cursor table for tracking event processing position
+CREATE TABLE IF NOT EXISTS jetstream_cursor (
+    id TEXT PRIMARY KEY DEFAULT 'default',
+    time_us BIGINT NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Index for tracking cursor freshness
+CREATE INDEX idx_jetstream_cursor_updated_at ON jetstream_cursor(updated_at);
+
+-- Insert default cursor starting at 0 (will be updated when events are processed)
+INSERT INTO jetstream_cursor (id, time_us) VALUES ('default', 0)
+ON CONFLICT (id) DO NOTHING;

api/src/api/xrpc_dynamic.rs

···
         validate: false,
     };
 
-    let result = create_record(&http_client, &dpop_auth, &pds_url, create_request)
+    let result = create_record(&http_client, &atproto_client::client::Auth::DPoP(dpop_auth), &pds_url, create_request)
         .await
         .map_err(|_e| status_to_error_response(StatusCode::INTERNAL_SERVER_ERROR))?;
 
···
         validate: false,
     };
 
-    let result = put_record(&http_client, &dpop_auth, &pds_url, put_request)
+    let result = put_record(&http_client, &atproto_client::client::Auth::DPoP(dpop_auth), &pds_url, put_request)
         .await
         .map_err(|_| status_to_error_response(StatusCode::INTERNAL_SERVER_ERROR))?;
 
···
         swap_commit: None,
     };
 
-    delete_record(&http_client, &dpop_auth, &pds_url, delete_request)
+    delete_record(&http_client, &atproto_client::client::Auth::DPoP(dpop_auth), &pds_url, delete_request)
         .await
         .map_err(|_| status_to_error_response(StatusCode::INTERNAL_SERVER_ERROR))?;
 

api/src/atproto_extensions.rs

···
 
 use serde::{Deserialize, Serialize};
 use atproto_client::client::DPoPAuth;
-use atproto_client::url::URLBuilder;
 use thiserror::Error;
 use atproto_oauth::dpop::{DpopRetry, request_dpop};
 use reqwest_middleware::ClientBuilder;
···
     UploadFailed { status: u16, message: String },
 }
 
-/// Request for uploading a blob
-#[derive(Serialize, Deserialize, Debug)]
-pub struct UploadBlobRequest {
-    // Note: For blob uploads, the data is sent as the request body, not JSON
-    // So this struct is mainly for reference - we'll handle the actual upload differently
-}
 
 /// Response from blob upload
 #[cfg_attr(debug_assertions, derive(Debug))]
···
     blob_data: Vec<u8>,
     mime_type: &str,
 ) -> Result<UploadBlobResponse, BlobUploadError> {
-    // Build the URL
-    let mut url_builder = URLBuilder::new(base_url);
-    url_builder.path("/xrpc/com.atproto.repo.uploadBlob");
-    let url = url_builder.build();
-    
+    // Build the URL using standard string formatting
+    let url = format!("{}/xrpc/com.atproto.repo.uploadBlob", base_url.trim_end_matches('/'));
+
     // For blob uploads, we need to use a different approach than post_dpop_json
     // since we're sending binary data, not JSON
     // We need to use the same DPoP mechanism but with binary body
-    
+
     // Use the internal post_dpop function but for binary data
     post_dpop_binary(http_client, dpop_auth, &url, blob_data, mime_type)
         .await
···
     if !http_response.status().is_success() {
         let status = http_response.status();
         let error_text = http_response.text().await.unwrap_or_else(|_| "unknown".to_string());
-        return Err(BlobUploadError::UploadFailed { 
-            status: status.as_u16(), 
-            message: error_text 
+        return Err(BlobUploadError::UploadFailed {
+            status: status.as_u16(),
+            message: error_text
         });
     }
 
···
         .json::<serde_json::Value>()
         .await
         .map_err(|e| BlobUploadError::HttpRequest(e.into()))?;
-        
+
     Ok(value)
-}
+}

api/src/jetstream.rs

···
 
 use crate::actor_resolver::resolve_actor_data;
 use crate::database::Database;
+use crate::jetstream_cursor::PostgresCursorHandler;
 use crate::models::{Record, Actor};
 use crate::errors::SliceError;
 use crate::logging::{Logger, LogLevel};
···
     consumer: Consumer,
     database: Database,
     http_client: Client,
-    // Track which collections we should index for each slice
     slice_collections: Arc<RwLock<HashMap<String, HashSet<String>>>>,
-    // Track domains for each slice (slice_uri -> domain)
     slice_domains: Arc<RwLock<HashMap<String, String>>>,
-    // Cache for actor lookups
     actor_cache: Arc<RwLock<HashMap<(String, String), bool>>>,
-    // Lexicon cache for each slice
     slice_lexicons: Arc<RwLock<HashMap<String, Vec<serde_json::Value>>>>,
-    // Event counter for health monitoring
     pub event_count: Arc<std::sync::atomic::AtomicU64>,
+    cursor_handler: Option<Arc<PostgresCursorHandler>>,
 }
 
 // Event handler that implements the EventHandler trait
···
     slice_collections: Arc<RwLock<HashMap<String, HashSet<String>>>>,
     slice_domains: Arc<RwLock<HashMap<String, String>>>,
     event_count: Arc<std::sync::atomic::AtomicU64>,
-    // Cache for (did, slice_uri) -> is_actor lookups
     actor_cache: Arc<RwLock<HashMap<(String, String), bool>>>,
-    // Lexicon cache for each slice
     slice_lexicons: Arc<RwLock<HashMap<String, Vec<serde_json::Value>>>>,
+    cursor_handler: Option<Arc<PostgresCursorHandler>>,
 }
 
 #[async_trait]
 impl EventHandler for SliceEventHandler {
     async fn handle_event(&self, event: JetstreamEvent) -> Result<()> {
-        // Increment event counter
         let count = self.event_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
-        
-        // Log every 10000 events to show activity (console only, not in DB)
-        if count % 10000 == 0 {
+
+        if count.is_multiple_of(10000) {
             info!("Jetstream consumer has processed {} events", count);
         }
-        
+
+        // Extract and update cursor position from event
+        let time_us = match &event {
+            JetstreamEvent::Commit { time_us, .. } => *time_us,
+            JetstreamEvent::Delete { time_us, .. } => *time_us,
+            JetstreamEvent::Identity { time_us, .. } => *time_us,
+            JetstreamEvent::Account { time_us, .. } => *time_us,
+        };
+
+        if let Some(cursor_handler) = &self.cursor_handler {
+            cursor_handler.update_position(time_us);
+
+            // Periodically write cursor to DB (debounced by handler)
+            if let Err(e) = cursor_handler.maybe_write_cursor().await {
+                error!("Failed to write cursor: {}", e);
+            }
+        }
+
         match event {
             JetstreamEvent::Commit { did, commit, .. } => {
                 if let Err(e) = self.handle_commit_event(&did, commit).await {
···
 }
 
 impl JetstreamConsumer {
-    pub async fn new(database: Database, jetstream_hostname: Option<String>) -> Result<Self, SliceError> {
+    /// Create a new Jetstream consumer with optional cursor support
+    ///
+    /// # Arguments
+    /// * `database` - Database connection for slice configurations and record storage
+    /// * `jetstream_hostname` - Optional custom jetstream hostname
+    /// * `cursor_handler` - Optional cursor handler for resumable event processing
+    /// * `initial_cursor` - Optional starting cursor position (time_us) to resume from
+    pub async fn new(
+        database: Database,
+        jetstream_hostname: Option<String>,
+        cursor_handler: Option<Arc<PostgresCursorHandler>>,
+        initial_cursor: Option<i64>,
+    ) -> Result<Self, SliceError> {
         let config = ConsumerTaskConfig {
             user_agent: "slice-server/1.0".to_string(),
             compression: false,
             zstd_dictionary_location: String::new(),
             jetstream_hostname: jetstream_hostname
                 .unwrap_or_else(|| "jetstream1.us-east.bsky.network".to_string()),
-            collections: Vec::new(), // We'll update this dynamically based on slice configs
-            dids: Vec::new(), // Subscribe to all DIDs
+            collections: Vec::new(),
+            dids: Vec::new(),
             max_message_size_bytes: None,
-            cursor: None,
-            require_hello: true, // Match official example - enables proper handshake
+            cursor: initial_cursor,
+            require_hello: true,
         };
 
         let consumer = Consumer::new(config);
···
             actor_cache: Arc::new(RwLock::new(HashMap::new())),
             slice_lexicons: Arc::new(RwLock::new(HashMap::new())),
             event_count: Arc::new(std::sync::atomic::AtomicU64::new(0)),
+            cursor_handler,
         })
     }
 
···
             event_count: self.event_count.clone(),
             actor_cache: self.actor_cache.clone(),
             slice_lexicons: self.slice_lexicons.clone(),
+            cursor_handler: self.cursor_handler.clone(),
         });
         
         self.consumer.register_handler(handler).await
···
         
         // Start the consumer
         info!("Starting Jetstream background consumer...");
-        self.consumer.run_background(cancellation_token).await
+        let result = self.consumer.run_background(cancellation_token).await
             .map_err(|e| SliceError::JetstreamError {
                 message: format!("Consumer failed: {}", e),
-            })?;
-        
+            });
+
+        // Force write cursor on shutdown to ensure latest position is persisted
+        if let Some(cursor_handler) = &self.cursor_handler {
+            if let Err(e) = cursor_handler.force_write_cursor().await {
+                error!("Failed to write final cursor position: {}", e);
+            } else {
+                info!("Final cursor position written to database");
+            }
+        }
+
+        result?;
         Ok(())
     }
 

api/src/jetstream_cursor.rs

···
+use sqlx::PgPool;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, Instant};
+use tokio::sync::Mutex;
+use tracing::{debug, warn};
+
+/// Handles persistence of Jetstream cursor position to Postgres
+///
+/// The cursor tracks the last processed event's time_us to enable resumption
+/// after disconnections or restarts. Writes are debounced to reduce DB load.
+pub struct PostgresCursorHandler {
+    pool: PgPool,
+    cursor_id: String,
+    last_time_us: Arc<AtomicU64>,
+    last_write: Arc<Mutex<Instant>>,
+    write_interval: Duration,
+}
+
+impl PostgresCursorHandler {
+    /// Create a new cursor handler
+    ///
+    /// # Arguments
+    /// * `pool` - Database connection pool
+    /// * `cursor_id` - Unique identifier for this cursor (e.g., "default", "instance-1")
+    /// * `write_interval_secs` - Minimum seconds between cursor writes to reduce DB load
+    pub fn new(pool: PgPool, cursor_id: String, write_interval_secs: u64) -> Self {
+        Self {
+            pool,
+            cursor_id,
+            last_time_us: Arc::new(AtomicU64::new(0)),
+            last_write: Arc::new(Mutex::new(Instant::now())),
+            write_interval: Duration::from_secs(write_interval_secs),
+        }
+    }
+
+    /// Update the in-memory cursor position from an event's time_us
+    ///
+    /// This is called for every event but only writes to DB at intervals
+    pub fn update_position(&self, time_us: u64) {
+        self.last_time_us.store(time_us, Ordering::Relaxed);
+    }
+
+    /// Conditionally write cursor to Postgres if interval has elapsed
+    ///
+    /// This implements debouncing to avoid excessive DB writes while ensuring
+    /// we don't lose more than write_interval seconds of progress on restart
+    pub async fn maybe_write_cursor(&self) -> anyhow::Result<()> {
+        let current_time_us = self.last_time_us.load(Ordering::Relaxed);
+        if current_time_us == 0 {
+            return Ok(());
+        }
+
+        let mut last_write = self.last_write.lock().await;
+        if last_write.elapsed() >= self.write_interval {
+            sqlx::query!(
+                r#"
+                INSERT INTO jetstream_cursor (id, time_us, updated_at)
+                VALUES ($1, $2, NOW())
+                ON CONFLICT (id)
+                DO UPDATE SET time_us = $2, updated_at = NOW()
+                "#,
+                self.cursor_id,
+                current_time_us as i64
+            )
+            .execute(&self.pool)
+            .await?;
+
+            *last_write = Instant::now();
+            debug!(
+                cursor = current_time_us,
+                cursor_id = %self.cursor_id,
+                "Updated jetstream cursor in Postgres"
+            );
+        }
+        Ok(())
+    }
+
+    /// Force immediate write of cursor to Postgres, bypassing interval check
+    ///
+    /// Used during graceful shutdown to ensure latest position is persisted
+    pub async fn force_write_cursor(&self) -> anyhow::Result<()> {
+        let current_time_us = self.last_time_us.load(Ordering::Relaxed);
+        if current_time_us == 0 {
+            return Ok(());
+        }
+
+        sqlx::query!(
+            r#"
+            INSERT INTO jetstream_cursor (id, time_us, updated_at)
+            VALUES ($1, $2, NOW())
+            ON CONFLICT (id)
+            DO UPDATE SET time_us = $2, updated_at = NOW()
+            "#,
+            self.cursor_id,
+            current_time_us as i64
+        )
+        .execute(&self.pool)
+        .await?;
+
+        let mut last_write = self.last_write.lock().await;
+        *last_write = Instant::now();
+
+        debug!(
+            cursor = current_time_us,
+            cursor_id = %self.cursor_id,
+            "Force wrote jetstream cursor to Postgres"
+        );
+        Ok(())
+    }
+
+    /// Read the last persisted cursor position from Postgres
+    ///
+    /// Returns None if no cursor exists or cursor is 0 (indicating fresh start)
+    /// This should be called on startup to resume from last position
+    pub async fn read_cursor(pool: &PgPool, cursor_id: &str) -> Option<i64> {
+        match sqlx::query!(
+            r#"
+            SELECT time_us
+            FROM jetstream_cursor
+            WHERE id = $1
+            "#,
+            cursor_id
+        )
+        .fetch_optional(pool)
+        .await
+        {
+            Ok(Some(row)) => {
+                let time_us = row.time_us;
+                if time_us > 0 {
+                    Some(time_us)
+                } else {
+                    None
+                }
+            }
+            Ok(None) => None,
+            Err(e) => {
+                warn!(error = ?e, "Failed to read cursor from Postgres");
+                None
+            }
+        }
+    }
+}

api/src/main.rs

···
 mod database;
 mod errors;
 mod jetstream;
+mod jetstream_cursor;
 mod jobs;
 mod logging;
 mod models;
···
 use crate::database::Database;
 use crate::errors::AppError;
 use crate::jetstream::JetstreamConsumer;
-use crate::logging::{LogLevel, Logger, start_log_cleanup_task};
+use crate::jetstream_cursor::PostgresCursorHandler;
+use crate::logging::{Logger, start_log_cleanup_task};
 
 #[derive(Clone)]
 pub struct Config {
···
     // Create shared jetstream connection status
     let jetstream_connected = Arc::new(AtomicBool::new(false));
 
-    // Start Jetstream consumer for real-time indexing with automatic recovery
+    // Start Jetstream consumer with cursor persistence and improved reconnection logic
     let database_for_jetstream = database.clone();
+    let pool_for_jetstream = pool.clone();
     let jetstream_connected_clone = jetstream_connected.clone();
     tokio::spawn(async move {
-        let jetstream_hostname = env::var("JETSTREAM_HOSTNAME").ok(); // Optional, will use default if not set
+        let jetstream_hostname = env::var("JETSTREAM_HOSTNAME").ok();
+        let cursor_write_interval = env::var("JETSTREAM_CURSOR_WRITE_INTERVAL_SECS")
+            .unwrap_or_else(|_| "5".to_string())
+            .parse::<u64>()
+            .unwrap_or(5);
 
-        // Create initial consumer to start configuration reloader (only once)
-        let initial_consumer = match JetstreamConsumer::new(
-            database_for_jetstream.clone(),
-            jetstream_hostname.clone(),
-        )
-        .await
-        {
-            Ok(consumer) => {
-                let consumer_arc = std::sync::Arc::new(consumer);
-                // Start configuration reloader ONCE - it will run independently
-                JetstreamConsumer::start_configuration_reloader(consumer_arc.clone());
-                Some(consumer_arc)
+        // Reconnection rate limiting (5 retries per minute max)
+        const MAX_RECONNECTS_PER_MINUTE: u32 = 5;
+        const RECONNECT_WINDOW: tokio::time::Duration = tokio::time::Duration::from_secs(60);
+        let mut reconnect_count = 0u32;
+        let mut window_start = std::time::Instant::now();
+
+        let mut retry_delay = tokio::time::Duration::from_secs(5);
+        const MAX_RETRY_DELAY: tokio::time::Duration = tokio::time::Duration::from_secs(300);
+
+        // Configuration reloader setup (run once)
+        let mut config_reloader_started = false;
+
+        loop {
+            // Rate limiting: reset counter if window has passed
+            let now = std::time::Instant::now();
+            if now.duration_since(window_start) >= RECONNECT_WINDOW {
+                reconnect_count = 0;
+                window_start = now;
             }
-            Err(e) => {
-                tracing::error!("Failed to create initial Jetstream consumer: {}", e);
-                None
+
+            // Check rate limit
+            if reconnect_count >= MAX_RECONNECTS_PER_MINUTE {
+                let wait_time = RECONNECT_WINDOW - now.duration_since(window_start);
+                tracing::warn!(
+                    "Rate limit exceeded: {} reconnects in last minute, waiting {:?}",
+                    reconnect_count, wait_time
+                );
+                tokio::time::sleep(wait_time).await;
+                continue;
             }
-        };
 
-        // Retry loop for Jetstream consumer with exponential backoff
-        let mut retry_delay = tokio::time::Duration::from_secs(5); // Start with 5 seconds
-        const MAX_RETRY_DELAY: tokio::time::Duration = tokio::time::Duration::from_secs(300); // Cap at 5 minutes
-        let mut current_consumer = initial_consumer;
+            reconnect_count += 1;
 
-        loop {
-            tracing::info!("Starting Jetstream consumer...");
-            Logger::global().log_jetstream(
-                LogLevel::Info,
-                "Starting Jetstream consumer",
-                Some(serde_json::json!({"action": "starting_consumer"})),
-            );
+            // Read cursor position from database
+            let initial_cursor = PostgresCursorHandler::read_cursor(&pool_for_jetstream, "default").await;
+            if let Some(cursor) = initial_cursor {
+                tracing::info!("Resuming from cursor position: {}", cursor);
+            } else {
+                tracing::info!("No cursor found, starting from latest events");
+            }
 
-            // Use existing consumer or create new one
-            let consumer_arc = match current_consumer.take() {
-                Some(existing) => existing,
-                None => {
-                    match JetstreamConsumer::new(
-                        database_for_jetstream.clone(),
-                        jetstream_hostname.clone(),
-                    )
-                    .await
-                    {
-                        Ok(consumer) => std::sync::Arc::new(consumer),
-                        Err(e) => {
-                            let message = format!(
-                                "Failed to create Jetstream consumer: {} - will retry in {:?}",
-                                e, retry_delay
-                            );
-                            tracing::error!("{}", message);
-                            Logger::global().log_jetstream(
-                                LogLevel::Error,
-                                &message,
-                                Some(serde_json::json!({
-                                    "error": e.to_string(),
-                                    "retry_delay_secs": retry_delay.as_secs(),
-                                    "action": "consumer_creation_failed"
-                                })),
-                            );
-                            jetstream_connected_clone
-                                .store(false, std::sync::atomic::Ordering::Relaxed);
+            // Create cursor handler
+            let cursor_handler = Arc::new(PostgresCursorHandler::new(
+                pool_for_jetstream.clone(),
+                "default".to_string(),
+                cursor_write_interval,
+            ));
 
-                            // Wait before retrying
-                            tokio::time::sleep(retry_delay).await;
-                            retry_delay = std::cmp::min(retry_delay * 2, MAX_RETRY_DELAY);
-                            continue;
-                        }
+            // Create consumer with cursor support
+            let consumer_result = JetstreamConsumer::new(
+                database_for_jetstream.clone(),
+                jetstream_hostname.clone(),
+                Some(cursor_handler.clone()),
+                initial_cursor,
+            ).await;
+
+            let consumer_arc = match consumer_result {
+                Ok(consumer) => {
+                    let arc = Arc::new(consumer);
+
+                    // Start configuration reloader only once
+                    if !config_reloader_started {
+                        JetstreamConsumer::start_configuration_reloader(arc.clone());
+                        config_reloader_started = true;
                     }
+
+                    arc
+                }
+                Err(e) => {
+                    tracing::error!("Failed to create Jetstream consumer: {} - retry in {:?}", e, retry_delay);
+                    jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
+                    tokio::time::sleep(retry_delay).await;
+                    retry_delay = std::cmp::min(retry_delay * 2, MAX_RETRY_DELAY);
+                    continue;
                 }
             };
 
-            // Reset retry delay on successful connection
+            // Reset retry delay on successful creation
             retry_delay = tokio::time::Duration::from_secs(5);
 
-            // Mark as connected when consumer starts successfully
+            tracing::info!("Starting Jetstream consumer with cursor support...");
             jetstream_connected_clone.store(true, std::sync::atomic::Ordering::Relaxed);
-            tracing::info!("Jetstream consumer connected successfully");
-            Logger::global().log_jetstream(
-                LogLevel::Info,
-                "Jetstream consumer connected",
-                Some(serde_json::json!({
-                    "action": "consumer_connected"
-                })),
-            );
 
-            // Start consuming events
+            // Start consuming with cancellation token
             let cancellation_token = atproto_jetstream::CancellationToken::new();
             match consumer_arc.start_consuming(cancellation_token).await {
-                Err(e) => {
-                    tracing::error!(
-                        "Jetstream consumer disconnected: {} - will retry in {:?}",
-                        e,
-                        retry_delay
-                    );
-                    Logger::global().log_jetstream(
-                        LogLevel::Error,
-                        &format!("Jetstream consumer disconnected: {}", e),
-                        Some(serde_json::json!({
-                            "error": e.to_string(),
-                            "retry_delay_secs": retry_delay.as_secs(),
-                            "action": "consumer_disconnected"
-                        })),
-                    );
-                    // Mark as disconnected on failure
+                Ok(_) => {
+                    tracing::info!("Jetstream consumer shut down normally");
                     jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
                 }
-                Ok(_) => {
-                    tracing::info!("Jetstream consumer closed normally");
-                    Logger::global().log_jetstream(
-                        LogLevel::Info,
-                        "Jetstream consumer closed normally",
-                        Some(serde_json::json!({
-                            "action": "consumer_closed"
-                        })),
-                    );
-                    // This shouldn't happen in normal operation since start_consuming should run indefinitely
+                Err(e) => {
+                    tracing::error!("Jetstream consumer failed: {} - will reconnect", e);
                     jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
+                    tokio::time::sleep(retry_delay).await;
+                    retry_delay = std::cmp::min(retry_delay * 2, MAX_RETRY_DELAY);
                 }
             }
-
-            // Wait before retrying with exponential backoff
-            tokio::time::sleep(retry_delay).await;
-
-            // Increase retry delay, but cap it at MAX_RETRY_DELAY
-            retry_delay = std::cmp::min(retry_delay * 2, MAX_RETRY_DELAY);
         }
     });