fix: treat HTTP 402 (payment required) as non-retryable

OpenRouter 402 'requires more credits' errors were being retried by both
the SSE stream retry loop and the auto-poke continuation logic, wasting
time and re-hitting the same deterministic failure.

- openrouter_sse_stream: parse the reported HTTP status and short-circuit
  4xx client errors (400/401/402/403/404/405/406/422) as non-retryable,
  before the loose 5xx substring heuristics.
- auto-poke: add 402/credit-exhaustion markers to the non-retryable set.
- add unit tests for both paths.

Author: 1jehuang

crates/jcode-base/src/provider/openrouter_sse_stream.rs

@@ -219,7 +219,36 @@ async fn stream_response(
     Ok(())
 }
 
+/// Extract the HTTP status code reported in a formatted provider error string.
+///
+/// Error strings produced in this module embed the status as `status: <code>`
+/// (e.g. `status: 402 Payment Required`). The input may be lowercased before
+/// it reaches here, so matching is case-insensitive.
+fn parsed_http_status(error_str: &str) -> Option<u16> {
+    let lower = error_str.to_ascii_lowercase();
+    let idx = lower.find("status:")?;
+    let rest = lower[idx + "status:".len()..].trim_start();
+    let digits: String = rest.chars().take_while(|c| c.is_ascii_digit()).collect();
+    if digits.len() == 3 {
+        digits.parse().ok()
+    } else {
+        None
+    }
+}
+
 fn is_retryable_error(error_str: &str) -> bool {
+    // Explicit non-retryable HTTP statuses take precedence over the loose
+    // substring heuristics below. These are deterministic client-side failures
+    // (auth, billing, malformed request) where retrying is futile and just
+    // burns time/credits. 429 (rate limit) is intentionally NOT listed here so
+    // it can still be retried.
+    if let Some(status) = parsed_http_status(error_str) {
+        match status {
+            400 | 401 | 402 | 403 | 404 | 405 | 406 | 422 => return false,
+            _ => {}
+        }
+    }
+
     crate::provider::is_transient_transport_error(error_str)
         || error_str.contains("stream error")
         || error_str.contains("eof")
@@ -801,4 +830,49 @@ mod tests {
         assert!(hint.contains("Local Server"));
         assert!(hint.contains("/v1/models"));
     }
+
+    #[test]
+    fn parsed_http_status_extracts_code() {
+        assert_eq!(
+            parsed_http_status("status: 402 payment required"),
+            Some(402)
+        );
+        assert_eq!(parsed_http_status("  status:404 not found"), Some(404));
+        assert_eq!(parsed_http_status("no status here"), None);
+        // Embedded numbers elsewhere must not be misread as a status.
+        assert_eq!(parsed_http_status("you requested 65536 tokens"), None);
+    }
+
+    #[test]
+    fn payment_required_is_not_retryable() {
+        let err = "openai-compatible chat request failed\n  endpoint: \
+            https://openrouter.ai/api/v1/chat/completions\n  model: openai/gpt-5.4\n  \
+            auth: openrouter_api_key\n  status: 402 payment required\n  response: \
+            {\"error\":{\"message\":\"this request requires more credits, or fewer \
+            max_tokens. you requested up to 65536 tokens, but can only afford 34424\"}}";
+        assert!(!is_retryable_error(err));
+    }
+
+    #[test]
+    fn client_errors_are_not_retryable() {
+        for status in [400u16, 401, 402, 403, 404, 405, 406, 422] {
+            let err = format!("chat request failed\n  status: {status} client error");
+            assert!(
+                !is_retryable_error(&err),
+                "status {status} should not be retryable"
+            );
+        }
+    }
+
+    #[test]
+    fn server_errors_remain_retryable() {
+        assert!(is_retryable_error(
+            "chat request failed\n  status: 503 service unavailable"
+        ));
+        assert!(is_retryable_error(
+            "chat request failed\n  status: 500 internal server error"
+        ));
+        // Rate limiting should still be retried.
+        assert!(is_retryable_error("overloaded"));
+    }
 }

crates/jcode-tui/src/tui/app/commands.rs

@@ -145,8 +145,14 @@ pub(super) fn is_non_retryable_auto_poke_error(error: &str) -> bool {
         "401 unauthorized",
         "403 forbidden",
         "insufficient_quota",
+        "402 payment required",
+        "payment required",
+        "requires more credits",
+        "add more credits",
+        "more credits",
         "billing",
         "credit balance",
+        "out of credits",
     ];
 
     deterministic_markers

crates/jcode-tui/src/tui/app/commands_tests.rs

@@ -56,3 +56,22 @@ fn parse_manual_subagent_spec_rejects_missing_prompt() {
         .expect_err("missing prompt should be rejected");
     assert!(err.contains("Missing prompt"));
 }
+
+#[test]
+fn openrouter_402_payment_required_is_non_retryable() {
+    use super::is_non_retryable_auto_poke_error;
+    let err = "OpenAI-compatible chat request failed\n  endpoint: \
+        https://openrouter.ai/api/v1/chat/completions\n  model: openai/gpt-5.4\n  \
+        auth: OPENROUTER_API_KEY\n  status: 402 Payment Required\n  response: \
+        {\"error\":{\"message\":\"This request requires more credits, or fewer max_tokens. \
+        You requested up to 65536 tokens, but can only afford 34424. To increase, visit \
+        https://openrouter.ai/settings/credits and add more credits\",\"code\":402}}";
+    assert!(is_non_retryable_auto_poke_error(err));
+}
+
+#[test]
+fn transient_server_error_remains_retryable_for_auto_poke() {
+    use super::is_non_retryable_auto_poke_error;
+    let err = "OpenAI-compatible chat request failed\n  status: 503 Service Unavailable";
+    assert!(!is_non_retryable_auto_poke_error(err));
+}