feat: default ingest to Yahoo and restore a full README

Use Yahoo Finance as the default tape for config, CLI, Gradio, and UIs; fail closed instead of silently simulating. Merge the algotrader 2.0 lab docs with the v1 FinRL/agentic README and drop the Northwestern line.

Co-authored-by: Cursor <cursoragent@cursor.com>

README.md

@@ -1,127 +1,87 @@
-# Backtest Reality Check
+# Algorithmic Trading
 
-**algotrader 2.0 — a backtester that tries to prove itself wrong.**
+Parallel LLC. Two layers in one repository:
 
-Most backtesting tools answer *"how much would this have made?"*. That is the easy
-question, and the answer is almost always flattering. This one answers the question
-you actually need before risking money: **how much of that was luck?**
+1. **algotrader 2.0** (`algotrader/`, `app.py`): a backtester that tries to prove a rule was luck (permutation, deflated Sharpe, PBO, walk-forward, cost stress).
+2. **Agentic v1** (`agentic_ai_system/`): FinRL policies, Yahoo or Alpaca ingest, paper/live execution, Streamlit/Dash/Jupyter UIs, Docker.
 
-```bash
-pip install -r requirements-space.txt
-python app.py                                   # the Gradio app on localhost:7860
-python -m algotrader.cli lab --symbol SPY --strategy sma_cross
-```
-
-<sub>The v1 agentic trading system (FinRL, Alpaca, Yahoo ingest, Streamlit/Dash UIs) is
-unchanged and still lives here — see [docs/AGENTIC_SYSTEM_V1.md](docs/AGENTIC_SYSTEM_V1.md).</sub>
+Default market data is **Yahoo Finance** (`yfinance>=1.0`), not simulated prices. The simulator exists for offline tests (`--source synthetic` or `ALGOTRADER_OFFLINE=1` with `source=auto`). Live capital still needs a separate evaluation contract. This is research tooling, not investment advice.
 
 ---
 
-## Two labs
+## 1. Title and Summary
 
-**The Lab** validates a timing rule on one asset. **The Portfolio Lab** validates a
-cross-sectional book that ranks many names — and it asks three harder questions,
-because a long-short book fails in ways a timing rule cannot.
+**Algorithmic Trading**  
+Ingest real OHLCV, test whether a timing or cross-sectional rule survives a hostile null, optionally train a FinRL policy, size orders under position and drawdown caps, route to paper or live Alpaca.
 
-## The four ways a backtest lies
+GitHub keeps two branches: `main` (protected) and `dev` (integration).
 
-| The lie | The test | Where |
-|---|---|---|
-| The market had no structure to find | Monte-Carlo **permutation test** — re-run your rule on hundreds of shuffled markets | `algotrader/validation/permutation.py` |
-| You tried 200 things and reported the best | **Deflated Sharpe Ratio** — charge for every variant you tried | `algotrader/validation/deflated_sharpe.py` |
-| The parameters were fitted to the past | **PBO** (CSCV) and **walk-forward** | `algotrader/validation/pbo.py`, `walkforward.py` |
-| The edge is smaller than the costs | **Cost stress test** at 3× friction | `algotrader/lab.py` |
-
-Each feeds a single **Reality Score** out of 100 with a grade from A to F:
-
-| Weight | Component | What it measures |
-|---:|---|---|
-| 30% | Significance | How far outside the shuffled-market null the result sits |
-| 25% | Selection | Deflated Sharpe — does it clear the best-of-N bar |
-| 20% | Walk-forward | How much of the tuned Sharpe survived trading forward |
-| 15% | Overfitting | 1 − PBO |
-| 10% | Robustness | Sharpe retained when costs triple |
-
-The scale is deliberately harsh. On most markets, plain buy & hold beats every
-strategy in the arena on evidence, and the built-in coin-flip control out-ranks
-several respectable-looking rules. That is the finding, not a bug.
-
-## The permutation test, concretely
-
-We take the real price series and shuffle it. Each bar's gap, high, low, body and
-volume are kept intact, but their **order** is destroyed. The result is a market
-with the same volatility and the same fat tails, and no exploitable structure at
-all. Then we re-run *your exact rule* on hundreds of these shuffled markets.
-
-If your Sharpe sits inside that cloud, your rule found nothing that a coin-flip
-market would not also have handed it. The p-value is the share of shuffled markets
-that did as well or better.
-
-Block mode resamples contiguous chunks instead of single bars, preserving
-short-horizon momentum and volatility clustering — a harder null that trend
-strategies deserve to be held to.
-
-## Cross-sectional books get a harder null
-
-Shuffling the price path is the right null for a timing rule and the *wrong* one for
-a book that ranks names: it destroys the market's whole correlation structure, and
-almost any long-short book clears a null that weak.
-
-So the Portfolio Lab permutes the **weights across assets within each date**. Every
-calendar effect survives. Every correlation between names survives. Each date's gross
-exposure, net exposure and position count survive *exactly*. The only thing destroyed
-is the link between the strategy's choice and the asset it chose.
-
-A book that beats that null is picking names. One that doesn't was being paid for
-market exposure or a style tilt — which the factor regression measures directly:
-
-| Question | Test |
-|---|---|
-| Did it pick the right names? | Within-date weight permutation |
-| Is it alpha, or beta you can buy for 3bps? | Style regression (market, momentum, low-vol, reversal, liquidity) with White standard errors |
-| Does the universe contain the losers? | Survivorship measured, not assumed |
-
-That last one is not optional. A universe where every name is still trading after ten
-years was chosen after the fact, and every result computed on it is an upper bound.
-The Panel measures survival directly and the Reality Score caps at 60 when it finds
-none.
+**Design themes**
 
-```python
-from algotrader import PortfolioLabConfig, run_portfolio_lab
+* Yahoo as the default public tape (delayed, unofficial, lookback-limited)
+* Validation before belief: permutation, DSR, PBO/CSCV, walk-forward, 3× cost stress
+* FinRL (PPO, A2C, DDPG, TD3) unchanged on the v1 path
+* Alpaca optional for authenticated bars and orders; keys from the environment
+* Synthetic GBM / regime simulator only when requested
+* Secrets never in git
 
-report = run_portfolio_lab(PortfolioLabConfig(
-    symbols=["SPY", "QQQ", "AAPL", "MSFT", "NVDA", "GLD", "TLT"],
-    strategy="xs_momentum",
-    rebalance="M",
-))
-print(report.verdict["grade"], report.permutation.p_value)
-print(report.attribution["note"])
-print(report.survivorship.note)
+---
+
+## 2. Quick start
+
+```bash
+git clone https://github.com/ParallelLLC/algorithmic_trading.git
+cd algorithmic_trading
+python -m venv .venv && source .venv/bin/activate
+pip install -r requirements-space.txt   # algotrader + Gradio
+# or: pip install -r requirements.txt   # full v1 stack (FinRL, Dash, Docker CI)
 ```
 
 ```bash
-python -m algotrader.cli portfolio --symbols SPY,QQQ,AAPL,MSFT,NVDA --strategy xs_momentum
+python app.py                                      # Gradio, localhost:7860, Yahoo by default
+python -m algotrader.cli lab --symbol SPY --strategy sma_cross
+python -m algotrader.cli lab --symbol NVDA --strategy rsi_reversion --permutations 500
+python -m agentic_ai_system.main --mode backtest --start-date 2024-01-01 --end-date 2024-12-31
+```
+
+`config.yaml` defaults:
+
+```yaml
+data_source:
+  type: 'yahoo'
+trading:
+  symbol: 'AAPL'
+  timeframe: '1d'    # Yahoo 1m history is ~7 days; use 1d for multi-year windows
+yahoo:
+  auto_adjust: true  # raw Close turns splits into fake crashes
 ```
 
-## Turnover is measured against drift, not against the last target
+Alpaca is opt-in: `ALPACA_API_KEY` / `ALPACA_SECRET_KEY` and `data_source.type: alpaca` or `execution.broker_api: alpaca_paper`.
+
+---
+
+## 3. algotrader 2.0 (validation lab)
+
+Most backtests answer "how much would this have made?" This one asks **how much of that was luck?**
+
+### Two labs
+
+**The Lab** validates a timing rule on one asset. **The Portfolio Lab** validates a cross-sectional book that ranks many names.
 
-Holding 50% of a book in a name that doubles leaves you at 67% without trading. A
-backtest that charges turnover as `|target[t] - target[t-1]|` understates the cost of
-doing nothing and overstates the cost of rebalancing. Both engines measure turnover
-against the *drifted* weight instead, and a rebalance schedule (`D`/`W`/`M`/`Q`) lets a
-monthly book drift between dates rather than paying daily to stand still.
+### The four ways a backtest lies
 
-## No look-ahead, by construction
+| The lie | The test | Where |
+| --- | --- | --- |
+| The market had no structure to find | Monte-Carlo permutation (shuffle bar order, keep gap/high/low/body/volume) | `algotrader/validation/permutation.py` |
+| You tried 200 things and reported the best | Deflated Sharpe Ratio | `algotrader/validation/deflated_sharpe.py` |
+| Parameters were fitted to the past | PBO (CSCV) and walk-forward | `algotrader/validation/pbo.py`, `walkforward.py` |
+| The edge is smaller than the costs | Cost stress at 3× friction | `algotrader/lab.py` |
 
-A strategy emits a target exposure at each bar's close using only data up to that
-bar. The engine holds `position[t] = target[t - lag]` with `lag >= 1`, so a signal
-computed on Tuesday's close cannot earn Tuesday's move.
+Reality Score (0–100, grades A–F): significance 30%, selection 25%, walk-forward 20%, overfitting 15%, robustness 10%. The scale is harsh on purpose. Buy-and-hold and a coin-flip stay in the arena as controls.
 
-That is the single line where look-ahead could enter, and the test suite asserts it
-from four directions — including that truncating the data never changes the equity
-curve before the cut, and that a `lag=0` request is refused outright.
+Cross-sectional books use a **within-date weight permutation** so market correlation survives; path-shuffle is the wrong null for a long-short ranker. Survivorship is measured. Style regression (market, momentum, low-vol, reversal, liquidity) with White standard errors.
 
-## Python API
+Look-ahead: `position[t] = target[t - lag]` with `lag >= 1`. Turnover is measured against drifted weights, not `|target[t]-target[t-1]|`.
 
 ```python
 from algotrader import LabConfig, run_lab
@@ -131,114 +91,108 @@ report = run_lab(LabConfig(
     start="2015-01-01",
     strategy="sma_cross",
     params={"fast": 20, "slow": 100},
-    commission_bps=1.0,
-    slippage_bps=2.0,
+    source="yahoo",
     n_permutations=500,
 ))
+print(report.verdict["grade"], report.permutation.p_value, report.dsr["dsr"])
+```
 
-print(report.verdict["grade"], report.verdict["score"])
-print("p-value          ", report.permutation.p_value)
-print("deflated Sharpe  ", report.dsr["dsr"])
-print("overfit prob.    ", report.pbo["pbo"])
-print("walk-forward eff.", report.walkforward["efficiency"])
-for flag in report.verdict["flags"]:
-    print(" !", flag)
+```bash
+python -m algotrader.cli strategies
+python -m algotrader.cli lab --symbol SPY --source yahoo
+python -m algotrader.cli portfolio --symbols SPY,QQQ,AAPL,MSFT,NVDA --strategy xs_momentum
+python -m algotrader.cli lab --source synthetic   # offline tests only
 ```
 
-Lower-level pieces compose on their own:
+Single-asset zoo: `buy_and_hold`, `sma_cross`, `ema_cross`, `macd_trend`, `rsi_reversion`, `bollinger_reversion`, `donchian_breakout`, `momentum`, `vol_target_momentum`, `channel_trend`, `coin_flip`.
 
-```python
-from algotrader import load_ohlcv, run_backtest, get_strategy
-from algotrader.types import CostModel
-
-market = load_ohlcv("BTC-USD", "2018-01-01")
-strategy = get_strategy("donchian_breakout")
-result = run_backtest(
-    market.df,
-    strategy.generate(market.df, {"window": 55}),
-    costs=CostModel(commission_bps=1, slippage_bps=5, short_borrow_bps=50),
-)
-print(result.metrics["sharpe"], result.metrics["max_drawdown"])
-```
+Cross-sectional: `equal_weight`, `xs_momentum`, `xs_reversal`, `low_volatility`, `xs_value_proxy`, `xs_random`.
 
-## CLI
+**Data:** `load_ohlcv(..., source="yahoo")` downloads from Yahoo and **raises** if the download is empty. `source="auto"` is the Space fallback (cache, then simulator). `ALGOTRADER_OFFLINE=1` disables the network.
 
-```bash
-python -m algotrader.cli strategies                     # list the zoo
-python -m algotrader.cli lab --symbol NVDA --strategy rsi_reversion --permutations 500
-python -m algotrader.cli lab --symbol SPY --param fast=10 --param slow=50 --json
-python -m algotrader.cli arena --symbol BTC-USD --start 2018-01-01
-```
+**HF Space:** `HF_TOKEN=hf_xxx ./scripts/deploy_hf_space.sh <user>/backtest-reality-check`. Card is `SPACE_README.md`. Tests: `python -m pytest tests/test_v2_*.py -q`.
 
-`--source synthetic` forces the offline simulator, which makes runs fully
-deterministic and network-free.
+References: Bailey & López de Prado (2014) DSR; Bailey et al. (2016) PBO; Masters (2018) permutation tests for trading systems.
 
-## The strategy zoo
+---
 
-Single asset: `buy_and_hold` · `sma_cross` · `ema_cross` · `macd_trend` ·
-`rsi_reversion` · `bollinger_reversion` · `donchian_breakout` · `momentum` ·
-`vol_target_momentum` · `channel_trend` · `coin_flip`
+## 4. Concepts and methods (v1 ingest and execution)
 
-Cross-sectional: `equal_weight` · `xs_momentum` · `xs_reversal` · `low_volatility` ·
-`xs_value_proxy` · `xs_random`
+| Source | Default? | Failure modes |
+| ------ | -------- | ------------- |
+| **Yahoo** | Yes (`config.yaml`, algotrader CLI, Gradio) | Unofficial API, ~15 min delay, 1m ≈ 7 days, split-adjustment required (`auto_adjust: true`) |
+| **Alpaca** | Optional | Auth, feed, rate limits |
+| **CSV** | Replay | Missing path or OHLCV columns |
+| **Synthetic** | Tests / `--source synthetic` | Not tradable edge |
 
-Buy & hold and the coin flip are controls, and they stay in the arena on purpose: a
-leaderboard without a control group is marketing, not measurement.
+`agentic_ai_system.data_ingestion.load_data` dispatches on `data_source.type`. Yahoo stream: `yahoo_data_stream.py` (clamped lookback, no incomplete bars by default).
 
-Adding one is a function and a registry entry — see `algotrader/strategies.py`.
+* `StrategyAgent`: SMA, RSI, Bollinger, MACD on Close (teaching rule, not an alpha claim)
+* `FinRLAgent`: PPO / A2C / DDPG / TD3 via Stable-Baselines3
+* `ExecutionAgent` / `AlpacaBroker`: paper simulation or Alpaca orders
 
-## Data
+v1 `run_backtest` is a single in-sample pass unless you use algotrader walk-forward. Leakage is the null hypothesis.
 
-Live prices come from Yahoo Finance. When the network is unavailable or rate-limited,
-the app falls back to a deterministic market simulator — regime switching, Student-t
-innovations, persistent volatility — and says so on every result. Naive geometric
-Brownian motion flatters strategies; this simulator does not.
+---
 
-Set `ALGOTRADER_OFFLINE=1` to skip network access entirely.
+## 5. Stack
 
-## Deploying the Hugging Face Space
+| Layer | Tools |
+| ----- | ----- |
+| Language | Python 3.11 (CI) |
+| Validation | algotrader (permutation, DSR, PBO, walk-forward) |
+| RL | FinRL / Stable-Baselines3, Gym/Gymnasium, PyTorch |
+| Market data | yfinance ≥ 1.0 (default); alpaca-py optional |
+| Tabular | pandas, NumPy, scikit-learn |
+| UI | Gradio (`app.py`); Streamlit, Dash, Jupyter (v1) |
+| Deploy | Docker Compose, GitHub Actions, Hugging Face Space |
+| Tests | pytest |
 
-The Space ships `app.py` plus the `algotrader` package and nothing else, so it builds
-in well under a minute:
+---
 
-```bash
-HF_TOKEN=hf_xxx ./scripts/deploy_hf_space.sh <your-username>/backtest-reality-check
+## 6. Structure
+
+```
+algorithmic_trading/
+├── algotrader/                 # 2.0 lab, engine, validation, strategies
+├── app.py                      # Gradio Reality Check
+├── agentic_ai_system/          # v1 FinRL, Yahoo/Alpaca ingest, execution
+├── ui/                         # Streamlit, Dash, Jupyter, WebSocket
+├── tests/
+├── docs/AGENTIC_SYSTEM_V1.md   # v1 notes
+├── config.yaml                 # default data_source.type: yahoo
+├── requirements-space.txt      # Space / algotrader
+├── requirements.txt            # full v1 + CI
+└── scripts/deploy_hf_space.sh
 ```
 
-Or set the `HF_TOKEN` secret and `HF_SPACE_ID` variable on the repository and let
-`.github/workflows/sync-hf-space.yml` publish on every push to `main`. The workflow
-runs the test suite and builds the app before it publishes anything.
+---
 
-`SPACE_README.md` is the Space card (with the Hugging Face YAML frontmatter);
-`requirements-space.txt` is its dependency set. The root `requirements.txt` still
-carries the full v1 stack for CI, Docker and the FinRL agents.
+## 7. Configuration
 
-## Tests
+| Key | Meaning |
+| --- | ------- |
+| `data_source.type` | `yahoo` (default) \| `csv` \| `synthetic` \| `alpaca` |
+| `trading.timeframe` | Mapped to Yahoo intervals; use `1d` for multi-year history |
+| `yahoo.auto_adjust` | Split/dividend adjust (keep true) |
+| `yahoo.emit_incomplete_bars` | Default false; forming bars are not closes |
+| `execution.broker_api` | `paper` \| `alpaca_paper` \| `alpaca_live` |
+| `finrl.algorithm` | PPO, A2C, DDPG, TD3 |
+| algotrader `--source` | `yahoo` (default) \| `auto` \| `cache` \| `synthetic` |
 
-```bash
-python -m pytest tests/test_v2_*.py -q     # 162 tests, ~25s, no network
-```
-
-The validation tests check both directions, which is the part that matters: the
-statistics must reject noise **and** detect a real edge. They build a market with
-genuine serial correlation and assert that the permutation test finds it, that PBO
-stays near 0.5 on pure noise and drops below 0.15 when one variant is genuinely
-better, and that walk-forward efficiency survives.
+---
 
-The cross-sectional null is held to the same standard, and it is calibrated: on a
-universe with no cross-sectional structure it returns p ≈ 0.5, and its power rises
-monotonically with the size of the injected effect. The tests also assert the
-permutation preserves each date's gross exposure, net exposure and position count
-exactly — if it did not, the null would be testing something else.
+## 8. Tests and ops
 
-## References
+```bash
+python -m pytest tests/test_v2_*.py -q
+python -m pytest tests/test_yahoo_data_stream.py tests/test_data_ingestion.py -q
+```
 
-- Bailey & López de Prado (2014), *The Deflated Sharpe Ratio: Correcting for Selection
-  Bias, Backtest Overfitting and Non-Normality*
-- Bailey, Borwein, López de Prado & Zhu (2016), *The Probability of Backtest Overfitting*
-- Masters (2018), *Permutation and Randomization Tests for Trading System Development*
+UI launchers and Docker: `UI_SETUP.md`, `DOCKER_HUB_SETUP.md`. Branch policy: `main` and `dev` only. Do not re-enable Dependabot.
 
-## License
+---
 
-Apache-2.0. Research tooling, not investment advice. Nothing here is a
-recommendation to trade.
+**License:** Apache License 2.0  
+**Organization:** [Parallel LLC](https://github.com/ParallelLLC)  
+**Repository:** <https://github.com/ParallelLLC/algorithmic_trading>

algotrader/cli.py

@@ -33,8 +33,8 @@ def _add_common(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--end", default=None)
     parser.add_argument("--interval", default="1d")
     parser.add_argument(
-        "--source", default="auto", choices=["auto", "cache", "synthetic"],
-        help="'auto' downloads and falls back offline; 'synthetic' forces the simulator.",
+        "--source", default="yahoo", choices=["yahoo", "live", "auto", "cache", "synthetic"],
+        help="'yahoo' requires a Yahoo download. 'synthetic' is offline tests only. 'auto' falls back to the simulator.",
     )
     parser.add_argument("--commission-bps", type=float, default=1.0)
     parser.add_argument("--slippage-bps", type=float, default=2.0)

algotrader/data.py

@@ -209,12 +209,12 @@ def load_ohlcv(
     start: str = "2015-01-01",
     end: str | None = None,
     interval: str = "1d",
-    source: str = "auto",
+    source: str = "yahoo",
 ) -> MarketData:
-    """Load OHLCV for ``symbol``, never raising for a merely-unreachable network.
+    """Load OHLCV for ``symbol``.
 
-    ``source`` is one of ``auto`` (download, then cache, then simulate),
-    ``cache``, or ``synthetic``.
+    Default ``source='yahoo'`` requires a Yahoo download. ``auto`` still falls
+    back to cache then the simulator (Hugging Face Space). ``synthetic`` is tests only.
     """
     symbol = (symbol or "SPY").strip().upper()
 
@@ -222,11 +222,17 @@ def load_ohlcv(
         df = simulate_ohlcv(symbol, start, end, interval)
         return MarketData(symbol, df, "synthetic", interval, "Simulated prices (requested).")
 
-    if source in ("auto", "live"):
+    if source in ("yahoo", "live", "auto"):
         df = _download(symbol, start, end, interval)
         if df is not None and len(df) > 50:
             _write_cache(symbol, interval, df)
             return MarketData(symbol, df, "yfinance", interval, "Live data from Yahoo Finance.")
+        if source in ("yahoo", "live"):
+            raise RuntimeError(
+                f"Yahoo returned no usable bars for {symbol}. "
+                "Check the ticker, date range, and network. "
+                "Pass source='synthetic' only for offline tests."
+            )
 
     cached = _read_cache(symbol, interval)
     if cached is not None and len(cached) > 50:

algotrader/lab.py

@@ -38,7 +38,7 @@ class LabConfig:
     start: str = "2015-01-01"
     end: Optional[str] = None
     interval: str = "1d"
-    source: str = "auto"
+    source: str = "yahoo"
 
     strategy: str = "sma_cross"
     params: Dict[str, float] = field(default_factory=dict)

algotrader/portfolio_lab.py

@@ -52,7 +52,7 @@ class PortfolioLabConfig:
     start: str = "2015-01-01"
     end: Optional[str] = None
     interval: str = "1d"
-    source: str = "auto"
+    source: str = "yahoo"
 
     strategy: str = "xs_momentum"
     params: Dict[str, float] = field(default_factory=dict)

app.py

@@ -342,6 +342,7 @@ def analyse_portfolio(
             symbols=universe,
             start=start or "2015-01-01",
             end=end or None,
+            source="yahoo",
             strategy=strategy_key,
             params=params,
             commission_bps=float(commission),
@@ -450,6 +451,7 @@ def analyse(
             symbol=symbol or "SPY",
             start=start or "2015-01-01",
             end=end or None,
+            source="yahoo",
             strategy=strategy_key,
             params=collect_params(strategy_key, p1, p2, p3),
             commission_bps=float(commission),
@@ -484,6 +486,7 @@ def race(symbol: str, start: str, allow_short: bool, n_permutations: int, progre
         cfg = LabConfig(
             symbol=symbol or "SPY",
             start=start or "2015-01-01",
+            source="yahoo",
             allow_short=bool(allow_short),
         )
         table, market, _ = run_arena(

config.yaml

@@ -1,11 +1,11 @@
 # Configuration file for the agentic AI trading system
 data_source:
-  type: 'csv'
+  type: 'yahoo'
   path: 'data/market_data.csv'
 
 trading:
   symbol: 'AAPL'
-  timeframe: '1m'
+  timeframe: '1d'
   capital: 100000
 
 risk:
@@ -29,7 +29,7 @@ alpaca:
   websocket_url: 'wss://stream.data.alpaca.markets/v2/iex'  # WebSocket URL
   account_type: 'paper'  # 'paper' or 'live'
 
-# Yahoo Finance (optional). Set data_source.type: 'yahoo' to use.
+# Yahoo Finance (default ingest). Unofficial API, typically delayed; 1m lookback is ~7 days.
 # Unofficial API, typically delayed; 1m lookback is ~7 days.
 yahoo:
   poll_interval_seconds: 60

docs/AGENTIC_SYSTEM_V1.md

@@ -1,6 +1,6 @@
 # Algorithmic Trading
 
-FinRL reinforcement-learning trading with Alpaca execution, plus optional Yahoo Finance OHLCV for unlabeled real-price research. Parallel LLC.
+FinRL reinforcement-learning trading with Alpaca execution, plus Yahoo Finance OHLCV as the default public tape. Parallel LLC.
 
 This is **research and paper-trading infrastructure**. Live capital requires a separate evaluation contract, feature-parity tests, and a rewritten execution path. Do not treat `paper_trading: false` as a promotion gate.
 
@@ -9,9 +9,9 @@ This is **research and paper-trading infrastructure**. Live capital requires a s
 ## 1. Title and Summary
 
 **Algorithmic Trading**  
-Northwestern-trained data-engineering practice applied to a trading loop: ingest OHLCV, compute indicators or train a FinRL policy, size orders under position and drawdown caps, route to paper or live Alpaca.
+Ingest OHLCV, compute indicators or train a FinRL policy, size orders under position and drawdown caps, route to paper or live Alpaca.
 
-GitHub `main` is the FinRL / Docker / Streamlit tree. `dev` is the integration branch. Yahoo is an additive `data_source.type`, not a replacement for Alpaca or FinRL.
+GitHub `main` is the FinRL / Docker / Streamlit tree plus algotrader 2.0. `dev` is the integration branch. Yahoo is the default `data_source.type`.
 
 **Design themes**
 

tests/test_v2_strategies.py

@@ -119,10 +119,15 @@ class TestData:
         assert returns.kurtosis() > 1.0
         assert returns.abs().autocorr(1) > 0.05
 
+    def test_yahoo_source_does_not_silently_simulate(self, monkeypatch):
+        monkeypatch.setattr("algotrader.data._download", lambda *a, **k: None)
+        with pytest.raises(RuntimeError, match="Yahoo returned no usable bars"):
+            load_ohlcv("SPY", "2018-01-01", "2022-01-01", source="yahoo")
+
     def test_offline_load_falls_back_and_says_so(self, monkeypatch):
         monkeypatch.setattr("algotrader.data._download", lambda *a, **k: None)
         monkeypatch.setattr("algotrader.data._read_cache", lambda *a, **k: None)
-        market = load_ohlcv("SPY", "2018-01-01", "2022-01-01")
+        market = load_ohlcv("SPY", "2018-01-01", "2022-01-01", source="auto")
         assert market.source == "synthetic"
         assert not market.is_real
         assert "unavailable" in market.note

ui/dash_app.py

@@ -158,11 +158,12 @@ class TradingDashApp:
                                     dbc.Select(
                                         id="data-source-select",
                                         options=[
+                                            {"label": "Yahoo Finance", "value": "yahoo"},
                                             {"label": "CSV File", "value": "csv"},
                                             {"label": "Alpaca API", "value": "alpaca"},
                                             {"label": "Synthetic Data", "value": "synthetic"}
                                         ],
-                                        value="csv"
+                                        value="yahoo"
                                     )
                                 ], width=4),
                                 dbc.Col([

ui/jupyter_widgets.py

@@ -62,8 +62,8 @@ class TradingJupyterUI:
         
         # Data widgets
         self.data_source = widgets.Dropdown(
-            options=['csv', 'alpaca', 'synthetic'],
-            value='csv',
+            options=['yahoo', 'csv', 'alpaca', 'synthetic'],
+            value='yahoo',
             description='Data Source:',
             style={'description_width': '120px'}
         )
@@ -76,7 +76,7 @@ class TradingJupyterUI:
         
         self.timeframe_input = widgets.Dropdown(
             options=['1m', '5m', '15m', '1h', '1d'],
-            value='1m',
+            value='1d',
             description='Timeframe:',
             style={'description_width': '120px'}
         )