Make the signal reachable, directional, and timeframe-aware

The app could only ever answer HOLD. Four defects, each sufficient alone:

1. min_confidence was 70/65/60/55 against a quantity whose measured max was 47 --
it fired on 0 of 80 observations. Recalibrated to 40/38/36/34, percentiles of
the real distribution; fires ~9%, so HOLD stays the common answer.
2. A component with no reading was scored as 0 confidence instead of abstaining,
spending 30% of the budget on a constant zero and pinning output near 25.
3. momentum_score is a magnitude and _convert_signal_format hardcoded CALLS, so
PUTS was unreachable for any input and a selloff read as a bullish setup.
Direction recovered from directional_bias, which was computed then discarded.
4. The selected timeframe never reached the momentum engine, which hardcoded its
weights -- every timeframe analysed identical data. 5m bars added so the fast
settings have real data to weight.

Gap mode was gated on the TFT gap_probability (~67.1 for every symbol, never
cleared its own >70 test) and is now gated on a measured overnight gap.

Direction gates set by permutation test on real bars: at the old settings the
engine fired MORE often on shuffled data than real (lift 0.70). Now 1.83x.
That is a modest edge, not a tradeable one, and is documented as such.

signal_reachability_test.py

@@ -0,0 +1,148 @@
+"""Can the app emit anything other than HOLD? And does either dropdown do anything?
+
+    venv\Scripts\python.exe huggingface_space\signal_reachability_test.py
+
+Audited 2026-09-07: all 12 timeframe x strategy combinations returned ONE distinct answer,
+always HOLD, at a confidence pinned near 25. Four separate defects, each of which alone was
+enough to cause it:
+
+  1. min_confidence was 70/65/60/55 against a quantity whose measured MAXIMUM was 47.
+     The gate fired on 0 of 80 observations. Not strict -- unreachable.
+  2. sentiment abstains almost always, but was scored as 0 confidence rather than excluded,
+     permanently spending 30% of the confidence budget on a constant zero.
+  3. momentum_score is a MAGNITUDE (every term abs()-wrapped or non-negative) and
+     _convert_signal_format hardcoded `return 'CALLS'`. weighted_score could not go
+     negative, so PUTS was unreachable for any input, and a collapsing stock read as a
+     bullish setup.
+  4. the selected timeframe never reached the momentum engine, which hardcoded its
+     timeframe weights -- so every timeframe analysed identical data.
+
+These assert all four stay fixed. Synthetic bars are used deliberately: a live-market test
+would pass or fail on that morning's tape.
+"""
+from __future__ import annotations
+
+import os
+import sys
+import warnings
+from pathlib import Path
+
+warnings.filterwarnings("ignore")
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+for _k in ("FINNHUB_KEY", "REDDIT_CLIENT_ID", "REDDIT_CLIENT_SECRET", "REDDIT_USER_AGENT"):
+    os.environ.setdefault(_k, "unused")
+
+import numpy as np
+import pandas as pd
+
+from trade_analysis.enhanced_api import _generate_master_signal
+from trade_analysis.momentum_trading_engine import IntegratedMomentumEngine
+
+SENT = {"composite_score": 0.05, "confidence": "LOW"}
+ALT = {"vix_level": 14.5, "implied_vol_pct": 60.0}
+LLM = {"signal": "HOLD", "confidence": 40}
+TFS = ["1m", "5m", "15m", "1h"]
+
+
+def trend_bars(n: int = 200, drift: float = 0.005, seed: int = 0) -> pd.DataFrame:
+    """A clean, decisive trend. drift < 0 falls."""
+    rng = np.random.default_rng(seed)
+    close = 100.0 * np.cumprod(1.0 + drift + rng.normal(0, 0.0004, n))
+    high = close * 1.002
+    low = close * 0.998
+    vol = np.linspace(1e6, 2e6, n)
+    vol[-1] *= 3.0                                  # closing volume spike
+    idx = pd.date_range("2026-01-02 09:30", periods=n, freq="15min", tz="UTC")
+    return pd.DataFrame({"Open": close, "High": high, "Low": low,
+                         "Close": close, "Volume": vol}, index=idx)
+
+
+def bar_set(drift: float) -> dict:
+    return {tf: trend_bars(drift=drift, seed=i)
+            for i, tf in enumerate(["5m", "15m", "hourly", "daily"])}
+
+
+def run(bars, timeframe="15m", strategy="momentum", gap=None):
+    eng = IntegratedMomentumEngine()
+    mom = eng.generate_enhanced_signal(bars, SENT, ALT, timeframe)
+    sig = _generate_master_signal(mom, LLM, SENT, None, timeframe, strategy, gap)
+    return mom, sig
+
+
+failures = []
+
+
+def check(label, cond, detail=""):
+    print(f"  {'PASS' if cond else 'FAIL'}  {label}{('  -- ' + detail) if detail else ''}")
+    if not cond:
+        failures.append(label)
+
+
+print("1. the confidence gate is reachable at all")
+up = bar_set(+0.005)
+mom, sig = run(up)
+check("a decisive uptrend clears the gate and is not HOLD", sig["signal"] != "HOLD",
+      f"signal={sig['signal']} conf={sig['confidence']} score={sig['weighted_score']:+.3f}")
+check("...and it is bullish", sig["signal"] == "CALLS", f"got {sig['signal']}")
+
+print("\n2. PUTS is reachable -- the direction bug")
+dn = bar_set(-0.005)
+mom_d, sig_d = run(dn)
+check("a decisive DOWNtrend is not reported as a CALLS setup",
+      sig_d["signal"] != "CALLS", f"got {sig_d['signal']}")
+check("...it is PUTS", sig_d["signal"] == "PUTS",
+      f"signal={sig_d['signal']} score={sig_d['weighted_score']:+.3f}")
+check("weighted_score carries a negative sign", sig_d["weighted_score"] < 0,
+      f"{sig_d['weighted_score']:+.3f}")
+check("engine direction is BEARISH",
+      mom_d["momentum_analysis"]["master_signal"].get("direction") == "BEARISH",
+      str(mom_d["momentum_analysis"]["master_signal"].get("direction")))
+
+print("\n3. the timeframe selector reaches the analysis")
+mixed = {"5m": trend_bars(drift=+0.006, seed=1),
+         "15m": trend_bars(drift=+0.004, seed=2),
+         "hourly": trend_bars(drift=-0.001, seed=3),
+         "daily": trend_bars(drift=-0.005, seed=4)}
+scores = {}
+for tf in TFS:
+    _, s = run(mixed, timeframe=tf)
+    scores[tf] = round(s["weighted_score"], 6)
+print(f"      weighted_score by timeframe: {scores}")
+check("timeframes do not all produce one identical score",
+      len(set(scores.values())) > 1, f"{len(set(scores.values()))} distinct")
+check("a fast setting differs from the slow one", scores["1m"] != scores["1h"])
+
+print("\n4. the gap strategy responds to a real gap")
+_, no_gap = run(up, strategy="gap", gap=0.05)
+_, big_gap = run(up, strategy="gap", gap=2.4)
+check("a 0.05% move is reported as below the floor",
+      "below the 0.5% floor" in no_gap["reasoning"], no_gap["reasoning"])
+check("a 2.4% gap qualifies and says so",
+      "qualifies" in big_gap["reasoning"], big_gap["reasoning"])
+check("the measured gap is returned to the caller",
+      big_gap.get("overnight_gap_pct") == 2.4, str(big_gap.get("overnight_gap_pct")))
+
+print()
+print("5. a directionless tape stays HOLD (the gates must remain demanding)")
+# One case is not a test: direction is a noisy statistic and any single draw can clear a
+# threshold by luck, so this fires an ENSEMBLE and asserts the rate. Note the DISTINCT
+# seed per bar set -- an earlier version of this test reused one seed for all four, which
+# made the timeframes literally identical, forced agreement to 1.0, and guaranteed a fire.
+noise_fires, noise_n = 0, 0
+for k in range(25):
+    flat = {tf: trend_bars(drift=0.0, seed=500 + k * 4 + j)
+            for j, tf in enumerate(["5m", "15m", "hourly", "daily"])}
+    for tf in TFS:
+        noise_n += 1
+        if run(flat, timeframe=tf)[1]["signal"] != "HOLD":
+            noise_fires += 1
+rate = noise_fires / noise_n * 100
+check("fires on under 10% of zero-drift tapes", rate < 10.0,
+      f"{noise_fires}/{noise_n} = {rate:.1f}%")
+
+print("\n" + "=" * 66)
+if failures:
+    print(f"FAILED ({len(failures)}): " + "; ".join(failures))
+    sys.exit(1)
+print("All reachability checks passed.")

tools/calibrate_confidence_gate.py

@@ -0,0 +1,98 @@
+"""Measure the attainable range of weighted_confidence over real bars, so that
+enhanced_api's min_confidence is a percentile of something real rather than a guess.
+
+    venv\\Scripts\\python.exe huggingface_space\\tools\\calibrate_confidence_gate.py
+
+min_confidence was originally 70/65/60/55 against a quantity whose measured maximum was
+47: it fired on 0 of 80 observations, which is why the app answered HOLD for every symbol
+on every timeframe. Re-run this after changing any confidence component, or when the
+volatility regime shifts -- the sample it was set from was a quiet tape (VIX ~14.5).
+"""
+from __future__ import annotations
+
+import os
+import statistics as st
+import sys
+import warnings
+from pathlib import Path
+
+warnings.filterwarnings("ignore")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+for _k in ("FINNHUB_KEY", "REDDIT_CLIENT_ID", "REDDIT_CLIENT_SECRET", "REDDIT_USER_AGENT"):
+    os.environ.setdefault(_k, "unused")
+
+import pandas as pd
+import yfinance as yf
+
+from trade_analysis.data import TIMEFRAME_SPEC
+from trade_analysis.enhanced_api import _generate_master_signal
+from trade_analysis.momentum_trading_engine import IntegratedMomentumEngine
+
+COLS = ["Open", "High", "Low", "Close", "Volume"]
+TFS = ["1m", "5m", "15m", "1h"]
+THRESH = {"1m": .20, "5m": .25, "15m": .30, "1h": .35}
+GATE = {"1m": 40, "5m": 38, "15m": 36, "1h": 34}          # what enhanced_api uses now
+BASKET = ["NVDA", "TSLA", "SPY", "QQQ", "AAPL", "MSFT", "AMD", "META", "AMZN", "GOOGL",
+          "NFLX", "COIN", "XLE", "JPM", "WMT", "BA", "DIS", "UBER", "PLTR", "SMCI"]
+SENT = {"composite_score": 0.05, "confidence": "LOW"}
+ALT = {"vix_level": 14.5, "implied_vol_pct": 60.0}
+LLM = {"signal": "HOLD", "confidence": 40}
+
+
+def bars(symbol: str) -> dict:
+    out = {}
+    for tf, (period, interval) in TIMEFRAME_SPEC.items():
+        try:
+            df = yf.Ticker(symbol).history(period=period, interval=interval,
+                                           auto_adjust=False)
+        except Exception:
+            continue
+        if df is None or df.empty:
+            continue
+        if isinstance(df.columns, pd.MultiIndex):
+            df.columns = df.columns.get_level_values(0)
+        out[tf] = df[COLS].dropna()
+    return out
+
+
+def main() -> int:
+    eng = IntegratedMomentumEngine()
+    rows = []
+    for sym in BASKET:
+        o = bars(sym)
+        if not o:
+            print(f"  {sym}: no data, skipped")
+            continue
+        gap = None
+        d = o.get("daily")
+        if d is not None and len(d) >= 2:
+            prev, opn = float(d["Close"].iloc[-2]), float(d["Open"].iloc[-1])
+            gap = (opn - prev) / prev * 100 if prev else None
+        for tf in TFS:
+            mom = eng.generate_enhanced_signal(o, SENT, ALT, tf)
+            r = _generate_master_signal(mom, LLM, SENT, None, tf, "momentum", gap)
+            rows.append((tf, r["confidence"], r["weighted_score"], r["signal"]))
+        print(f"  {sym}: " + " ".join(f"{t}={c}" for t, c, _, _ in rows[-4:]))
+
+    if not rows:
+        print("no data at all -- market data unreachable?")
+        return 1
+    confs = sorted(c for _, c, _, _ in rows)
+
+    def p(q):
+        return confs[min(len(confs) - 1, int(len(confs) * q))]
+
+    print("\n" + "=" * 64)
+    print(f"n = {len(rows)} observations")
+    print(f"weighted_confidence  min {min(confs)}  p50 {p(.50)}  p75 {p(.75)}  "
+          f"p90 {p(.90)}  max {max(confs)}  (mean {st.mean(confs):.1f})")
+    fires = sum(1 for tf, c, s, _ in rows if c > GATE[tf] and abs(s) > THRESH[tf])
+    print(f"current gate {GATE}")
+    print(f"fires on {fires}/{len(rows)} ({fires / len(rows) * 100:.1f}%)")
+    print("\nA gate ABOVE the observed max is not strict, it is broken. Keep the fire "
+          "rate low but\nnon-zero: HOLD should be the common answer, not the only one.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tools/calibrate_direction_gate.py

@@ -0,0 +1,131 @@
+"""Calibrate the direction gates by PERMUTATION on real bars.
+
+    venv\\Scripts\\python.exe huggingface_space\\tools\\calibrate_direction_gate.py
+
+The first question a trading signal must answer is not "how often is it right" but "how
+often does it fire when there is nothing there". Shuffling the returns of a real series
+destroys any persistent trend while preserving the volume profile, volatility level and
+bar geometry that the momentum MAGNITUDE depends on -- so anything the engine emits on a
+permuted series is a false positive, and the ratio of its real firing rate to its permuted
+firing rate is its lift over noise.
+
+Two earlier attempts at this were wrong and are recorded here so they are not repeated:
+
+  * Independent random walks per timeframe. In production 5m/15m/hourly/daily are nested
+    aggregations of ONE price path, so they agree far more often than independent draws
+    do. Treating them as independent flatters the multi-timeframe agreement test.
+  * Synthetic nested walks with uniform random volume. The momentum magnitude gate then
+    blocks every case before the direction logic is ever consulted, so the measurement
+    reported 0% for everything and was insensitive to the knobs being swept.
+
+Permutation avoids both: the geometry and the volume are real, only the path is destroyed.
+"""
+from __future__ import annotations
+
+import os
+import sys
+import warnings
+from pathlib import Path
+
+warnings.filterwarnings("ignore")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+for _k in ("FINNHUB_KEY", "REDDIT_CLIENT_ID", "REDDIT_CLIENT_SECRET", "REDDIT_USER_AGENT"):
+    os.environ.setdefault(_k, "unused")
+
+import numpy as np
+import pandas as pd
+import yfinance as yf
+
+import trade_analysis.momentum_trading_engine as MTE
+from trade_analysis.data import TIMEFRAME_SPEC
+from trade_analysis.enhanced_api import _generate_master_signal
+
+COLS = ["Open", "High", "Low", "Close", "Volume"]
+TFS = ["1m", "5m", "15m", "1h"]
+BASKET = ["NVDA", "TSLA", "SPY", "QQQ", "AAPL", "MSFT", "AMD", "META", "AMZN", "GOOGL",
+          "NFLX", "COIN", "XLE", "JPM", "WMT", "BA", "DIS", "UBER", "PLTR", "SMCI"]
+GRID = [(0.15, 0.60), (0.25, 0.60), (0.35, 0.60), (0.35, 0.75),
+        (0.40, 0.60), (0.40, 0.75), (0.45, 0.75), (0.50, 0.75)]
+IN_USE = (0.40, 0.75)
+REPS = 6
+
+SENT = {"composite_score": 0.05, "confidence": "LOW"}
+ALT = {"vix_level": 14.5, "implied_vol_pct": 60.0}
+LLM = {"signal": "HOLD", "confidence": 40}
+
+
+def bars(symbol: str) -> dict:
+    out = {}
+    for tf, (period, interval) in TIMEFRAME_SPEC.items():
+        try:
+            df = yf.Ticker(symbol).history(period=period, interval=interval,
+                                           auto_adjust=False)
+        except Exception:
+            continue
+        if df is None or df.empty:
+            continue
+        if isinstance(df.columns, pd.MultiIndex):
+            df.columns = df.columns.get_level_values(0)
+        out[tf] = df[COLS].dropna()
+    return out
+
+
+def permute(df: pd.DataFrame, rng: np.random.Generator) -> pd.DataFrame:
+    """Shuffle the return sequence, rescaling OHLC together so bars stay coherent."""
+    close = df["Close"].to_numpy(float)
+    rets = np.diff(close) / close[:-1]
+    rng.shuffle(rets)
+    rebuilt = np.empty_like(close)
+    rebuilt[0] = close[0]
+    rebuilt[1:] = close[0] * np.cumprod(1.0 + rets)
+    scale = rebuilt / close
+    out = df.copy()
+    for col in ("Open", "High", "Low", "Close"):
+        out[col] = df[col].to_numpy(float) * scale
+    return out
+
+
+def main() -> int:
+    eng = MTE.IntegratedMomentumEngine()
+
+    def sig(bar_set, tf):
+        m = eng.generate_enhanced_signal(bar_set, SENT, ALT, tf)
+        return _generate_master_signal(m, LLM, SENT, None, tf, "momentum", None)["signal"]
+
+    print("fetching...")
+    data = {s: b for s in BASKET if (b := bars(s))}
+    if not data:
+        print("no market data -- cannot calibrate")
+        return 1
+    n_real = len(data) * len(TFS)
+    print(f"{len(data)} symbols x {len(TFS)} timeframes; "
+          f"{n_real * REPS} permuted observations, {n_real} real\n")
+
+    print(f"{'dead':>6}{'agr':>6}{'FPR(perm)':>11}{'fire(real)':>12}{'lift':>7}")
+    print("-" * 42)
+    for dead, agr in GRID:
+        MTE.DIRECTION_DEADBAND, MTE.DIRECTION_AGREEMENT = dead, agr
+        fp = n = 0
+        for i, (sym, o) in enumerate(data.items()):
+            rng = np.random.default_rng(11 + i)
+            for _ in range(REPS):
+                pb = {k: permute(v, rng) for k, v in o.items()}
+                for tf in TFS:
+                    n += 1
+                    if sig(pb, tf) != "HOLD":
+                        fp += 1
+        real = sum(1 for o in data.values() for tf in TFS if sig(o, tf) != "HOLD")
+        fpr, rr = fp / n * 100, real / n_real * 100
+        lift = rr / fpr if fpr else float("inf")
+        mark = "  <-- in use" if (dead, agr) == IN_USE else ""
+        print(f"{dead:>6.2f}{agr:>6.2f}{fpr:>10.1f}%{rr:>11.1f}%{lift:>7.2f}{mark}")
+
+    print("\nLIFT IS THE COLUMN THAT MATTERS. Below 1.0 the engine fires more often on")
+    print("shuffled data than on real data, which is worse than useless. Restore the")
+    print("gates from this table -- never by eye -- and re-run after touching the")
+    print("direction score, the momentum magnitude, or the confidence weights.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

trade_analysis/data.py

@@ -15,7 +15,18 @@ import pytz
 # .generate_enhanced_signal() looks up exactly those three, and enhanced_api hands
 # ohlcv_data["daily"] to the TFT. yfinance caps intraday history: 15m is 60 days, 1h is
 # 730 days, so those periods are the provider's limit, not a choice.
+# "5m" was added 2026-09-07 so that the UI's timeframe selector has distinct DATA to
+# weight, not just distinct thresholds. Before that, 15m/hourly/daily were the only bars
+# ever fetched and the momentum engine hardcoded its weights over them, so picking "1m"
+# vs "1h" changed nothing about the analysis -- measured: 1 distinct outcome across all
+# 12 timeframe x strategy combinations.
+#
+# yfinance caps 5m history at 60d and 1m at 7d. 7 days is too few bars for the 20-period
+# indicators to warm up, so there is deliberately NO "1m" fetch: the UI's 1m setting is
+# the most REACTIVE WEIGHTING over the 5m set, and the response says so in
+# timeframe_weights rather than implying minute bars exist.
 TIMEFRAME_SPEC = {
+    "5m":     ("60d",  "5m"),
     "15m":    ("60d",  "15m"),
     "hourly": ("180d", "1h"),
     "daily":  ("2y",   "1d"),

trade_analysis/enhanced_api.py

@@ -192,8 +192,11 @@ async def predict_enhanced_signal(
         )
         
         # 2. Momentum Analysis
+        # `timeframe` is passed through so the user's selection actually reweights the
+        # bars (see TIMEFRAME_WEIGHTS in momentum_trading_engine). Until 2026-09-07 it
+        # stopped at enhanced_api and only moved a threshold, making the selector inert.
         momentum_analysis = momentum_engine.generate_enhanced_signal(
-            ohlcv_data, sentiment_analysis, alt_data
+            ohlcv_data, sentiment_analysis, alt_data, timeframe
         )
         
         # 3. TFT Prediction
@@ -240,10 +243,24 @@ async def predict_enhanced_signal(
             }
             llm_analysis = generate_enhanced_llm_signal(conditions)
         
+        # 4b. Real overnight gap, for strategy_mode="gap".
+        # That mode used to be gated on tft_prediction["gap_probability"] > 70. The TFT
+        # returns ~67.1 for every symbol (measured spread 0.10 across six symbols), so the
+        # branch was UNREACHABLE and "gap" was a silent no-op -- one of the reasons all 12
+        # timeframe x strategy combinations produced an identical answer. The gap is a
+        # directly observable quantity, so it is now measured from the daily bars instead
+        # of being predicted by a model that has collapsed to its prior.
+        gap_pct = None
+        if daily_df is not None and len(daily_df) >= 2:
+            prev_close = float(daily_df["Close"].iloc[-2])
+            today_open = float(daily_df["Open"].iloc[-1])
+            if prev_close > 0:
+                gap_pct = (today_open - prev_close) / prev_close * 100.0
+
         # 5. Master Signal Generation - FIXED FUNCTION NAME
         master_signal = _generate_master_signal(
             momentum_analysis, llm_analysis, sentiment_analysis, tft_prediction,
-            timeframe, strategy_mode
+            timeframe, strategy_mode, gap_pct
         )
         
         # 6. Options Strategy - FIXED FUNCTION NAME
@@ -321,7 +338,8 @@ async def analyze_agent():
 
 def _generate_master_signal(momentum_analysis: Dict, llm_analysis: Dict, 
                           sentiment_analysis: Dict, tft_prediction: Dict,
-                          timeframe: str = "15m", strategy_mode: str = "momentum") -> Dict:
+                          timeframe: str = "15m", strategy_mode: str = "momentum",
+                          gap_pct: float = None) -> Dict:
     """Generate master trading signal from all analyses - FIXED VERSION"""
     
     # Extract signals
@@ -337,28 +355,50 @@ def _generate_master_signal(momentum_analysis: Dict, llm_analysis: Dict,
     tft_direction = tft_prediction.get("expected_direction", "FLAT") if tft_prediction else "FLAT"
     
     # TIMEFRAME-SPECIFIC THRESHOLDS
+    #
+    # min_confidence was 70/65/60/55 and was UNREACHABLE. weighted_confidence is a weighted
+    # mean of three components whose own ceilings are far below 100 (the rule-based LLM
+    # fallback tops out at 65; sentiment abstains almost always), so the quantity being
+    # tested never approached the numbers it was tested against. Measured over 80
+    # observations -- 20 symbols x 4 timeframes, 2026-09-07, VIX ~14.5 -- the distribution
+    # was min 17 / p50 33 / p75 35 / p90 38 / MAX 47. The old vector therefore fired on
+    # 0 of 80. Not "strict": impossible. That single fact is why the app answered HOLD for
+    # every symbol, and why every timeframe and strategy looked identical.
+    #
+    # The replacement is each timeframe's gate placed at a percentile of that measured
+    # distribution -- roughly p90/p85/p75/p60 -- preserving the original ordering (a faster
+    # trade must clear a higher bar). It fires on 10% of the sample; HOLD stays the answer
+    # 90% of the time, which is the honest base rate for "is there a trade right now".
+    #
+    # This is CALIBRATION, NOT INFLATION: the score thresholds below are untouched, the
+    # component weights are untouched, and a gate that fires 10% of the time is still a
+    # demanding one. The distinction from cosmetically widening the spread is that the old
+    # value was not a strict threshold, it was a broken one.
+    #
+    # Re-measure with tools/calibrate_confidence_gate.py if the regime changes -- this
+    # sample is one quiet-tape snapshot, and a high-VIX tape will shift it.
     timeframe_configs = {
         "1m": {
             "threshold": 0.2,
-            "min_confidence": 70,
+            "min_confidence": 40,
             "hold_time": "1-2 minutes",
             "position_multiplier": 0.5
         },
         "5m": {
             "threshold": 0.25,
-            "min_confidence": 65,
+            "min_confidence": 38,
             "hold_time": "2-5 minutes",
             "position_multiplier": 0.7
         },
         "15m": {
             "threshold": 0.3,
-            "min_confidence": 60,
+            "min_confidence": 36,
             "hold_time": "10-30 minutes",
             "position_multiplier": 1.0
         },
         "1h": {
             "threshold": 0.35,
-            "min_confidence": 55,
+            "min_confidence": 34,
             "hold_time": "30-60 minutes",
             "position_multiplier": 1.2
         }
@@ -367,16 +407,35 @@ def _generate_master_signal(momentum_analysis: Dict, llm_analysis: Dict,
     config = timeframe_configs.get(timeframe, timeframe_configs["15m"])
     
     # STRATEGY MODE ADJUSTMENTS
+    gap_note = None
     if strategy_mode == "scalp":
         config["threshold"] *= 0.8
         config["hold_time"] = "1-3 minutes"
-    elif strategy_mode == "gap" and tft_prediction:
-        if tft_direction != "FLAT" and tft_prediction.get("gap_probability", 50) > 70:
+    elif strategy_mode == "gap":
+        # Gated on a MEASURED overnight gap, not the TFT's gap_probability -- that value
+        # sits at ~67.1 for every symbol and never cleared its own >70 test, so this
+        # branch never once executed. 0.5% is the floor for "a gap rather than noise".
+        # When no gap qualifies the mode now SAYS SO in the reasoning; the old failure was
+        # that it did nothing silently, which is indistinguishable from working.
+        if gap_pct is None:
+            gap_note = "Gap mode: no daily history to measure a gap"
+        elif abs(gap_pct) >= 0.5:
             config["min_confidence"] -= 10
+            config["hold_time"] = "Gap fill / continuation"
+            gap_note = f"Gap mode: {gap_pct:+.2f}% overnight gap qualifies"
+        else:
+            gap_note = f"Gap mode: {gap_pct:+.2f}% overnight, below the 0.5% floor"
     
     # Calculate weighted score
     if momentum_strategy in ["AGGRESSIVE_SCALP", "STANDARD_MOMENTUM"]:
-        weighted_score = momentum_master.get("conviction", 0)
+        # conviction is a MAGNITUDE and is never negative, so this branch used to make
+        # `weighted_score < -threshold` unreachable: it could emit CALLS or HOLD and never
+        # PUTS, for any input. The engine now carries a signed direction, and the sign is
+        # applied here. A strong move with no agreed direction scores 0 and falls to HOLD,
+        # which is the honest reading of "something is happening but not which way".
+        _dir = momentum_master.get("direction", "NEUTRAL")
+        _sign = 1.0 if _dir == "BULLISH" else -1.0 if _dir == "BEARISH" else 0.0
+        weighted_score = momentum_master.get("conviction", 0) * _sign
         weighted_confidence = momentum_confidence
     else:
         # The TFT term was REMOVED from this weighting on 2026-09-06, after measuring it.
@@ -438,12 +497,24 @@ def _generate_master_signal(momentum_analysis: Dict, llm_analysis: Dict,
         llm_conf = llm_analysis.get("conviction")
         if llm_conf is None:
             llm_conf = llm_analysis.get("confidence", 50)
+
+        # A component with NO READING is now EXCLUDED and the remaining weights are
+        # renormalised -- it is not scored as "0% confident".
+        #
+        # sentiment confidence is LOW unless std_dev < 0.2 AND mean_abs > 0.3, which
+        # headline sentiment essentially never satisfies. Averaging that in as a zero
+        # spent 30% of the confidence budget on a permanent 0, capping weighted_confidence
+        # at 70 even for a flawless setup and pinning the observed output in a 23-27 band.
+        # This is the same correction already applied to the TFT weights above: a term
+        # that has nothing to say should abstain, not vote zero.
+        components = [(momentum_confidence, 0.4), (llm_conf, 0.3)]
         sent_conf = {"HIGH": 80, "MEDIUM": 40}.get(
-            sentiment_analysis.get("confidence", "LOW"), 0)
+            sentiment_analysis.get("confidence", "LOW"))
+        if sent_conf is not None:
+            components.append((sent_conf, 0.3))
 
-        weighted_confidence = (momentum_confidence * 0.4 +
-                               llm_conf * 0.3 +
-                               sent_conf * 0.3)
+        _wsum = sum(w for _, w in components)
+        weighted_confidence = sum(v * w for v, w in components) / _wsum
     
     # Generate final signal
     if weighted_score > config["threshold"] and weighted_confidence > config["min_confidence"]:
@@ -466,8 +537,10 @@ def _generate_master_signal(momentum_analysis: Dict, llm_analysis: Dict,
         reasoning.append(f"Momentum: {momentum_strategy}")
     if abs(sentiment_composite) > 0.3:
         reasoning.append(f"Sentiment: {'Bullish' if sentiment_composite > 0 else 'Bearish'}")
-    if tft_prediction and tft_prediction.get("gap_probability", 50) > 70:
-        reasoning.append(f"Gap probability: {tft_prediction['gap_probability']:.0f}%")
+    if gap_note:
+        reasoning.append(gap_note)
+    elif gap_pct is not None and abs(gap_pct) >= 0.5:
+        reasoning.append(f"Overnight gap {gap_pct:+.2f}%")
     
     return {
         "signal": final_signal,
@@ -478,7 +551,8 @@ def _generate_master_signal(momentum_analysis: Dict, llm_analysis: Dict,
         "hold_time": config["hold_time"],
         "weighted_score": weighted_score,
         "strategy_mode": strategy_mode,
-        "momentum_strategy": momentum_strategy
+        "momentum_strategy": momentum_strategy,
+        "overnight_gap_pct": gap_pct
     }
 
 def _generate_options_strategy(master_signal: Dict, momentum_analysis: Dict, 

trade_analysis/momentum_trading_engine.py

@@ -10,6 +10,40 @@ import asyncio
 import warnings
 warnings.filterwarnings("ignore")
 
+# Direction gates, set by PERMUTATION TEST on real bars, not by eye.
+# Reproduce with tools/calibrate_direction_gate.py.
+#
+# Shuffling a real series' returns destroys any persistent trend while keeping its volume
+# profile, volatility and bar geometry -- so whatever the engine emits on the shuffled
+# version is a false positive, and real-fire-rate / permuted-fire-rate is its lift over
+# noise. 20 symbols x 4 timeframes, 6 permutations each (480 noise observations):
+#
+#     dead   agr   FPR(perm)  fire(real)   lift
+#     0.15   0.60      14.4%       10.0%   0.70   <- the ORIGINAL behaviour
+#     0.25   0.60      10.8%        8.8%   0.81
+#     0.35   0.60       7.3%        8.8%   1.20
+#     0.40   0.60       5.2%        8.8%   1.68
+#  >  0.40   0.75       4.8%        8.8%   1.83   <- chosen
+#     0.45   0.75       2.5%        6.2%   2.50
+#     0.50   0.75       1.2%        3.8%   3.00
+#
+# READ THE FIRST ROW. With a +-0.15 deadband and no agreement requirement -- which is what
+# this engine effectively had, since direction was not consulted at all -- it fires MORE
+# often on shuffled data than on real data. A lift below 1.0 is worse than useless: it is
+# an engine that prefers noise. Lift only crosses 1.0 around a 0.35 deadband.
+#
+# 0.40/0.75 is chosen as the point where lift is meaningfully above 1 while the signal
+# still fires often enough to be worth showing. Tightening to 0.50 does reach 3.0x lift,
+# but on 3.8% of 80 real observations that is three firings, and a lift estimated from
+# three events is not a measurement.
+#
+# HONEST LIMITATION: 1.83x over shuffled noise is a MODEST edge, and this sample is one
+# quiet-tape snapshot with n=80 on the real side. It is enough to say the engine is not
+# reading noise; it is NOT enough to claim a tradeable edge, and nothing here has been
+# tested against forward returns. Do not present it as more than it is.
+DIRECTION_DEADBAND = 0.40
+DIRECTION_AGREEMENT = 0.75
+
 class MomentumTradingEngine:
     """
     High-frequency momentum trading engine for options
@@ -57,13 +91,17 @@ class MomentumTradingEngine:
         }
     
     def analyze_momentum_setup(self, ohlcv_data: Dict, sentiment_data: Dict, 
-                             alternative_data: Dict) -> Dict:
+                             alternative_data: Dict, timeframe: str = '15m') -> Dict:
         """
         Analyze current momentum setup across multiple timeframes
         """
         setups = {}
-        
-        for timeframe, df in ohlcv_data.items():
+
+        # NOTE: the loop variable is `tf_key`, NOT `timeframe`. It used to be `timeframe`,
+        # which silently shadowed the parameter of the same name -- the master signal would
+        # then have been weighted by whatever key happened to be LAST in ohlcv_data rather
+        # than by the user's selection.
+        for tf_key, df in ohlcv_data.items():
             if df.empty:
                 continue
                 
@@ -81,16 +119,17 @@ class MomentumTradingEngine:
                 momentum_indicators, volume_profile, volatility_conditions, sentiment_data
             )
             
-            setups[timeframe] = {
+            setups[tf_key] = {
                 'momentum_score': momentum_score,
+                'direction_score': self._calculate_direction_score(momentum_indicators),
                 'indicators': momentum_indicators,
                 'volume_profile': volume_profile,
                 'volatility': volatility_conditions,
-                'trade_signal': self._generate_trade_signal(momentum_score, timeframe)
+                'trade_signal': self._generate_trade_signal(momentum_score, tf_key)
             }
         
         # Generate master signal from all timeframes
-        master_signal = self._generate_master_signal(setups, sentiment_data, alternative_data)
+        master_signal = self._generate_master_signal(setups, sentiment_data, alternative_data, timeframe)
         
         return {
             'timeframe_setups': setups,
@@ -141,6 +180,7 @@ class MomentumTradingEngine:
         return {
             'price_change_1min': price_change_1,
             'price_change_5min': price_change_5,
+            'price_change_10min': price_change_10,
             'velocity_1min': velocity_1min,
             'velocity_5min': velocity_5min,
             'momentum_strength': momentum_strength,
@@ -231,6 +271,30 @@ class MomentumTradingEngine:
             'volatility_trend': vol_trend
         }
     
+    def _calculate_direction_score(self, momentum_indicators: Dict) -> float:
+        """Signed direction in [-1, +1]. Negative is bearish.
+
+        _calculate_momentum_score is a pure MAGNITUDE -- every one of its terms is either
+        abs()-wrapped (directional_bias, acceleration, sentiment) or non-negative by
+        construction (velocity, volume ratio, volatility ratio). It answers "how much is
+        happening", never "which way". Because of that, _convert_signal_format below used
+        to hardcode `return 'CALLS'` for any momentum signal, with the comment "momentum
+        typically bullish for options": a stock breaking down hard scored HIGH momentum and
+        was reported as a CALLS setup. In enhanced_api the same defect made
+        `weighted_score = conviction` unconditionally positive, so `weighted_score <
+        -threshold` was unreachable and PUTS could never be emitted by that branch at all.
+
+        The direction was always available and simply thrown away -- directional_bias is
+        already normalised to [-1, +1], and the 5/10-bar price changes are signed. This
+        recovers it. The price-change terms saturate at +-2% because on intraday bars a 2%
+        drift is already a decisive move; without a cap a single gap would dominate.
+        """
+        bias = momentum_indicators.get('directional_bias', 0.0)
+        chg5 = momentum_indicators.get('price_change_5min', 0.0)
+        chg10 = momentum_indicators.get('price_change_10min', chg5)
+        sat = lambda x: max(-1.0, min(1.0, x * 50.0))   # +-2% -> +-1.0
+        return max(-1.0, min(1.0, bias * 0.5 + sat(chg5) * 0.3 + sat(chg10) * 0.2))
+
     def _calculate_momentum_score(self, momentum_indicators: Dict, volume_profile: Dict, 
                                 volatility_conditions: Dict, sentiment_data: Dict) -> float:
         """Calculate composite momentum score"""
@@ -314,30 +378,70 @@ class MomentumTradingEngine:
         }
     
     def _generate_master_signal(self, setups: Dict, sentiment_data: Dict, 
-                              alternative_data: Dict) -> Dict:
+                              alternative_data: Dict, timeframe: str = '15m') -> Dict:
         """Generate master trading signal from all timeframes"""
         
         if not setups:
-            return {'signal': 'NO_SIGNAL', 'conviction': 0, 'strategy': 'WAIT'}
-        
-        # Weight timeframes by importance for momentum trading
-        timeframe_weights = {
-            '15m': 0.5,    # Primary for scalping
-            'hourly': 0.3, # Secondary confirmation
-            'daily': 0.2   # Trend context
+            return {'signal': 'NO_SIGNAL', 'conviction': 0, 'strategy': 'WAIT',
+                    'direction': 'NEUTRAL', 'direction_score': 0.0}
+        
+        # These weights used to be hardcoded to {15m:.5, hourly:.3, daily:.2} and the
+        # user's selected timeframe never reached this function -- it only picked a
+        # threshold in enhanced_api. Every timeframe therefore analysed identical data and
+        # the selector was decorative. It now chooses which bars dominate the score.
+        #
+        # Each row sums to 1.0 and slides emphasis from the fastest available bars to the
+        # slowest. "1m" is an emphasis setting over 5m bars, not minute data -- see the
+        # note on TIMEFRAME_SPEC in data.py for why minute bars are not fetched.
+        TIMEFRAME_WEIGHTS = {
+            '1m':     {'5m': 0.60, '15m': 0.25, 'hourly': 0.10, 'daily': 0.05},
+            '5m':     {'5m': 0.45, '15m': 0.35, 'hourly': 0.15, 'daily': 0.05},
+            '15m':    {'5m': 0.15, '15m': 0.45, 'hourly': 0.25, 'daily': 0.15},
+            '1h':     {'5m': 0.05, '15m': 0.20, 'hourly': 0.45, 'daily': 0.30},
         }
+        timeframe_weights = TIMEFRAME_WEIGHTS.get(timeframe, TIMEFRAME_WEIGHTS['15m'])
         
         weighted_momentum = 0
+        weighted_direction = 0
         total_weight = 0
         
-        for timeframe, setup in setups.items():
-            weight = timeframe_weights.get(timeframe, 0.1)
+        for tf_key, setup in setups.items():
+            weight = timeframe_weights.get(tf_key, 0.1)
             momentum_score = setup.get('momentum_score', 0)
             
             weighted_momentum += momentum_score * weight
+            weighted_direction += setup.get('direction_score', 0.0) * weight
             total_weight += weight
         
         avg_momentum = weighted_momentum / total_weight if total_weight > 0 else 0
+        avg_direction = weighted_direction / total_weight if total_weight > 0 else 0
+
+        # Direction is carried alongside magnitude rather than collapsed into it, and it
+        # must clear TWO tests, not one.
+        #
+        # A deadband alone is not enough. directional_bias is measured over ~10 bars, so on
+        # a random walk its standard error is roughly 1/sqrt(10) = 0.32 -- a +-0.15 band is
+        # INSIDE the noise and gets cleared by chance more often than not. Measured on 600
+        # pure random walks with zero drift, deadband-only fired on 31.5% of them. A third
+        # of coin flips is not a signal.
+        #
+        # So the timeframes must also AGREE. Agreement is weighted by the same vector the
+        # user's timeframe selection chose, which is the point: picking "1m" means the fast
+        # bars carry the vote, and a 5m move that the hourly and daily contradict is a real
+        # disagreement rather than something to average away. Requiring 0.60 of the weight
+        # on one side is the classic multi-timeframe confirmation, and it is what separates
+        # a trend from a wiggle.
+        agree_weight = 0.0
+        for tf_key, setup in setups.items():
+            ds = setup.get('direction_score', 0.0)
+            if ds != 0 and avg_direction != 0 and (ds > 0) == (avg_direction > 0):
+                agree_weight += timeframe_weights.get(tf_key, 0.1)
+        agreement = agree_weight / total_weight if total_weight > 0 else 0.0
+
+        if abs(avg_direction) > DIRECTION_DEADBAND and agreement >= DIRECTION_AGREEMENT:
+            direction = 'BULLISH' if avg_direction > 0 else 'BEARISH'
+        else:
+            direction = 'NEUTRAL'
         
         # Apply sentiment and alternative data modifiers
         sentiment_boost = abs(sentiment_data.get('composite_score', 0)) * 0.2
@@ -349,6 +453,9 @@ class MomentumTradingEngine:
         if final_momentum > 0.6:
             return {
                 'signal': 'STRONG_MOMENTUM',
+                'direction': direction,
+                'direction_score': avg_direction,
+                'direction_agreement': agreement,
                 'conviction': min(final_momentum, 1.0),
                 'strategy': 'AGGRESSIVE_SCALP',
                 'timeframe': '5m',
@@ -356,7 +463,10 @@ class MomentumTradingEngine:
             }
         elif final_momentum > 0.4:
             return {
-                'signal': 'MODERATE_MOMENTUM', 
+                'signal': 'MODERATE_MOMENTUM',
+                'direction': direction,
+                'direction_score': avg_direction,
+                'direction_agreement': agreement, 
                 'conviction': final_momentum,
                 'strategy': 'STANDARD_MOMENTUM',
                 'timeframe': '15m',
@@ -365,6 +475,9 @@ class MomentumTradingEngine:
         elif final_momentum > 0.25:
             return {
                 'signal': 'WEAK_MOMENTUM',
+                'direction': direction,
+                'direction_score': avg_direction,
+                'direction_agreement': agreement,
                 'conviction': final_momentum,
                 'strategy': 'CAUTIOUS_ENTRY',
                 'timeframe': '30m',
@@ -373,6 +486,9 @@ class MomentumTradingEngine:
         else:
             return {
                 'signal': 'NO_MOMENTUM',
+                'direction': direction,
+                'direction_score': avg_direction,
+                'direction_agreement': agreement,
                 'conviction': 0,
                 'strategy': 'WAIT',
                 'timeframe': 'N/A',
@@ -530,20 +646,20 @@ class IntegratedMomentumEngine:
         self.momentum_engine = MomentumTradingEngine()
         
     def generate_enhanced_signal(self, market_data: Dict, sentiment_data: Dict, 
-                                alternative_data: Dict) -> Dict:
+                                alternative_data: Dict, timeframe: str = '15m') -> Dict:
         """
         Generate enhanced trading signal using momentum analysis
         """
         
         # Extract OHLCV data
         ohlcv_data = {}
-        for timeframe in ['15m', 'hourly', 'daily']:
-            if timeframe in market_data:
-                ohlcv_data[timeframe] = market_data[timeframe]
+        for tf_name in ['5m', '15m', 'hourly', 'daily']:
+            if tf_name in market_data:
+                ohlcv_data[tf_name] = market_data[tf_name]
         
         # Run momentum analysis
         momentum_analysis = self.momentum_engine.analyze_momentum_setup(
-            ohlcv_data, sentiment_data, alternative_data
+            ohlcv_data, sentiment_data, alternative_data, timeframe
         )
         
         # Generate options strategy
@@ -562,7 +678,8 @@ class IntegratedMomentumEngine:
         master_signal = momentum_analysis['master_signal']
         
         return {
-            'signal': self._convert_signal_format(master_signal['signal']),
+            'signal': self._convert_signal_format(master_signal['signal'],
+                                                  master_signal.get('direction', 'NEUTRAL')),
             'confidence': int(master_signal['conviction'] * 100),
             'reasoning': self._generate_reasoning(momentum_analysis),
             'position_size': master_signal['conviction'] * 0.5,  # Max 50% allocation
@@ -579,12 +696,20 @@ class IntegratedMomentumEngine:
                 return float(ohlcv_data[timeframe]['Close'].iloc[-1])
         return 400.0  # Default for QQQ
     
-    def _convert_signal_format(self, momentum_signal: str) -> str:
-        """Convert momentum signal to existing system format"""
-        if 'MOMENTUM' in momentum_signal:
-            return 'CALLS'  # Momentum typically bullish for options
-        else:
-            return 'HOLD'
+    def _convert_signal_format(self, momentum_signal: str, direction: str = 'NEUTRAL') -> str:
+        """Convert momentum signal to existing system format.
+
+        This used to be `if 'MOMENTUM' in momentum_signal: return 'CALLS'` -- the momentum
+        score is unsigned, so a violent SELL-off returned a CALLS setup. The engine now
+        carries a direction alongside the magnitude and this respects it; a strong move
+        with no agreed direction is HOLD rather than a coin-flip long.
+        """
+        if 'MOMENTUM' in momentum_signal and momentum_signal != 'NO_MOMENTUM':
+            if direction == 'BULLISH':
+                return 'CALLS'
+            if direction == 'BEARISH':
+                return 'PUTS'
+        return 'HOLD'
     
     def _generate_reasoning(self, momentum_analysis: Dict) -> str:
         """Generate human-readable reasoning"""