Function detect_backtracking

atomic-agent/src/provenance/consolidate.rs:192–255

Detect backtracking: the agent reads/edits the same file multiple times. Pattern: any file appears in both an exploration AND a commitment more than once in the sequence, suggesting the agent revised its approach.

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

/// Pattern: any file appears in both an exploration AND a commitment more
/// than once in the sequence, suggesting the agent revised its approach.
fn detect_backtracking(
    nodes: &[GraphNode],
    seq: &[usize],
    counter: &mut u64,
    prefix: &str,
) -> Option<(GraphNode, Vec<GraphEdge>)> {
    let mut file_edit_counts: std::collections::HashMap<String, u32> =
        std::collections::HashMap::new();

    for &idx in seq {
        let node = &nodes[idx];
        if node.kind == NodeKind::Commitment {
            if let Some(file) = extract_file(node) {
                *file_edit_counts.entry(file).or_default() += 1;
            }
        }
    }

    // Need at least one file edited more than once
    let repeated: Vec<(&String, &u32)> = file_edit_counts
        .iter()
        .filter(|(_, count)| **count > 1)
        .collect();

    if repeated.is_empty() {
        return None;
    }

    let max_file = repeated
        .iter()
        .max_by_key(|(_, c)| *c)
        .map(|(f, _)| f.to_string())
        .unwrap_or_default();
    let max_count = file_edit_counts.get(&max_file).copied().unwrap_or(0);

    let summary = format!(
        "Iterated on {} ({} attempts)",
        short_path(&max_file),
        max_count
    );

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

    let detail = serde_json::json!({
        "pattern": "backtracking",
        "iterations": max_count,
        "file": max_file,
        "files_revisited": repeated.iter().map(|(f, c)| {
            serde_json::json!({"file": f, "edits": c})
        }).collect::<Vec<_>>(),
    });

    let id = next_id(counter, prefix);
    let timestamp = seq.last().map(|&i| nodes[i].timestamp).unwrap_or_default();

    let mut node = GraphNode::new(&id, NodeKind::Decision, timestamp, summary).with_detail(detail);
    node.classified = true;
    node.confidence = Some(0.85);