perf(sdk): stop cloning turn streams in analyze hot paths (#422)

Aggregate per-session/per-file groups by `&TurnRecord` instead of cloning
the full record. The biggest win is `overhead.rs`, which used to clone
every applicable turn per file (~3x for Claude turns with two CLAUDE.md
candidates plus AGENTS.md cross-checks).

- `overhead`: per-file filter into `Vec<&TurnRecord>`; route through a
  new internal `attribute_claude_md_refs` so the public
  `attribute_claude_md` is a thin wrapper.
- `hotspots`: `IndexMap<String, Vec<&TurnRecord>>` for the per-session
  groups; private `attribute_session` / `index_tool_results` now take
  `&[&TurnRecord]`.
- `quality`: per-session groups borrow turns; private
  `infer_outcome_refs` / `compute_one_shot_rate_refs` drive the work and
  the public functions adapt via a single ref collect.
- `compare`: hoist the model-name clone above the three `entry` calls so
  we allocate once per *new* model, not four times per turn.

Closes #325.

Co-authored-by: Claude <noreply@anthropic.com>

Author: willwashburn

CHANGELOG.md

@@ -4,6 +4,13 @@ Cross-package release notes for relayburn. Package changelogs contain package-le
 
 ## [Unreleased]
 
+### Changed
+
+- `relayburn-sdk`: analyze hot paths (`overhead`, `hotspots`, `quality`,
+  `compare`) now aggregate per-session/per-file groups by reference instead
+  of cloning `TurnRecord`s, cutting working-set memory on the most expensive
+  verbs. Behavior is unchanged.
+
 ## [2.8.6] - 2026-05-12
 
 ### Changed

crates/relayburn-sdk/src/analyze/claude_md.rs

@@ -306,7 +306,20 @@ fn matches_close_fence(s: &str, ch: char, min_len: usize) -> bool {
 }
 
 pub fn attribute_claude_md(input: &AttributeClaudeMdInput<'_>) -> ClaudeMdAttributionResult {
-    let total_tokens: u64 = input.files.iter().map(|f| f.tokens).sum();
+    let turns: Vec<&TurnRecord> = input.turns.iter().collect();
+    attribute_claude_md_refs(input.files, &turns, input.pricing)
+}
+
+/// Reference-borrow variant of [`attribute_claude_md`] used by callers that
+/// have already pre-filtered turns into a `Vec<&TurnRecord>` (e.g. the
+/// per-file overhead attribution loop). Avoids the per-turn `Vec<TurnRecord>`
+/// clone that the public entry point would otherwise force.
+pub(crate) fn attribute_claude_md_refs(
+    files: &[ParsedClaudeMd],
+    turns: &[&TurnRecord],
+    pricing: &PricingTable,
+) -> ClaudeMdAttributionResult {
+    let total_tokens: u64 = files.iter().map(|f| f.tokens).sum();
     if total_tokens == 0 {
         return ClaudeMdAttributionResult {
             total_tokens: 0,
@@ -320,8 +333,8 @@ pub fn attribute_claude_md(input: &AttributeClaudeMdInput<'_>) -> ClaudeMdAttrib
     }
 
     let mut by_session: IndexMap<String, Vec<&TurnRecord>> = IndexMap::new();
-    for t in input.turns {
-        by_session.entry(t.session_id.clone()).or_default().push(t);
+    for t in turns {
+        by_session.entry(t.session_id.clone()).or_default().push(*t);
     }
 
     let mut session_costs: Vec<SessionClaudeMdCost> = Vec::new();
@@ -333,7 +346,7 @@ pub fn attribute_claude_md(input: &AttributeClaudeMdInput<'_>) -> ClaudeMdAttrib
         let mut riding_turns: u64 = 0;
         let mut model_counts: IndexMap<String, u64> = IndexMap::new();
         for t in &turns {
-            let Some(rate) = lookup_model_rate(&t.model, input.pricing) else {
+            let Some(rate) = lookup_model_rate(&t.model, pricing) else {
                 continue;
             };
             *model_counts.entry(t.model.clone()).or_insert(0) += 1;
@@ -363,9 +376,9 @@ pub fn attribute_claude_md(input: &AttributeClaudeMdInput<'_>) -> ClaudeMdAttrib
     };
     let per_session_p95 = percentile(&session_cost_values, 0.95);
 
-    let total_bytes: u64 = input.files.iter().map(|f| f.bytes).sum();
+    let total_bytes: u64 = files.iter().map(|f| f.bytes).sum();
     let mut section_costs: Vec<SectionCost> = Vec::new();
-    for f in input.files {
+    for f in files {
         for section in &f.sections {
             let token_share = if total_bytes > 0 {
                 section.bytes as f64 / total_bytes as f64

crates/relayburn-sdk/src/analyze/compare.rs

@@ -126,25 +126,38 @@ pub fn build_compare_table(turns: &[EnrichedTurn], opts: &CompareOptions<'_>) ->
 
     for et in turns {
         let t = &et.turn;
-        let model = if t.model.is_empty() {
-            "unknown".to_string()
+        let model: &str = if t.model.is_empty() {
+            "unknown"
         } else {
-            t.model.clone()
+            t.model.as_str()
         };
         if let Some(ref filter) = model_filter {
-            if !filter.iter().any(|m| m == &model) {
+            if !filter.iter().any(|m| m == model) {
                 continue;
             }
         }
         let cat = activity_label(t.activity);
-        model_set.insert(model.clone(), ());
-        category_set.insert(cat.clone(), ());
+        // One clone per *new* model — `by_model_category` is the canonical
+        // per-turn map (the other two may be pre-seeded by the model
+        // filter), so gate on it and reuse the owned key across the three
+        // maps to avoid the four clones the naive form does.
+        if !by_model_category.contains_key(model) {
+            let owned = model.to_string();
+            model_set.insert(owned.clone(), ());
+            model_totals
+                .entry(owned.clone())
+                .or_insert_with(CompareTotals::default);
+            by_model_category.insert(owned, BTreeMap::new());
+        }
+        if !category_set.contains_key(&cat) {
+            category_set.insert(cat.clone(), ());
+        }
 
-        let by_cat = by_model_category.entry(model.clone()).or_default();
+        let by_cat = by_model_category.get_mut(model).expect("model just inserted");
         let acc = by_cat.entry(cat).or_default();
 
         acc.turns += 1;
-        let mt = model_totals.entry(model.clone()).or_default();
+        let mt = model_totals.get_mut(model).expect("model just inserted");
         mt.turns += 1;
         if let Some(c) = cost_for_turn(t, opts.pricing) {
             acc.priced_turns += 1;

crates/relayburn-sdk/src/analyze/hotspots.rs

@@ -207,12 +207,11 @@ static FILE_TOOLS: phf::Set<&'static str> = phf_set! {
 /// charged via Codex `included_in_output`, etc.) lands in `unattributed_*`.
 pub fn attribute_hotspots(turns: &[TurnRecord], opts: &HotspotsOptions<'_>) -> HotspotsResult {
     // First-seen session ordering matches the TS `Map` iteration semantics.
-    let mut by_session: IndexMap<String, Vec<TurnRecord>> = IndexMap::new();
+    // Borrow turns rather than cloning — nothing below mutates them and the
+    // input slice outlives every aggregation step.
+    let mut by_session: IndexMap<String, Vec<&TurnRecord>> = IndexMap::new();
     for t in turns {
-        by_session
-            .entry(t.session_id.clone())
-            .or_default()
-            .push(t.clone());
+        by_session.entry(t.session_id.clone()).or_default().push(t);
     }
 
     let mut attributions: Vec<ToolAttribution> = Vec::new();
@@ -284,7 +283,7 @@ struct SessionAttribution {
 }
 
 fn attribute_session(
-    turns: &[TurnRecord],
+    turns: &[&TurnRecord],
     pricing: &PricingTable,
     tool_results_by_turn: Option<&HashMap<u64, PerTurnContent>>,
     user_turns: &[UserTurnRecord],
@@ -341,7 +340,7 @@ fn attribute_session(
     let mut riding_active: Vec<usize> = Vec::new();
     let mut grand_total = 0.0_f64;
 
-    for turn in turns {
+    for &turn in turns {
         let turn_rate = lookup_model_rate(&turn.model, pricing);
 
         // Accumulate the per-turn grand total in this same pass. Routes
@@ -490,7 +489,7 @@ fn attribute_session(
 
 fn index_tool_results(
     content: &[ContentRecord],
-    turns: &[TurnRecord],
+    turns: &[&TurnRecord],
 ) -> HashMap<u64, PerTurnContent> {
     let mut by_turn: HashMap<u64, PerTurnContent> = HashMap::new();
     let mut turn_index_by_tool_use_id: HashMap<String, u64> = HashMap::new();

crates/relayburn-sdk/src/analyze/overhead.rs

@@ -15,8 +15,7 @@ use crate::reader::{SourceKind, TurnRecord};
 use serde::{Deserialize, Serialize};
 
 use crate::analyze::claude_md::{
-    attribute_claude_md, load_claude_md_file, AttributeClaudeMdInput, ClaudeMdAttributionResult,
-    ParsedClaudeMd,
+    attribute_claude_md_refs, load_claude_md_file, ClaudeMdAttributionResult, ParsedClaudeMd,
 };
 use crate::analyze::pricing::PricingTable;
 
@@ -128,17 +127,16 @@ pub fn attribute_overhead(input: AttributeOverheadInput<'_>) -> OverheadAttribut
         std::collections::HashMap::new();
 
     for pf in input.files {
-        let filtered: Vec<TurnRecord> = input
+        let filtered: Vec<&TurnRecord> = input
             .turns
             .iter()
             .filter(|t| pf.file.applies_to.contains(&t.source))
-            .cloned()
             .collect();
-        let attribution = attribute_claude_md(&AttributeClaudeMdInput {
-            files: std::slice::from_ref(&pf.parsed),
-            turns: &filtered,
-            pricing: input.pricing,
-        });
+        let attribution = attribute_claude_md_refs(
+            std::slice::from_ref(&pf.parsed),
+            &filtered,
+            input.pricing,
+        );
 
         for sc in &attribution.session_costs {
             let prev = max_riding_by_session

crates/relayburn-sdk/src/analyze/quality.rs

@@ -112,14 +112,16 @@ const FAILURE_STREAK_THRESHOLD: u64 = 3;
 
 pub fn compute_quality(turns: &[TurnRecord], opts: &ComputeQualityOptions) -> QualityResult {
     // Preserve TS Map iteration order: insertion-order across sessionIds.
-    let mut by_session: Vec<(String, Vec<TurnRecord>)> = Vec::new();
+    // Borrow rather than clone — nothing here mutates the turns and the
+    // input slice outlives every per-session aggregation.
+    let mut by_session: Vec<(String, Vec<&TurnRecord>)> = Vec::new();
     let mut idx: HashMap<String, usize> = HashMap::new();
     for t in turns {
         if let Some(&i) = idx.get(&t.session_id) {
-            by_session[i].1.push(t.clone());
+            by_session[i].1.push(t);
         } else {
             idx.insert(t.session_id.clone(), by_session.len());
-            by_session.push((t.session_id.clone(), vec![t.clone()]));
+            by_session.push((t.session_id.clone(), vec![t]));
         }
     }
 
@@ -129,13 +131,13 @@ pub fn compute_quality(turns: &[TurnRecord], opts: &ComputeQualityOptions) -> Qu
     let mut one_shot = Vec::with_capacity(by_session.len());
     for (session_id, mut session_turns) in by_session {
         session_turns.sort_by_key(|t| t.turn_index);
-        outcomes.push(infer_outcome(
+        outcomes.push(infer_outcome_refs(
             &session_id,
             &session_turns,
             opts.content_by_session,
             now,
         ));
-        one_shot.push(compute_one_shot_rate(&session_id, &session_turns));
+        one_shot.push(compute_one_shot_rate_refs(&session_id, &session_turns));
     }
 
     QualityResult { outcomes, one_shot }
@@ -146,6 +148,16 @@ pub fn infer_outcome(
     turns: &[TurnRecord],
     content_by_session: Option<&HashMap<String, Vec<ContentRecord>>>,
     now_ms: i64,
+) -> SessionOutcome {
+    let refs: Vec<&TurnRecord> = turns.iter().collect();
+    infer_outcome_refs(session_id, &refs, content_by_session, now_ms)
+}
+
+fn infer_outcome_refs(
+    session_id: &str,
+    turns: &[&TurnRecord],
+    content_by_session: Option<&HashMap<String, Vec<ContentRecord>>>,
+    now_ms: i64,
 ) -> SessionOutcome {
     if turns.is_empty() {
         return SessionOutcome {
@@ -260,6 +272,11 @@ pub fn infer_outcome(
 }
 
 pub fn compute_one_shot_rate(session_id: &str, turns: &[TurnRecord]) -> OneShotMetrics {
+    let refs: Vec<&TurnRecord> = turns.iter().collect();
+    compute_one_shot_rate_refs(session_id, &refs)
+}
+
+fn compute_one_shot_rate_refs(session_id: &str, turns: &[&TurnRecord]) -> OneShotMetrics {
     let mut edit_turns: u64 = 0;
     let mut one_shot_turns: u64 = 0;
     let mut total_retries: u64 = 0;
@@ -299,7 +316,7 @@ enum EndingRole {
     Unknown,
 }
 
-fn ending_role(turns: &[TurnRecord]) -> EndingRole {
+fn ending_role(turns: &[&TurnRecord]) -> EndingRole {
     // TurnRecord represents assistant turns; "ended-with-assistant" means the
     // final turn reached a natural stop (`end_turn`). A non-`end_turn` stop
     // reason means user-ended (session died after a tool_use). When the
@@ -312,7 +329,7 @@ fn ending_role(turns: &[TurnRecord]) -> EndingRole {
     }
 }
 
-fn trailing_failure_streak(turns: &[TurnRecord]) -> u64 {
+fn trailing_failure_streak(turns: &[&TurnRecord]) -> u64 {
     let mut streak: u64 = 0;
     for t in turns.iter().rev() {
         let calls = &t.tool_calls;