Function detect_full_cycle

atomic-agent/src/provenance/consolidate.rs:345–421

Detect full cycle: explore → commit → verify. The agent reads files, makes a change, then validates it.

(
    nodes: &[GraphNode],
    seq: &[usize],
    counter: &mut u64,
    prefix: &str,
)

///
/// The agent reads files, makes a change, then validates it.
fn detect_full_cycle(
    nodes: &[GraphNode],
    seq: &[usize],
    counter: &mut u64,
    prefix: &str,
) -> Option<(GraphNode, Vec<GraphEdge>)> {
    let mut has_exploration = false;
    let mut has_commitment = false;
    let mut has_verification = false;
    let mut committed_file = None;
    let mut verify_cmd = None;

    for &idx in seq {
        let node = &nodes[idx];
        match node.kind {
            NodeKind::Exploration => has_exploration = true,
            NodeKind::Commitment => {
                has_commitment = true;
                if committed_file.is_none() {
                    committed_file = extract_file(node);
                }
            }
            NodeKind::Verification => {
                has_verification = true;
                if verify_cmd.is_none() {
                    verify_cmd = extract_command(node);
                }
            }
            _ => {}
        }
    }

    if !(has_exploration && has_commitment && has_verification) {
        return None;
    }

    let file_display = committed_file
        .as_deref()
        .map(short_path)
        .unwrap_or_else(|| "file".to_string());

    let cmd_display = verify_cmd
        .as_deref()
        .map(|c| truncate(c, 40))
        .unwrap_or_else(|| "tests".to_string());

    let exploration_count = seq
        .iter()
        .filter(|&&i| nodes[i].kind == NodeKind::Exploration)
        .count();

    let summary = format!(
        "Investigated ({} files) → fixed {} → verified with {}",
        exploration_count, file_display, cmd_display
    );

    let consolidated_ids: Vec<String> = seq.iter().map(|&i| nodes[i].id.clone()).collect();