fix(trace): rename TotalCompactions to MaxCompactions

internal/classifier/classify.go

@@ -75,7 +75,7 @@ func detectBudget(t *trace.Trace) *Classification {
 
 func detectContextOverflow(t *trace.Trace) *Classification {
 	maxFill := t.MaxContextFill()
-	compactions := t.TotalCompactions()
+	compactions := t.MaxCompactions()
 
 	if compactions >= 3 && maxFill >= 90 {
 		return &Classification{

internal/cli/stats.go

@@ -59,7 +59,7 @@ func runStats(cmd *cobra.Command, args []string) error {
 		fmt.Printf("Max context:   %.0f%%\n", ctx)
 	}
 
-	compactions := t.TotalCompactions()
+	compactions := t.MaxCompactions()
 	if compactions > 0 {
 		fmt.Printf("Compactions:   %d\n", compactions)
 	}

internal/trace/metrics.go

@@ -44,7 +44,11 @@ func (t *Trace) MaxContextFill() float64 {
 	return max
 }
 
-func (t *Trace) TotalCompactions() int {
+// MaxCompactions returns the highest ContextState.Compactions value across
+// iterations. Compactions is a running counter (compactions so far in the
+// loop), so the max is the total observed; the name MaxCompactions matches
+// the aggregation (unlike the former TotalCompactions).
+func (t *Trace) MaxCompactions() int {
 	var max int
 	for _, it := range t.Iterations {
 		if it.Context.Compactions > max {

internal/trace/metrics_test.go

@@ -0,0 +1,33 @@
+package trace
+
+import "testing"
+
+func TestMaxCompactions(t *testing.T) {
+	tr := &Trace{Iterations: []Iteration{
+		{Number: 1, Context: ContextState{Compactions: 0}},
+		{Number: 2, Context: ContextState{Compactions: 1}},
+		{Number: 3, Context: ContextState{Compactions: 4}},
+	}}
+	if got := tr.MaxCompactions(); got != 4 {
+		t.Errorf("MaxCompactions() = %d, want 4 (max of running counter, not sum 5)", got)
+	}
+}
+
+func TestMaxCompactionsEmpty(t *testing.T) {
+	tr := &Trace{}
+	if got := tr.MaxCompactions(); got != 0 {
+		t.Errorf("MaxCompactions() = %d, want 0", got)
+	}
+}
+
+func TestMaxCompactionsOutOfOrder(t *testing.T) {
+	// Max (not last) so out-of-order iterations still yield the peak counter.
+	tr := &Trace{Iterations: []Iteration{
+		{Number: 3, Context: ContextState{Compactions: 4}},
+		{Number: 1, Context: ContextState{Compactions: 0}},
+		{Number: 2, Context: ContextState{Compactions: 1}},
+	}}
+	if got := tr.MaxCompactions(); got != 4 {
+		t.Errorf("MaxCompactions() = %d, want 4", got)
+	}
+}

internal/trace/types.go

@@ -54,7 +54,7 @@ type ContextState struct {
 	WindowUsed  int
 	WindowMax   int
 	FillPct     float64
-	Compactions int
+	Compactions int // running counter: so far in the loop, not per-iteration
 	CacheHitPct float64
 }