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");
+        }
+    }
 }