exp_1186

FORMULA_NAME = "Explore Regime Momentum Recovery Quality Hybrid (Conflict-Arbitrated Relay, v1186)"
LOGIC_VARIANT_COUNT = 4
NOTES = """mode=explore; family=regime-momentum-recovery-quality-hybrid
New hybrid family built as a conflict-arbitrated relay instead of a static blend: leadership momentum, repair-and-recovery, and quality-franchise defense each earn the right to lead only when their own confirmation tests pass, and the regime branch decides how harshly conflicting evidence is penalized. The explicit arbitration is stock-level: leadership is blocked when momentum outruns trend quality or volatility control, repair is blocked when drawdown lacks internal improvement, and defensive franchise names jump the queue when tape conditions are weak or dispersion is likely high.
Deliberate metric coverage this run: momentum actively uses 1m, 3m, 6m, and 12_1 with different sleeve roles; trend/recovery actively uses both 200d distance and 52-week-high distance; volatility is active through realized_vol_3m; liquidity actively uses avg_daily_dollar_volume_3m, avg_daily_volume_3m, and trading_days_3m; income actively uses dividend_yield_ttm_pct; valuation actively uses forward_pe and peg; growth actively uses revenue_growth_pct, forward_eps, and free_cash_flow_growth_pct; quality actively uses operating_margin_pct and free_cash_flow_margin_pct; size is deliberately active only as a mild market_cap stability tilt. Deliberate weight-0 metrics this run: return_12m_pct, dividend_ttm, pe, eps_growth_pct, operating_income_growth_pct, shares_outstanding, close, adj_close, high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, free_cash_flow_ttm.
"""


def score_universe(stocks, regime, ctx):
    def _iter_items(obj):
        if isinstance(obj, dict):
            items = []
            for k, v in obj.items():
                if isinstance(v, dict):
                    row = dict(v)
                    if "symbol" not in row:
                        row["symbol"] = k
                    items.append((row["symbol"], row))
            if items:
                return items
        items = []
        for row in obj:
            if isinstance(row, dict):
                sym = row.get("symbol") or row.get("ticker") or row.get("Symbol")
                if sym is not None:
                    items.append((sym, row))
        return items

    items = _iter_items(stocks)
    if not items:
        return {}

    def _to_num(v):
        if v is None or isinstance(v, bool):
            return None
        try:
            x = float(v)
        except Exception:
            return None
        if x != x:
            return None
        return x

    def _get(row, key):
        return _to_num(row.get(key))

    def _rank_map(metric, direction):
        vals = []
        for sym, row in items:
            v = _get(row, metric)
            if v is not None:
                vals.append((sym, v))
        if not vals:
            return {}
        vals.sort(key=lambda x: x[1], reverse=(direction > 0))
        n = len(vals)
        if n == 1:
            return {vals[0][0]: 1.0}
        out = {}
        i = 0
        while i < n:
            j = i + 1
            while j < n and vals[j][1] == vals[i][1]:
                j += 1
            rank = (i + (j - 1)) * 0.5
            score = 1.0 - (rank / (n - 1))
            for k in range(i, j):
                out[vals[k][0]] = score
            i = j
        return out

    rank_cache = {}

    def rk(metric, direction, sym):
        key = (metric, direction)
        if key not in rank_cache:
            rank_cache[key] = _rank_map(metric, direction)
        return rank_cache[key].get(sym, 0.5)

    def raw(metric, sym):
        for s, row in items:
            if s == sym:
                return _get(row, metric)
        return None

    def gate(cond, pass_value, fail_value):
        if cond is None:
            return (pass_value + fail_value) * 0.5
        return pass_value if cond else fail_value

    regime_text = str(regime if regime is not None else "").lower()
    if ctx is not None:
        regime_text += " " + str(ctx).lower()

    if any(tag in regime_text for tag in ("bull", "risk_on", "expansion", "uptrend")):
        branch = "expansion"
    elif any(tag in regime_text for tag in ("recovery", "rebound", "repair", "bottom")):
        branch = "recovery"
    elif any(tag in regime_text for tag in ("bear", "crash", "contraction", "stress", "panic")):
        branch = "contraction"
    else:
        branch = "caution"

    scores = {}
    for sym, row in items:
        mom_1m = rk("return_1m_pct", +1, sym)
        mom_3m = rk("return_3m_pct", +1, sym)
        mom_6m = rk("return_6m_pct", +1, sym)
        mom_12_1 = rk("momentum_12_1_pct", +1, sym)

        trend_200 = rk("from_200d_ma_pct", +1, sym)
        recover_52w = rk("from_52w_high_pct", +1, sym)
        low_vol = rk("realized_vol_3m", -1, sym)

        liq_dollar = rk("avg_daily_dollar_volume_3m", +1, sym)
        liq_share = rk("avg_daily_volume_3m", +1, sym)
        liq_days = rk("trading_days_3m", +1, sym)

        income = rk("dividend_yield_ttm_pct", +1, sym)
        cheap_fwd = rk("forward_pe", -1, sym)
        cheap_peg = rk("peg", -1, sym)

        growth_rev = rk("revenue_growth_pct", +1, sym)
        growth_fwd = rk("forward_eps", +1, sym)
        growth_fcf = rk("free_cash_flow_growth_pct", +1, sym)

        qual_op = rk("operating_margin_pct", +1, sym)
        qual_fcf = rk("free_cash_flow_margin_pct", +1, sym)
        size = rk("market_cap", +1, sym)

        trend_raw = raw("from_200d_ma_pct", sym)
        drawdown_raw = raw("from_52w_high_pct", sym)
        vol_raw = raw("realized_vol_3m", sym)
        rev_raw = raw("revenue_growth_pct", sym)
        fcf_margin_raw = raw("free_cash_flow_margin_pct", sym)
        op_margin_raw = raw("operating_margin_pct", sym)

        leadership_core = (
            0.25 * mom_12_1 +
            0.24 * mom_6m +
            0.18 * mom_3m +
            0.12 * mom_1m +
            0.11 * trend_200 +
            0.10 * low_vol
        )
        leadership_confirm = (
            0.45 * gate(trend_raw is not None and trend_raw > -5.0, 1.0, 0.2) +
            0.35 * gate(drawdown_raw is not None and drawdown_raw > -18.0, 1.0, 0.35) +
            0.20 * gate(vol_raw is not None and vol_raw < 55.0, 1.0, 0.45)
        )
        leadership = leadership_core * leadership_confirm + 0.06 * liq_dollar + 0.04 * liq_days

        repair_core = (
            0.22 * recover_52w +
            0.20 * trend_200 +
            0.16 * mom_3m +
            0.12 * mom_1m +
            0.10 * growth_rev +
            0.10 * growth_fcf +
            0.10 * qual_fcf
        )
        repair_setup = (
            0.40 * gate(drawdown_raw is not None and drawdown_raw < -12.0, 1.0, 0.30) +
            0.30 * gate(trend_raw is not None and trend_raw > -18.0, 1.0, 0.40) +
            0.30 * gate(
                (rev_raw is not None and rev_raw > 0.0) or
                (fcf_margin_raw is not None and fcf_margin_raw > 0.0),
                1.0,
                0.35,
            )
        )
        repair = repair_core * repair_setup + 0.05 * liq_share + 0.05 * low_vol

        franchise_core = (
            0.20 * qual_fcf +
            0.18 * qual_op +
            0.14 * cheap_fwd +
            0.12 * cheap_peg +
            0.10 * income +
            0.09 * growth_fwd +
            0.07 * growth_fcf +
            0.05 * liq_dollar +
            0.05 * liq_days
        )
        franchise_confirm = (
            0.35 * gate(op_margin_raw is not None and op_margin_raw > 0.0, 1.0, 0.45) +
            0.35 * gate(fcf_margin_raw is not None and fcf_margin_raw > 0.0, 1.0, 0.45) +
            0.30 * gate(vol_raw is not None and vol_raw < 60.0, 1.0, 0.55)
        )
        franchise = franchise_core * franchise_confirm + 0.05 * size

        conflict_penalty = 0.0
        if leadership > 0.72 and repair > 0.72 and (drawdown_raw is not None and drawdown_raw < -20.0):
            conflict_penalty += 0.08
        if leadership > 0.74 and franchise > 0.74 and (vol_raw is not None and vol_raw > 60.0):
            conflict_penalty += 0.07
        if repair > 0.72 and franchise > 0.72 and (rev_raw is not None and rev_raw < 0.0):
            conflict_penalty += 0.06

        if branch == "expansion":
            dominant = leadership
            challenger = max(repair, franchise)
            score = (
                0.62 * leadership +
                0.20 * repair +
                0.12 * franchise +
                0.03 * liq_dollar +
                0.03 * low_vol
            )
            score += 0.08 * max(0.0, dominant - challenger)
            score -= 0.10 * max(0.0, franchise - leadership) * gate(trend_raw is not None and trend_raw > 0.0, 0.2, 1.0)
        elif branch == "recovery":
            dominant = repair
            challenger = max(leadership, franchise)
            score = (
                0.50 * repair +
                0.24 * leadership +
                0.18 * franchise +
                0.04 * growth_rev +
                0.04 * qual_fcf
            )
            score += 0.10 * max(0.0, dominant - challenger)
            score -= 0.10 * gate(drawdown_raw is not None and drawdown_raw > -8.0, 1.0, 0.0)
        elif branch == "contraction":
            dominant = franchise
            challenger = max(leadership, repair)
            score = (
                0.58 * franchise +
                0.18 * repair +
                0.12 * leadership +
                0.07 * low_vol +
                0.05 * liq_days
            )
            score += 0.10 * max(0.0, dominant - challenger)
            score -= 0.11 * gate(vol_raw is not None and vol_raw > 70.0, 1.0, 0.0)
        else:
            dominant = max(leadership, repair, franchise)
            score = (
                0.36 * leadership +
                0.30 * repair +
                0.28 * franchise +
                0.03 * liq_dollar +
                0.03 * size
            )
            score += 0.06 * (dominant - min(leadership, repair, franchise))

        score -= conflict_penalty
        scores[sym] = score

    return scores