feat: add challenge_path to StageResult for proper stage name display

- Add challenge_path field to StageResult model
- Update field names for clarity (valid_keystrokes, valid_mistakes)
- Improve SessionResult with better field semantics

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: unhappychoice

src/models/session.rs

@@ -1,5 +1,5 @@
 use super::stage::{Stage, StageResult};
-use crate::scoring::ScoringEngine;
+use crate::scoring::StageTracker;
 use std::time::{Duration, Instant};
 
 #[derive(Debug, Clone)]
@@ -11,27 +11,26 @@ pub struct Session {
 #[derive(Debug, Clone)]
 pub struct SessionResult {
     pub session_start_time: Instant,
-    pub session_duration: Duration,
-    pub total_session_time: Duration, // Alias for session_duration for backward compatibility
+    pub session_duration: Duration, // Total duration (valid + invalid) for backward compatibility
+    pub valid_session_duration: Duration, // Duration of completed stages only
+    pub invalid_session_duration: Duration, // Duration of skipped/failed stages
     pub stages_completed: usize,
     pub stages_attempted: usize,
     pub stages_skipped: usize,
-    pub total_challenges_completed: usize, // Alias for stages_completed
-    pub total_challenges_attempted: usize, // Alias for stages_attempted
-    pub total_skips_used: usize,           // Alias for stages_skipped
     pub stage_results: Vec<StageResult>,
     pub overall_accuracy: f64,
     pub overall_wpm: f64,
     pub overall_cpm: f64,
-    pub total_keystrokes: usize,
-    pub total_mistakes: usize,
-    pub total_partial_effort_keystrokes: usize,
-    pub total_partial_effort_mistakes: usize,
+    pub valid_keystrokes: usize,
+    pub valid_mistakes: usize,
+    pub invalid_keystrokes: usize,
+    pub invalid_mistakes: usize,
     pub best_stage_wpm: f64,
     pub worst_stage_wpm: f64,
     pub best_stage_accuracy: f64,
     pub worst_stage_accuracy: f64,
     pub session_score: f64,
+    pub session_successful: bool, // True if session was completed successfully
 }
 
 impl Session {
@@ -48,39 +47,37 @@ impl SessionResult {
         Self {
             session_start_time: Instant::now(),
             session_duration: Duration::default(),
-            total_session_time: Duration::default(),
+            valid_session_duration: Duration::default(),
+            invalid_session_duration: Duration::default(),
             stages_completed: 0,
             stages_attempted: 0,
             stages_skipped: 0,
-            total_challenges_completed: 0,
-            total_challenges_attempted: 0,
-            total_skips_used: 0,
             stage_results: Vec::new(),
             overall_accuracy: 0.0,
             overall_wpm: 0.0,
             overall_cpm: 0.0,
-            total_keystrokes: 0,
-            total_mistakes: 0,
-            total_partial_effort_keystrokes: 0,
-            total_partial_effort_mistakes: 0,
+            valid_keystrokes: 0,
+            valid_mistakes: 0,
+            invalid_keystrokes: 0,
+            invalid_mistakes: 0,
             best_stage_wpm: 0.0,
             worst_stage_wpm: f64::MAX,
             best_stage_accuracy: 0.0,
             worst_stage_accuracy: f64::MAX,
             session_score: 0.0,
+            session_successful: false,
         }
     }
 
     pub fn add_stage_result(
         &mut self,
         _stage_name: String,
         stage_result: StageResult,
-        engine: &ScoringEngine,
+        engine: &StageTracker,
     ) {
-        self.total_challenges_completed += 1;
-        self.stages_completed = self.total_challenges_completed;
-        self.total_keystrokes += engine.total_chars();
-        self.total_mistakes += stage_result.mistakes;
+        self.stages_completed += 1;
+        self.valid_keystrokes += engine.get_data().keystrokes.len();
+        self.valid_mistakes += stage_result.mistakes;
         self.session_score += stage_result.challenge_score;
 
         // Track best/worst performance
@@ -99,40 +96,36 @@ impl SessionResult {
     }
 
     pub fn add_skip(&mut self) {
-        self.total_skips_used += 1;
-        self.stages_skipped = self.total_skips_used;
-        self.total_challenges_attempted += 1;
-        self.stages_attempted = self.total_challenges_attempted;
+        self.stages_skipped += 1;
+        self.stages_attempted += 1;
     }
 
     pub fn add_partial_effort(&mut self, keystrokes: usize, mistakes: usize) {
-        self.total_partial_effort_keystrokes += keystrokes;
-        self.total_partial_effort_mistakes += mistakes;
+        self.invalid_keystrokes += keystrokes;
+        self.invalid_mistakes += mistakes;
     }
 
     // Calculate total effort including both completed and partial
     pub fn total_effort_keystrokes(&self) -> usize {
-        self.total_keystrokes + self.total_partial_effort_keystrokes
+        self.valid_keystrokes + self.invalid_keystrokes
     }
 
     pub fn total_effort_mistakes(&self) -> usize {
-        self.total_mistakes + self.total_partial_effort_mistakes
+        self.valid_mistakes + self.invalid_mistakes
     }
 
     pub fn finalize_session(&mut self) {
         self.session_duration = self.session_start_time.elapsed();
-        self.total_session_time = self.session_duration;
-        self.total_challenges_attempted = self.total_challenges_completed + self.total_skips_used;
-        self.stages_attempted = self.total_challenges_attempted;
+        self.stages_attempted = self.stages_completed + self.stages_skipped;
 
         // Calculate overall metrics
-        if self.session_duration.as_secs() > 0 && self.total_keystrokes > 0 {
+        if self.session_duration.as_secs() > 0 && self.valid_keystrokes > 0 {
             self.overall_cpm =
-                (self.total_keystrokes as f64 / self.session_duration.as_secs_f64()) * 60.0;
+                (self.valid_keystrokes as f64 / self.session_duration.as_secs_f64()) * 60.0;
             self.overall_wpm = self.overall_cpm / 5.0;
-            self.overall_accuracy = ((self.total_keystrokes.saturating_sub(self.total_mistakes))
+            self.overall_accuracy = ((self.valid_keystrokes.saturating_sub(self.valid_mistakes))
                 as f64
-                / self.total_keystrokes as f64)
+                / self.valid_keystrokes as f64)
                 * 100.0;
         }
 
@@ -146,7 +139,7 @@ impl SessionResult {
     }
 
     pub fn get_session_completion_status(&self) -> String {
-        match (self.total_challenges_completed, self.total_skips_used) {
+        match (self.stages_completed, self.stages_skipped) {
             (0, 0) => "No challenges attempted".to_string(),
             (completed, 0) if completed > 0 => {
                 format!("Perfect session! {} challenges completed", completed)

src/models/stage.rs

@@ -12,6 +12,7 @@ pub struct StageResult {
     pub cpm: f64,
     pub wpm: f64,
     pub accuracy: f64,
+    pub keystrokes: usize,
     pub mistakes: usize,
     pub consistency_streaks: Vec<usize>,
     pub completion_time: Duration,
@@ -24,6 +25,31 @@ pub struct StageResult {
     pub overall_total: usize,
     pub was_skipped: bool,
     pub was_failed: bool,
+    pub challenge_path: String,
+}
+
+impl Default for StageResult {
+    fn default() -> Self {
+        Self {
+            cpm: 0.0,
+            wpm: 0.0,
+            accuracy: 0.0,
+            keystrokes: 0,
+            mistakes: 0,
+            consistency_streaks: vec![],
+            completion_time: Duration::new(0, 0),
+            challenge_score: 0.0,
+            rank_name: "Unranked".to_string(),
+            tier_name: "Beginner".to_string(),
+            tier_position: 0,
+            tier_total: 0,
+            overall_position: 0,
+            overall_total: 0,
+            was_skipped: false,
+            was_failed: false,
+            challenge_path: String::new(),
+        }
+    }
 }
 
 impl Stage {