@@ -13,6 +13,7 @@ use super::Result;
 use crate::can_track::can_track;
 use crate::collect::{Collect, posthog};
 use crate::event::Identity;
+use crate::rate_limit::RateLimiter;
 use crate::{Event, EventKind, client_id};
 
 const POSTHOG_API_SECRET: &str = match option_env!("POSTHOG_API_SECRET") {
@@ -47,6 +48,13 @@ static CACHED_PATH: LazyLock<Option<String>> = LazyLock::new(|| {
 });
 static CACHED_ARGS: LazyLock<Vec<String>> = LazyLock::new(|| std::env::args().skip(1).collect());
 
+/// Maximum number of events that can be dispatched per minute.
+///
+/// This acts as a rate limiter to prevent runaway loops (e.g. when
+/// stdout/stderr is closed and every write error triggers another error event)
+/// while allowing normal tracking to continue for long-running sessions.
+const MAX_EVENTS_PER_MINUTE: usize = 1_000;
+
 #[derive(Clone)]
 pub struct Tracker {
     collectors: Arc<Vec<Box<dyn Collect>>>,
@@ -56,6 +64,7 @@ pub struct Tracker {
     model: Arc<Mutex<Option<String>>>,
     conversation: Arc<Mutex<Option<Conversation>>>,
     is_logged_in: Arc<AtomicBool>,
+    rate_limiter: Arc<RateLimiter>,
 }
 
 impl Default for Tracker {
@@ -71,6 +80,7 @@ impl Default for Tracker {
             model: Arc::new(Mutex::new(None)),
             conversation: Arc::new(Mutex::new(None)),
             is_logged_in: Arc::new(AtomicBool::new(false)),
+            rate_limiter: Arc::new(RateLimiter::new(MAX_EVENTS_PER_MINUTE)),
         }
     }
 }
@@ -93,35 +103,41 @@ impl Tracker {
     }
 
     pub async fn dispatch(&self, event_kind: EventKind) -> Result<()> {
-        if self.can_track {
-            // Create a new event
-            let email = self.email().await;
-            let event = Event {
-                event_name: event_kind.name(),
-                event_value: event_kind.value(),
-                start_time: self.start_time,
-                cores: cores(),
-                client_id: client_id(),
-                os_name: os_name(),
-                up_time: up_time(self.start_time),
-                args: args(),
-                path: path(),
-                cwd: cwd(),
-                user: user(),
-                version: version(),
-                email: email.clone(),
-                model: self.model.lock().await.clone(),
-                conversation: self.conversation().await,
-                identity: match event_kind {
-                    EventKind::Login(id) => Some(id),
-                    _ => None,
-                },
-            };
-
-            // Dispatch the event to all collectors
-            for collector in self.collectors.as_ref() {
-                collector.collect(event.clone()).await?;
-            }
+        if !self.can_track {
+            return Ok(());
+        }
+
+        if !self.rate_limiter.check() {
+            return Ok(()); // Drop event if rate limit exceeded
+        }
+
+        // Create a new event
+        let email = self.email().await;
+        let event = Event {
+            event_name: event_kind.name(),
+            event_value: event_kind.value(),
+            start_time: self.start_time,
+            cores: cores(),
+            client_id: client_id(),
+            os_name: os_name(),
+            up_time: up_time(self.start_time),
+            args: args(),
+            path: path(),
+            cwd: cwd(),
+            user: user(),
+            version: version(),
+            email: email.clone(),
+            model: self.model.lock().await.clone(),
+            conversation: self.conversation().await,
+            identity: match event_kind {
+                EventKind::Login(id) => Some(id),
+                _ => None,
+            },
+        };
+
+        // Dispatch the event to all collectors
+        for collector in self.collectors.as_ref() {
+            collector.collect(event.clone()).await?;
         }
         Ok(())
     }
 
@@ -5,6 +5,7 @@ mod dispatch;
 mod error;
 mod event;
 mod log;
+mod rate_limit;
 pub use can_track::VERSION;
 pub use dispatch::Tracker;
 use error::Result;
 
@@ -0,0 +1,61 @@
+use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
+
+use chrono::Utc;
+
+/// A simple thread-safe rate limiter that allows a maximum number of events per
+/// minute.
+#[derive(Debug)]
+pub struct RateLimiter {
+    max_per_minute: usize,
+    window_start: AtomicU64,
+    count: AtomicUsize,
+}
+
+impl RateLimiter {
+    /// Creates a new rate limiter with the specified maximum events per minute.
+    pub fn new(max_per_minute: usize) -> Self {
+        Self {
+            max_per_minute,
+            window_start: AtomicU64::new(Utc::now().timestamp() as u64),
+            count: AtomicUsize::new(0),
+        }
+    }
+
+    /// Checks if an event should be allowed based on the rate limit.
+    /// Returns true if the event is allowed, false if it should be dropped.
+    pub fn check(&self) -> bool {
+        let now = Utc::now().timestamp() as u64;
+        let window_start = self.window_start.load(Ordering::Relaxed);
+
+        // If a minute has passed, reset the window and counter
+        if now.saturating_sub(window_start) >= 60 {
+            // We use compare_exchange to avoid race conditions when multiple threads try to
+            // reset
+            if self
+                .window_start
+                .compare_exchange(window_start, now, Ordering::SeqCst, Ordering::Relaxed)
+                .is_ok()
+            {
+                self.count.store(0, Ordering::SeqCst);
+            }
+        }
+
+        // Increment and check the rate limit
+        self.count.fetch_add(1, Ordering::Relaxed) < self.max_per_minute
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rate_limiter() {
+        let limiter = RateLimiter::new(2);
+
+        assert!(limiter.check()); // 1
+        assert!(limiter.check()); // 2
+        assert!(!limiter.check()); // 3 - blocked
+        assert!(!limiter.check()); // 4 - blocked
+    }
+}