# Extended Strategies + Fundamental Data — Implementation Plan

> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.

**Goal:** Add 6 new trading strategies (Value, MACD Crossover, Bollinger Breakout, VWAP, Liquidity, MA Stack) with a fundamental data pipeline (3 providers with rotation + DB caching) and 7 new technical indicators.

**Architecture:** New `shared/fundamentals/` module provides fundamental data via a rotating provider abstraction (Alpha Vantage → FMP → Yahoo Finance). Technical indicators (MACD, Bollinger, VWAP, ATR, EMA-9, EMA-21, SMA-200) are computed in `MarketDataManager` from existing OHLCV bars. Strategies implement the existing `BaseStrategy.evaluate()` interface and plug into the `WeightedEnsemble`.

**Tech Stack:** Python 3.12, Pydantic v2, SQLAlchemy 2.0 async, httpx (REST calls), yfinance, pytest

**Design doc:** `docs/plans/2026-02-23-strategies-fundamentals-design.md`

---

## Task 1: Add new technical indicator fields to MarketSnapshot

**Files:**
- Modify: `shared/schemas/trading.py:127-140`
- Test: `tests/test_schemas.py` (existing — new fields are optional, won't break)

**Step 1: Add indicator fields to MarketSnapshot**

In `shared/schemas/trading.py`, add after line 137 (`rsi: float | None = None`):

```python
# Technical indicators — computed by MarketDataManager
ema_9: float | None = None
ema_21: float | None = None
sma_200: float | None = None
macd: float | None = None
macd_signal: float | None = None
macd_histogram: float | None = None
bollinger_upper: float | None = None
bollinger_mid: float | None = None
bollinger_lower: float | None = None
vwap: float | None = None
atr: float | None = None
```

**Step 2: Add FundamentalsSnapshot schema**

Add after `SentimentContext` in the same file:

```python
class FundamentalsSnapshot(BaseModel):
    """Fundamental financial data for a single ticker — cached daily."""

    ticker: str
    eps_ttm: float | None = None
    pe_ratio: float | None = None
    peg_ratio: float | None = None
    revenue_growth_yoy: float | None = None
    profit_margin: float | None = None
    debt_to_equity: float | None = None
    market_cap: float | None = None
    fetched_at: datetime

    model_config = {"from_attributes": True}
```

Also add a `fundamentals` field to `MarketSnapshot`:

```python
fundamentals: FundamentalsSnapshot | None = None
```

**Step 3: Run existing tests to confirm nothing breaks**

Run: `python -m pytest tests/test_schemas.py -v`
Expected: All 49 tests PASS (new fields are optional with defaults)

**Step 4: Commit**

```bash
git add shared/schemas/trading.py
git commit -m "feat: add technical indicator and fundamentals fields to MarketSnapshot"
```

---

## Task 2: Implement technical indicator computations in MarketDataManager

**Files:**
- Modify: `services/signal_generator/market_data.py`
- Test: `tests/test_indicators.py` (new)

**Step 1: Write failing tests for EMA computation**

Create `tests/test_indicators.py`:

```python
"""Tests for technical indicator computations in MarketDataManager."""

import pytest
from datetime import datetime, timezone

from services.signal_generator.market_data import MarketDataManager
from shared.schemas.trading import OHLCVBar


def _bar(close: float, volume: float = 1000.0, high: float | None = None, low: float | None = None, open_: float | None = None) -> OHLCVBar:
    """Helper to create an OHLCVBar with sensible defaults."""
    return OHLCVBar(
        timestamp=datetime.now(timezone.utc),
        open=open_ if open_ is not None else close,
        high=high if high is not None else close + 1,
        low=low if low is not None else close - 1,
        close=close,
        volume=volume,
    )


def _add_bars(mgr: MarketDataManager, ticker: str, closes: list[float], volume: float = 1000.0) -> None:
    """Add multiple bars with given close prices."""
    for c in closes:
        mgr.add_bar(ticker, _bar(c, volume=volume))


class TestEMA:
    """Tests for exponential moving average computation."""

    def test_ema_returns_none_insufficient_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 5)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.ema_9 is None  # Need at least 9 bars

    def test_ema_9_with_exact_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 9)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.ema_9 is not None
        assert snap.ema_9 == pytest.approx(100.0, abs=0.01)

    def test_ema_responds_to_recent_prices(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        # 20 bars at 100, then 1 bar at 110
        _add_bars(mgr, "AAPL", [100.0] * 20 + [110.0])
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.ema_9 is not None
        # EMA-9 should be > 100 because the most recent price is 110
        assert snap.ema_9 > 100.0
        assert snap.ema_9 < 110.0

    def test_ema_21_returns_none_insufficient_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 15)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.ema_21 is None

    def test_ema_21_computed_with_enough_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 25)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.ema_21 is not None
        assert snap.ema_21 == pytest.approx(100.0, abs=0.01)


class TestSMA200:
    """Tests for SMA-200 computation."""

    def test_sma_200_returns_none_insufficient_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 100)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.sma_200 is None

    def test_sma_200_computed_with_enough_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 200)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.sma_200 is not None
        assert snap.sma_200 == pytest.approx(100.0, abs=0.01)


class TestMACD:
    """Tests for MACD computation."""

    def test_macd_returns_none_insufficient_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 20)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.macd is None

    def test_macd_computed_with_enough_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        # Need 26 bars for EMA-26, plus 9 more for the signal line = 35 minimum
        _add_bars(mgr, "AAPL", [100.0] * 40)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.macd is not None
        assert snap.macd_signal is not None
        assert snap.macd_histogram is not None
        # With constant prices, MACD should be ~0
        assert snap.macd == pytest.approx(0.0, abs=0.1)

    def test_macd_positive_in_uptrend(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        # Rising prices: EMA-12 > EMA-26 → positive MACD
        prices = [100.0 + i * 0.5 for i in range(50)]
        _add_bars(mgr, "AAPL", prices)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.macd is not None
        assert snap.macd > 0


class TestBollingerBands:
    """Tests for Bollinger Bands computation."""

    def test_bollinger_returns_none_insufficient_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 10)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.bollinger_upper is None

    def test_bollinger_computed_with_enough_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 25)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.bollinger_upper is not None
        assert snap.bollinger_mid is not None
        assert snap.bollinger_lower is not None
        # With constant prices, bands should be tight around the price
        assert snap.bollinger_mid == pytest.approx(100.0, abs=0.01)
        assert snap.bollinger_upper >= snap.bollinger_mid
        assert snap.bollinger_lower <= snap.bollinger_mid

    def test_bollinger_width_increases_with_volatility(self) -> None:
        mgr_stable = MarketDataManager(max_bars=300)
        _add_bars(mgr_stable, "AAPL", [100.0] * 25)
        snap_stable = mgr_stable.get_snapshot("AAPL")

        mgr_volatile = MarketDataManager(max_bars=300)
        # Alternating prices = high volatility
        _add_bars(mgr_volatile, "AAPL", [90.0 + (i % 2) * 20 for i in range(25)])
        snap_volatile = mgr_volatile.get_snapshot("AAPL")

        assert snap_stable is not None and snap_volatile is not None
        width_stable = snap_stable.bollinger_upper - snap_stable.bollinger_lower
        width_volatile = snap_volatile.bollinger_upper - snap_volatile.bollinger_lower
        assert width_volatile > width_stable


class TestVWAP:
    """Tests for VWAP computation."""

    def test_vwap_computed(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 5, volume=1000.0)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.vwap is not None
        # With constant prices and volume, VWAP = typical price
        # typical = (high + low + close) / 3 = (101 + 99 + 100) / 3 = 100.0
        assert snap.vwap == pytest.approx(100.0, abs=0.01)

    def test_vwap_weighted_by_volume(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        # Bar 1: close=100, volume=1000
        mgr.add_bar("AAPL", _bar(100.0, volume=1000.0))
        # Bar 2: close=200, volume=3000 (should pull VWAP toward 200)
        mgr.add_bar("AAPL", _bar(200.0, volume=3000.0))
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.vwap is not None
        assert snap.vwap > 150.0  # Weighted toward 200


class TestATR:
    """Tests for ATR computation."""

    def test_atr_returns_none_insufficient_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        _add_bars(mgr, "AAPL", [100.0] * 5)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.atr is None

    def test_atr_computed_with_enough_data(self) -> None:
        mgr = MarketDataManager(max_bars=300)
        # 15 bars needed (14-period ATR + 1 for prev close)
        _add_bars(mgr, "AAPL", [100.0] * 15)
        snap = mgr.get_snapshot("AAPL")
        assert snap is not None
        assert snap.atr is not None
        assert snap.atr >= 0

    def test_atr_increases_with_volatility(self) -> None:
        mgr_stable = MarketDataManager(max_bars=300)
        for i in range(20):
            mgr_stable.add_bar("AAPL", OHLCVBar(
                timestamp=datetime.now(timezone.utc),
                open=100.0, high=101.0, low=99.0, close=100.0, volume=1000.0,
            ))
        snap_stable = mgr_stable.get_snapshot("AAPL")

        mgr_volatile = MarketDataManager(max_bars=300)
        for i in range(20):
            mgr_volatile.add_bar("AAPL", OHLCVBar(
                timestamp=datetime.now(timezone.utc),
                open=100.0, high=115.0, low=85.0, close=100.0, volume=1000.0,
            ))
        snap_volatile = mgr_volatile.get_snapshot("AAPL")

        assert snap_stable is not None and snap_volatile is not None
        assert snap_volatile.atr > snap_stable.atr
```

**Step 2: Run tests to verify they fail**

Run: `python -m pytest tests/test_indicators.py -v`
Expected: FAIL — `ema_9`, `macd`, etc. don't exist on `MarketSnapshot` yet (Task 1 must be done first) and computations aren't implemented.

**Step 3: Implement indicator computations in MarketDataManager**

Modify `services/signal_generator/market_data.py`:

1. Add `_compute_ema` static method:
```python
@staticmethod
def _compute_ema(closes: list[float], period: int) -> float | None:
    """Compute exponential moving average over *closes* with given *period*."""
    if len(closes) < period:
        return None
    multiplier = 2.0 / (period + 1)
    ema = sum(closes[:period]) / period  # Seed with SMA
    for price in closes[period:]:
        ema = (price - ema) * multiplier + ema
    return round(ema, 6)
```

2. Add `_compute_macd` static method:
```python
@staticmethod
def _compute_macd(closes: list[float]) -> tuple[float, float, float] | None:
    """Compute MACD (12,26,9). Returns (macd_line, signal_line, histogram) or None."""
    if len(closes) < 35:  # 26 for slow EMA + 9 for signal
        return None
    mul_12 = 2.0 / 13
    mul_26 = 2.0 / 27
    mul_9 = 2.0 / 10

    ema_12 = sum(closes[:12]) / 12
    ema_26 = sum(closes[:26]) / 26

    macd_values: list[float] = []
    for i in range(len(closes)):
        if i < 12:
            continue
        if i == 12:
            ema_12 = sum(closes[:12]) / 12
        else:
            ema_12 = (closes[i] - ema_12) * mul_12 + ema_12
        if i < 26:
            continue
        if i == 26:
            ema_26 = sum(closes[:26]) / 26
            # Recompute ema_12 from scratch for accuracy
            ema_12 = sum(closes[:12]) / 12
            for j in range(12, i + 1):
                ema_12 = (closes[j] - ema_12) * mul_12 + ema_12
        else:
            ema_26 = (closes[i] - ema_26) * mul_26 + ema_26
        macd_values.append(ema_12 - ema_26)

    if len(macd_values) < 9:
        return None

    signal = sum(macd_values[:9]) / 9
    for val in macd_values[9:]:
        signal = (val - signal) * mul_9 + signal

    macd_line = macd_values[-1]
    histogram = macd_line - signal
    return round(macd_line, 6), round(signal, 6), round(histogram, 6)
```

3. Add `_compute_bollinger` static method:
```python
@staticmethod
def _compute_bollinger(closes: list[float], period: int = 20, num_std: float = 2.0) -> tuple[float, float, float] | None:
    """Compute Bollinger Bands. Returns (upper, mid, lower) or None."""
    if len(closes) < period:
        return None
    window = closes[-period:]
    mid = sum(window) / period
    variance = sum((x - mid) ** 2 for x in window) / period
    std = variance ** 0.5
    return round(mid + num_std * std, 6), round(mid, 6), round(mid - num_std * std, 6)
```

4. Add `_compute_vwap` static method:
```python
@staticmethod
def _compute_vwap(bars: list[OHLCVBar]) -> float | None:
    """Compute VWAP from bars. Returns None if no bars."""
    if not bars:
        return None
    cum_tp_vol = 0.0
    cum_vol = 0.0
    for bar in bars:
        typical_price = (bar.high + bar.low + bar.close) / 3.0
        cum_tp_vol += typical_price * bar.volume
        cum_vol += bar.volume
    if cum_vol == 0:
        return None
    return round(cum_tp_vol / cum_vol, 6)
```

5. Add `_compute_atr` static method:
```python
@staticmethod
def _compute_atr(bars: list[OHLCVBar], period: int = 14) -> float | None:
    """Compute Average True Range over *period*. Needs period+1 bars."""
    if len(bars) < period + 1:
        return None
    relevant = bars[-(period + 1):]
    true_ranges: list[float] = []
    for i in range(1, len(relevant)):
        high_low = relevant[i].high - relevant[i].low
        high_prev_close = abs(relevant[i].high - relevant[i - 1].close)
        low_prev_close = abs(relevant[i].low - relevant[i - 1].close)
        true_ranges.append(max(high_low, high_prev_close, low_prev_close))
    return round(sum(true_ranges) / len(true_ranges), 6)
```

6. Update `get_snapshot()` to compute and include all new indicators:
```python
def get_snapshot(self, ticker: str) -> MarketSnapshot | None:
    bars = self._bars.get(ticker)
    if not bars:
        return None

    latest = bars[-1]
    closes = [b.close for b in bars]
    bar_list = list(bars)

    # MACD
    macd_result = self._compute_macd(closes)
    macd_val = macd_signal = macd_hist = None
    if macd_result:
        macd_val, macd_signal, macd_hist = macd_result

    # Bollinger
    boll_result = self._compute_bollinger(closes)
    boll_upper = boll_mid = boll_lower = None
    if boll_result:
        boll_upper, boll_mid, boll_lower = boll_result

    return MarketSnapshot(
        ticker=ticker,
        current_price=latest.close,
        open=latest.open,
        high=latest.high,
        low=latest.low,
        close=latest.close,
        volume=latest.volume,
        sma_20=self._compute_sma(closes, 20),
        sma_50=self._compute_sma(closes, 50),
        sma_200=self._compute_sma(closes, 200),
        rsi=self._compute_rsi(closes, _RSI_PERIOD),
        ema_9=self._compute_ema(closes, 9),
        ema_21=self._compute_ema(closes, 21),
        macd=macd_val,
        macd_signal=macd_signal,
        macd_histogram=macd_hist,
        bollinger_upper=boll_upper,
        bollinger_mid=boll_mid,
        bollinger_lower=boll_lower,
        vwap=self._compute_vwap(bar_list),
        atr=self._compute_atr(bar_list),
        bars=[b.model_dump(mode="json") for b in bars],
    )
```

**Step 4: Run tests to verify they pass**

Run: `python -m pytest tests/test_indicators.py -v`
Expected: All PASS

**Step 5: Run existing tests to confirm no regressions**

Run: `python -m pytest tests/ -v -m "not integration" --timeout=30`
Expected: All 246+ tests PASS

**Step 6: Commit**

```bash
git add services/signal_generator/market_data.py tests/test_indicators.py
git commit -m "feat: add MACD, Bollinger, VWAP, ATR, EMA, SMA-200 indicator computations"
```

---

## Task 3: Implement fundamental data providers

**Files:**
- Create: `shared/fundamentals/__init__.py`
- Create: `shared/fundamentals/base.py`
- Create: `shared/fundamentals/alpha_vantage.py`
- Create: `shared/fundamentals/fmp.py`
- Create: `shared/fundamentals/yahoo.py`
- Create: `shared/fundamentals/rotating.py`
- Test: `tests/test_fundamentals.py` (new)

**Step 1: Write failing tests**

Create `tests/test_fundamentals.py`:

```python
"""Tests for fundamental data providers."""

import pytest
from datetime import datetime, timezone
from unittest.mock import AsyncMock, patch, MagicMock

from shared.fundamentals.base import FundamentalsProvider, FundamentalsSnapshot
from shared.fundamentals.alpha_vantage import AlphaVantageProvider
from shared.fundamentals.fmp import FMPProvider
from shared.fundamentals.yahoo import YahooFinanceProvider
from shared.fundamentals.rotating import RotatingProvider


class TestFundamentalsSnapshot:
    """Tests for the FundamentalsSnapshot model."""

    def test_snapshot_all_fields(self) -> None:
        snap = FundamentalsSnapshot(
            ticker="AAPL",
            eps_ttm=6.5,
            pe_ratio=28.0,
            peg_ratio=1.5,
            revenue_growth_yoy=0.08,
            profit_margin=0.25,
            debt_to_equity=1.8,
            market_cap=3_000_000_000_000.0,
            fetched_at=datetime.now(timezone.utc),
        )
        assert snap.ticker == "AAPL"
        assert snap.eps_ttm == 6.5

    def test_snapshot_optional_fields(self) -> None:
        snap = FundamentalsSnapshot(
            ticker="AAPL",
            fetched_at=datetime.now(timezone.utc),
        )
        assert snap.eps_ttm is None
        assert snap.pe_ratio is None


class TestAlphaVantageProvider:
    """Tests for Alpha Vantage provider."""

    @pytest.mark.asyncio
    async def test_fetch_parses_response(self) -> None:
        mock_response = AsyncMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {
            "Symbol": "AAPL",
            "EPS": "6.50",
            "PERatio": "28.00",
            "PEGRatio": "1.50",
            "QuarterlyRevenueGrowthYOY": "0.08",
            "ProfitMargin": "0.25",
            "DebtToEquity": "180",  # Alpha Vantage returns as percentage
            "MarketCapitalization": "3000000000000",
        }

        provider = AlphaVantageProvider(api_key="test-key")
        with patch.object(provider, "_client") as mock_client:
            mock_client.get = AsyncMock(return_value=mock_response)
            result = await provider.fetch("AAPL")

        assert result is not None
        assert result.ticker == "AAPL"
        assert result.eps_ttm == 6.5
        assert result.pe_ratio == 28.0

    @pytest.mark.asyncio
    async def test_fetch_handles_rate_limit(self) -> None:
        mock_response = AsyncMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {
            "Note": "Thank you for using Alpha Vantage! Our standard API rate limit is 25 requests per day."
        }

        provider = AlphaVantageProvider(api_key="test-key")
        with patch.object(provider, "_client") as mock_client:
            mock_client.get = AsyncMock(return_value=mock_response)
            result = await provider.fetch("AAPL")

        assert result is None


class TestFMPProvider:
    """Tests for Financial Modeling Prep provider."""

    @pytest.mark.asyncio
    async def test_fetch_parses_response(self) -> None:
        mock_response = AsyncMock()
        mock_response.status_code = 200
        mock_response.json.return_value = [
            {
                "symbol": "AAPL",
                "eps": 6.5,
                "pe": 28.0,
                "pegRatio": 1.5,
                "revenueGrowth": 0.08,
                "netProfitMargin": 0.25,
                "debtToEquity": 1.8,
                "marketCap": 3_000_000_000_000,
            }
        ]

        provider = FMPProvider(api_key="test-key")
        with patch.object(provider, "_client") as mock_client:
            mock_client.get = AsyncMock(return_value=mock_response)
            result = await provider.fetch("AAPL")

        assert result is not None
        assert result.ticker == "AAPL"
        assert result.peg_ratio == 1.5

    @pytest.mark.asyncio
    async def test_fetch_handles_empty_response(self) -> None:
        mock_response = AsyncMock()
        mock_response.status_code = 200
        mock_response.json.return_value = []

        provider = FMPProvider(api_key="test-key")
        with patch.object(provider, "_client") as mock_client:
            mock_client.get = AsyncMock(return_value=mock_response)
            result = await provider.fetch("INVALID")

        assert result is None


class TestYahooFinanceProvider:
    """Tests for Yahoo Finance provider."""

    @pytest.mark.asyncio
    async def test_fetch_parses_ticker_info(self) -> None:
        mock_ticker = MagicMock()
        mock_ticker.info = {
            "trailingEps": 6.5,
            "trailingPE": 28.0,
            "pegRatio": 1.5,
            "revenueGrowth": 0.08,
            "profitMargins": 0.25,
            "debtToEquity": 180.0,
            "marketCap": 3_000_000_000_000,
        }

        provider = YahooFinanceProvider()
        with patch("shared.fundamentals.yahoo.yfinance.Ticker", return_value=mock_ticker):
            result = await provider.fetch("AAPL")

        assert result is not None
        assert result.ticker == "AAPL"
        assert result.eps_ttm == 6.5
        assert result.debt_to_equity == pytest.approx(1.8, abs=0.01)


class TestRotatingProvider:
    """Tests for the rotating provider with failover."""

    @pytest.mark.asyncio
    async def test_uses_first_provider_on_success(self) -> None:
        snap = FundamentalsSnapshot(ticker="AAPL", fetched_at=datetime.now(timezone.utc), eps_ttm=6.5)
        p1 = AsyncMock(spec=FundamentalsProvider)
        p1.fetch = AsyncMock(return_value=snap)
        p2 = AsyncMock(spec=FundamentalsProvider)

        rotating = RotatingProvider([p1, p2])
        result = await rotating.fetch("AAPL")

        assert result is not None
        assert result.eps_ttm == 6.5
        p1.fetch.assert_awaited_once_with("AAPL")
        p2.fetch.assert_not_awaited()

    @pytest.mark.asyncio
    async def test_falls_back_on_failure(self) -> None:
        snap = FundamentalsSnapshot(ticker="AAPL", fetched_at=datetime.now(timezone.utc), eps_ttm=7.0)
        p1 = AsyncMock(spec=FundamentalsProvider)
        p1.fetch = AsyncMock(return_value=None)  # Rate limited
        p2 = AsyncMock(spec=FundamentalsProvider)
        p2.fetch = AsyncMock(return_value=snap)

        rotating = RotatingProvider([p1, p2])
        result = await rotating.fetch("AAPL")

        assert result is not None
        assert result.eps_ttm == 7.0

    @pytest.mark.asyncio
    async def test_returns_none_when_all_fail(self) -> None:
        p1 = AsyncMock(spec=FundamentalsProvider)
        p1.fetch = AsyncMock(return_value=None)
        p2 = AsyncMock(spec=FundamentalsProvider)
        p2.fetch = AsyncMock(return_value=None)

        rotating = RotatingProvider([p1, p2])
        result = await rotating.fetch("AAPL")
        assert result is None

    @pytest.mark.asyncio
    async def test_handles_exception_and_falls_back(self) -> None:
        snap = FundamentalsSnapshot(ticker="AAPL", fetched_at=datetime.now(timezone.utc))
        p1 = AsyncMock(spec=FundamentalsProvider)
        p1.fetch = AsyncMock(side_effect=Exception("API error"))
        p2 = AsyncMock(spec=FundamentalsProvider)
        p2.fetch = AsyncMock(return_value=snap)

        rotating = RotatingProvider([p1, p2])
        result = await rotating.fetch("AAPL")
        assert result is not None
```

**Step 2: Run tests to verify they fail**

Run: `python -m pytest tests/test_fundamentals.py -v`
Expected: FAIL — modules don't exist yet

**Step 3: Create `shared/fundamentals/__init__.py`**

```python
"""Fundamental data providers for stock financial metrics."""

from shared.fundamentals.base import FundamentalsProvider, FundamentalsSnapshot
from shared.fundamentals.rotating import RotatingProvider

__all__ = ["FundamentalsProvider", "FundamentalsSnapshot", "RotatingProvider"]
```

**Step 4: Create `shared/fundamentals/base.py`**

```python
"""Abstract base class for fundamental data providers."""

from __future__ import annotations

from abc import ABC, abstractmethod
from datetime import datetime

from pydantic import BaseModel


class FundamentalsSnapshot(BaseModel):
    """Fundamental financial data for a single ticker."""

    ticker: str
    eps_ttm: float | None = None
    pe_ratio: float | None = None
    peg_ratio: float | None = None
    revenue_growth_yoy: float | None = None
    profit_margin: float | None = None
    debt_to_equity: float | None = None
    market_cap: float | None = None
    fetched_at: datetime

    model_config = {"from_attributes": True}


class FundamentalsProvider(ABC):
    """Abstract base class for fundamental data providers."""

    @abstractmethod
    async def fetch(self, ticker: str) -> FundamentalsSnapshot | None:
        """Fetch fundamental data for *ticker*. Returns None on failure/rate limit."""
        ...
```

**Step 5: Create `shared/fundamentals/alpha_vantage.py`**

```python
"""Alpha Vantage fundamental data provider."""

from __future__ import annotations

import logging
from datetime import datetime, timezone

import httpx

from shared.fundamentals.base import FundamentalsProvider, FundamentalsSnapshot

logger = logging.getLogger(__name__)

_BASE_URL = "https://www.alphavantage.co/query"


class AlphaVantageProvider(FundamentalsProvider):
    """Fetch fundamentals from the Alpha Vantage OVERVIEW endpoint."""

    def __init__(self, api_key: str) -> None:
        self._api_key = api_key
        self._client = httpx.AsyncClient(timeout=30.0)

    async def fetch(self, ticker: str) -> FundamentalsSnapshot | None:
        try:
            resp = await self._client.get(
                _BASE_URL,
                params={"function": "OVERVIEW", "symbol": ticker, "apikey": self._api_key},
            )
            data = resp.json()

            # Rate limit detection
            if "Note" in data or "Information" in data:
                logger.warning("Alpha Vantage rate limit hit for %s", ticker)
                return None

            if "Symbol" not in data:
                logger.warning("Alpha Vantage returned no data for %s", ticker)
                return None

            return FundamentalsSnapshot(
                ticker=ticker,
                eps_ttm=_safe_float(data.get("EPS")),
                pe_ratio=_safe_float(data.get("PERatio")),
                peg_ratio=_safe_float(data.get("PEGRatio")),
                revenue_growth_yoy=_safe_float(data.get("QuarterlyRevenueGrowthYOY")),
                profit_margin=_safe_float(data.get("ProfitMargin")),
                debt_to_equity=_safe_float_div100(data.get("DebtToEquity")),
                market_cap=_safe_float(data.get("MarketCapitalization")),
                fetched_at=datetime.now(timezone.utc),
            )
        except Exception:
            logger.exception("Alpha Vantage fetch failed for %s", ticker)
            return None


def _safe_float(val: str | None) -> float | None:
    if val is None or val in ("None", "-", ""):
        return None
    try:
        return float(val)
    except (ValueError, TypeError):
        return None


def _safe_float_div100(val: str | None) -> float | None:
    """Alpha Vantage returns debt-to-equity as a percentage (e.g. 180 = 1.8)."""
    f = _safe_float(val)
    return f / 100.0 if f is not None else None
```

**Step 6: Create `shared/fundamentals/fmp.py`**

```python
"""Financial Modeling Prep (FMP) fundamental data provider."""

from __future__ import annotations

import logging
from datetime import datetime, timezone

import httpx

from shared.fundamentals.base import FundamentalsProvider, FundamentalsSnapshot

logger = logging.getLogger(__name__)

_BASE_URL = "https://financialmodelingprep.com/api/v3"


class FMPProvider(FundamentalsProvider):
    """Fetch fundamentals from the FMP key-metrics endpoint."""

    def __init__(self, api_key: str) -> None:
        self._api_key = api_key
        self._client = httpx.AsyncClient(timeout=30.0)

    async def fetch(self, ticker: str) -> FundamentalsSnapshot | None:
        try:
            resp = await self._client.get(
                f"{_BASE_URL}/key-metrics-ttm/{ticker}",
                params={"apikey": self._api_key},
            )
            data = resp.json()

            if not data or not isinstance(data, list) or len(data) == 0:
                logger.warning("FMP returned no data for %s", ticker)
                return None

            item = data[0]
            return FundamentalsSnapshot(
                ticker=ticker,
                eps_ttm=item.get("eps") or item.get("netIncomePerShareTTM"),
                pe_ratio=item.get("pe") or item.get("peRatioTTM"),
                peg_ratio=item.get("pegRatio") or item.get("pegRatioTTM"),
                revenue_growth_yoy=item.get("revenueGrowth"),
                profit_margin=item.get("netProfitMargin") or item.get("netProfitMarginTTM"),
                debt_to_equity=item.get("debtToEquity") or item.get("debtToEquityTTM"),
                market_cap=item.get("marketCap") or item.get("marketCapTTM"),
                fetched_at=datetime.now(timezone.utc),
            )
        except Exception:
            logger.exception("FMP fetch failed for %s", ticker)
            return None
```

**Step 7: Create `shared/fundamentals/yahoo.py`**

```python
"""Yahoo Finance fundamental data provider (via yfinance library)."""

from __future__ import annotations

import asyncio
import logging
from datetime import datetime, timezone

from shared.fundamentals.base import FundamentalsProvider, FundamentalsSnapshot

logger = logging.getLogger(__name__)


class YahooFinanceProvider(FundamentalsProvider):
    """Fetch fundamentals via yfinance (runs in thread pool to avoid blocking)."""

    async def fetch(self, ticker: str) -> FundamentalsSnapshot | None:
        try:
            import yfinance

            loop = asyncio.get_running_loop()
            info = await loop.run_in_executor(None, _get_ticker_info, ticker)

            if not info:
                logger.warning("yfinance returned no info for %s", ticker)
                return None

            d2e = info.get("debtToEquity")
            # yfinance returns debt-to-equity as percentage (e.g. 180.0 = 1.8)
            if d2e is not None:
                d2e = d2e / 100.0

            return FundamentalsSnapshot(
                ticker=ticker,
                eps_ttm=info.get("trailingEps"),
                pe_ratio=info.get("trailingPE"),
                peg_ratio=info.get("pegRatio"),
                revenue_growth_yoy=info.get("revenueGrowth"),
                profit_margin=info.get("profitMargins"),
                debt_to_equity=d2e,
                market_cap=info.get("marketCap"),
                fetched_at=datetime.now(timezone.utc),
            )
        except Exception:
            logger.exception("yfinance fetch failed for %s", ticker)
            return None


def _get_ticker_info(ticker: str) -> dict:
    """Synchronous helper — called via run_in_executor."""
    import yfinance

    t = yfinance.Ticker(ticker)
    return t.info
```

**Step 8: Create `shared/fundamentals/rotating.py`**

```python
"""Rotating provider that tries multiple providers with failover."""

from __future__ import annotations

import logging

from shared.fundamentals.base import FundamentalsProvider, FundamentalsSnapshot

logger = logging.getLogger(__name__)


class RotatingProvider(FundamentalsProvider):
    """Try each provider in order; return the first successful result."""

    def __init__(self, providers: list[FundamentalsProvider]) -> None:
        self._providers = providers

    async def fetch(self, ticker: str) -> FundamentalsSnapshot | None:
        for provider in self._providers:
            try:
                result = await provider.fetch(ticker)
                if result is not None:
                    logger.debug(
                        "Fetched fundamentals for %s via %s",
                        ticker,
                        type(provider).__name__,
                    )
                    return result
                logger.debug(
                    "%s returned None for %s, trying next",
                    type(provider).__name__,
                    ticker,
                )
            except Exception:
                logger.exception(
                    "%s failed for %s, trying next",
                    type(provider).__name__,
                    ticker,
                )
        logger.warning("All providers failed for %s", ticker)
        return None
```

**Step 9: Run tests**

Run: `python -m pytest tests/test_fundamentals.py -v`
Expected: All PASS

**Step 10: Commit**

```bash
git add shared/fundamentals/ tests/test_fundamentals.py
git commit -m "feat: add fundamental data providers (Alpha Vantage, FMP, Yahoo Finance) with rotation"
```

---

## Task 4: Add fundamentals DB table and caching

**Files:**
- Create: `shared/models/fundamentals.py`
- Modify: `shared/models/__init__.py`
- Create: `alembic/versions/xxx_add_fundamentals_table.py` (via alembic)
- Create: `shared/fundamentals/cache.py`
- Test: `tests/test_fundamentals.py` (add cache tests)

**Step 1: Create `shared/models/fundamentals.py`**

```python
"""Fundamentals database model for caching fundamental data."""

import uuid

from sqlalchemy import Float, String, DateTime
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.orm import Mapped, mapped_column

from shared.models.base import Base, TimestampMixin


class Fundamentals(TimestampMixin, Base):
    __tablename__ = "fundamentals"

    id: Mapped[uuid.UUID] = mapped_column(
        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
    )
    ticker: Mapped[str] = mapped_column(String(20), unique=True, nullable=False, index=True)
    eps_ttm: Mapped[float | None] = mapped_column(Float, nullable=True)
    pe_ratio: Mapped[float | None] = mapped_column(Float, nullable=True)
    peg_ratio: Mapped[float | None] = mapped_column(Float, nullable=True)
    revenue_growth_yoy: Mapped[float | None] = mapped_column(Float, nullable=True)
    profit_margin: Mapped[float | None] = mapped_column(Float, nullable=True)
    debt_to_equity: Mapped[float | None] = mapped_column(Float, nullable=True)
    market_cap: Mapped[float | None] = mapped_column(Float, nullable=True)
    fetched_at: Mapped[str] = mapped_column(DateTime(timezone=True), nullable=False)
```

**Step 2: Update `shared/models/__init__.py`**

Add `from shared.models.fundamentals import Fundamentals` and add `"Fundamentals"` to `__all__`.

**Step 3: Generate Alembic migration**

Run: `python -m alembic revision --autogenerate -m "add fundamentals table"`
Then verify the generated migration looks correct.

**Step 4: Create `shared/fundamentals/cache.py`**

```python
"""DB-backed cache for fundamental data."""

from __future__ import annotations

import logging
from datetime import datetime, timezone, timedelta

from sqlalchemy import select
from sqlalchemy.ext.asyncio import async_sessionmaker

from shared.fundamentals.base import FundamentalsProvider, FundamentalsSnapshot
from shared.models.fundamentals import Fundamentals

logger = logging.getLogger(__name__)


class CachedFundamentalsProvider:
    """Wraps a FundamentalsProvider with DB-backed caching.

    On fetch: checks DB first. If data is fresh (within TTL), returns cached.
    Otherwise fetches from the underlying provider and updates the DB.
    """

    def __init__(
        self,
        provider: FundamentalsProvider,
        session_factory: async_sessionmaker,
        cache_ttl_hours: int = 24,
    ) -> None:
        self._provider = provider
        self._session_factory = session_factory
        self._cache_ttl = timedelta(hours=cache_ttl_hours)

    async def fetch(self, ticker: str) -> FundamentalsSnapshot | None:
        # Try cache first
        cached = await self._load_from_db(ticker)
        if cached is not None:
            age = datetime.now(timezone.utc) - cached.fetched_at.replace(tzinfo=timezone.utc)
            if age < self._cache_ttl:
                logger.debug("Cache hit for %s (age=%s)", ticker, age)
                return cached
            logger.debug("Cache stale for %s (age=%s), refreshing", ticker, age)

        # Fetch from provider
        result = await self._provider.fetch(ticker)
        if result is not None:
            await self._save_to_db(result)
        return result

    async def _load_from_db(self, ticker: str) -> FundamentalsSnapshot | None:
        try:
            async with self._session_factory() as session:
                stmt = select(Fundamentals).where(Fundamentals.ticker == ticker)
                row = (await session.execute(stmt)).scalar_one_or_none()
                if row is None:
                    return None
                return FundamentalsSnapshot(
                    ticker=row.ticker,
                    eps_ttm=row.eps_ttm,
                    pe_ratio=row.pe_ratio,
                    peg_ratio=row.peg_ratio,
                    revenue_growth_yoy=row.revenue_growth_yoy,
                    profit_margin=row.profit_margin,
                    debt_to_equity=row.debt_to_equity,
                    market_cap=row.market_cap,
                    fetched_at=row.fetched_at,
                )
        except Exception:
            logger.exception("Failed to load fundamentals from DB for %s", ticker)
            return None

    async def _save_to_db(self, snapshot: FundamentalsSnapshot) -> None:
        try:
            async with self._session_factory() as session:
                stmt = select(Fundamentals).where(Fundamentals.ticker == snapshot.ticker)
                existing = (await session.execute(stmt)).scalar_one_or_none()

                if existing:
                    existing.eps_ttm = snapshot.eps_ttm
                    existing.pe_ratio = snapshot.pe_ratio
                    existing.peg_ratio = snapshot.peg_ratio
                    existing.revenue_growth_yoy = snapshot.revenue_growth_yoy
                    existing.profit_margin = snapshot.profit_margin
                    existing.debt_to_equity = snapshot.debt_to_equity
                    existing.market_cap = snapshot.market_cap
                    existing.fetched_at = snapshot.fetched_at
                else:
                    row = Fundamentals(
                        ticker=snapshot.ticker,
                        eps_ttm=snapshot.eps_ttm,
                        pe_ratio=snapshot.pe_ratio,
                        peg_ratio=snapshot.peg_ratio,
                        revenue_growth_yoy=snapshot.revenue_growth_yoy,
                        profit_margin=snapshot.profit_margin,
                        debt_to_equity=snapshot.debt_to_equity,
                        market_cap=snapshot.market_cap,
                        fetched_at=snapshot.fetched_at,
                    )
                    session.add(row)

                await session.commit()
                logger.debug("Saved fundamentals for %s to DB", snapshot.ticker)
        except Exception:
            logger.exception("Failed to save fundamentals for %s to DB", snapshot.ticker)
```

**Step 5: Run tests**

Run: `python -m pytest tests/test_fundamentals.py tests/test_models.py -v`
Expected: PASS

**Step 6: Commit**

```bash
git add shared/models/fundamentals.py shared/models/__init__.py shared/fundamentals/cache.py alembic/
git commit -m "feat: add fundamentals DB model and cached provider"
```

---

## Task 5: Implement the 6 new strategies

**Files:**
- Create: `shared/strategies/value.py`
- Create: `shared/strategies/macd_crossover.py`
- Create: `shared/strategies/bollinger_breakout.py`
- Create: `shared/strategies/vwap.py`
- Create: `shared/strategies/liquidity.py`
- Create: `shared/strategies/ma_stack.py`
- Modify: `shared/strategies/__init__.py`
- Test: `tests/test_new_strategies.py` (new)

**Step 1: Write failing tests**

Create `tests/test_new_strategies.py`:

```python
"""Tests for the 6 new trading strategies."""

import pytest
from datetime import datetime, timezone

from shared.fundamentals.base import FundamentalsSnapshot
from shared.schemas.trading import MarketSnapshot, SentimentContext, SignalDirection
from shared.strategies import BaseStrategy
from shared.strategies.value import ValueStrategy
from shared.strategies.macd_crossover import MACDCrossoverStrategy
from shared.strategies.bollinger_breakout import BollingerBreakoutStrategy
from shared.strategies.vwap import VWAPStrategy
from shared.strategies.liquidity import LiquidityStrategy
from shared.strategies.ma_stack import MAStackStrategy


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------

def _market(
    ticker: str = "AAPL",
    price: float = 150.0,
    volume: float = 1_000_000,
    sma_20: float | None = None,
    sma_50: float | None = None,
    sma_200: float | None = None,
    rsi: float | None = None,
    ema_9: float | None = None,
    ema_21: float | None = None,
    macd: float | None = None,
    macd_signal: float | None = None,
    macd_histogram: float | None = None,
    bollinger_upper: float | None = None,
    bollinger_mid: float | None = None,
    bollinger_lower: float | None = None,
    vwap: float | None = None,
    atr: float | None = None,
    fundamentals: FundamentalsSnapshot | None = None,
    bars: list | None = None,
) -> MarketSnapshot:
    return MarketSnapshot(
        ticker=ticker,
        current_price=price,
        open=price - 1,
        high=price + 2,
        low=price - 2,
        close=price,
        volume=volume,
        sma_20=sma_20,
        sma_50=sma_50,
        sma_200=sma_200,
        rsi=rsi,
        ema_9=ema_9,
        ema_21=ema_21,
        macd=macd,
        macd_signal=macd_signal,
        macd_histogram=macd_histogram,
        bollinger_upper=bollinger_upper,
        bollinger_mid=bollinger_mid,
        bollinger_lower=bollinger_lower,
        vwap=vwap,
        atr=atr,
        fundamentals=fundamentals,
        bars=bars or [],
    )


def _fundamentals(
    ticker: str = "AAPL",
    eps_ttm: float | None = 6.5,
    pe_ratio: float | None = 28.0,
    peg_ratio: float | None = 1.5,
    revenue_growth_yoy: float | None = 0.08,
    profit_margin: float | None = 0.25,
    debt_to_equity: float | None = 1.8,
) -> FundamentalsSnapshot:
    return FundamentalsSnapshot(
        ticker=ticker,
        eps_ttm=eps_ttm,
        pe_ratio=pe_ratio,
        peg_ratio=peg_ratio,
        revenue_growth_yoy=revenue_growth_yoy,
        profit_margin=profit_margin,
        debt_to_equity=debt_to_equity,
        fetched_at=datetime.now(timezone.utc),
    )


# ===================================================================
# Value strategy
# ===================================================================


class TestValueStrategy:

    @pytest.fixture()
    def strategy(self) -> ValueStrategy:
        return ValueStrategy()

    @pytest.mark.asyncio
    async def test_long_signal_undervalued(self, strategy: ValueStrategy) -> None:
        f = _fundamentals(peg_ratio=0.8, pe_ratio=15.0, eps_ttm=5.0, revenue_growth_yoy=0.1)
        market = _market(fundamentals=f)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.LONG

    @pytest.mark.asyncio
    async def test_short_signal_overvalued(self, strategy: ValueStrategy) -> None:
        f = _fundamentals(peg_ratio=4.0, pe_ratio=60.0, eps_ttm=-1.0)
        market = _market(fundamentals=f)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.SHORT

    @pytest.mark.asyncio
    async def test_no_signal_without_fundamentals(self, strategy: ValueStrategy) -> None:
        market = _market(fundamentals=None)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is None

    @pytest.mark.asyncio
    async def test_no_signal_neutral_fundamentals(self, strategy: ValueStrategy) -> None:
        f = _fundamentals(peg_ratio=1.5, pe_ratio=20.0, eps_ttm=3.0)
        market = _market(fundamentals=f)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is None

    @pytest.mark.asyncio
    async def test_strength_bounded(self, strategy: ValueStrategy) -> None:
        f = _fundamentals(peg_ratio=0.1, pe_ratio=5.0, eps_ttm=10.0, revenue_growth_yoy=0.5)
        market = _market(fundamentals=f)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert 0 < signal.strength <= 1.0


# ===================================================================
# MACD Crossover strategy
# ===================================================================


class TestMACDCrossoverStrategy:

    @pytest.fixture()
    def strategy(self) -> MACDCrossoverStrategy:
        return MACDCrossoverStrategy()

    @pytest.mark.asyncio
    async def test_long_signal_bullish_crossover(self, strategy: MACDCrossoverStrategy) -> None:
        # Simulate: previous MACD was below signal, now above
        # First call sets the state
        market_prev = _market(macd=-0.5, macd_signal=0.1, macd_histogram=-0.6, atr=2.0)
        await strategy.evaluate("AAPL", market_prev)

        # Second call: MACD crossed above signal
        market = _market(macd=0.5, macd_signal=0.1, macd_histogram=0.4, atr=2.0)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.LONG

    @pytest.mark.asyncio
    async def test_short_signal_bearish_crossover(self, strategy: MACDCrossoverStrategy) -> None:
        # Previous: MACD above signal
        market_prev = _market(macd=0.5, macd_signal=0.1, macd_histogram=0.4, atr=2.0)
        await strategy.evaluate("AAPL", market_prev)

        # Now: MACD crossed below signal
        market = _market(macd=-0.5, macd_signal=0.1, macd_histogram=-0.6, atr=2.0)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.SHORT

    @pytest.mark.asyncio
    async def test_no_signal_without_macd(self, strategy: MACDCrossoverStrategy) -> None:
        market = _market(macd=None, macd_signal=None)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is None

    @pytest.mark.asyncio
    async def test_no_signal_without_crossover(self, strategy: MACDCrossoverStrategy) -> None:
        # Both calls have MACD above signal — no crossover
        market1 = _market(macd=0.5, macd_signal=0.1, macd_histogram=0.4, atr=2.0)
        await strategy.evaluate("AAPL", market1)
        market2 = _market(macd=0.6, macd_signal=0.1, macd_histogram=0.5, atr=2.0)
        signal = await strategy.evaluate("AAPL", market2)
        assert signal is None


# ===================================================================
# Bollinger Breakout strategy
# ===================================================================


class TestBollingerBreakoutStrategy:

    @pytest.fixture()
    def strategy(self) -> BollingerBreakoutStrategy:
        return BollingerBreakoutStrategy()

    @pytest.mark.asyncio
    async def test_long_signal_above_upper_band(self, strategy: BollingerBreakoutStrategy) -> None:
        market = _market(
            price=155.0, bollinger_upper=152.0, bollinger_mid=150.0, bollinger_lower=148.0,
            volume=2_000_000, sma_20=150.0,
        )
        # Need bars to compute average volume
        bars = [{"volume": 1_000_000}] * 20
        market.bars = bars
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.LONG

    @pytest.mark.asyncio
    async def test_long_signal_below_lower_band(self, strategy: BollingerBreakoutStrategy) -> None:
        market = _market(
            price=145.0, bollinger_upper=152.0, bollinger_mid=150.0, bollinger_lower=148.0,
        )
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.LONG

    @pytest.mark.asyncio
    async def test_no_signal_inside_bands(self, strategy: BollingerBreakoutStrategy) -> None:
        market = _market(
            price=150.0, bollinger_upper=155.0, bollinger_mid=150.0, bollinger_lower=145.0,
        )
        signal = await strategy.evaluate("AAPL", market)
        assert signal is None

    @pytest.mark.asyncio
    async def test_no_signal_without_bollinger(self, strategy: BollingerBreakoutStrategy) -> None:
        market = _market()
        signal = await strategy.evaluate("AAPL", market)
        assert signal is None


# ===================================================================
# VWAP strategy
# ===================================================================


class TestVWAPStrategy:

    @pytest.fixture()
    def strategy(self) -> VWAPStrategy:
        return VWAPStrategy()

    @pytest.mark.asyncio
    async def test_long_signal_above_vwap(self, strategy: VWAPStrategy) -> None:
        # First call: below VWAP
        market_prev = _market(price=148.0, vwap=150.0, volume=1_000_000)
        await strategy.evaluate("AAPL", market_prev)

        # Second call: crossed above VWAP with volume
        market = _market(price=152.0, vwap=150.0, volume=1_500_000)
        market.bars = [{"volume": 1_000_000}] * 20
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.LONG

    @pytest.mark.asyncio
    async def test_short_signal_below_vwap(self, strategy: VWAPStrategy) -> None:
        market_prev = _market(price=152.0, vwap=150.0, volume=1_000_000)
        await strategy.evaluate("AAPL", market_prev)

        market = _market(price=148.0, vwap=150.0, volume=1_500_000)
        market.bars = [{"volume": 1_000_000}] * 20
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.SHORT

    @pytest.mark.asyncio
    async def test_no_signal_without_vwap(self, strategy: VWAPStrategy) -> None:
        market = _market(vwap=None)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is None


# ===================================================================
# Liquidity strategy
# ===================================================================


class TestLiquidityStrategy:

    @pytest.fixture()
    def strategy(self) -> LiquidityStrategy:
        return LiquidityStrategy()

    @pytest.mark.asyncio
    async def test_long_signal_high_volume_up(self, strategy: LiquidityStrategy) -> None:
        bars = [{"close": 100.0, "volume": 1_000_000}] * 20
        market = _market(price=105.0, volume=2_500_000, bars=bars)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.LONG

    @pytest.mark.asyncio
    async def test_short_signal_high_volume_down(self, strategy: LiquidityStrategy) -> None:
        bars = [{"close": 100.0, "volume": 1_000_000}] * 20
        market = _market(price=95.0, volume=2_500_000, bars=bars)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.SHORT

    @pytest.mark.asyncio
    async def test_no_signal_thin_volume(self, strategy: LiquidityStrategy) -> None:
        bars = [{"close": 100.0, "volume": 1_000_000}] * 20
        market = _market(price=105.0, volume=400_000, bars=bars)
        signal = await strategy.evaluate("AAPL", market)
        assert signal is None

    @pytest.mark.asyncio
    async def test_no_signal_no_bars(self, strategy: LiquidityStrategy) -> None:
        market = _market(price=105.0, volume=2_000_000, bars=[])
        signal = await strategy.evaluate("AAPL", market)
        assert signal is None


# ===================================================================
# MA Stack strategy
# ===================================================================


class TestMAStackStrategy:

    @pytest.fixture()
    def strategy(self) -> MAStackStrategy:
        return MAStackStrategy()

    @pytest.mark.asyncio
    async def test_full_bull_alignment(self, strategy: MAStackStrategy) -> None:
        market = _market(
            price=160.0, ema_9=155.0, ema_21=150.0, sma_50=145.0, sma_200=140.0,
        )
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.LONG
        assert signal.strength > 0.5

    @pytest.mark.asyncio
    async def test_full_bear_alignment(self, strategy: MAStackStrategy) -> None:
        market = _market(
            price=130.0, ema_9=135.0, ema_21=140.0, sma_50=145.0, sma_200=150.0,
        )
        signal = await strategy.evaluate("AAPL", market)
        assert signal is not None
        assert signal.direction == SignalDirection.SHORT
        assert signal.strength > 0.5

    @pytest.mark.asyncio
    async def test_no_signal_tangled_mas(self, strategy: MAStackStrategy) -> None:
        market = _market(
            price=150.0, ema_9=151.0, ema_21=149.0, sma_50=152.0, sma_200=148.0,
        )
        signal = await strategy.evaluate("AAPL", market)
        assert signal is None

    @pytest.mark.asyncio
    async def test_no_signal_missing_mas(self, strategy: MAStackStrategy) -> None:
        market = _market(ema_9=155.0)  # Missing others
        signal = await strategy.evaluate("AAPL", market)
        assert signal is None

    @pytest.mark.asyncio
    async def test_partial_bull(self, strategy: MAStackStrategy) -> None:
        # Price > EMA-9 > EMA-21, but below SMA-200 (partial bull)
        market = _market(
            price=155.0, ema_9=152.0, ema_21=148.0, sma_50=145.0, sma_200=160.0,
        )
        signal = await strategy.evaluate("AAPL", market)
        # Should still produce LONG but with lower strength
        if signal is not None:
            assert signal.direction == SignalDirection.LONG
            assert signal.strength < 0.8


# ===================================================================
# Cross-strategy tests
# ===================================================================


class TestNewStrategyCrossChecks:

    def test_all_new_strategies_inherit_base(self) -> None:
        for cls in (ValueStrategy, MACDCrossoverStrategy, BollingerBreakoutStrategy,
                    VWAPStrategy, LiquidityStrategy, MAStackStrategy):
            assert issubclass(cls, BaseStrategy)

    def test_all_strategy_names_unique(self) -> None:
        strategies = [
            ValueStrategy(), MACDCrossoverStrategy(), BollingerBreakoutStrategy(),
            VWAPStrategy(), LiquidityStrategy(), MAStackStrategy(),
        ]
        names = [s.name for s in strategies]
        assert len(names) == len(set(names))

    def test_strategy_names_non_empty(self) -> None:
        for cls in (ValueStrategy, MACDCrossoverStrategy, BollingerBreakoutStrategy,
                    VWAPStrategy, LiquidityStrategy, MAStackStrategy):
            assert len(cls().name) > 0
```

**Step 2: Run tests to verify they fail**

Run: `python -m pytest tests/test_new_strategies.py -v`
Expected: FAIL — strategy modules don't exist

**Step 3: Implement all 6 strategies**

Create each strategy file following the `BaseStrategy.evaluate()` interface. Each strategy:
- Has a `name: str` class attribute
- Implements `async def evaluate(self, ticker, market, sentiment) -> TradeSignal | None`
- Returns `None` when required data is missing

**`shared/strategies/value.py`:**
```python
"""Value investing strategy — trade on fundamental data."""

from datetime import datetime, timezone

from shared.schemas.trading import MarketSnapshot, SentimentContext, SignalDirection, TradeSignal
from shared.strategies.base import BaseStrategy


class ValueStrategy(BaseStrategy):
    """Generate signals from fundamental metrics (EPS, P/E, PEG, etc.)."""

    name: str = "value"

    async def evaluate(
        self,
        ticker: str,
        market: MarketSnapshot,
        sentiment: SentimentContext | None = None,
    ) -> TradeSignal | None:
        f = market.fundamentals
        if f is None:
            return None

        # Need at least PEG and P/E to form an opinion
        if f.peg_ratio is None or f.pe_ratio is None:
            return None

        score = 0.0  # Positive = undervalued, negative = overvalued

        # PEG ratio: < 1.0 is undervalued, > 3.0 is overvalued
        if f.peg_ratio < 1.0:
            score += (1.0 - f.peg_ratio)  # max 1.0
        elif f.peg_ratio > 3.0:
            score -= min((f.peg_ratio - 3.0) / 3.0, 1.0)

        # P/E ratio: < 15 is cheap, > 40 is expensive
        if f.pe_ratio < 15:
            score += (15 - f.pe_ratio) / 15
        elif f.pe_ratio > 40:
            score -= min((f.pe_ratio - 40) / 40, 1.0)

        # EPS: positive is good, negative is bad
        if f.eps_ttm is not None:
            if f.eps_ttm > 0:
                score += 0.2
            elif f.eps_ttm < 0:
                score -= 0.3

        # Revenue growth: positive growth is bullish
        if f.revenue_growth_yoy is not None:
            if f.revenue_growth_yoy > 0.1:
                score += 0.2
            elif f.revenue_growth_yoy < -0.1:
                score -= 0.2

        # Profit margin: healthy margin is bullish
        if f.profit_margin is not None:
            if f.profit_margin > 0.15:
                score += 0.1
            elif f.profit_margin < 0:
                score -= 0.2

        # Debt-to-equity: low is healthy
        if f.debt_to_equity is not None:
            if f.debt_to_equity > 3.0:
                score -= 0.2
            elif f.debt_to_equity < 0.5:
                score += 0.1

        # Determine direction and strength
        if score > 0.3:
            direction = SignalDirection.LONG
        elif score < -0.3:
            direction = SignalDirection.SHORT
        else:
            return None

        strength = max(0.0, min(1.0, abs(score) / 2.0))

        return TradeSignal(
            ticker=ticker,
            direction=direction,
            strength=strength,
            strategy_sources=[self.name],
            timestamp=datetime.now(tz=timezone.utc),
        )
```

**`shared/strategies/macd_crossover.py`:**
```python
"""MACD crossover strategy — trade on MACD/signal line crossovers."""

from datetime import datetime, timezone

from shared.schemas.trading import MarketSnapshot, SentimentContext, SignalDirection, TradeSignal
from shared.strategies.base import BaseStrategy


class MACDCrossoverStrategy(BaseStrategy):
    """Detect MACD/signal line crossovers for trade signals."""

    name: str = "macd_crossover"

    def __init__(self) -> None:
        self._prev_macd: dict[str, float] = {}
        self._prev_signal: dict[str, float] = {}

    async def evaluate(
        self,
        ticker: str,
        market: MarketSnapshot,
        sentiment: SentimentContext | None = None,
    ) -> TradeSignal | None:
        if market.macd is None or market.macd_signal is None:
            return None

        macd = market.macd
        sig = market.macd_signal
        prev_macd = self._prev_macd.get(ticker)
        prev_signal = self._prev_signal.get(ticker)

        # Store current state for next evaluation
        self._prev_macd[ticker] = macd
        self._prev_signal[ticker] = sig

        # Need previous state to detect a crossover
        if prev_macd is None or prev_signal is None:
            return None

        prev_diff = prev_macd - prev_signal
        curr_diff = macd - sig

        # Detect crossover: sign change
        if prev_diff <= 0 and curr_diff > 0:
            direction = SignalDirection.LONG
        elif prev_diff >= 0 and curr_diff < 0:
            direction = SignalDirection.SHORT
        else:
            return None

        # Strength: magnitude of histogram normalized by ATR if available
        histogram = abs(market.macd_histogram) if market.macd_histogram is not None else abs(curr_diff)
        if market.atr and market.atr > 0:
            raw_strength = histogram / market.atr
        else:
            raw_strength = min(histogram / 2.0, 1.0)

        strength = max(0.0, min(1.0, raw_strength))

        return TradeSignal(
            ticker=ticker,
            direction=direction,
            strength=strength,
            strategy_sources=[self.name],
            timestamp=datetime.now(tz=timezone.utc),
        )
```

**`shared/strategies/bollinger_breakout.py`:**
```python
"""Bollinger Bands breakout strategy."""

from datetime import datetime, timezone

from shared.schemas.trading import MarketSnapshot, SentimentContext, SignalDirection, TradeSignal
from shared.strategies.base import BaseStrategy


class BollingerBreakoutStrategy(BaseStrategy):
    """Generate signals from Bollinger Band breakouts."""

    name: str = "bollinger_breakout"

    async def evaluate(
        self,
        ticker: str,
        market: MarketSnapshot,
        sentiment: SentimentContext | None = None,
    ) -> TradeSignal | None:
        if market.bollinger_upper is None or market.bollinger_lower is None or market.bollinger_mid is None:
            return None

        price = market.current_price
        upper = market.bollinger_upper
        lower = market.bollinger_lower
        band_width = upper - lower
        if band_width <= 0:
            return None

        direction: SignalDirection | None = None

        if price > upper:
            # Breakout above upper band — check for volume confirmation
            avg_vol = _avg_volume(market.bars)
            if avg_vol and market.volume > avg_vol * 1.5:
                direction = SignalDirection.LONG
            else:
                # Above band but no volume = potential failed breakout, skip
                return None
        elif price < lower:
            # Below lower band — mean reversion bounce expected
            direction = SignalDirection.LONG
        else:
            return None

        # Strength: how far price is from the band, relative to band width
        if direction == SignalDirection.LONG and price > upper:
            raw_strength = (price - upper) / band_width
        elif price < lower:
            raw_strength = (lower - price) / band_width
        else:
            raw_strength = 0.3

        strength = max(0.0, min(1.0, raw_strength))

        return TradeSignal(
            ticker=ticker,
            direction=direction,
            strength=strength,
            strategy_sources=[self.name],
            timestamp=datetime.now(tz=timezone.utc),
        )


def _avg_volume(bars: list[dict]) -> float | None:
    """Compute average volume from bar dicts."""
    if not bars:
        return None
    volumes = [b.get("volume", 0) for b in bars if "volume" in b]
    if not volumes:
        return None
    return sum(volumes) / len(volumes)
```

**`shared/strategies/vwap.py`:**
```python
"""VWAP strategy — trade on price crossing VWAP."""

from datetime import datetime, timezone

from shared.schemas.trading import MarketSnapshot, SentimentContext, SignalDirection, TradeSignal
from shared.strategies.base import BaseStrategy


class VWAPStrategy(BaseStrategy):
    """Generate signals when price crosses VWAP with volume confirmation."""

    name: str = "vwap"

    def __init__(self) -> None:
        self._prev_price: dict[str, float] = {}
        self._prev_vwap: dict[str, float] = {}

    async def evaluate(
        self,
        ticker: str,
        market: MarketSnapshot,
        sentiment: SentimentContext | None = None,
    ) -> TradeSignal | None:
        if market.vwap is None:
            return None

        price = market.current_price
        vwap = market.vwap
        prev_price = self._prev_price.get(ticker)
        prev_vwap = self._prev_vwap.get(ticker)

        self._prev_price[ticker] = price
        self._prev_vwap[ticker] = vwap

        if prev_price is None or prev_vwap is None:
            return None

        prev_diff = prev_price - prev_vwap
        curr_diff = price - vwap

        # Detect crossover
        if prev_diff <= 0 and curr_diff > 0:
            direction = SignalDirection.LONG
        elif prev_diff >= 0 and curr_diff < 0:
            direction = SignalDirection.SHORT
        else:
            return None

        # Strength: distance from VWAP as % of price, amplified by relative volume
        distance_pct = abs(curr_diff) / price if price > 0 else 0
        vol_ratio = 1.0
        avg_vol = _avg_volume(market.bars)
        if avg_vol and avg_vol > 0:
            vol_ratio = min(market.volume / avg_vol, 3.0) / 3.0

        raw_strength = distance_pct * 20 * vol_ratio  # Scale up since % distance is small
        strength = max(0.0, min(1.0, raw_strength))

        return TradeSignal(
            ticker=ticker,
            direction=direction,
            strength=strength,
            strategy_sources=[self.name],
            timestamp=datetime.now(tz=timezone.utc),
        )


def _avg_volume(bars: list[dict]) -> float | None:
    if not bars:
        return None
    volumes = [b.get("volume", 0) for b in bars if "volume" in b]
    return sum(volumes) / len(volumes) if volumes else None
```

**`shared/strategies/liquidity.py`:**
```python
"""Liquidity strategy — trade on volume patterns."""

from datetime import datetime, timezone

from shared.schemas.trading import MarketSnapshot, SentimentContext, SignalDirection, TradeSignal
from shared.strategies.base import BaseStrategy


class LiquidityStrategy(BaseStrategy):
    """Analyze volume-based liquidity to confirm directional moves."""

    name: str = "liquidity"

    async def evaluate(
        self,
        ticker: str,
        market: MarketSnapshot,
        sentiment: SentimentContext | None = None,
    ) -> TradeSignal | None:
        if not market.bars or len(market.bars) < 5:
            return None

        # Compute average volume from bars
        volumes = [b.get("volume", 0) for b in market.bars if "volume" in b]
        if not volumes:
            return None

        avg_vol = sum(volumes) / len(volumes)
        if avg_vol <= 0:
            return None

        relative_volume = market.volume / avg_vol

        # Thin liquidity — unreliable, skip
        if relative_volume < 1.0:
            return None

        # Determine price direction from bars
        closes = [b.get("close", 0) for b in market.bars if "close" in b]
        if len(closes) < 2:
            return None

        # Compare current price to recent average close
        recent_avg = sum(closes[-5:]) / min(len(closes), 5)
        price_change = (market.current_price - recent_avg) / recent_avg if recent_avg > 0 else 0

        if relative_volume >= 2.0 and price_change > 0.001:
            direction = SignalDirection.LONG
        elif relative_volume >= 2.0 and price_change < -0.001:
            direction = SignalDirection.SHORT
        elif price_change > 0.001 and relative_volume < 0.7:
            # Price rising on declining volume — weak rally
            direction = SignalDirection.SHORT
        else:
            return None

        # Strength based on relative volume magnitude
        raw_strength = min(relative_volume / 4.0, 1.0)
        strength = max(0.0, min(1.0, raw_strength))

        return TradeSignal(
            ticker=ticker,
            direction=direction,
            strength=strength,
            strategy_sources=[self.name],
            timestamp=datetime.now(tz=timezone.utc),
        )
```

**`shared/strategies/ma_stack.py`:**
```python
"""MA Stack strategy — read the full 5-MA stack for trend alignment."""

from datetime import datetime, timezone

from shared.schemas.trading import MarketSnapshot, SentimentContext, SignalDirection, TradeSignal
from shared.strategies.base import BaseStrategy


class MAStackStrategy(BaseStrategy):
    """Assess trend strength from the alignment of 5 moving averages."""

    name: str = "ma_stack"

    def __init__(self) -> None:
        self._prev_sma50: dict[str, float] = {}
        self._prev_sma200: dict[str, float] = {}

    async def evaluate(
        self,
        ticker: str,
        market: MarketSnapshot,
        sentiment: SentimentContext | None = None,
    ) -> TradeSignal | None:
        # Need all MAs
        if any(v is None for v in [market.ema_9, market.ema_21, market.sma_50, market.sma_200]):
            return None

        price = market.current_price
        ema_9 = market.ema_9
        ema_21 = market.ema_21
        sma_50 = market.sma_50
        sma_200 = market.sma_200

        # Count bull alignment: each pair in order scores a point
        values = [price, ema_9, ema_21, sma_50, sma_200]
        bull_score = sum(1 for i in range(len(values) - 1) if values[i] > values[i + 1])
        bear_score = sum(1 for i in range(len(values) - 1) if values[i] < values[i + 1])

        # Golden/death cross detection
        prev_50 = self._prev_sma50.get(ticker)
        prev_200 = self._prev_sma200.get(ticker)
        self._prev_sma50[ticker] = sma_50
        self._prev_sma200[ticker] = sma_200

        cross_bonus = 0.0
        if prev_50 is not None and prev_200 is not None:
            if prev_50 <= prev_200 and sma_50 > sma_200:
                cross_bonus = 0.2  # Golden cross
            elif prev_50 >= prev_200 and sma_50 < sma_200:
                cross_bonus = -0.2  # Death cross

        if bull_score >= 3:
            direction = SignalDirection.LONG
            raw_strength = bull_score / 4.0 + max(cross_bonus, 0)
        elif bear_score >= 3:
            direction = SignalDirection.SHORT
            raw_strength = bear_score / 4.0 + max(-cross_bonus, 0)
        else:
            # Tangled — no clear trend
            return None

        strength = max(0.0, min(1.0, raw_strength))

        return TradeSignal(
            ticker=ticker,
            direction=direction,
            strength=strength,
            strategy_sources=[self.name],
            timestamp=datetime.now(tz=timezone.utc),
        )
```

**Step 4: Update `shared/strategies/__init__.py`**

Add imports for all 6 new strategies and update `__all__`.

**Step 5: Run tests**

Run: `python -m pytest tests/test_new_strategies.py tests/test_strategies.py -v`
Expected: All PASS

**Step 6: Commit**

```bash
git add shared/strategies/ tests/test_new_strategies.py
git commit -m "feat: add 6 new strategies (value, MACD, Bollinger, VWAP, liquidity, MA stack)"
```

---

## Task 6: Wire everything into the signal generator

**Files:**
- Modify: `services/signal_generator/main.py`
- Modify: `services/signal_generator/config.py`
- Modify: `.env`
- Modify: `scripts/seed_strategies.py`
- Modify: `pyproject.toml`

**Step 1: Update signal generator config**

In `services/signal_generator/config.py`, add:
```python
alpha_vantage_api_key: str = ""
fmp_api_key: str = ""
fundamentals_cache_ttl_hours: int = 24
```

**Step 2: Update `.env`**

Add:
```
TRADING_ALPHA_VANTAGE_API_KEY=M0I3TWB6VKU0UF51
TRADING_FMP_API_KEY=34zqbQFeRxYvPtzp3Y5QLKPVPztkZyfK
TRADING_FUNDAMENTALS_CACHE_TTL_HOURS=24
TRADING_HISTORICAL_BARS=250
```

**Step 3: Update `services/signal_generator/main.py`**

1. Import the 6 new strategies.
2. Update `_DEFAULT_WEIGHTS` to include all 9 strategies (equal weight ~0.111).
3. Add fundamentals initialization:
   - Create `RotatingProvider` with all three providers
   - Wrap with `CachedFundamentalsProvider`
   - Fetch fundamentals for watchlist tickers on startup
   - Store in a `dict[str, FundamentalsSnapshot]`
4. In `_consume_scored_articles`, inject fundamentals into `MarketSnapshot` before calling ensemble:
   ```python
   if fundamentals_cache:
       snapshot.fundamentals = fundamentals_cache.get(ticker)
   ```
5. Add a daily refresh background task for fundamentals.

**Step 4: Update `scripts/seed_strategies.py`**

Add 6 new strategies to `DEFAULT_STRATEGIES` with descriptions and equal weights (recalculate to ~0.111).

**Step 5: Update `pyproject.toml`**

Add `yfinance` to the `trading` optional dependency group:
```toml
trading = ["alpaca-py>=0.21", "pytz>=2024.1", "yfinance>=0.2"]
```

Add `httpx` to the `trading` group if not already available (it's in `news` group but signal-generator uses the `trading` group):
```toml
trading = ["alpaca-py>=0.21", "pytz>=2024.1", "yfinance>=0.2", "httpx>=0.27"]
```

**Step 6: Run all tests**

Run: `python -m pytest tests/ -v -m "not integration" --timeout=30`
Expected: All tests PASS (should be ~270+ tests now)

**Step 7: Commit**

```bash
git add services/signal_generator/ scripts/seed_strategies.py .env pyproject.toml
git commit -m "feat: wire 6 new strategies and fundamentals into signal generator"
```

---

## Task 7: Update MarketDataManager max_bars default

**Files:**
- Modify: `services/signal_generator/market_data.py:16`

**Step 1: Update default max bars**

Change `_DEFAULT_MAX_BARS = 100` to `_DEFAULT_MAX_BARS = 250`.

**Step 2: Run tests**

Run: `python -m pytest tests/test_indicators.py tests/ -v -m "not integration" --timeout=30`
Expected: All PASS

**Step 3: Commit**

```bash
git add services/signal_generator/market_data.py
git commit -m "feat: increase default max bars to 250 for SMA-200 support"
```

---

## Task 8: Run migration and seed new strategies

**Step 1: Apply migration (if docker is running)**

Run: `docker compose exec api-gateway python -m alembic upgrade head`

**Step 2: Seed new strategies**

Run: `docker compose exec api-gateway python -m scripts.seed_strategies`

**Step 3: Rebuild and restart services**

Run: `docker compose build signal-generator && docker compose up -d signal-generator`

**Step 4: Verify**

Check logs: `docker compose logs signal-generator --tail 50`
Expected: All 9 strategies loaded, fundamentals fetched for watchlist tickers.