Struct LatencyBreakdown 

pub struct LatencyBreakdown {

    pub pre_phase_ms: f64,
    pub parse_changed_ms: f64,
    pub universe_walk_ms: f64,
    pub discovery_ms: f64,
    pub parse_discovered_ms: f64,
    pub tokenization_ms: f64,
    pub graph_build_ms: f64,
    pub scoring_selection_ms: f64,
    pub total_ms: f64,
    pub scoring_ms: f64,
    pub selection_ms: f64,
    pub candidate_count: usize,
    pub edge_count: usize,
    pub greedy_iters: usize,
    pub edges_before_cap: usize,
    pub edges_dropped_by_cap: usize,
    pub nodes_capped: usize,
    pub max_out_edges_per_node: usize,
    pub ppr_truncated: bool,
    pub ppr_forward_pushes: usize,
    pub ppr_backward_pushes: usize,
    pub stopping_certificate: f64,
    pub peak_rss_bytes: u64,
    pub edge_emissions_by_category: Vec<(&'static str, u64, u64)>,
}

Fields

pre_phase_ms: f64

Pre-heavy-phase work: hunk parse, untracked scan, ignore resolution and the git diff calls. Outside every timer until #183, which is why the reported phases could not be reconciled with the wall clock.

parse_changed_ms: f64

universe_walk_ms: f64

discovery_ms: f64

parse_discovered_ms: f64

tokenization_ms: f64

graph_build_ms: f64

Typed dependency graph construction: edge builders + dedup + hub suppression + per-source cap. Carved out of scoring_ms (which used to absorb it) so the cost distribution is truthful. Zero for BM25 mode (no graph built).

scoring_selection_ms: f64

Combined graph build + scoring + selection time. Kept for backward compatibility with the existing checkpoint schema; the split values below are the new diagnostic signal.

total_ms: f64

scoring_ms: f64

Heavy-phase rank computation only (PPR/EGO/BM25 + relevance filtering). Graph construction is reported in graph_build_ms; the selection stage is excluded.

selection_ms: f64

Selection stage only (lazy greedy / Boltzmann + post-passes).

candidate_count: usize

Size of the candidate fragment universe handed to the scoring strategy (after fragment generation + signature variants but before per-strategy filtering). Surfaces blowup on large repos — pathological scoring time is correlated with this number, not with fragment_count (which is the output size after selection).

edge_count: usize

Edge count of the typed dependency graph used by PPR/EGO. Zero for BM25 mode (no graph built).

greedy_iters: usize

Number of greedy iterations actually executed (selected non-core fragments). Bounded by selected.len() - core.len(). Pairs with selection_ms to spot lazy-heap blowup vs. genuine large output.

edges_before_cap: usize

Edge count after merge + hub suppression, before per-source cap.

edges_dropped_by_cap: usize

Edges discarded by the per-source top-K cap.

nodes_capped: usize

Source nodes whose outgoing edge list was truncated by the cap.

max_out_edges_per_node: usize

The K value applied for the per-source cap.

ppr_truncated: bool

PPR push iteration was truncated by max_pushes_cap before convergence. When true, rel_scores are biased toward seeds and absolute file_recall on this instance should be flagged in post-analysis. Always false for non-PPR scoring modes.

ppr_forward_pushes: usize

ppr_backward_pushes: usize

stopping_certificate: f64

Additive stopping certificate: upper bound (tau * peak_density * remaining_budget) on utility foregone by adaptive stopping. 0 when the greedy loop ended for another reason (budget exhausted, no candidates, singleton override).

peak_rss_bytes: u64

Lifetime peak physical memory of the process, sampled in-process at the end of the run. 0 when the platform query fails.

edge_emissions_by_category: Vec<(&'static str, u64, u64)>

Per-category (raw, first-seen deduped) edge emission counts from pass 1 of the two-pass edge build, sorted by category name. Names the builder category behind near-dense emission blowups (#116). Empty for BM25 mode (no graph built).