fix: enhance error handling in Node and Task execution phases to preserve original error variants when retries are disabled

Author: nassor

src/node.rs

@@ -344,6 +344,9 @@ where
                             if attempt >= max_attempts {
                                 #[cfg(feature = "tracing")]
                                 tracing::error!(attempt = attempt, error = ?e, "Node execution failed after maximum attempts");
+                                if max_attempts <= 1 {
+                                    return Err(e);
+                                }
                                 return Err(CanoError::retry_exhausted(format!(
                                     "Node post phase failed after {} attempt(s): {}",
                                     attempt, e
@@ -371,6 +374,9 @@ where
                     if attempt >= max_attempts {
                         #[cfg(feature = "tracing")]
                         tracing::error!(attempt = attempt, error = ?e, "Node execution failed after maximum attempts");
+                        if max_attempts <= 1 {
+                            return Err(e);
+                        }
                         return Err(CanoError::retry_exhausted(format!(
                             "Node prep phase failed after {} attempt(s): {}",
                             attempt, e
@@ -1940,4 +1946,84 @@ mod tests {
             "expected RetryExhausted after retry exhaustion, got: {err}"
         );
     }
+
+    #[tokio::test]
+    async fn test_node_no_retry_preserves_error_variant() {
+        use std::sync::atomic::{AtomicUsize, Ordering};
+
+        struct PrepFailNode {
+            attempt_counter: Arc<AtomicUsize>,
+        }
+
+        #[async_trait]
+        impl Node<TestAction> for PrepFailNode {
+            type PrepResult = ();
+            type ExecResult = ();
+
+            fn config(&self) -> TaskConfig {
+                TaskConfig::minimal()
+            }
+
+            async fn prep(&self, _store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+                self.attempt_counter.fetch_add(1, Ordering::SeqCst);
+                Err(CanoError::preparation("prep boom"))
+            }
+
+            async fn exec(&self, _prep_res: Self::PrepResult) -> Self::ExecResult {}
+
+            async fn post(
+                &self,
+                _store: &MemoryStore,
+                _exec_res: Self::ExecResult,
+            ) -> Result<TestAction, CanoError> {
+                Ok(TestAction::Complete)
+            }
+        }
+
+        let node = PrepFailNode {
+            attempt_counter: Arc::new(AtomicUsize::new(0)),
+        };
+        let store = MemoryStore::new();
+        let err = node.run(&store).await.unwrap_err();
+
+        assert_eq!(node.attempt_counter.load(Ordering::SeqCst), 1);
+        assert!(
+            matches!(err, CanoError::Preparation(_)),
+            "expected original Preparation variant when retries disabled, got: {err}"
+        );
+        assert!(err.to_string().contains("prep boom"));
+
+        struct PostFailNode;
+
+        #[async_trait]
+        impl Node<TestAction> for PostFailNode {
+            type PrepResult = ();
+            type ExecResult = ();
+
+            fn config(&self) -> TaskConfig {
+                TaskConfig::minimal()
+            }
+
+            async fn prep(&self, _store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+                Ok(())
+            }
+
+            async fn exec(&self, _prep_res: Self::PrepResult) -> Self::ExecResult {}
+
+            async fn post(
+                &self,
+                _store: &MemoryStore,
+                _exec_res: Self::ExecResult,
+            ) -> Result<TestAction, CanoError> {
+                Err(CanoError::node_execution("post boom"))
+            }
+        }
+
+        let err = PostFailNode.run(&store).await.unwrap_err();
+        assert!(
+            matches!(err, CanoError::NodeExecution(_)),
+            "expected original NodeExecution variant when retries disabled, got: {err}"
+        );
+        assert!(err.to_string().contains("post boom"));
+    }
 }

src/store/memory.rs

@@ -757,7 +757,10 @@ mod tests {
         let arc2: Arc<String> = store.get_shared("msg").unwrap();
 
         assert_eq!(*arc1, "hello");
-        assert_eq!(arc1, arc2);
+        assert!(
+            Arc::ptr_eq(&arc1, &arc2),
+            "get_shared must return clones of the same Arc, not fresh allocations"
+        );
     }
 
     #[test]

src/task.rs

@@ -300,6 +300,9 @@ where
                 }
 
                 if attempt >= max_attempts {
+                    if max_attempts <= 1 {
+                        return Err(e);
+                    }
                     return Err(CanoError::retry_exhausted(format!(
                         "Task failed after {} attempt(s): {}",
                         attempt, e
@@ -1068,7 +1071,12 @@ mod tests {
 
         assert!(result.is_err());
         assert_eq!(counter.load(Ordering::SeqCst), 1);
-        assert!(result.unwrap_err().to_string().contains("immediate fail"));
+        let err = result.unwrap_err();
+        assert!(
+            matches!(err, CanoError::TaskExecution(_)),
+            "expected original TaskExecution variant when retries disabled, got: {err}"
+        );
+        assert!(err.to_string().contains("immediate fail"));
     }
 
     #[tokio::test]