Function detect_commit_and_verify

atomic-agent/src/provenance/consolidate.rs:424–481

Detect commit-and-verify: commit → verify (without preceding exploration).

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

/// Detect commit-and-verify: commit → verify (without preceding exploration).
fn detect_commit_and_verify(
    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_commitment = kinds.contains(&NodeKind::Commitment);
    let has_verification = kinds.contains(&NodeKind::Verification);
    let has_exploration = kinds.contains(&NodeKind::Exploration);

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

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

    let verify_cmd = seq
        .iter()
        .filter(|&&i| nodes[i].kind == NodeKind::Verification)
        .find_map(|&i| extract_command(&nodes[i]));

    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 summary = format!("Edited {} → verified with {}", file_display, cmd_display);

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

    let detail = serde_json::json!({
        "pattern": "commit_and_verify",
        "file": committed_file,
        "verify_command": verify_cmd,
    });

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

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

    Some((node, decision_edges))
}