From 6c1d670a57c12262eb2db93190fcbfb0d0d5e70b Mon Sep 17 00:00:00 2001 From: damocles Date: Sat, 21 Nov 2026 13:02:48 +0100 Subject: [PATCH] swarm-review-classifier: a claude that exits non-zero reports the error it printed --- swarm-review-classifier/src/run.rs | 81 +++++++++++++++++++++++++++++- 1 file changed, 79 insertions(+), 2 deletions(-) diff --git a/swarm-review-classifier/src/run.rs b/swarm-review-classifier/src/run.rs index 10d8d5eea..848acbd48 100644 --- a/swarm-review-classifier/src/run.rs +++ b/swarm-review-classifier/src/run.rs @@ -320,7 +320,7 @@ impl Claude { tokio::pin!(wait); match tokio::time::timeout(deadline, &mut wait).await { Ok(Ok(())) => sink.take(), - Ok(Err(e)) => Err(format!("claude failed: {e}")), + Ok(Err(e)) => Err(claude_failure(&e.to_string(), sink.reported_error())), Err(_) => { cancel.cancel(true); let _ = wait.await; @@ -414,6 +414,33 @@ impl ResultSink { .take() .unwrap_or_else(|| Err("claude ended without a result".to_owned())) } + + /// What claude said when its `result` event was an error, without + /// consuming the outcome: the reason a run that then exited non-zero + /// failed, which the exit status alone does not carry. + fn reported_error(&self) -> Option { + match &*self + .result + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + { + Some(Err(reported)) => Some(reported.clone()), + _ => None, + } + } +} + +/// The failure text for a claude that exited non-zero: its exit (with the +/// stderr tail it carries) and, when claude reported one, the error from its +/// `result` event. A claude that dies on an API or account error writes that +/// error to stdout and nothing to stderr, so the exit alone reads as a bare +/// status. +fn claude_failure(exit: &str, reported: Option) -> String { + let exit = exit.trim_end(); + match reported { + Some(reported) => format!("claude failed: {exit}; {reported}"), + None => format!("claude failed: {exit}"), + } } impl Sink for ResultSink { @@ -421,7 +448,11 @@ impl Sink for ResultSink { if event["type"] != "result" { return; } - let text = event["result"].as_str().unwrap_or_default().to_owned(); + let text = match event["result"].as_str().filter(|t| !t.is_empty()) { + Some(text) => text, + None => event["subtype"].as_str().unwrap_or_default(), + } + .to_owned(); let outcome = if event["is_error"].as_bool().unwrap_or(false) { Err(format!("claude reported an error: {text}")) } else { @@ -522,6 +553,52 @@ mod tests { ); } + fn sink_after(event: &serde_json::Value) -> ResultSink { + let sink = ResultSink::default(); + sink.on_event(event); + sink + } + + #[test] + fn an_error_result_is_what_a_nonzero_exit_reports() { + let sink = sink_after(&serde_json::json!({ + "type": "result", "is_error": true, + "result": "Credit balance is too low", + })); + let reported = sink.reported_error(); + assert_eq!( + claude_failure("claude exited exit status: 1\n", reported), + "claude failed: claude exited exit status: 1; claude reported an error: \ + Credit balance is too low" + ); + // Reading it does not consume the outcome. + assert!(sink.take().is_err()); + } + + #[test] + fn an_error_result_without_text_names_its_subtype() { + let sink = sink_after(&serde_json::json!({ + "type": "result", "is_error": true, "subtype": "error_during_execution", + })); + assert_eq!( + sink.reported_error().as_deref(), + Some("claude reported an error: error_during_execution") + ); + } + + #[test] + fn no_reported_error_leaves_the_exit_alone() { + let ok = sink_after(&serde_json::json!({ + "type": "result", "is_error": false, "result": "{}", + })); + assert_eq!(ok.reported_error(), None); + assert_eq!(ResultSink::default().reported_error(), None); + assert_eq!( + claude_failure("claude exited exit status: 1\nsome stderr", None), + "claude failed: claude exited exit status: 1\nsome stderr" + ); + } + #[test] fn chain_renders_every_level() { let e = Level(