The Key Test You Haven’t Run Yet
Right now you tested:
“Do tail days have high precursor levels?”
What you must test next is:
When precursor spikes occur, how often do tails follow?
This flips the conditional direction.
You need:
P(Tail | v750 spike) vs P(Tail | no spike)
If:
P(Tail | spike) is 3–5× baseline,
then you truly have a surgical filter.
If:
P(Tail | spike) is only modestly higher, then you're just observing volatility clustering.
Why This Matters
Right now:
Extreme days are ~10% of sample.
If v750 spike happens on, say, 25% of days, and tails occur on 20% of those spike days, that’s not a clean dodger.
Because filtering spike days cuts too much μ.
A surgical dodger must:
Trigger infrequently
Contain a disproportionate share of disasters
Preserve most high-μ days
That’s the geometric requirement.One table:
Baseline P(Tail) P(Tail | v750 > 75th percentile) P(Tail | v750 > 90th percentile) P(Tail | v750 > 95th percentile)
If the curve explodes upward nonlinearly, you have a true convex hazard zone.

APART FROM THIS, I WILL PASTE SOME sample code prototyping the ESOTERIC_FACTORS. REVIEW THE CODE TO EXTRACT THE FEATURES THAT CAN BE COMPUTED ON THE FLY, and add each of them to the correlation tests you have run. Try and include also the population/weight stats, etc. You are wlecome to write any stats you gather to disk, per scan period, right next to the source parquuet files, name them ESOTERIC_data_TIMESTAMP, like the origibal filess. Do not overwrite or alter any data files.
import datetime
import json
import math
import time
import zoneinfo
import numpy as np
from astropy.time import Time
import astropy.coordinates as coord
import astropy.units as u
from astropy.coordinates import solar_system_ephemeris, get_body, EarthLocation

class MarketIndicators:
    def __init__(self):
        # Regions defined by NON-OVERLAPPING population clusters for accurate global weighting.
        # Population in Millions (approximate). Liquidity weight is estimated crypto volume share.
        # This fixes the previous "triple-counting" of Asia.
        self.regions = [
            {'name': 'Americas', 'tz': 'America/New_York', 'pop': 1000, 'liq_weight': 0.35},      # N/S America
            {'name': 'EMEA', 'tz': 'Europe/London', 'pop': 2200, 'liq_weight': 0.30},            # Europe/Africa/Mid-East
            {'name': 'South_Asia', 'tz': 'Asia/Kolkata', 'pop': 1400, 'liq_weight': 0.05},       # India
            {'name': 'East_Asia', 'tz': 'Asia/Shanghai', 'pop': 1600, 'liq_weight': 0.20},       # China/Japan/Korea
            {'name': 'Oceania_SEA', 'tz': 'Asia/Singapore', 'pop': 800, 'liq_weight': 0.10}      # SE Asia/Australia
        ]
        
        # Market cycle: Bitcoin halving based, ~4 years
        self.cycle_length_days = 1460
        self.last_halving = datetime.datetime(2024, 4, 20, tzinfo=datetime.timezone.utc)
        
        # Cache for expensive calculations
        self._cache = {
            'moon': {'val': None, 'ts': 0},
            'mercury': {'val': None, 'ts': 0}
        }
        self.cache_ttl_seconds = 3600 * 6 # Update astro every 6 hours

    def get_calendar_items(self, now):
        """Explicit simple calendar outputs."""
        return {
            'year': now.year,
            'month': now.month,
            'day_of_month': now.day,
            'hour': now.hour,
            'minute': now.minute,
            'day_of_week': now.weekday(), # 0=Monday
            'week_of_year': now.isocalendar().week
        }

    def get_regional_times(self, now_utc):
        times = {}
        for region in self.regions:
            tz = zoneinfo.ZoneInfo(region['tz'])
            local_time = now_utc.astimezone(tz)
            times[region['name']] = {
                'hour': local_time.hour + local_time.minute / 60.0,
                'is_tradfi_open': self.is_tradfi_open(region['name'], local_time)
            }
        return times

    def is_tradfi_open(self, region_name, local_time):
        day = local_time.weekday()
        if day >= 5: return False
        hour = local_time.hour + local_time.minute / 60.0
        
        if 'Americas' in region_name:
            return 9.5 <= hour < 16.0
        elif 'EMEA' in region_name:
            return 8.0 <= hour < 16.5
        elif 'Asia' in region_name:
            return 9.0 <= hour < 15.0
        return False

    def get_liquidity_session(self, now_utc):
        """Maps time to Crypto Liquidity Sessions."""
        utc_hour = now_utc.hour
        if 13 <= utc_hour < 17:
            return "LONDON_NEW_YORK_OVERLAP"
        elif 8 <= utc_hour < 13:
            return "LONDON_MORNING"
        elif 0 <= utc_hour < 8:
            return "ASIA_PACIFIC"
        elif 17 <= utc_hour < 21:
            return "NEW_YORK_AFTERNOON"
        else:
            return "LOW_LIQUIDITY" 

    def get_weighted_times(self, now_utc):
        """
        Calculates two types of weighted hours:
        1. Population Weighted: "Global Human Activity Cycle"
        2. Liquidity Weighted: "Global Money Activity Cycle"
        """
        pop_sin, pop_cos = 0, 0
        liq_sin, liq_cos = 0, 0
        
        total_pop = sum(r['pop'] for r in self.regions) # ~7000M
        
        for region in self.regions:
            tz = zoneinfo.ZoneInfo(region['tz'])
            local_time = now_utc.astimezone(tz)
            hour_frac = (local_time.hour + local_time.minute / 60.0) / 24.0
            angle = 2 * math.pi * hour_frac
            
            # Population Calculation
            w_pop = region['pop'] / total_pop
            pop_sin += math.sin(angle) * w_pop
            pop_cos += math.cos(angle) * w_pop
            
            # Liquidity Calculation
            w_liq = region['liq_weight']
            liq_sin += math.sin(angle) * w_liq
            liq_cos += math.cos(angle) * w_liq

        # Calculate Population Hour
        pop_angle = math.atan2(pop_sin, pop_cos)
        if pop_angle < 0: pop_angle += 2 * math.pi
        pop_hour = (pop_angle / (2 * math.pi)) * 24

        # Calculate Liquidity Hour
        liq_angle = math.atan2(liq_sin, liq_cos)
        if liq_angle < 0: liq_angle += 2 * math.pi
        liq_hour = (liq_angle / (2 * math.pi)) * 24

        return round(pop_hour, 2), round(liq_hour, 2)

    def get_market_cycle_position(self, now_utc):
        days_since_halving = (now_utc - self.last_halving).days
        position = (days_since_halving % self.cycle_length_days) / self.cycle_length_days
        return position

    def get_fibonacci_time(self, now_utc):
        mins_passed = now_utc.hour * 60 + now_utc.minute
        fib_seq = [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597]
        closest = min(fib_seq, key=lambda x: abs(x - mins_passed))
        distance = abs(mins_passed - closest)
        strength = 1.0 - min(distance / 30.0, 1.0) 
        return {'closest_fib_minute': closest, 'harmonic_strength': round(strength, 3)}

    def get_moon_phase(self, now_utc):
        now_ts = now_utc.timestamp()
        if self._cache['moon']['val'] and (now_ts - self._cache['moon']['ts'] < self.cache_ttl_seconds):
            return self._cache['moon']['val']

        t = Time(now_utc)
        with solar_system_ephemeris.set('builtin'):
            moon = coord.get_moon(t)
            sun = coord.get_sun(t)
            elongation = sun.separation(moon)
            phase_angle = np.arctan2(sun.distance * np.sin(elongation),
                                     moon.distance - sun.distance * np.cos(elongation))
            illumination = (1 + np.cos(phase_angle)) / 2.0
            
            phase_name = "WAXING"
            if illumination < 0.03: phase_name = "NEW_MOON"
            elif illumination > 0.97: phase_name = "FULL_MOON"
            elif illumination < 0.5: phase_name = "WAXING_CRESCENT" if moon.dec.deg > sun.dec.deg else "WANING_CRESCENT"
            else: phase_name = "WAXING_GIBBOUS" if moon.dec.deg > sun.dec.deg else "WANING_GIBBOUS"

        result = {'illumination': float(illumination), 'phase_name': phase_name}
        self._cache['moon'] = {'val': result, 'ts': now_ts}
        return result

    def is_mercury_retrograde(self, now_utc):
        now_ts = now_utc.timestamp()
        if self._cache['mercury']['val'] is not None and (now_ts - self._cache['mercury']['ts'] < self.cache_ttl_seconds):
            return self._cache['mercury']['val']

        t = Time(now_utc)
        is_retro = False
        try:
            with solar_system_ephemeris.set('builtin'):
                loc = EarthLocation.of_site('greenwich')
                merc_now = get_body('mercury', t, loc)
                merc_later = get_body('mercury', t + 1 * u.day, loc)
                
                # Use Geocentric Ecliptic Longitude for correct astrological determination
                lon_now = merc_now.geometrictrueecliptic.lon.deg
                lon_later = merc_later.geometrictrueecliptic.lon.deg
                
                diff = (lon_later - lon_now) % 360
                is_retro = diff > 180 # If movement is "backwards" (wrapping 360)
        except Exception as e:
            print(f"Astro calc error: {e}")

        self._cache['mercury'] = {'val': is_retro, 'ts': now_ts}
        return is_retro

    def get_indicators(self):
        now_utc = datetime.datetime.now(datetime.timezone.utc)
        
        pop_hour, liq_hour = self.get_weighted_times(now_utc)
        moon_data = self.get_moon_phase(now_utc)
        calendar = self.get_calendar_items(now_utc)

        indicators = {
            'timestamp': now_utc.isoformat(),
            'unix': int(now_utc.timestamp()),
            
            # Simple Calendar
            'calendar': calendar,
            
            # Temporal & Geometry
            'fibonacci_time': self.get_fibonacci_time(now_utc),
            
            # Global Activity (Dual Weighted)
            'regional_times': self.get_regional_times(now_utc),
            'population_weighted_hour': pop_hour, # Human Activity Cycle
            'liquidity_weighted_hour': liq_hour,  # Money Activity Cycle
            'liquidity_session': self.get_liquidity_session(now_utc),
            
            # Macro Cycles
            'market_cycle_position': round(self.get_market_cycle_position(now_utc), 4),
            
            # Esoteric
            'moon_illumination': moon_data['illumination'],
            'moon_phase_name': moon_data['phase_name'],
            'mercury_retrograde': self.is_mercury_retrograde(now_utc),
        }
        return indicators

if __name__ == "__main__":
    mi = MarketIndicators()
    ind = mi.get_indicators()
    print(json.dumps(ind, indent=2))