quantwise 1.2.0 → 1.2.2

package/.claude/skills/macro-regime-detector/scripts/tests/test_credit_conditions.py

@@ -0,0 +1,59 @@
+"""Tests for Credit Conditions Calculator (HYG/LQD)"""
+
+from calculators.credit_conditions_calculator import calculate_credit_conditions
+from test_helpers import make_monthly_history
+
+
+class TestCalculateCreditConditions:
+    def test_insufficient_data_empty(self):
+        result = calculate_credit_conditions([], [])
+        assert result["score"] == 0
+        assert result["data_available"] is False
+
+    def test_stable_ratio_low_score(self):
+        hyg = make_monthly_history([75] * 24, start_year=2024)
+        lqd = make_monthly_history([105] * 24, start_year=2024)
+        result = calculate_credit_conditions(hyg, lqd)
+        assert result["data_available"] is True
+        assert result["score"] <= 30  # Small noise from daily variation is expected
+
+    def test_easing_conditions(self):
+        # HYG rising relative to LQD = easing
+        hyg_closes = [70 + i * 0.5 for i in range(24)]
+        lqd_closes = [105] * 24
+        hyg = make_monthly_history(hyg_closes, start_year=2024)
+        lqd = make_monthly_history(lqd_closes, start_year=2024)
+        result = calculate_credit_conditions(hyg, lqd)
+        assert result["data_available"] is True
+
+    def test_tightening_conditions(self):
+        # HYG falling relative to LQD = tightening
+        hyg_closes = [80 - i * 0.5 for i in range(24)]
+        lqd_closes = [105] * 24
+        hyg = make_monthly_history(hyg_closes, start_year=2024)
+        lqd = make_monthly_history(lqd_closes, start_year=2024)
+        result = calculate_credit_conditions(hyg, lqd)
+        assert result["data_available"] is True
+
+    def test_output_structure(self):
+        hyg = make_monthly_history([75 + i * 0.1 for i in range(24)], start_year=2024)
+        lqd = make_monthly_history([105] * 24, start_year=2024)
+        result = calculate_credit_conditions(hyg, lqd)
+
+        required_keys = [
+            "score",
+            "signal",
+            "data_available",
+            "direction",
+            "current_ratio",
+            "sma_6m",
+            "sma_12m",
+            "roc_3m",
+            "roc_12m",
+            "percentile",
+            "crossover",
+            "monthly_points",
+        ]
+        for key in required_keys:
+            assert key in result
+        assert 0 <= result["score"] <= 100

package/.claude/skills/macro-regime-detector/scripts/tests/test_equity_bond.py

@@ -0,0 +1,74 @@
+"""Tests for Equity-Bond Relationship Calculator (SPY/TLT + correlation)"""
+
+from calculators.equity_bond_calculator import calculate_equity_bond
+from test_helpers import make_monthly_history
+
+
+class TestCalculateEquityBond:
+    def test_insufficient_data_empty(self):
+        result = calculate_equity_bond([], [])
+        assert result["score"] == 0
+        assert result["data_available"] is False
+
+    def test_stable_ratio_low_score(self):
+        spy = make_monthly_history([500] * 24, start_year=2024)
+        tlt = make_monthly_history([90] * 24, start_year=2024)
+        result = calculate_equity_bond(spy, tlt)
+        assert result["data_available"] is True
+        assert result["score"] <= 30  # Small noise from daily variation is expected
+
+    def test_risk_on_shift(self):
+        # SPY rising, TLT flat = risk-on
+        spy_closes = [500 + i * 5 for i in range(24)]
+        tlt_closes = [90] * 24
+        spy = make_monthly_history(spy_closes, start_year=2024)
+        tlt = make_monthly_history(tlt_closes, start_year=2024)
+        result = calculate_equity_bond(spy, tlt)
+        assert result["data_available"] is True
+
+    def test_risk_off_shift(self):
+        # SPY falling, TLT rising = risk-off
+        spy_closes = [600 - i * 5 for i in range(24)]
+        tlt_closes = [80 + i * 2 for i in range(24)]
+        spy = make_monthly_history(spy_closes, start_year=2024)
+        tlt = make_monthly_history(tlt_closes, start_year=2024)
+        result = calculate_equity_bond(spy, tlt)
+        assert result["data_available"] is True
+
+    def test_correlation_regime_present(self):
+        spy = make_monthly_history([500 + i * 2 for i in range(24)], start_year=2024)
+        tlt = make_monthly_history([90 - i * 0.5 for i in range(24)], start_year=2024)
+        result = calculate_equity_bond(spy, tlt)
+        assert result["correlation_regime"] in (
+            "negative_strong",
+            "negative_mild",
+            "near_zero",
+            "positive",
+            "unknown",
+        )
+
+    def test_output_structure(self):
+        spy = make_monthly_history([500 + i for i in range(24)], start_year=2024)
+        tlt = make_monthly_history([90] * 24, start_year=2024)
+        result = calculate_equity_bond(spy, tlt)
+
+        required_keys = [
+            "score",
+            "signal",
+            "data_available",
+            "direction",
+            "correlation_regime",
+            "current_ratio",
+            "sma_6m",
+            "sma_12m",
+            "roc_3m",
+            "roc_12m",
+            "percentile",
+            "correlation_6m",
+            "correlation_12m",
+            "crossover",
+            "monthly_points",
+        ]
+        for key in required_keys:
+            assert key in result
+        assert 0 <= result["score"] <= 100

package/.claude/skills/macro-regime-detector/scripts/tests/test_helpers.py

@@ -0,0 +1,90 @@
+"""Importable test helpers for Macro Regime Detector tests"""
+
+
+def make_daily_bar(close, volume=1000000, date="2026-01-15", open_=None, high=None, low=None):
+    """Helper to create a daily OHLCV bar dict."""
+    if open_ is None:
+        open_ = close
+    if high is None:
+        high = close * 1.005
+    if low is None:
+        low = close * 0.995
+    return {
+        "date": date,
+        "open": open_,
+        "high": high,
+        "low": low,
+        "close": close,
+        "adjClose": close,
+        "volume": volume,
+    }
+
+
+def make_history(closes, base_volume=1000000, start_date="2026-01-15"):
+    """Create a list of daily bars from a list of closes (most recent first)."""
+    bars = []
+    for i, close in enumerate(closes):
+        vol = base_volume + (i * 1000)
+        bars.append(
+            make_daily_bar(
+                close=close,
+                volume=vol,
+                date=f"day-{i}",
+            )
+        )
+    return bars
+
+
+def make_monthly_history(monthly_closes, start_year=2024, start_month=1):
+    """
+    Create daily history that downsamples to expected monthly points.
+
+    Each monthly close gets 20 daily bars in its month.
+    Monthly_closes should be in chronological order (oldest first).
+    Returns bars in most-recent-first order.
+    """
+    bars = []
+    for i, close in enumerate(monthly_closes):
+        month = start_month + i
+        year = start_year + (month - 1) // 12
+        m = ((month - 1) % 12) + 1
+
+        for day in range(1, 21):
+            daily_close = close * (1 + (day - 10) * 0.001)
+            date_str = f"{year:04d}-{m:02d}-{day:02d}"
+            bars.append(
+                make_daily_bar(
+                    close=daily_close,
+                    date=date_str,
+                    volume=1000000,
+                )
+            )
+
+    bars.reverse()
+    return bars
+
+
+def make_treasury_rates(spreads, start_year=2024, start_month=1):
+    """
+    Create treasury rate data from a list of 10Y-2Y spreads.
+    """
+    entries = []
+    for i, spread in enumerate(spreads):
+        month = start_month + i
+        year = start_year + (month - 1) // 12
+        m = ((month - 1) % 12) + 1
+
+        for day in range(1, 21):
+            date_str = f"{year:04d}-{m:02d}-{day:02d}"
+            year2 = 4.5 - spread / 2
+            year10 = 4.5 + spread / 2
+            entries.append(
+                {
+                    "date": date_str,
+                    "year2": str(round(year2, 2)),
+                    "year10": str(round(year10, 2)),
+                }
+            )
+
+    entries.reverse()
+    return entries

package/.claude/skills/macro-regime-detector/scripts/tests/test_scorer.py

@@ -0,0 +1,439 @@
+"""Tests for Macro Regime Detector Scorer"""
+
+from scorer import (
+    calculate_composite_score,
+    classify_regime,
+    check_regime_consistency,
+    COMPONENT_WEIGHTS,
+)
+
+
+class TestCalculateCompositeScore:
+    def test_all_zero_scores(self):
+        scores = {
+            "concentration": 0,
+            "yield_curve": 0,
+            "credit_conditions": 0,
+            "size_factor": 0,
+            "equity_bond": 0,
+            "sector_rotation": 0,
+        }
+        result = calculate_composite_score(scores)
+        assert result["composite_score"] == 0.0
+        assert "Green" in result["zone"] or "Stable" in result["zone"]
+
+    def test_all_max_scores(self):
+        scores = {
+            "concentration": 100,
+            "yield_curve": 100,
+            "credit_conditions": 100,
+            "size_factor": 100,
+            "equity_bond": 100,
+            "sector_rotation": 100,
+        }
+        result = calculate_composite_score(scores)
+        assert result["composite_score"] == 100.0
+
+    def test_weighted_calculation(self):
+        # Only concentration = 100, rest = 0 -> should be 25%
+        scores = {
+            "concentration": 100,
+            "yield_curve": 0,
+            "credit_conditions": 0,
+            "size_factor": 0,
+            "equity_bond": 0,
+            "sector_rotation": 0,
+        }
+        result = calculate_composite_score(scores)
+        assert result["composite_score"] == 25.0
+
+    def test_data_quality_tracking(self):
+        scores = {
+            "concentration": 50,
+            "yield_curve": 50,
+            "credit_conditions": 50,
+            "size_factor": 50,
+            "equity_bond": 50,
+            "sector_rotation": 50,
+        }
+        availability = {
+            "concentration": True,
+            "yield_curve": False,
+            "credit_conditions": True,
+            "size_factor": True,
+            "equity_bond": True,
+            "sector_rotation": True,
+        }
+        result = calculate_composite_score(scores, availability)
+        assert result["data_quality"]["available_count"] == 5
+        assert len(result["data_quality"]["missing_components"]) == 1
+
+    def test_strongest_weakest_signal(self):
+        scores = {
+            "concentration": 80,
+            "yield_curve": 10,
+            "credit_conditions": 50,
+            "size_factor": 30,
+            "equity_bond": 60,
+            "sector_rotation": 40,
+        }
+        result = calculate_composite_score(scores)
+        assert result["strongest_signal"]["component"] == "concentration"
+        assert result["weakest_signal"]["component"] == "yield_curve"
+
+    def test_signaling_count(self):
+        scores = {
+            "concentration": 50,  # signaling (>= 40)
+            "yield_curve": 60,  # signaling
+            "credit_conditions": 10,  # not signaling
+            "size_factor": 45,  # signaling
+            "equity_bond": 20,  # not signaling
+            "sector_rotation": 70,  # signaling
+        }
+        result = calculate_composite_score(scores)
+        assert result["signaling_components"] == 4
+
+    def test_zone_boundaries(self):
+        # Test each zone boundary
+        for score_val, expected_zone_part in [
+            (0, "Stable"),
+            (20, "Stable"),
+            (21, "Early"),
+            (40, "Early"),
+            (41, "Transition"),
+            (60, "Transition"),
+            (61, "Active"),
+            (80, "Active"),
+            (81, "Confirmed"),
+        ]:
+            scores = {
+                k: score_val
+                for k in [
+                    "concentration",
+                    "yield_curve",
+                    "credit_conditions",
+                    "size_factor",
+                    "equity_bond",
+                    "sector_rotation",
+                ]
+            }
+            result = calculate_composite_score(scores)
+            assert expected_zone_part in result["zone"], (
+                f"Score {score_val}: expected '{expected_zone_part}' in '{result['zone']}'"
+            )
+
+
+class TestClassifyRegime:
+    def _make_component(self, score=0, direction="unknown", **kwargs):
+        base = {
+            "score": score,
+            "signal": "test",
+            "data_available": True,
+            "direction": direction,
+            "crossover": {"type": "none", "bars_ago": None},
+        }
+        base.update(kwargs)
+        return base
+
+    def test_concentration_regime(self):
+        components = {
+            "concentration": self._make_component(60, "concentrating"),
+            "yield_curve": self._make_component(10, "stable"),
+            "credit_conditions": self._make_component(10, "stable"),
+            "size_factor": self._make_component(50, "large_cap_leading"),
+            "equity_bond": self._make_component(10, "neutral"),
+            "sector_rotation": self._make_component(10, "neutral"),
+        }
+        result = classify_regime(components)
+        assert result["current_regime"] == "concentration"
+
+    def test_broadening_regime(self):
+        components = {
+            "concentration": self._make_component(60, "broadening"),
+            "yield_curve": self._make_component(10, "steepening"),
+            "credit_conditions": self._make_component(10, "easing"),
+            "size_factor": self._make_component(50, "small_cap_leading"),
+            "equity_bond": self._make_component(10, "risk_on"),
+            "sector_rotation": self._make_component(50, "risk_on"),
+        }
+        result = classify_regime(components)
+        assert result["current_regime"] == "broadening"
+
+    def test_contraction_regime(self):
+        components = {
+            "concentration": self._make_component(10, "unknown"),
+            "yield_curve": self._make_component(10, "flattening"),
+            "credit_conditions": self._make_component(60, "tightening"),
+            "size_factor": self._make_component(10, "unknown"),
+            "equity_bond": self._make_component(50, "risk_off"),
+            "sector_rotation": self._make_component(60, "risk_off"),
+        }
+        result = classify_regime(components)
+        assert result["current_regime"] == "contraction"
+
+    def test_inflationary_regime(self):
+        components = {
+            "concentration": self._make_component(10, "unknown"),
+            "yield_curve": self._make_component(10, "steepening"),
+            "credit_conditions": self._make_component(10, "unknown"),
+            "size_factor": self._make_component(10, "unknown"),
+            "equity_bond": self._make_component(60, "risk_off", correlation_regime="positive"),
+            "sector_rotation": self._make_component(10, "neutral"),
+        }
+        result = classify_regime(components)
+        assert result["current_regime"] == "inflationary"
+
+    def test_transitional_regime(self):
+        # Many components signaling but no clear pattern
+        components = {
+            "concentration": self._make_component(50, "broadening"),
+            "yield_curve": self._make_component(50, "steepening"),
+            "credit_conditions": self._make_component(50, "tightening"),
+            "size_factor": self._make_component(50, "large_cap_leading"),
+            "equity_bond": self._make_component(50, "risk_off"),
+            "sector_rotation": self._make_component(50, "risk_off"),
+        }
+        result = classify_regime(components)
+        # With mixed signals, should be transitional or the strongest match
+        assert result["current_regime"] in (
+            "transitional",
+            "contraction",
+            "broadening",
+            "concentration",
+            "inflationary",
+        )
+
+    def test_confidence_levels(self):
+        # High confidence: many matching signals
+        components = {
+            "concentration": self._make_component(60, "concentrating"),
+            "yield_curve": self._make_component(10, "stable"),
+            "credit_conditions": self._make_component(10, "stable"),
+            "size_factor": self._make_component(50, "large_cap_leading"),
+            "equity_bond": self._make_component(10, "neutral"),
+            "sector_rotation": self._make_component(10, "neutral"),
+        }
+        result = classify_regime(components)
+        assert result["confidence"] in ("high", "moderate", "low", "very_low")
+
+    def test_transition_probability(self):
+        components = {
+            "concentration": self._make_component(60, "broadening"),
+            "yield_curve": self._make_component(50, "steepening"),
+            "credit_conditions": self._make_component(45, "easing"),
+            "size_factor": self._make_component(55, "small_cap_leading"),
+            "equity_bond": self._make_component(40, "risk_on"),
+            "sector_rotation": self._make_component(50, "risk_on"),
+        }
+        result = classify_regime(components)
+        tp = result["transition_probability"]
+        assert "level" in tp
+        assert "probability_range" in tp
+        assert "signaling_count" in tp
+        assert tp["level"] in ("high", "moderate", "low", "minimal")
+
+    def test_evidence_list(self):
+        components = {
+            "concentration": self._make_component(60, "broadening"),
+            "yield_curve": self._make_component(50, "steepening"),
+            "credit_conditions": self._make_component(10, "stable"),
+            "size_factor": self._make_component(10, "neutral"),
+            "equity_bond": self._make_component(10, "neutral"),
+            "sector_rotation": self._make_component(10, "neutral"),
+        }
+        result = classify_regime(components)
+        assert len(result["evidence"]) == 2  # Only 2 components >= 40
+        # Sorted by score descending
+        if len(result["evidence"]) >= 2:
+            assert result["evidence"][0]["score"] >= result["evidence"][1]["score"]
+
+    def test_unknown_credit_no_concentration_bias(self):
+        """Missing credit data should NOT bias toward Concentration regime."""
+        # All components with data_available=True but direction="unknown"
+        # means data exists but direction is unclear
+        components = {
+            "concentration": self._make_component(10, "unknown"),
+            "yield_curve": self._make_component(10, "stable"),
+            "credit_conditions": self._make_component(0, "unknown", data_available=False),
+            "size_factor": self._make_component(10, "unknown"),
+            "equity_bond": self._make_component(10, "neutral"),
+            "sector_rotation": self._make_component(10, "neutral"),
+        }
+        result = classify_regime(components)
+        # With no real signals, concentration should NOT get bonus from unknown credit
+        assert result["regime_scores"]["concentration"] == 0
+
+    def test_missing_data_caps_confidence(self):
+        """With 3 or fewer available components, confidence capped at very_low."""
+        components = {
+            "concentration": self._make_component(60, "concentrating"),
+            "yield_curve": self._make_component(0, "unknown", data_available=False),
+            "credit_conditions": self._make_component(0, "unknown", data_available=False),
+            "size_factor": self._make_component(60, "large_cap_leading"),
+            "equity_bond": self._make_component(0, "unknown", data_available=False),
+            "sector_rotation": self._make_component(0, "unknown", data_available=False),
+        }
+        result = classify_regime(components)
+        # Only 2 components available -> must be very_low confidence
+        assert result["confidence"] == "very_low"
+
+    def test_four_components_caps_at_low(self):
+        """With 4 available components, confidence capped at low."""
+        components = {
+            "concentration": self._make_component(60, "concentrating"),
+            "yield_curve": self._make_component(50, "steepening"),
+            "credit_conditions": self._make_component(0, "unknown", data_available=False),
+            "size_factor": self._make_component(60, "large_cap_leading"),
+            "equity_bond": self._make_component(50, "risk_on"),
+            "sector_rotation": self._make_component(0, "unknown", data_available=False),
+        }
+        result = classify_regime(components)
+        assert result["confidence"] in ("low", "very_low")
+
+    def test_unavailable_component_direction_ignored(self):
+        """Components with data_available=False should have direction treated as unknown."""
+        # Credit has direction="tightening" but data_available=False -> should be ignored
+        components = {
+            "concentration": self._make_component(10, "unknown"),
+            "yield_curve": self._make_component(10, "stable"),
+            "credit_conditions": self._make_component(60, "tightening", data_available=False),
+            "size_factor": self._make_component(10, "neutral"),
+            "equity_bond": self._make_component(10, "neutral"),
+            "sector_rotation": self._make_component(10, "neutral"),
+        }
+        result = classify_regime(components)
+        # Contraction should NOT score from unavailable credit data
+        assert result["regime_scores"]["contraction"] == 0
+
+    # --- Improvement 1: Tiebreak → Transitional ---
+
+    def test_tiebreak_broadening_contraction_becomes_transitional(self):
+        """Tied broadening=3, contraction=3, low composite → transitional."""
+        # broadening: conc broadening(+2) + credit easing(+1) = 3
+        # contraction: sector risk_off(+2) + eb risk_off(+1) = 3
+        # concentration: size large_cap? no, size=unknown -> 0
+        # inflationary: corr_regime unknown -> 0
+        components = {
+            "concentration": self._make_component(20, "broadening"),
+            "yield_curve": self._make_component(10, "stable"),
+            "credit_conditions": self._make_component(20, "easing"),
+            "size_factor": self._make_component(20, "unknown"),
+            "equity_bond": self._make_component(20, "risk_off"),
+            "sector_rotation": self._make_component(20, "risk_off"),
+        }
+        result = classify_regime(components)
+        # Low composite (all scores ~20) < 50 → tied → transitional
+        assert result["current_regime"] == "transitional"
+        assert result.get("tied_regimes") is not None
+        assert set(result["tied_regimes"]) == {"broadening", "contraction"}
+
+    def test_tiebreak_keeps_winner_high_composite(self):
+        """Tied but composite >= 50 → keeps top scorer (not forced transitional)."""
+        # Same tie but high individual scores
+        # broadening: conc broadening(+2) + credit easing(+1) = 3
+        # contraction: sector risk_off(+2) + eb risk_off(+1) = 3
+        components = {
+            "concentration": self._make_component(70, "broadening"),
+            "yield_curve": self._make_component(60, "stable"),
+            "credit_conditions": self._make_component(60, "easing"),
+            "size_factor": self._make_component(50, "unknown"),
+            "equity_bond": self._make_component(50, "risk_off"),
+            "sector_rotation": self._make_component(50, "risk_off"),
+        }
+        result = classify_regime(components)
+        # Composite >= 50: even though tied, keep top scorer
+        assert result["current_regime"] in ("broadening", "contraction")
+        # tied_regimes should still be reported
+        assert result.get("tied_regimes") is not None
+
+    def test_no_tied_regimes_clear_winner(self):
+        """Clear winner → tied_regimes is None."""
+        components = {
+            "concentration": self._make_component(60, "concentrating"),
+            "yield_curve": self._make_component(10, "stable"),
+            "credit_conditions": self._make_component(10, "stable"),
+            "size_factor": self._make_component(50, "large_cap_leading"),
+            "equity_bond": self._make_component(10, "neutral"),
+            "sector_rotation": self._make_component(10, "neutral"),
+        }
+        result = classify_regime(components)
+        assert result["current_regime"] == "concentration"
+        assert result.get("tied_regimes") is None
+
+    # --- Improvement 3: Transition Direction ---
+
+    def test_transition_direction_present(self):
+        """from_regime and to_regime present when transition probability is high/moderate."""
+        components = {
+            "concentration": self._make_component(60, "broadening"),
+            "yield_curve": self._make_component(50, "steepening"),
+            "credit_conditions": self._make_component(45, "easing"),
+            "size_factor": self._make_component(55, "small_cap_leading"),
+            "equity_bond": self._make_component(40, "risk_on"),
+            "sector_rotation": self._make_component(50, "risk_on"),
+        }
+        result = classify_regime(components)
+        tp = result["transition_probability"]
+        assert "from_regime" in tp
+        assert "to_regime" in tp
+
+    def test_transition_direction_none_when_minimal(self):
+        """from/to are None when transition probability is minimal."""
+        components = {
+            "concentration": self._make_component(10, "unknown"),
+            "yield_curve": self._make_component(5, "stable"),
+            "credit_conditions": self._make_component(5, "stable"),
+            "size_factor": self._make_component(5, "unknown"),
+            "equity_bond": self._make_component(5, "neutral"),
+            "sector_rotation": self._make_component(5, "neutral"),
+        }
+        result = classify_regime(components)
+        tp = result["transition_probability"]
+        assert tp["from_regime"] is None
+        assert tp["to_regime"] is None
+
+    # --- Improvement 4: Regime Consistency ---
+
+    def test_check_regime_consistency_broadening(self):
+        """Broadening regime with matching components → all consistent."""
+        components = {
+            "concentration": self._make_component(60, "broadening"),
+            "yield_curve": self._make_component(10, "stable"),
+            "credit_conditions": self._make_component(20, "easing"),
+            "size_factor": self._make_component(50, "small_cap_leading"),
+            "equity_bond": self._make_component(30, "risk_on"),
+            "sector_rotation": self._make_component(40, "risk_on"),
+        }
+        result = check_regime_consistency("broadening", components)
+        assert result["concentration"] == "consistent"
+        assert result["size_factor"] == "consistent"
+        assert result["sector_rotation"] == "consistent"
+
+    def test_check_regime_consistency_contradicting(self):
+        """Broadening regime but some components contradicting."""
+        components = {
+            "concentration": self._make_component(60, "concentrating"),  # contradicts
+            "yield_curve": self._make_component(10, "stable"),
+            "credit_conditions": self._make_component(20, "tightening"),  # contradicts
+            "size_factor": self._make_component(50, "large_cap_leading"),  # contradicts
+            "equity_bond": self._make_component(30, "risk_off"),  # contradicts
+            "sector_rotation": self._make_component(40, "risk_off"),  # contradicts
+        }
+        result = check_regime_consistency("broadening", components)
+        assert result["concentration"] == "contradicting"
+        assert result["size_factor"] == "contradicting"
+        assert result["sector_rotation"] == "contradicting"
+
+    def test_check_regime_consistency_transitional(self):
+        """Transitional regime → all neutral (no expectations)."""
+        components = {
+            "concentration": self._make_component(60, "broadening"),
+            "yield_curve": self._make_component(10, "stable"),
+            "credit_conditions": self._make_component(20, "tightening"),
+            "size_factor": self._make_component(50, "small_cap_leading"),
+            "equity_bond": self._make_component(30, "risk_on"),
+            "sector_rotation": self._make_component(40, "risk_on"),
+        }
+        result = check_regime_consistency("transitional", components)
+        for v in result.values():
+            assert v == "neutral"