exp_1161

FORMULA_NAME = "Recovery Quality Contrarian 52W Regime Momentum Hybrid (Ticket Arbitration, v1161)"
LOGIC_VARIANT_COUNT = 4
NOTES = """mode=explore; family=recovery-quality-contrarian-52w-regime-momentum-hybrid
New hybrid family built as a ticket-arbitration market rather than a blended sleeve: each stock competes as a momentum leader, repaired rebound, deep-contrarian survivor, or defensive franchise, and the regime branch only changes which tickets are allowed to win. This preserves what each parent family is good at while making conflicts explicit: deep drawdowns do not score unless repair evidence and franchise quality confirm, and momentum leadership is demoted when the tape or the stock still looks broken.
Deliberate metric coverage this run: active momentum uses return_1m_pct, return_3m_pct, return_6m_pct, return_12m_pct, and momentum_12_1_pct; trend/recovery uses from_200d_ma_pct and from_52w_high_pct; volatility uses realized_vol_3m; liquidity uses avg_daily_volume_3m, avg_daily_dollar_volume_3m, and trading_days_3m; income uses dividend_yield_ttm_pct and dividend_ttm; valuation rotates to pe and peg while deliberately zeroing forward_pe; growth rotates to eps_growth_pct, revenue_growth_pct, and forward_eps while deliberately zeroing operating_income_growth_pct and free_cash_flow_growth_pct; quality uses operating_margin_pct and free_cash_flow_margin_pct; size is used only through market_cap gates, never as a raw z-score. Deliberate weight-0 metrics this run: forward_pe, 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):
    z_cache = {}

    def z(metric, symbol):
        series = z_cache.get(metric)
        if series is None:
            series = ctx.z(metric)
            z_cache[metric] = series
        if not series:
            return None
        return series.get(symbol)

    def blend(symbol, terms):
        total = 0.0
        used = 0.0
        for metric, weight, sign in terms:
            value = z(metric, symbol)
            if value is None:
                continue
            total += weight * sign * value
            used += weight
        if used <= 0.0:
            return 0.0
        return total / used

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

    breadth = regime.get("breadth")
    avg_vol = regime.get("avg_realized_vol_3m")
    median_momo = regime.get("median_momentum_12_1_pct")
    median_200d = regime.get("median_from_200d_ma_pct")

    if breadth is None:
        breadth = 0.5
    if avg_vol is None:
        avg_vol = 32.0
    if median_momo is None:
        median_momo = 0.0
    if median_200d is None:
        median_200d = 0.0

    if regime.get("bull") and breadth >= 0.64 and median_momo >= 2.0 and median_200d >= 1.0 and avg_vol <= 30.0:
        branch = "launch"
    elif breadth >= 0.53 and median_200d >= -1.5 and avg_vol <= 36.0:
        branch = "rotation"
    elif breadth >= 0.40 and median_200d >= -8.0 and avg_vol <= 46.0:
        branch = "repair"
    else:
        branch = "storm"

    scores = {}
    for stock in stocks:
        symbol = stock["symbol"]

        leader = blend(symbol, [
            ("momentum_12_1_pct", 0.26, +1),
            ("return_6m_pct", 0.22, +1),
            ("return_12m_pct", 0.14, +1),
            ("return_3m_pct", 0.12, +1),
            ("from_200d_ma_pct", 0.12, +1),
            ("from_52w_high_pct", 0.07, +1),
            ("realized_vol_3m", 0.07, -1),
        ])

        repair = blend(symbol, [
            ("from_200d_ma_pct", 0.24, +1),
            ("from_52w_high_pct", 0.18, -1),
            ("return_1m_pct", 0.11, +1),
            ("return_3m_pct", 0.17, +1),
            ("return_6m_pct", 0.10, +1),
            ("realized_vol_3m", 0.08, -1),
            ("avg_daily_dollar_volume_3m", 0.07, +1),
            ("trading_days_3m", 0.05, +1),
        ])

        contrarian = blend(symbol, [
            ("from_52w_high_pct", 0.24, -1),
            ("return_12m_pct", 0.20, -1),
            ("return_1m_pct", 0.12, -1),
            ("pe", 0.12, -1),
            ("peg", 0.12, -1),
            ("eps_growth_pct", 0.08, +1),
            ("revenue_growth_pct", 0.06, +1),
            ("avg_daily_volume_3m", 0.06, +1),
        ])

        franchise = blend(symbol, [
            ("operating_margin_pct", 0.21, +1),
            ("free_cash_flow_margin_pct", 0.21, +1),
            ("forward_eps", 0.12, +1),
            ("eps_growth_pct", 0.12, +1),
            ("revenue_growth_pct", 0.10, +1),
            ("dividend_ttm", 0.08, +1),
            ("dividend_yield_ttm_pct", 0.08, +1),
            ("pe", 0.04, -1),
            ("peg", 0.04, -1),
        ])

        stability = blend(symbol, [
            ("realized_vol_3m", 0.30, -1),
            ("avg_daily_dollar_volume_3m", 0.24, +1),
            ("trading_days_3m", 0.18, +1),
            ("dividend_yield_ttm_pct", 0.10, +1),
            ("operating_margin_pct", 0.10, +1),
            ("free_cash_flow_margin_pct", 0.08, +1),
        ])

        liquidity = blend(symbol, [
            ("avg_daily_dollar_volume_3m", 0.46, +1),
            ("avg_daily_volume_3m", 0.24, +1),
            ("trading_days_3m", 0.30, +1),
        ])

        from_200d = stock.get("from_200d_ma_pct")
        if from_200d is None:
            from_200d = -999.0
        from_high = stock.get("from_52w_high_pct")
        if from_high is None:
            from_high = -999.0
        ret_1m = stock.get("return_1m_pct")
        if ret_1m is None:
            ret_1m = 0.0
        ret_3m = stock.get("return_3m_pct")
        if ret_3m is None:
            ret_3m = -999.0
        ret_12m = stock.get("return_12m_pct")
        if ret_12m is None:
            ret_12m = 0.0
        realized_vol = stock.get("realized_vol_3m")
        if realized_vol is None:
            realized_vol = 999.0
        trading_days = stock.get("trading_days_3m")
        if trading_days is None:
            trading_days = 0.0
        market_cap = stock.get("market_cap")
        if market_cap is None:
            market_cap = 0.0

        near_high = from_high > -14.0
        trend_ok = from_200d > 0.0 and ret_3m > 0.0
        rebound = from_200d > -12.0 and ret_3m > 0.0 and ret_1m > -6.0
        deep_drawdown = from_high < -28.0
        hard_washout = deep_drawdown and ret_12m < 0.0
        quality_ok = franchise > -0.15
        strong_quality = franchise > 0.12
        liquid_ok = trading_days >= 45.0 and liquidity > -0.20
        large_cap = market_cap >= 12000000000.0
        microcap_risk = market_cap > 0.0 and market_cap < 1500000000.0

        leader_ticket = leader - 0.30
        if trend_ok and near_high and liquid_ok:
            leader_ticket = leader + 0.20 * franchise + 0.10 * stability

        repair_ticket = repair - 0.32
        if deep_drawdown and rebound and quality_ok and liquid_ok:
            repair_ticket = repair + 0.24 * franchise + 0.12 * stability

        contrarian_ticket = contrarian - 0.35
        if hard_washout and rebound and strong_quality and liquid_ok:
            contrarian_ticket = contrarian + 0.30 * repair + 0.16 * franchise + 0.08 * stability

        defense_ticket = stability - 0.18
        if quality_ok and liquid_ok:
            defense_ticket = stability + 0.34 * franchise + 0.14 * repair

        if branch == "launch":
            leader_ticket += 0.16
            repair_ticket += 0.03
            contrarian_ticket -= 0.10
            defense_ticket -= 0.02
        elif branch == "rotation":
            leader_ticket += 0.08
            repair_ticket += 0.11
            contrarian_ticket += 0.04
            defense_ticket += 0.03
        elif branch == "repair":
            leader_ticket -= 0.03
            repair_ticket += 0.16
            contrarian_ticket += 0.12
            defense_ticket += 0.06
        else:
            leader_ticket -= 0.12
            repair_ticket += 0.02
            contrarian_ticket -= 0.02
            defense_ticket += 0.16

        best_name = "leader"
        best_score = leader_ticket
        second_score = -999.0

        for name, value in (
            ("repair", repair_ticket),
            ("contrarian", contrarian_ticket),
            ("defense", defense_ticket),
        ):
            if value > best_score:
                second_score = best_score
                best_score = value
                best_name = name
            elif value > second_score:
                second_score = value

        if second_score < -900.0:
            second_score = 0.0

        conflict_penalty = 0.0
        if best_name == "leader" and (deep_drawdown or not trend_ok):
            conflict_penalty += 0.16
        if best_name == "repair" and not deep_drawdown:
            conflict_penalty += 0.10
        if best_name == "contrarian" and (not hard_washout or not strong_quality):
            conflict_penalty += 0.18
        if best_name == "defense" and branch == "launch" and leader > defense_ticket:
            conflict_penalty += 0.06

        if leader - repair > 1.0 and not near_high:
            conflict_penalty += 0.12 * (leader - repair)
        if repair - leader > 1.0 and near_high and ret_1m > 8.0:
            conflict_penalty += 0.10 * (repair - leader)
        if contrarian > leader + 0.9 and not rebound:
            conflict_penalty += 0.16
        if franchise < -0.30:
            conflict_penalty += 0.10 + 0.08 * (-franchise)
        if realized_vol > 58.0 and best_name != "leader":
            conflict_penalty += 0.08
        if microcap_risk and branch != "launch":
            conflict_penalty += 0.06
        if trading_days < 38.0:
            conflict_penalty += 0.10

        support_bonus = 0.08 * clamp(second_score, -0.5, 1.2)
        quality_bonus = 0.05 * clamp(franchise, -0.6, 1.0)
        liquidity_bonus = 0.04 * clamp(liquidity, -0.6, 1.0)

        score = best_score + support_bonus + quality_bonus + liquidity_bonus - conflict_penalty

        if best_name == "repair" and strong_quality:
            score += 0.05
        if best_name == "contrarian" and repair > 0.10:
            score += 0.05
        if best_name == "defense" and large_cap and branch == "storm":
            score += 0.05
        if best_name == "leader" and branch == "launch" and leader > 0.30:
            score += 0.04

        scores[symbol] = score

    return scores