Deepen Market Brain intelligence system

README.md

@@ -88,10 +88,14 @@ The Market Brain is Blum's high-level reasoning orchestrator. It is not a single
 
 The output includes current regime, forward scenarios, opportunity stack, risk alerts, model stack and an evidence ledger. It is a research-priority engine, not a recommendation system.
 
+The Brain also persists snapshot history and compares each run with the previous one. The change log highlights regime changes, score movement, top stock/ETF/IPO leader changes and risk-count shifts. A contradiction engine flags price/sentiment conflicts, overbought high-risk setups and market-wide narrative conflicts. An event graph links themes, stocks, ETFs, IPO candidates and live news into a compact intelligence map.
+
 ## IPO And Pre-Listing Intelligence
 
 IPO Radar scans SEC EDGAR current filing feeds for `S-1`, `S-1/A`, `F-1`, `F-1/A`, `424B1` and `424B4` forms. It also surfaces stored public news narratives that mention IPOs, listings, prospectuses, market debuts and SPACs.
 
+For deeper issuer history, the backend can query the official SEC company submissions API at `data.sec.gov`. The IPO Radar UI exposes SEC filing history and can persist additional IPO-related filings into PostgreSQL.
+
 The IPO score separates:
 
 - readiness score;
@@ -146,14 +150,18 @@ FastAPI exposes clean JSON endpoints:
 - `POST /semantic-search`
 - `GET /related-news?ticker=NVDA`
 - `GET /themes`
+- `GET /themes/{label}`
 - `GET /etf-trends`
 - `GET /stock-radar`
 - `POST /stock-radar/update`
 - `GET /ipo-radar`
 - `POST /ipo-radar/update`
+- `GET /ipo-radar/sec-submissions/{cik}`
 - `GET /market-brain`
 - `GET /market-brain/latest`
+- `GET /market-brain/history`
 - `POST /market-brain/run`
+- `GET /ai/models/status`
 - `GET /dashboard/overview`
 - `GET /ai/explain/{ticker}`
 - `POST /backtest/{ticker}`
@@ -178,6 +186,8 @@ Interactive API docs are available at `/docs`.
 
 The UI is intentionally dense, dark and technical: Bloomberg-style information density, Linear/Vercel-style cleanliness, TradingView-style chart clarity and OpenBB-style open-source posture.
 
+Signal surfaces include score version, confidence score and lifecycle state (`new`, `confirmed`, `strengthening`, `active`, `faded`, `invalidated`) so the platform can show whether a signal is emerging, durable or deteriorating.
+
 ## Local Setup
 
 ```bash

ROADMAP.md

@@ -16,6 +16,11 @@ Shipped in the current architecture:
 - Stock Radar is now a first-class research surface with dedicated API, on-demand stock hydration, sector leadership, factor views, research priorities and real market snapshots.
 - IPO Radar is now a first-class primary-market research surface using SEC EDGAR current filing feeds for S-1, F-1 and 424B prospectus forms.
 - Market Brain is now the top-level orchestration layer combining stock signals, ETF rotation, market sentiment, public news, IPO evidence, forward scenarios, risk alerts and an evidence ledger.
+- Market Brain now persists snapshot history, produces a changelog against the prior run, detects price/news/risk contradictions and emits an event graph linking themes, assets, ETFs, IPO candidates and live news.
+- IPO Radar now supports official `data.sec.gov` company submissions enrichment by CIK, with optional persistence of additional IPO-related filings.
+- Theme Explorer now supports theme detail with article list, source mix, linked assets and sentiment.
+- The signal engine now records score version, confidence score and lifecycle state for every signal snapshot.
+- `/ai/models/status` exposes configured models, observed model records and fallback policy.
 - `/market-brain`, `/market-brain/run`, `/ipo-radar` and `/ipo-radar/update` expose the new intelligence layer through documented JSON APIs.
 
 ## Phase 0 - Stabilize Docker Space Deployment

backend/alembic/versions/0003_signal_metadata.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from alembic import op
+import sqlalchemy as sa
+
+
+revision = "0003_signal_metadata"
+down_revision = "0002_market_brain_ipo"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column("signal_snapshots", sa.Column("score_version", sa.String(length=40), nullable=False, server_default="blum-score-v0.4"))
+    op.add_column("signal_snapshots", sa.Column("confidence_score", sa.Float(), nullable=False, server_default="0"))
+    op.add_column("signal_snapshots", sa.Column("lifecycle_state", sa.String(length=40), nullable=False, server_default="new"))
+    op.create_index("ix_signal_snapshots_score_version", "signal_snapshots", ["score_version"])
+    op.create_index("ix_signal_snapshots_confidence_score", "signal_snapshots", ["confidence_score"])
+    op.create_index("ix_signal_snapshots_lifecycle_state", "signal_snapshots", ["lifecycle_state"])
+    op.alter_column("signal_snapshots", "score_version", server_default=None)
+    op.alter_column("signal_snapshots", "confidence_score", server_default=None)
+    op.alter_column("signal_snapshots", "lifecycle_state", server_default=None)
+
+
+def downgrade() -> None:
+    op.drop_index("ix_signal_snapshots_lifecycle_state", table_name="signal_snapshots")
+    op.drop_index("ix_signal_snapshots_confidence_score", table_name="signal_snapshots")
+    op.drop_index("ix_signal_snapshots_score_version", table_name="signal_snapshots")
+    op.drop_column("signal_snapshots", "lifecycle_state")
+    op.drop_column("signal_snapshots", "confidence_score")
+    op.drop_column("signal_snapshots", "score_version")

backend/app/api/routes.py

@@ -8,13 +8,13 @@ from app.ai.orchestrator import AIOrchestrator
 from app.core.config import get_settings
 from app.core.database import get_db
 from app.ingestion.news_ingestor import NewsIngestor
-from app.models import AIInsight, Asset, NewsArticle, NewsAssetLink, PriceHistory, SentimentAnalysis, SignalSnapshot
+from app.models import AIInsight, Asset, EmbeddingVector, NewsArticle, NewsAssetLink, PriceHistory, SentimentAnalysis, SignalSnapshot
 from app.schemas import AssetOut, MarketUpdateRequest, NewsOut, NewsUpdateRequest, SemanticSearchRequest, SignalRunRequest
 from app.services.dashboard import dashboard_overview, signal_payload
 from app.services.etf import list_etf_trends, update_etf_trends
-from app.services.ipo import ipo_radar, update_ipo_radar
+from app.services.ipo import ipo_radar, sec_company_submissions, update_ipo_radar
 from app.services.live import live_news, market_sentiment
-from app.services.market_brain import build_market_brain, latest_market_brain
+from app.services.market_brain import build_market_brain, latest_market_brain, market_brain_history
 from app.services.market_data import MarketDataService, market_snapshot_for_asset
 from app.services.pipeline import PipelineService
 from app.services.realtime import realtime_status
@@ -192,6 +192,11 @@ def themes(db: Session = Depends(get_db)):
     return SemanticService().themes(db)
 
 
+@router.get("/themes/{label}")
+def theme_detail(label: str, limit: int = Query(default=60, ge=1, le=160), db: Session = Depends(get_db)):
+    return SemanticService().theme_detail(db, label=label, limit=limit)
+
+
 @router.get("/etf-trends")
 def etf_trends(db: Session = Depends(get_db)):
     return list_etf_trends(db)
@@ -217,6 +222,11 @@ def ipo_radar_update(limit_per_form: int = Query(default=50, ge=10, le=120), db:
     return update_ipo_radar(db, limit_per_form=limit_per_form)
 
 
+@router.get("/ipo-radar/sec-submissions/{cik}")
+def ipo_sec_submissions(cik: str, persist: bool = Query(default=False), db: Session = Depends(get_db)):
+    return sec_company_submissions(db, cik=cik, persist=persist)
+
+
 @router.get("/market-brain")
 def market_brain_endpoint(db: Session = Depends(get_db)):
     return build_market_brain(db, persist=False)
@@ -227,6 +237,11 @@ def market_brain_latest_endpoint(db: Session = Depends(get_db)):
     return latest_market_brain(db)
 
 
+@router.get("/market-brain/history")
+def market_brain_history_endpoint(limit: int = Query(default=20, ge=1, le=100), db: Session = Depends(get_db)):
+    return market_brain_history(db, limit=limit)
+
+
 @router.post("/market-brain/run")
 def market_brain_run(
     refresh_pipeline: bool = Query(default=False),
@@ -243,6 +258,45 @@ def market_brain_run(
     return brain
 
 
+@router.get("/ai/models/status")
+def ai_model_status(db: Session = Depends(get_db)):
+    sentiment_models = db.execute(
+        select(SentimentAnalysis.model_name, func.count(SentimentAnalysis.id))
+        .group_by(SentimentAnalysis.model_name)
+        .order_by(func.count(SentimentAnalysis.id).desc())
+    ).all()
+    insight_models = db.execute(
+        select(AIInsight.model_name, func.count(AIInsight.id))
+        .group_by(AIInsight.model_name)
+        .order_by(func.count(AIInsight.id).desc())
+    ).all()
+    embedding_models = db.execute(
+        select(EmbeddingVector.model_name, func.count(EmbeddingVector.id))
+        .group_by(EmbeddingVector.model_name)
+        .order_by(func.count(EmbeddingVector.id).desc())
+    ).all()
+    return {
+        "model_loading_enabled": settings.enable_model_loading,
+        "configured_models": {
+            "financial_sentiment": settings.finbert_model,
+            "embeddings": settings.embedding_model,
+            "reasoning_llm": settings.llm_model,
+            "time_series": "statistical-fallback with adapter-ready interface",
+        },
+        "observed_models": {
+            "sentiment": [{"model_name": model, "records": int(count)} for model, count in sentiment_models],
+            "embeddings": [{"model_name": model, "records": int(count)} for model, count in embedding_models],
+            "insights": [{"model_name": model, "records": int(count)} for model, count in insight_models],
+        },
+        "fallback_policy": {
+            "sentiment": "FinBERT primary when loadable; VADER baseline/fallback is labeled in stored records.",
+            "embeddings": "sentence-transformers primary when loadable; deterministic embedding fallback is explicit in code path.",
+            "reasoning": "Configured LLM when loadable; deterministic evidence reasoner fallback never invents data.",
+            "time_series": "Transparent statistical fallback until Chronos, TimesFM or PatchTST adapter is enabled.",
+        },
+    }
+
+
 @router.get("/dashboard/overview")
 def overview(db: Session = Depends(get_db)):
     return dashboard_overview(db)

backend/app/models.py

@@ -127,6 +127,9 @@ class SignalSnapshot(Base):
     blum_score: Mapped[float] = mapped_column(Float, index=True)
     risk_level: Mapped[str] = mapped_column(String(40), index=True)
     time_horizon: Mapped[str] = mapped_column(String(80), default="Short/Medium term")
+    score_version: Mapped[str] = mapped_column(String(40), default="blum-score-v0.4", index=True)
+    confidence_score: Mapped[float] = mapped_column(Float, default=0.0, index=True)
+    lifecycle_state: Mapped[str] = mapped_column(String(40), default="new", index=True)
     score_breakdown: Mapped[dict] = mapped_column(JsonType, default=dict)
     technical_summary: Mapped[dict] = mapped_column(JsonType, default=dict)
     narrative_summary: Mapped[dict] = mapped_column(JsonType, default=dict)

backend/app/services/dashboard.py

@@ -54,6 +54,9 @@ def signal_payload(signal: SignalSnapshot, db: Session | None = None) -> dict:
         "blum_score": signal.blum_score,
         "risk_level": signal.risk_level,
         "time_horizon": signal.time_horizon,
+        "score_version": signal.score_version,
+        "confidence_score": signal.confidence_score,
+        "lifecycle_state": signal.lifecycle_state,
         "score_breakdown": signal.score_breakdown,
         "explanation": signal.explanation,
         "watch_points": signal.watch_points,

backend/app/services/ipo.py

@@ -19,7 +19,9 @@ settings = get_settings()
 
 SEC_CURRENT_FORMS = ["S-1", "S-1/A", "F-1", "F-1/A", "424B1", "424B4"]
 SEC_CURRENT_URL = "https://www.sec.gov/cgi-bin/browse-edgar"
+SEC_SUBMISSIONS_URL = "https://data.sec.gov/submissions/CIK{cik}.json"
 SEC_SOURCE = "SEC EDGAR current filings"
+SEC_SUBMISSIONS_SOURCE = "SEC EDGAR company submissions API"
 IPO_NEWS_KEYWORDS = [
     "ipo",
     "initial public offering",
@@ -172,6 +174,150 @@ def ipo_radar(db: Session, limit: int = 80) -> dict:
     }
 
 
+def sec_company_submissions(db: Session, cik: str, persist: bool = False) -> dict:
+    normalized_cik = normalize_cik(cik)
+    payload = fetch_sec_company_submissions(normalized_cik)
+    recent = payload.get("filings", {}).get("recent", {})
+    filings = normalize_company_submission_filings(payload, recent)
+    ipo_related = [filing for filing in filings if filing["form_type"] in set(SEC_CURRENT_FORMS + ["424B2", "424B3", "424B5"])]
+
+    company = db.scalar(select(IPOCompany).where(IPOCompany.cik == normalized_cik))
+    if company is not None:
+        metadata = dict(company.company_metadata or {})
+        metadata["sec_submissions"] = {
+            "entity_type": payload.get("entityType"),
+            "sic": payload.get("sic"),
+            "sic_description": payload.get("sicDescription"),
+            "exchanges": payload.get("exchanges", []),
+            "tickers": payload.get("tickers", []),
+            "filing_count": len(filings),
+            "ipo_related_filing_count": len(ipo_related),
+            "last_enriched_at": datetime.utcnow().isoformat(),
+            "source": SEC_SUBMISSIONS_SOURCE,
+        }
+        company.company_metadata = metadata
+        if payload.get("tickers") and not company.ticker:
+            company.ticker = payload["tickers"][0]
+        if payload.get("exchanges") and not company.exchange:
+            company.exchange = payload["exchanges"][0]
+        if payload.get("sicDescription") and company.industry == "Unknown":
+            company.industry = payload["sicDescription"]
+        company.last_seen_at = datetime.utcnow()
+
+    inserted = 0
+    if persist and company is not None:
+        for filing in ipo_related:
+            accession = filing["accession_number"]
+            if db.scalar(select(IPOFiling).where(IPOFiling.accession_number == accession)):
+                continue
+            db.add(
+                IPOFiling(
+                    company_id=company.id,
+                    cik=normalized_cik,
+                    company_name=company.name,
+                    form_type=filing["form_type"],
+                    filing_date=filing["filing_date"],
+                    title=f"{filing['form_type']} - {company.name}",
+                    url=filing["url"],
+                    accession_number=accession,
+                    source=SEC_SUBMISSIONS_SOURCE,
+                    raw_payload={**filing, "filing_date": filing["filing_date"].isoformat() if filing["filing_date"] else None},
+                )
+            )
+            inserted += 1
+        if inserted:
+            db.flush()
+            score = score_ipo_company(db, company)
+            if score:
+                db.add(score)
+        db.commit()
+    elif company is not None:
+        db.commit()
+
+    return {
+        "cik": normalized_cik,
+        "name": payload.get("name"),
+        "entity_type": payload.get("entityType"),
+        "sic": payload.get("sic"),
+        "sic_description": payload.get("sicDescription"),
+        "tickers": payload.get("tickers", []),
+        "exchanges": payload.get("exchanges", []),
+        "fiscal_year_end": payload.get("fiscalYearEnd"),
+        "filing_count": len(filings),
+        "ipo_related_filing_count": len(ipo_related),
+        "recent_filings": filings[:80],
+        "ipo_related_filings": ipo_related[:80],
+        "persisted_new_ipo_filings": inserted,
+        "source": SEC_SUBMISSIONS_SOURCE,
+        "data_policy": "Official SEC company submissions data. No unavailable listing dates, valuations or tickers are inferred.",
+    }
+
+
+def fetch_sec_company_submissions(cik: str) -> dict:
+    response = requests.get(
+        SEC_SUBMISSIONS_URL.format(cik=normalize_cik(cik)),
+        headers={"User-Agent": settings.sec_user_agent, "Accept-Encoding": "gzip, deflate", "Host": "data.sec.gov"},
+        timeout=24,
+    )
+    response.raise_for_status()
+    return response.json()
+
+
+def normalize_company_submission_filings(payload: dict, recent: dict) -> list[dict]:
+    forms = recent.get("form", []) or []
+    accession_numbers = recent.get("accessionNumber", []) or []
+    filing_dates = recent.get("filingDate", []) or []
+    report_dates = recent.get("reportDate", []) or []
+    documents = recent.get("primaryDocument", []) or []
+    descriptions = recent.get("primaryDocDescription", []) or []
+    cik = normalize_cik(str(payload.get("cik", "")))
+    filings = []
+    for index, form_type in enumerate(forms):
+        accession = safe_list_value(accession_numbers, index)
+        document = safe_list_value(documents, index)
+        filing_date = parse_sec_date(safe_list_value(filing_dates, index))
+        filings.append(
+            {
+                "form_type": form_type,
+                "accession_number": accession,
+                "filing_date": filing_date,
+                "report_date": safe_list_value(report_dates, index),
+                "primary_document": document,
+                "description": safe_list_value(descriptions, index),
+                "url": sec_document_url(cik, accession, document),
+                "source": SEC_SUBMISSIONS_SOURCE,
+            }
+        )
+    return filings
+
+
+def normalize_cik(cik: str) -> str:
+    digits = re.sub(r"\D", "", cik or "")
+    return digits.zfill(10)
+
+
+def parse_sec_date(value: str | None) -> datetime | None:
+    if not value:
+        return None
+    try:
+        return datetime.strptime(value, "%Y-%m-%d")
+    except Exception:
+        return None
+
+
+def safe_list_value(values: list, index: int):
+    if index >= len(values):
+        return None
+    return values[index]
+
+
+def sec_document_url(cik: str, accession: str | None, document: str | None) -> str:
+    if not cik or not accession or not document:
+        return ""
+    compact_accession = accession.replace("-", "")
+    return f"https://www.sec.gov/Archives/edgar/data/{int(cik)}/{compact_accession}/{document}"
+
+
 def fetch_sec_current_filings(form_type: str, count: int) -> list[dict]:
     response = requests.get(
         SEC_CURRENT_URL,

backend/app/services/market_brain.py

@@ -16,6 +16,7 @@ from app.services.stock import stock_radar
 
 
 def build_market_brain(db: Session, persist: bool = True) -> dict:
+    previous = db.scalar(select(MarketBrainSnapshot).order_by(desc(MarketBrainSnapshot.created_at)).limit(1))
     overview = dashboard_overview(db)
     sentiment = market_sentiment(db, hours=48)
     stocks = stock_radar(db, limit=100)
@@ -31,6 +32,8 @@ def build_market_brain(db: Session, persist: bool = True) -> dict:
     risks = build_risk_alerts(stocks, latest_signals, sentiment, ipo, overview)
     evidence = evidence_ledger(overview, sentiment, stocks, etfs, ipo, news, latest_signals)
     summary = brain_summary(regime, brain_score, opportunity_stack, risks)
+    contradictions = detect_contradictions(stocks, latest_signals, sentiment)
+    event_graph = build_event_graph(opportunity_stack, sentiment, news)
 
     payload = {
         "run_id": f"brain-{datetime.utcnow().strftime('%Y%m%d%H%M%S')}-{uuid.uuid4().hex[:8]}",
@@ -52,7 +55,10 @@ def build_market_brain(db: Session, persist: bool = True) -> dict:
         "opportunity_stack": opportunity_stack,
         "forward_scenarios": scenarios,
         "risk_alerts": risks,
+        "contradictions": contradictions,
+        "event_graph": event_graph,
         "evidence_ledger": evidence,
+        "change_log": [],
         "model_stack": {
             "sentiment": "FinBERT-led sentiment records when model loading is available; VADER remains a baseline comparator.",
             "semantic": "Sentence-transformer embeddings and theme clusters where stored news embeddings exist.",
@@ -62,6 +68,7 @@ def build_market_brain(db: Session, persist: bool = True) -> dict:
         },
         "disclaimer": "Educational research case study only. Not financial advice, not a recommendation and not an operational trading signal.",
     }
+    payload["change_log"] = compare_with_previous(previous.structured_output if previous else None, payload)
 
     if persist:
         db.add(
@@ -79,6 +86,25 @@ def build_market_brain(db: Session, persist: bool = True) -> dict:
     return payload
 
 
+def market_brain_history(db: Session, limit: int = 20) -> list[dict]:
+    snapshots = db.scalars(select(MarketBrainSnapshot).order_by(desc(MarketBrainSnapshot.created_at)).limit(limit)).all()
+    return [
+        {
+            "run_id": snapshot.run_id,
+            "created_at": snapshot.created_at,
+            "brain_score": snapshot.brain_score,
+            "regime": snapshot.regime,
+            "summary": snapshot.summary,
+            "risk_alert_count": len((snapshot.structured_output or {}).get("risk_alerts", [])),
+            "contradiction_count": len((snapshot.structured_output or {}).get("contradictions", [])),
+            "top_stock": first_stack_name(snapshot.structured_output, "stock_research_priorities"),
+            "top_etf": first_stack_name(snapshot.structured_output, "etf_rotation_leaders"),
+            "top_ipo": first_stack_name(snapshot.structured_output, "ipo_watch"),
+        }
+        for snapshot in snapshots
+    ]
+
+
 def latest_market_brain(db: Session) -> dict:
     snapshot = db.scalar(select(MarketBrainSnapshot).order_by(desc(MarketBrainSnapshot.created_at)).limit(1))
     if snapshot is None:
@@ -245,6 +271,159 @@ def build_risk_alerts(stocks: dict, signals: list[SignalSnapshot], sentiment: di
     return alerts
 
 
+def detect_contradictions(stocks: dict, signals: list[SignalSnapshot], sentiment: dict) -> list[dict]:
+    contradictions: list[dict] = []
+    for row in stocks.get("rows", []):
+        snapshot = row.get("market_snapshot") or {}
+        narrative = row.get("narrative_flags") or {}
+        technical = row.get("technical_flags") or {}
+        signal = row.get("signal") or {}
+        perf_5d = numeric(snapshot.get("perf_5d"))
+        sentiment_7d = numeric(narrative.get("sentiment_7d"))
+        rsi = numeric(technical.get("rsi"))
+        if perf_5d >= 4 and sentiment_7d <= -0.15:
+            contradictions.append(
+                {
+                    "type": "price_up_sentiment_down",
+                    "severity": "High" if perf_5d >= 8 else "Medium",
+                    "ticker": row.get("ticker"),
+                    "title": f"{row.get('ticker')} price strength conflicts with negative 7D sentiment.",
+                    "evidence": {"perf_5d": perf_5d, "sentiment_7d": sentiment_7d, "classification": signal.get("classification")},
+                }
+            )
+        if perf_5d <= -4 and sentiment_7d >= 0.18:
+            contradictions.append(
+                {
+                    "type": "price_down_sentiment_up",
+                    "severity": "Medium",
+                    "ticker": row.get("ticker"),
+                    "title": f"{row.get('ticker')} price weakness conflicts with positive 7D sentiment.",
+                    "evidence": {"perf_5d": perf_5d, "sentiment_7d": sentiment_7d, "classification": signal.get("classification")},
+                }
+            )
+        if rsi >= 72 and signal.get("risk_level") == "High":
+            contradictions.append(
+                {
+                    "type": "overbought_high_risk",
+                    "severity": "Medium",
+                    "ticker": row.get("ticker"),
+                    "title": f"{row.get('ticker')} combines elevated RSI with high risk classification.",
+                    "evidence": {"rsi": rsi, "risk_level": signal.get("risk_level"), "score": signal.get("blum_score")},
+                }
+            )
+    market_sentiment = numeric(sentiment.get("average_sentiment"))
+    if market_sentiment < -0.12:
+        bullish = [signal for signal in signals if signal.blum_score >= 72]
+        if bullish:
+            contradictions.append(
+                {
+                    "type": "bullish_signals_negative_tape",
+                    "severity": "Medium",
+                    "ticker": "MARKET",
+                    "title": "High-scoring signals exist while market-wide sentiment is negative.",
+                    "evidence": {"average_sentiment": market_sentiment, "bullish_signal_count": len(bullish)},
+                }
+            )
+    return contradictions[:24]
+
+
+def build_event_graph(opportunity_stack: dict, sentiment: dict, news: list[dict]) -> dict:
+    nodes: list[dict] = []
+    edges: list[dict] = []
+
+    def add_node(node_id: str, label: str, node_type: str, score: float | None = None) -> None:
+        if any(node["id"] == node_id for node in nodes):
+            return
+        nodes.append({"id": node_id, "label": label, "type": node_type, "score": score})
+
+    add_node("market", "Market Brain", "system", None)
+    for theme in sentiment.get("themes", [])[:8]:
+        node_id = f"theme:{theme['theme']}"
+        add_node(node_id, theme["theme"], "theme", theme.get("avg_sentiment"))
+        edges.append({"source": "market", "target": node_id, "relationship": "theme_detected", "weight": theme.get("headline_count", 0)})
+
+    for item in opportunity_stack.get("stock_research_priorities", [])[:8]:
+        node_id = f"stock:{item.get('ticker')}"
+        add_node(node_id, item.get("ticker") or "Stock", "stock", item.get("score"))
+        edges.append({"source": "market", "target": node_id, "relationship": "research_priority", "weight": item.get("score") or 0})
+        for tag in (item.get("tags") or [])[:3]:
+            theme_id = f"theme:{tag}"
+            add_node(theme_id, tag, "theme", None)
+            edges.append({"source": theme_id, "target": node_id, "relationship": "tag_link", "weight": 1})
+
+    for item in opportunity_stack.get("etf_rotation_leaders", [])[:6]:
+        node_id = f"etf:{item.get('ticker')}"
+        add_node(node_id, item.get("ticker") or "ETF", "etf", item.get("confirmation_score"))
+        edges.append({"source": "market", "target": node_id, "relationship": "rotation_confirmation", "weight": item.get("confirmation_score") or 0})
+
+    for item in opportunity_stack.get("ipo_watch", [])[:6]:
+        node_id = f"ipo:{item.get('name')}"
+        add_node(node_id, item.get("name") or "IPO candidate", "ipo", item.get("opportunity_score"))
+        edges.append({"source": "market", "target": node_id, "relationship": "primary_market_watch", "weight": item.get("opportunity_score") or 0})
+
+    for article in news[:8]:
+        node_id = f"news:{article.get('id')}"
+        add_node(node_id, article.get("title", "News")[:80], "news", article.get("quality_score"))
+        edges.append({"source": "market", "target": node_id, "relationship": "live_news", "weight": article.get("quality_score") or 0})
+
+    return {"nodes": nodes[:48], "edges": edges[:80]}
+
+
+def compare_with_previous(previous: dict | None, current: dict) -> list[dict]:
+    if not previous:
+        return [{"type": "initial_snapshot", "severity": "Info", "message": "No previous Market Brain snapshot exists yet."}]
+    changes: list[dict] = []
+    if previous.get("regime") != current.get("regime"):
+        changes.append(
+            {
+                "type": "regime_change",
+                "severity": "High",
+                "message": f"Regime changed from {previous.get('regime')} to {current.get('regime')}.",
+            }
+        )
+    previous_score = numeric(previous.get("brain_score"))
+    current_score = numeric(current.get("brain_score"))
+    delta = round(current_score - previous_score, 2)
+    if abs(delta) >= 5:
+        changes.append(
+            {
+                "type": "brain_score_change",
+                "severity": "Medium",
+                "message": f"Brain score moved {delta:+.2f} points.",
+                "previous": previous_score,
+                "current": current_score,
+            }
+        )
+    for key, label in [
+        ("stock_research_priorities", "top stock"),
+        ("etf_rotation_leaders", "top ETF"),
+        ("ipo_watch", "top IPO watch"),
+    ]:
+        old = first_stack_name(previous, key)
+        new = first_stack_name(current, key)
+        if old and new and old != new:
+            changes.append(
+                {
+                    "type": f"{key}_leader_change",
+                    "severity": "Info",
+                    "message": f"{label.title()} changed from {old} to {new}.",
+                    "previous": old,
+                    "current": new,
+                }
+            )
+    previous_risk_count = len(previous.get("risk_alerts", []))
+    current_risk_count = len(current.get("risk_alerts", []))
+    if previous_risk_count != current_risk_count:
+        changes.append(
+            {
+                "type": "risk_alert_count_change",
+                "severity": "Info",
+                "message": f"Risk alerts changed from {previous_risk_count} to {current_risk_count}.",
+            }
+        )
+    return changes or [{"type": "stable_snapshot", "severity": "Info", "message": "No material Market Brain change versus the previous snapshot."}]
+
+
 def evidence_ledger(overview: dict, sentiment: dict, stocks: dict, etfs: list[dict], ipo: dict, news: list[dict], signals: list[SignalSnapshot]) -> dict:
     return {
         "stored_assets": overview["market_pulse"]["asset_count"],
@@ -262,6 +441,16 @@ def evidence_ledger(overview: dict, sentiment: dict, stocks: dict, etfs: list[di
     }
 
 
+def first_stack_name(payload: dict | None, key: str) -> str | None:
+    if not payload:
+        return None
+    rows = (payload.get("opportunity_stack") or {}).get(key, [])
+    if not rows:
+        return None
+    first = rows[0]
+    return first.get("ticker") or first.get("name")
+
+
 def brain_summary(regime: str, brain_score: float, opportunity_stack: dict, risks: list[dict]) -> str:
     stocks = len(opportunity_stack.get("stock_research_priorities", []))
     etfs = len(opportunity_stack.get("etf_rotation_leaders", []))
@@ -365,3 +554,12 @@ def probability_from_regime(regime: str, scenario: str) -> int:
 
 def clamp(value: float, low: float = 0, high: float = 100) -> float:
     return max(low, min(high, float(value)))
+
+
+def numeric(value) -> float:
+    try:
+        if value is None:
+            return 0.0
+        return float(value)
+    except Exception:
+        return 0.0

backend/app/services/semantic.py

@@ -5,7 +5,7 @@ from sqlalchemy.orm import Session
 from sklearn.cluster import KMeans
 
 from app.ai.orchestrator import AIOrchestrator
-from app.models import EmbeddingVector, NewsArticle, ThemeCluster
+from app.models import Asset, EmbeddingVector, NewsArticle, NewsAssetLink, SentimentAnalysis, ThemeCluster
 
 
 class SemanticService:
@@ -78,6 +78,67 @@ class SemanticService:
             for label, value in sorted(clusters.items(), key=lambda item: item[1]["articles"], reverse=True)
         ]
 
+    def theme_detail(self, db: Session, label: str, limit: int = 60) -> dict:
+        normalized = label.strip().lower()
+        articles = db.scalars(select(NewsArticle).order_by(desc(NewsArticle.published_at), desc(NewsArticle.created_at)).limit(700)).all()
+        matched = [
+            article for article in articles
+            if normalized in [str(theme).lower() for theme in article.theme_tags.get("themes", [])]
+            or normalized in article.title.lower()
+            or normalized in article.summary.lower()
+        ][:limit]
+        article_ids = [article.id for article in matched]
+        sentiments = []
+        links_by_article: dict[int, list[dict]] = {}
+        if article_ids:
+            sentiments = db.scalars(
+                select(SentimentAnalysis)
+                .where(SentimentAnalysis.article_id.in_(article_ids))
+                .order_by(desc(SentimentAnalysis.created_at))
+            ).all()
+            link_rows = db.execute(
+                select(NewsAssetLink.article_id, Asset.ticker, Asset.name, Asset.sector, NewsAssetLink.relevance_score)
+                .join(Asset, Asset.id == NewsAssetLink.asset_id)
+                .where(NewsAssetLink.article_id.in_(article_ids))
+            ).all()
+            for article_id, ticker, name, sector, relevance in link_rows:
+                links_by_article.setdefault(article_id, []).append(
+                    {"ticker": ticker, "name": name, "sector": sector, "relevance_score": relevance}
+                )
+        sentiment_by_article = {}
+        for sentiment in sentiments:
+            sentiment_by_article.setdefault(sentiment.article_id, sentiment)
+        scores = [float(sentiment.score) for sentiment in sentiments]
+        source_counts: dict[str, int] = {}
+        asset_counts: dict[str, dict] = {}
+        for article in matched:
+            source_counts[article.source] = source_counts.get(article.source, 0) + 1
+            for asset in links_by_article.get(article.id, []):
+                item = asset_counts.setdefault(asset["ticker"], {"ticker": asset["ticker"], "name": asset["name"], "sector": asset["sector"], "mentions": 0})
+                item["mentions"] += 1
+        return {
+            "label": label,
+            "article_count": len(matched),
+            "average_sentiment": round(sum(scores) / len(scores), 4) if scores else 0,
+            "source_mix": sorted([{"source": source, "count": count} for source, count in source_counts.items()], key=lambda item: item["count"], reverse=True),
+            "linked_assets": sorted(asset_counts.values(), key=lambda item: item["mentions"], reverse=True)[:20],
+            "articles": [
+                {
+                    "id": article.id,
+                    "title": article.title,
+                    "summary": article.summary,
+                    "source": article.source,
+                    "url": article.url,
+                    "published_at": article.published_at,
+                    "quality_score": article.quality_score,
+                    "theme_tags": article.theme_tags,
+                    "sentiment": sentiment_payload(sentiment_by_article.get(article.id)),
+                    "linked_assets": links_by_article.get(article.id, [])[:8],
+                }
+                for article in matched
+            ],
+        }
+
 
 def semantic_clusters(rows, vectors: list[list[float]]) -> list[dict]:
     import numpy as np
@@ -116,3 +177,15 @@ def semantic_clusters(rows, vectors: list[list[float]]) -> list[dict]:
             }
         )
     return sorted(output, key=lambda item: item["article_count"], reverse=True)
+
+
+def sentiment_payload(row: SentimentAnalysis | None) -> dict | None:
+    if row is None:
+        return None
+    return {
+        "model_name": row.model_name,
+        "label": row.label,
+        "score": row.score,
+        "confidence": row.confidence,
+        "baseline_vader": row.baseline_vader,
+    }

backend/app/services/stock.py

@@ -103,6 +103,9 @@ def stock_row(db: Session, asset: Asset, signal: SignalSnapshot | None) -> dict:
             "blum_score": signal.blum_score,
             "risk_level": signal.risk_level,
             "time_horizon": signal.time_horizon,
+            "score_version": signal.score_version,
+            "confidence_score": signal.confidence_score,
+            "lifecycle_state": signal.lifecycle_state,
             "score_breakdown": breakdown,
             "created_at": signal.created_at,
         },
@@ -217,6 +220,12 @@ def research_priority(signal: SignalSnapshot, snapshot: dict) -> str:
         return "Data Watch"
     if signal.risk_level == "High" and score >= 70:
         return "Risk Review"
+    if signal.lifecycle_state == "confirmed" and score >= 70:
+        return "Confirmed Priority"
+    if signal.lifecycle_state == "faded":
+        return "Fade Watch"
+    if signal.lifecycle_state == "invalidated":
+        return "Invalidated"
     if score >= 78:
         return "Priority A"
     if score >= 65:
@@ -227,7 +236,11 @@ def research_priority(signal: SignalSnapshot, snapshot: dict) -> str:
 
 
 def radar_tags(signal: SignalSnapshot, technical: dict, narrative: dict) -> list[str]:
-    tags = [signal.classification, signal.risk_level]
+    tags = [signal.classification, signal.risk_level, signal.lifecycle_state]
+    if signal.confidence_score >= 70:
+        tags.append("High Confidence")
+    if signal.confidence_score < 45:
+        tags.append("Low Confidence")
     if technical.get("above_sma20") and technical.get("above_sma50"):
         tags.append("Trend Confirmed")
     if technical.get("above_sma200"):

backend/app/signals/engine.py

@@ -10,6 +10,9 @@ from app.models import Asset, NewsAssetLink, PriceHistory, SentimentAnalysis, Si
 from app.signals.indicators import compute_indicators
 
 
+SCORE_VERSION = "blum-score-v0.4"
+
+
 class SignalEngine:
     def __init__(self, ai: AIOrchestrator | None = None):
         self.ai = ai or AIOrchestrator()
@@ -30,6 +33,9 @@ class SignalEngine:
             ts = self.ai.time_series.analyze(frame)
             narrative = self.narrative_features(db, asset)
             score = build_score(indicators, narrative, ts, asset)
+            previous = latest_signal_for_asset(db, asset.id)
+            confidence = confidence_score(frame, indicators, narrative, ts)
+            lifecycle = lifecycle_state(previous, score, confidence)
             explanation_stub = build_rule_explanation(asset, score, indicators, narrative, ts)
             snapshot = SignalSnapshot(
                 asset_id=asset.id,
@@ -38,6 +44,9 @@ class SignalEngine:
                 blum_score=score["blum_score"],
                 risk_level=score["risk_level"],
                 time_horizon=score["time_horizon"],
+                score_version=SCORE_VERSION,
+                confidence_score=confidence,
+                lifecycle_state=lifecycle,
                 score_breakdown=score["score_breakdown"],
                 technical_summary={**indicators, "time_series": ts},
                 narrative_summary=narrative,
@@ -224,6 +233,40 @@ def build_rule_explanation(asset: Asset, score: dict, indicators: dict, narrativ
     )
 
 
+def latest_signal_for_asset(db: Session, asset_id: int) -> SignalSnapshot | None:
+    return db.scalar(
+        select(SignalSnapshot)
+        .where(SignalSnapshot.asset_id == asset_id)
+        .order_by(desc(SignalSnapshot.created_at))
+        .limit(1)
+    )
+
+
+def confidence_score(frame: pd.DataFrame, indicators: dict, narrative: dict, ts: dict) -> float:
+    history_depth = scale(len(frame), 60, 900)
+    indicator_completeness = sum(1 for key in ["sma20", "sma50", "sma200", "rsi", "macd_hist", "atr_percent", "support", "resistance"] if indicators.get(key) is not None) / 8 * 100
+    news_support = scale(narrative.get("news_count_30d", 0), 0, 12)
+    sentiment_quality = scale(abs(narrative.get("sentiment_30d", 0)), 0, 0.55)
+    time_series_depth = 80 if ts.get("regime") not in {"unknown", "insufficient_history"} else 35
+    return round(avg(history_depth, indicator_completeness, news_support, sentiment_quality, time_series_depth), 1)
+
+
+def lifecycle_state(previous: SignalSnapshot | None, score: dict, confidence: float) -> str:
+    current_score = float(score.get("blum_score", 0))
+    if previous is None:
+        return "new"
+    previous_score = float(previous.blum_score)
+    if previous_score >= 65 and current_score < 42:
+        return "invalidated"
+    if previous_score - current_score >= 12:
+        return "faded"
+    if previous.classification == score.get("classification") and current_score >= previous_score - 5 and confidence >= 50:
+        return "confirmed"
+    if current_score - previous_score >= 10:
+        return "strengthening"
+    return "active"
+
+
 def etf_confirmation_proxy(asset: Asset, indicators: dict) -> float:
     base = scale(indicators.get("relative_strength_vs_benchmark"), -12, 12)
     if asset.asset_type == "ETF":

frontend/app/globals.css

@@ -287,9 +287,50 @@ p { color: var(--muted); line-height: 1.55; }
 }
 .evidence-grid strong, .method-grid strong { display: block; margin-top: 6px; line-height: 1.35; }
 .method-grid strong { color: #d8e5f2; font-size: 12px; font-weight: 700; }
+.observed-model-panel {
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  padding: 12px;
+  background: #070a0f;
+}
+.theme-card { cursor: pointer; transition: border-color .15s ease, transform .15s ease; }
+.theme-card:hover { border-color: rgba(255,176,0,.45); transform: translateY(-1px); }
 .opportunity-panel { min-height: 520px; }
 .ipo-card { min-height: 410px; }
 .ipo-card .button { display: inline-flex; width: fit-content; margin-top: 12px; }
+.event-graph {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 8px;
+}
+.event-node {
+  min-height: 78px;
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  padding: 9px;
+  background: #070a0f;
+}
+.event-node span, .event-node em {
+  display: block;
+  color: var(--muted);
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: .06em;
+  font-style: normal;
+  font-weight: 900;
+}
+.event-node strong {
+  display: block;
+  margin: 6px 0;
+  color: #eef3fa;
+  font-size: 12px;
+  line-height: 1.25;
+}
+.event-node.stock { border-left: 3px solid var(--green); }
+.event-node.etf { border-left: 3px solid var(--cyan); }
+.event-node.ipo { border-left: 3px solid var(--amber); }
+.event-node.news { border-left: 3px solid var(--blue); }
+.event-node.theme { border-left: 3px solid #b58cff; }
 
 .realtime-strip {
   display: grid;
@@ -485,7 +526,7 @@ p { color: var(--muted); line-height: 1.55; }
   .app-shell { grid-template-columns: 1fr; }
   .sidebar { position: static; height: auto; }
   .system-card { position: static; margin-top: 14px; }
-  .hero, .grid-2, .grid-3, .grid-4, .live-grid, .realtime-strip, .diagnostic-grid, .instrument-card, .market-strip, .market-strip.compact, .brain-hero, .scenario-grid, .evidence-grid, .method-grid { grid-template-columns: 1fr; }
+  .hero, .grid-2, .grid-3, .grid-4, .live-grid, .realtime-strip, .diagnostic-grid, .instrument-card, .market-strip, .market-strip.compact, .brain-hero, .scenario-grid, .evidence-grid, .method-grid, .event-graph { grid-template-columns: 1fr; }
   .tape-row { grid-template-columns: 1fr; }
   .tape-meta { justify-content: flex-start; max-width: none; }
 }

frontend/app/ipo-radar/page.tsx

@@ -21,8 +21,10 @@ export default function IPORadarPage() {
   const [search, setSearch] = useState("");
   const [classification, setClassification] = useState("");
   const [busy, setBusy] = useState(false);
+  const [secBusy, setSecBusy] = useState("");
   const [error, setError] = useState("");
   const [updateResult, setUpdateResult] = useState<any>(null);
+  const [secResult, setSecResult] = useState<any>(null);
 
   const load = async () => {
     setError("");
@@ -49,6 +51,21 @@ export default function IPORadarPage() {
     }
   };
 
+  const loadSecSubmissions = async (row: IPORadarRow, persist: boolean) => {
+    if (!row.company.cik) return;
+    setSecBusy(row.company.cik);
+    setError("");
+    try {
+      const result = await api.secSubmissions(row.company.cik, persist);
+      setSecResult(result);
+      if (persist) await load();
+    } catch (err) {
+      setError((err as Error).message);
+    } finally {
+      setSecBusy("");
+    }
+  };
+
   const rows = useMemo(() => {
     const query = search.trim().toLowerCase();
     const base = radar?.sections?.[selectedSection] ?? radar?.rows ?? [];
@@ -134,9 +151,49 @@ export default function IPORadarPage() {
       </section>
 
       <section className="grid-3" style={{ marginTop: 12 }}>
-        {rows.slice(0, 6).map((row) => <IPORadarCard row={row} key={`${row.company.id}-${row.latest_filing?.accession_number ?? row.company.name}`} />)}
+        {rows.slice(0, 6).map((row) => (
+          <IPORadarCard
+            row={row}
+            key={`${row.company.id}-${row.latest_filing?.accession_number ?? row.company.name}`}
+            onLoadSec={(persist) => loadSecSubmissions(row, persist)}
+            secBusy={secBusy === row.company.cik}
+          />
+        ))}
       </section>
 
+      {secResult && (
+        <section className="panel" style={{ marginTop: 12 }}>
+          <div className="panel-head"><span>SEC company submissions</span><strong>{secResult.name ?? secResult.cik}</strong></div>
+          <div className="diagnostic-grid">
+            <div>
+              <span>Official filing history</span>
+              <strong>{secResult.filing_count} filings | {secResult.ipo_related_filing_count} IPO-related</strong>
+              <p>{(secResult.tickers ?? []).join(" | ") || "No public ticker in SEC payload"} | {(secResult.exchanges ?? []).join(" | ") || "No exchange in SEC payload"}</p>
+            </div>
+            <div>
+              <span>Persistence</span>
+              <strong>{secResult.persisted_new_ipo_filings ?? 0} new filings stored</strong>
+              <p>{secResult.data_policy}</p>
+            </div>
+          </div>
+          <div className="table-shell" style={{ marginTop: 12 }}>
+            <table className="intel-table">
+              <thead><tr><th>Form</th><th>Date</th><th>Description</th><th>Document</th></tr></thead>
+              <tbody>
+                {(secResult.ipo_related_filings ?? []).slice(0, 20).map((filing: any) => (
+                  <tr key={filing.accession_number}>
+                    <td><strong>{filing.form_type}</strong></td>
+                    <td><span>{formatTime(filing.filing_date)}</span></td>
+                    <td><span>{filing.description ?? "n/a"}</span></td>
+                    <td>{filing.url ? <a className="asset-link" href={filing.url} target="_blank" rel="noreferrer">Open</a> : <span>n/a</span>}</td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </section>
+      )}
+
       <section className="panel" style={{ marginTop: 12 }}>
         <div className="panel-head"><span>IPO radar table</span><strong>{rows.length} companies</strong></div>
         <div className="control-row">
@@ -171,7 +228,7 @@ export default function IPORadarPage() {
   );
 }
 
-function IPORadarCard({ row }: { row: IPORadarRow }) {
+function IPORadarCard({ row, onLoadSec, secBusy }: { row: IPORadarRow; onLoadSec: (persist: boolean) => void; secBusy: boolean }) {
   return (
     <article className="score-card ipo-card">
       <div className="score-card-top">
@@ -192,7 +249,11 @@ function IPORadarCard({ row }: { row: IPORadarRow }) {
         <div><span>Narrative</span><strong>{row.score.narrative_heat_score.toFixed(0)}</strong></div>
         <div><span>Risk terms</span><strong>{row.score.valuation_risk_score.toFixed(0)}</strong></div>
       </div>
-      {row.latest_filing?.url && <a className="button" href={row.latest_filing.url} target="_blank" rel="noreferrer">Open SEC filing</a>}
+      <div className="control-row" style={{ marginTop: 12, marginBottom: 0 }}>
+        {row.latest_filing?.url && <a className="button" href={row.latest_filing.url} target="_blank" rel="noreferrer">Open SEC filing</a>}
+        {row.company.cik && <button className="button" onClick={() => onLoadSec(false)} disabled={secBusy}>{secBusy ? "Loading SEC..." : "SEC history"}</button>}
+        {row.company.cik && <button className="button" onClick={() => onLoadSec(true)} disabled={secBusy}>{secBusy ? "Syncing..." : "Sync filings"}</button>}
+      </div>
     </article>
   );
 }

frontend/app/market-brain/page.tsx

@@ -3,20 +3,24 @@
 import Link from "next/link";
 import { useEffect, useState } from "react";
 import { api } from "@/lib/api";
-import { MarketBrain } from "@/lib/types";
+import { MarketBrain, MarketBrainHistoryRow } from "@/lib/types";
 import { LoadingState } from "@/components/LoadingState";
 import { PlotPanel } from "@/components/PlotPanel";
 import { StatusBadge } from "@/components/StatusBadge";
 
 export default function MarketBrainPage() {
   const [brain, setBrain] = useState<MarketBrain | null>(null);
+  const [history, setHistory] = useState<MarketBrainHistoryRow[]>([]);
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState("");
 
   const load = async () => {
     setError("");
     try {
-      setBrain(await api.marketBrain());
+      const [brainResult, historyResult] = await Promise.allSettled([api.marketBrain(), api.marketBrainHistory(12)] as const);
+      if (brainResult.status === "fulfilled") setBrain(brainResult.value);
+      if (historyResult.status === "fulfilled") setHistory(historyResult.value);
+      if (brainResult.status === "rejected") throw brainResult.reason;
     } catch (err) {
       setError((err as Error).message);
     }
@@ -28,7 +32,9 @@ export default function MarketBrainPage() {
     setBusy(true);
     setError("");
     try {
-      setBrain(await api.runMarketBrain(refreshPipeline));
+      const result = await api.runMarketBrain(refreshPipeline);
+      setBrain(result);
+      setHistory(await api.marketBrainHistory(12));
     } catch (err) {
       setError((err as Error).message);
     } finally {
@@ -125,12 +131,71 @@ export default function MarketBrainPage() {
         ))}
       </section>
 
+      <section className="grid-2" style={{ marginTop: 12 }}>
+        <div className="panel">
+          <div className="panel-head"><span>Brain changelog</span><strong>{brain.change_log.length}</strong></div>
+          <div className="brain-list">
+            {brain.change_log.map((item) => (
+              <div key={`${item.type}-${item.message}`}>
+                <StatusBadge label={item.severity} />
+                <strong>{item.type.replaceAll("_", " ")}</strong>
+                <p>{item.message}</p>
+              </div>
+            ))}
+          </div>
+        </div>
+        <div className="panel">
+          <div className="panel-head"><span>Contradiction engine</span><strong>{brain.contradictions.length}</strong></div>
+          <div className="brain-list">
+            {brain.contradictions.length === 0 && <div className="empty-state">No material price, sentiment or risk contradictions detected.</div>}
+            {brain.contradictions.slice(0, 8).map((item) => (
+              <div key={`${item.type}-${item.ticker}-${item.title}`}>
+                <StatusBadge label={item.severity} />
+                <strong>{item.title}</strong>
+                <span>{Object.entries(item.evidence).map(([key, value]) => `${key} ${value}`).join(" | ")}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+      </section>
+
       <section className="grid-3" style={{ marginTop: 12 }}>
         <OpportunityPanel title="Stock research priorities" rows={stack.stock_research_priorities} kind="stock" />
         <OpportunityPanel title="ETF rotation leaders" rows={stack.etf_rotation_leaders} kind="etf" />
         <OpportunityPanel title="IPO / pre-listing watch" rows={stack.ipo_watch} kind="ipo" />
       </section>
 
+      <section className="grid-2" style={{ marginTop: 12 }}>
+        <div className="panel">
+          <div className="panel-head"><span>Event graph</span><strong>{brain.event_graph.nodes.length} nodes</strong></div>
+          <div className="event-graph">
+            {brain.event_graph.nodes.slice(0, 28).map((node) => (
+              <div className={`event-node ${node.type}`} key={node.id}>
+                <span>{node.type}</span>
+                <strong>{node.label}</strong>
+                {node.score !== undefined && node.score !== null && <em>{Number(node.score).toFixed(1)}</em>}
+              </div>
+            ))}
+          </div>
+        </div>
+        <div className="panel">
+          <div className="panel-head"><span>Snapshot history</span><strong>{history.length}</strong></div>
+          <div className="brain-list dense">
+            {history.length === 0 && <div className="empty-state">No persisted Market Brain snapshots yet. Run brain to create the first snapshot.</div>}
+            {history.map((item) => (
+              <div key={item.run_id}>
+                <div className="opportunity-line">
+                  <strong>{item.regime}</strong>
+                  <span>{Number(item.brain_score).toFixed(1)}</span>
+                </div>
+                <p>{formatTime(item.created_at)} | risk {item.risk_alert_count} | contradictions {item.contradiction_count}</p>
+                <span>Top: {item.top_stock ?? "n/a"} | ETF {item.top_etf ?? "n/a"} | IPO {item.top_ipo ?? "n/a"}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+      </section>
+
       <section className="grid-2" style={{ marginTop: 12 }}>
         <div className="panel">
           <div className="panel-head"><span>Risk alerts</span><strong>{brain.risk_alerts.length}</strong></div>

frontend/app/methodology/page.tsx

@@ -1,4 +1,15 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { api } from "@/lib/api";
+
 export default function MethodologyPage() {
+  const [modelStatus, setModelStatus] = useState<any>(null);
+
+  useEffect(() => {
+    api.modelStatus().then(setModelStatus).catch(() => setModelStatus(null));
+  }, []);
+
   return (
     <>
       <div className="page-header">
@@ -12,6 +23,27 @@ export default function MethodologyPage() {
           </article>
         ))}
       </section>
+      <section className="panel" style={{ marginTop: 12 }}>
+        <div className="panel-head"><span>AI model status</span><strong>{modelStatus?.model_loading_enabled ? "model loading enabled" : "fallback-ready"}</strong></div>
+        {!modelStatus && <div className="empty-state">Model status is not available yet.</div>}
+        {modelStatus && (
+          <>
+            <div className="method-grid">
+              {Object.entries(modelStatus.configured_models).map(([key, value]) => (
+                <div key={key}>
+                  <span>{key.replaceAll("_", " ")}</span>
+                  <strong>{String(value)}</strong>
+                </div>
+              ))}
+            </div>
+            <div className="grid-3" style={{ marginTop: 10 }}>
+              <ObservedModelPanel title="Sentiment records" rows={modelStatus.observed_models.sentiment} />
+              <ObservedModelPanel title="Embedding records" rows={modelStatus.observed_models.embeddings} />
+              <ObservedModelPanel title="Insight records" rows={modelStatus.observed_models.insights} />
+            </div>
+          </>
+        )}
+      </section>
       <section className="panel" style={{ marginTop: 12 }}>
         <div className="panel-head"><span>Financial disclaimer</span></div>
         <p>
@@ -24,12 +56,30 @@ export default function MethodologyPage() {
   );
 }
 
+function ObservedModelPanel({ title, rows }: { title: string; rows: any[] }) {
+  return (
+    <div className="observed-model-panel">
+      <div className="panel-head"><span>{title}</span><strong>{rows?.length ?? 0}</strong></div>
+      <div className="brain-list dense">
+        {!rows?.length && <div className="empty-state">No records observed yet.</div>}
+        {rows?.map((row) => (
+          <div key={row.model_name}>
+            <strong>{row.model_name}</strong>
+            <span>{row.records} records</span>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
+
 const sections = [
-  { title: "Data workflow", body: "The backend seeds an asset universe, ingests yfinance OHLCV history, collects public RSS news, deduplicates articles, links them to assets and persists all artifacts in PostgreSQL." },
+  { title: "Data workflow", body: "The backend seeds an asset universe, ingests public OHLCV history, collects public RSS news, deduplicates articles, links them to assets and persists all artifacts in PostgreSQL." },
   { title: "AI orchestration", body: "FinBERT handles financial sentiment, sentence-transformers handles embeddings and semantic search, a lightweight LLM creates evidence-only explanations, and the time-series layer computes anomalies, volatility regimes and scenarios." },
+  { title: "Market Brain", body: "The Market Brain combines stock signals, ETF rotation, live news, sentiment, SEC filing evidence, forward scenarios, contradictions, risk alerts and change logs into one evidence-bound operating view." },
+  { title: "IPO intelligence", body: "IPO Radar uses SEC EDGAR current filings and company submissions data for S-1, F-1 and 424B prospectus evidence. It never fabricates listing dates, valuations or tickers." },
   { title: "Signal scoring", body: "The Blum Intelligence Score combines momentum, trend quality, technical indicators, volatility/risk, sentiment trend, semantic intensity, ETF confirmation and anomaly pressure." },
   { title: "Explainability", body: "Each surfaced asset must expose why it appeared, which technical and narrative data support it, what contradicts it, what to monitor, and which risks limit confidence." },
   { title: "Backtesting", body: "Historical validation reports hit rate, forward returns, max adverse excursion, max favorable excursion, false positives and methodology limits. It does not promise future performance." },
   { title: "Provider architecture", body: "The first provider is yfinance. The backend isolates providers so future integrations can add licensed market data, estimates, filings, transcripts, ownership and portfolio systems." }
 ];
-

frontend/app/stock-radar/page.tsx

@@ -190,7 +190,7 @@ function StockRadarCard({ row }: { row: StockRadarRow }) {
         <div><span>Trend</span><strong>{factor(row, "trend")}</strong></div>
         <div><span>Momentum</span><strong>{factor(row, "momentum")}</strong></div>
         <div><span>Sentiment</span><strong>{factor(row, "sentiment")}</strong></div>
-        <div><span>Volume</span><strong>{formatVolume(row.market_snapshot.volume)}</strong></div>
+        <div><span>Confidence</span><strong>{row.signal?.confidence_score?.toFixed(0) ?? "n/a"}</strong></div>
       </div>
     </article>
   );
@@ -229,7 +229,8 @@ function StockRadarTable({ rows }: { rows: StockRadarRow[] }) {
               <td><span className="metric-pill">{row.research_priority}</span></td>
               <td>
                 {row.signal ? <StatusBadge label={row.signal.classification} /> : <StatusBadge label="Insufficient Evidence" />}
-                <span>Score {row.signal?.blum_score?.toFixed(1) ?? "n/a"} | {row.signal?.risk_level ?? "Not rated"}</span>
+                <span>Score {row.signal?.blum_score?.toFixed(1) ?? "n/a"} | conf {row.signal?.confidence_score?.toFixed(0) ?? "n/a"} | {row.signal?.risk_level ?? "Not rated"}</span>
+                <span>{row.signal?.lifecycle_state ?? "no lifecycle"} | {row.signal?.score_version ?? "no score version"}</span>
               </td>
               <td>
                 <span>Mom {factor(row, "momentum")} | Trend {factor(row, "trend")}</span>

frontend/app/themes/page.tsx

@@ -6,10 +6,12 @@ import { LoadingState } from "@/components/LoadingState";
 
 export default function ThemeExplorerPage() {
   const [themes, setThemes] = useState<any[] | null>(null);
+  const [themeDetail, setThemeDetail] = useState<any | null>(null);
   const [query, setQuery] = useState("AI infrastructure guidance");
   const [results, setResults] = useState<any[]>([]);
   useEffect(() => { api.themes().then(setThemes); }, []);
   const search = async () => setResults(await api.semanticSearch(query));
+  const openTheme = async (label: string) => setThemeDetail(await api.themeDetail(label));
   if (!themes) return <LoadingState label="Loading semantic themes" />;
   return (
     <>
@@ -22,12 +24,49 @@ export default function ThemeExplorerPage() {
       </div>
       <section className="grid-3">
         {themes.slice(0, 12).map((theme) => (
-          <article className="panel" key={theme.label}>
+          <article className="panel theme-card" key={theme.label} onClick={() => openTheme(theme.label)}>
             <div className="panel-head"><span>{theme.label}</span><strong>{theme.article_count ?? 0} articles</strong></div>
             <p>Keywords: {(theme.keywords ?? []).join(", ") || "semantic cluster"}</p>
+            <div className="tag-row">
+              <span>sentiment {Number(theme.sentiment_score ?? 0).toFixed(2)}</span>
+              <span>{theme.cluster_method ?? "theme aggregation"}</span>
+            </div>
           </article>
         ))}
       </section>
+      {themeDetail && (
+        <section className="panel" style={{ marginTop: 12 }}>
+          <div className="panel-head"><span>Theme detail</span><strong>{themeDetail.label}</strong></div>
+          <div className="grid-4">
+            <Metric label="Articles" value={themeDetail.article_count} />
+            <Metric label="Avg Sentiment" value={Number(themeDetail.average_sentiment).toFixed(2)} />
+            <Metric label="Sources" value={themeDetail.source_mix.length} />
+            <Metric label="Assets" value={themeDetail.linked_assets.length} />
+          </div>
+          <div className="grid-2" style={{ marginTop: 12 }}>
+            <div className="observed-model-panel">
+              <div className="panel-head"><span>Linked assets</span></div>
+              <div className="tag-row">
+                {themeDetail.linked_assets.slice(0, 20).map((asset: any) => <span key={asset.ticker}>{asset.ticker} {asset.mentions}</span>)}
+              </div>
+            </div>
+            <div className="observed-model-panel">
+              <div className="panel-head"><span>Source mix</span></div>
+              <div className="tag-row">
+                {themeDetail.source_mix.slice(0, 16).map((source: any) => <span key={source.source}>{source.source} {source.count}</span>)}
+              </div>
+            </div>
+          </div>
+          <div className="news-list" style={{ marginTop: 12 }}>
+            {themeDetail.articles.slice(0, 16).map((article: any) => (
+              <a className="news-item" href={article.url} target="_blank" rel="noreferrer" key={article.id}>
+                <strong>{article.title}</strong>
+                <span>{article.source} | sentiment {article.sentiment?.score?.toFixed?.(2) ?? "n/a"} | assets {(article.linked_assets ?? []).map((asset: any) => asset.ticker).join(" | ")}</span>
+              </a>
+            ))}
+          </div>
+        </section>
+      )}
       <section className="panel" style={{ marginTop: 12 }}>
         <div className="panel-head"><span>Semantic Search Results</span></div>
         <div className="news-list">
@@ -43,3 +82,6 @@ export default function ThemeExplorerPage() {
   );
 }
 
+function Metric({ label, value }: { label: string; value: number | string }) {
+  return <div className="metric-card"><span>{label}</span><strong>{value}</strong></div>;
+}

frontend/components/ScoreCard.tsx

@@ -22,8 +22,8 @@ export function ScoreCard({ signal }: { signal: Signal }) {
       <p>{signal.explanation}</p>
       <div className="mini-metrics">
         <div><span>Risk</span><strong>{signal.risk_level}</strong></div>
-        <div><span>Horizon</span><strong>{signal.time_horizon}</strong></div>
-        <div><span>Exchange</span><strong>{signal.asset?.exchange ?? "n/a"}</strong></div>
+        <div><span>Confidence</span><strong>{Number(signal.confidence_score ?? 0).toFixed(0)}</strong></div>
+        <div><span>Lifecycle</span><strong>{signal.lifecycle_state ?? "active"}</strong></div>
         <div><span>Volume</span><strong>{formatVolume(signal.market_snapshot?.volume)}</strong></div>
       </div>
     </article>

frontend/components/SignalTable.tsx

@@ -13,6 +13,7 @@ export function SignalTable({ signals }: { signals: Signal[] }) {
             <th>Asset</th>
             <th>Market</th>
             <th>Score</th>
+            <th>Confidence</th>
             <th>Classification</th>
             <th>Risk</th>
             <th>Momentum</th>
@@ -35,8 +36,12 @@ export function SignalTable({ signals }: { signals: Signal[] }) {
                 <span>{signal.market_snapshot?.provider ?? "provider n/a"} | vol {formatVolume(signal.market_snapshot?.volume)}</span>
               </td>
               <td><strong className="score-number">{signal.blum_score.toFixed(1)}</strong></td>
+              <td>
+                <span className="metric-pill">{Number(signal.confidence_score ?? 0).toFixed(0)}</span>
+                <span>{signal.lifecycle_state ?? "active"}</span>
+              </td>
               <td><StatusBadge label={signal.classification} /></td>
-              <td>{signal.risk_level}</td>
+              <td>{signal.risk_level}<span>{signal.score_version ?? "blum-score"}</span></td>
               <td>{metric(signal, "momentum_score")}</td>
               <td>{metric(signal, "trend_score")}</td>
               <td>{metric(signal, "sentiment_score")}</td>

frontend/lib/api.ts

@@ -1,4 +1,4 @@
-import { Asset, DashboardOverview, IPORadar, LiveNewsArticle, MarketBrain, MarketSentiment, PipelineStatus, RelatedNews, Signal, StockRadar } from "./types";
+import { Asset, DashboardOverview, IPORadar, LiveNewsArticle, MarketBrain, MarketBrainHistoryRow, MarketSentiment, PipelineStatus, RelatedNews, Signal, StockRadar } from "./types";
 
 const API_BASE = process.env.NEXT_PUBLIC_API_BASE ?? "";
 
@@ -35,13 +35,17 @@ export const api = {
   explain: (ticker: string) => getJson<any>(`/ai/explain/${ticker}`),
   relatedNews: (ticker: string) => getJson<RelatedNews[]>(`/related-news?ticker=${ticker}`),
   themes: () => getJson<any[]>("/themes"),
+  themeDetail: (label: string) => getJson<any>(`/themes/${encodeURIComponent(label)}`),
   etfTrends: () => getJson<any[]>("/etf-trends"),
   stockRadar: (limit = 80) => getJson<StockRadar>(`/stock-radar?limit=${limit}`),
   updateStockRadar: (limit = 36) => postJson<any>(`/stock-radar/update?limit=${limit}`, {}),
   ipoRadar: (limit = 80) => getJson<IPORadar>(`/ipo-radar?limit=${limit}`),
   updateIpoRadar: (limitPerForm = 50) => postJson<any>(`/ipo-radar/update?limit_per_form=${limitPerForm}`, {}),
+  secSubmissions: (cik: string, persist = false) => getJson<any>(`/ipo-radar/sec-submissions/${cik}?persist=${persist ? "true" : "false"}`),
   marketBrain: () => getJson<MarketBrain>("/market-brain"),
+  marketBrainHistory: (limit = 20) => getJson<MarketBrainHistoryRow[]>(`/market-brain/history?limit=${limit}`),
   runMarketBrain: (refreshPipeline = false) => postJson<MarketBrain>(`/market-brain/run?refresh_pipeline=${refreshPipeline ? "true" : "false"}&refresh_sec=true`, {}),
+  modelStatus: () => getJson<any>("/ai/models/status"),
   semanticSearch: (query: string) => postJson<any[]>("/semantic-search", { query, limit: 12 }),
   marketUpdate: () => postJson("/market/update", { period: "max", limit: 36 }),
   newsUpdate: () => postJson("/news/update", { lookback_hours: 72, limit_per_feed: 35 }),

frontend/lib/types.ts

@@ -31,6 +31,9 @@ export type Signal = {
   blum_score: number;
   risk_level: string;
   time_horizon: string;
+  score_version?: string;
+  confidence_score?: number;
+  lifecycle_state?: string;
   score_breakdown: Record<string, number>;
   technical_summary?: Record<string, number | string | boolean | null>;
   narrative_summary?: Record<string, number | string | boolean | null>;
@@ -119,6 +122,9 @@ export type StockRadarSignal = {
   blum_score: number;
   risk_level: string;
   time_horizon: string;
+  score_version?: string;
+  confidence_score?: number;
+  lifecycle_state?: string;
   score_breakdown: Record<string, number>;
   created_at: string;
 };
@@ -253,12 +259,31 @@ export type MarketBrain = {
     evidence: Record<string, any>;
   }>;
   risk_alerts: Array<{ severity: string; title: string; detail: string; tickers: string[] }>;
+  contradictions: Array<{ type: string; severity: string; ticker: string; title: string; evidence: Record<string, any> }>;
+  event_graph: {
+    nodes: Array<{ id: string; label: string; type: string; score?: number | null }>;
+    edges: Array<{ source: string; target: string; relationship: string; weight: number }>;
+  };
   evidence_ledger: Record<string, number | string>;
+  change_log: Array<{ type: string; severity: string; message: string; previous?: any; current?: any }>;
   model_stack: Record<string, string>;
   disclaimer: string;
   update_diagnostics?: Record<string, any>;
 };
 
+export type MarketBrainHistoryRow = {
+  run_id: string;
+  created_at: string;
+  brain_score: number;
+  regime: string;
+  summary: string;
+  risk_alert_count: number;
+  contradiction_count: number;
+  top_stock?: string | null;
+  top_etf?: string | null;
+  top_ipo?: string | null;
+};
+
 export type PricePoint = {
   date: string;
   open?: number;