use crate::ingest::Turn;
const MUTATING: &[&str] = &["Edit", "Write", "MultiEdit", "NotebookEdit"];
const WINDOW: usize = 10;
const MIN_BASELINE_EDITS: u32 = 3;
const MIN_TURNS: usize = 12;
const T_DIMINISHING: f64 = 3.0;
const T_BURNING: f64 = 8.0;
#[derive(Debug, Clone, PartialEq)]
pub struct BurnSummary {
pub level: &'static str,
pub ratio: Option<f64>,
pub baseline: Option<f64>,
pub recent: Option<f64>,
pub turns: usize,
}
impl BurnSummary {
fn unknown(turns: usize) -> Self {
Self {
level: "unknown",
ratio: None,
baseline: None,
recent: None,
turns,
}
}
pub fn to_json(&self, updated_at: &str) -> serde_json::Value {
let mut o = serde_json::Map::new();
o.insert("level".into(), serde_json::json!(self.level));
o.insert("turns".into(), serde_json::json!(self.turns));
if let Some(r) = self.ratio {
o.insert("ratio".into(), serde_json::json!(round2(r)));
}
if let Some(b) = self.baseline {
o.insert("baseline".into(), serde_json::json!(round2(b)));
}
if let Some(r) = self.recent {
o.insert("recent".into(), serde_json::json!(round2(r)));
}
if !updated_at.is_empty() {
o.insert("updated_at".into(), serde_json::json!(updated_at));
}
serde_json::Value::Object(o)
}
}
fn round2(x: f64) -> f64 {
(x * 100.0).round() / 100.0
}
struct PerTurn {
context: f64,
edits: u32,
}
fn tool_name(call: &str) -> &str {
match call.find(':') {
Some(i) => call[..i].trim(),
None => call.trim(),
}
}
fn per_turn(t: &Turn) -> PerTurn {
let calls = t.tool_calls.len().max(1) as f64;
let context = (t.tokens.cache_read + t.tokens.cache_creation) as f64 / calls;
let edits = t
.tool_calls
.iter()
.filter(|c| MUTATING.contains(&tool_name(c)))
.count() as u32;
PerTurn { context, edits }
}
fn edits_in(rows: &[PerTurn]) -> u32 {
rows.iter().map(|r| r.edits).sum()
}
fn cost_per_edit(rows: &[PerTurn]) -> Option<f64> {
let ed: u32 = rows.iter().map(|r| r.edits).sum();
if ed == 0 {
return None;
}
let ctx: f64 = rows.iter().map(|r| r.context).sum();
Some(ctx / ed as f64)
}
pub fn compute(turns: &[Turn]) -> BurnSummary {
let n = turns.len();
if n < MIN_TURNS {
return BurnSummary::unknown(n);
}
let rows: Vec<PerTurn> = turns.iter().map(per_turn).collect();
let base_end = WINDOW.max(n / 3);
let base_rows = &rows[..base_end];
if edits_in(base_rows) < MIN_BASELINE_EDITS {
return BurnSummary::unknown(n);
}
let baseline = match cost_per_edit(base_rows) {
Some(b) if b > 0.0 => b,
_ => return BurnSummary::unknown(n),
};
let recent_rows = &rows[n.saturating_sub(WINDOW)..];
let recent_edits = edits_in(recent_rows);
let recent_ctx: f64 = recent_rows.iter().map(|r| r.context).sum();
let recent = if recent_edits > 0 {
recent_ctx / recent_edits as f64
} else {
recent_ctx
};
let ratio = recent / baseline;
let level = if ratio >= T_BURNING {
"burning"
} else if ratio >= T_DIMINISHING {
"diminishing"
} else {
"productive"
};
BurnSummary {
level,
ratio: Some(ratio),
baseline: Some(baseline),
recent: Some(recent),
turns: n,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ingest::TurnTokens;
fn turn(edits: usize, reads: usize, per_call_context: u64) -> Turn {
let mut calls: Vec<String> = Vec::new();
for i in 0..edits {
calls.push(format!("Edit: /src/f{i}.rs"));
}
for i in 0..reads {
calls.push(format!("Read: /src/r{i}.rs"));
}
let n = calls.len().max(1) as u64;
Turn {
user_text: "u".into(),
assistant_text: "a".into(),
tool_calls: calls,
tool_calls_raw: vec![],
tokens: TurnTokens {
cache_read: per_call_context * n,
..Default::default()
},
model: "m".into(),
timestamp: "t".into(),
cwd: None,
git_branches: vec![],
git_commit: None,
}
}
fn steady(n: usize) -> Vec<Turn> {
(0..n).map(|_| turn(3, 3, 100_000)).collect()
}
#[test]
fn short_session_is_unknown() {
assert_eq!(compute(&steady(MIN_TURNS - 1)).level, "unknown");
}
#[test]
fn edit_sparse_baseline_is_unknown() {
let mut turns: Vec<Turn> = (0..20).map(|_| turn(0, 6, 100_000)).collect();
turns.extend((0..10).map(|_| turn(4, 2, 100_000)));
assert_eq!(compute(&turns).level, "unknown");
}
#[test]
fn steady_session_is_productive() {
let r = compute(&steady(40));
assert_eq!(r.level, "productive");
assert!(r.ratio.unwrap() < T_DIMINISHING);
}
#[test]
fn higher_cost_per_edit_is_worse_not_better() {
let cheap = compute(&steady(40));
let mut expensive = steady(20);
expensive.extend((0..20).map(|_| turn(3, 3, 1_000_000)));
let expensive = compute(&expensive);
assert!(expensive.ratio.unwrap() > cheap.ratio.unwrap());
assert_eq!(cheap.level, "productive");
assert_eq!(expensive.level, "burning");
}
#[test]
fn severe_collapse_is_burning() {
let mut turns: Vec<Turn> = (0..20).map(|_| turn(4, 4, 100_000)).collect();
turns.extend((0..20).map(|_| turn(1, 7, 400_000)));
let r = compute(&turns);
assert!(r.ratio.unwrap() >= T_BURNING);
assert_eq!(r.level, "burning");
}
#[test]
fn zero_edit_trailing_window_is_burning() {
let mut turns: Vec<Turn> = (0..20).map(|_| turn(4, 2, 100_000)).collect();
turns.extend((0..WINDOW).map(|_| turn(0, 8, 300_000)));
assert_eq!(compute(&turns).level, "burning");
}
#[test]
fn unknown_stores_no_numbers() {
let j = BurnSummary::unknown(5).to_json("2026-01-01");
assert!(j.get("ratio").is_none());
assert_eq!(j["level"], "unknown");
assert_eq!(j["updated_at"], "2026-01-01");
}
}