ralph_workflow/reducer/

state_reduction.rs

//! Reducer function for state transitions.
//!
//! Implements pure state reduction - no side effects, exhaustive pattern matching.

use super::event::PipelineEvent;
use super::state::{CommitState, PipelineState, RebaseState};

/// Pure reducer - no side effects, exhaustive match.
///
/// Computes new state by applying an event to current state.
/// This function has zero side effects - all state mutations are explicit.
pub fn reduce(state: PipelineState, event: PipelineEvent) -> PipelineState {
    match event {
        PipelineEvent::PipelineStarted => state,

        PipelineEvent::PipelineResumed { .. } => state,

        PipelineEvent::PipelineCompleted => PipelineState {
            phase: super::event::PipelinePhase::Complete,
            ..state
        },

        PipelineEvent::PipelineAborted { .. } => PipelineState {
            phase: super::event::PipelinePhase::Interrupted,
            ..state
        },

        PipelineEvent::PlanningPhaseStarted => PipelineState {
            phase: super::event::PipelinePhase::Planning,
            ..state
        },

        PipelineEvent::PlanningPhaseCompleted => PipelineState {
            phase: super::event::PipelinePhase::Development,
            ..state
        },

        PipelineEvent::DevelopmentPhaseStarted => PipelineState {
            phase: super::event::PipelinePhase::Development,
            ..state
        },

        PipelineEvent::DevelopmentIterationStarted { iteration } => PipelineState {
            iteration,
            agent_chain: state.agent_chain.reset(),
            ..state
        },

        PipelineEvent::PlanGenerationStarted { .. } => state,

        PipelineEvent::PlanGenerationCompleted { .. } => PipelineState {
            phase: super::event::PipelinePhase::Development,
            ..state
        },

        PipelineEvent::DevelopmentIterationCompleted {
            iteration,
            output_valid: _output_valid,
        } => {
            // After dev iteration, go to CommitMessage phase to create a commit
            // Store current phase so we can return after commit
            PipelineState {
                phase: super::event::PipelinePhase::CommitMessage,
                previous_phase: Some(super::event::PipelinePhase::Development),
                iteration,
                commit: super::state::CommitState::NotStarted,
                context_cleaned: false,
                ..state
            }
        }

        PipelineEvent::DevelopmentPhaseCompleted => PipelineState {
            phase: super::event::PipelinePhase::Review,
            ..state
        },

        PipelineEvent::ReviewPhaseStarted => PipelineState {
            phase: super::event::PipelinePhase::Review,
            reviewer_pass: 0,
            review_issues_found: false,
            ..state
        },

        PipelineEvent::ReviewPassStarted { pass } => PipelineState {
            reviewer_pass: pass,
            review_issues_found: false, // Reset at start of new review pass
            agent_chain: state.agent_chain.reset(),
            ..state
        },

        PipelineEvent::ReviewCompleted { pass, issues_found } => {
            // If no issues found, increment to next pass
            // If issues found, stay on same pass for fix attempt
            let next_pass = if issues_found { pass } else { pass + 1 };

            // If this was the last review pass and no issues, transition to CommitMessage
            let next_phase = if !issues_found && next_pass >= state.total_reviewer_passes {
                super::event::PipelinePhase::CommitMessage
            } else {
                state.phase
            };

            PipelineState {
                phase: next_phase,
                reviewer_pass: next_pass,
                review_issues_found: issues_found,
                ..state
            }
        }

        PipelineEvent::FixAttemptStarted { .. } => PipelineState {
            agent_chain: state.agent_chain.reset(),
            ..state
        },

        PipelineEvent::FixAttemptCompleted { pass, .. } => {
            // After fix attempt, go to CommitMessage phase to create a commit
            // Store current phase so we can return after commit
            PipelineState {
                phase: super::event::PipelinePhase::CommitMessage,
                previous_phase: Some(super::event::PipelinePhase::Review),
                reviewer_pass: pass,
                review_issues_found: false, // Reset flag after fix attempt
                commit: super::state::CommitState::NotStarted,
                ..state
            }
        }

        PipelineEvent::ReviewPhaseCompleted { .. } => PipelineState {
            phase: super::event::PipelinePhase::CommitMessage,
            ..state
        },

        PipelineEvent::AgentInvocationFailed {
            retriable: true, ..
        } => PipelineState {
            agent_chain: state.agent_chain.advance_to_next_model(),
            ..state
        },

        PipelineEvent::AgentFallbackTriggered { to_agent: _, .. } => PipelineState {
            agent_chain: state.agent_chain.switch_to_next_agent(),
            ..state
        },

        PipelineEvent::AgentChainExhausted { .. } => PipelineState {
            agent_chain: state.agent_chain.start_retry_cycle(),
            ..state
        },

        PipelineEvent::RebaseStarted {
            target_branch,
            phase: _,
        } => PipelineState {
            rebase: RebaseState::InProgress {
                original_head: state.current_head(),
                target_branch,
            },
            ..state
        },

        PipelineEvent::RebaseConflictDetected { files } => PipelineState {
            rebase: match &state.rebase {
                RebaseState::InProgress {
                    original_head,
                    target_branch,
                } => RebaseState::Conflicted {
                    original_head: original_head.clone(),
                    target_branch: target_branch.clone(),
                    files,
                    resolution_attempts: 0,
                },
                _ => state.rebase.clone(),
            },
            ..state
        },

        PipelineEvent::RebaseConflictResolved { files: _ } => PipelineState {
            rebase: match &state.rebase {
                RebaseState::Conflicted {
                    original_head,
                    target_branch,
                    ..
                } => RebaseState::InProgress {
                    original_head: original_head.clone(),
                    target_branch: target_branch.clone(),
                },
                _ => state.rebase.clone(),
            },
            ..state
        },

        PipelineEvent::RebaseSucceeded { new_head, phase: _ } => PipelineState {
            rebase: RebaseState::Completed { new_head },
            ..state
        },

        PipelineEvent::RebaseFailed { phase: _, .. } => PipelineState {
            rebase: RebaseState::NotStarted,
            ..state
        },

        PipelineEvent::RebaseSkipped { phase: _, .. } => PipelineState {
            rebase: RebaseState::Skipped,
            ..state
        },

        PipelineEvent::CommitGenerationStarted => PipelineState {
            commit: CommitState::Generating {
                attempt: 1,
                max_attempts: super::state::MAX_VALIDATION_RETRY_ATTEMPTS,
            },
            ..state
        },

        PipelineEvent::CommitMessageGenerated { message, .. } => PipelineState {
            commit: CommitState::Generated { message },
            ..state
        },

        PipelineEvent::CommitCreated { hash, .. } => {
            // After commit, return to Planning (next iteration) or Review, or FinalValidation
            let (next_phase, next_iter, next_reviewer_pass) = match state.previous_phase {
                Some(super::event::PipelinePhase::Development) => {
                    let next_iter = state.iteration + 1;
                    if next_iter >= state.total_iterations {
                        // All dev iterations done, go to Review
                        (
                            super::event::PipelinePhase::Review,
                            next_iter,
                            state.reviewer_pass,
                        )
                    } else {
                        // More iterations, go back to Planning for next iteration
                        (
                            super::event::PipelinePhase::Planning,
                            next_iter,
                            state.reviewer_pass,
                        )
                    }
                }
                Some(super::event::PipelinePhase::Review) => {
                    let next_pass = state.reviewer_pass + 1;
                    if next_pass >= state.total_reviewer_passes {
                        // All review passes done, go to FinalValidation
                        (
                            super::event::PipelinePhase::FinalValidation,
                            state.iteration,
                            next_pass,
                        )
                    } else {
                        // More review passes, stay in Review
                        (
                            super::event::PipelinePhase::Review,
                            state.iteration,
                            next_pass,
                        )
                    }
                }
                _ => {
                    // Final commit (no previous phase), go to FinalValidation
                    (
                        super::event::PipelinePhase::FinalValidation,
                        state.iteration,
                        state.reviewer_pass,
                    )
                }
            };

            PipelineState {
                commit: CommitState::Committed { hash },
                phase: next_phase,
                previous_phase: None,
                iteration: next_iter,
                reviewer_pass: next_reviewer_pass,
                context_cleaned: false, // Reset so cleanup runs before next Planning/Review phase
                ..state
            }
        }

        PipelineEvent::CommitGenerationFailed { .. } => PipelineState {
            commit: CommitState::NotStarted,
            ..state
        },

        PipelineEvent::CommitSkipped { .. } => {
            // Same logic as CommitCreated - respect previous_phase for proper flow
            let (next_phase, next_iter, next_reviewer_pass) = match state.previous_phase {
                Some(super::event::PipelinePhase::Development) => {
                    let next_iter = state.iteration + 1;
                    if next_iter >= state.total_iterations {
                        // All dev iterations done, go to Review
                        (
                            super::event::PipelinePhase::Review,
                            next_iter,
                            state.reviewer_pass,
                        )
                    } else {
                        // More iterations, go back to Planning for next iteration
                        (
                            super::event::PipelinePhase::Planning,
                            next_iter,
                            state.reviewer_pass,
                        )
                    }
                }
                Some(super::event::PipelinePhase::Review) => {
                    let next_pass = state.reviewer_pass + 1;
                    if next_pass >= state.total_reviewer_passes {
                        // All review passes done, go to FinalValidation
                        (
                            super::event::PipelinePhase::FinalValidation,
                            state.iteration,
                            next_pass,
                        )
                    } else {
                        // More review passes, stay in Review
                        (
                            super::event::PipelinePhase::Review,
                            state.iteration,
                            next_pass,
                        )
                    }
                }
                _ => {
                    // Final commit (no previous phase), go to FinalValidation
                    (
                        super::event::PipelinePhase::FinalValidation,
                        state.iteration,
                        state.reviewer_pass,
                    )
                }
            };

            PipelineState {
                commit: CommitState::Skipped,
                phase: next_phase,
                previous_phase: None,
                iteration: next_iter,
                reviewer_pass: next_reviewer_pass,
                context_cleaned: false, // Reset so cleanup runs before next phase
                ..state
            }
        }

        PipelineEvent::ContextCleaned => PipelineState {
            context_cleaned: true,
            ..state
        },

        PipelineEvent::CheckpointSaved { .. } => state,

        PipelineEvent::AgentInvocationStarted { .. } => state,
        PipelineEvent::AgentInvocationSucceeded { .. } => state,
        PipelineEvent::AgentInvocationFailed {
            retriable: false, ..
        } => PipelineState {
            agent_chain: state.agent_chain.switch_to_next_agent(),
            ..state
        },
        PipelineEvent::AgentModelFallbackTriggered { .. } => PipelineState {
            agent_chain: state.agent_chain.advance_to_next_model(),
            ..state
        },
        PipelineEvent::AgentRetryCycleStarted { .. } => state,
        PipelineEvent::AgentChainInitialized { role, agents } => {
            let models_per_agent = agents.iter().map(|_| vec![]).collect();

            PipelineState {
                agent_chain: state
                    .agent_chain
                    .with_agents(agents, models_per_agent, role)
                    .reset_for_role(role),
                ..state
            }
        }
        PipelineEvent::RebaseAborted { .. } => state,

        PipelineEvent::CommitMessageValidationFailed { attempt, .. } => {
            // If we haven't exceeded max attempts, retry with same agent
            let next_attempt = attempt + 1;
            let max_attempts = super::state::MAX_VALIDATION_RETRY_ATTEMPTS;

            if next_attempt <= max_attempts {
                PipelineState {
                    commit: CommitState::Generating {
                        attempt: next_attempt,
                        max_attempts,
                    },
                    ..state
                }
            } else {
                // Exceeded max attempts with current agent - try next agent
                let old_agent_index = state.agent_chain.current_agent_index;
                let old_retry_cycle = state.agent_chain.retry_cycle;
                let new_agent_chain = state.agent_chain.switch_to_next_agent();

                // Check if we wrapped around (retry_cycle incremented = all agents exhausted)
                let wrapped_around = new_agent_chain.retry_cycle > old_retry_cycle;

                // Check if we're on a different agent (advanced successfully)
                let advanced_to_next =
                    new_agent_chain.current_agent_index != old_agent_index && !wrapped_around;

                if advanced_to_next {
                    // Reset to attempt 1 with next agent
                    PipelineState {
                        agent_chain: new_agent_chain,
                        commit: CommitState::Generating {
                            attempt: 1,
                            max_attempts,
                        },
                        ..state
                    }
                } else {
                    // All agents exhausted (wrapped around) - give up
                    // Reset to NotStarted so orchestration can handle agent chain exhaustion
                    PipelineState {
                        agent_chain: new_agent_chain,
                        commit: CommitState::NotStarted,
                        ..state
                    }
                }
            }
        }

        PipelineEvent::FinalizingStarted => PipelineState {
            phase: super::event::PipelinePhase::Finalizing,
            ..state
        },

        PipelineEvent::PromptPermissionsRestored => PipelineState {
            phase: super::event::PipelinePhase::Complete,
            ..state
        },
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::agents::AgentRole;
    use crate::reducer::event::AgentErrorKind;
    use crate::reducer::event::PipelinePhase;
    use crate::reducer::event::RebasePhase;
    use crate::reducer::state::AgentChainState;

    fn create_test_state() -> PipelineState {
        PipelineState {
            agent_chain: AgentChainState::initial().with_agents(
                vec!["agent1".to_string(), "agent2".to_string()],
                vec![vec!["model1".to_string(), "model2".to_string()]],
                AgentRole::Developer,
            ),
            ..PipelineState::initial(5, 2)
        }
    }

    #[test]
    fn test_reduce_pipeline_started() {
        let state = create_test_state();
        let new_state = reduce(state, PipelineEvent::PipelineStarted);
        assert_eq!(new_state.phase, PipelinePhase::Planning);
    }

    #[test]
    fn test_reduce_pipeline_completed() {
        let state = create_test_state();
        let new_state = reduce(state, PipelineEvent::PipelineCompleted);
        assert_eq!(new_state.phase, PipelinePhase::Complete);
    }

    #[test]
    fn test_reduce_development_iteration_completed() {
        // DevelopmentIterationCompleted transitions to CommitMessage phase
        // The iteration counter stays the same; it gets incremented by CommitCreated
        let state = PipelineState {
            phase: PipelinePhase::Development,
            iteration: 2,
            total_iterations: 5,
            ..create_test_state()
        };
        let new_state = reduce(
            state,
            PipelineEvent::DevelopmentIterationCompleted {
                iteration: 2,
                output_valid: true,
            },
        );
        // Iteration stays at 2 (incremented by CommitCreated later)
        assert_eq!(new_state.iteration, 2);
        // Goes to CommitMessage phase to create a commit
        assert_eq!(new_state.phase, PipelinePhase::CommitMessage);
        // Previous phase stored for return after commit
        assert_eq!(new_state.previous_phase, Some(PipelinePhase::Development));
    }

    #[test]
    fn test_reduce_development_iteration_complete_goes_to_commit() {
        // Even on last iteration, DevelopmentIterationCompleted goes to CommitMessage
        // The transition to Review happens after CommitCreated
        let state = PipelineState {
            phase: PipelinePhase::Development,
            iteration: 5,
            total_iterations: 5,
            ..create_test_state()
        };
        let new_state = reduce(
            state,
            PipelineEvent::DevelopmentIterationCompleted {
                iteration: 5,
                output_valid: true,
            },
        );
        // Iteration stays at 5 (incremented by CommitCreated later)
        assert_eq!(new_state.iteration, 5);
        // Goes to CommitMessage phase first
        assert_eq!(new_state.phase, PipelinePhase::CommitMessage);
    }

    #[test]
    fn test_reduce_agent_fallback_to_next_model() {
        let state = create_test_state();
        let initial_agent = state.agent_chain.current_agent().unwrap().clone();
        let initial_model_index = state.agent_chain.current_model_index;

        let new_state = reduce(
            state,
            PipelineEvent::AgentInvocationFailed {
                role: AgentRole::Developer,
                agent: initial_agent.clone(),
                exit_code: 1,
                error_kind: AgentErrorKind::Network,
                retriable: true,
            },
        );

        assert_ne!(
            new_state.agent_chain.current_model_index,
            initial_model_index
        );
    }

    #[test]
    fn test_reduce_rebase_started() {
        let state = create_test_state();
        let new_state = reduce(
            state,
            PipelineEvent::RebaseStarted {
                phase: RebasePhase::Initial,
                target_branch: "main".to_string(),
            },
        );

        assert!(matches!(new_state.rebase, RebaseState::InProgress { .. }));
    }

    #[test]
    fn test_reduce_rebase_succeeded() {
        let state = create_test_state();
        let new_state = reduce(
            state,
            PipelineEvent::RebaseSucceeded {
                phase: RebasePhase::Initial,
                new_head: "abc123".to_string(),
            },
        );

        assert!(matches!(new_state.rebase, RebaseState::Completed { .. }));
    }

    #[test]
    fn test_reduce_commit_generation_started() {
        let state = create_test_state();
        let new_state = reduce(state, PipelineEvent::CommitGenerationStarted);

        assert!(matches!(new_state.commit, CommitState::Generating { .. }));
    }

    #[test]
    fn test_reduce_commit_created() {
        let state = create_test_state();
        let new_state = reduce(
            state,
            PipelineEvent::CommitCreated {
                hash: "abc123".to_string(),
                message: "test commit".to_string(),
            },
        );

        assert!(matches!(new_state.commit, CommitState::Committed { .. }));
        assert_eq!(new_state.phase, PipelinePhase::FinalValidation);
    }

    #[test]
    fn test_reduce_all_agent_failure_scenarios() {
        let state = create_test_state();
        let initial_agent_index = state.agent_chain.current_agent_index;
        let initial_model_index = state.agent_chain.current_model_index;
        let agent_name = state.agent_chain.current_agent().unwrap().clone();

        let network_error_state = reduce(
            state.clone(),
            PipelineEvent::AgentInvocationFailed {
                role: AgentRole::Developer,
                agent: agent_name.clone(),
                exit_code: 1,
                error_kind: AgentErrorKind::Network,
                retriable: true,
            },
        );
        assert_eq!(
            network_error_state.agent_chain.current_agent_index,
            initial_agent_index
        );
        assert!(network_error_state.agent_chain.current_model_index > initial_model_index);

        let auth_error_state = reduce(
            state.clone(),
            PipelineEvent::AgentInvocationFailed {
                role: AgentRole::Developer,
                agent: agent_name.clone(),
                exit_code: 1,
                error_kind: AgentErrorKind::Authentication,
                retriable: false,
            },
        );
        assert!(auth_error_state.agent_chain.current_agent_index > initial_agent_index);
        assert_eq!(
            auth_error_state.agent_chain.current_model_index,
            initial_model_index
        );

        let internal_error_state = reduce(
            state,
            PipelineEvent::AgentInvocationFailed {
                role: AgentRole::Developer,
                agent: agent_name,
                exit_code: 139,
                error_kind: AgentErrorKind::InternalError,
                retriable: false,
            },
        );
        assert!(internal_error_state.agent_chain.current_agent_index > initial_agent_index);
    }

    #[test]
    fn test_reduce_rebase_full_state_machine() {
        let mut state = create_test_state();

        state = reduce(
            state,
            PipelineEvent::RebaseStarted {
                phase: RebasePhase::Initial,
                target_branch: "main".to_string(),
            },
        );
        assert!(matches!(state.rebase, RebaseState::InProgress { .. }));

        state = reduce(
            state,
            PipelineEvent::RebaseConflictDetected {
                files: vec![std::path::PathBuf::from("file1.txt")],
            },
        );
        assert!(matches!(state.rebase, RebaseState::Conflicted { .. }));

        state = reduce(
            state,
            PipelineEvent::RebaseConflictResolved {
                files: vec![std::path::PathBuf::from("file1.txt")],
            },
        );
        assert!(matches!(state.rebase, RebaseState::InProgress { .. }));

        state = reduce(
            state,
            PipelineEvent::RebaseSucceeded {
                phase: RebasePhase::Initial,
                new_head: "def456".to_string(),
            },
        );
        assert!(matches!(state.rebase, RebaseState::Completed { .. }));
    }

    #[test]
    fn test_reduce_commit_full_state_machine() {
        let mut state = create_test_state();

        state = reduce(state, PipelineEvent::CommitGenerationStarted);
        assert!(matches!(state.commit, CommitState::Generating { .. }));

        state = reduce(
            state,
            PipelineEvent::CommitCreated {
                hash: "abc123".to_string(),
                message: "test commit".to_string(),
            },
        );
        assert!(matches!(state.commit, CommitState::Committed { .. }));
    }

    #[test]
    fn test_reduce_phase_transitions() {
        let mut state = create_test_state();

        state = reduce(state, PipelineEvent::PlanningPhaseCompleted);
        assert_eq!(state.phase, PipelinePhase::Development);

        state = reduce(state, PipelineEvent::DevelopmentPhaseStarted);
        assert_eq!(state.phase, PipelinePhase::Development);

        state = reduce(state, PipelineEvent::DevelopmentPhaseCompleted);
        assert_eq!(state.phase, PipelinePhase::Review);

        state = reduce(state, PipelineEvent::ReviewPhaseStarted);
        assert_eq!(state.phase, PipelinePhase::Review);

        state = reduce(
            state,
            PipelineEvent::ReviewPhaseCompleted { early_exit: false },
        );
        assert_eq!(state.phase, PipelinePhase::CommitMessage);
    }

    #[test]
    fn test_reduce_agent_chain_exhaustion() {
        let state = PipelineState {
            agent_chain: AgentChainState::initial()
                .with_agents(
                    vec!["agent1".to_string()],
                    vec![vec!["model1".to_string()]],
                    AgentRole::Developer,
                )
                .with_max_cycles(3),
            ..create_test_state()
        };

        let exhausted_state = reduce(
            state,
            PipelineEvent::AgentChainExhausted {
                role: AgentRole::Developer,
            },
        );

        assert_eq!(exhausted_state.agent_chain.current_agent_index, 0);
        assert_eq!(exhausted_state.agent_chain.current_model_index, 0);
        assert_eq!(exhausted_state.agent_chain.retry_cycle, 1);
    }

    #[test]
    fn test_reduce_agent_fallback_triggers_fallback_event() {
        let state = create_test_state();
        let agent = state.agent_chain.current_agent().unwrap().clone();

        let new_state = reduce(
            state,
            PipelineEvent::AgentInvocationFailed {
                role: AgentRole::Developer,
                agent: agent.clone(),
                exit_code: 1,
                error_kind: AgentErrorKind::Authentication,
                retriable: false,
            },
        );

        assert!(new_state.agent_chain.current_agent_index > 0);
    }

    #[test]
    fn test_reduce_model_fallback_triggers_fallback_event() {
        let state = create_test_state();
        let initial_model_index = state.agent_chain.current_model_index;
        let agent_name = state.agent_chain.current_agent().unwrap().clone();

        let new_state = reduce(
            state,
            PipelineEvent::AgentInvocationFailed {
                role: AgentRole::Developer,
                agent: agent_name,
                exit_code: 1,
                error_kind: AgentErrorKind::RateLimit,
                retriable: true,
            },
        );

        assert!(new_state.agent_chain.current_model_index > initial_model_index);
    }

    #[test]
    fn test_reduce_finalizing_started() {
        let state = PipelineState {
            phase: PipelinePhase::FinalValidation,
            ..create_test_state()
        };
        let new_state = reduce(state, PipelineEvent::FinalizingStarted);
        assert_eq!(new_state.phase, PipelinePhase::Finalizing);
    }

    #[test]
    fn test_reduce_prompt_permissions_restored() {
        let state = PipelineState {
            phase: PipelinePhase::Finalizing,
            ..create_test_state()
        };
        let new_state = reduce(state, PipelineEvent::PromptPermissionsRestored);
        assert_eq!(new_state.phase, PipelinePhase::Complete);
    }

    #[test]
    fn test_reduce_finalization_full_flow() {
        let mut state = PipelineState {
            phase: PipelinePhase::FinalValidation,
            ..create_test_state()
        };

        // FinalValidation -> Finalizing
        state = reduce(state, PipelineEvent::FinalizingStarted);
        assert_eq!(state.phase, PipelinePhase::Finalizing);

        // Finalizing -> Complete
        state = reduce(state, PipelineEvent::PromptPermissionsRestored);
        assert_eq!(state.phase, PipelinePhase::Complete);
    }

    /// Test the complete finalization flow from FinalValidation through effects.
    ///
    /// This tests the orchestration + reduction path:
    /// 1. FinalValidation phase -> ValidateFinalState effect
    /// 2. ValidateFinalState effect -> FinalizingStarted event
    /// 3. FinalizingStarted event -> Finalizing phase
    /// 4. Finalizing phase -> RestorePromptPermissions effect
    /// 5. RestorePromptPermissions effect -> PromptPermissionsRestored event
    /// 6. PromptPermissionsRestored event -> Complete phase
    #[test]
    fn test_finalization_orchestration_integration() {
        use crate::reducer::mock_effect_handler::MockEffectHandler;
        use crate::reducer::orchestration::determine_next_effect;

        // Start in FinalValidation
        let initial_state = PipelineState {
            phase: PipelinePhase::FinalValidation,
            ..PipelineState::initial(5, 2)
        };

        let mut handler = MockEffectHandler::new(initial_state.clone());

        // Step 1: Determine effect for FinalValidation
        let effect1 = determine_next_effect(&initial_state);
        assert!(
            matches!(effect1, crate::reducer::effect::Effect::ValidateFinalState),
            "FinalValidation should emit ValidateFinalState effect"
        );

        // Step 2: Execute effect, get event
        let event1 = handler.execute_mock(effect1);
        assert!(
            matches!(event1, PipelineEvent::FinalizingStarted),
            "ValidateFinalState should return FinalizingStarted"
        );

        // Step 3: Reduce state with event
        let state2 = reduce(initial_state, event1);
        assert_eq!(state2.phase, PipelinePhase::Finalizing);
        assert!(!state2.is_complete(), "Finalizing should not be complete");

        // Step 4: Determine effect for Finalizing
        let effect2 = determine_next_effect(&state2);
        assert!(
            matches!(
                effect2,
                crate::reducer::effect::Effect::RestorePromptPermissions
            ),
            "Finalizing should emit RestorePromptPermissions effect"
        );

        // Step 5: Execute effect, get event
        let event2 = handler.execute_mock(effect2);
        assert!(
            matches!(event2, PipelineEvent::PromptPermissionsRestored),
            "RestorePromptPermissions should return PromptPermissionsRestored"
        );

        // Step 6: Reduce state with event
        let final_state = reduce(state2, event2);
        assert_eq!(final_state.phase, PipelinePhase::Complete);
        assert!(final_state.is_complete(), "Complete should be complete");

        // Verify effects were captured
        let effects = handler.captured_effects();
        assert_eq!(effects.len(), 2);
        assert!(matches!(
            effects[0],
            crate::reducer::effect::Effect::ValidateFinalState
        ));
        assert!(matches!(
            effects[1],
            crate::reducer::effect::Effect::RestorePromptPermissions
        ));
    }
}