ivolatility-backtesting 2.149__tar.gz → 2.150__tar.gz

{ivolatility_backtesting-2.149 → ivolatility_backtesting-2.150}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ivolatility_backtesting
-Version: 2.149
+Version: 2.150
 Summary: A universal backtesting framework for financial strategies using the IVolatility API.
 Author-email: IVolatility <support@ivolatility.com>
 Project-URL: Homepage, https://ivolatility.com

{ivolatility_backtesting-2.149 → ivolatility_backtesting-2.150}/ivolatility_backtesting/__init__.py

@@ -28,6 +28,7 @@ from .ivolatility_backtesting import (
     FUTURES_HEDGE_MAP, _load_futures_for_hedge,
     set_project_root, get_project_root,
     get_position_multiplier, get_hedge_multiplier,
+    parse_earnings_calendar,
 )
 
 __all__ = [
@@ -60,4 +61,5 @@ __all__ = [
     'FUTURES_HEDGE_MAP', '_load_futures_for_hedge',
     'set_project_root', 'get_project_root',
     'get_position_multiplier', 'get_hedge_multiplier',
+    'parse_earnings_calendar',
 ]

{ivolatility_backtesting-2.149 → ivolatility_backtesting-2.150}/ivolatility_backtesting/ivolatility_backtesting.py

@@ -758,6 +758,12 @@ def _get_options_eod_table(config_like: Optional[Dict[str, Any]]) -> str:
     return 'options_eod_1545' if snap == '1545' else 'options_eod_close'
 
 
+def _complete_option_dates_sql(table: str) -> str:
+    """Dates holding both calls and puts; a date with a single type is treated as not loaded."""
+    return (f"SELECT date FROM {table} WHERE symbol = ? "
+            f"GROUP BY date HAVING COUNT(DISTINCT UPPER(SUBSTR(CAST(type AS VARCHAR), 1, 1))) >= 2")
+
+
 def _get_legacy_1545_duckdb_path(config_like: Optional[Dict[str, Any]]) -> str:
     """Legacy pre-refactor 15:45 DuckDB path kept for one-time migration."""
     cache_dir = _resolve_path((config_like or {}).get('cache_dir', 'cache'))
@@ -3740,6 +3746,11 @@ STRATEGIES = {
     },
 }
 
+STRATEGIES['DIRECTIONAL_LONG'] = {**STRATEGIES['LONG_STOCK'], 'name': 'Directional Long (stock)'}
+STRATEGIES['DIRECTIONAL_SHORT'] = {**STRATEGIES['SHORT_STOCK'], 'name': 'Directional Short (stock)'}
+STOCK_STRATEGY_TYPES = ('LONG_STOCK', 'SHORT_STOCK', 'DIRECTIONAL_LONG', 'DIRECTIONAL_SHORT')
+SHORT_STOCK_TYPES = ('SHORT_STOCK', 'DIRECTIONAL_SHORT')
+
 # Backwards compatibility mapping (lowercase to UPPERCASE)
 _STRATEGY_NAME_MAP = {
     'iron_condor': 'IRON_CONDOR',
@@ -6152,7 +6163,7 @@ class StrategyRegistry:
                 call_premium = position.get('call_premium', abs(credit))
                 capital_at_risk = max(stock_value - call_premium, stock_value * 0.8)
                 locked_capital = stock_value
-            elif position_type in ('LONG_STOCK', 'SHORT_STOCK'):
+            elif position_type in STOCK_STRATEGY_TYPES:
                 stock_value = underlying_price * contracts * um
                 capital_at_risk = stock_value
                 locked_capital = stock_value
@@ -6424,13 +6435,13 @@ class StrategyRegistry:
             # Universal CREDIT detection (works for ANY strategy)
             is_credit = cls.is_credit_strategy(strategy_type=strategy_type, position=position)
             
-            # ⚠️ CRITICAL: For NEUTRAL strategies (STRADDLE, STRANGLE) without 'short' prefix
-            # If ALL legs don't have 'short' prefix AND strategy is CREDIT → treat ALL as SHORT
-            if is_credit and not is_short_leg and category == 'NEUTRAL':
+            # ⚠️ CRITICAL: NEUTRAL (STRADDLE, STRANGLE) and single-leg CREDIT (SHORT_PUT, SHORT_CALL)
+            # legs carry no 'short' prefix. If ALL legs lack it AND position is CREDIT → treat ALL as SHORT
+            if is_credit and not is_short_leg and category in ('NEUTRAL', 'CREDIT'):
                 # Check if NO legs have 'short' prefix (simple STRADDLE/STRANGLE)
                 has_short_prefix = any('short' in l['name'].lower() for l in legs)
                 if not has_short_prefix:
-                    # Simple STRADDLE/STRANGLE: all legs are SHORT for CREDIT
+                    # STRADDLE/STRANGLE, SHORT_PUT/SHORT_CALL: all legs are SHORT for CREDIT
                     is_short_leg = True
             
             # ⚠️ FIX: For DEBIT strategies used as CREDIT (e.g. DCS SELL, calendar SELL)
@@ -6634,7 +6645,7 @@ class StrategyRegistry:
             # total_cost is negative (credit from selling call), so adding it reduces risk
             return (stock_price * um * contracts) + total_cost  # subtract call premium
 
-        elif strategy_type in ('LONG_STOCK', 'SHORT_STOCK'):
+        elif strategy_type in STOCK_STRATEGY_TYPES:
             stock_price = position_params.get('stock_price', position_params.get('underlying_entry_price', 0))
             return stock_price * um * contracts
 
@@ -6833,13 +6844,13 @@ class StrategyRegistry:
             # doubling the call bid while completely missing the stock value.
             # Fix: compute P&L directly using underlying_price (available here) + call leg.
             # ── LONG_STOCK / SHORT_STOCK — pure stock position, no option legs ──
-            if strategy_type in ('LONG_STOCK', 'SHORT_STOCK'):
+            if strategy_type in STOCK_STRATEGY_TYPES:
                 stock_exit_value = underlying_price * contracts * um
-                if strategy_type == 'SHORT_STOCK':
+                if strategy_type in SHORT_STOCK_TYPES:
                     pnl = entry_cost - stock_exit_value  # short: profit when price drops
                 else:
                     pnl = stock_exit_value - entry_cost  # long: profit when price rises
-                is_credit = (strategy_type == 'SHORT_STOCK')
+                is_credit = (strategy_type in SHORT_STOCK_TYPES)
                 close_cost = stock_exit_value
             # ── COVERED_CALL / COVERED_PUT — stock + option leg ──────────
             elif (strategy_type in ('COVERED_CALL', 'COVERED_CALL_ATM', 'COVERED_CALL_25D', 'COVERED_PUT', 'COVERED_PUT_ATM', 'COVERED_PUT_25D')
@@ -9774,7 +9785,7 @@ class StopLossManager:
 
         # --- Stock-based strategies (no option legs for intraday SL) ---
 
-        elif strategy_type in ('LONG_STOCK', 'SHORT_STOCK'):
+        elif strategy_type in STOCK_STRATEGY_TYPES:
             pass
 
         elif strategy_type in ('COVERED_CALL', 'COVERED_CALL_ATM', 'COVERED_CALL_25D', 'COVERED_PUT', 'COVERED_PUT_ATM', 'COVERED_PUT_25D') or 'COVERED_CALL' in strategy_type.upper() or 'COVERED_PUT' in strategy_type.upper():
@@ -10474,10 +10485,9 @@ class StopLossManager:
                         pnl_from_baseline = current_value - baseline_close_cost  # change in close cost
                         denom = abs(baseline_close_cost)
                     else:
-                        # Fallback: old behavior (no baseline close cost stored)
-                        original_credit_fb = original_credit or entry_value
-                        position_value_now = original_credit_fb + current_value
-                        pnl_from_baseline = position_value_now - entry_value
+                        # Simple credit (straddle, single leg): entry_value is the 09:30 close cost
+                        # (or the credit before any reset); current_value is -close cost now
+                        pnl_from_baseline = abs(entry_value) + current_value
                         denom = abs(entry_value)
                     intraday_pnl_pct = (pnl_from_baseline / denom) * 100 if denom != 0 else 0
                 else:
@@ -11345,6 +11355,18 @@ class StopLossManager:
     
     def _check_pl_loss_stop(self, pos, kwargs):
         """Stop-loss based on actual P&L"""
+        # Stock positions: entry_price may be per share or a whole-position dollar value, so measure the
+        # per-share move from underlying_entry_price (per share in both conventions)
+        if pos.get('sl_baseline_reset') and pos.get('strategy_type') in STOCK_STRATEGY_TYPES:
+            base_px = pos.get('underlying_entry_price')
+            px = kwargs.get('underlying_price')
+            if base_px and px:
+                move_pct = (px - base_px) / base_px * 100
+                is_short = pos.get('is_short_bias') or pos.get('strategy_type') in SHORT_STOCK_TYPES
+                stock_pnl_pct = -move_pct if is_short else move_pct
+                stop_level = -pos['stop_value'] * 100
+                return stock_pnl_pct <= stop_level, stop_level, 'pl_loss'
+
         pnl_pct = kwargs.get('pnl_pct')
 
         # [EARNINGS SL FIX] Force recalculation when baseline was reset
@@ -12708,7 +12730,7 @@ class PositionManager:
             call_intrinsic = max(0, underlying_price - call_strike)
             intrinsic_value = call_intrinsic * unit_multiplier * contracts  # Only call obligation
         
-        elif strategy_type in ('LONG_STOCK', 'SHORT_STOCK'):
+        elif strategy_type in STOCK_STRATEGY_TYPES:
             intrinsic_value = underlying_price * unit_multiplier * contracts
             if self.debug:
                 print(f"[INTRINSIC SETTLEMENT] {position_id} - {strategy_type}:")
@@ -12847,7 +12869,16 @@ class PositionManager:
         # BACKWARD COMPATIBILITY: If 'type' passed but 'strategy_type' not, copy type → strategy_type
         if 'strategy_type' not in kwargs and 'type' in kwargs:
             kwargs['strategy_type'] = kwargs['type']
-        
+
+        # DIRECTIONAL_* pass shares in `quantity` with contracts=0; stock P&L paths use contracts × unit_multiplier
+        if kwargs.get('strategy_type') in ('DIRECTIONAL_LONG', 'DIRECTIONAL_SHORT'):
+            if not kwargs.get('contracts'):
+                kwargs['contracts'] = quantity
+            kwargs.setdefault('unit_multiplier', 1)
+            if not kwargs.get('total_cost'):
+                entry_px = kwargs.get('underlying_entry_price') or entry_price
+                kwargs['total_cost'] = entry_px * kwargs['contracts'] * kwargs['unit_multiplier']
+
         # AUTO-DETECT position_type if not provided
         if position_type is None:
             strategy_type = kwargs.get('strategy_type')
@@ -13506,7 +13537,7 @@ class PositionManager:
                                 _is_stock_position = (
                                     'COVERED_CALL' in strategy_type.upper()
                                     or 'COVERED_PUT' in strategy_type.upper()
-                                    or strategy_type in ('LONG_STOCK', 'SHORT_STOCK')
+                                    or strategy_type in STOCK_STRATEGY_TYPES
                                 )
                                 if _is_stock_position:
                                     # entry_value/current_value are full position values
@@ -13521,10 +13552,16 @@ class PositionManager:
                                     is_credit = StrategyRegistry.is_credit_strategy(
                                         strategy_type=strategy_type, position=position
                                     )
+                                    # entry_value may be the reset 09:30 baseline; the trade is booked against its cost
+                                    _orig_cost = abs(position.get('total_cost') or entry_value)
                                     if is_credit:
-                                        intraday_pnl = entry_value + current_value
+                                        intraday_pnl = _orig_cost + current_value
+                                        _pnl_denom = position.get('entry_max_risk') or position.get('max_risk') or _orig_cost
                                     else:
-                                        intraday_pnl = current_value - entry_value
+                                        intraday_pnl = current_value - _orig_cost
+                                        _pnl_denom = _orig_cost
+                                    if _pnl_denom:
+                                        intraday_pnl_pct = (intraday_pnl / _pnl_denom) * 100
                                 
                                 if self.debug:
                                     print(f"  [Stop Loss] Using intraday P&L: {intraday_pnl_pct:.2f}% (${intraday_pnl:.2f}) instead of EOD: {current_pnl_pct:.2f}% (${current_pnl:.2f})")
@@ -13841,11 +13878,11 @@ class PositionManager:
             
             # LONG_STOCK / SHORT_STOCK: no option legs → compute P&L directly from stock price
             strategy_type = position.get('strategy_type', self.config.get('strategy_type', 'STRADDLE'))
-            if leg_data is None and strategy_type in ('LONG_STOCK', 'SHORT_STOCK'):
+            if leg_data is None and strategy_type in STOCK_STRATEGY_TYPES:
                 entry_cost = abs(position.get('total_cost', 0))
                 contracts = position.get('contracts', 1)
                 stock_exit_value = stock_price * contracts * _pos_unit_multiplier(position)
-                if strategy_type == 'SHORT_STOCK':
+                if strategy_type in SHORT_STOCK_TYPES:
                     pnl = entry_cost - stock_exit_value
                 else:
                     pnl = stock_exit_value - entry_cost
@@ -14888,7 +14925,7 @@ class PositionManager:
             # ========================================
             # LONG STOCK (pure stock position)
             # ========================================
-            elif position_type in ('LONG_STOCK', 'SHORT_STOCK'):
+            elif position_type in STOCK_STRATEGY_TYPES:
                 contracts = position.get('contracts', 1)
                 underlying_price = position.get('underlying_entry_price', 0)
                 stock_value = underlying_price * contracts * _pos_unit_multiplier(position)
@@ -19300,9 +19337,7 @@ def _try_read_from_duckdb_storage(config, cache_config, symbol, extended_start,
             _rich_print(f"           📋 DB DTE: 0-{int(db_max_dte)}")
             
             # Get dates that have options data
-            options_dates_result = db.execute_read(f"""
-                SELECT DISTINCT date FROM {_opt_tbl} WHERE symbol = ?
-            """, [symbol]).fetchdf()
+            options_dates_result = db.execute_read(_complete_option_dates_sql(_opt_tbl), [symbol]).fetchdf()
             options_dates = set(pd.to_datetime(options_dates_result['date']).dt.strftime('%Y-%m-%d'))
         
         _rich_print(f"           🔍 Need: {extended_start} → {end_date}, DTE 0-{required_max_dte}")
@@ -19458,9 +19493,7 @@ def _try_read_from_duckdb_storage(config, cache_config, symbol, extended_start,
             if trading_days:
                 try:
                     db.refresh_conn()
-                    _post_df = db.execute_read(
-                        f"SELECT DISTINCT date FROM {_opt_tbl} WHERE symbol = ?", [symbol]
-                    ).fetchdf()
+                    _post_df = db.execute_read(_complete_option_dates_sql(_opt_tbl), [symbol]).fetchdf()
                     _post_dates = set(pd.to_datetime(_post_df['date']).dt.strftime('%Y-%m-%d'))
                     _req_min = pd.to_datetime(extended_start)
                     _req_max = pd.to_datetime(end_date)
@@ -20085,9 +20118,7 @@ def _preload_duckdb_SSD_storage(config, cache_config):
             # Cold-path completeness: every backtest trading day must exist in
             # the options table; misses are loud + flag _failed_chunks
             try:
-                _cc_df = conn.execute(
-                    f"SELECT DISTINCT date FROM {_opt_tbl} WHERE symbol = ?", [symbol]
-                ).fetchdf()
+                _cc_df = conn.execute(_complete_option_dates_sql(_opt_tbl), [symbol]).fetchdf()
                 _cc_have = set(pd.to_datetime(_cc_df['date']).dt.strftime('%Y-%m-%d'))
                 _cc_need = {pd.Timestamp(d).strftime('%Y-%m-%d') for d in backtest_trading_days}
                 _cc_missing = sorted(_cc_need - _cc_have)
@@ -23707,6 +23738,7 @@ def preload_data_universal(config, data_requests=None, debug=False):
                 # and _try_read_from_duckdb_storage).  Setting the old per-row lazy
                 # patch here would be redundant and wasteful (extra intraday API calls
                 # for data that is already correct in DuckDB).
+                _activate_runtime_stock_shim(config, result)
                 _timing.end_stage()  # End "Loading Data" timing
                 return result
             # Check if lock was the reason for failure
@@ -23745,6 +23777,7 @@ def preload_data_universal(config, data_requests=None, debug=False):
                         return None
                     if config.get('bar_exit') == '16:00':
                         set_option_patch_context(OptionPatchContext(_sym, _fetch_opt_intraday_duckdb_ram))
+                _activate_runtime_stock_shim(config, result)
                 _timing.end_stage()  # End "Loading Data" timing
                 return result
             print("   ⚠️ DuckDB RAM reader: No cached Parquet data, falling back to API...")
@@ -24992,7 +25025,7 @@ def parse_earnings_calendar(earnings_df):
     
     Returns:
         list: [{'date': datetime.date, 'estimate': float, 'reported': float, 
-                'time_of_day': str}, ...]
+                'time_of_day': str, 'time_of_day_code': str}, ...]
         Sorted by date ascending.
     
     Usage in strategy:
@@ -25020,11 +25053,13 @@ def parse_earnings_calendar(earnings_df):
             else:
                 date_obj = earning_date
             
+            time_of_day = record.get('time_of_day_code', 'UNK')
             earnings_events.append({
                 'date': date_obj,
                 'estimate': record.get('estimate'),
                 'reported': record.get('reported_earning'),
-                'time_of_day': record.get('time_of_day_code', 'UNK')
+                'time_of_day': time_of_day,
+                'time_of_day_code': time_of_day,
             })
     
     return sorted(earnings_events, key=lambda x: x['date'])

{ivolatility_backtesting-2.149 → ivolatility_backtesting-2.150}/ivolatility_backtesting.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ivolatility_backtesting
-Version: 2.149
+Version: 2.150
 Summary: A universal backtesting framework for financial strategies using the IVolatility API.
 Author-email: IVolatility <support@ivolatility.com>
 Project-URL: Homepage, https://ivolatility.com

{ivolatility_backtesting-2.149 → ivolatility_backtesting-2.150}/ivolatility_backtesting.egg-info/SOURCES.txt

@@ -13,4 +13,5 @@ tests/test_2144_duckdb_dedup.py
 tests/test_2146_vix_vro.py
 tests/test_2147_cents_multiplier.py
 tests/test_2148_loader_memory.py
-tests/test_2149_client_errors.py
+tests/test_2149_client_errors.py
+tests/test_2150_prompt_patterns.py

{ivolatility_backtesting-2.149 → ivolatility_backtesting-2.150}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ivolatility_backtesting"
-version = "2.149"
+version = "2.150"
 description = "A universal backtesting framework for financial strategies using the IVolatility API."
 readme = "README.md"
 authors = [

ivolatility_backtesting-2.150/tests/test_2150_prompt_patterns.py

@@ -0,0 +1,356 @@
+# Patterns that backtest_master_prompt.md teaches the agent, checked against known answers.
+# Run: python3 tests/test_2150_prompt_patterns.py  (or pytest). Offline.
+import datetime as dt
+import os
+import subprocess
+import sys
+import traceback
+
+import matplotlib
+matplotlib.use('Agg')
+
+import pandas as pd
+
+_REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.join(_REPO, 'ivolatility_backtesting'))
+import ivolatility_backtesting as lib  # noqa: E402
+
+EXP = pd.Timestamp('2024-02-16')
+DAY = dt.date(2024, 1, 5)
+SL20 = {'type': 'pl_loss', 'min_days_before_check': 0, 'pl_loss_settings': {'pl_loss': 0.20},
+        'intraday_settings': {'intraday_mode': 'disabled'}}
+
+
+def _chain(put_bid, put_ask, call_bid, call_ask, underlying=460.0):
+    rows = []
+    for typ, bid, ask, delta in (('P', put_bid, put_ask, -0.5), ('C', call_bid, call_ask, 0.5)):
+        rows.append({'date': pd.Timestamp(DAY), 'expiration': EXP, 'strike': 470.0, 'type': typ,
+                     'bid': bid, 'ask': ask, 'delta': delta, 'iv': 0.2, 'price': (bid + ask) / 2,
+                     'dte': 42, 'underlying_price': underlying})
+    return pd.DataFrame(rows)
+
+
+def _stock_row(price):
+    return pd.DataFrame([{'date': pd.Timestamp(DAY), 'close': price, 'open': price, 'high': price, 'low': price}])
+
+
+def _pm(strategy_type, sl=SL20):
+    return lib.PositionManager({'symbol': 'SPY', 'debuginfo': 0, 'strategy_type': strategy_type,
+                                'stop_loss_enabled': True, 'stop_loss_config': sl}, debug=False)
+
+
+def _price_data(pm, stock_price, chain):
+    return pm.build_price_data(DAY, stock_price, chain,
+                               lambda s, e, t: lib.get_option_by_strike_exp(chain, s, e, t),
+                               stock_row=_stock_row(stock_price))
+
+
+def _short_option(strategy_type, chain):
+    pm = _pm(strategy_type)
+    pm.open_position(position_id='P1', symbol='SPY', entry_date=dt.date(2024, 1, 2), entry_price=0,
+                     quantity=100, strategy_type=strategy_type, contracts=1, total_cost=-500.0,
+                     is_short_bias=True, entry_max_risk=500.0, strike=470.0, expiration=EXP,
+                     underlying_entry_price=470.0)
+    pdx = _price_data(pm, 460.0, chain)
+    return pm, pdx
+
+
+def test_short_single_leg_buys_back_at_ask():
+    # credit 500, buy back at ask 10.00 x 100 = 1000 -> P&L -500
+    put_rich = _chain(9.9, 10.0, 1.0, 1.1)
+    call_rich = _chain(1.0, 1.1, 9.9, 10.0)
+    for strategy_type, chain in (('SHORT_PUT', put_rich), ('PUT_ATM', put_rich),
+                                 ('SHORT_CALL', call_rich), ('CALL', call_rich)):
+        pm, pdx = _short_option(strategy_type, chain)
+        assert round(pdx['P1']['pnl']) == -500, (strategy_type, pdx['P1']['pnl'])
+        hits = pm.check_positions(DAY, pdx, underlying_price=460.0)
+        assert [h['exit_reason'] for h in hits] == ['stop_loss_pl_loss'], (strategy_type, hits)
+
+
+def test_short_single_leg_profit_when_option_decays():
+    put_cheap = _chain(0.9, 1.0, 9.9, 10.0)
+    pm, pdx = _short_option('SHORT_PUT', put_cheap)
+    assert round(pdx['P1']['pnl']) == 400, pdx['P1']['pnl']
+
+
+def test_long_call_unchanged():
+    chain = _chain(1.0, 1.1, 9.9, 10.0)
+    pm = _pm('CALL')
+    pm.open_position(position_id='P1', symbol='SPY', entry_date=dt.date(2024, 1, 2), entry_price=5.0,
+                     quantity=100, strategy_type='CALL', contracts=1, total_cost=500.0,
+                     entry_max_risk=500.0, strike=470.0, expiration=EXP, underlying_entry_price=470.0)
+    pdx = _price_data(pm, 460.0, chain)
+    assert round(pdx['P1']['pnl']) == 490, pdx['P1']['pnl']
+
+
+def test_multi_leg_close_cost_unchanged():
+    expected = {
+        'IRON_CONDOR': (-320.0, 320.0), 'IRON_BUTTERFLY': (-320.0, 320.0),
+        'BEAR_CALL_SPREAD': (-160.0, 160.0), 'BULL_PUT_SPREAD': (-160.0, 160.0),
+        'BULL_CALL_SPREAD': (240.0, 160.0), 'STRADDLE': (680.0, 600.0), 'STRANGLE': (680.0, 600.0),
+        'CALENDAR_SPREAD': (680.0, 600.0), 'COVERED_CALL': (680.0, 600.0),
+    }
+    reg = lib.StrategyRegistry
+    for strategy_type, (credit_cost, debit_cost) in expected.items():
+        legs = [leg.get('field_prefix', leg['name']) for leg in reg.get(strategy_type)['legs']]
+        leg_data = {p: {'bid': 1.0 + i, 'ask': 1.2 + i} for i, p in enumerate(legs)}
+        got = []
+        for credit in (True, False):
+            pos = {'contracts': 2, 'unit_multiplier': 100, 'entry_price': 0 if credit else 3.0,
+                   'total_cost': -300.0 if credit else 300.0, 'is_short_bias': credit}
+            got.append(round(reg.calculate_close_cost(strategy_type, pos, leg_data), 6))
+        assert tuple(got) == (credit_cost, debit_cost), (strategy_type, got)
+
+
+def _directional(strategy_type, side, entry, now, sl_pct=0.03, with_total_cost=True):
+    sl = dict(SL20, pl_loss_settings={'pl_loss': sl_pct})
+    pm = _pm(strategy_type, sl=sl)
+    shares = 10
+    extra = {'total_cost': entry * shares} if with_total_cost else {}
+    pm.open_position(position_id='D1', strategy_type=strategy_type, symbol='SPY',
+                     entry_date=dt.date(2024, 1, 2), entry_price=entry, entry_max_risk=entry * shares,
+                     quantity=shares, contracts=0, is_short_bias=(side == 'SHORT'), position_type=side,
+                     underlying_entry_price=entry, **extra)
+    pdx = _price_data(pm, now, pd.DataFrame())
+    return pm, pdx
+
+
+def test_directional_stock_positions_have_pnl_and_stop():
+    for strategy_type, side, now in (('DIRECTIONAL_LONG', 'LONG', 90.0), ('DIRECTIONAL_SHORT', 'SHORT', 110.0)):
+        pm, pdx = _directional(strategy_type, side, 100.0, now)
+        assert 'D1' in pdx, strategy_type
+        assert round(pdx['D1']['pnl']) == -100, (strategy_type, pdx['D1'])
+        hits = pm.check_positions(DAY, pdx, underlying_price=now)
+        assert [h['exit_reason'] for h in hits] == ['stop_loss_pl_loss'], (strategy_type, hits)
+
+
+def test_directional_without_total_cost_uses_entry_value():
+    for strategy_type, side in (('DIRECTIONAL_LONG', 'LONG'), ('DIRECTIONAL_SHORT', 'SHORT')):
+        pm, pdx = _directional(strategy_type, side, 100.0, 100.0, sl_pct=0.5, with_total_cost=False)
+        assert round(pdx['D1']['pnl']) == 0, (strategy_type, pdx['D1'])
+        pm, pdx = _directional(strategy_type, side, 100.0, 90.0 if side == 'LONG' else 110.0, sl_pct=0.5, with_total_cost=False)
+        assert round(pdx['D1']['pnl']) == -100, (strategy_type, pdx['D1'])
+
+
+def test_directional_signal_close_keeps_pnl_and_label():
+    pm, pdx = _directional('DIRECTIONAL_LONG', 'LONG', 100.0, 110.0, sl_pct=0.5)
+    pnl = pm.close_position_by_signal('D1', DAY, pdx, 'z_score_exit')
+    assert round(pnl) == 100, pnl
+    trade = pm.get_closed_trades()[-1]
+    assert round(trade['pnl']) == 100, trade
+    assert trade.get('strategy_type') == 'DIRECTIONAL_LONG', trade.get('strategy_type')
+
+
+def _stock_100(strategy_type, sl, now):
+    pm = _pm(strategy_type, sl=dict(sl, min_days_before_check=0))
+    short = strategy_type in ('SHORT_STOCK', 'DIRECTIONAL_SHORT')
+    pm.open_position(position_id='S1', strategy_type=strategy_type, symbol='SPY', entry_date=dt.date(2024, 1, 2),
+                     entry_price=100.0, quantity=100, contracts=100, unit_multiplier=1, total_cost=10000.0,
+                     entry_max_risk=10000.0, is_short_bias=short, position_type='SHORT' if short else 'LONG',
+                     underlying_entry_price=100.0)
+    pdx = _price_data(pm, now, pd.DataFrame())
+    return [h['exit_reason'] for h in pm.check_positions(DAY, pdx, underlying_price=now)]
+
+
+def test_stock_pl_loss_with_baseline_reset_uses_per_share_move():
+    sl = {'type': 'pl_loss', 'pl_loss_settings': {'pl_loss': 0.03}, 'reset_baseline_on_sl_start': True,
+          'intraday_settings': {'intraday_mode': 'disabled'}}
+    for strategy_type, small, big in (('DIRECTIONAL_SHORT', 100.3, 103.5), ('SHORT_STOCK', 100.3, 103.5),
+                                      ('DIRECTIONAL_LONG', 99.7, 96.5), ('LONG_STOCK', 99.7, 96.5)):
+        assert _stock_100(strategy_type, sl, small) == [], (strategy_type, small)
+        assert _stock_100(strategy_type, sl, big) == ['stop_loss_pl_loss'], (strategy_type, big)
+
+
+def test_stock_pl_loss_reset_with_dollar_entry_price():
+    sl = {'type': 'pl_loss', 'pl_loss_settings': {'pl_loss': 0.50}, 'reset_baseline_on_sl_start': True,
+          'min_days_before_check': 0, 'intraday_settings': {'intraday_mode': 'disabled'}}
+
+    def run(strategy_type, now):
+        pm = _pm(strategy_type, sl=sl)
+        short = strategy_type == 'SHORT_STOCK'
+        pm.open_position(position_id='G1', strategy_type=strategy_type, symbol='SPY', entry_date=dt.date(2024, 1, 2),
+                         entry_price=10000.0, quantity=100, contracts=1, total_cost=10000.0, entry_max_risk=10000.0,
+                         is_short_bias=short, position_type='SHORT' if short else 'LONG', underlying_entry_price=100.0)
+        pdx = _price_data(pm, now, pd.DataFrame())
+        return [h['exit_reason'] for h in pm.check_positions(DAY, pdx, underlying_price=now)]
+
+    assert run('LONG_STOCK', 100.5) == []
+    assert run('LONG_STOCK', 49.0) == ['stop_loss_pl_loss']
+    assert run('SHORT_STOCK', 160.0) == ['stop_loss_pl_loss']
+
+
+def test_long_stock_price_stops_do_not_fire_on_gains():
+    for sl in ({'type': 'fixed_pct', 'value': 0.03}, {'type': 'trailing', 'value': 0.03, 'trailing_distance': 0.03}):
+        for strategy_type in ('LONG_STOCK', 'DIRECTIONAL_LONG'):
+            assert _stock_100(strategy_type, sl, 103.0) == [], (strategy_type, sl['type'])
+
+
+def test_long_short_stock_unchanged():
+    for strategy_type, now in (('LONG_STOCK', 90.0), ('SHORT_STOCK', 110.0)):
+        pm = _pm(strategy_type, sl=dict(SL20, pl_loss_settings={'pl_loss': 0.03}))
+        pm.open_position(position_id='S1', strategy_type=strategy_type, symbol='SPY',
+                         entry_date=dt.date(2024, 1, 2), entry_price=100.0, quantity=10, contracts=10,
+                         unit_multiplier=1, total_cost=1000.0, entry_max_risk=1000.0,
+                         is_short_bias=(strategy_type == 'SHORT_STOCK'), underlying_entry_price=100.0)
+        pdx = _price_data(pm, now, pd.DataFrame())
+        assert round(pdx['S1']['pnl']) == -100, (strategy_type, pdx['S1'])
+
+
+def test_earnings_calendar_keeps_time_of_day_code():
+    df = pd.DataFrame([{'earning_date': '2024-01-12', 'estimate': 3.3, 'reported_earning': 3.9, 'time_of_day_code': 'BMO'},
+                       {'earning_date': '2024-04-12', 'estimate': 4.1, 'reported_earning': 4.4, 'time_of_day_code': 'AMC'}])
+    events = lib.parse_earnings_calendar(df)
+    assert [e['time_of_day_code'] for e in events] == ['BMO', 'AMC'], events
+    assert [e['time_of_day'] for e in events] == ['BMO', 'AMC'], events
+
+
+def test_package_exports_parse_earnings_calendar():
+    r = subprocess.run([sys.executable, '-c', 'from ivolatility_backtesting import parse_earnings_calendar'],
+                       cwd=_REPO, capture_output=True, text=True)
+    assert r.returncode == 0, r.stderr[-400:]
+
+
+def test_duckdb_preload_returns_option_aligned_stock():
+    adjusted = pd.DataFrame({'date': pd.to_datetime(['2024-01-02', '2024-01-03']),
+                             'close': [48.17, 47.57], 'unadjusted_close': [481.68, 475.69],
+                             'runtime_close': [481.68, 475.69], 'split_factor': [10.0, 10.0]})
+    canned = {'_preloaded_stock': adjusted.copy(),
+              '_preloaded_options': pd.DataFrame({'date': pd.to_datetime(['2024-01-02'])})}
+    saved_ssd, saved_ram = lib._preload_duckdb_SSD_storage, lib._try_duckdb_preload
+    try:
+        lib._preload_duckdb_SSD_storage = lambda config, cache_config: {k: v.copy() for k, v in canned.items()}
+        lib._try_duckdb_preload = lambda config, cache_config, debug=False: {k: v.copy() for k, v in canned.items()}
+        for mode in ('duckdb_SSD_storage', 'duckdb_RAM_reader'):
+            cfg = {'symbol': 'NVDA', 'start_date': '2024-01-02', 'end_date': '2024-01-03', 'debuginfo': 0,
+                   'strategy_type': 'STRADDLE', 'cache_config': {'cache_mode': mode}}
+            out = lib.preload_data_universal(cfg)
+            assert list(out['_preloaded_stock']['close'].round(2)) == [481.68, 475.69], (mode, out['_preloaded_stock'])
+            assert list(out['_preloaded_stock_adjusted']['close'].round(2)) == [48.17, 47.57], mode
+    finally:
+        lib._preload_duckdb_SSD_storage, lib._try_duckdb_preload = saved_ssd, saved_ram
+
+
+# --- event-day stop (reset_baseline_on_sl_start) with intraday bars -------------------------------
+
+def _event_day_stop(strategy_type, pl_loss, bars_by_time, eod_chain, **open_kwargs):
+    sl = {'type': 'pl_loss', 'min_days_before_check': 0, 'pl_loss_settings': {'pl_loss': pl_loss},
+          'reset_baseline_on_sl_start': True,
+          'intraday_settings': {'intraday_mode': 'auto', 'minute_interval': 'MINUTE_5',
+                                'reset_baseline_on_sl_start': True}}
+    pm = _pm(strategy_type, sl)
+    pm.sl_manager._get_legs_intraday_data = lambda *a, **k: (bars_by_time, sorted(bars_by_time))
+    pm.open_position(position_id='P1', symbol='SPY', entry_date=dt.date(2024, 1, 2), quantity=100,
+                     strategy_type=strategy_type, contracts=1, strike=470.0, expiration=EXP,
+                     underlying_entry_price=460.0, **open_kwargs)
+    pdx = _price_data(pm, 460.0, eod_chain)
+    return pm.check_positions(DAY, pdx, underlying_price=460.0)
+
+
+def _put_bars(asks):
+    return {t: [{'strike': 470.0, 'type': 'P', 'expiration': EXP, 'bid': a - 0.05, 'ask': a}]
+            for t, a in asks.items()}
+
+
+SHORT_500 = dict(entry_price=0, total_cost=-500.0, is_short_bias=True, entry_max_risk=500.0)
+
+
+def test_event_day_short_put_no_stop_without_a_real_loss():
+    for label, asks, thr in (('flat', {'09:30': 5.0, '09:35': 5.0, '15:55': 5.0}, 1.0),
+                             ('adverse then recovers', {'09:30': 5.0, '09:35': 5.05, '15:55': 4.9}, 1.0),
+                             ('favorable', {'09:30': 5.0, '09:35': 4.0, '15:55': 4.0}, 0.4)):
+        eod_ask = asks['15:55']
+        hits = _event_day_stop('SHORT_PUT', thr, _put_bars(asks),
+                               _chain(eod_ask - 0.05, eod_ask, 1.0, 1.1), **SHORT_500)
+        assert hits == [], (label, hits)
+
+
+def test_event_day_short_put_real_loss_books_pnl_from_premium():
+    hits = _event_day_stop('SHORT_PUT', 1.0, _put_bars({'09:30': 5.0, '09:35': 11.0, '15:55': 11.0}),
+                           _chain(10.95, 11.0, 1.0, 1.1), **SHORT_500)
+    assert len(hits) == 1 and hits[0]['options_stop_trigger_time'] == '09:35', hits
+    assert round(hits[0]['pnl']) == -600 and round(hits[0]['pnl_pct']) == -120, hits[0]
+    hits = _event_day_stop('SHORT_PUT', 0.4, _put_bars({'09:30': 5.0, '09:35': 7.5, '15:55': 7.5}),
+                           _chain(7.45, 7.5, 1.0, 1.1), **SHORT_500)
+    assert len(hits) == 1 and hits[0]['options_stop_trigger_time'] == '09:35', hits
+    assert round(hits[0]['pnl']) == -250 and round(hits[0]['pnl_pct']) == -50, hits[0]
+
+
+def test_event_day_long_call_books_pnl_from_premium_not_from_0930():
+    bars = {t: [{'strike': 470.0, 'type': 'C', 'expiration': EXP, 'bid': b, 'ask': b + 0.05}]
+            for t, b in {'09:30': 3.0, '09:35': 1.5, '15:55': 1.5}.items()}
+    hits = _event_day_stop('CALL', 0.4, bars, _chain(1.0, 1.1, 1.5, 1.55),
+                           entry_price=500.0, total_cost=500.0, call_entry_bid=5.0)
+    assert len(hits) == 1 and hits[0]['options_stop_trigger_time'] == '09:35', hits
+    assert round(hits[0]['pnl']) == -350, hits[0]
+
+
+def _cache_gap_probe(puts_missing_on):
+    import contextlib, io, tempfile
+    tmp = tempfile.mkdtemp(prefix='ivb_cache_')
+    cc = lib._normalize_cache_config({'cache_mode': 'duckdb_SSD_storage', 'cache_dir': tmp, 'disk_enabled': True})
+    conn = lib._get_duckdb_storage_conn(cc)
+    for table in ('stock_eod', 'options_eod_1545'):
+        conn.execute(f"DELETE FROM {table} WHERE symbol = 'AAPL'")
+    days = [d.date() for d in pd.bdate_range('2024-01-02', '2024-01-31')]
+    exp = dt.date(2024, 2, 16)
+    stock = pd.DataFrame({'symbol': 'AAPL', 'date': days, 'open': 180.0, 'high': 182.0, 'low': 179.0, 'close': 181.0,
+                          'volume': 1e6, 'bid': 180.9, 'ask': 181.1, 'unadjusted_close': 181.0, 'source_endpoint': 't'})
+    conn.execute("INSERT INTO stock_eod SELECT * FROM stock")
+    rows = [dict(option_symbol=f'AAPL_{exp}_{k}_{t}', date=d, symbol='AAPL', expiration=exp, strike=k, type=t,
+                 bid=1.0, ask=1.2, price=1.1, underlying_price=181.0, iv=0.25, delta=0.5 if t == 'C' else -0.5,
+                 gamma=0.01, theta=-0.05, vega=0.1, rho=0.01, dte=float((exp - d).days), volume=10.0,
+                 open_interest=100.0, source_endpoint='t', bid_eod=1.0, ask_eod=1.2)
+            for d in days for t in ('C', 'P') for k in (180.0, 185.0)
+            if not (t == 'P' and puts_missing_on(d))]
+    opts = pd.DataFrame(rows)
+    conn.execute("INSERT INTO options_eod_1545 SELECT * FROM opts")
+    config = {'symbol': 'AAPL', 'start_date': '2024-01-08', 'end_date': '2024-01-26', 'dte_target': 35,
+              'dte_tolerance': 10, 'options_snapshot_mode': '1545', 'use_duckdb_indicators': True,
+              'cache_config': cc, 'debuginfo': 0}
+    fetched = []
+    saved = {n: getattr(lib, n) for n in ('_fetch_date_range_data', '_load_stock_to_duckdb', '_load_ivx_to_duckdb',
+                                          '_patch_eod_prices_to_1545', '_load_futures_for_hedge', '_attach_vro_settlement')}
+    try:
+        lib._fetch_date_range_data = lambda cfg, c, sym, s, e, dfrom, dto: (fetched.append((s, e)), 0)[1]
+        lib._load_stock_to_duckdb = lambda *a, **k: None
+        lib._load_ivx_to_duckdb = lambda *a, **k: None
+        lib._patch_eod_prices_to_1545 = lambda *a, **k: {}
+        lib._load_futures_for_hedge = lambda *a, **k: None
+        lib._attach_vro_settlement = lambda *a, **k: None
+        lib._clear_gap_detection_cache()
+        with contextlib.redirect_stdout(io.StringIO()):
+            result = lib._try_read_from_duckdb_storage(config, cc, 'AAPL', '2024-01-02', '2024-01-31', '2024-01-08')
+    finally:
+        for n, f in saved.items():
+            setattr(lib, n, f)
+    return result is None, fetched
+
+
+def test_duckdb_cache_days_with_only_calls_are_refetched():
+    rejected, fetched = _cache_gap_probe(lambda d: d.day in (10, 11, 12))
+    assert not rejected and fetched, 'calls-only days were accepted as complete'
+    assert fetched[0][0] <= '2024-01-10' and fetched[-1][1] >= '2024-01-12', fetched
+
+
+def test_duckdb_cache_all_days_calls_only_forces_full_reload():
+    rejected, fetched = _cache_gap_probe(lambda d: True)
+    assert rejected and fetched == []
+
+
+def test_duckdb_cache_complete_days_are_not_refetched():
+    rejected, fetched = _cache_gap_probe(lambda d: False)
+    assert not rejected and fetched == []
+
+
+if __name__ == '__main__':
+    failed = 0
+    for name, fn in list(globals().items()):
+        if name.startswith('test_') and callable(fn):
+            try:
+                fn()
+                print(f'PASS {name}')
+            except Exception:
+                failed += 1
+                print(f'FAIL {name}')
+                traceback.print_exc()
+    sys.exit(1 if failed else 0)