Function detect_informed_commit

atomic-agent/src/provenance/consolidate.rs:484–541

Detect informed commit: explore → commit (without verification).

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

/// Detect informed commit: explore → commit (without verification).
fn detect_informed_commit(
    nodes: &[GraphNode],
    seq: &[usize],
    counter: &mut u64,
    prefix: &str,
) -> Option<(GraphNode, Vec<GraphEdge>)> {
    let kinds: Vec<NodeKind> = seq.iter().map(|&i| nodes[i].kind).collect();

    let has_exploration = kinds.contains(&NodeKind::Exploration);
    let has_commitment = kinds.contains(&NodeKind::Commitment);
    let has_verification = kinds.contains(&NodeKind::Verification);

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

    let exploration_count = kinds
        .iter()
        .filter(|k| **k == NodeKind::Exploration)
        .count();

    let committed_file = seq
        .iter()
        .filter(|&&i| nodes[i].kind == NodeKind::Commitment)
        .find_map(|&i| extract_file(&nodes[i]));

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

    let summary = format!(
        "Investigated {} file{} → edited {}",
        exploration_count,
        if exploration_count == 1 { "" } else { "s" },
        file_display
    );

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

    let detail = serde_json::json!({
        "pattern": "informed_commit",
        "explorations": exploration_count,
        "file": committed_file,
    });

    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.75);
    node.consolidated_from = consolidated_ids;

    let decision_edges = build_decision_edges(nodes, seq, &id);

    Some((node, decision_edges))
}