exp_1172

FORMULA_NAME = "Explore Regime Momentum Recovery Quality Hybrid (Passport Arbitration, v1172)"
LOGIC_VARIANT_COUNT = 4
NOTES = """mode=explore; family=regime-momentum-recovery-quality-hybrid
This hybrid combines momentum leadership, repair-driven recovery, and durable quality carry through an explicit passport arbitration system rather than a static blend. Each stock competes for three passports: leader (trend-confirmed momentum), repair (damaged but repairing), and franchise (quality, value, income, low-vol carry). The active regime branch then decides which passport is allowed to dominate, and conflict is resolved with hard gates: damaged names cannot win on momentum alone, low-quality rallies cannot win on repair alone, and defensive franchises pre-empt both when tape quality weakens.
Deliberate metric coverage this run: momentum actively uses return_1m_pct, return_6m_pct, and momentum_12_1_pct, while return_3m_pct and return_12m_pct are deliberately zeroed; trend/recovery actively uses from_200d_ma_pct and from_52w_high_pct; volatility actively uses realized_vol_3m; liquidity actively uses avg_daily_volume_3m, avg_daily_dollar_volume_3m, and trading_days_3m; income rotates to dividend_ttm and deliberately zeros dividend_yield_ttm_pct; valuation rotates to pe and forward_pe while peg is deliberately zeroed; growth rotates to revenue_growth_pct and eps_growth_pct while forward_eps, operating_income_growth_pct, and free_cash_flow_growth_pct are deliberately zeroed; quality uses operating_margin_pct and free_cash_flow_margin_pct; size is used only as a light market_cap stability tilt, never as a dominant factor.
Deliberate weight-0 metrics this run: return_3m_pct, return_12m_pct, dividend_yield_ttm_pct, peg, forward_eps, operating_income_growth_pct, free_cash_flow_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 get_num(stock, key):
        value = stock.get(key)
        if value is None:
            return None
        if isinstance(value, bool):
            return 1.0 if value else 0.0
        if isinstance(value, (int, float)):
            return float(value)
        return None

    def clamp(x, lo, hi):
        if x < lo:
            return lo
        if x > hi:
            return hi
        return x

    def percentile_map(key, higher_better=True):
        pairs = []
        for stock in stocks:
            value = get_num(stock, key)
            if value is not None:
                pairs.append((stock["symbol"], value))
        result = {}
        n = len(pairs)
        if n == 0:
            return result
        pairs.sort(key=lambda item: item[1], reverse=higher_better)
        if n == 1:
            result[pairs[0][0]] = 1.0
            return result
        i = 0
        while i < n:
            j = i + 1
            while j < n and pairs[j][1] == pairs[i][1]:
                j += 1
            rank = 1.0 - ((i + j - 1) * 0.5) / (n - 1)
            k = i
            while k < j:
                result[pairs[k][0]] = rank
                k += 1
            i = j
        return result

    def regime_name(regime_obj):
        if isinstance(regime_obj, dict):
            parts = []
            for key in ("state", "name", "label", "regime", "trend", "market_regime", "risk"):
                value = regime_obj.get(key)
                if value is not None:
                    parts.append(str(value).lower())
            text = " ".join(parts)
        else:
            text = str(regime_obj).lower()

        if any(token in text for token in ("bear", "risk_off", "risk-off", "defensive", "crash", "stress", "weak")):
            return "defense"
        if any(token in text for token in ("recovery", "rebound", "repair", "turn", "bottom")):
            return "repair"
        if any(token in text for token in ("sideways", "mixed", "neutral", "range", "chop", "transition")):
            return "carry"
        return "leader"

    p_return_1m = percentile_map("return_1m_pct", True)
    p_return_6m = percentile_map("return_6m_pct", True)
    p_mom_12_1 = percentile_map("momentum_12_1_pct", True)
    p_from_200d = percentile_map("from_200d_ma_pct", True)
    p_from_52w = percentile_map("from_52w_high_pct", True)
    p_low_vol = percentile_map("realized_vol_3m", False)

    p_adv = percentile_map("avg_daily_volume_3m", True)
    p_addv = percentile_map("avg_daily_dollar_volume_3m", True)
    p_trading_days = percentile_map("trading_days_3m", True)

    p_dividend = percentile_map("dividend_ttm", True)
    p_pe = percentile_map("pe", False)
    p_forward_pe = percentile_map("forward_pe", False)

    p_rev_growth = percentile_map("revenue_growth_pct", True)
    p_eps_growth = percentile_map("eps_growth_pct", True)

    p_oper_margin = percentile_map("operating_margin_pct", True)
    p_fcf_margin = percentile_map("free_cash_flow_margin_pct", True)
    p_market_cap = percentile_map("market_cap", True)

    active_regime = regime_name(regime)
    scores = {}

    for stock in stocks:
        symbol = stock["symbol"]

        liquid = (
            0.40 * p_adv.get(symbol, 0.5) +
            0.40 * p_addv.get(symbol, 0.5) +
            0.20 * p_trading_days.get(symbol, 0.5)
        )

        quality = (
            0.48 * p_oper_margin.get(symbol, 0.5) +
            0.32 * p_fcf_margin.get(symbol, 0.5) +
            0.20 * p_market_cap.get(symbol, 0.5)
        )

        value_carry = (
            0.40 * p_pe.get(symbol, 0.5) +
            0.30 * p_forward_pe.get(symbol, 0.5) +
            0.30 * p_dividend.get(symbol, 0.5)
        )

        growth = (
            0.55 * p_rev_growth.get(symbol, 0.5) +
            0.45 * p_eps_growth.get(symbol, 0.5)
        )

        momentum = (
            0.34 * p_return_1m.get(symbol, 0.5) +
            0.33 * p_return_6m.get(symbol, 0.5) +
            0.33 * p_mom_12_1.get(symbol, 0.5)
        )

        trend = (
            0.60 * p_from_200d.get(symbol, 0.5) +
            0.40 * p_from_52w.get(symbol, 0.5)
        )

        low_vol = p_low_vol.get(symbol, 0.5)

        from_200d = get_num(stock, "from_200d_ma_pct")
        from_52w = get_num(stock, "from_52w_high_pct")

        above_200d = 0.5
        if from_200d is not None:
            above_200d = clamp((from_200d + 12.0) / 24.0, 0.0, 1.0)

        repair_depth = 0.5
        if from_52w is not None:
            drawdown = -from_52w
            repair_depth = 1.0 - clamp(abs(drawdown - 22.0) / 22.0, 0.0, 1.0)

        leader_passport = (
            0.40 * momentum +
            0.25 * trend +
            0.15 * quality +
            0.10 * growth +
            0.10 * liquid
        )
        if from_200d is not None and from_200d < -2.0:
            leader_passport -= 0.18
        if from_52w is not None and from_52w < -18.0:
            leader_passport -= 0.08

        repair_passport = (
            0.26 * repair_depth +
            0.22 * above_200d +
            0.18 * p_return_1m.get(symbol, 0.5) +
            0.12 * p_return_6m.get(symbol, 0.5) +
            0.12 * quality +
            0.10 * liquid
        )
        if from_52w is not None and from_52w > -5.0:
            repair_passport -= 0.12
        if from_200d is not None and from_200d < -8.0:
            repair_passport -= 0.16

        franchise_passport = (
            0.28 * quality +
            0.20 * value_carry +
            0.18 * low_vol +
            0.14 * liquid +
            0.10 * growth +
            0.10 * above_200d
        )
        if from_200d is not None and from_200d < -10.0:
            franchise_passport -= 0.10

        conflict_penalty = 0.0
        if momentum > 0.72 and repair_depth > 0.72 and quality < 0.42:
            conflict_penalty += 0.10
        if momentum < 0.40 and leader_passport > franchise_passport and low_vol < 0.35:
            conflict_penalty += 0.08
        if repair_depth < 0.30 and repair_passport > leader_passport:
            conflict_penalty += 0.08

        if active_regime == "leader":
            score = (
                0.58 * leader_passport +
                0.20 * franchise_passport +
                0.14 * repair_passport +
                0.08 * low_vol
            )
            if leader_passport < 0.48:
                score -= 0.10
            if quality > 0.62 and momentum > 0.62:
                score += 0.05
        elif active_regime == "repair":
            score = (
                0.50 * repair_passport +
                0.24 * leader_passport +
                0.18 * franchise_passport +
                0.08 * growth
            )
            if repair_depth < 0.35:
                score -= 0.08
            if above_200d > 0.58 and momentum > 0.55:
                score += 0.06
        elif active_regime == "carry":
            score = (
                0.44 * franchise_passport +
                0.28 * leader_passport +
                0.18 * repair_passport +
                0.10 * value_carry
            )
            if low_vol > 0.65 and quality > 0.60:
                score += 0.05
        else:
            score = (
                0.56 * franchise_passport +
                0.18 * repair_passport +
                0.14 * leader_passport +
                0.12 * low_vol
            )
            if low_vol < 0.35:
                score -= 0.10
            if liquid < 0.40:
                score -= 0.06

        if liquid < 0.25:
            score -= 0.20
        elif liquid > 0.70:
            score += 0.03

        score -= conflict_penalty
        scores[symbol] = score

    return scores