if ready_step_indices.is_empty() && running_count == 0 {
                let error_message = if blocked_by_failure {
                    "Workflow failed due to step dependency failure".to_string()
                } else {
                    "Workflow deadlocked. This may indicate a cycle or issue in the workflow definition.".to_string()
                };

                self.state_store.update(instance_id, |s| {
                    s.status = WorkflowStatus::Failed;
                })?;

                let failed_step = tracker.read().failed.iter().next().cloned();
                self.event_bus
                    .publish(WorkflowEvent::WorkflowFailed {
                        instance_id,
                        failed_step: failed_step.unwrap_or_else(|| StepId::new("internal_scheduler")),
                        error: error_message,
                    })
                    .await;
                return Ok(());
            }

    pub fn validate(&self) -> Result<(), String> {
        let steps_map: std::collections::HashMap<_, _> = self.steps.iter().map(|s| (&s.id, s)).collect();

        // Check all dependencies exist
        for step in &self.steps {
            for dep in &step.depends_on {
                if !steps_map.contains_key(dep) {
                    return Err(format!(
                        "Step '{}' depends on non-existent step '{}'",
                        step.id, dep
                    ));
                }
            }
        }

        // Check for cycles using DFS
        let mut visited = HashSet::new();
        let mut rec_stack = HashSet::new();

        for step in &self.steps {
            if !visited.contains(&step.id) {
                if self.has_cycle(&step.id, &steps_map, &mut visited, &mut rec_stack) {
                    return Err(format!("Cycle detected involving step '{}'", step.id));
                }
            }
        }

        Ok(())
    }

    /// DFS helper for cycle detection
    fn has_cycle<'a>(
        &self,
        step_id: &'a StepId,
        steps_map: &std::collections::HashMap<&'a StepId, &'a StepDefinition>,
        visited: &mut HashSet<&'a StepId>,
        rec_stack: &mut HashSet<&'a StepId>,
    ) -> bool {
        if rec_stack.contains(step_id) {
            return true; // Back edge found - cycle!
        }
        if visited.contains(step_id) {
            return false; // Already fully processed
        }

        visited.insert(step_id);
        rec_stack.insert(step_id);

        // Find the step and check its dependencies
        if let Some(step) = steps_map.get(step_id) {
            for dep in &step.depends_on {
                if self.has_cycle(dep, steps_map, visited, rec_stack) {
                    return true;
                }
            }
        }

        rec_stack.remove(step_id);
        false
    }