ralph-workflow 0.7.18

PROMPT-driven multi-agent orchestrator for git repos
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

// Event sequence tests for determinism.
//
// Tests that verify deterministic behavior: same events produce same state,
// validation failures trigger correct agent switches, etc.

use crate::reducer::event::PipelineEvent;
use crate::reducer::event::PipelinePhase;
use crate::reducer::io_tests::create_test_state;
use crate::reducer::state::ContinuationState;
use crate::reducer::state::PipelineState;
use crate::reducer::state_reduction::reduce;

#[test]
fn test_event_sequence_output_validation_retry_then_success() {
    let mut state = PipelineState {
        continuation: ContinuationState {
            max_xsd_retry_count: 3,
            ..ContinuationState::new()
        },
        ..create_test_state()
    };
    state.phase = PipelinePhase::Development;

    // Simulate: validation fail -> validation fail -> success
    state = reduce(
        state,
        PipelineEvent::development_output_validation_failed(0, 0),
    );
    assert_eq!(state.continuation.invalid_output_attempts, 1);
    assert_eq!(state.phase, PipelinePhase::Development);

    state = reduce(
        state,
        PipelineEvent::development_output_validation_failed(0, 1),
    );
    assert_eq!(state.continuation.invalid_output_attempts, 2);

    assert_eq!(
        state.agent_chain.current_agent_index, 0,
        "Should not switch agents yet"
    );

    // Now succeed
    state = reduce(
        state,
        PipelineEvent::development_iteration_completed(0, true),
    );
    assert_eq!(state.phase, PipelinePhase::CommitMessage);
}

#[test]
fn test_event_sequence_validation_failures_trigger_agent_switch() {
    use crate::reducer::state::ContinuationState;

    let mut state = PipelineState {
        continuation: ContinuationState {
            max_xsd_retry_count: 3,
            ..ContinuationState::new()
        },
        ..create_test_state()
    };
    state.phase = PipelinePhase::Development;

    // First validation failure
    state = reduce(
        state,
        PipelineEvent::development_output_validation_failed(0, 0),
    );

    // Second validation failure
    state = reduce(
        state,
        PipelineEvent::development_output_validation_failed(0, 1),
    );

    // Third validation failure - should trigger agent switch
    state = reduce(
        state,
        PipelineEvent::development_output_validation_failed(0, 2),
    );

    // After max failures, should switch agents and reset counter
    assert_eq!(
        state.continuation.invalid_output_attempts, 0,
        "Counter should reset"
    );
    assert!(
        state.agent_chain.current_agent_index > 0 || state.agent_chain.retry_cycle > 0,
        "Should have advanced to next agent or started retry cycle"
    );
}

#[test]
fn test_determinism_same_events_same_state() {
    use crate::reducer::state::DevelopmentStatus;

    // Create two identical initial states
    let state1 = create_test_state();
    let state2 = create_test_state();

    // Apply the same sequence of events
    let events = vec![
        PipelineEvent::development_iteration_started(0),
        PipelineEvent::development_output_validation_failed(0, 0),
        PipelineEvent::development_iteration_continuation_triggered(
            0,
            DevelopmentStatus::Partial,
            "Work".to_string(),
            None,
            None,
        ),
    ];

    let mut final1 = state1;
    let mut final2 = state2;

    for event in events {
        final1 = reduce(final1, event.clone());
        final2 = reduce(final2, event);
    }

    // States should be identical
    assert_eq!(final1.iteration, final2.iteration);
    assert_eq!(final1.phase, final2.phase);
    assert_eq!(
        final1.continuation.continuation_attempt,
        final2.continuation.continuation_attempt
    );
    assert_eq!(
        final1.continuation.invalid_output_attempts,
        final2.continuation.invalid_output_attempts
    );
}