fn developer_loop_placeholder(elided: usize, tools: &[String]) -> Message {
    ...
    Message {
        role: Role::User,
        content: MessageContent::Text(text),
        pinned: false,
        timestamp: None,
    }
}

if last.role == msg.role
    && !message_has_tool_use(last)
    && !message_is_only_tool_results(&msg)
    && !message_has_tool_use(&msg)
    && !message_is_only_tool_results(last) // <-- Returns false, skipping the merge

        if steps.len() >= max_steps && steps.len() > 2 {
            let first = steps[0];
            let last = steps[steps.len() - 1];
            
            // 1. Keep the first step's ToolUse
            result.push(messages[first.0].clone());
            
            // 2. Append the aggregation note to the first step's ToolResult
            let mut first_result = messages[first.1].clone();
            let elided = steps.len() - 2;
            let tools = collect_dev_tool_names(messages, &steps[1..steps.len() - 1]);
            
            append_aggregation_note(&mut first_result, elided, &tools);
            result.push(first_result);
            
            // 3. Keep the last step
            result.push(messages[last.0].clone());
            result.push(messages[last.1].clone());
            i = j;

    #[test]
    fn test_developer_loop_aggregation_causes_consecutive_user_roles() {
        let mut msgs = Vec::new();

        // 1. First message from User
        msgs.push(Message {
            role: Role::User,
            content: MessageContent::Text("perform refactoring".to_string()),
            pinned: false,
            timestamp: None,
        });

        // 2. Read file (Read-only tool, not a developer tool)
        // Assistant: requests file_read
        msgs.push(Message {
            role: Role::Assistant,
            content: MessageContent::Blocks(vec![ContentBlock::ToolUse {
                id: "t_read".to_string(),
                name: "file_read".to_string(),
                input: serde_json::json!({ "path": "src/main.rs" }),
                provider_metadata: None,
            }]),
            pinned: false,
            timestamp: None,
        });
        // User: returns file content
        msgs.push(Message {
            role: Role::User,
            content: MessageContent::Blocks(vec![ContentBlock::ToolResult {
                tool_use_id: "t_read".to_string(),
                tool_name: "file_read".to_string(),
                content: "fn main() { println!(\"hello\"); }".to_string(),
                is_error: false,
                status: Default::default(),
                approval_request_id: None,
            }]),
            pinned: false,
            timestamp: None,
        });

        // 3. Mutating edits sequence (Developer loop)
        // 4 steps of writing to file
        for k in 0..4 {
            msgs.push(dev_tool_use(&format!("t_write_{k}"), "file_write"));
            msgs.push(tool_result(&format!("t_write_{k}"), "file_write"));
        }

        // 4. Final Assistant response
        msgs.push(Message {
            role: Role::Assistant,
            content: MessageContent::Text("I have finished the refactoring".to_string()),
            pinned: false,
            timestamp: None,
        });

        // Run developer loop aggregation (threshold of 2 steps)
        aggregate_developer_loops(&mut msgs, 2);

        // Verify aggregation actually triggered and reduced the message count:
        // 1 (user) + 2 (read) + 8 (write steps) + 1 (assistant) = 12 messages.
        // After aggregating 4 write steps (8 messages) down to 5 messages:
        // 1 (user) + 2 (read) + 5 (aggregated writes) + 1 (assistant) = 9 messages.
        assert_eq!(msgs.len(), 9);

        // Run session repair
        let (repaired, _stats) = crate::session_repair::validate_and_repair_with_stats(&msgs);

        // Check for consecutive User-role messages.
        // The test MUST fail (panic) if consecutive user messages are found.
        let mut last_was_user = false;
        let mut consecutive_indices = None;

        for (idx, m) in repaired.iter().enumerate() {
            if m.role == Role::User {
                if last_was_user {
                    consecutive_indices = Some((idx - 1, idx));
                    break;
                }
                last_was_user = true;
            } else {
                last_was_user = false;
            }
        }

        if let Some((i1, i2)) = consecutive_indices {
            panic!(
                "FAIL: Found consecutive user messages at indices {} and {} in the repaired session!\n\
                 Message {}: {:?}\n\
                 Message {}: {:?}",
                i1, i2,
                i1, repaired[i1],
                i2, repaired[i2]
            );
        }
    }