Address soundness hole in cycle prevention

benches/comparisons/deep_chain.rs

@@ -3,6 +3,7 @@
 //! Long sequential chain: 100 tasks in sequence
 
 use criterion::Criterion;
+use dagx::TaskHandle;
 use futures::FutureExt;
 
 pub fn bench_deep_chain(c: &mut Criterion) {
@@ -17,10 +18,10 @@ pub fn bench_deep_chain(c: &mut Criterion) {
 
                 let dag = DagRunner::new();
 
-                let first = dag.add_task(task_fn(|_: ()| async { 0 }));
+                let first: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 0 })).into();
                 let mut prev = dag
                     .add_task(task_fn(|x: i32| async move { x + 1 }))
-                    .depends_on(&first);
+                    .depends_on(first);
 
                 for i in 2..100 {
                     prev = dag

benches/comparisons/diamond_pattern.rs

@@ -3,6 +3,7 @@
 //! Classic diamond: A → B,C → D
 
 use criterion::Criterion;
+use dagx::TaskHandle;
 use futures::FutureExt;
 
 pub fn bench_diamond_pattern(c: &mut Criterion) {
@@ -17,13 +18,13 @@ pub fn bench_diamond_pattern(c: &mut Criterion) {
 
                 let dag = DagRunner::new();
 
-                let a = dag.add_task(task_fn(|_: ()| async { 10 }));
+                let a: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 10 })).into();
                 let b = dag
                     .add_task(task_fn(|x: i32| async move { x * 2 }))
-                    .depends_on(&a);
+                    .depends_on(a);
                 let c = dag
                     .add_task(task_fn(|x: i32| async move { x + 5 }))
-                    .depends_on(&a);
+                    .depends_on(a);
                 let d = dag
                     .add_task(task_fn(|(x, y): (i32, i32)| async move { x + y }))
                     .depends_on((&b, &c));

benches/comparisons/etl_pipeline.rs

@@ -27,19 +27,19 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                     .add_task(task_fn(|data: Vec<i32>| async move {
                         data.into_iter().map(|x| x * 2).collect::<Vec<_>>()
                     }))
-                    .depends_on(&source1);
+                    .depends_on(source1);
 
                 let transform2 = dag
                     .add_task(task_fn(|data: Vec<i32>| async move {
                         data.into_iter().map(|x| x * 2).collect::<Vec<_>>()
                     }))
-                    .depends_on(&source2);
+                    .depends_on(source2);
 
                 let transform3 = dag
                     .add_task(task_fn(|data: Vec<i32>| async move {
                         data.into_iter().map(|x| x * 2).collect::<Vec<_>>()
                     }))
-                    .depends_on(&source3);
+                    .depends_on(source3);
 
                 // Merge all transformed data
                 let merge = dag

benches/comparisons/linear_pipeline.rs

@@ -20,7 +20,7 @@ pub fn bench_linear_pipeline(c: &mut Criterion) {
                 let a = dag.add_task(task_fn(|_: ()| async { 1 }));
                 let b = dag
                     .add_task(task_fn(|x: i32| async move { x + 1 }))
-                    .depends_on(&a);
+                    .depends_on(a);
                 let c = dag
                     .add_task(task_fn(|x: i32| async move { x * 2 }))
                     .depends_on(b);

benches/comparisons/wide_fanout.rs

@@ -3,6 +3,7 @@
 //! One source task feeding 100 dependent tasks
 
 use criterion::Criterion;
+use dagx::TaskHandle;
 use futures::FutureExt;
 
 pub fn bench_wide_fanout(c: &mut Criterion) {
@@ -16,12 +17,12 @@ pub fn bench_wide_fanout(c: &mut Criterion) {
                 use dagx::{task_fn, DagRunner};
 
                 let dag = DagRunner::new();
-                let source = dag.add_task(task_fn(|_: ()| async { 42 }));
+                let source: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 42 })).into();
 
                 // Create 100 tasks that all depend on source
                 for i in 0..100 {
                     dag.add_task(task_fn(move |x: i32| async move { x + i }))
-                        .depends_on(&source);
+                        .depends_on(source);
                 }
 
                 dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))