fix: resolve test failures — PromptLoader path + missing data_ingestion_ic.json

test failures (TestPromptLoader — 10 tests failed on all 3 CI matrix targets):
- Tests hardcoded 'src/quant_pod/prompts' path, resolving to tests/src/... which
  is an untracked legacy directory (old src-layout). CI doesn't have it. Fix:
  change to parent.parent.parent/"packages/quant_pod/prompts" (3 levels up to repo
  root, then correct package path).
- data_ingestion_ic.json was excluded from git by the 'data/' gitignore rule.
  Add negation: !packages/*/prompts/**/data/** and force-add the file.

Also commits pre-existing local changes:
- packages/quant_pod/mcp/server.py: refactor _fetch_price_data to use provider
  registry with DuckDB cache → fallback chain; fix ruff I001
- packages/quantcore/mcp/server.py: initialize DataProviderRegistry in lifespan;
  update fetch_market_data docstring to reflect provider chain behaviour
- packages/quant_pod/tools/mcp_bridge.py: new file (pre-existing uncommitted)

Note: Docker/Trivy scan has 2 HIGH CVEs (jaraco.context, wheel) — not a gate
blocker (all-checks only requires lint + test + security, not docker).

Author: kbichave

.gitignore

@@ -38,6 +38,9 @@ env/
 data/
 !packages/*/data/
 !packages/*/data/**
+# Nested data dirs inside prompts (IC pod subdirectory named "data")
+!packages/*/prompts/**/data/
+!packages/*/prompts/**/data/**
 *.duckdb
 *.db
 *.parquet

packages/quant_pod/mcp/server.py

@@ -909,36 +909,58 @@ def _fetch_price_data(
     symbol: str,
     start_date: str | None = None,
     end_date: str | None = None,
-) -> "pd.DataFrame":  # noqa: F821
-    """Fetch OHLCV price data from QuantCore DataStore or provider."""
+) -> "pd.DataFrame | None":  # noqa: F821
+    """Fetch OHLCV price data using the configured provider registry.
+
+    Resolution order:
+      1. Local DuckDB cache (fastest, no network)
+      2. Provider registry (DATA_PROVIDER_PRIORITY from .env)
+
+    Returns None if all sources fail.
+    """
+    import pandas as pd
+    from quantcore.config.settings import get_settings
+    from quantcore.config.timeframes import Timeframe
+    from quantcore.data.base import AssetClass
+    from quantcore.data.registry import DataProviderRegistry
+
+    def _apply_date_filter(df: pd.DataFrame) -> pd.DataFrame:
+        if start_date:
+            df = df[df.index >= start_date]
+        if end_date:
+            df = df[df.index <= end_date]
+        return df
+
+    # 1. Local DuckDB cache
     try:
         from quantcore.data.storage import DataStore
 
-        store = DataStore()
-        df = store.load(symbol)
-        if df is not None and not df.empty:
-            if start_date:
-                df = df[df.index >= start_date]
-            if end_date:
-                df = df[df.index <= end_date]
-            return df
-    except Exception:
-        pass
+        with DataStore() as store:
+            df = store.load(symbol)
+            if df is not None and not df.empty:
+                return _apply_date_filter(df)
+    except Exception as exc:
+        logger.debug(f"DuckDB cache miss for {symbol}: {exc}")
 
-    # Fallback: try fetching from provider
+    # 2. Provider registry — respects DATA_PROVIDER_PRIORITY
     try:
-        from quantcore.data.providers import get_data_provider
+        from datetime import datetime, timedelta
+
+        settings = get_settings()
+        registry = DataProviderRegistry.from_settings(settings)
 
-        provider = get_data_provider()
-        df = provider.fetch_ohlcv(symbol, interval="daily")
+        end_dt = datetime.strptime(end_date, "%Y-%m-%d") if end_date else datetime.now()
+        start_dt = (
+            datetime.strptime(start_date, "%Y-%m-%d")
+            if start_date
+            else end_dt - timedelta(days=365 * 6)
+        )
+
+        df = registry.fetch_ohlcv(symbol, AssetClass.EQUITY, Timeframe.D1, start_dt, end_dt)
         if df is not None and not df.empty:
-            if start_date:
-                df = df[df.index >= start_date]
-            if end_date:
-                df = df[df.index <= end_date]
             return df
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning(f"Provider registry fetch failed for {symbol}: {exc}")
 
     return None
 

packages/quant_pod/prompts/ics/data/data_ingestion_ic.json

@@ -0,0 +1,16 @@
+{
+  "name": "data_ingestion_ic",
+  "role": "Data Ingestion Specialist for {symbol}",
+  "goal": "Fetch and validate market data using QuantCore MCP tools. Return raw OHLCV data, data quality metrics, and coverage info.",
+  "backstory": "You are the data pipeline specialist. Your job is to fetch market data, check for gaps/staleness, and report raw data quality metrics. You use fetch_market_data and load_market_data tools. Return RAW data summaries - no interpretation, just facts.",
+  "settings": {
+    "llm": "openai/gpt-4o",
+    "reasoning": true,
+    "verbose": true,
+    "allow_delegation": false,
+    "max_iter": 20,
+    "respect_context_window": true
+  },
+  "tools": ["fetch_market_data", "load_market_data", "list_stored_symbols", "get_symbol_snapshot"],
+  "pod": "data"
+}

packages/quant_pod/prompts/ics/data/data_ingestion_ic.md

@@ -0,0 +1,118 @@
+# Data Ingestion IC - Detailed Prompt
+
+## Role
+You are the **Data Ingestion Specialist** - the foundation of the trading system's data pipeline.
+
+## Mission
+Fetch, validate, and report market data quality. You are the first line of defense against bad data reaching the analysis pipeline.
+
+## Capabilities
+
+### Tools Available
+- `fetch_market_data` - Fetch OHLCV data from external sources (Alpha Vantage, etc.)
+- `load_market_data` - Load stored market data from local cache
+- `list_stored_symbols` - Check what symbols are available in local storage
+- `get_symbol_snapshot` - Get current price and basic stats for a symbol
+
+## Detailed Instructions
+
+### Step 1: Data Availability Check
+Before fetching new data, always check what's already available:
+```
+1. Use list_stored_symbols to see cached data
+2. Check if symbol has recent data (within last trading day)
+3. Only fetch new data if cache is stale or missing
+```
+
+### Step 2: Data Fetching
+When fetching market data:
+```
+1. Request sufficient history (minimum 200 bars for indicator calculations)
+2. Verify the response contains expected fields (open, high, low, close, volume)
+3. Note any gaps in the data (weekends expected, mid-week gaps are problems)
+```
+
+### Step 3: Data Quality Assessment
+For every data fetch, compute and report:
+```
+- Total bars retrieved
+- Date range coverage (start date to end date)
+- Missing data points (count and percentage)
+- Volume anomalies (zero volume days)
+- Price anomalies (gaps > 5%, unchanged OHLC)
+- Data freshness (time since last bar)
+```
+
+### Step 4: Output Format
+Return a structured data quality report:
+```
+SYMBOL: {symbol}
+DATE RANGE: {start_date} to {end_date}
+TOTAL BARS: {count}
+COVERAGE: {coverage_pct}%
+GAPS: {gap_count} ({gap_pct}%)
+LAST UPDATE: {last_bar_timestamp}
+QUALITY SCORE: {quality_score}/100
+
+ISSUES (if any):
+- {issue_1}
+- {issue_2}
+
+RAW METRICS:
+- Average Daily Volume: {avg_volume}
+- Price Range: ${low_price} - ${high_price}
+- Current Price: ${current_price}
+```
+
+## Critical Rules
+
+1. **NO INTERPRETATION** - Report facts only. Don't say "data looks good" - say "100% coverage, 0 gaps"
+2. **NO ASSUMPTIONS** - If data is missing, report it. Don't fill gaps with guesses.
+3. **FAIL LOUDLY** - If you cannot fetch data, report the exact error. No silent failures.
+4. **RAW OUTPUT** - Your job is to provide raw data status. Let Pod Managers interpret.
+
+## Example Scenarios
+
+### Scenario 1: Clean Data
+```
+SYMBOL: SPY
+DATE RANGE: 2024-01-01 to 2024-12-10
+TOTAL BARS: 236
+COVERAGE: 100%
+GAPS: 0 (0%)
+LAST UPDATE: 2024-12-10 16:00:00 EST
+QUALITY SCORE: 100/100
+
+RAW METRICS:
+- Average Daily Volume: 78,234,521
+- Price Range: $460.12 - $608.35
+- Current Price: $605.78
+```
+
+### Scenario 2: Data Issues
+```
+SYMBOL: ILLIQUID_STOCK
+DATE RANGE: 2024-01-01 to 2024-12-10
+TOTAL BARS: 198
+COVERAGE: 84%
+GAPS: 38 (16%)
+LAST UPDATE: 2024-12-09 16:00:00 EST (STALE)
+QUALITY SCORE: 62/100
+
+ISSUES:
+- 38 missing trading days in date range
+- Data is 1 day stale (missing Dec 10)
+- 12 zero-volume days detected
+
+RAW METRICS:
+- Average Daily Volume: 45,231
+- Price Range: $12.45 - $18.92
+- Current Price: $15.67
+```
+
+## Integration Notes
+
+This IC feeds into the **Data Pod Manager** who will:
+- Decide if data quality is sufficient for analysis
+- Request re-fetch if data is stale
+- Flag symbols with poor data to upstream managers

packages/quant_pod/tools/mcp_bridge.py

@@ -263,6 +263,20 @@ class LoadMarketDataInput(BaseModel):
     end_date: str | None = Field(None, description="End date (YYYY-MM-DD)")
 
 
+class EmptyInput(BaseModel):
+    """Input schema for tools that take no parameters."""
+
+    pass
+
+
+class MarketRegimeSnapshotInput(BaseModel):
+    """Input for get_market_regime_snapshot tool."""
+
+    end_date: str | None = Field(
+        None, description="End date filter (YYYY-MM-DD) for historical simulation"
+    )
+
+
 class SymbolInput(BaseModel):
     """Input for symbol-based tools."""
 
@@ -841,6 +855,7 @@ class ListStoredSymbolsTool(BaseTool):
     description: str = (
         "List all symbols stored in the local database with their available timeframes."
     )
+    args_schema: type[BaseModel] = EmptyInput
 
     def _run(self) -> str:
         async def _exec():
@@ -928,6 +943,7 @@ class ListAvailableIndicatorsTool(BaseTool):
 
     name: str = "list_available_indicators"
     description: str = "List all available technical indicators with their descriptions."
+    args_schema: type[BaseModel] = EmptyInput
 
     def _run(self) -> str:
         async def _exec():
@@ -1570,6 +1586,7 @@ class GetMarketRegimeSnapshotTool(BaseTool):
     description: str = (
         "Get current market regime classification (trending, ranging, volatile) with confidence."
     )
+    args_schema: type[BaseModel] = MarketRegimeSnapshotInput
 
     def _run(self, end_date: str | None = None) -> str:
         async def _exec():

packages/quantcore/mcp/server.py

@@ -47,6 +47,7 @@ class ServerContext:
     settings: Settings
     data_store: Any = None
     feature_factory: Any = None
+    data_registry: Any = None
 
 
 @asynccontextmanager
@@ -83,6 +84,11 @@ async def lifespan(server: FastMCP):
         include_technical_indicators=True,
     )
 
+    # Provider registry — initialized once, used by fetch_market_data
+    from quantcore.data.registry import DataProviderRegistry
+
+    ctx.data_registry = DataProviderRegistry.from_settings(settings)
+
     server.context = ctx
     logger.info("QuantCore MCP Server initialized")
 
@@ -184,34 +190,45 @@ async def fetch_market_data(
     outputsize: str = "compact",
 ) -> dict[str, Any]:
     """
-    Fetch OHLCV market data from Alpha Vantage API.
+    Fetch OHLCV market data using the configured provider chain.
+
+    Uses DATA_PROVIDER_PRIORITY (default: alpaca,polygon,alpha_vantage) with
+    automatic fallback. Stores fetched data in DuckDB for future load_market_data calls.
 
     Args:
         symbol: Stock/ETF symbol (e.g., "SPY", "AAPL", "QQQ")
         timeframe: Data frequency - "daily", "1h", "4h", "weekly"
-        outputsize: "compact" (100 bars) or "full" (20+ years)
+        outputsize: "compact" (~6 months) or "full" (5+ years)
 
     Returns:
         Dictionary with OHLCV data and metadata
     """
-    from quantcore.data.fetcher import AlphaVantageClient
+    from datetime import datetime, timedelta
+
+    from quantcore.data.base import AssetClass
 
-    client = AlphaVantageClient()
+    ctx: ServerContext = mcp.context
+    registry = ctx.data_registry
     tf = _parse_timeframe(timeframe)
 
+    # Convert outputsize to date range — providers like Alpaca require
+    # explicit start/end rather than Alpha Vantage's compact/full enum
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=365 * 6 if outputsize == "full" else 180)
+
     try:
-        if tf == Timeframe.D1:
-            df = client.fetch_daily(symbol, outputsize=outputsize)
-        elif tf == Timeframe.W1:
-            df = client.fetch_weekly(symbol)
-        else:
-            # Intraday
-            interval = "60min" if tf == Timeframe.H1 else "60min"
-            df = client.fetch_intraday(symbol, interval=interval, outputsize=outputsize)
+        df = registry.fetch_ohlcv(symbol, AssetClass.EQUITY, tf, start_date, end_date)
 
         if df.empty:
             return {"error": f"No data returned for {symbol}", "symbol": symbol}
 
+        # Persist to local DuckDB so load_market_data works without re-fetching
+        if ctx.data_store:
+            try:
+                ctx.data_store.save(symbol, tf, df)
+            except Exception as store_exc:
+                logger.warning(f"Data fetched but failed to persist locally: {store_exc}")
+
         return {
             "symbol": symbol,
             "timeframe": tf.value,

tests/quant_pod/test_trading_crew.py

@@ -123,12 +123,12 @@ class TestPromptLoader:
 
     def test_prompts_directory_exists(self):
         """Test that prompts directory exists."""
-        prompts_dir = Path(__file__).parent.parent / "src/quant_pod/prompts"
+        prompts_dir = Path(__file__).parent.parent.parent / "packages/quant_pod/prompts"
         assert prompts_dir.exists()
 
     def test_ic_json_files_exist(self):
         """Test that IC JSON config files exist."""
-        prompts_dir = Path(__file__).parent.parent / "src/quant_pod/prompts"
+        prompts_dir = Path(__file__).parent.parent.parent / "packages/quant_pod/prompts"
         ics_dir = prompts_dir / "ics"
 
         # Check some IC files exist
@@ -138,20 +138,20 @@ def test_ic_json_files_exist(self):
 
     def test_pod_manager_json_files_exist(self):
         """Test that pod manager JSON config files exist."""
-        prompts_dir = Path(__file__).parent.parent / "src/quant_pod/prompts"
+        prompts_dir = Path(__file__).parent.parent.parent / "packages/quant_pod/prompts"
         pm_dir = prompts_dir / "pod_managers"
 
         assert (pm_dir / "data_pod_manager.json").exists()
         assert (pm_dir / "technicals_pod_manager.json").exists()
 
     def test_assistant_json_exists(self):
         """Test that assistant JSON config exists."""
-        prompts_dir = Path(__file__).parent.parent / "src/quant_pod/prompts"
+        prompts_dir = Path(__file__).parent.parent.parent / "packages/quant_pod/prompts"
         assert (prompts_dir / "assistant/trading_assistant.json").exists()
 
     def test_supertrader_json_exists(self):
         """Test that supertrader JSON config exists."""
-        prompts_dir = Path(__file__).parent.parent / "src/quant_pod/prompts"
+        prompts_dir = Path(__file__).parent.parent.parent / "packages/quant_pod/prompts"
         assert (prompts_dir / "supertrader/super_trader.json").exists()
 
     def test_load_agent_config(self):