diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs b/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
index d7e830ead586b..fe1f662ed518e 100644
--- a/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
@@ -609,7 +609,7 @@ impl Backend for TurboTasksBackend {
 
         let task_type = Arc::new(task_type);
         let task_id = self.transient_task_id_factory.get();
-        if let Err(existing_task_id) = self.task_cache.try_insert(task_type, task_id) {
+        if let Err(existing_task_id) = self.task_cache.try_insert(task_type.clone(), task_id) {
             // Safety: We just created the id and failed to insert it.
             unsafe {
                 self.transient_task_id_factory.reuse(task_id);
@@ -618,6 +618,8 @@ impl Backend for TurboTasksBackend {
             return existing_task_id;
         }
 
+        println!("{task_id} {task_type:?}");
+
         self.connect_child(parent_task, task_id, turbo_tasks);
 
         task_id
diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs b/turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs
index 71d39e7663013..0fac9b82ea6a5 100644
--- a/turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs
@@ -140,6 +140,7 @@ impl AggregatedDataUpdate {
             dirty_task_count,
             dirty_tasks_update,
         } = self;
+        println!("apply {:?} {dirty_tasks_update:?}", task.id());
         let mut result = Self::default();
         if *dirty_task_count != 0 {
             update!(task, AggregatedDirtyTaskCount, |old: Option<i32>| {
@@ -268,6 +269,7 @@ impl AggregationUpdateQueue {
 
     pub fn process(&mut self, ctx: &ExecuteContext<'_>) -> bool {
         if let Some(job) = self.jobs.pop_front() {
+            println!("process {:?}", job);
             match job {
                 AggregationUpdateJob::UpdateAggregationNumber {
                     task_id,
@@ -276,6 +278,10 @@ impl AggregationUpdateQueue {
                     let mut task = ctx.task(task_id);
                     let old = get_aggregation_number(&task);
                     if old < aggregation_number {
+                        println!(
+                            "UpdateAggregationNumber {:?} {} -> {}",
+                            task_id, old, aggregation_number
+                        );
                         task.insert(CachedDataItem::AggregationNumber {
                             value: aggregation_number,
                         });
@@ -565,6 +571,11 @@ impl AggregationUpdateQueue {
                     let (mut upper, mut task) = ctx.task_pair(upper_id, task_id);
                     let upper_aggregation_number = get_aggregation_number(&upper);
                     let task_aggregation_number = get_aggregation_number(&task);
+                    println!(
+                        "BalanceEdge {:?} {upper_aggregation_number} {:?} \
+                         {task_aggregation_number}",
+                        upper_id, task_id
+                    );
 
                     let should_be_inner = is_root_node(upper_aggregation_number)
                         || upper_aggregation_number > task_aggregation_number;
@@ -675,7 +686,12 @@ impl AggregationUpdateQueue {
             }
         }
 
-        self.jobs.is_empty()
+        if self.jobs.is_empty() {
+            println!("done");
+            true
+        } else {
+            false
+        }
     }
 }
 
diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/operation/invalidate.rs b/turbopack/crates/turbo-tasks-backend/src/backend/operation/invalidate.rs
index 106d3e4d5a3ab..890eb03d81b6d 100644
--- a/turbopack/crates/turbo-tasks-backend/src/backend/operation/invalidate.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/backend/operation/invalidate.rs
@@ -61,10 +61,14 @@ impl Operation for InvalidateOperation {
 pub fn make_task_dirty(task_id: TaskId, queue: &mut AggregationUpdateQueue, ctx: &ExecuteContext) {
     let mut task = ctx.task(task_id);
 
+    println!("make_task_dirty {:?}", task_id);
+
     if task.add(CachedDataItem::Dirty { value: () }) {
         queue.push(AggregationUpdateJob::DataUpdate {
             task_id,
             update: AggregatedDataUpdate::dirty_task(task_id),
         })
+    } else {
+        println!("already dirty");
     }
 }
diff --git a/turbopack/crates/turbo-tasks-backend/tests/emptied_cells.rs b/turbopack/crates/turbo-tasks-backend/tests/emptied_cells.rs
new file mode 120000
index 0000000000000..9070c4d0b4dcc
--- /dev/null
+++ b/turbopack/crates/turbo-tasks-backend/tests/emptied_cells.rs
@@ -0,0 +1 @@
+../../turbo-tasks-testing/tests/emptied_cells.rs
\ No newline at end of file
diff --git a/turbopack/crates/turbo-tasks-backend/tests/scope_stress.rs b/turbopack/crates/turbo-tasks-backend/tests/scope_stress.rs
new file mode 120000
index 0000000000000..0ca21b0967629
--- /dev/null
+++ b/turbopack/crates/turbo-tasks-backend/tests/scope_stress.rs
@@ -0,0 +1 @@
+../../turbo-tasks-testing/tests/scope_stress.rs
\ No newline at end of file
diff --git a/turbopack/crates/turbo-tasks-testing/tests/emptied_cells.rs b/turbopack/crates/turbo-tasks-testing/tests/emptied_cells.rs
index e2b1624eb4298..63658a34b33e8 100644
--- a/turbopack/crates/turbo-tasks-testing/tests/emptied_cells.rs
+++ b/turbopack/crates/turbo-tasks-testing/tests/emptied_cells.rs
@@ -50,12 +50,14 @@ struct ChangingInput {
 #[turbo_tasks::function]
 async fn compute(input: Vc<ChangingInput>) -> Result<Vc<u32>> {
     let value = *inner_compute(input).await?;
+    println!("compute {value}");
     Ok(Vc::cell(value))
 }
 
 #[turbo_tasks::function]
 async fn inner_compute(input: Vc<ChangingInput>) -> Result<Vc<u32>> {
     let state_value = *input.await?.state.get();
+    println!("inner_compute {state_value}");
     let mut last = None;
     for i in 0..=state_value {
         last = Some(compute2(Vc::cell(i)));
@@ -66,5 +68,6 @@ async fn inner_compute(input: Vc<ChangingInput>) -> Result<Vc<u32>> {
 #[turbo_tasks::function]
 async fn compute2(input: Vc<u32>) -> Result<Vc<u32>> {
     let value = *input.await?;
+    println!("compute2 {value}");
     Ok(Vc::cell(value))
 }