Make Space backtests causal and auditable

README.md

@@ -31,9 +31,14 @@ missing candle, and writes a data snapshot plus manifest for every completed run
 - **Single model** mode or **Parallel models** mode. Every model keeps its own
   result and error; a failed model is never replaced by another model's output.
 - One configuration is shared by Live Signal and Backtesting.
+- The Space installs the real TimesFM/Moirai runtime dependencies; foundation
+  model failures are surfaced rather than replaced by a fallback forecast.
 - Walk-forward backtest uses training data only at each origin, checks the
   selected candle duration, skips gap-crossing targets, reports failures and
   coverage, and includes a last-close persistence baseline.
+- Backtests use the next candle's open as the entry, keep costs explicit, and
+  report separate 65% tuning and 35% final-check phases. The optional,
+  default-off random-signal control is available for leakage sanity checks.
 - Live results are blocked when the latest closed candle is stale. The MAYTHOS
   heuristic and forecast metrics are shown separately.
 - Actionable live signals include causal Entry, Stop Loss, Take Profit and

app.py

@@ -32,11 +32,12 @@ def server_port():
     return port
 
 
-def ui_config(provider, market, symbol, timeframe, mode, models, days, window, horizon, step, evaluations, features, spread_bps, fee_bps, slippage_bps):
+def ui_config(provider, market, symbol, timeframe, mode, models, days, window, horizon, step, evaluations, features, spread_bps, fee_bps, slippage_bps, random_baseline):
     return RunConfig(provider=provider, market=market, symbol=symbol, timeframe=timeframe,
                      mode=mode, models=tuple(models or ()), lookback_days=days, window=window,
                      horizon=horizon, step=step, max_evaluations=evaluations, use_features=features,
-                     spread_bps=spread_bps, fee_bps=fee_bps, slippage_bps=slippage_bps)
+                     spread_bps=spread_bps, fee_bps=fee_bps, slippage_bps=slippage_bps,
+                     random_baseline=random_baseline)
 
 
 def metadata_text(metadata):
@@ -127,7 +128,8 @@ def run_backtest_ui(*args):
         status = (
             f"### Walk-forward evaluation completed — {failed} failed/skipped model evaluations\n\n"
             f"History window: **{config.window}** · horizon: **{config.horizon}** · origin stride: **{config.step}** · "
-            f"at most **{config.max_evaluations} most-recent evaluation origins per model**. "
+            f"at most **{config.max_evaluations} most-recent evaluation origins per phase/model**. "
+            "The report contains separate **TUNING (65%)** and **FINAL_CHECK (35%)** rows; final-check target candles are not used during tuning. "
             'Orders are reselected using only each training window; no future target prices/features are supplied to models. '
             'Targets crossing gaps/market closures are explicitly skipped. Flat prices are classified as FLAT.\n\n'
             '**Accuracy denominator:** successful forecast evaluations; failures and coverage are shown separately. '
@@ -205,12 +207,13 @@ with gr.Blocks(title='MYTHOS · MAYTHOS × RINKING', theme=THEME, css=CSS) as de
                 spread_bps = gr.Number(value=1.0, minimum=0, maximum=1000, label='Assumed spread (bps)')
                 fee_bps = gr.Number(value=1.0, minimum=0, maximum=1000, label='Assumed fees (bps, round trip)')
                 slippage_bps = gr.Number(value=1.0, minimum=0, maximum=1000, label='Assumed slippage (bps)')
-            gr.Markdown('ARIMA-family order selection runs at every evaluation origin and may take several minutes. SL/TP uses closed-candle Wilder ATR plus prior swing structure; levels are omitted when no valid positive-risk target exists. Parallel mode runs independent models concurrently (two workers). Future indicator covariates use the last observed values. Moirai/TimesFM require their real pretrained weights.')
+            random_baseline = gr.Checkbox(value=False, label='Random-signal baseline (audit mode; default off)')
+            gr.Markdown('ARIMA-family order selection runs at every evaluation origin and may take several minutes. SL/TP uses closed-candle Wilder ATR plus prior swing structure; levels are omitted when no valid positive-risk target exists. Backtests enter at the next candle open. The backtest report splits ordered candles into 65% tuning and a final 35% check; final targets are never used during tuning. Parallel mode runs independent models concurrently (two workers). Future indicator covariates use the last observed values. Moirai/TimesFM require their real pretrained weights.')
         with gr.Accordion('Model dependency status', open=False):
             gr.Dataframe(value=model_readiness(), interactive=False)
             gr.Markdown('“Packages detected” is not an inference or accuracy certification. See README for installing optional foundation models.')
 
-    inputs = [provider, market, symbol, timeframe, mode, models, days, window, horizon, step, evaluations, features, spread_bps, fee_bps, slippage_bps]
+    inputs = [provider, market, symbol, timeframe, mode, models, days, window, horizon, step, evaluations, features, spread_bps, fee_bps, slippage_bps, random_baseline]
     with gr.Tab('Live Signal'):
         live_button = gr.Button('Refresh live signal', variant='primary')
         live_summary = gr.Markdown('Choose your configuration and refresh to fetch real closed candles.')

backtest/backtester.py

@@ -2,7 +2,10 @@ from math import floor, log10
 import numpy as np
 import pandas as pd
 from features.feature_pipeline import slice_features
-from risk_management import CostModel, build_trade_levels, simulate_trade, summarize_trades
+from risk_management import (
+    CostModel, average_true_range, build_trade_levels, simulate_trade,
+    summarize_trades,
+)
 from utils.helpers import MINUTES_PER_CANDLE, price_direction
 
 
@@ -25,6 +28,8 @@ def backtest_model(
     market: str = 'Crypto',
     symbol: str = '',
     costs: CostModel = None,
+    origin_start: int = None,
+    origin_end: int = None,
 ) -> pd.DataFrame:
     if not isinstance(df, pd.DataFrame):
         raise TypeError('Backtest candles must be provided as a pandas DataFrame.')
@@ -32,6 +37,9 @@ def backtest_model(
         raise ValueError('Window, horizon, and step must be positive integers.')
     if max_evaluations is not None and (isinstance(max_evaluations, (bool, np.bool_)) or not isinstance(max_evaluations, (int, np.integer)) or max_evaluations < 1):
         raise ValueError('max_evaluations must be a positive integer.')
+    for name, value in (('origin_start', origin_start), ('origin_end', origin_end)):
+        if value is not None and (isinstance(value, (bool, np.bool_)) or not isinstance(value, (int, np.integer)) or value < 0):
+            raise ValueError(f'{name} must be a non-negative integer when supplied.')
     if features_df is not None and len(features_df) != len(df):
         raise ValueError('Features must align with every OHLCV row.')
     if features_df is not None and not isinstance(features_df, pd.DataFrame):
@@ -63,6 +71,10 @@ def backtest_model(
     last_i = len(close) - horizon
     rows = []
     positions = list(range(window, last_i + 1, step))
+    if origin_start is not None:
+        positions = [position for position in positions if position >= origin_start]
+    if origin_end is not None:
+        positions = [position for position in positions if position < origin_end]
     if max_evaluations is not None:
         if max_evaluations < 1:
             raise ValueError('max_evaluations must be positive.')
@@ -121,6 +133,10 @@ def backtest_model(
             levels = build_trade_levels(
                 df.iloc[:i], trade_direction, market, symbol,
             forecast_target=predicted_next_close,
+            # The signal is formed on close[i - 1].  The order is filled on
+            # the next candle's real open, while all levels still use only
+            # history through the closed signal candle.
+            entry_price=float(df['Open'].iloc[i]),
             # Only trade a forecast that clears volatility noise and has a
             # target the model actually predicted. Previously a tiny forecast
             # was replaced by a distant swing target, creating timeout losses
@@ -169,6 +185,131 @@ def backtest_model(
     return pd.DataFrame(rows)
 
 
+def backtest_random_signals(
+    df: pd.DataFrame,
+    window: int = 100,
+    horizon: int = 1,
+    step: int = 1,
+    max_evaluations: int = None,
+    timeframe: str = None,
+    market: str = 'Crypto',
+    symbol: str = '',
+    costs: CostModel = None,
+    seed: int = 42,
+    origin_start: int = None,
+    origin_end: int = None,
+) -> pd.DataFrame:
+    """Run a deterministic random-direction control using only causal levels.
+
+    The direction is random and independently reproducible for each origin.
+    Its target is two historical ATRs from the signal close, so the control
+    has the same conservative level construction and explicit costs as model
+    trades without using a realized future price.
+    """
+    if not isinstance(df, pd.DataFrame):
+        raise TypeError('Backtest candles must be provided as a pandas DataFrame.')
+    if any(isinstance(value, (bool, np.bool_)) or not isinstance(value, (int, np.integer)) or value < 1 for value in (window, horizon, step)):
+        raise ValueError('Window, horizon, and step must be positive integers.')
+    if max_evaluations is not None and (isinstance(max_evaluations, (bool, np.bool_)) or not isinstance(max_evaluations, (int, np.integer)) or max_evaluations < 1):
+        raise ValueError('max_evaluations must be a positive integer.')
+    if timeframe is not None and timeframe not in MINUTES_PER_CANDLE:
+        raise ValueError(f'Unknown timeframe {timeframe!r}.')
+    for name, value in (('origin_start', origin_start), ('origin_end', origin_end)):
+        if value is not None and (isinstance(value, (bool, np.bool_)) or not isinstance(value, (int, np.integer)) or value < 0):
+            raise ValueError(f'{name} must be a non-negative integer when supplied.')
+    if df.empty or len(df) < window + horizon or not df.index.is_monotonic_increasing or df.index.duplicated().any():
+        raise ValueError('Backtest candles must be non-empty, chronologically ordered, and unique.')
+    required = {'Open', 'High', 'Low', 'Close'}
+    if not required.issubset(df.columns):
+        raise ValueError(f'Backtest candles are missing columns: {sorted(required - set(df.columns))}.')
+    ohlc = df[['Open', 'High', 'Low', 'Close']].apply(pd.to_numeric, errors='coerce')
+    if (not np.isfinite(ohlc.to_numpy(dtype=float)).all() or (ohlc <= 0).any().any() or
+            (ohlc['High'] < ohlc[['Open', 'Close', 'Low']].max(axis=1)).any() or
+            (ohlc['Low'] > ohlc[['Open', 'Close', 'High']].min(axis=1)).any()):
+        raise ValueError('Backtest candles contain invalid/non-finite OHLC observations.')
+    if costs is None:
+        costs = CostModel()
+    elif not isinstance(costs, CostModel):
+        raise TypeError('costs must be a CostModel instance.')
+    df = df.copy()
+    df[['Open', 'High', 'Low', 'Close']] = ohlc.astype(float)
+    close = df['Close']
+    timestamps = [ts.isoformat() if hasattr(ts, 'isoformat') else ts for ts in df.index]
+    last_i = len(close) - horizon
+    positions = list(range(window, last_i + 1, step))
+    if origin_start is not None:
+        positions = [position for position in positions if position >= origin_start]
+    if origin_end is not None:
+        positions = [position for position in positions if position < origin_end]
+    if max_evaluations is not None:
+        positions = positions[-max_evaluations:]
+    rows = []
+    for i in positions:
+        current_close = float(close.iloc[i - 1])
+        target_idx = i + horizon - 1
+        actual_next_close = float(close.iloc[target_idx])
+        continuous = True
+        try:
+            if timeframe:
+                expected_step = pd.Timedelta(minutes=MINUTES_PER_CANDLE[timeframe])
+                target_times = df.index[i - 1:target_idx + 1]
+                continuous = bool((target_times.to_series().diff().dropna() == expected_step).all())
+                if not continuous:
+                    raise ValueError('Target crosses a missing candle or market closure; not a continuous timeframe horizon.')
+            atr = average_true_range(df.iloc[:i][['High', 'Low', 'Close']])
+            if not np.isfinite(atr) or atr <= 0:
+                raise ValueError('Causal ATR is unavailable for the random control.')
+            direction = 'BUY' if np.random.default_rng(int(seed) + i * 1009).integers(0, 2) == 1 else 'SELL'
+            sign = 1.0 if direction == 'BUY' else -1.0
+            random_target = current_close + sign * 2.0 * float(atr)
+            levels = build_trade_levels(
+                df.iloc[:i], direction, market, symbol,
+                forecast_target=random_target,
+                entry_price=float(df['Open'].iloc[i]),
+                forecast_only=True,
+                minimum_edge_atr=0.20,
+                minimum_risk_reward=1.20,
+                use_structure_stop=False,
+                minimum_edge_bps=(
+                    costs.spread_bps + costs.fee_bps + 2.0 * costs.slippage_bps
+                ) * 1.25,
+            )
+            if levels is None:
+                raise ValueError('Causal random-control levels did not clear the execution gate.')
+            trade = simulate_trade(levels, df.iloc[i:target_idx + 1], costs)
+            error = None
+        except Exception as exc:
+            direction = None
+            random_target = np.nan
+            levels = None
+            trade = {'outcome': 'RANDOM_FAILED', 'exit_price': np.nan, 'net_r': np.nan, 'bars_held': 0}
+            error = str(exc)
+        actual_direction = price_direction(actual_next_close, current_close) if direction else None
+        predicted_direction = {'BUY': 'up', 'SELL': 'down'}.get(direction)
+        rows.append({
+            'datetime': timestamps[target_idx],
+            'current_close': current_close,
+            'predicted_close': random_target,
+            'actual_close': actual_next_close,
+            'predicted_direction': predicted_direction,
+            'actual_direction': actual_direction,
+            'correct': predicted_direction == actual_direction if predicted_direction else None,
+            'continuous_target': continuous,
+            'trade_taken': levels is not None,
+            'entry': levels.entry if levels else np.nan,
+            'stop_loss': levels.stop_loss if levels else np.nan,
+            'take_profit': levels.take_profit if levels else np.nan,
+            'risk_reward': levels.risk_reward if levels else np.nan,
+            'atr': levels.atr if levels else np.nan,
+            'outcome': trade.get('outcome'),
+            'exit_price': trade.get('exit_price'),
+            'net_r': trade.get('net_r'),
+            'bars_held': trade.get('bars_held', 0),
+            'error': error,
+        })
+    return pd.DataFrame(rows)
+
+
 def summarize_backtest(results: pd.DataFrame, model_name: str) -> dict:
     if results.empty:
         return {
@@ -227,12 +368,22 @@ def run_all_models_backtest(
     horizon: int = 1,
     step: int = 1,
     features_df: pd.DataFrame = None,
+    origin_start: int = None,
+    origin_end: int = None,
+    max_evaluations: int = None,
+    timeframe: str = None,
+    market: str = 'Crypto',
+    symbol: str = '',
+    costs: CostModel = None,
 ):
     per_model_results = {}
     per_model_summary = {}
     for name, model in models.items():
         results = backtest_model(
-            df, model, window=window, horizon=horizon, step=step, features_df=features_df
+            df, model, window=window, horizon=horizon, step=step, features_df=features_df,
+            origin_start=origin_start, origin_end=origin_end,
+            max_evaluations=max_evaluations, timeframe=timeframe,
+            market=market, symbol=symbol, costs=costs,
         )
         per_model_results[name] = results
         per_model_summary[name] = summarize_backtest(results, name)
@@ -250,6 +401,13 @@ def run_comparison_backtest(
     window: int = 100,
     horizon: int = 1,
     step: int = 1,
+    origin_start: int = None,
+    origin_end: int = None,
+    max_evaluations: int = None,
+    timeframe: str = None,
+    market: str = 'Crypto',
+    symbol: str = '',
+    costs: CostModel = None,
 ):
     per_model_results = {}
     per_model_summary = {}
@@ -261,7 +419,10 @@ def run_comparison_backtest(
             (FEATURED_LABEL, featured_model, features_df),
         ):
             results = backtest_model(
-                df, model, window=window, horizon=horizon, step=step, features_df=feats
+                df, model, window=window, horizon=horizon, step=step, features_df=feats,
+                origin_start=origin_start, origin_end=origin_end,
+                max_evaluations=max_evaluations, timeframe=timeframe,
+                market=market, symbol=symbol, costs=costs,
             )
             summary = summarize_backtest(results, name)
             summary["mode"] = label

maythos_integration.py

@@ -90,17 +90,32 @@ def backtest_maythos(
     market: str = 'Crypto',
     symbol: str = '',
     costs: CostModel = None,
+    origin_start: int = None,
+    origin_end: int = None,
 ) -> Tuple[pd.DataFrame, Dict[str, Any]]:
     """Evaluate MAYTHOS direction only when its signal is execution-ready."""
     window = positive_integer(window, 'MAYTHOS backtest window')
     horizon = positive_integer(horizon, 'MAYTHOS backtest horizon')
     step = positive_integer(step, 'MAYTHOS backtest step')
+    for name, value in (('origin_start', origin_start), ('origin_end', origin_end)):
+        if value is not None:
+            if isinstance(value, (bool, np.bool_)) or not isinstance(value, (int, np.integer)) or value < 0:
+                raise ValueError(f'MAYTHOS {name} must be a non-negative integer.')
+            value = int(value)
+            if name == 'origin_start':
+                origin_start = value
+            else:
+                origin_end = value
     frame = _normalise_frame(df)
     costs = costs or CostModel()
     outputs = _run_engine(frame)
     last_i = len(frame) - horizon
     rows = []
     positions = list(range(window, last_i + 1, step))
+    if origin_start is not None:
+        positions = [position for position in positions if position >= origin_start]
+    if origin_end is not None:
+        positions = [position for position in positions if position < origin_end]
     if max_evaluations is not None:
         max_evaluations = positive_integer(max_evaluations, 'MAYTHOS max_evaluations')
         positions = positions[-max_evaluations:]
@@ -129,6 +144,7 @@ def backtest_maythos(
         levels = (
             build_trade_levels(
                 frame.iloc[:i], output['direction'], market, symbol,
+                entry_price=float(frame['Open'].iloc[i]),
                 minimum_edge_atr=0.20, minimum_risk_reward=1.20,
                 minimum_edge_bps=(
                     costs.spread_bps + costs.fee_bps + 2.0 * costs.slippage_bps

pipeline.py

@@ -15,7 +15,7 @@ import zipfile
 import numpy as np
 import pandas as pd
 
-from backtest.backtester import backtest_model, summarize_backtest
+from backtest.backtester import backtest_model, backtest_random_signals, summarize_backtest
 from config import MODEL_NAMES, OUTPUT_DIR, PROVIDERS, RANDOM_SEED, TIMEFRAMES
 from data.providers import fetch_market_history, normalize_symbol
 from features.feature_pipeline import compute_feature_frame_for_period
@@ -42,6 +42,7 @@ class RunConfig:
     spread_bps: float = 1.0
     fee_bps: float = 1.0
     slippage_bps: float = 1.0
+    random_baseline: bool = False
 
     def __post_init__(self):
         if self.provider not in PROVIDERS or self.timeframe not in TIMEFRAMES:
@@ -77,6 +78,9 @@ class RunConfig:
             if isinstance(value, bool) or not finite or value < 0 or value > 1000:
                 raise ValueError(f'{name} must be a finite number between 0 and 1000 bps.')
             object.__setattr__(self, name, float(value))
+        if not isinstance(self.random_baseline, (bool, np.bool_)):
+            raise ValueError('random_baseline must be a boolean.')
+        object.__setattr__(self, 'random_baseline', bool(self.random_baseline))
         object.__setattr__(self, 'models', models)
         object.__setattr__(self, 'symbol', normalize_symbol(self.symbol, self.provider, self.market))
 
@@ -271,7 +275,24 @@ def backtest_result(config, frame=None, features=None):
     if len(frame) < config.window + config.horizon:
         raise ValueError(f'Backtesting needs at least {config.window + config.horizon} closed candles; provider returned {len(frame)}.')
 
-    def evaluate_one(name):
+    # The first portion is available for configuration research.  The final
+    # portion is addressed by origin, not by slicing away its training
+    # history: a final origin may train on older candles, but no final target
+    # candle can enter tuning or model fitting before that origin.
+    split_index = int(len(frame) * 0.65)
+    tuning_end = split_index - config.horizon + 1
+    final_start = split_index
+    final_end = len(frame) - config.horizon + 1
+    if tuning_end <= config.window:
+        raise ValueError('The fetched history is too short to provide a 65% tuning segment after the selected training window and horizon.')
+    if final_end <= max(config.window, final_start):
+        raise ValueError('The fetched history is too short to provide a 35% final-check segment after the selected training window and horizon.')
+    phases = (
+        ('TUNING', 0, tuning_end),
+        ('FINAL_CHECK', final_start, final_end),
+    )
+
+    def evaluate_one(name, origin_start, origin_end, phase):
         try:
             model = new_configured_model(name, config)
             details = backtest_model(
@@ -279,8 +300,10 @@ def backtest_result(config, frame=None, features=None):
                 step=config.step, features_df=features,
                 max_evaluations=config.max_evaluations, timeframe=config.timeframe,
                 market=config.market, symbol=config.symbol, costs=config.costs,
+                origin_start=origin_start, origin_end=origin_end,
             )
             summary = summarize_backtest(details, name)
+            diagnostics = dict(getattr(model, 'last_diagnostics', {}) or {})
         except Exception as error:
             details = pd.DataFrame([{
                 'datetime': None, 'current_close': np.nan,
@@ -293,7 +316,9 @@ def backtest_result(config, frame=None, features=None):
             }])
             summary = summarize_backtest(details, name)
             summary['error'] = str(error)
+            diagnostics = {}
         summary['Model'] = summary.pop('model')
+        summary['Phase'] = phase
         valid = details.dropna(subset=['correct'])
         summary['evaluations_attempted'] = len(details)
         summary['coverage_pct'] = round(100 * len(valid) / len(details), 2) if len(details) else None
@@ -303,24 +328,86 @@ def backtest_result(config, frame=None, features=None):
         summary['cost_slippage_bps'] = config.slippage_bps
         summary['status'] = 'OK' if summary['failed_predictions'] == 0 else ('PARTIAL' if len(valid) else 'FAILED')
         details.insert(0, 'Model', name)
-        return summary, details
+        details.insert(1, 'Phase', phase)
+        return summary, details, diagnostics
 
-    evaluated = _map_models(config, evaluate_one)
-    try:
-        signal_details, signal_summary = backtest_maythos(
-            frame, window=config.window, horizon=config.horizon, step=config.step,
-            max_evaluations=config.max_evaluations, timeframe=config.timeframe,
-            market=config.market, symbol=config.symbol, costs=config.costs,
+    forecast_summaries = []
+    forecast_details = []
+    model_diagnostics = {}
+    signal_summaries = []
+    signal_details = []
+    for phase, origin_start, origin_end in phases:
+        evaluated = _map_models(
+            config,
+            lambda name: evaluate_one(name, origin_start, origin_end, phase),
         )
-    except Exception as error:
-        signal_details = pd.DataFrame()
-        signal_summary = {'engine': 'MAYTHOS', 'error': str(error)}
+        for summary, details, diagnostics in evaluated:
+            forecast_summaries.append(summary)
+            forecast_details.append(details)
+            model_diagnostics[f'{phase}:{summary["Model"]}'] = diagnostics
+
+        if config.random_baseline:
+            random_details = backtest_random_signals(
+                frame, window=config.window, horizon=config.horizon, step=config.step,
+                max_evaluations=config.max_evaluations, timeframe=config.timeframe,
+                market=config.market, symbol=config.symbol, costs=config.costs,
+                seed=RANDOM_SEED, origin_start=origin_start, origin_end=origin_end,
+            )
+            random_summary = summarize_backtest(random_details, 'Random baseline')
+            random_summary['Model'] = random_summary.pop('model')
+            random_summary['Phase'] = phase
+            valid = random_details.dropna(subset=['correct'])
+            random_summary['evaluations_attempted'] = len(random_details)
+            random_summary['coverage_pct'] = round(100 * len(valid) / len(random_details), 2) if len(random_details) else None
+            random_summary['status'] = 'OK' if random_summary['failed_predictions'] == 0 else ('PARTIAL' if len(valid) else 'FAILED')
+            random_summary['cost_spread_bps'] = config.spread_bps
+            random_summary['cost_fee_bps'] = config.fee_bps
+            random_summary['cost_slippage_bps'] = config.slippage_bps
+            random_details.insert(0, 'Model', 'Random baseline')
+            random_details.insert(1, 'Phase', phase)
+            forecast_summaries.append(random_summary)
+            forecast_details.append(random_details)
+            model_diagnostics[f'{phase}:Random baseline'] = {
+                'type': 'deterministic random-direction control',
+                'seed': RANDOM_SEED,
+                'fallback': False,
+            }
+
+        try:
+            phase_signal_details, phase_signal_summary = backtest_maythos(
+                frame, window=config.window, horizon=config.horizon, step=config.step,
+                max_evaluations=config.max_evaluations, timeframe=config.timeframe,
+                market=config.market, symbol=config.symbol, costs=config.costs,
+                origin_start=origin_start, origin_end=origin_end,
+            )
+        except Exception as error:
+            phase_signal_details = pd.DataFrame()
+            phase_signal_summary = {'engine': 'MAYTHOS', 'error': str(error)}
+        phase_signal_summary['Phase'] = phase
+        phase_signal_details.insert(0, 'Phase', phase)
+        signal_summaries.append(phase_signal_summary)
+        signal_details.append(phase_signal_details)
+
+    split_metadata = {
+        'policy': 'first 65% of ordered closed candles for tuning; last 35% for final check',
+        'fraction_tuning': 0.65,
+        'split_index': split_index,
+        'tuning_candles': split_index,
+        'final_check_candles': len(frame) - split_index,
+        'tuning_origin_end_exclusive': tuning_end,
+        'final_origin_start_inclusive': final_start,
+        'final_origin_end_exclusive': final_end,
+        'final_targets_are_unseen_during_tuning': True,
+    }
     return {
         'config': config, 'frame': frame, 'features': features,
         'metadata': data_metadata(frame, config),
-        'forecast_summary': pd.DataFrame([summary for summary, _ in evaluated]),
-        'forecast_details': pd.concat([details for _, details in evaluated], ignore_index=True),
-        'signal_summary': pd.DataFrame([signal_summary]), 'signal_details': signal_details,
+        'split': split_metadata,
+        'model_diagnostics': model_diagnostics,
+        'forecast_summary': pd.DataFrame(forecast_summaries),
+        'forecast_details': pd.concat(forecast_details, ignore_index=True),
+        'signal_summary': pd.DataFrame(signal_summaries),
+        'signal_details': pd.concat(signal_details, ignore_index=True),
     }
 
 
@@ -348,6 +435,8 @@ def export_run(result, kind):
         'feature_future_policy': 'Last observed covariates carried forward, never future actual indicators',
         'evaluation': 'Walk-forward direction/price error plus causal candle-path SL/TP trade simulation; costs are explicit assumptions',
         'trade_costs': result['config'].costs.as_dict(),
+        'split': result.get('split'),
+        'model_diagnostics': result.get('model_diagnostics', {}),
     }
     (directory / 'manifest.json').write_text(json.dumps(manifest, indent=2, default=str, allow_nan=False), encoding='utf-8')
     if kind == 'live':
@@ -356,6 +445,10 @@ def export_run(result, kind):
     else:
         for key in ('forecast_summary', 'forecast_details', 'signal_summary', 'signal_details'):
             result[key].to_csv(directory / f'{key}.csv', index=False)
+        (directory / 'model_diagnostics.json').write_text(
+            json.dumps(result.get('model_diagnostics', {}), indent=2, default=str),
+            encoding='utf-8',
+        )
     path = directory.with_suffix('.zip')
     with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED) as archive:
         for file in sorted(directory.iterdir()):

requirements.txt

@@ -1,8 +1,6 @@
-# Hugging Face Spaces/core runtime. Foundation-model dependencies are
-# deliberately opt-in via requirements-foundation.txt; a missing optional
-# model is reported as failed instead of being replaced by fake output.
-# Spaces mounts only this file during dependency installation, so keep the
-# core dependencies inline and in sync with requirements-core.txt.
+# Hugging Face Spaces runtime.  Foundation models are installed here rather
+# than left opt-in: a TimesFM result is only valid when the real package and
+# checkpoint can load in the deployed Space.
 numpy==1.26.4
 pandas==2.1.4
 scipy==1.11.4
@@ -12,3 +10,16 @@ yfinance==1.7.0
 gradio==5.50.0
 plotly==6.9.0
 requests==2.34.2
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.4.1+cpu
+uni2ts==2.0.0
+timesfm[torch]==3.0.2
+gluonts==0.14.4
+lightning==2.4.0
+pytorch-lightning==2.4.0
+torchmetrics==1.4.3
+huggingface_hub==0.36.0
+pyarrow==16.1.0
+jax[cpu]==0.4.38
+scikit-learn==1.5.2
+safetensors>=0.5.3

risk_management.py

@@ -197,6 +197,7 @@ def build_trade_levels(
     market: str,
     symbol: str,
     forecast_target: float | None = None,
+    entry_price: float | None = None,
     atr_period: int = ATR_PERIOD,
     swing_lookback: int = SWING_LOOKBACK,
     forecast_only: bool = False,
@@ -251,7 +252,15 @@ def build_trade_levels(
     if (numeric['High'] < numeric[['Low', 'Close'] + (['Open'] if 'Open' in numeric else [])].max(axis=1)).any() or \
             (numeric['Low'] > numeric[['High', 'Close'] + (['Open'] if 'Open' in numeric else [])].min(axis=1)).any():
         return None
-    entry = float(frame['Close'].iloc[-1])
+    if entry_price is None:
+        entry = float(frame['Close'].iloc[-1])
+    else:
+        try:
+            entry = float(entry_price)
+        except (TypeError, ValueError):
+            return None
+        if not _finite_positive(entry):
+            return None
     atr = average_true_range(numeric, atr_period)
     if not _finite_positive(atr) or not _finite_positive(entry):
         return None
@@ -419,6 +428,7 @@ def summarize_trades(details: pd.DataFrame) -> dict:
             'trades': 0, 'wins': 0, 'losses': 0, 'timeouts': 0,
             'win_rate_pct': None, 'profit_factor': None,
             'expectancy_r': None, 'max_drawdown_r': None, 'average_r': None,
+            'net_profit_r': None, 'top3_removed_profit_r': None,
         }
     trades = details[details['trade_taken'] & details['net_r'].notna()].copy()
     if trades.empty:
@@ -426,6 +436,7 @@ def summarize_trades(details: pd.DataFrame) -> dict:
             'trades': 0, 'wins': 0, 'losses': 0, 'timeouts': 0,
             'win_rate_pct': None, 'profit_factor': None,
             'expectancy_r': None, 'max_drawdown_r': None, 'average_r': None,
+            'net_profit_r': None, 'top3_removed_profit_r': None,
         }
     returns = trades['net_r'].astype(float).to_numpy()
     wins = int((trades['outcome'] == 'TP').sum())
@@ -437,6 +448,9 @@ def summarize_trades(details: pd.DataFrame) -> dict:
     equity = np.cumsum(returns)
     peaks = np.maximum.accumulate(np.r_[0.0, equity])[1:]
     drawdown = peaks - equity
+    net_profit = float(returns.sum())
+    top_count = min(3, len(returns))
+    top3_removed = float(net_profit - np.sort(returns)[-top_count:].sum())
     return {
         'trades': int(len(trades)), 'wins': wins, 'losses': losses, 'timeouts': timeouts,
         'win_rate_pct': round(100.0 * wins / len(trades), 2),
@@ -444,4 +458,6 @@ def summarize_trades(details: pd.DataFrame) -> dict:
         'expectancy_r': round(float(returns.mean()), 6),
         'max_drawdown_r': round(float(drawdown.max()) if len(drawdown) else 0.0, 6),
         'average_r': round(float(returns.mean()), 6),
+        'net_profit_r': round(net_profit, 6),
+        'top3_removed_profit_r': round(top3_removed, 6),
     }

tests/test_risk_management.py

@@ -94,6 +94,19 @@ class TestTradeLevels(unittest.TestCase):
 
 
 class TestBacktestTradeMetrics(unittest.TestCase):
+    def test_backtest_entry_is_next_candle_open(self):
+        frame = _history(80)
+        results = backtest_model(
+            frame, _UpModel(), window=40, horizon=1, step=10,
+            timeframe='5m', market='Crypto', symbol='BTC-USD', costs=CostModel(),
+        )
+        traded = results[results['trade_taken']]
+        self.assertGreater(len(traded), 0)
+        first = traded.iloc[0]
+        target_position = frame.index.get_loc(pd.Timestamp(first['datetime']))
+        entry_position = target_position
+        self.assertAlmostEqual(first['entry'], float(frame['Open'].iloc[entry_position]))
+
     def test_backtest_contains_candle_path_trade_fields_and_summary(self):
         frame = _history(80)
         results = backtest_model(frame, _UpModel(), window=40, horizon=2, step=10, timeframe='5m', market='Crypto', symbol='BTC-USD', costs=CostModel())