feat: parse and display rate_limit_event messages from Claude CLI

Closes #155

- Add RateLimitInfo struct and RateLimitEvent variant to ClaudeMessage
- Emit rate-limit OutputEvent with human-readable message in wsl_bridge
- Add rate-limit line type to TerminalLine union and Terminal rendering
- Display rate-limit lines in amber with [rate-limit] prefix
- Add Terminal.test.ts with 28 tests for getLineClass, getLinePrefix,
  formatTime, isToolContentLong, and truncateToolContent

src-tauri/src/types.rs

@@ -63,6 +63,26 @@ pub struct PermissionDenial {
     pub tool_input: serde_json::Value,
 }
 
+/// Rate limit information from a `rate_limit_event` message.
+/// All fields are optional to ensure forward-compatibility as the Claude CLI evolves.
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct RateLimitInfo {
+    #[serde(default)]
+    pub requests_limit: Option<u64>,
+    #[serde(default)]
+    pub requests_remaining: Option<u64>,
+    #[serde(default)]
+    pub requests_reset: Option<String>,
+    #[serde(default)]
+    pub tokens_limit: Option<u64>,
+    #[serde(default)]
+    pub tokens_remaining: Option<u64>,
+    #[serde(default)]
+    pub tokens_reset: Option<String>,
+    #[serde(default)]
+    pub retry_after_ms: Option<u64>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type")]
 pub enum ClaudeMessage {
@@ -100,6 +120,11 @@ pub enum ClaudeMessage {
         #[serde(default)]
         usage: Option<UsageInfo>,
     },
+    #[serde(rename = "rate_limit_event")]
+    RateLimitEvent {
+        #[serde(default)]
+        rate_limit_info: RateLimitInfo,
+    },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -446,4 +471,77 @@ mod tests {
         assert!(serialized.contains("\"input_tokens\":100"));
         assert!(serialized.contains("\"output_tokens\":50"));
     }
+
+    #[test]
+    fn test_rate_limit_info_default() {
+        let info = RateLimitInfo::default();
+        assert!(info.requests_limit.is_none());
+        assert!(info.requests_remaining.is_none());
+        assert!(info.requests_reset.is_none());
+        assert!(info.tokens_limit.is_none());
+        assert!(info.tokens_remaining.is_none());
+        assert!(info.tokens_reset.is_none());
+        assert!(info.retry_after_ms.is_none());
+    }
+
+    #[test]
+    fn test_rate_limit_event_deserialization_empty_info() {
+        let json = r#"{"type":"rate_limit_event","rate_limit_info":{}}"#;
+        let msg: ClaudeMessage = serde_json::from_str(json).unwrap();
+        assert!(matches!(msg, ClaudeMessage::RateLimitEvent { .. }));
+    }
+
+    #[test]
+    fn test_rate_limit_event_deserialization_no_info() {
+        // rate_limit_info field is optional via #[serde(default)]
+        let json = r#"{"type":"rate_limit_event"}"#;
+        let msg: ClaudeMessage = serde_json::from_str(json).unwrap();
+        assert!(matches!(msg, ClaudeMessage::RateLimitEvent { .. }));
+    }
+
+    #[test]
+    fn test_rate_limit_event_deserialization_with_data() {
+        let json = r#"{
+            "type": "rate_limit_event",
+            "rate_limit_info": {
+                "requests_limit": 1000,
+                "requests_remaining": 0,
+                "requests_reset": "2024-01-01T00:01:00Z",
+                "tokens_limit": 50000,
+                "tokens_remaining": 0,
+                "tokens_reset": "2024-01-01T00:01:00Z",
+                "retry_after_ms": 60000
+            }
+        }"#;
+        let msg: ClaudeMessage = serde_json::from_str(json).unwrap();
+        if let ClaudeMessage::RateLimitEvent { rate_limit_info } = msg {
+            assert_eq!(rate_limit_info.requests_limit, Some(1000));
+            assert_eq!(rate_limit_info.requests_remaining, Some(0));
+            assert_eq!(
+                rate_limit_info.requests_reset,
+                Some("2024-01-01T00:01:00Z".to_string())
+            );
+            assert_eq!(rate_limit_info.retry_after_ms, Some(60000));
+        } else {
+            panic!("Expected RateLimitEvent variant");
+        }
+    }
+
+    #[test]
+    fn test_rate_limit_event_ignores_unknown_fields() {
+        // Ensures forward-compat: unknown fields in rate_limit_info are silently ignored
+        let json = r#"{
+            "type": "rate_limit_event",
+            "rate_limit_info": {
+                "requests_remaining": 0,
+                "some_future_field": "some_value"
+            }
+        }"#;
+        let msg: ClaudeMessage = serde_json::from_str(json).unwrap();
+        if let ClaudeMessage::RateLimitEvent { rate_limit_info } = msg {
+            assert_eq!(rate_limit_info.requests_remaining, Some(0));
+        } else {
+            panic!("Expected RateLimitEvent variant");
+        }
+    }
 }

src-tauri/src/wsl_bridge.rs

@@ -1521,6 +1521,23 @@ fn process_json_line(
             emit_state_change(app, state, None, conversation_id.clone());
         }
 
+        ClaudeMessage::RateLimitEvent { rate_limit_info } => {
+            tracing::warn!("Rate limit event received: {:?}", rate_limit_info);
+
+            let content = format_rate_limit_message(rate_limit_info);
+            let _ = app.emit(
+                "claude:output",
+                OutputEvent {
+                    line_type: "rate-limit".to_string(),
+                    content,
+                    tool_name: None,
+                    conversation_id: conversation_id.clone(),
+                    cost: None,
+                    parent_tool_use_id: None,
+                },
+            );
+        }
+
         ClaudeMessage::User { message } => {
             // Increment message count for user messages
             stats.write().increment_messages();
@@ -1629,6 +1646,35 @@ fn get_tool_state(tool_name: &str) -> CharacterState {
     }
 }
 
+fn format_rate_limit_message(info: &crate::types::RateLimitInfo) -> String {
+    let mut parts = Vec::new();
+
+    if let (Some(remaining), Some(limit)) = (info.requests_remaining, info.requests_limit) {
+        parts.push(format!("requests: {}/{}", remaining, limit));
+    }
+
+    if let (Some(remaining), Some(limit)) = (info.tokens_remaining, info.tokens_limit) {
+        parts.push(format!("tokens: {}/{}", remaining, limit));
+    }
+
+    if let Some(reset) = &info.requests_reset {
+        parts.push(format!("resets at {}", reset));
+    } else if let Some(reset) = &info.tokens_reset {
+        parts.push(format!("resets at {}", reset));
+    }
+
+    if let Some(retry_ms) = info.retry_after_ms {
+        let secs = retry_ms / 1000;
+        parts.push(format!("retry after {}s", secs));
+    }
+
+    if parts.is_empty() {
+        "Rate limit reached".to_string()
+    } else {
+        format!("Rate limit reached — {}", parts.join(", "))
+    }
+}
+
 fn format_tool_description(name: &str, input: &serde_json::Value) -> String {
     // Helper function to check if a path is a memory file
     fn is_memory_path(path: &str) -> bool {