fix: normalize stats model aggregation

src/cortex-cli/src/stats_cmd.rs

@@ -406,14 +406,14 @@ async fn collect_stats(sessions_dir: &PathBuf, cli: &StatsCli) -> Result<UsageSt
             provider_stats.estimated_cost_usd += session_cost;
 
             // Per-model stats
-            let model_stats =
-                stats
-                    .by_model
-                    .entry(model.to_string())
-                    .or_insert_with(|| ModelStats {
-                        provider: provider.clone(),
-                        ..Default::default()
-                    });
+            let model_key = model.to_lowercase();
+            let model_stats = stats
+                .by_model
+                .entry(model_key)
+                .or_insert_with(|| ModelStats {
+                    provider: provider.clone(),
+                    ..Default::default()
+                });
             model_stats.sessions += 1;
             model_stats.messages += session_data.message_count;
             model_stats.input_tokens += session_data.input_tokens;

src/cortex-cli/tests/stats_model_case.rs

@@ -0,0 +1,77 @@
+use std::fs;
+use std::path::PathBuf;
+use std::process::Command;
+
+#[test]
+fn stats_aggregates_model_names_case_insensitively() {
+    let sessions_dir = home_dir().join(".cortex").join("sessions");
+    fs::create_dir_all(&sessions_dir).expect("sessions directory should be created");
+
+    let unique = format!("codex-case-model-{}", std::process::id());
+    let lower_model = unique.to_lowercase();
+    let upper_model = lower_model.to_uppercase();
+    let lower_path = sessions_dir.join(format!("{lower_model}-lower.json"));
+    let upper_path = sessions_dir.join(format!("{lower_model}-upper.json"));
+
+    fs::write(
+        &lower_path,
+        serde_json::json!({
+            "model": lower_model,
+            "messages": [{"role": "user", "content": "a"}],
+            "usage": {"input_tokens": 100, "output_tokens": 100}
+        })
+        .to_string(),
+    )
+    .expect("lowercase session should be written");
+
+    fs::write(
+        &upper_path,
+        serde_json::json!({
+            "model": upper_model,
+            "messages": [{"role": "user", "content": "b"}],
+            "usage": {"input_tokens": 200, "output_tokens": 200}
+        })
+        .to_string(),
+    )
+    .expect("uppercase session should be written");
+
+    let output = Command::new(env!("CARGO_BIN_EXE_Cortex"))
+        .args(["stats", "--days", "3650", "--json"])
+        .output()
+        .expect("cortex binary should run");
+
+    let _ = fs::remove_file(&lower_path);
+    let _ = fs::remove_file(&upper_path);
+
+    assert!(
+        output.status.success(),
+        "expected zero exit; stdout: {}; stderr: {}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let json: serde_json::Value =
+        serde_json::from_slice(&output.stdout).expect("stats output should be JSON");
+    let by_model = json["by_model"]
+        .as_object()
+        .expect("by_model should be an object");
+
+    assert!(
+        by_model.contains_key(&lower_model),
+        "expected lowercase model key in by_model: {by_model:?}"
+    );
+    assert!(
+        !by_model.contains_key(&upper_model),
+        "uppercase model key should be folded into lowercase key: {by_model:?}"
+    );
+    assert_eq!(by_model[&lower_model]["sessions"], 2);
+    assert_eq!(by_model[&lower_model]["input_tokens"], 300);
+    assert_eq!(by_model[&lower_model]["output_tokens"], 300);
+}
+
+fn home_dir() -> PathBuf {
+    std::env::var_os("USERPROFILE")
+        .or_else(|| std::env::var_os("HOME"))
+        .map(PathBuf::from)
+        .expect("home directory environment should be available")
+}