Upload folder using huggingface_hub

data/data_fetcher.py

@@ -94,6 +94,8 @@ class DataFetcher:
         'cabalspy_name',
         'axiom_kol_name'
     ]
+    DB_BATCH_SIZE = 5000
+
     def __init__(self, clickhouse_client: Any, neo4j_driver: Any):
         self.db_client = clickhouse_client
         self.graph_client = neo4j_driver
@@ -115,7 +117,6 @@ class DataFetcher:
         if where_clauses:
             query += " WHERE " + " AND ".join(where_clauses)
 
-        print(f"INFO: Executing query to get all mints: `{query}` with params: {params}")
         try:
             rows, columns_info = self.db_client.execute(query, params, with_column_types=True)
             if not rows:
@@ -136,7 +137,6 @@ class DataFetcher:
         Fetches the raw mint record for a token from the 'mints' table.
         """
         query = f"SELECT timestamp, creator_address, mint_address, protocol FROM mints WHERE mint_address = '{token_address}' ORDER BY timestamp ASC LIMIT 1"
-        print(f"INFO: Executing query to fetch mint record: `{query}`")
 
         # Assumes the client returns a list of dicts or can be converted
         # Using column names from your schema
@@ -177,12 +177,9 @@ class DataFetcher:
         if not wallet_addresses:
             return {}
 
-        BATCH_SIZE = 1000
+        BATCH_SIZE = self.DB_BATCH_SIZE
         socials = {}
-        total_wallets = len(wallet_addresses)
-        print(f"INFO: Executing query to fetch wallet socials for {total_wallets} wallets in batches of {BATCH_SIZE}.")
-
-        for i in range(0, total_wallets, BATCH_SIZE):
+        for i in range(0, len(wallet_addresses), BATCH_SIZE):
             batch_addresses = wallet_addresses[i : i + BATCH_SIZE]
             
             query = "SELECT * FROM wallet_socials WHERE wallet_address IN %(addresses)s"
@@ -245,14 +242,11 @@ class DataFetcher:
         profile_keys = [f"profile__{col}" for col in (profile_base_select_cols + profile_metric_select_cols)]
         social_keys = [f"social__{col}" for col in social_select_cols]
 
-        BATCH_SIZE = 1000
+        BATCH_SIZE = self.DB_BATCH_SIZE
         all_profiles = {}
         all_socials = {}
 
-        total_wallets = len(wallet_addresses)
-        print(f"INFO: Fetching profiles+socials for {total_wallets} wallets in batches of {BATCH_SIZE}...")
-
-        for i in range(0, total_wallets, BATCH_SIZE):
+        for i in range(0, len(wallet_addresses), BATCH_SIZE):
             batch_addresses = wallet_addresses[i : i + BATCH_SIZE]
             
             query = f"""
@@ -349,12 +343,9 @@ class DataFetcher:
         if not wallet_addresses:
             return {}
 
-        BATCH_SIZE = 1000
+        BATCH_SIZE = self.DB_BATCH_SIZE
         holdings = defaultdict(list)
-        total_wallets = len(wallet_addresses)
-        print(f"INFO: Executing query to fetch wallet holdings for {total_wallets} wallets in batches of {BATCH_SIZE}.")
-
-        for i in range(0, total_wallets, BATCH_SIZE):
+        for i in range(0, len(wallet_addresses), BATCH_SIZE):
             batch_addresses = wallet_addresses[i : i + BATCH_SIZE]
 
             # --- Time-aware query ---
@@ -423,8 +414,6 @@ class DataFetcher:
 
         cutoff_ts = int(T_cutoff.timestamp())
 
-        print(f"INFO: Fetching graph links up to {max_degrees} degrees for {len(initial_addresses)} initial entities...")
-
         max_retries = 3
         backoff_sec = 2
 
@@ -439,8 +428,6 @@ class DataFetcher:
                         if not newly_found_entities:
                             break
 
-                        print(f"  - Degree {i+1}: Traversing from {len(newly_found_entities)} new entities...")
-
                         # --- TIMING: Query execution ---
                         _t_query_start = time.perf_counter()
 
@@ -481,12 +468,6 @@ class DataFetcher:
 
                         _t_process_done = time.perf_counter()
 
-                        # --- TIMING: Print detailed stats ---
-                        print(f"    [NEO4J TIMING] query_exec: {(_t_query_done - _t_query_start)*1000:.1f}ms, "
-                              f"result_process: {(_t_process_done - _t_process_start)*1000:.1f}ms")
-                        print(f"    [NEO4J STATS] records_returned: {records_total}, "
-                              f"new_entities: {len(current_degree_new_entities)}")
-
                         newly_found_entities = current_degree_new_entities
 
                     # --- Post-process: rename, map props, strip, cap ---
@@ -589,12 +570,9 @@ class DataFetcher:
         if not token_addresses:
             return {}
 
-        BATCH_SIZE = 1000
+        BATCH_SIZE = self.DB_BATCH_SIZE
         tokens = {}
-        total_tokens = len(token_addresses)
-        print(f"INFO: Executing query to fetch token data for {total_tokens} tokens in batches of {BATCH_SIZE}.")
-
-        for i in range(0, total_tokens, BATCH_SIZE):
+        for i in range(0, len(token_addresses), BATCH_SIZE):
             batch_addresses = token_addresses[i : i + BATCH_SIZE]
 
             # --- NEW: Time-aware query for historical token data ---
@@ -645,10 +623,9 @@ class DataFetcher:
         if not token_addresses:
             return {}
 
-        BATCH_SIZE = 1000
+        BATCH_SIZE = self.DB_BATCH_SIZE
         token_details = {}
         total_tokens = len(token_addresses)
-        print(f"INFO: Executing query to fetch deployed token details for {total_tokens} tokens in batches of {BATCH_SIZE}.")
 
         for i in range(0, total_tokens, BATCH_SIZE):
             batch_addresses = token_addresses[i : i + BATCH_SIZE]
@@ -790,7 +767,6 @@ class DataFetcher:
         ORDER BY timestamp ASC
         """
         params = {'token_address': token_address, 'T_cutoff': T_cutoff, 'min_amount': min_amount_threshold}
-        print(f"INFO: Fetching significant transfers for {token_address} (amount >= {min_amount_threshold}).")
 
         try:
             # This query no longer uses H/B/H, it fetches all significant transfers

data/data_loader.py

@@ -19,6 +19,8 @@ from models.multi_modal_processor import MultiModalEncoder
 from data.data_fetcher import DataFetcher # NEW: Import the DataFetcher
 from data.context_targets import derive_movement_targets
 from data.quant_ohlc_feature_schema import (
+    FEATURE_INDEX,
+    SEGMENT_SECONDS,
     FEATURE_VERSION,
     FEATURE_VERSION_ID,
     LOOKBACK_SECONDS,
@@ -27,7 +29,6 @@ from data.quant_ohlc_feature_schema import (
     empty_feature_dict,
     feature_dict_to_vector,
 )
-from signals.patterns import compute_pattern_features
 from signals.rolling_quant import compute_rolling_quant_features
 from signals.support_resistance import compute_support_resistance_features
 from signals.trendlines import compute_trendline_features
@@ -233,6 +234,7 @@ class OracleDataset(Dataset):
         
         # Cache for lightweight token metadata to avoid redundant DB fetches
         self._token_meta_cache = {}
+        self._chart_feature_log_count = 0
         
 
 
@@ -956,11 +958,6 @@ class OracleDataset(Dataset):
                 continue
             all_token_data[addr] = data
 
-        # Print wallet_data sub-timings
-        print(f"    [WALLET_DATA] db_fetch: {_wd_timings['db_fetch']*1000:.1f}ms, "
-              f"holding_tokens: {_wd_timings['num_holding_tokens']}, "
-              f"holding_token_processing: {_wd_timings['holding_token_processing']*1000:.1f}ms")
-
         # --- Calculate deployed token stats using point-in-time logic ---
         self._calculate_deployed_token_stats(profiles, T_cutoff)
 
@@ -1105,7 +1102,6 @@ class OracleDataset(Dataset):
                 
                 # Fetch missing tokens
                 if missing_tokens and self.fetcher:
-                    print(f"INFO: Processing token data for {len(missing_tokens)} unique tokens (cache miss)...")
                     fetched = self.fetcher.fetch_token_data(missing_tokens, T_cutoff)
                     # Update cache
                     for addr, data in fetched.items():
@@ -1327,24 +1323,27 @@ class OracleDataset(Dataset):
     ) -> Dict[str, float]:
         return compute_trendline_features(closes, highs, lows, end_idx)
 
-    def _compute_optional_pattern_flags(
-        self,
-        closes: List[float],
-        highs: List[float],
-        lows: List[float],
-        end_idx: int,
-    ) -> Dict[str, float]:
-        return compute_pattern_features(closes, highs, lows, end_idx)
-
     def _extract_quant_ohlc_features_for_segment(
         self,
         segment: List[tuple],
         interval_label: str,
+        token_address: Optional[str] = None,
     ) -> List[Dict[str, Any]]:
-        del interval_label
         if not segment:
+            print(
+                f"INFO: Chart quant skipped | token={token_address or 'unknown'} "
+                "reason=empty_segment"
+            )
             return []
 
+        try:
+            interval_seconds = max(1, int(str(interval_label).rstrip("s")))
+        except Exception:
+            interval_seconds = 1
+        window_bar_count = max(1, WINDOW_SECONDS // interval_seconds)
+        effective_window_seconds = max(WINDOW_SECONDS, interval_seconds)
+        max_windows = max(1, SEGMENT_SECONDS // effective_window_seconds)
+
         timestamps = [int(row[0]) for row in segment]
         opens = [float(row[1]) for row in segment]
         closes = [float(row[2]) for row in segment]
@@ -1354,11 +1353,11 @@ class OracleDataset(Dataset):
         one_sec_returns = np.diff(log_closes)
         feature_windows: List[Dict[str, Any]] = []
 
-        for window_idx in range(TOKENS_PER_SEGMENT):
-            window_start = window_idx * WINDOW_SECONDS
+        for window_idx in range(max_windows):
+            window_start = window_idx * window_bar_count
             if window_start >= len(segment):
                 break
-            window_end = min(len(segment), window_start + WINDOW_SECONDS)
+            window_end = min(len(segment), window_start + window_bar_count)
             current_end_idx = window_end - 1
             window_returns = one_sec_returns[window_start:max(window_start, current_end_idx)]
             window_closes = closes[window_start:window_end]
@@ -1439,17 +1438,11 @@ class OracleDataset(Dataset):
                     closes=closes,
                     end_idx=current_end_idx,
                 ))
-                features.update(self._compute_optional_pattern_flags(
-                    closes=closes,
-                    highs=highs,
-                    lows=lows,
-                    end_idx=current_end_idx,
-                ))
 
             feature_windows.append({
                 "start_ts": timestamps[window_start],
                 "end_ts": timestamps[current_end_idx],
-                "window_seconds": WINDOW_SECONDS,
+                "window_seconds": effective_window_seconds,
                 "feature_vector": feature_dict_to_vector(features),
                 "feature_names_version": FEATURE_VERSION,
                 "feature_version_id": FEATURE_VERSION_ID,
@@ -1458,14 +1451,57 @@ class OracleDataset(Dataset):
                     "resistance_distance": features.get("nearest_resistance_dist", 0.0),
                     "support_strength": features.get("support_strength", 0.0),
                     "resistance_strength": features.get("resistance_strength", 0.0),
+                    "breakout_up": features.get("keylevel_breakout_up", 0.0),
+                    "breakout_down": features.get("keylevel_breakout_down", 0.0),
+                    "hold_above": features.get("keylevel_hold_above", 0.0),
+                    "hold_below": features.get("keylevel_hold_below", 0.0),
+                    "flip_to_support": features.get("keylevel_flip_to_support", 0.0),
+                    "flip_to_resistance": features.get("keylevel_flip_to_resistance", 0.0),
                 },
-                "pattern_flags": {
-                    key.replace("pattern_", "").replace("_confidence", ""): features[key]
-                    for key in features.keys()
-                    if key.startswith("pattern_") and key.endswith("_confidence")
+                "keylevel_flags": {
+                    "breakout_up": features.get("keylevel_breakout_up", 0.0),
+                    "breakout_down": features.get("keylevel_breakout_down", 0.0),
+                    "hold_above": features.get("keylevel_hold_above", 0.0),
+                    "hold_below": features.get("keylevel_hold_below", 0.0),
+                    "failed_breakout_up": features.get("keylevel_failed_breakout_up", 0.0),
+                    "failed_breakout_down": features.get("keylevel_failed_breakout_down", 0.0),
+                    "flip_to_support": features.get("keylevel_flip_to_support", 0.0),
+                    "flip_to_resistance": features.get("keylevel_flip_to_resistance", 0.0),
                 },
             })
 
+        sr_windows = sum(
+            1 for window in feature_windows
+            if float(window["feature_vector"][FEATURE_INDEX["sr_available"]]) > 0.0
+        )
+        trendline_windows = sum(
+            1 for window in feature_windows
+            if float(window["feature_vector"][FEATURE_INDEX["trendline_available"]]) > 0.0
+        )
+        breakout_windows = sum(
+            1 for window in feature_windows
+            if (
+                float(window["feature_vector"][FEATURE_INDEX["keylevel_breakout_up"]]) > 0.0
+                or float(window["feature_vector"][FEATURE_INDEX["keylevel_breakout_down"]]) > 0.0
+                or float(window["feature_vector"][FEATURE_INDEX["keylevel_flip_to_support"]]) > 0.0
+                or float(window["feature_vector"][FEATURE_INDEX["keylevel_flip_to_resistance"]]) > 0.0
+            )
+        )
+        keylevel_break_events = sum(
+            1 for window in feature_windows
+            if (
+                float(window["feature_vector"][FEATURE_INDEX["keylevel_breakout_up"]]) > 0.0
+                or float(window["feature_vector"][FEATURE_INDEX["keylevel_breakout_down"]]) > 0.0
+            )
+        )
+        self._chart_feature_log_count += 1
+        print(
+            f"INFO: Chart quant built | token={token_address or 'unknown'} "
+            f"interval={interval_label} segment={self._chart_feature_log_count} "
+            f"windows={len(feature_windows)}/{max_windows} "
+            f"sr={sr_windows} trend={trendline_windows} breaks={breakout_windows} "
+            f"break_events={keylevel_break_events}"
+        )
         return feature_windows
 
     def __getitem__(self, idx: int) -> Optional[Dict[str, Any]]:
@@ -2179,7 +2215,7 @@ class OracleDataset(Dataset):
                     'opens': self._normalize_price_series(opens_raw),
                     'closes': self._normalize_price_series(closes_raw),
                     'i': interval_label,
-                    'quant_ohlc_features': self._extract_quant_ohlc_features_for_segment(segment, interval_label) if interval_label == "1s" else [],
+                    'quant_ohlc_features': self._extract_quant_ohlc_features_for_segment(segment, interval_label, token_address=token_address),
                     'quant_feature_version': FEATURE_VERSION,
                 }
                 emitted_events.append(chart_event)

data/quant_ohlc_feature_schema.py

@@ -2,19 +2,11 @@ from collections import OrderedDict
 from typing import Dict, Iterable, List
 
 
-FEATURE_VERSION = "qohlc_v1"
-FEATURE_VERSION_ID = 1
+FEATURE_VERSION = "qohlc_v2"
+FEATURE_VERSION_ID = 2
 WINDOW_SECONDS = 5
 SEGMENT_SECONDS = 300
 TOKENS_PER_SEGMENT = SEGMENT_SECONDS // WINDOW_SECONDS
-PATTERN_NAMES = [
-    "double_top",
-    "double_bottom",
-    "ascending_triangle",
-    "descending_triangle",
-    "head_shoulders",
-    "inverse_head_shoulders",
-]
 LOOKBACK_SECONDS = [15, 30, 60, 120]
 
 
@@ -63,6 +55,18 @@ FEATURE_NAMES.extend([
     "resistance_swept",
     "support_reclaim",
     "resistance_reject",
+    "keylevel_breakout_up",
+    "keylevel_breakout_down",
+    "keylevel_hold_above",
+    "keylevel_hold_below",
+    "keylevel_failed_breakout_up",
+    "keylevel_failed_breakout_down",
+    "keylevel_flip_to_support",
+    "keylevel_flip_to_resistance",
+    "keylevel_upper_distance",
+    "keylevel_lower_distance",
+    "keylevel_zone_width_frac",
+    "keylevel_density",
     "lower_trendline_slope",
     "upper_trendline_slope",
     "dist_to_lower_line",
@@ -84,13 +88,9 @@ FEATURE_NAMES.extend([
     "rolling_vol_zscore",
 ])
 
-for pattern_name in PATTERN_NAMES:
-    FEATURE_NAMES.append(f"pattern_{pattern_name}_confidence")
-
 FEATURE_NAMES.extend([
     "sr_available",
     "trendline_available",
-    "pattern_available",
 ])
 
 FEATURE_INDEX = {name: idx for idx, name in enumerate(FEATURE_NAMES)}
@@ -126,6 +126,18 @@ FEATURE_GROUPS = OrderedDict([
         "resistance_swept",
         "support_reclaim",
         "resistance_reject",
+        "keylevel_breakout_up",
+        "keylevel_breakout_down",
+        "keylevel_hold_above",
+        "keylevel_hold_below",
+        "keylevel_failed_breakout_up",
+        "keylevel_failed_breakout_down",
+        "keylevel_flip_to_support",
+        "keylevel_flip_to_resistance",
+        "keylevel_upper_distance",
+        "keylevel_lower_distance",
+        "keylevel_zone_width_frac",
+        "keylevel_density",
     ]),
     ("trendlines", [
         "lower_trendline_slope",
@@ -150,11 +162,9 @@ FEATURE_GROUPS = OrderedDict([
         "mean_reversion_score",
         "rolling_vol_zscore",
     ]),
-    ("patterns", [name for name in FEATURE_NAMES if name.startswith("pattern_")]),
     ("availability", [
         "sr_available",
         "trendline_available",
-        "pattern_available",
     ]),
 ])
 

log.log

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:49c4d500d58301a7c158851716c6cf0c7e6bc60cdf59f7a166fcb92b4e77b04a
-size 390587
+oid sha256:edec35bc8304b6d83bfc091ee6f7ff1a9dd1864937f1e91b8655e01de2617d1c
+size 102571

scripts/cache_debug_web.py

@@ -0,0 +1,986 @@
+#!/usr/bin/env python3
+"""
+Minimal web viewer for cached context samples.
+
+Loads one cache sample with the same torch.load path used by dump_cache_sample.py
+and renders:
+- top-level debug metadata
+- cached Chart_Segment line view
+- quant window boundaries
+- per-window level/pattern summaries
+- full per-window feature maps
+
+Usage:
+    /venv/main/bin/python scripts/cache_debug_web.py
+    /venv/main/bin/python scripts/cache_debug_web.py --cache_dir data/cache --port 8765
+    /venv/main/bin/python scripts/cache_debug_web.py --file data/cache/sample_ABC.pt
+"""
+
+import argparse
+import json
+import os
+import random
+import sys
+from collections import Counter
+from datetime import datetime
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from urllib.parse import parse_qs, urlparse
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import numpy as np
+import torch
+import pandas as pd
+
+from data.quant_ohlc_feature_schema import FEATURE_NAMES
+from signals.support_resistance import compute_support_resistance_debug, compute_support_resistance_features
+from signals.trendlines import _fit_with_trendln
+from ta.trend import ema_indicator, sma_indicator
+
+
+def _load_cache_sample(path: Path) -> Dict[str, Any]:
+    return torch.load(path, map_location="cpu", weights_only=False)
+
+
+def _safe_float(value: Any) -> float:
+    try:
+        return float(value)
+    except Exception:
+        return 0.0
+
+
+def _feature_map(window: Dict[str, Any]) -> Dict[str, float]:
+    vector = window.get("feature_vector", [])
+    if not isinstance(vector, list):
+        return {}
+    return {
+        name: _safe_float(vector[idx]) if idx < len(vector) else 0.0
+        for idx, name in enumerate(FEATURE_NAMES)
+    }
+
+
+def _chart_points(chart_event: Dict[str, Any]) -> List[Dict[str, float]]:
+    raw_opens = chart_event.get("raw_opens")
+    raw_closes = chart_event.get("raw_closes")
+    if isinstance(raw_opens, list) and isinstance(raw_closes, list) and raw_closes:
+        opens = raw_opens
+        closes = raw_closes
+    else:
+        opens_logged = chart_event.get("opens", []) or []
+        closes_logged = chart_event.get("closes", []) or []
+        opens = [float(np.exp(v)) for v in opens_logged]
+        closes = [float(np.exp(v)) for v in closes_logged]
+    end_ts = int(chart_event.get("timestamp", 0) or 0)
+    if not closes:
+        return []
+    interval_str = str(chart_event.get("i", "1s"))
+    try:
+        interval_seconds = max(1, int(interval_str.rstrip("s")))
+    except Exception:
+        interval_seconds = 1
+    start_ts = end_ts - interval_seconds * (len(closes) - 1)
+    points: List[Dict[str, float]] = []
+    for idx, (open_value, close_value) in enumerate(zip(opens, closes)):
+        ts = start_ts + idx * interval_seconds
+        high_value = max(open_value, close_value)
+        low_value = min(open_value, close_value)
+        points.append({
+            "time": int(ts),
+            "open": _safe_float(open_value),
+            "high": _safe_float(high_value),
+            "low": _safe_float(low_value),
+            "close": _safe_float(close_value),
+            "index": idx,
+        })
+    return points
+
+
+def _compute_level_overlays(points: List[Dict[str, float]], windows: List[Dict[str, Any]]) -> Dict[str, Any]:
+    del windows
+    if not points:
+        return {"support_levels": [], "resistance_levels": []}
+    closes = [_safe_float(p["close"]) for p in points]
+    highs = [_safe_float(p["high"]) for p in points]
+    lows = [_safe_float(p["low"]) for p in points]
+    timestamps = [int(p["time"]) for p in points]
+    debug = compute_support_resistance_debug(
+        closes=closes,
+        highs=highs,
+        lows=lows,
+        timestamps=timestamps,
+    )
+    support_levels = debug.get("support_levels", []) or debug.get("all_support_levels", [])
+    resistance_levels = debug.get("resistance_levels", []) or debug.get("all_resistance_levels", [])
+    return {
+        "support_levels": support_levels,
+        "resistance_levels": resistance_levels,
+        "all_support_levels": debug.get("all_support_levels", []),
+        "all_resistance_levels": debug.get("all_resistance_levels", []),
+        "sr_available": debug.get("sr_available", 0.0),
+    }
+
+
+def _compute_trendline_overlays(points: List[Dict[str, float]]) -> List[Dict[str, Any]]:
+    if len(points) < 5:
+        return []
+    closes = np.asarray([p["close"] for p in points], dtype=np.float64)
+    highs = np.asarray([p["high"] for p in points], dtype=np.float64)
+    lows = np.asarray([p["low"] for p in points], dtype=np.float64)
+    out: List[Dict[str, Any]] = []
+    try:
+        lower_line, upper_line = _fit_with_trendln(closes)
+    except Exception:
+        lower_line, upper_line = None, None
+    if lower_line is None:
+        try:
+            lower_line, _ = _fit_with_trendln(lows)
+        except Exception:
+            lower_line = None
+    if upper_line is None:
+        try:
+            _, upper_line = _fit_with_trendln(highs)
+        except Exception:
+            upper_line = None
+
+    def _line_payload(name: str, line: Any, color: str) -> Optional[Dict[str, Any]]:
+        if line is None:
+            return None
+        slope, intercept = line
+        x0, x1 = 0, len(points) - 1
+        y0 = slope * x0 + intercept
+        y1 = slope * x1 + intercept
+        return {
+            "name": name,
+            "color": color,
+            "points": [
+                {"time": points[x0]["time"], "value": _safe_float(y0)},
+                {"time": points[x1]["time"], "value": _safe_float(y1)},
+            ],
+        }
+
+    lower_payload = _line_payload("lower_trendline", lower_line, "#0f766e")
+    upper_payload = _line_payload("upper_trendline", upper_line, "#b91c1c")
+    if lower_payload:
+        out.append(lower_payload)
+    if upper_payload:
+        out.append(upper_payload)
+    return out
+
+
+def _compute_window_boundaries(points: List[Dict[str, float]], windows: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    if not points:
+        return []
+    min_value = min(point["low"] for point in points)
+    max_value = max(point["high"] for point in points)
+    out: List[Dict[str, Any]] = []
+    for idx, window in enumerate(windows):
+        end_ts = int(window.get("end_ts", 0) or 0)
+        breakout_active = any(
+            _safe_float((window.get("keylevel_flags", {}) or {}).get(flag, 0.0)) > 0.0
+            for flag in ("breakout_up", "breakout_down", "flip_to_support", "flip_to_resistance")
+        )
+        out.append({
+            "name": f"window_{idx}",
+            "window_idx": idx,
+            "color": "#8b1e3f" if breakout_active else "#c84c2d",
+            "points": [
+                {"time": end_ts, "value": _safe_float(min_value)},
+                {"time": end_ts, "value": _safe_float(max_value)},
+            ],
+        })
+    return out
+
+
+def _compute_indicator_overlays(points: List[Dict[str, float]]) -> List[Dict[str, Any]]:
+    if not points:
+        return []
+    closes = pd.Series([_safe_float(point["close"]) for point in points], dtype="float64")
+    ema_fast = ema_indicator(closes, window=8, fillna=True)
+    ema_medium = ema_indicator(closes, window=21, fillna=True)
+    sma_fast = sma_indicator(closes, window=8, fillna=True)
+    sma_medium = sma_indicator(closes, window=21, fillna=True)
+
+    def _series_payload(name: str, series: pd.Series, color: str, dash: str = "solid") -> Dict[str, Any]:
+        return {
+            "name": name,
+            "color": color,
+            "dash": dash,
+            "points": [
+                {"time": points[idx]["time"], "value": _safe_float(value)}
+                for idx, value in enumerate(series.tolist())
+            ],
+        }
+
+    return [
+        _series_payload("ema_fast_8", ema_fast, "#2563eb"),
+        _series_payload("ema_medium_21", ema_medium, "#7c3aed"),
+        _series_payload("sma_fast_8", sma_fast, "#ea580c", "dot"),
+        _series_payload("sma_medium_21", sma_medium, "#0891b2", "dot"),
+    ]
+
+
+def _recompute_window_keylevel_flags(
+    points: List[Dict[str, float]],
+    windows: List[Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    if not points or not windows:
+        return windows
+    closes = [_safe_float(point["close"]) for point in points]
+    highs = [_safe_float(point["high"]) for point in points]
+    lows = [_safe_float(point["low"]) for point in points]
+    timestamps = [int(point["time"]) for point in points]
+    time_to_idx = {timestamp: idx for idx, timestamp in enumerate(timestamps)}
+
+    updated: List[Dict[str, Any]] = []
+    for window in windows:
+        start_ts = int(window.get("start_ts", 0) or 0)
+        end_ts = int(window.get("end_ts", 0) or 0)
+        if end_ts not in time_to_idx:
+            updated.append(window)
+            continue
+        end_idx = time_to_idx[end_ts]
+        start_idx = time_to_idx.get(start_ts, max(0, end_idx))
+        if start_idx > end_idx:
+            start_idx = end_idx
+        sr_features = compute_support_resistance_features(
+            closes=closes,
+            highs=highs,
+            lows=lows,
+            end_idx=end_idx,
+            window_start=start_idx,
+            window_end=end_idx + 1,
+            timestamps=timestamps,
+        )
+        keylevel_flags = {
+            "breakout_up": sr_features.get("keylevel_breakout_up", 0.0),
+            "breakout_down": sr_features.get("keylevel_breakout_down", 0.0),
+            "hold_above": sr_features.get("keylevel_hold_above", 0.0),
+            "hold_below": sr_features.get("keylevel_hold_below", 0.0),
+            "failed_breakout_up": sr_features.get("keylevel_failed_breakout_up", 0.0),
+            "failed_breakout_down": sr_features.get("keylevel_failed_breakout_down", 0.0),
+            "flip_to_support": sr_features.get("keylevel_flip_to_support", 0.0),
+            "flip_to_resistance": sr_features.get("keylevel_flip_to_resistance", 0.0),
+        }
+        top_signal_name = "none"
+        for signal_name in (
+            "breakout_up",
+            "breakout_down",
+            "flip_to_support",
+            "flip_to_resistance",
+            "failed_breakout_up",
+            "failed_breakout_down",
+        ):
+            if _safe_float(keylevel_flags.get(signal_name, 0.0)) > 0.0:
+                top_signal_name = signal_name
+                break
+        updated_window = dict(window)
+        updated_window["keylevel_flags"] = keylevel_flags
+        updated_window["top_signal_name"] = top_signal_name
+        updated.append(updated_window)
+    return updated
+
+
+def _compute_keylevel_signal_overlays(
+    points: List[Dict[str, float]],
+    windows: List[Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    if not points or not windows:
+        return []
+    time_to_point = {int(point["time"]): point for point in points}
+    signal_specs = {
+        "breakout_up": {"color": "#15803d", "symbol": "triangle-up", "y_key": "high"},
+        "breakout_down": {"color": "#b91c1c", "symbol": "triangle-down", "y_key": "low"},
+        "flip_to_support": {"color": "#1d4ed8", "symbol": "diamond", "y_key": "close"},
+        "flip_to_resistance": {"color": "#7c2d12", "symbol": "diamond", "y_key": "close"},
+        "failed_breakout_up": {"color": "#ea580c", "symbol": "x", "y_key": "high"},
+        "failed_breakout_down": {"color": "#9333ea", "symbol": "x", "y_key": "low"},
+    }
+    overlays: List[Dict[str, Any]] = []
+    for window in windows:
+        end_ts = int(window.get("end_ts", 0) or 0)
+        point = time_to_point.get(end_ts)
+        if point is None:
+            continue
+        flags = window.get("keylevel_flags", {}) or {}
+        for signal_name, spec in signal_specs.items():
+            if _safe_float(flags.get(signal_name, 0.0)) <= 0.0:
+                continue
+            y_value = _safe_float(point.get(spec["y_key"], point["close"]))
+            if spec["y_key"] == "high":
+                y_value *= 1.003
+            elif spec["y_key"] == "low":
+                y_value *= 0.997
+            overlays.append({
+                "name": signal_name,
+                "time": end_ts,
+                "value": y_value,
+                "color": spec["color"],
+                "symbol": spec["symbol"],
+                "window_idx": int(window.get("idx", -1)),
+            })
+    return overlays
+
+
+def _sample_to_payload(sample: Dict[str, Any], source_file: Path) -> Dict[str, Any]:
+    event_sequence = sample.get("event_sequence", [])
+    event_counts = Counter(event.get("event_type", "Unknown") for event in event_sequence)
+    chart_events = [event for event in event_sequence if event.get("event_type") == "Chart_Segment"]
+    chart_event = chart_events[0] if chart_events else {}
+    quant_windows = chart_event.get("quant_ohlc_features", []) or []
+
+    windows_payload: List[Dict[str, Any]] = []
+    for idx, window in enumerate(quant_windows):
+        feature_map = _feature_map(window)
+
+        windows_payload.append({
+            "idx": idx,
+            "start_ts": window.get("start_ts"),
+            "end_ts": window.get("end_ts"),
+            "window_seconds": window.get("window_seconds"),
+            "level_snapshot": window.get("level_snapshot", {}) or {},
+            "keylevel_flags": window.get("keylevel_flags", {}) or {},
+            "top_signal_name": "none",
+            "feature_map": feature_map,
+            "sr_available": _safe_float(feature_map.get("sr_available", 0.0)),
+            "trendline_available": _safe_float(feature_map.get("trendline_available", 0.0)),
+        })
+
+    chart_points = _chart_points(chart_event) if chart_event else []
+    windows_payload = _recompute_window_keylevel_flags(chart_points, windows_payload)
+    level_overlays = _compute_level_overlays(chart_points, windows_payload)
+    trendline_overlays = _compute_trendline_overlays(chart_points)
+    boundary_overlays = _compute_window_boundaries(chart_points, windows_payload)
+    indicator_overlays = _compute_indicator_overlays(chart_points)
+    signal_overlays = _compute_keylevel_signal_overlays(chart_points, windows_payload)
+
+    return {
+        "source_file": str(source_file),
+        "sample": {
+            "token_address": sample.get("token_address"),
+            "source_token": sample.get("source_token"),
+            "sample_idx": sample.get("sample_idx"),
+            "class_id": sample.get("class_id"),
+            "context_bucket": sample.get("context_bucket"),
+            "context_score": sample.get("context_score"),
+            "quality_score": _safe_float(sample.get("quality_score", 0.0)),
+            "t_cutoff": sample.get("t_cutoff"),
+            "labels": sample.get("labels").tolist() if hasattr(sample.get("labels"), "tolist") else sample.get("labels"),
+            "labels_mask": sample.get("labels_mask").tolist() if hasattr(sample.get("labels_mask"), "tolist") else sample.get("labels_mask"),
+            "event_counts": dict(event_counts),
+            "n_events": len(event_sequence),
+            "n_wallets": len(sample.get("wallets", {})),
+            "n_tokens": len(sample.get("tokens", {})),
+            "n_graph_link_types": len(sample.get("graph_links", {})),
+        },
+        "chart": {
+            "present": bool(chart_event),
+            "timestamp": chart_event.get("timestamp"),
+            "relative_ts": chart_event.get("relative_ts"),
+            "interval": chart_event.get("i"),
+            "opens": chart_event.get("opens", []) or [],
+            "closes": chart_event.get("closes", []) or [],
+            "windows": windows_payload,
+            "points": chart_points,
+            "overlays": {
+                "levels": level_overlays,
+                "trendlines": trendline_overlays,
+                "boundaries": boundary_overlays,
+                "indicators": indicator_overlays,
+                "signals": signal_overlays,
+            },
+        },
+    }
+
+
+HTML = """<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Cache Debug</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    :root {
+      --bg: #f4efe7;
+      --panel: #fffaf2;
+      --ink: #1f1a17;
+      --muted: #6f645b;
+      --line: #d7ccbf;
+      --accent: #c84c2d;
+      --accent2: #0f766e;
+      --warn: #8b1e3f;
+      --chart: #1f1a17;
+      --chart2: #6a8a82;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: Georgia, "Times New Roman", serif;
+      background: radial-gradient(circle at top left, #fffdf8, var(--bg) 46%, #efe4d4 100%);
+      color: var(--ink);
+    }
+    header, main { max-width: 1420px; margin: 0 auto; padding: 18px 20px; }
+    header { display: flex; gap: 12px; align-items: center; justify-content: space-between; }
+    h1 { margin: 0; font-size: 28px; letter-spacing: -0.03em; }
+    .sub { color: var(--muted); font-size: 14px; }
+    .actions { display: flex; gap: 10px; align-items: center; }
+    button, input {
+      font: inherit;
+      border: 1px solid var(--line);
+      background: var(--panel);
+      color: var(--ink);
+      border-radius: 999px;
+      padding: 9px 14px;
+    }
+    button { cursor: pointer; }
+    button:hover { border-color: var(--accent); }
+    main { display: grid; gap: 18px; }
+    .grid {
+      display: grid;
+      grid-template-columns: 340px minmax(0, 1fr);
+      gap: 18px;
+      align-items: start;
+    }
+    .panel {
+      background: color-mix(in srgb, var(--panel) 88%, white);
+      border: 1px solid var(--line);
+      border-radius: 22px;
+      box-shadow: 0 14px 50px rgba(31, 26, 23, 0.06);
+    }
+    .panel h2, .panel h3 { margin: 0 0 12px; }
+    .meta { padding: 18px; }
+    .kv {
+      display: grid;
+      grid-template-columns: 120px 1fr;
+      gap: 8px 10px;
+      font-size: 14px;
+      margin-bottom: 16px;
+    }
+    .kv div:nth-child(odd) { color: var(--muted); }
+    .badge {
+      display: inline-block;
+      border: 1px solid var(--line);
+      border-radius: 999px;
+      padding: 4px 10px;
+      margin: 0 6px 6px 0;
+      font-size: 12px;
+      background: #fff;
+    }
+    .main-panel { padding: 18px; }
+    #chart-wrap { border: 1px solid var(--line); border-radius: 18px; background: #fff; overflow: hidden; padding: 6px; }
+    #chart-root { width: 100%; height: 460px; }
+    .legend { display: flex; flex-wrap: wrap; gap: 10px; margin-top: 12px; color: var(--muted); font-size: 13px; }
+    .legend span::before { content: ""; display: inline-block; width: 16px; height: 2px; margin-right: 6px; vertical-align: middle; background: var(--ink); }
+    .legend .close::before { background: var(--chart); }
+    .legend .open::before { background: var(--chart2); }
+    .legend .boundary::before { background: var(--accent); }
+    .legend .pattern::before { background: var(--warn); }
+    .window-layout {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) 380px;
+      gap: 18px;
+      align-items: start;
+    }
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: 13px;
+    }
+    th, td {
+      padding: 8px 10px;
+      border-bottom: 1px solid var(--line);
+      text-align: left;
+      vertical-align: top;
+    }
+    tr:hover { background: rgba(200, 76, 45, 0.05); cursor: pointer; }
+    tr.active { background: rgba(200, 76, 45, 0.11); }
+    .detail {
+      padding: 14px;
+      border: 1px solid var(--line);
+      border-radius: 18px;
+      background: #fff;
+      position: sticky;
+      top: 18px;
+    }
+    .detail pre {
+      margin: 0;
+      white-space: pre-wrap;
+      word-break: break-word;
+      font-size: 12px;
+      color: var(--ink);
+    }
+    .muted { color: var(--muted); }
+    .toggles {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+      margin: 0 0 12px;
+      font-size: 13px;
+      color: var(--muted);
+    }
+    .toggles label {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      padding: 6px 10px;
+      border: 1px solid var(--line);
+      border-radius: 999px;
+      background: #fff;
+      cursor: pointer;
+    }
+    @media (max-width: 1080px) {
+      .grid, .window-layout { grid-template-columns: 1fr; }
+      .detail { position: static; }
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <div>
+      <h1>Cache Debug Console</h1>
+      <div class="sub">Render one cached sample, its chart segment, quant-window boundaries, keylevels, breakouts, and feature payloads.</div>
+    </div>
+    <div class="actions">
+      <input id="file-input" placeholder="sample_123.pt or absolute path">
+      <button id="load-file">Load File</button>
+      <button id="random-btn">Random Sample</button>
+    </div>
+  </header>
+  <main>
+    <div class="grid">
+      <section class="panel meta">
+        <h2>Sample</h2>
+        <div id="meta"></div>
+        <h3>Event Counts</h3>
+        <div id="events"></div>
+      </section>
+      <section class="panel main-panel">
+        <h2>Chart Segment</h2>
+        <div class="toggles">
+          <label><input type="checkbox" id="toggle-indicators" checked> Indicators</label>
+          <label><input type="checkbox" id="toggle-levels"> Levels</label>
+          <label><input type="checkbox" id="toggle-trendlines"> Trendlines</label>
+          <label><input type="checkbox" id="toggle-boundaries" checked> Boundaries</label>
+        </div>
+        <div id="chart-wrap">
+          <div id="chart-root"></div>
+        </div>
+        <div class="legend">
+          <span class="close">Price</span>
+          <span class="open">Levels</span>
+          <span class="boundary">Quant Window Boundary</span>
+          <span class="pattern">Break / Trendline</span>
+        </div>
+      </section>
+    </div>
+    <section class="panel main-panel">
+      <h2>Quant Windows</h2>
+      <div class="window-layout">
+        <div style="overflow:auto;">
+          <table>
+            <thead>
+              <tr>
+                <th>#</th>
+                <th>Range</th>
+                <th>SR</th>
+                <th>Trend</th>
+                <th>Top Signal</th>
+                <th>Support</th>
+                <th>Resistance</th>
+              </tr>
+            </thead>
+            <tbody id="windows-body"></tbody>
+          </table>
+        </div>
+        <div class="detail">
+          <h3 id="detail-title">Window Detail</h3>
+          <pre id="detail-pre">Select a quant window.</pre>
+        </div>
+      </div>
+    </section>
+  </main>
+  <script src="https://cdn.plot.ly/plotly-2.35.2.min.js"></script>
+  <script>
+    const chartRoot = document.getElementById("chart-root");
+    const meta = document.getElementById("meta");
+    const events = document.getElementById("events");
+    const body = document.getElementById("windows-body");
+    const detailTitle = document.getElementById("detail-title");
+    const detailPre = document.getElementById("detail-pre");
+    let currentPayload = null;
+    let activeWindow = -1;
+    const layerState = {
+      indicators: true,
+      levels: false,
+      trendlines: false,
+      boundaries: true,
+    };
+
+    function q(path) {
+      return fetch(path).then(r => {
+        if (!r.ok) throw new Error("HTTP " + r.status);
+        return r.json();
+      });
+    }
+
+    function fmt(v) {
+      if (v === null || v === undefined) return "n/a";
+      if (typeof v === "number") return Number(v).toFixed(4);
+      return String(v);
+    }
+
+    function renderMeta(data) {
+      const s = data.sample;
+      meta.innerHTML = `
+        <div class="kv">
+          <div>file</div><div>${data.source_file}</div>
+          <div>token</div><div>${s.token_address || "n/a"}</div>
+          <div>source token</div><div>${s.source_token || "n/a"}</div>
+          <div>sample idx</div><div>${fmt(s.sample_idx)}</div>
+          <div>class</div><div>${fmt(s.class_id)}</div>
+          <div>bucket</div><div>${fmt(s.context_bucket)}</div>
+          <div>context score</div><div>${fmt(s.context_score)}</div>
+          <div>quality score</div><div>${fmt(s.quality_score)}</div>
+          <div>t cutoff</div><div>${fmt(s.t_cutoff)}</div>
+          <div>events</div><div>${fmt(s.n_events)}</div>
+          <div>wallets</div><div>${fmt(s.n_wallets)}</div>
+          <div>tokens</div><div>${fmt(s.n_tokens)}</div>
+          <div>graph types</div><div>${fmt(s.n_graph_link_types)}</div>
+          <div>labels</div><div>${JSON.stringify(s.labels)}</div>
+          <div>mask</div><div>${JSON.stringify(s.labels_mask)}</div>
+        </div>
+      `;
+      events.innerHTML = Object.entries(s.event_counts)
+        .sort((a, b) => b[1] - a[1])
+        .map(([k, v]) => `<span class="badge">${k}: ${v}</span>`)
+        .join("");
+    }
+
+    function clearChart() {
+      Plotly.purge(chartRoot);
+      chartRoot.innerHTML = "";
+    }
+
+    function renderChart(data) {
+      clearChart();
+      const chart = data.chart;
+      if (!chart.present || !(chart.points || []).length) {
+        chartRoot.innerHTML = `<div style="padding:24px;color:#6f645b;">No Chart_Segment found in this sample.</div>`;
+        return;
+      }
+
+      const xs = chart.points.map((_, idx) => idx);
+      const hoverTexts = chart.points.map((p, idx) =>
+        `idx=${idx}<br>ts=${new Date(p.time * 1000).toISOString()}<br>open=${p.open.toFixed(4)}<br>close=${p.close.toFixed(4)}`
+      );
+      const traces = [{
+        type: 'scatter',
+        mode: 'lines+markers',
+        x: xs,
+        y: chart.points.map(p => p.close),
+        line: { color: '#1f1a17', width: 3 },
+        marker: { color: '#1f1a17', size: 5 },
+        name: 'close',
+        text: hoverTexts,
+        hovertemplate: '%{text}<extra></extra>',
+      }, {
+        type: 'scatter',
+        mode: 'lines',
+        x: xs,
+        y: chart.points.map(p => p.open),
+        line: { color: '#6a8a82', width: 1.5, dash: 'dot' },
+        name: 'open',
+        text: hoverTexts,
+        hovertemplate: '%{text}<extra></extra>',
+      }];
+
+      const timeToIndex = new Map(chart.points.map((p, idx) => [p.time, idx]));
+      const selectedWindow = activeWindow >= 0 ? chart.windows[activeWindow] : null;
+
+      function overlayTrace(name, points, color, width = 2, dash = 'solid', opacity = 1.0) {
+        return {
+          type: 'scatter',
+          mode: 'lines',
+          x: points.map(p => timeToIndex.has(p.time) ? timeToIndex.get(p.time) : 0),
+          y: points.map(p => p.value),
+          line: { color, width, dash },
+          opacity,
+          name,
+          hovertemplate: `${name}<br>idx=%{x}<br>%{y}<extra></extra>`,
+        };
+      }
+
+      if (layerState.levels) {
+        (chart.overlays.levels.support_levels || []).forEach((level, idx) => {
+          const isSelected = activeWindow >= 0 && level.window_idx === activeWindow;
+          traces.push(overlayTrace(
+            `support_${idx}`,
+            [
+              { time: chart.points[0].time, value: level.price },
+              { time: chart.points[chart.points.length - 1].time, value: level.price },
+            ],
+            '#064e3b',
+            isSelected ? 4 : 3,
+            'dash',
+            isSelected ? 1.0 : 0.95
+          ));
+        });
+        (chart.overlays.levels.resistance_levels || []).forEach((level, idx) => {
+          const isSelected = activeWindow >= 0 && level.window_idx === activeWindow;
+          traces.push(overlayTrace(
+            `resistance_${idx}`,
+            [
+              { time: chart.points[0].time, value: level.price },
+              { time: chart.points[chart.points.length - 1].time, value: level.price },
+            ],
+            '#7f1d1d',
+            isSelected ? 4 : 3,
+            'dash',
+            isSelected ? 1.0 : 0.95
+          ));
+        });
+      }
+      if (layerState.trendlines) {
+        (chart.overlays.trendlines || []).forEach((overlay) => {
+          traces.push(overlayTrace(overlay.name, overlay.points, overlay.color, 2.5, 'solid', 0.55));
+        });
+      }
+      if (layerState.indicators) {
+        (chart.overlays.indicators || []).forEach((overlay) => {
+          traces.push(overlayTrace(
+            overlay.name,
+            overlay.points,
+            overlay.color,
+            overlay.name.includes('medium') ? 2.4 : 1.8,
+            overlay.dash || 'solid',
+            0.95
+          ));
+        });
+      }
+      const signalGroups = {};
+      (chart.overlays.signals || []).forEach((signal) => {
+        if (!signalGroups[signal.name]) signalGroups[signal.name] = [];
+        signalGroups[signal.name].push(signal);
+      });
+      Object.entries(signalGroups).forEach(([signalName, signals]) => {
+        traces.push({
+          type: 'scatter',
+          mode: 'markers+text',
+          x: signals.map(signal => timeToIndex.has(signal.time) ? timeToIndex.get(signal.time) : chart.points.length - 1),
+          y: signals.map(signal => signal.value),
+          text: signals.map(() => signalName),
+          textposition: signalName.includes('down') ? 'bottom center' : 'top center',
+          marker: {
+            color: signals[0].color,
+            size: 14,
+            symbol: signals[0].symbol,
+            line: { color: '#111827', width: 1.5 },
+          },
+          name: signalName,
+          hovertemplate: `${signalName}<br>idx=%{x}<br>%{y}<extra></extra>`,
+        });
+      });
+
+      const shapes = layerState.boundaries ? (chart.overlays.boundaries || []).map((overlay) => {
+        const x = timeToIndex.has(overlay.points[0].time) ? timeToIndex.get(overlay.points[0].time) : 0;
+        const isActive = activeWindow >= 0 && overlay.window_idx === activeWindow;
+        return {
+          type: 'line',
+          x0: x,
+          x1: x,
+          y0: Math.min(...chart.points.map(p => p.low)),
+          y1: Math.max(...chart.points.map(p => p.high)),
+          line: {
+            color: overlay.color,
+            width: isActive ? 3 : 1,
+            dash: isActive ? 'solid' : 'dot',
+          },
+          opacity: isActive ? 0.95 : 0.35,
+        };
+      }) : [];
+
+      if (selectedWindow) {
+        const startIdx = Math.max(0, Math.floor((selectedWindow.start_ts - chart.points[0].time) / Math.max(1, chart.points[1] ? chart.points[1].time - chart.points[0].time : 1)));
+        const endIdx = timeToIndex.has(selectedWindow.end_ts) ? timeToIndex.get(selectedWindow.end_ts) : startIdx;
+        shapes.push({
+          type: 'rect',
+          x0: startIdx,
+          x1: endIdx,
+          y0: Math.min(...chart.points.map(p => p.low)),
+          y1: Math.max(...chart.points.map(p => p.high)),
+          fillcolor: 'rgba(200, 76, 45, 0.08)',
+          line: { width: 0 },
+          layer: 'below',
+        });
+      }
+
+      const layout = {
+        margin: { l: 50, r: 18, t: 28, b: 40 },
+        paper_bgcolor: '#fff',
+        plot_bgcolor: '#fff',
+        font: { family: 'Georgia, "Times New Roman", serif', color: '#1f1a17' },
+        xaxis: {
+          showgrid: true,
+          gridcolor: '#efe4d4',
+          rangeslider: { visible: false },
+          tickmode: 'array',
+          tickvals: xs,
+          ticktext: chart.points.map((p, idx) => idx === 0 || idx === chart.points.length - 1 || idx % 5 === 0
+            ? new Date(p.time * 1000).toLocaleTimeString()
+            : ''),
+        },
+        yaxis: {
+          showgrid: true,
+          gridcolor: '#efe4d4',
+          fixedrange: false,
+        },
+        shapes,
+        showlegend: false,
+        hovermode: 'closest',
+      };
+
+      Plotly.newPlot(chartRoot, traces, layout, {
+        displayModeBar: true,
+        responsive: true,
+      });
+    }
+
+    function selectWindow(idx) {
+      activeWindow = idx;
+      const win = currentPayload.chart.windows[idx];
+      detailTitle.textContent = `Window ${idx} | ${win.start_ts} -> ${win.end_ts}`;
+      detailPre.textContent = JSON.stringify(win, null, 2);
+      Array.from(body.querySelectorAll("tr")).forEach((row, rowIdx) => row.classList.toggle("active", rowIdx === idx));
+      renderChart(currentPayload);
+    }
+
+    function renderWindows(data) {
+      body.innerHTML = "";
+      const windows = data.chart.windows || [];
+      windows.forEach((win, idx) => {
+        const tr = document.createElement("tr");
+        tr.innerHTML = `
+          <td>${idx}</td>
+          <td>${win.start_ts} -> ${win.end_ts}<br><span class="muted">${win.window_seconds}s</span></td>
+          <td>${fmt(win.sr_available)}</td>
+          <td>${fmt(win.trendline_available)}</td>
+          <td>${win.top_signal_name}</td>
+          <td>${fmt((win.level_snapshot || {}).support_distance)}</td>
+          <td>${fmt((win.level_snapshot || {}).resistance_distance)}</td>
+        `;
+        tr.addEventListener("click", () => selectWindow(idx));
+        body.appendChild(tr);
+      });
+      if (windows.length) selectWindow(0);
+      else detailPre.textContent = "No quant windows present.";
+    }
+
+    function render(data) {
+      currentPayload = data;
+      renderMeta(data);
+      renderChart(data);
+      renderWindows(data);
+    }
+
+    function loadRandom() {
+      q("/api/sample?random=1").then(render).catch(err => alert(err));
+    }
+
+    function loadByFile() {
+      const value = document.getElementById("file-input").value.trim();
+      if (!value) return;
+      q("/api/sample?file=" + encodeURIComponent(value)).then(render).catch(err => alert(err));
+    }
+
+    document.getElementById("random-btn").addEventListener("click", loadRandom);
+    document.getElementById("load-file").addEventListener("click", loadByFile);
+    document.getElementById("toggle-indicators").addEventListener("change", (e) => { layerState.indicators = e.target.checked; if (currentPayload) renderChart(currentPayload); });
+    document.getElementById("toggle-levels").addEventListener("change", (e) => { layerState.levels = e.target.checked; if (currentPayload) renderChart(currentPayload); });
+    document.getElementById("toggle-trendlines").addEventListener("change", (e) => { layerState.trendlines = e.target.checked; if (currentPayload) renderChart(currentPayload); });
+    document.getElementById("toggle-boundaries").addEventListener("change", (e) => { layerState.boundaries = e.target.checked; if (currentPayload) renderChart(currentPayload); });
+    loadRandom();
+  </script>
+</body>
+</html>
+"""
+
+
+class CacheDebugHandler(BaseHTTPRequestHandler):
+    cache_dir: Path = Path("data/cache")
+    fixed_file: Optional[Path] = None
+
+    def _json(self, payload: Dict[str, Any], code: int = 200) -> None:
+        encoded = json.dumps(payload).encode("utf-8")
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(encoded)))
+        self.end_headers()
+        self.wfile.write(encoded)
+
+    def _html(self, body: str, code: int = 200) -> None:
+        encoded = body.encode("utf-8")
+        self.send_response(code)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(encoded)))
+        self.end_headers()
+        self.wfile.write(encoded)
+
+    def _pick_sample(self, qs: Dict[str, List[str]]) -> Path:
+        if self.fixed_file is not None:
+            return self.fixed_file
+        if "file" in qs and qs["file"] and qs["file"][0]:
+            candidate = Path(qs["file"][0]).expanduser()
+            if not candidate.is_absolute():
+                candidate = (Path.cwd() / candidate).resolve()
+            if not candidate.exists():
+                raise FileNotFoundError(candidate)
+            return candidate
+        files = sorted(self.cache_dir.glob("sample_*.pt"))
+        if not files:
+            raise FileNotFoundError(f"No sample_*.pt files found in {self.cache_dir}")
+        if "index" in qs and qs["index"]:
+            idx = max(0, min(int(qs["index"][0]), len(files) - 1))
+            return files[idx]
+        return random.choice(files)
+
+    def do_GET(self) -> None:
+        parsed = urlparse(self.path)
+        if parsed.path == "/":
+            self._html(HTML)
+            return
+        if parsed.path == "/api/sample":
+            try:
+                source = self._pick_sample(parse_qs(parsed.query))
+                sample = _load_cache_sample(source)
+                self._json(_sample_to_payload(sample, source))
+            except Exception as exc:
+                self._json({"error": str(exc)}, code=500)
+            return
+        self.send_response(404)
+        self.end_headers()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="View cached samples in a simple web UI.")
+    parser.add_argument("--cache_dir", type=str, default="data/cache", help="Cache directory containing sample_*.pt")
+    parser.add_argument("--file", type=str, default=None, help="Optional fixed sample file to always render")
+    parser.add_argument("--host", type=str, default="127.0.0.1", help="Bind host")
+    parser.add_argument("--port", type=int, default=8765, help="Bind port")
+    args = parser.parse_args()
+
+    CacheDebugHandler.cache_dir = Path(args.cache_dir)
+    CacheDebugHandler.fixed_file = Path(args.file).resolve() if args.file else None
+    server = ThreadingHTTPServer((args.host, args.port), CacheDebugHandler)
+    print(f"Cache debug viewer running at http://{args.host}:{args.port}")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/evaluate_sample.py

@@ -50,7 +50,6 @@ ABLATION_SWEEP_MODES = [
     "quant_trendline",
     "quant_breaks",
     "quant_rolling",
-    "quant_patterns",
 ]
 
 OHLC_PROBE_MODES = [
@@ -85,7 +84,7 @@ def parse_args():
         "--ablation",
         type=str,
         default="none",
-        choices=["none", "wallet", "graph", "wallet_graph", "social", "token", "holder", "ohlc", "ohlc_wallet", "trade", "onchain", "all", "sweep", "ohlc_probe", "quant_ohlc", "quant_levels", "quant_trendline", "quant_breaks", "quant_rolling", "quant_patterns"],
+        choices=["none", "wallet", "graph", "wallet_graph", "social", "token", "holder", "ohlc", "ohlc_wallet", "trade", "onchain", "all", "sweep", "ohlc_probe", "quant_ohlc", "quant_levels", "quant_trendline", "quant_breaks", "quant_rolling"],
         help="Run inference with selected signal families removed, or use 'sweep' to rank multiple families.",
     )
     return parser.parse_args()
@@ -183,7 +182,6 @@ def apply_ablation(batch, mode, device):
         "quant_trendline": ["trendlines"],
         "quant_breaks": ["relative_structure", "levels_breaks"],
         "quant_rolling": ["rolling_quant"],
-        "quant_patterns": ["patterns"],
     }
     if mode in quant_group_map and "quant_ohlc_feature_tensors" in ablated:
         idxs = group_feature_indices(quant_group_map[mode])

signals/support_resistance.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 import numpy as np
 from scipy.signal import argrelextrema
@@ -38,11 +38,227 @@ def _cluster_levels(prices: np.ndarray, pivot_indices: List[int], tolerance: flo
     return levels
 
 
+def _filter_significant_pivots(prices: np.ndarray, pivot_indices: List[int], lookaround: int, min_prominence: float) -> List[int]:
+    kept: List[int] = []
+    for idx in pivot_indices:
+        left = max(0, idx - lookaround)
+        right = min(len(prices), idx + lookaround + 1)
+        window = prices[left:right]
+        if window.size <= 1:
+            continue
+        center = float(prices[idx])
+        prominence = max(abs(center - float(np.min(window))), abs(center - float(np.max(window))))
+        if prominence >= min_prominence:
+            kept.append(idx)
+    return kept
+
+
+def _merge_close_levels(levels: List[Dict[str, float]], tolerance: float) -> List[Dict[str, float]]:
+    if not levels:
+        return []
+    levels_sorted = sorted(levels, key=lambda level: level["price"])
+    merged: List[Dict[str, float]] = [levels_sorted[0].copy()]
+    for level in levels_sorted[1:]:
+        prev = merged[-1]
+        if abs(level["price"] - prev["price"]) <= tolerance:
+            total_touches = prev["touches"] + level["touches"]
+            prev["price"] = ((prev["price"] * prev["touches"]) + (level["price"] * level["touches"])) / total_touches
+            prev["touches"] = total_touches
+            prev["first_idx"] = min(prev["first_idx"], level["first_idx"])
+            prev["last_idx"] = max(prev["last_idx"], level["last_idx"])
+        else:
+            merged.append(level.copy())
+    return merged
+
+
+def _suppress_nearby_weaker_levels(levels: List[Dict[str, float]], tolerance: float) -> List[Dict[str, float]]:
+    if not levels:
+        return []
+    kept: List[Dict[str, float]] = []
+    for level in sorted(levels, key=lambda l: (-float(l.get("quality", 0.0)), abs(float(l["price"])))):
+        if any(abs(float(level["price"]) - float(prev["price"])) <= tolerance for prev in kept):
+            continue
+        kept.append(level)
+    kept.sort(key=lambda l: float(l["price"]))
+    return kept
+
+
+def _prune_weak_levels(levels: List[Dict[str, float]], current_idx: int, min_touches: float, min_separation_bars: float) -> List[Dict[str, float]]:
+    kept: List[Dict[str, float]] = []
+    for level in levels:
+        touches = float(level["touches"])
+        span = float(level["last_idx"]) - float(level["first_idx"])
+        age = float(current_idx) - float(level["last_idx"])
+        if touches < min_touches:
+            continue
+        if touches < (min_touches + 1.0) and span < min_separation_bars:
+            continue
+        if age > max(30.0, current_idx * 0.85):
+            continue
+        kept.append(level)
+    return kept
+
+
+def _level_quality(level: Dict[str, float], current_idx: int, current_price: float) -> float:
+    touches = float(level["touches"])
+    age = max(0.0, float(current_idx) - float(level["last_idx"]))
+    recency = 1.0 / (1.0 + age / 20.0)
+    distance = abs(float(level["price"]) - current_price) / max(abs(current_price), 1e-8)
+    proximity = 1.0 / (1.0 + distance * 20.0)
+    duration = max(1.0, float(level["last_idx"]) - float(level["first_idx"]) + 1.0)
+    duration_score = min(1.0, duration / 20.0)
+    return (touches * 2.0) + (1.25 * recency) + (0.75 * proximity) + (0.75 * duration_score)
+
+
+def _rank_levels(levels: List[Dict[str, float]], current_idx: int, current_price: float) -> List[Dict[str, float]]:
+    ranked = [level.copy() for level in levels]
+    for level in ranked:
+        level["quality"] = _level_quality(level, current_idx, current_price)
+    ranked.sort(key=lambda level: (-level["quality"], abs(level["price"] - current_price)))
+    return ranked
+
+
 def _nearest_level(levels: List[Dict[str, float]], current_price: float, below: bool) -> Optional[Dict[str, float]]:
     candidates = [level for level in levels if (level["price"] <= current_price if below else level["price"] >= current_price)]
     if not candidates:
         return None
-    return min(candidates, key=lambda level: abs(level["price"] - current_price))
+    candidates = sorted(candidates, key=lambda level: (-float(level.get("quality", 0.0)), abs(level["price"] - current_price)))
+    return candidates[0]
+
+
+def _select_active_levels(levels: List[Dict[str, float]], current_price: float, below: bool, quality_floor: float) -> List[Dict[str, float]]:
+    side_levels = [level for level in levels if (level["price"] <= current_price if below else level["price"] >= current_price)]
+    strong = [level for level in side_levels if float(level.get("quality", 0.0)) >= quality_floor]
+    if strong:
+        return strong
+    return side_levels
+
+
+def _dedupe_cross_side_levels(
+    support_levels: List[Dict[str, float]],
+    resistance_levels: List[Dict[str, float]],
+    overlap_tolerance: float,
+    current_price: float,
+) -> tuple[List[Dict[str, float]], List[Dict[str, float]]]:
+    kept_supports: List[Dict[str, float]] = []
+    kept_resistances = [level.copy() for level in resistance_levels]
+
+    for support in support_levels:
+        overlapping = [
+            resistance
+            for resistance in kept_resistances
+            if abs(float(support["price"]) - float(resistance["price"])) <= overlap_tolerance
+        ]
+        if not overlapping:
+            kept_supports.append(support.copy())
+            continue
+
+        best_resistance = max(overlapping, key=lambda level: float(level.get("quality", 0.0)))
+        support_gap = abs(current_price - float(support["price"]))
+        resistance_gap = abs(float(best_resistance["price"]) - current_price)
+        support_score = float(support.get("quality", 0.0)) + (0.25 if support_gap <= resistance_gap else 0.0)
+        resistance_score = float(best_resistance.get("quality", 0.0)) + (0.25 if resistance_gap < support_gap else 0.0)
+
+        if support_score >= resistance_score:
+            kept_supports.append(support.copy())
+            kept_resistances = [
+                resistance
+                for resistance in kept_resistances
+                if abs(float(support["price"]) - float(resistance["price"])) > overlap_tolerance
+            ]
+
+    return kept_supports, kept_resistances
+
+
+def compute_support_resistance_debug(
+    closes: List[float],
+    highs: List[float],
+    lows: List[float],
+    timestamps: Optional[List[int]] = None,
+) -> Dict[str, Any]:
+    closes_np = np.asarray(closes, dtype=np.float64)
+    highs_np = np.asarray(highs, dtype=np.float64)
+    lows_np = np.asarray(lows, dtype=np.float64)
+    if closes_np.size == 0:
+        return {
+            "support_levels": [],
+            "resistance_levels": [],
+            "all_support_levels": [],
+            "all_resistance_levels": [],
+            "sr_available": 0.0,
+        }
+
+    current_price = float(closes_np[-1])
+    current_idx = len(closes_np) - 1
+    local_range = max(float(np.max(highs_np) - np.min(lows_np)), current_price * 1e-3, 1e-8)
+    tolerance = max(local_range * 0.035, current_price * 0.001)
+    support_merge_tolerance = max(local_range * 0.055, current_price * 0.0021)
+    resistance_merge_tolerance = max(local_range * 0.065, current_price * 0.0026)
+    order = 2 if closes_np.size < 48 else 3
+    resistance_order = order
+    lookaround = max(2, order)
+    resistance_lookaround = max(2, resistance_order)
+    min_prominence = max(local_range * 0.03, current_price * 0.0012)
+    resistance_min_prominence = max(local_range * 0.045, current_price * 0.0018)
+    support_min_touches = 1.0
+    resistance_min_touches = 1.0
+    min_separation_bars = float(max(2, order))
+    resistance_min_separation_bars = float(max(3, resistance_order))
+
+    pivots_high = _compute_pivots(highs_np, order=resistance_order)["highs"]
+    pivots_low = _compute_pivots(lows_np, order=order)["lows"]
+    pivots_high = _filter_significant_pivots(highs_np, pivots_high, resistance_lookaround, resistance_min_prominence)
+    pivots_low = _filter_significant_pivots(lows_np, pivots_low, lookaround, min_prominence)
+
+    support_levels = _cluster_levels(lows_np, pivots_low, tolerance)
+    resistance_levels = _cluster_levels(highs_np, pivots_high, tolerance)
+    support_levels = _merge_close_levels(support_levels, support_merge_tolerance)
+    resistance_levels = _merge_close_levels(resistance_levels, resistance_merge_tolerance)
+    support_levels = _prune_weak_levels(support_levels, current_idx, min_touches=support_min_touches, min_separation_bars=min_separation_bars)
+    resistance_levels = _prune_weak_levels(resistance_levels, current_idx, min_touches=resistance_min_touches, min_separation_bars=resistance_min_separation_bars)
+    support_levels = _rank_levels(support_levels, current_idx, current_price)
+    resistance_levels = _rank_levels(resistance_levels, current_idx, current_price)
+    support_levels = _suppress_nearby_weaker_levels(support_levels, support_merge_tolerance * 0.8)
+    resistance_levels = _suppress_nearby_weaker_levels(resistance_levels, resistance_merge_tolerance * 1.25)
+
+    overlap_tolerance = max(local_range * 0.03, current_price * 0.0012)
+    support_levels, resistance_levels = _dedupe_cross_side_levels(
+        support_levels=support_levels,
+        resistance_levels=resistance_levels,
+        overlap_tolerance=overlap_tolerance,
+        current_price=current_price,
+    )
+
+    all_support_levels = [level.copy() for level in support_levels]
+    all_resistance_levels = [level.copy() for level in resistance_levels]
+
+    support_levels = _select_active_levels(support_levels, current_price, below=True, quality_floor=3.25)
+    resistance_levels = _select_active_levels(resistance_levels, current_price, below=False, quality_floor=3.75)
+
+    def _serialize(levels: List[Dict[str, float]], side: str) -> List[Dict[str, float]]:
+        payload: List[Dict[str, float]] = []
+        for level in levels:
+            last_idx = int(level["last_idx"])
+            first_idx = int(level["first_idx"])
+            payload.append({
+                "price": float(level["price"]),
+                "touches": float(level["touches"]),
+                "first_idx": first_idx,
+                "last_idx": last_idx,
+                "quality": float(level.get("quality", 0.0)),
+                "first_ts": float(timestamps[first_idx]) if timestamps and 0 <= first_idx < len(timestamps) else float(first_idx),
+                "last_ts": float(timestamps[last_idx]) if timestamps and 0 <= last_idx < len(timestamps) else float(last_idx),
+                "side": side,
+            })
+        return payload
+
+    return {
+        "support_levels": _serialize(support_levels, "support"),
+        "resistance_levels": _serialize(resistance_levels, "resistance"),
+        "all_support_levels": _serialize(all_support_levels, "support"),
+        "all_resistance_levels": _serialize(all_resistance_levels, "resistance"),
+        "sr_available": 1.0 if support_levels or resistance_levels else 0.0,
+    }
 
 
 def compute_support_resistance_features(
@@ -63,21 +279,35 @@ def compute_support_resistance_features(
             "resistance_touch_count", "support_age_sec", "resistance_age_sec",
             "support_strength", "resistance_strength", "inside_support_zone",
             "inside_resistance_zone", "support_swept", "resistance_swept",
-            "support_reclaim", "resistance_reject", "sr_available",
+            "support_reclaim", "resistance_reject", "keylevel_breakout_up",
+            "keylevel_breakout_down", "keylevel_hold_above", "keylevel_hold_below",
+            "keylevel_failed_breakout_up", "keylevel_failed_breakout_down",
+            "keylevel_flip_to_support", "keylevel_flip_to_resistance",
+            "keylevel_upper_distance", "keylevel_lower_distance",
+            "keylevel_zone_width_frac", "keylevel_density", "sr_available",
         ]}
 
     current_price = float(closes_np[-1])
-    local_range = max(float(np.max(highs_np) - np.min(lows_np)), current_price * 1e-3, 1e-8)
-    tolerance = max(local_range * 0.08, current_price * 0.0025)
-
-    pivots_high = _compute_pivots(highs_np, order=2)["highs"]
-    pivots_low = _compute_pivots(lows_np, order=2)["lows"]
-    support_levels = _cluster_levels(lows_np, pivots_low, tolerance)
-    resistance_levels = _cluster_levels(highs_np, pivots_high, tolerance)
+    current_high = float(highs_np[-1])
+    current_low = float(lows_np[-1])
+    debug = compute_support_resistance_debug(
+        closes=closes[: end_idx + 1],
+        highs=highs[: end_idx + 1],
+        lows=lows[: end_idx + 1],
+        timestamps=timestamps[: end_idx + 1] if timestamps else None,
+    )
+    support_levels = debug["support_levels"]
+    resistance_levels = debug["resistance_levels"]
 
     support = _nearest_level(support_levels, current_price, below=True)
     resistance = _nearest_level(resistance_levels, current_price, below=False)
     current_ts = float(timestamps[min(end_idx, len(timestamps) - 1)]) if timestamps else float(end_idx)
+    local_range = max(float(np.max(highs_np) - np.min(lows_np)), current_price * 1e-3, 1e-8)
+    zone_half_width = max(local_range * 0.035, abs(current_price) * 0.0015)
+    window_prices_high = highs[window_start:window_end]
+    window_prices_low = lows[window_start:window_end]
+    window_high = max(window_prices_high) if window_prices_high else current_high
+    window_low = min(window_prices_low) if window_prices_low else current_low
 
     def _level_stats(level: Optional[Dict[str, float]], is_support: bool) -> Dict[str, float]:
         if level is None:
@@ -91,17 +321,14 @@ def compute_support_resistance_features(
                 "confirm": 0.0,
             }
         level_price = float(level["price"])
-        zone_half_width = max(tolerance, abs(level_price) * 0.002)
-        window_prices_high = highs[window_start:window_end]
-        window_prices_low = lows[window_start:window_end]
         swept = 0.0
         confirm = 0.0
         if is_support:
-            min_low = min(window_prices_low) if window_prices_low else current_price
+            min_low = window_low
             swept = 1.0 if min_low < (level_price - zone_half_width) else 0.0
             confirm = 1.0 if swept > 0 and current_price >= level_price else 0.0
         else:
-            max_high = max(window_prices_high) if window_prices_high else current_price
+            max_high = window_high
             swept = 1.0 if max_high > (level_price + zone_half_width) else 0.0
             confirm = 1.0 if swept > 0 and current_price <= level_price else 0.0
 
@@ -117,6 +344,41 @@ def compute_support_resistance_features(
 
     support_stats = _level_stats(support, True)
     resistance_stats = _level_stats(resistance, False)
+
+    breakout_up = 0.0
+    breakout_down = 0.0
+    hold_above = 0.0
+    hold_below = 0.0
+    failed_breakout_up = 0.0
+    failed_breakout_down = 0.0
+    flip_to_support = 0.0
+    flip_to_resistance = 0.0
+    keylevel_upper_distance = 0.0
+    keylevel_lower_distance = 0.0
+
+    if resistance is not None:
+        resistance_price = float(resistance["price"])
+        keylevel_upper_distance = (resistance_price - current_price) / max(abs(current_price), 1e-8)
+        breakout_up = 1.0 if window_high > (resistance_price + zone_half_width) and current_price > resistance_price else 0.0
+        hold_above = 1.0 if breakout_up > 0.0 and window_low >= (resistance_price - zone_half_width * 0.5) else 0.0
+        failed_breakout_up = 1.0 if window_high > (resistance_price + zone_half_width) and current_price <= resistance_price else 0.0
+        flip_to_support = 1.0 if breakout_up > 0.0 and current_low <= (resistance_price + zone_half_width) and current_price >= resistance_price else 0.0
+
+    if support is not None:
+        support_price = float(support["price"])
+        keylevel_lower_distance = (current_price - support_price) / max(abs(current_price), 1e-8)
+        breakout_down = 1.0 if window_low < (support_price - zone_half_width) and current_price < support_price else 0.0
+        hold_below = 1.0 if breakout_down > 0.0 and window_high <= (support_price + zone_half_width * 0.5) else 0.0
+        failed_breakout_down = 1.0 if window_low < (support_price - zone_half_width) and current_price >= support_price else 0.0
+        flip_to_resistance = 1.0 if breakout_down > 0.0 and current_high >= (support_price - zone_half_width) and current_price <= support_price else 0.0
+
+    density_levels = debug.get("all_support_levels", []) + debug.get("all_resistance_levels", [])
+    nearby_count = sum(
+        1
+        for level in density_levels
+        if abs(float(level["price"]) - current_price) <= zone_half_width * 3.0
+    )
+
     return {
         "nearest_support_dist": support_stats["dist"],
         "nearest_resistance_dist": resistance_stats["dist"],
@@ -132,5 +394,17 @@ def compute_support_resistance_features(
         "resistance_swept": resistance_stats["swept"],
         "support_reclaim": support_stats["confirm"],
         "resistance_reject": resistance_stats["confirm"],
+        "keylevel_breakout_up": breakout_up,
+        "keylevel_breakout_down": breakout_down,
+        "keylevel_hold_above": hold_above,
+        "keylevel_hold_below": hold_below,
+        "keylevel_failed_breakout_up": failed_breakout_up,
+        "keylevel_failed_breakout_down": failed_breakout_down,
+        "keylevel_flip_to_support": flip_to_support,
+        "keylevel_flip_to_resistance": flip_to_resistance,
+        "keylevel_upper_distance": keylevel_upper_distance,
+        "keylevel_lower_distance": keylevel_lower_distance,
+        "keylevel_zone_width_frac": zone_half_width / max(abs(current_price), 1e-8),
+        "keylevel_density": float(nearby_count),
         "sr_available": 1.0 if support_levels or resistance_levels else 0.0,
     }