fix caching problems for A-stock hourly

Author: yuh-yang

docs/CACHING.md

@@ -33,6 +33,8 @@ A Python script (`scripts/precompute_frontend_cache.py`) generates static JSON f
 The frontend (`assets/js/cache-manager.js`) implements smart caching with per-market storage:
 
 1. **First Load**: Fetches pre-computed cache from server for the active market
+   - Uses cache-busting headers to bypass browser HTTP cache
+   - Ensures latest version is always checked from server
 2. **Saves to localStorage**: Stores each market's cache separately (us, cn, cn_hour)
 3. **Version Checking**: Auto-invalidates when data changes (version mismatch)
 4. **Graceful Degradation**: Falls back to live calculation if cache unavailable
@@ -331,13 +333,24 @@ if agents_data:
 
 **Symptom**: Generated new cache file but browser still shows old data
 
-**Cause**: Version hash based only on file timestamps didn't change
+**Root Cause**: Browser's HTTP cache serving stale `*_cache.json` files
 
-**Solution**: Increment `CACHE_FORMAT_VERSION` in `precompute_frontend_cache.py`:
-```python
-CACHE_FORMAT_VERSION = 'v4'  # Increment this!
+**Solution**: Added cache-busting to `cache-manager.js` (lines 126-136):
+```javascript
+// Add cache-busting to prevent browser HTTP cache from serving stale files
+const timestamp = Date.now();
+const response = await fetch(`./data/${market}_cache.json?v=${timestamp}`, {
+    cache: 'no-store',
+    headers: {
+        'Cache-Control': 'no-cache, no-store, must-revalidate',
+        'Pragma': 'no-cache',
+        'Expires': '0'
+    }
+});
 ```
 
+This ensures the browser always checks the server for the latest version instead of serving cached files.
+
 #### 5. Incomplete Data for Latest Trading Day
 
 **Symptom**: Cache missing today's data even though position files have it
@@ -798,6 +811,27 @@ To add hourly granularity to an existing daily market:
 
 ## Key Fixes and Design Decisions
 
+### Browser HTTP Cache Issue (v4 Critical Fix)
+
+**Problem**: After regenerating cache files with new data, browser continued showing old cached values (e.g., SSE-50 at ¥101,529 instead of ¥99,991)
+
+**Root Cause**: The `cache-manager.js` fetch call didn't include cache-busting headers, so browser's HTTP cache served stale `*_cache.json` files without checking the server
+
+**Solution**: Added cache-busting to `loadServerCache()` method:
+```javascript
+const timestamp = Date.now();
+const response = await fetch(`./data/${market}_cache.json?v=${timestamp}`, {
+    cache: 'no-store',
+    headers: {
+        'Cache-Control': 'no-cache, no-store, must-revalidate',
+        'Pragma': 'no-cache',
+        'Expires': '0'
+    }
+});
+```
+
+**Impact**: This ensures version detection works correctly - the browser always fetches the latest cache file from server, compares versions, and updates localStorage when data changes.
+
 ### Nov 19, 2025 Data Inclusion Fix
 
 **Problem**: Hourly A-shares cache stopped at Nov 18, missing Nov 19 data

docs/assets/js/asset-chart.js

@@ -236,23 +236,29 @@ function createChart() {
             sampleData: chartData.slice(0, 3)
         });
 
+        // Detect if we have hourly data (many data points with time component)
+        const isHourlyData = sortedDates.length > 50 && sortedDates[0].includes(':');
+
         const datasetObj = {
             label: dataLoader.getAgentDisplayName(agentName),
             data: chartData,
             borderColor: color,
-            backgroundColor: isBenchmark ? 'transparent' : createGradient(ctx, color),
+            backgroundColor: isBenchmark ? 'transparent' : createGradient(ctx, color), // Keep gradient for all
             borderWidth: borderWidth,
             borderDash: borderDash,
-            tension: 0.42, // Smooth curves for financial charts
+            tension: isHourlyData ? 0.45 : 0.4, // More smoothing for dense hourly data
             pointRadius: 0,
             pointHoverRadius: 7,
             pointHoverBackgroundColor: color,
             pointHoverBorderColor: '#fff',
             pointHoverBorderWidth: 3,
-            fill: !isBenchmark, // No fill for benchmarks
+            fill: !isBenchmark, // Fill for all non-benchmark agents
+            spanGaps: true, // Draw continuous lines even with missing data points
+            segment: {
+                borderColor: color,
+            },
             agentName: agentName,
-            agentIcon: dataLoader.getAgentIcon(agentName),
-            cubicInterpolationMode: 'monotone' // Smooth, monotonic interpolation
+            agentIcon: dataLoader.getAgentIcon(agentName)
         };
 
         console.log(`[DATASET OBJECT ${index}] borderColor: ${datasetObj.borderColor}, pointHoverBackgroundColor: ${datasetObj.pointHoverBackgroundColor}`);

docs/assets/js/cache-manager.js

@@ -122,7 +122,18 @@ class CacheManager {
     async loadServerCache(market) {
         try {
             console.log(`[CacheManager] Loading server cache for ${market} market...`);
-            const response = await fetch(`./data/${market}_cache.json`);
+
+            // Add cache-busting to prevent browser HTTP cache from serving stale files
+            // This ensures we always check for the latest version from the server
+            const timestamp = Date.now();
+            const response = await fetch(`./data/${market}_cache.json?v=${timestamp}`, {
+                cache: 'no-store',
+                headers: {
+                    'Cache-Control': 'no-cache, no-store, must-revalidate',
+                    'Pragma': 'no-cache',
+                    'Expires': '0'
+                }
+            });
 
             if (!response.ok) {
                 console.warn(`[CacheManager] Server cache not found for ${market} (${response.status})`);

scripts/precompute_frontend_cache.py

@@ -541,20 +541,48 @@ def process_benchmark_cn(market_config, agents_data=None):
             print(f"    Date filter: {start_date_filter} to {end_date_filter}")
             print(f"    Using initial value from agents: {initial_value}")
 
+        # Detect if this is hourly market by checking agent timestamps
+        is_hourly_market = False
+        all_agent_timestamps = set()
+        if agents_data:
+            for agent_name, agent_data in agents_data.items():
+                if agent_data.get('assetHistory'):
+                    first_date = agent_data['assetHistory'][0]['date']
+                    if ':' in first_date:
+                        is_hourly_market = True
+                    # Collect all agent timestamps for hourly expansion
+                    for h in agent_data['assetHistory']:
+                        all_agent_timestamps.add(h['date'])
+            print(f"    Market type: {'Hourly' if is_hourly_market else 'Daily'}")
+
         # Convert to asset history format
         asset_history = []
         dates = sorted(time_series.keys())
 
         benchmark_start_price = None
 
-        for date in dates:
+        # For hourly markets, use agent timestamps; for daily markets, use benchmark dates
+        timestamps_to_use = sorted(all_agent_timestamps) if is_hourly_market else dates
+
+        for timestamp in timestamps_to_use:
             # Apply date filtering to match agent date ranges
-            if start_date_filter and date < start_date_filter:
+            if start_date_filter and timestamp < start_date_filter:
                 continue
-            if end_date_filter and date > end_date_filter:
+            if end_date_filter and timestamp > end_date_filter:
                 continue
 
-            close_price = float(time_series[date].get('4. close') or time_series[date].get('4. sell price', 0))
+            # Find the benchmark price
+            if is_hourly_market:
+                # For hourly timestamps, extract date part and look up daily price
+                date_only = timestamp.split(' ')[0]
+                if date_only not in time_series:
+                    continue
+                close_price = float(time_series[date_only].get('4. close') or time_series[date_only].get('4. sell price', 0))
+            else:
+                # For daily timestamps, direct lookup
+                if timestamp not in time_series:
+                    continue
+                close_price = float(time_series[timestamp].get('4. close') or time_series[timestamp].get('4. sell price', 0))
 
             if benchmark_start_price is None:
                 benchmark_start_price = close_price
@@ -563,9 +591,9 @@ def process_benchmark_cn(market_config, agents_data=None):
             current_value = initial_value * (1 + benchmark_return)
 
             asset_history.append({
-                'date': date,
+                'date': timestamp,
                 'value': current_value,
-                'id': f'sse50-{date}',
+                'id': f'sse50-{timestamp}',
                 'action': None
             })
 
@@ -633,7 +661,7 @@ def generate_cache_for_market(market_id, market_config, config):
 
     # Create cache object
     # Add a manual version prefix to force cache invalidation when data structure changes
-    CACHE_FORMAT_VERSION = 'v3'  # Increment this when changing data structure (v3: added date filtering to QQQ)
+    CACHE_FORMAT_VERSION = 'v4'  # Increment this when changing data structure (v4: fixed hourly SSE-50 benchmark)
     cache = {
         'version': f"{CACHE_FORMAT_VERSION}_{version}",
         'generatedAt': datetime.now().isoformat(),