Fix HSA balance chart to use actual balance history records

The previous calculation derived historical balances backwards from
expenses, which incorrectly showed $40k starting balance when HSA
expenses were "Open" (not reimbursed).

Now uses hsa_balance_history table directly for the balance line,
showing accurate contribution progression ($4k -> $8k -> $12k).
Cumulative expenses are still calculated from expense records.

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

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: JavaDogWebDesign

app/services/hsa_balance_service.py

@@ -313,9 +313,9 @@ def calculate_balance_history(
     ) -> dict:
         """Calculate historical HSA balance for charting.
 
-        Works backwards from current balance to derive historical balances.
-        This ensures the chart shows an upward trajectory toward the current balance,
-        even when historical expenses are added after setting the current balance.
+        Uses actual hsa_balance_history records for balance values, ensuring
+        the chart shows accurate contribution and balance progression.
+        Cumulative expenses are calculated separately from HSA expense records.
 
         Args:
             user_id: The user's ID
@@ -326,59 +326,67 @@ def calculate_balance_history(
         """
         current_balance = self.get_balance(user_id)
 
-        # Get all HSA transactions ordered by date
-        transactions = self.conn.execute('''
-            SELECT date_of_service, amount_outflow, amount_inflow
+        # Get HSA balance history records ordered by date
+        history_records = self.conn.execute('''
+            SELECT date(recorded_at) as record_date, new_balance
+            FROM hsa_balance_history
+            WHERE user_id = ?
+            ORDER BY recorded_at ASC
+        ''', (user_id,)).fetchall()
+
+        # Get all HSA expenses for cumulative expense calculation
+        expenses = self.conn.execute('''
+            SELECT date_of_service, amount_outflow
             FROM expenses
             WHERE user_id = ? AND category = 'HSA'
             ORDER BY date_of_service ASC
         ''', (user_id,)).fetchall()
 
-        if not transactions:
+        # Build cumulative expenses by date
+        expense_by_date: dict = {}
+        cumulative = 0.0
+        for expense in expenses:
+            date_str = expense['date_of_service']
+            outflow = float(expense['amount_outflow']) if expense['amount_outflow'] else 0
+            cumulative += outflow
+            expense_by_date[date_str] = cumulative
+
+        # If no history records, return current balance only
+        if not history_records:
+            total_expenses = cumulative if expenses else 0
             return {
                 'dates': [current_date],
                 'balances': [current_balance],
-                'cumulative_expenses': [0]
+                'cumulative_expenses': [total_expenses]
             }
 
-        # Calculate the total net effect of all transactions
-        # net_effect = sum(inflow) - sum(outflow)
-        # This represents total reimbursements drawn from the HSA
-        total_net_effect = 0.0
-        total_outflow = 0.0
-        for transaction in transactions:
-            outflow = float(transaction['amount_outflow']) if transaction['amount_outflow'] else 0
-            inflow = float(transaction['amount_inflow']) if transaction['amount_inflow'] else 0
-            total_net_effect += (inflow - outflow)
-            total_outflow += outflow
-
-        # Work backwards: starting_balance = current_balance - net_effect_of_all_transactions
-        # This gives us what the balance would have been before any transactions
-        starting_balance = current_balance - total_net_effect
-
         dates: List[str] = []
         balances: List[float] = []
         cumulative_expenses: List[float] = []
 
-        balance_at_point = starting_balance
-        cumulative_total = 0.0
+        # Add data points from balance history
+        for record in history_records:
+            date_str = record['record_date']
+            balance = float(record['new_balance']) if record['new_balance'] else 0
 
-        for transaction in transactions:
-            date_str = transaction['date_of_service']
-            outflow = float(transaction['amount_outflow']) if transaction['amount_outflow'] else 0
-            inflow = float(transaction['amount_inflow']) if transaction['amount_inflow'] else 0
-
-            # Record the balance BEFORE this transaction is applied
+            # Only add if date not already present (avoid duplicates)
             if not dates or dates[-1] != date_str:
                 dates.append(date_str)
-                balances.append(balance_at_point)
-                cumulative_expenses.append(cumulative_total)
-
-            # Apply the transaction effect
-            balance_at_point += (inflow - outflow)
-            cumulative_total += outflow
-
-        # Add current date as the final point with the actual current balance
+                balances.append(balance)
+
+                # Find cumulative expenses up to this date
+                cumulative_at_date = 0.0
+                for exp_date, exp_cumulative in expense_by_date.items():
+                    if exp_date <= date_str:
+                        cumulative_at_date = exp_cumulative
+                    else:
+                        break
+                cumulative_expenses.append(cumulative_at_date)
+            else:
+                # Update the balance for the same date to the latest value
+                balances[-1] = balance
+
+        # Add current date as the final point if not already present
         if current_date not in dates:
             # Find correct chronological position
             insert_idx = len(dates)
@@ -387,21 +395,17 @@ def calculate_balance_history(
                     insert_idx = i
                     break
 
-            # Calculate cumulative expenses up to current date
+            # Get cumulative expenses up to current date
             cumulative_at_current = 0.0
-            for transaction in transactions:
-                if transaction['date_of_service'] > current_date:
+            for exp_date, exp_cumulative in expense_by_date.items():
+                if exp_date <= current_date:
+                    cumulative_at_current = exp_cumulative
+                else:
                     break
-                outflow = float(transaction['amount_outflow']) if transaction['amount_outflow'] else 0
-                cumulative_at_current += outflow
 
             dates.insert(insert_idx, current_date)
             balances.insert(insert_idx, current_balance)
             cumulative_expenses.insert(insert_idx, cumulative_at_current)
-        else:
-            # If current_date matches a transaction date, update that balance to current_balance
-            idx = dates.index(current_date)
-            balances[idx] = current_balance
 
         return {
             'dates': dates,