exp_1164

FORMULA_NAME = "Recovery Quality Contrarian 52-Week Hybrid (Quorum Ladder, v1164)"
LOGIC_VARIANT_COUNT = 4
NOTES = """mode=explore; family=recovery-quality-contrarian-52w-hybrid
New hybrid family that combines the strongest parent ideas with an explicit arbitration ladder instead of a flat blend: contrarian drawdown entry, repair confirmation, and sparse-fundamental durability each get a turn to lead only when their preconditions are met. Strong tapes let repaired names and shallow 52-week-high pullbacks outrank deep value traps; mixed tapes require a quality-plus-liquidity quorum before a turnaround can score; risk-off tapes only admit contrarian candidates if low-vol, income support, and tradability confirm durability. When contrarian drawdown and trend-repair disagree, the script resolves the conflict with a quorum gate rather than averaging both sides.
Deliberate metric coverage this run: use one short-horizon shakeout metric, one medium-horizon return, one momentum metric, both recovery distance metrics, volatility, all three liquidity metrics, both income metrics, two valuation metrics, three growth metrics, both quality metrics, and one explicit size tilt. Deliberate weight-0 metrics this run: return_3m_pct, return_12m_pct, pe, eps_growth_pct, revenue_growth_pct, shares_outstanding, close, adj_close, high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, free_cash_flow_ttm. Correlated momentum and valuation clusters are intentionally thinned, and sparse fundamentals are normalized by present weights so missing fields do not auto-zero a stock."""

def score_universe(stocks, regime, ctx):
    metrics = [
        "return_1m_pct",
        "return_6m_pct",
        "momentum_12_1_pct",
        "from_200d_ma_pct",
        "from_52w_high_pct",
        "realized_vol_3m",
        "avg_daily_volume_3m",
        "avg_daily_dollar_volume_3m",
        "trading_days_3m",
        "dividend_yield_ttm_pct",
        "dividend_ttm",
        "forward_pe",
        "peg",
        "operating_income_growth_pct",
        "free_cash_flow_growth_pct",
        "forward_eps",
        "operating_margin_pct",
        "free_cash_flow_margin_pct",
    ]
    zmap = {}
    for metric in metrics:
        zmap[metric] = ctx.z(metric)

    def raw(stock, key):
        return stock.get(key)

    def z(metric, symbol):
        vals = zmap.get(metric)
        if not vals:
            return None
        return vals.get(symbol)

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

    def blend(symbol, spec):
        total = 0.0
        used = 0.0
        for metric, weight, sign in spec:
            val = z(metric, symbol)
            if val is None:
                continue
            total += weight * sign * clamp(val, -3.0, 3.0)
            used += weight
        if used == 0.0:
            return 0.0
        return total / used

    def size_tilt(stock, prefer_small):
        cap = raw(stock, "market_cap")
        if cap is None or cap <= 0:
            return 0.0
        if cap <= 4.0e9:
            base = 1.0
        elif cap <= 1.2e10:
            base = 0.55
        elif cap <= 3.0e10:
            base = 0.10
        elif cap <= 9.0e10:
            base = -0.20
        else:
            base = -0.55
        return base if prefer_small else -base

    def liquidity_score(stock, symbol):
        score = 0.0
        count = 0.0

        adv = raw(stock, "avg_daily_dollar_volume_3m")
        if adv is not None:
            count += 1.0
            if adv >= 2.0e7:
                score += 1.0
            elif adv >= 7.0e6:
                score += 0.7
            elif adv >= 2.0e6:
                score += 0.4

        av = raw(stock, "avg_daily_volume_3m")
        if av is not None:
            count += 1.0
            if av >= 2.5e6:
                score += 1.0
            elif av >= 8.0e5:
                score += 0.7
            elif av >= 2.0e5:
                score += 0.4

        td = raw(stock, "trading_days_3m")
        if td is not None:
            count += 1.0
            if td >= 62:
                score += 1.0
            elif td >= 59:
                score += 0.7
            elif td >= 56:
                score += 0.35

        if count == 0.0:
            return 0.0
        return score / count

    def quality_quorum(stock, symbol):
        score = 0.0
        count = 0.0
        for metric in [
            "operating_margin_pct",
            "free_cash_flow_margin_pct",
            "operating_income_growth_pct",
            "free_cash_flow_growth_pct",
            "forward_eps",
        ]:
            val = z(metric, symbol)
            if val is None:
                continue
            count += 1.0
            if val > 0.35:
                score += 1.0
            elif val > -0.15:
                score += 0.5
        if count == 0.0:
            return 0.0
        return score / count

    def income_support(stock, symbol):
        return blend(symbol, [
            ("dividend_yield_ttm_pct", 0.65, 1),
            ("dividend_ttm", 0.35, 1),
        ])

    def valuation_relief(stock, symbol):
        return blend(symbol, [
            ("forward_pe", 0.55, -1),
            ("peg", 0.45, -1),
        ])

    def repair_strength(stock, symbol):
        return blend(symbol, [
            ("from_200d_ma_pct", 0.36, 1),
            ("return_6m_pct", 0.24, 1),
            ("momentum_12_1_pct", 0.22, 1),
            ("return_1m_pct", 0.18, -1),
        ])

    def quality_strength(stock, symbol):
        return blend(symbol, [
            ("operating_margin_pct", 0.22, 1),
            ("free_cash_flow_margin_pct", 0.18, 1),
            ("operating_income_growth_pct", 0.16, 1),
            ("free_cash_flow_growth_pct", 0.16, 1),
            ("forward_eps", 0.12, 1),
            ("forward_pe", 0.10, -1),
            ("peg", 0.06, -1),
        ])

    def risk_strength(stock, symbol):
        return blend(symbol, [
            ("realized_vol_3m", 0.55, -1),
            ("avg_daily_dollar_volume_3m", 0.20, 1),
            ("avg_daily_volume_3m", 0.10, 1),
            ("trading_days_3m", 0.15, 1),
        ])

    def drawdown_shape(stock, symbol):
        dd = raw(stock, "from_52w_high_pct")
        if dd is None:
            return 0.0
        if dd > -4.0:
            return -0.40
        if dd > -10.0:
            return 0.20
        if dd > -22.0:
            return 1.00
        if dd > -35.0:
            return 0.85
        if dd > -48.0:
            return 0.35
        if dd > -65.0:
            return -0.05
        return -0.45

    def deep_contrarian_strength(stock, symbol):
        base = drawdown_shape(stock, symbol)
        z52 = z("from_52w_high_pct", symbol)
        if z52 is None:
            return base
        return 0.65 * base + 0.35 * clamp(-z52, -3.0, 3.0) / 2.0

    bull = regime.get("bull", 0.0)
    breadth = regime.get("breadth", 0.0)
    median_mom = regime.get("median_momentum_12_1_pct", 0.0)
    median_repair = regime.get("median_from_200d_ma_pct", 0.0)
    avg_vol = regime.get("avg_realized_vol_3m", 0.0)

    if bull >= 0.74 and breadth >= 0.60 and median_mom >= 5.0:
        branch = 0
    elif bull >= 0.56 and breadth >= 0.46 and median_repair >= -2.0:
        branch = 1
    elif bull >= 0.40 and breadth >= 0.36:
        branch = 2
    else:
        branch = 3

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

        liq = liquidity_score(stock, symbol)
        quorum = quality_quorum(stock, symbol)
        repair = repair_strength(stock, symbol)
        quality = quality_strength(stock, symbol)
        risk = risk_strength(stock, symbol)
        contrarian = deep_contrarian_strength(stock, symbol)
        income = income_support(stock, symbol)
        value = valuation_relief(stock, symbol)

        dd = raw(stock, "from_52w_high_pct")
        above_200 = raw(stock, "from_200d_ma_pct")
        one_month = raw(stock, "return_1m_pct")

        knife_penalty = 0.0
        if dd is not None and dd < -52.0 and (above_200 is None or above_200 < -8.0):
            knife_penalty -= 0.55
        if repair < -0.35 and contrarian > 0.55:
            knife_penalty -= 0.35

        quality_gate = 0.0
        if quorum >= 0.66:
            quality_gate += 0.25
        elif quorum <= 0.20:
            quality_gate -= 0.25

        liquidity_gate = 0.0
        if liq >= 0.72:
            liquidity_gate += 0.18
        elif liq <= 0.28:
            liquidity_gate -= 0.30

        pullback_bonus = 0.0
        if one_month is not None:
            if -10.0 <= one_month <= -1.0:
                pullback_bonus += 0.18
            elif one_month > 12.0:
                pullback_bonus -= 0.12

        if branch == 0:
            repaired_leader = 0.0
            if repair > 0.20:
                repaired_leader = 0.22
            shallow_contrarian = 0.0
            if dd is not None and -24.0 <= dd <= -8.0 and (above_200 is None or above_200 > -2.0):
                shallow_contrarian = 0.18

            score = (
                0.34 * repair +
                0.23 * contrarian +
                0.15 * quality +
                0.10 * risk +
                0.08 * value +
                0.05 * income +
                0.05 * size_tilt(stock, True) +
                repaired_leader +
                shallow_contrarian +
                0.5 * pullback_bonus +
                quality_gate +
                liquidity_gate +
                knife_penalty
            )

        elif branch == 1:
            arbitration = 0.0
            if repair >= 0.10 and contrarian >= 0.25:
                arbitration += 0.24
            elif contrarian > 0.55 and quorum < 0.45:
                arbitration -= 0.28
            elif repair < -0.10 and contrarian > 0.35:
                arbitration -= 0.18

            score = (
                0.30 * repair +
                0.24 * contrarian +
                0.20 * quality +
                0.10 * risk +
                0.06 * value +
                0.05 * income +
                0.05 * size_tilt(stock, True) +
                arbitration +
                pullback_bonus +
                quality_gate +
                liquidity_gate +
                knife_penalty
            )

        elif branch == 2:
            turnaround_pass = 0.0
            if quorum >= 0.50 and liq >= 0.55:
                turnaround_pass += 0.20
            else:
                turnaround_pass -= 0.25

            if dd is not None and dd < -45.0 and quorum < 0.60:
                turnaround_pass -= 0.25
            if above_200 is not None and above_200 > 3.0:
                turnaround_pass += 0.12

            score = (
                0.27 * quality +
                0.24 * repair +
                0.18 * contrarian +
                0.12 * risk +
                0.08 * value +
                0.06 * income +
                0.05 * size_tilt(stock, False) +
                turnaround_pass +
                0.4 * pullback_bonus +
                quality_gate +
                liquidity_gate +
                knife_penalty
            )

        else:
            survivability = 0.0
            if risk > 0.10 and liq >= 0.60:
                survivability += 0.20
            else:
                survivability -= 0.25
            if quorum >= 0.55:
                survivability += 0.15
            if income > 0.05:
                survivability += 0.10
            if contrarian > 0.45 and repair < 0.0:
                survivability -= 0.22

            score = (
                0.28 * risk +
                0.24 * quality +
                0.14 * repair +
                0.12 * income +
                0.08 * value +
                0.08 * contrarian +
                0.06 * size_tilt(stock, False) +
                survivability +
                0.3 * quality_gate +
                liquidity_gate +
                knife_penalty
            )

        scores[symbol] = score

    return scores