Fix: Temporal data extraction and frontend date display

Backend:
- Extract dates for valuation/volatility/macro in analyzer.py
- Fix workflow_store.py to use regular_market_time for valuation
- Fix workflow_store.py to use generated_at for volatility
- Add Layer 2 (minimum citation count) to numeric_validator.py
- Add Layer 3 (uncited number detection) to numeric_validator.py
- Integrate Layers 2/3 in critic.py

Frontend:
- Add normalizeDate() for YYYY-MM-DD format (2025Q3→2025-09-30)
- Add inferDataType() "Spot" for valuation metrics
- Add extractDate() with multiple field fallbacks for news

Fixes issues 2, 3, 5, 6, 8 from frontend data display audit.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

CLAUDE.md

@@ -0,0 +1,87 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Multi-agent AI system that generates SWOT analyses for publicly-traded companies using a self-correcting workflow. Python/FastAPI backend with TypeScript/React frontend.
+
+**Live Demo:** https://huggingface.co/spaces/vn6295337/Instant-SWOT-Agent
+
+## Common Commands
+
+### Backend (Python)
+```bash
+make api                    # Run FastAPI server (port 7860)
+make test                   # Run pytest tests
+make lint                   # Run flake8 and pylint
+make format                 # Format with black
+make coverage               # Run tests with coverage
+make analyze TICKER=AAPL    # CLI analysis for a ticker
+```
+
+### Frontend (TypeScript/React)
+```bash
+cd frontend
+npm run dev                 # Vite dev server (port 5173)
+npm run build               # Production build
+npm run lint                # ESLint
+npm test                    # Vitest unit tests
+npm run test:e2e            # Playwright E2E tests
+npm run storybook           # Component docs (port 6006)
+```
+
+### Full Stack
+```bash
+make frontend               # Run both backend and React frontend
+```
+
+## Architecture
+
+```
+User Input → Researcher → [6 MCP Servers] → Raw Data
+                                ↓
+Raw Data → Analyst → SWOT Draft → Critic → Score
+                                    ↓
+                   Score < 7 → Editor → Revised Draft → Critic
+                   Score ≥ 7 or 3 revisions → Final Output
+```
+
+**Agent Workflow (LangGraph):**
+1. **Researcher** - Gathers data from MCP servers (fundamentals, volatility, macro, valuation, news, sentiment)
+2. **Analyst** - Generates SWOT draft based on strategy focus
+3. **Critic** - Scores output 1-10 with rubric-based evaluation
+4. **Editor** - Revises based on critique (loops until score ≥ 7 or 3 revisions)
+
+**Key Files:**
+- `src/workflow/graph.py` - LangGraph workflow definition
+- `src/nodes/` - Agent implementations (researcher, analyzer, critic, editor)
+- `src/api/app.py` - FastAPI application
+- `src/state.py` - TypedDict for workflow state
+- `frontend/src/App.tsx` - Main React component
+
+## API Endpoints
+
+- `POST /analyze` - Start SWOT analysis (returns workflow_id)
+- `GET /workflow/{id}/status` - Progress and metrics
+- `GET /workflow/{id}/result` - Final results
+- `GET /api/stocks/search?q=` - Stock ticker search
+- `GET /health` - Health check
+
+## Environment Variables
+
+Required (at least one LLM provider):
+- `GROQ_API_KEY` - Primary LLM (Llama 3.1 8B)
+- `GEMINI_API_KEY` - Fallback
+- `OPENROUTER_API_KEY` - Fallback
+
+Data sources:
+- `TAVILY_API_KEY` - Web search
+- `FRED_API_KEY` - Macro data
+- `FINNHUB_API_KEY` - Sentiment/ratings
+
+## Tech Stack
+
+**Backend:** Python 3.11+, FastAPI, LangGraph, LangChain, Pydantic
+**Frontend:** React 18, TypeScript, Vite, Tailwind CSS, Radix UI, React Query
+**Testing:** pytest (backend), Vitest + Playwright (frontend)

TEMPORAL_DATA_FIX.md

@@ -1,179 +0,0 @@
-# Temporal Data Display Issue - Root Cause Analysis and Solution
-
-## Problem Description
-
-Financial metrics in the SWOT analysis are not displaying temporal context (e.g., "FY 2024", "Q3 2024") next to the values. This affects the user's ability to understand when the financial data is from.
-
-## Current Behavior
-
-```plaintext
-Financials
-• revenue: $723.9M
-• net_margin: -35.30
-• debt_to_equity: 1.23
-• EPS: $2.45
-```
-
-## Expected Behavior
-
-```plaintext
-Financials
-• revenue: $723.9M (FY 2024)
-• net_margin: -35.30 (FY 2024)
-• debt_to_equity: 1.23 (FY 2024)
-• EPS: $2.45 (Q3 2024)
-```
-
-## Root Cause Analysis
-
-### Primary Issue: Calculated Metrics Lose Temporal Data
-
-**Location:** `/home/vn6295337/Researcher-Agent/mcp-servers/financials-basket/server.py`
-
-The financials MCP server calculates metrics like `net_margin` and `debt_to_equity` but loses temporal data in the process:
-
-```python
-# Problematic code (lines ~200-220)
-net_margin = None
-if revenue and net_income and revenue["value"] and net_income["value"]:
-    net_margin = round((net_income["value"] / revenue["value"]) * 100, 2)  # ❌ Just a number!
-```
-
-- `revenue` from SEC: `{value: 723900000, end_date: "2024-09-30", fiscal_year: 2024, form: "10-K"}`
-- `net_income` from SEC: `{value: -255600000, end_date: "2024-09-30", fiscal_year: 2024, form: "10-K"}`
-- `net_margin` calculated: `-35.30` (plain number, temporal data lost) ❌
-
-### Secondary Issue: MCP Client Handling
-
-**Location:** `/home/vn6295337/Researcher-Agent/mcp_client.py`
-
-The MCP client's `_extract_and_emit_metrics` function doesn't properly handle calculated metrics that should have temporal data.
-
-## Solution
-
-### 1. Fix Financials MCP Server
-
-**File:** `/home/vn6295337/Researcher-Agent/mcp-servers/financials-basket/server.py`
-
-Add helper function and modify margin calculations:
-
-```python
-def create_temporal_metric(value, source_metric):
-    """Create a metric with temporal data inherited from source metric."""
-    if source_metric and isinstance(source_metric, dict):
-        return {
-            "value": value,
-            "end_date": source_metric.get("end_date"),
-            "fiscal_year": source_metric.get("fiscal_year"),
-            "form": source_metric.get("form")
-        }
-    return {"value": value}
-
-# Replace margin calculations
-net_margin = None
-if revenue and net_income and revenue["value"] and net_income["value"]:
-    net_margin = create_temporal_metric(
-        round((net_income["value"] / revenue["value"]) * 100, 2),
-        revenue  # Inherit temporal data from revenue
-    )
-```
-
-### 2. Fix Debt Metrics
-
-**File:** Same file, in `fetch_debt_metrics` function
-
-```python
-debt_to_equity = None
-if total_debt and stockholders_equity:
-    debt_val = total_debt.get("value", 0) or 0
-    equity_val = stockholders_equity.get("value", 0) or 0
-    if equity_val > 0:
-        debt_to_equity = {
-            "value": round(debt_val / equity_val, 2),
-            "end_date": total_debt.get("end_date"),
-            "fiscal_year": total_debt.get("fiscal_year"),
-            "form": total_debt.get("form")
-        }
-```
-
-### 3. Enhance MCP Client
-
-**File:** `/home/vn6295337/Researcher-Agent/mcp_client.py`
-
-```python
-# In _extract_and_emit_metrics function, enhance financials section
-elif source == "financials":
-    financials = result.get("financials") or {}
-
-    def get_temporal_data(metric_data):
-        if isinstance(metric_data, dict):
-            return {
-                "end_date": metric_data.get("end_date"),
-                "fiscal_year": metric_data.get("fiscal_year"),
-                "form": metric_data.get("form")
-            }
-        return {"end_date": None, "fiscal_year": None, "form": None}
-
-    # Handle net_margin with temporal data
-    net_margin = financials.get("net_margin") or financials.get("net_margin_pct")
-    if isinstance(net_margin, dict) and net_margin.get("value") is not None:
-        temporal = get_temporal_data(net_margin)
-        await emit_metric(
-            progress_callback, source, "net_margin", net_margin["value"],
-            end_date=temporal["end_date"],
-            fiscal_year=temporal["fiscal_year"],
-            form=temporal["form"]
-        )
-    elif isinstance(net_margin, (int, float)):
-        # Fallback for old format
-        await emit_metric(progress_callback, source, "net_margin", net_margin)
-```
-
-## Files to Modify
-
-1. **Primary Fix:** `/home/vn6295337/Researcher-Agent/mcp-servers/financials-basket/server.py`
-   - Add `create_temporal_metric` helper function
-   - Modify margin calculations to preserve temporal data
-   - Modify debt_to_equity calculation to preserve temporal data
-
-2. **Secondary Fix:** `/home/vn6295337/Researcher-Agent/mcp_client.py`
-   - Enhance `_extract_and_emit_metrics` function
-   - Add proper handling for calculated metrics with temporal data
-   - Maintain backward compatibility with fallback handling
-
-## Expected Results
-
-After implementing the fix:
-
-```plaintext
-Financials
-• revenue: $723.9M (FY 2024) ✅
-• net_margin: -35.30 (FY 2024) ✅ FIXED
-• debt_to_equity: 1.23 (FY 2024) ✅ FIXED
-• EPS: $2.45 (Q3 2024) ✅
-• gross_margin: 45.20 (FY 2024) ✅ FIXED
-• operating_margin: 12.80 (FY 2024) ✅ FIXED
-```
-
-## Testing Plan
-
-1. **Unit Test:** Verify `create_temporal_metric` function works correctly
-2. **Integration Test:** Run full workflow and verify temporal data flows through system
-3. **UI Test:** Confirm frontend displays fiscal period labels correctly
-4. **Regression Test:** Ensure existing functionality still works
-
-## Backward Compatibility
-
-The solution maintains full backward compatibility:
-- Old format (plain numbers) still works via fallback handling
-- New format (objects with temporal data) provides enhanced functionality
-- No breaking changes to existing API contracts
-- Frontend already supports temporal data display
-
-## Impact
-
-This fix will significantly improve the user experience by:
-- Providing clear temporal context for all financial metrics
-- Enabling better financial analysis with period-specific data
-- Maintaining data consistency across the entire system
-- Supporting historical comparisons and trend analysis

frontend/src/components/MCPDataPanel.tsx

@@ -167,11 +167,26 @@ function inferDataSource(category: string, metric: string, form?: string, dataSo
 }
 
 // Infer data type from form and metric
-function inferDataType(form?: string, metric?: string): string {
+function inferDataType(form?: string, metric?: string, source?: string): string {
   if (form === '10-K') return 'FY'
   if (form === '10-Q') return 'Q'
 
   const lowerMetric = (metric || '').toLowerCase()
+
+  // Valuation metrics are spot/current prices (not TTM)
+  const spotMetrics = [
+    'current_price', 'market_cap', 'enterprise_value',
+    'trailing_pe', 'forward_pe', 'pb_ratio', 'ps_ratio',
+    'trailing_peg', 'forward_peg', 'ev_ebitda', 'ev_revenue',
+    'price_to_fcf', 'dividend_yield'
+  ]
+  if (spotMetrics.includes(lowerMetric)) return 'Spot'
+
+  // Growth metrics are year-over-year
+  const yoyMetrics = ['revenue_growth', 'earnings_growth']
+  if (yoyMetrics.includes(lowerMetric)) return 'YoY'
+
+  // Volatility/macro metrics
   if (['vix', 'vxn'].includes(lowerMetric)) return 'Daily'
   if (['gdp_growth'].includes(lowerMetric)) return 'Quarterly'
   if (['interest_rate', 'cpi_inflation', 'unemployment'].includes(lowerMetric)) return 'Monthly'
@@ -182,6 +197,80 @@ function inferDataType(form?: string, metric?: string): string {
   return 'TTM'
 }
 
+// Extract date from multiple possible field names
+function extractDate(item: Record<string, unknown>): string | undefined {
+  // Check multiple possible date field names
+  const dateFields = ['datetime', 'published_date', 'date', 'publishedAt', 'timestamp', 'created_at']
+  for (const field of dateFields) {
+    if (item[field]) {
+      return String(item[field])
+    }
+  }
+  return undefined
+}
+
+// Normalize various date formats to YYYY-MM-DD
+function normalizeDate(dateStr: string | undefined | null): string {
+  if (!dateStr) return '-'
+
+  const str = String(dateStr).trim()
+
+  // Already a dash or empty
+  if (str === '-' || str === '') return '-'
+
+  // Quarter format: 2025Q3 -> 2025-09-30 (BEA quarters: Q1=Mar, Q2=Jun, Q3=Sep, Q4=Dec)
+  const quarterMatch = str.match(/^(\d{4})Q(\d)$/)
+  if (quarterMatch) {
+    const year = quarterMatch[1]
+    const quarter = parseInt(quarterMatch[2], 10)
+    // BEA quarter end dates: Q1=03-31, Q2=06-30, Q3=09-30, Q4=12-31
+    const quarterEndDates: Record<number, string> = {
+      1: '03-31',
+      2: '06-30',
+      3: '09-30',
+      4: '12-31'
+    }
+    return `${year}-${quarterEndDates[quarter] || '12-31'}`
+  }
+
+  // Month-year format: 2025-November -> 2025-11-30 (last day of month)
+  const monthYearMatch = str.match(/^(\d{4})-(\w+)$/)
+  if (monthYearMatch) {
+    const year = parseInt(monthYearMatch[1], 10)
+    const monthName = monthYearMatch[2].toLowerCase()
+    const monthMap: Record<string, number> = {
+      january: 1, february: 2, march: 3, april: 4, may: 5, june: 6,
+      july: 7, august: 8, september: 9, october: 10, november: 11, december: 12
+    }
+    const month = monthMap[monthName]
+    if (month) {
+      // Get last day of month
+      const lastDay = new Date(year, month, 0).getDate()
+      return `${year}-${String(month).padStart(2, '0')}-${String(lastDay).padStart(2, '0')}`
+    }
+  }
+
+  // Compact format: 20260108 -> 2026-01-08
+  const compactMatch = str.match(/^(\d{4})(\d{2})(\d{2})$/)
+  if (compactMatch) {
+    return `${compactMatch[1]}-${compactMatch[2]}-${compactMatch[3]}`
+  }
+
+  // ISO format already: YYYY-MM-DD - return as is
+  if (/^\d{4}-\d{2}-\d{2}$/.test(str)) {
+    return str
+  }
+
+  // ISO datetime: YYYY-MM-DDTHH:MM:SS -> YYYY-MM-DD
+  const isoMatch = str.match(/^(\d{4}-\d{2}-\d{2})T/)
+  if (isoMatch) {
+    return isoMatch[1]
+  }
+
+  // Return original if no pattern matches
+  return str
+}
+
 // Format fiscal period label (e.g., "FY 2023" or "Q3 2024")
 function formatFiscalPeriod(form?: string, fiscalYear?: number, endDate?: string): string | null {
   if (!fiscalYear) return null
@@ -257,7 +346,7 @@ export function MCPDataPanel({ metrics, rawData, companyName, ticker, exchange,
           metric: m.metric,
           value: formatValue(m.value, m.metric),
           dataType: inferDataType(m.form, m.metric),
-          asOf: m.endDate || '-',
+          asOf: normalizeDate(m.endDate),
           source: inferDataSource(cat, m.metric, m.form, m.dataSource),
           category: cat.charAt(0).toUpperCase() + cat.slice(1)
         })
@@ -290,7 +379,7 @@ export function MCPDataPanel({ metrics, rawData, companyName, ticker, exchange,
           articles.push({
             title: String(a.title || a.content || 'News article'),
             url: String(a.url || '#'),
-            date: a.datetime ? String(a.datetime) : undefined,
+            date: extractDate(a),
             source: a.source ? String(a.source) : 'Tavily'
           })
         }
@@ -303,7 +392,7 @@ export function MCPDataPanel({ metrics, rawData, companyName, ticker, exchange,
         articles.push({
           title: a.title || 'News article',
           url: a.url || '#',
-          date: a.published_date,
+          date: extractDate(a as Record<string, unknown>),
           source: a.source || 'Tavily'
         })
       }
@@ -339,7 +428,7 @@ export function MCPDataPanel({ metrics, rawData, companyName, ticker, exchange,
       results.push({
         title: String(item.title || item.content || `${source} item`),
         url: String(item.url || '#'),
-        date: item.datetime ? String(item.datetime) : undefined,
+        date: extractDate(item),
         source,
         subreddit: item.subreddit ? String(item.subreddit) : undefined
       })
@@ -363,7 +452,7 @@ export function MCPDataPanel({ metrics, rawData, companyName, ticker, exchange,
     for (const article of newsArticles) {
       rows.push({
         title: article.title,
-        date: article.date || '-',
+        date: normalizeDate(article.date),
         source: article.source || 'Tavily',
         subreddit: '-',
         url: article.url,
@@ -375,7 +464,7 @@ export function MCPDataPanel({ metrics, rawData, companyName, ticker, exchange,
     for (const item of sentimentItems) {
       rows.push({
         title: item.title,
-        date: item.date || '-',
+        date: normalizeDate(item.date),
         source: item.source,
         subreddit: item.subreddit ? `r/${item.subreddit}` : '-',
         url: item.url,

src/nodes/analyzer.py

@@ -595,39 +595,65 @@ def _extract_key_metrics(raw_data: str) -> dict:
             "net_income": _extract_temporal_metric(fin_data.get("net_income", {})),
         }
 
-    # Extract valuation
+    # Extract valuation (with temporal data)
     val = metrics.get("valuation", {})
     if val and "error" not in val:
         val_metrics = val.get("metrics", {})
         pe = val_metrics.get("pe_ratio", {})
+        # Get valuation date from sources or response-level
+        val_date = (
+            val.get("sources", {}).get("yahoo_finance", {}).get("regular_market_time")
+            or val.get("as_of")
+            or val.get("generated_at", "")[:10] if val.get("generated_at") else None
+        )
         extracted["valuation"] = {
-            "pe_trailing": pe.get("trailing") if isinstance(pe, dict) else pe,
-            "pe_forward": pe.get("forward") if isinstance(pe, dict) else None,
-            "pb_ratio": val_metrics.get("pb_ratio"),
-            "ps_ratio": val_metrics.get("ps_ratio"),
-            "ev_ebitda": val_metrics.get("ev_ebitda"),
+            "pe_trailing": {"value": pe.get("trailing") if isinstance(pe, dict) else pe, "end_date": val_date},
+            "pe_forward": {"value": pe.get("forward") if isinstance(pe, dict) else None, "end_date": val_date},
+            "pb_ratio": {"value": val_metrics.get("pb_ratio"), "end_date": val_date},
+            "ps_ratio": {"value": val_metrics.get("ps_ratio"), "end_date": val_date},
+            "ev_ebitda": {"value": val_metrics.get("ev_ebitda"), "end_date": val_date},
             "valuation_signal": val.get("overall_signal"),
+            "as_of": val_date,
         }
 
-    # Extract volatility
+    # Extract volatility (with temporal data)
     vol = metrics.get("volatility", {})
     if vol and "error" not in vol:
         vol_metrics = vol.get("metrics", {})
+        # Get response-level date as fallback
+        vol_date = vol.get("generated_at", "")[:10] if vol.get("generated_at") else None
+        # Extract each metric with its own date (or fallback to response date)
+        vix_data = vol_metrics.get("vix", {})
+        beta_data = vol_metrics.get("beta", {})
+        hv_data = vol_metrics.get("historical_volatility", {})
         extracted["volatility"] = {
-            "beta": vol_metrics.get("beta", {}).get("value"),
-            "vix": vol_metrics.get("vix", {}).get("value"),
-            "historical_volatility": vol_metrics.get("historical_volatility", {}).get("value"),
+            "beta": {"value": beta_data.get("value") if isinstance(beta_data, dict) else beta_data,
+                     "end_date": beta_data.get("date") or vol_date if isinstance(beta_data, dict) else vol_date},
+            "vix": {"value": vix_data.get("value") if isinstance(vix_data, dict) else vix_data,
+                    "end_date": vix_data.get("date") or vol_date if isinstance(vix_data, dict) else vol_date},
+            "historical_volatility": {"value": hv_data.get("value") if isinstance(hv_data, dict) else hv_data,
+                                      "end_date": hv_data.get("date") or vol_date if isinstance(hv_data, dict) else vol_date},
+            "as_of": vol_date,
         }
 
-    # Extract macro
+    # Extract macro (with temporal data)
     macro = metrics.get("macro", {})
     if macro and "error" not in macro:
         macro_metrics = macro.get("metrics", {})
+        # Each macro metric has its own date/period
+        gdp = macro_metrics.get("gdp_growth", {})
+        interest = macro_metrics.get("interest_rate", {})
+        inflation = macro_metrics.get("cpi_inflation", {})
+        unemp = macro_metrics.get("unemployment", {})
         extracted["macro"] = {
-            "gdp_growth": macro_metrics.get("gdp_growth", {}).get("value"),
-            "interest_rate": macro_metrics.get("interest_rate", {}).get("value"),
-            "inflation": macro_metrics.get("cpi_inflation", {}).get("value"),
-            "unemployment": macro_metrics.get("unemployment", {}).get("value"),
+            "gdp_growth": {"value": gdp.get("value") if isinstance(gdp, dict) else gdp,
+                          "end_date": gdp.get("date") or gdp.get("period") if isinstance(gdp, dict) else None},
+            "interest_rate": {"value": interest.get("value") if isinstance(interest, dict) else interest,
+                              "end_date": interest.get("date") if isinstance(interest, dict) else None},
+            "inflation": {"value": inflation.get("value") if isinstance(inflation, dict) else inflation,
+                          "end_date": inflation.get("date") or inflation.get("period") if isinstance(inflation, dict) else None},
+            "unemployment": {"value": unemp.get("value") if isinstance(unemp, dict) else unemp,
+                             "end_date": unemp.get("date") or unemp.get("period") if isinstance(unemp, dict) else None},
         }
 
     # Extract news with VADER sentiment

src/nodes/critic.py

@@ -4,7 +4,11 @@ import json
 import time
 
 # Layer 4: Deterministic numeric validation
-from src.utils.numeric_validator import validate_numeric_accuracy
+from src.utils.numeric_validator import (
+    validate_numeric_accuracy,
+    validate_uncited_numbers,
+    validate_minimum_citations,
+)
 from src.nodes.analyzer import _verify_reference_integrity
 
 
@@ -402,6 +406,75 @@ def critic_node(state, workflow_id=None, progress_store=None):
             else:
                 _add_activity_log(workflow_id, progress_store, "critic",
                                   "Numeric validation: all citations verified")
+
+            # ============================================================
+            # LAYER 3: Uncited Number Detection
+            # ============================================================
+            uncited_warnings = validate_uncited_numbers(report, metric_ref)
+            if uncited_warnings:
+                _add_activity_log(workflow_id, progress_store, "critic",
+                                  f"Uncited numbers: {len(uncited_warnings)} suspicious value(s) found")
+
+                # Add to hallucinations_detected
+                if "hallucinations_detected" not in result:
+                    result["hallucinations_detected"] = []
+                result["hallucinations_detected"].extend(uncited_warnings)
+
+                # Cap score and add feedback (less severe than mismatches)
+                if scores.get("evidence_grounding", 0) > 6:
+                    scores["evidence_grounding"] = 6
+                    if "hard_floor_violations" not in result:
+                        result["hard_floor_violations"] = []
+                    result["hard_floor_violations"].append(
+                        "Uncited metric-like numbers found - evidence_grounding capped at 6"
+                    )
+
+                # Add feedback
+                if "actionable_feedback" not in result:
+                    result["actionable_feedback"] = []
+                result["actionable_feedback"].append(
+                    f"Add [M##] citations for {len(uncited_warnings)} uncited metric value(s)"
+                )
+
+                # Recalculate and reject
+                weighted_score = calculate_weighted_score(scores)
+                result["weighted_score"] = weighted_score
+                status = "REJECTED"
+                result["status"] = status
+
+            # ============================================================
+            # LAYER 2: Minimum Citation Count Enforcement
+            # ============================================================
+            citation_check = validate_minimum_citations(report, metric_ref, min_ratio=0.3)
+            if not citation_check["valid"]:
+                _add_activity_log(workflow_id, progress_store, "critic",
+                                  f"Citation coverage insufficient: {citation_check['message']}")
+
+                # Cap score severely - this indicates LLM ignored citation instructions
+                if scores.get("evidence_grounding", 0) > 3:
+                    scores["evidence_grounding"] = 3
+                    if "hard_floor_violations" not in result:
+                        result["hard_floor_violations"] = []
+                    result["hard_floor_violations"].append(
+                        f"Insufficient citation coverage ({citation_check['ratio']:.0%}) - evidence_grounding capped at 3"
+                    )
+
+                # Add feedback
+                if "actionable_feedback" not in result:
+                    result["actionable_feedback"] = []
+                result["actionable_feedback"].insert(0,
+                    f"CRITICAL: Add more [M##] citations. Current: {citation_check['citations_found']}/{citation_check['metrics_available']} ({citation_check['ratio']:.0%})"
+                )
+
+                # Recalculate and reject
+                weighted_score = calculate_weighted_score(scores)
+                result["weighted_score"] = weighted_score
+                status = "REJECTED"
+                result["status"] = status
+            else:
+                _add_activity_log(workflow_id, progress_store, "critic",
+                                  f"Citation coverage OK: {citation_check['message']}")
+
         else:
             _add_activity_log(workflow_id, progress_store, "critic",
                               "Warning: metric reference integrity check failed - skipping numeric validation")

src/services/workflow_store.py

@@ -168,7 +168,12 @@ def _extract_metrics_from_raw_data(raw_data: dict) -> list:
     yf_val = val_all.get("yahoo_finance", {}).get("data", {})
 
     # Get valuation fetch date if available (point-in-time data)
-    val_fetch_date = yf_val.get("_fetch_date") or yf_val.get("fetch_date")
+    # MCP server returns regular_market_time from Yahoo Finance quote data
+    val_fetch_date = (
+        yf_val.get("_fetch_date")
+        or yf_val.get("fetch_date")
+        or multi_source.get("valuation_all", {}).get("yahoo_finance", {}).get("regular_market_time")
+    )
 
     val_metrics = [
         "market_cap", "enterprise_value", "trailing_pe", "forward_pe",
@@ -221,8 +226,12 @@ def _extract_metrics_from_raw_data(raw_data: dict) -> list:
             metrics.append(entry)
 
     # Beta and volatility from Yahoo Finance
-    # Get volatility fetch date if available
-    vol_fetch_date = yf_vol.get("_fetch_date") or yf_vol.get("fetch_date")
+    # Get volatility fetch date if available (MCP returns generated_at at response level)
+    vol_fetch_date = (
+        yf_vol.get("_fetch_date")
+        or yf_vol.get("fetch_date")
+        or vol_all.get("generated_at", "")[:10] if vol_all.get("generated_at") else None
+    )
 
     for vol_metric in ["beta", "historical_volatility", "implied_volatility"]:
         metric_data = yf_vol.get(vol_metric)

src/utils/numeric_validator.py

@@ -224,3 +224,171 @@ def validate_numeric_accuracy(swot_text: str, metric_reference: dict) -> list[st
         errors.append(f"Invalid reference: {ref_id} not in metric table")
 
     return errors
+
+
+# ============================================================
+# LAYER 3: Uncited Number Detection
+# ============================================================
+
+# Pattern to match metric-like numbers (will filter out cited ones programmatically)
+# Matches: $56.6B, $394M, 25.3%, 12.14, 0.84x, etc.
+METRIC_NUMBER_PATTERN = re.compile(
+    r'('
+    r'\$[\d,]+\.?\d*[BMK]?'  # Currency: $56.6B, $394M, $1,234
+    r'|'
+    r'[\d,]+\.?\d*%'  # Percentage: 25.3%, 12%
+    r'|'
+    r'[\d,]+\.\d+x'  # Ratio with x: 1.5x, 12.3x
+    r')',
+    re.IGNORECASE
+)
+
+# Keywords that indicate a number is likely a metric value
+METRIC_CONTEXT_KEYWORDS = [
+    'revenue', 'income', 'profit', 'margin', 'cap', 'market cap', 'enterprise value',
+    'p/e', 'pe ratio', 'p/b', 'pb ratio', 'p/s', 'ps ratio', 'ev/ebitda',
+    'beta', 'volatility', 'vix', 'growth', 'yield', 'dividend',
+    'debt', 'equity', 'assets', 'liabilities', 'cash flow', 'fcf',
+    'eps', 'earnings', 'roi', 'roe', 'roa', 'ebitda',
+    'gdp', 'inflation', 'unemployment', 'interest rate',
+]
+
+
+def find_uncited_numbers(swot_text: str, metric_reference: dict) -> list[dict]:
+    """
+    Find numbers that look like metrics but don't have [M##] citations.
+
+    Returns list of suspicious uncited numbers with context.
+    """
+    uncited = []
+
+    # Get all cited positions to exclude
+    cited_matches = list(CITATION_PATTERN.finditer(swot_text))
+    cited_positions = set()
+    for match in cited_matches:
+        # Mark the entire citation span as "cited"
+        cited_positions.update(range(match.start(), match.end()))
+
+    # Find all metric-like numbers
+    for match in METRIC_NUMBER_PATTERN.finditer(swot_text):
+        # Skip if this position overlaps with a citation
+        if any(pos in cited_positions for pos in range(match.start(), match.end())):
+            continue
+
+        value_str = match.group(1)
+        normalized = normalize_value(value_str)
+
+        if normalized is None:
+            continue
+
+        # Get surrounding context (50 chars before and after)
+        start = max(0, match.start() - 50)
+        end = min(len(swot_text), match.end() + 50)
+        context = swot_text[start:end].replace('\n', ' ')
+
+        # Check if context contains metric-related keywords
+        context_lower = context.lower()
+        has_metric_context = any(kw in context_lower for kw in METRIC_CONTEXT_KEYWORDS)
+
+        # Check if value matches any known metric (within tolerance)
+        matches_known_metric = False
+        matched_metric_key = None
+        for ref_id, ref_entry in metric_reference.items():
+            expected = ref_entry.get("raw_value")
+            if expected and values_match(normalized, expected):
+                matches_known_metric = True
+                matched_metric_key = ref_entry.get("key")
+                break
+
+        # Flag as suspicious if it looks like a metric
+        if has_metric_context or matches_known_metric:
+            uncited.append({
+                "value": value_str,
+                "normalized": normalized,
+                "position": match.start(),
+                "context": context.strip(),
+                "has_metric_context": has_metric_context,
+                "matches_known_metric": matches_known_metric,
+                "matched_metric_key": matched_metric_key,
+            })
+
+    return uncited
+
+
+def validate_uncited_numbers(swot_text: str, metric_reference: dict) -> list[str]:
+    """
+    Validate that metric-like numbers have proper citations.
+
+    Returns list of warnings for uncited numbers that should have citations.
+    """
+    if not metric_reference:
+        return []
+
+    uncited = find_uncited_numbers(swot_text, metric_reference)
+    warnings = []
+
+    for item in uncited:
+        if item["matches_known_metric"]:
+            # This number matches a known metric - MUST have citation
+            warnings.append(
+                f"Uncited metric value: {item['value']} appears to be {item['matched_metric_key']} - add [M##] citation"
+            )
+        elif item["has_metric_context"]:
+            # Number in metric context without citation - suspicious
+            warnings.append(
+                f"Uncited number in metric context: {item['value']} - verify source or add citation"
+            )
+
+    return warnings
+
+
+def get_citation_count(swot_text: str) -> int:
+    """Count the number of [M##] citations in the text."""
+    return len(CITATION_PATTERN.findall(swot_text))
+
+
+def validate_minimum_citations(swot_text: str, metric_reference: dict, min_ratio: float = 0.5) -> dict:
+    """
+    Check if SWOT has enough citations relative to available metrics.
+
+    Args:
+        swot_text: The SWOT analysis output
+        metric_reference: Available metrics
+        min_ratio: Minimum ratio of citations to available metrics (default 0.5 = 50%)
+
+    Returns:
+        {
+            "valid": bool,
+            "citations_found": int,
+            "metrics_available": int,
+            "ratio": float,
+            "message": str
+        }
+    """
+    citations_found = get_citation_count(swot_text)
+    metrics_available = len(metric_reference) if metric_reference else 0
+
+    if metrics_available == 0:
+        return {
+            "valid": True,
+            "citations_found": citations_found,
+            "metrics_available": 0,
+            "ratio": 0,
+            "message": "No metrics available for citation"
+        }
+
+    ratio = citations_found / metrics_available
+    valid = ratio >= min_ratio
+
+    if valid:
+        message = f"Citation coverage: {citations_found}/{metrics_available} ({ratio:.0%})"
+    else:
+        message = f"Insufficient citations: {citations_found}/{metrics_available} ({ratio:.0%}) - minimum {min_ratio:.0%} required"
+
+    return {
+        "valid": valid,
+        "citations_found": citations_found,
+        "metrics_available": metrics_available,
+        "ratio": ratio,
+        "message": message
+    }

static/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>frontend</title>
-    <script type="module" crossorigin src="/assets/index-Cb1-3_-g.js"></script>
+    <script type="module" crossorigin src="/assets/index-juxGlBoI.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DCSmN--O.css">
   </head>
   <body>