Add chart vision technical analyst

README.md

@@ -29,6 +29,7 @@ This is not a consumer trading app and not a simple dashboard. The project is a
 | Accuracy layer | multi-provider checks, data quality, source credibility, macro/fundamental context and Blum Confidence Score |
 | Strategic intelligence | Opportunity Radar, Market Narrative AI, Asset Intelligence Reports, watchlist, portfolio scenarios and community sentiment |
 | Self-learning layer | signal outcome evaluation, accuracy memory, adaptive confidence, model weight versions and historical similarity cases |
+| Chart intelligence | Qwen3-VL/InternVL3-ready visual chart analyst plus deterministic OHLCV technical engine |
 | AI sentiment | FinBERT primary, VADER baseline |
 | Semantic layer | sentence-transformers embeddings, semantic search, theme discovery |
 | Reasoning | lightweight Qwen-compatible LLM evidence-only explanation layer |
@@ -45,6 +46,8 @@ Blum does not use one generic AI model for everything.
 - sentence-transformers: embeddings for semantic search, narrative clustering, recurring themes and links between assets, sectors and macro trends.
 - Qwen-compatible lightweight LLM: structured explanations from retrieved evidence only.
 - Blum Financial Brain: finance-domain reasoning adapter for regime interpretation, opportunity hypotheses, risk hypotheses and monitoring plans.
+- Chart Vision Technical Analyst: Qwen3-VL primary VLM for visual chart interpretation when configured, InternVL3 fallback for low-confidence or failed primary visual reads.
+- Deterministic Technical Analysis Engine: OHLCV-derived trend structure, levels, moving averages, RSI, MACD, Bollinger Bands, ATR, volume, gaps, divergences, volatility compression and risk/reward.
 - Statistical time-series module: anomalies, volatility regimes and scenario bands, ready for Chronos, TimesFM or PatchTST integration.
 - Rule-based quantitative engine: scoring, ranking, risk controls and classifications.
 
@@ -69,7 +72,9 @@ Blum does not use one generic AI model for everything.
 17. Evaluate matured signal outcomes after 1D, 3D, 7D, 14D and 30D.
 18. Update signal accuracy memory, source reliability, ticker/sector profiles and adaptive confidence adjustments.
 19. Version scoring weights in the database when real matured outcomes justify recalibration.
-20. Produce AI explanations using only retrieved evidence.
+20. Generate professional chart analysis from deterministic OHLCV evidence and optional Qwen3-VL/InternVL3 visual interpretation.
+21. Persist chart analyses, technical levels, technical signals and chart pattern memory.
+22. Produce AI explanations using only retrieved evidence.
 
 ## Live Runtime
 
@@ -151,6 +156,49 @@ The UI exposes:
 
 Governance rules are enforced in product language and API output: no absolute certainty, no direct financial advice, no autonomous trading, no self-modifying code and clear separation between observed data, inference and hypothesis.
 
+## Chart Vision Technical Analyst
+
+Blum includes a dedicated technical chart intelligence module. It is designed to read financial chart images when a vision model is configured, but it never relies only on visual interpretation.
+
+The module combines:
+
+- **Qwen3-VL** as the primary configurable vision-language model for chart screenshots.
+- **InternVL3** as a fallback model for low-confidence or failed visual interpretation.
+- A deterministic OHLCV technical analysis engine for objective indicator and level calculation.
+- Blum Financial Brain memory for historical context and similarity.
+- Existing sentiment/news context for confirmation or contradiction checks.
+
+The deterministic engine calculates:
+
+- trend direction;
+- higher highs, higher lows, lower highs and lower lows;
+- support and resistance zones;
+- EMA 9/21/50/200 and SMA 20/50/200;
+- RSI, MACD, Bollinger Bands and ATR;
+- relative volume and volume pressure;
+- volatility regime and compression;
+- gaps, consolidation zones and pullback quality;
+- accumulation/distribution bias;
+- price/RSI and price/MACD divergences;
+- breakout probability;
+- trend strength;
+- risk/reward geometry.
+
+The hybrid layer outputs trend summary, key levels, bullish/bearish/neutral evidence, confirmation signals, contradiction signals, invalidation level, risk zone, opportunity zone, confidence, scenarios, what to watch next and historical chart similarity.
+
+Model serving is configurable:
+
+```bash
+export CHART_VISION_MODEL=Qwen/Qwen3-VL
+export CHART_VISION_FALLBACK_MODEL=OpenGVLab/InternVL3
+export CHART_VISION_MODE=disabled   # local | remote | disabled
+export CHART_VISION_MIN_CONFIDENCE=0.70
+export CHART_VISION_REMOTE_URL=
+export CHART_VISION_REMOTE_TOKEN=
+```
+
+Default Docker demo behavior is `CHART_VISION_MODE=disabled`, so the app remains reliable on CPU Spaces. The UI displays: `Vision model unavailable, deterministic analysis active`. Use `remote` mode for a production VLM endpoint.
+
 ## Market Brain
 
 The Market Brain is Blum's high-level reasoning orchestrator. It is not a single model that invents an answer. It combines:
@@ -252,6 +300,12 @@ FastAPI exposes clean JSON endpoints:
 - `POST /brain/evaluate-signals`
 - `POST /brain/recalculate-weights`
 - `POST /brain/run-learning-cycle`
+- `POST /chart/analyze-image`
+- `POST /chart/analyze-ticker`
+- `GET /chart/technical-report/{ticker}`
+- `GET /chart/levels/{ticker}`
+- `GET /chart/signals/{ticker}`
+- `GET /chart/history/{ticker}`
 - `POST /signals/run`
 - `POST /pipeline/run`
 - `GET /pipeline/status`
@@ -291,6 +345,7 @@ Interactive API docs are available at `/docs`.
 - Asset Intelligence Report
 - AI Portfolio Scenario
 - Market Brain
+- Chart Analyst
 - Asset Detail
 - Blum Memory
 - Stock Radar
@@ -387,6 +442,7 @@ Backtesting is included for research validation only. It reports historical hit
 - SEC EDGAR current feeds are public filing evidence. They do not cover private-company rumor, expected listings without filings or licensed IPO calendars.
 - The system does not generate synthetic prices. If public providers fail or rate-limit, the affected assets are reported as missing instead of being filled with fake data.
 - FinBERT, embeddings and LLM model loading depend on runtime memory and Hugging Face model availability.
+- Qwen3-VL and InternVL3 chart vision are optional because multimodal models can exceed CPU Space resources. Deterministic OHLCV technical analysis remains active without them.
 - The reasoning layer must not invent data; it is constrained to retrieved evidence.
 - Signal classifications are research triage outputs, not investment recommendations.
 - PostgreSQL is the database layer; the Docker demo can start an embedded PostgreSQL instance for Hugging Face convenience.

ROADMAP.md

@@ -2,7 +2,7 @@
 
 This roadmap is the execution plan for turning Blum into a credible open-source AI financial intelligence platform. Each phase should ship with working code, API coverage, UI coverage, documentation and explicit limitations.
 
-## Current Increment - Self-Learning Financial Brain
+## Current Increment - Chart Vision Technical Analyst
 
 Shipped in the current architecture:
 
@@ -37,6 +37,14 @@ Shipped in the current architecture:
 - Asset Detail now exposes Blum Memory: similar historical setups, confidence evolution, outcome history, confidence-change reasons and what Blum learned.
 - Signal Lab now exposes pre-signal confidence, post-evaluation result, learning impact and invalidating conditions for stored horizon evaluations.
 - Governance is explicit: no autonomous code modification, no trading, no certainty claims, no direct financial advice and every database-only weight change is reversible.
+- Chart Vision Technical Analyst adds a Qwen3-VL primary / InternVL3 fallback architecture for chart image interpretation, with deterministic OHLCV analysis as the always-on backbone.
+- New chart tables include `chart_analyses`, `technical_levels`, `technical_signals` and `chart_pattern_memory`.
+- New chart APIs include `/chart/analyze-image`, `/chart/analyze-ticker`, `/chart/technical-report/{ticker}`, `/chart/levels/{ticker}`, `/chart/signals/{ticker}` and `/chart/history/{ticker}`.
+- The deterministic engine calculates trend structure, moving averages, RSI, MACD, Bollinger Bands, ATR, support/resistance, volume pressure, gaps, consolidation, accumulation/distribution, divergences, breakout probability, pullback quality and risk/reward geometry.
+- The hybrid chart layer compares visual observations, OHLCV indicators, sentiment/news, Blum memory and similar chart setups.
+- Asset Detail now includes a Chart Analyst module with timeframe selector, key-level overlays, technical snapshot, signal evidence, analyst report and historical similarity.
+- A dedicated Chart Analyst page allows fast ticker-level technical analysis without opening an asset detail first.
+- Default Space behavior keeps `CHART_VISION_MODE=disabled` for CPU reliability; the UI explicitly reports deterministic analysis active when the VLM is unavailable.
 
 ## Phase 0 - Stabilize Docker Space Deployment
 

backend/alembic/versions/0007_chart_vision_technical_analyst.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+
+revision = "0007_chart_vision_technical_analyst"
+down_revision = "0006_financial_brain_learning"
+branch_labels = None
+depends_on = None
+
+
+json_type = postgresql.JSONB(astext_type=sa.Text())
+
+
+def upgrade() -> None:
+    op.create_table(
+        "chart_analyses",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("asset_id", sa.Integer(), nullable=True),
+        sa.Column("ticker", sa.String(length=32), nullable=True),
+        sa.Column("timeframe", sa.String(length=40), nullable=False),
+        sa.Column("period", sa.String(length=40), nullable=False),
+        sa.Column("image_hash", sa.String(length=128), nullable=True),
+        sa.Column("model_used", sa.String(length=180), nullable=False),
+        sa.Column("visual_analysis_json", json_type, nullable=False),
+        sa.Column("deterministic_analysis_json", json_type, nullable=False),
+        sa.Column("hybrid_analysis_json", json_type, nullable=False),
+        sa.Column("chart_image", sa.Text(), nullable=True),
+        sa.Column("confidence", sa.Float(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.ForeignKeyConstraint(["asset_id"], ["assets.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_chart_analyses_asset_id", "chart_analyses", ["asset_id"])
+    op.create_index("ix_chart_analyses_ticker", "chart_analyses", ["ticker"])
+    op.create_index("ix_chart_analyses_timeframe", "chart_analyses", ["timeframe"])
+    op.create_index("ix_chart_analyses_period", "chart_analyses", ["period"])
+    op.create_index("ix_chart_analyses_image_hash", "chart_analyses", ["image_hash"])
+    op.create_index("ix_chart_analyses_model_used", "chart_analyses", ["model_used"])
+    op.create_index("ix_chart_analyses_confidence", "chart_analyses", ["confidence"])
+    op.create_index("ix_chart_analyses_created_at", "chart_analyses", ["created_at"])
+    op.create_index("ix_chart_analyses_ticker_timeframe_created", "chart_analyses", ["ticker", "timeframe", "created_at"])
+
+    op.create_table(
+        "technical_levels",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("asset_id", sa.Integer(), nullable=True),
+        sa.Column("ticker", sa.String(length=32), nullable=False),
+        sa.Column("timeframe", sa.String(length=40), nullable=False),
+        sa.Column("support_levels_json", json_type, nullable=False),
+        sa.Column("resistance_levels_json", json_type, nullable=False),
+        sa.Column("breakout_level", sa.Float(), nullable=True),
+        sa.Column("breakdown_level", sa.Float(), nullable=True),
+        sa.Column("invalidation_level", sa.Float(), nullable=True),
+        sa.Column("updated_at", sa.DateTime(), nullable=False),
+        sa.ForeignKeyConstraint(["asset_id"], ["assets.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("ticker", "timeframe", name="uq_technical_levels_ticker_timeframe"),
+    )
+    op.create_index("ix_technical_levels_asset_id", "technical_levels", ["asset_id"])
+    op.create_index("ix_technical_levels_ticker", "technical_levels", ["ticker"])
+    op.create_index("ix_technical_levels_timeframe", "technical_levels", ["timeframe"])
+    op.create_index("ix_technical_levels_updated_at", "technical_levels", ["updated_at"])
+    op.create_index("ix_technical_levels_ticker_updated", "technical_levels", ["ticker", "updated_at"])
+
+    op.create_table(
+        "technical_signals",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("asset_id", sa.Integer(), nullable=True),
+        sa.Column("ticker", sa.String(length=32), nullable=False),
+        sa.Column("timeframe", sa.String(length=40), nullable=False),
+        sa.Column("signal_type", sa.String(length=120), nullable=False),
+        sa.Column("direction", sa.String(length=40), nullable=False),
+        sa.Column("confidence", sa.Float(), nullable=False),
+        sa.Column("evidence_json", json_type, nullable=False),
+        sa.Column("invalidation_level", sa.Float(), nullable=True),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.ForeignKeyConstraint(["asset_id"], ["assets.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_technical_signals_asset_id", "technical_signals", ["asset_id"])
+    op.create_index("ix_technical_signals_ticker", "technical_signals", ["ticker"])
+    op.create_index("ix_technical_signals_timeframe", "technical_signals", ["timeframe"])
+    op.create_index("ix_technical_signals_signal_type", "technical_signals", ["signal_type"])
+    op.create_index("ix_technical_signals_direction", "technical_signals", ["direction"])
+    op.create_index("ix_technical_signals_confidence", "technical_signals", ["confidence"])
+    op.create_index("ix_technical_signals_created_at", "technical_signals", ["created_at"])
+    op.create_index("ix_technical_signals_ticker_timeframe_created", "technical_signals", ["ticker", "timeframe", "created_at"])
+
+    op.create_table(
+        "chart_pattern_memory",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("asset_id", sa.Integer(), nullable=True),
+        sa.Column("ticker", sa.String(length=32), nullable=False),
+        sa.Column("timeframe", sa.String(length=40), nullable=False),
+        sa.Column("pattern_type", sa.String(length=120), nullable=False),
+        sa.Column("setup_embedding", json_type, nullable=False),
+        sa.Column("outcome_1d", sa.Float(), nullable=True),
+        sa.Column("outcome_7d", sa.Float(), nullable=True),
+        sa.Column("outcome_30d", sa.Float(), nullable=True),
+        sa.Column("max_drawdown", sa.Float(), nullable=True),
+        sa.Column("success", sa.Boolean(), nullable=True),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.ForeignKeyConstraint(["asset_id"], ["assets.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_chart_pattern_memory_asset_id", "chart_pattern_memory", ["asset_id"])
+    op.create_index("ix_chart_pattern_memory_ticker", "chart_pattern_memory", ["ticker"])
+    op.create_index("ix_chart_pattern_memory_timeframe", "chart_pattern_memory", ["timeframe"])
+    op.create_index("ix_chart_pattern_memory_pattern_type", "chart_pattern_memory", ["pattern_type"])
+    op.create_index("ix_chart_pattern_memory_success", "chart_pattern_memory", ["success"])
+    op.create_index("ix_chart_pattern_memory_created_at", "chart_pattern_memory", ["created_at"])
+    op.create_index("ix_chart_pattern_memory_ticker_pattern_created", "chart_pattern_memory", ["ticker", "pattern_type", "created_at"])
+
+
+def downgrade() -> None:
+    op.drop_table("chart_pattern_memory")
+    op.drop_table("technical_signals")
+    op.drop_table("technical_levels")
+    op.drop_table("chart_analyses")

backend/app/api/routes.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
 from datetime import datetime
+import json
 import os
 
 from sqlalchemy import desc, func, select
 from sqlalchemy.orm import Session
-from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, UploadFile
 
 from app.ai.orchestrator import AIOrchestrator
 from app.ai.financial_brain import FinancialBrainModel
@@ -16,6 +17,8 @@ from app.models import (
     AIInsight,
     AccuracySnapshot,
     Asset,
+    ChartAnalysis,
+    ChartPatternMemory,
     ConfidenceAdjustment,
     EmbeddingVector,
     FundamentalSnapshot,
@@ -35,6 +38,8 @@ from app.models import (
     SignalOutcome,
     SignalSnapshot,
     SourceReliabilityScore,
+    TechnicalLevel,
+    TechnicalSignal,
     TickerAccuracyProfile,
     WatchlistItem,
 )
@@ -44,6 +49,7 @@ from app.services.dashboard import dashboard_overview, signal_payload
 from app.services.data_continuity import data_coverage_report, repair_data_gaps
 from app.services.etf import list_etf_trends, update_etf_trends
 from app.services.fundamentals import fundamentals_for_asset, update_fundamentals
+from app.services.chart_vision_engine import ChartVisionEngine
 from app.services.financial_brain_learning import (
     brain_accuracy,
     brain_asset_memory,
@@ -55,6 +61,7 @@ from app.services.financial_brain_learning import (
     recalculate_model_weights,
     run_learning_cycle,
 )
+from app.services.hybrid_chart_intelligence import HybridChartIntelligence
 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.macro import macro_overview, update_macro_snapshots
@@ -94,7 +101,7 @@ def system_status(db: Session = Depends(get_db)) -> dict:
     return {
         "service": "blum-ai-financial-intelligence",
         "app_version": settings.app_version,
-        "feature_set": "self-learning-financial-brain-v0.5.7",
+        "feature_set": "chart-vision-technical-analyst-v0.5.8",
         "environment": settings.environment,
         "generated_at": datetime.utcnow().isoformat(),
         "hugging_face": {
@@ -115,6 +122,8 @@ def system_status(db: Session = Depends(get_db)) -> dict:
             "accuracy_audit_minutes": settings.accuracy_audit_minutes,
             "learning_loop_enabled": settings.enable_learning_loop,
             "learning_loop_minutes": settings.learning_loop_minutes,
+            "chart_vision_mode": settings.chart_vision_mode,
+            "chart_vision_min_confidence": settings.chart_vision_min_confidence,
             "fundamentals_refresh_minutes": settings.fundamentals_refresh_minutes,
             "macro_refresh_minutes": settings.macro_refresh_minutes,
         },
@@ -124,6 +133,7 @@ def system_status(db: Session = Depends(get_db)) -> dict:
             "reasoning_llm": settings.llm_model,
             "financial_brain_configured": settings.financial_brain_model,
             "financial_brain_runtime": FinancialBrainModel().status(),
+            "chart_vision": ChartVisionEngine().status(),
         },
         "feature_visibility": {
             "market_brain_page": True,
@@ -137,6 +147,7 @@ def system_status(db: Session = Depends(get_db)) -> dict:
             "macro_fundamental_context": True,
             "strategic_intelligence_layer": True,
             "self_learning_financial_brain": True,
+            "chart_vision_technical_analyst": True,
             "portfolio_scenario": True,
             "watchlist": True,
         },
@@ -161,13 +172,17 @@ def system_status(db: Session = Depends(get_db)) -> dict:
             "source_reliability_scores": int(db.scalar(select(func.count(SourceReliabilityScore.id))) or 0),
             "ticker_accuracy_profiles": int(db.scalar(select(func.count(TickerAccuracyProfile.id))) or 0),
             "sector_accuracy_profiles": int(db.scalar(select(func.count(SectorAccuracyProfile.id))) or 0),
+            "chart_analyses": int(db.scalar(select(func.count(ChartAnalysis.id))) or 0),
+            "technical_levels": int(db.scalar(select(func.count(TechnicalLevel.id))) or 0),
+            "technical_signals": int(db.scalar(select(func.count(TechnicalSignal.id))) or 0),
+            "chart_pattern_memory": int(db.scalar(select(func.count(ChartPatternMemory.id))) or 0),
         },
         "latest_news_created_at": latest_brain,
         "why_gui_can_look_unchanged": [
             "Hugging Face serves the previous image until the Docker build finishes successfully.",
             "The finance-domain 7B model is disabled by default unless BLUM_ENABLE_FINANCIAL_BRAIN_MODEL=true.",
             "Existing snapshots must be regenerated with Run brain or full pipeline after a new deployment.",
-            "Browser cache can keep old static Next.js chunks; hard refresh if app_version is not 0.5.7.",
+            "Browser cache can keep old static Next.js chunks; hard refresh if app_version is not 0.5.8.",
         ],
     }
 
@@ -223,6 +238,64 @@ def financial_brain_run_learning_cycle(limit: int = Query(default=240, ge=1, le=
     return run_learning_cycle(db, limit=limit)
 
 
+@router.post("/chart/analyze-image")
+async def chart_analyze_image(
+    image: UploadFile = File(...),
+    ticker: str | None = Form(default=None),
+    timeframe: str = Form(default="unknown"),
+    ohlcv_data: str | None = Form(default=None),
+    db: Session = Depends(get_db),
+) -> dict:
+    image_bytes = await image.read()
+    if not image_bytes:
+        raise HTTPException(status_code=400, detail="Uploaded chart image is empty.")
+    parsed_ohlcv = parse_ohlcv_payload(ohlcv_data)
+    return HybridChartIntelligence().analyze_uploaded_image(
+        db,
+        image_bytes=image_bytes,
+        ticker=ticker.upper() if ticker else None,
+        timeframe=timeframe,
+        ohlcv_rows=parsed_ohlcv,
+        persist=bool(ticker),
+    )
+
+
+@router.post("/chart/analyze-ticker")
+def chart_analyze_ticker(
+    ticker: str = Query(...),
+    timeframe: str = Query(default="6M"),
+    period: str = Query(default="1y"),
+    include_visual: bool = Query(default=False),
+    db: Session = Depends(get_db),
+) -> dict:
+    asset = require_asset(db, ticker)
+    return HybridChartIntelligence().analyze_ticker(db, asset, timeframe=timeframe, period=period, include_visual=include_visual, persist=True)
+
+
+@router.get("/chart/technical-report/{ticker}")
+def chart_technical_report(ticker: str, timeframe: str = Query(default="6M"), db: Session = Depends(get_db)) -> dict:
+    asset = require_asset(db, ticker)
+    return HybridChartIntelligence().latest_report(db, asset, timeframe=timeframe)
+
+
+@router.get("/chart/levels/{ticker}")
+def chart_levels(ticker: str, timeframe: str = Query(default="6M"), db: Session = Depends(get_db)) -> dict:
+    asset = require_asset(db, ticker)
+    return HybridChartIntelligence().levels(db, asset, timeframe=timeframe)
+
+
+@router.get("/chart/signals/{ticker}")
+def chart_signals(ticker: str, timeframe: str = Query(default="6M"), limit: int = Query(default=30, ge=1, le=120), db: Session = Depends(get_db)) -> list[dict]:
+    asset = require_asset(db, ticker)
+    return HybridChartIntelligence().signals(db, asset, timeframe=timeframe, limit=limit)
+
+
+@router.get("/chart/history/{ticker}")
+def chart_history(ticker: str, limit: int = Query(default=30, ge=1, le=120), db: Session = Depends(get_db)) -> list[dict]:
+    asset = require_asset(db, ticker)
+    return HybridChartIntelligence().history(db, asset, limit=limit)
+
+
 @router.get("/assets")
 def list_assets(
     asset_type: str | None = Query(default=None),
@@ -580,9 +653,12 @@ def ai_model_status(db: Session = Depends(get_db)):
             "embeddings": settings.embedding_model,
             "reasoning_llm": settings.llm_model,
             "financial_brain": settings.financial_brain_model,
+            "chart_vision_primary": settings.chart_vision_model,
+            "chart_vision_fallback": settings.chart_vision_fallback_model,
             "time_series": "statistical-fallback with adapter-ready interface",
         },
         "financial_brain": FinancialBrainModel().status(),
+        "chart_vision": ChartVisionEngine().status(),
         "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],
@@ -593,6 +669,7 @@ def ai_model_status(db: Session = Depends(get_db)):
             "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.",
+            "chart_vision": "Qwen3-VL primary when remote/local vision is configured; InternVL3 fallback; deterministic OHLCV analysis remains active if VLM is unavailable.",
         },
     }
 
@@ -644,6 +721,33 @@ def backtest(ticker: str, db: Session = Depends(get_db)):
     return run_simple_backtest(db, asset.id, asset.ticker)
 
 
+def parse_ohlcv_payload(raw: str | None) -> list[dict] | None:
+    if not raw:
+        return None
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise HTTPException(status_code=400, detail=f"Invalid ohlcv_data JSON: {exc.msg}") from exc
+    rows = payload.get("rows") if isinstance(payload, dict) else payload
+    if not isinstance(rows, list):
+        raise HTTPException(status_code=400, detail="ohlcv_data must be a JSON array or an object with a rows array.")
+    normalized = []
+    for row in rows:
+        if not isinstance(row, dict) or "close" not in row:
+            continue
+        normalized.append(
+            {
+                "date": row.get("date"),
+                "open": row.get("open", row.get("close")),
+                "high": row.get("high", row.get("close")),
+                "low": row.get("low", row.get("close")),
+                "close": row.get("close"),
+                "volume": row.get("volume", 0),
+            }
+        )
+    return normalized
+
+
 def require_asset(db: Session, ticker: str) -> Asset:
     asset = db.scalar(select(Asset).where(Asset.ticker == ticker.upper()))
     if not asset:

backend/app/core/config.py

@@ -5,7 +5,7 @@ from pydantic_settings import BaseSettings
 
 class Settings(BaseSettings):
     app_name: str = "Blum AI Financial Intelligence"
-    app_version: str = "0.5.7"
+    app_version: str = "0.5.8"
     environment: str = Field(default="demo", alias="ENVIRONMENT")
     database_url: str = Field(
         default="postgresql+psycopg2://postgres:postgres@127.0.0.1:5432/blum",
@@ -20,6 +20,12 @@ class Settings(BaseSettings):
     enable_financial_brain_model: bool = Field(default=False, alias="BLUM_ENABLE_FINANCIAL_BRAIN_MODEL")
     financial_brain_model: str = Field(default="AdaptLLM/finance-chat", alias="BLUM_FINANCIAL_BRAIN_MODEL")
     financial_brain_max_new_tokens: int = Field(default=420, alias="BLUM_FINANCIAL_BRAIN_MAX_NEW_TOKENS")
+    chart_vision_model: str = Field(default="Qwen/Qwen3-VL", alias="CHART_VISION_MODEL")
+    chart_vision_fallback_model: str = Field(default="OpenGVLab/InternVL3", alias="CHART_VISION_FALLBACK_MODEL")
+    chart_vision_mode: str = Field(default="disabled", alias="CHART_VISION_MODE")
+    chart_vision_remote_url: str = Field(default="", alias="CHART_VISION_REMOTE_URL")
+    chart_vision_remote_token: str = Field(default="", alias="CHART_VISION_REMOTE_TOKEN")
+    chart_vision_min_confidence: float = Field(default=0.70, alias="CHART_VISION_MIN_CONFIDENCE")
     default_benchmark: str = Field(default="SPY", alias="BLUM_DEFAULT_BENCHMARK")
     enable_yfinance_fallback: bool = Field(default=False, alias="BLUM_ENABLE_YFINANCE_FALLBACK")
     max_update_assets: int = Field(default=36, alias="BLUM_MAX_UPDATE_ASSETS")

backend/app/models.py

@@ -466,6 +466,89 @@ class SectorAccuracyProfile(Base):
     updated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, index=True)
 
 
+class ChartAnalysis(Base):
+    __tablename__ = "chart_analyses"
+    __table_args__ = (
+        Index("ix_chart_analyses_ticker_timeframe_created", "ticker", "timeframe", "created_at"),
+        Index("ix_chart_analyses_image_hash", "image_hash"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    asset_id: Mapped[int | None] = mapped_column(ForeignKey("assets.id", ondelete="SET NULL"), index=True)
+    ticker: Mapped[str | None] = mapped_column(String(32), index=True)
+    timeframe: Mapped[str] = mapped_column(String(40), default="6M", index=True)
+    period: Mapped[str] = mapped_column(String(40), default="1y", index=True)
+    image_hash: Mapped[str | None] = mapped_column(String(128), index=True)
+    model_used: Mapped[str] = mapped_column(String(180), default="deterministic_technical_analysis", index=True)
+    visual_analysis_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    deterministic_analysis_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    hybrid_analysis_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    chart_image: Mapped[str | None] = mapped_column(Text)
+    confidence: Mapped[float] = mapped_column(Float, default=0.0, index=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+
+    asset = relationship("Asset")
+
+
+class TechnicalLevel(Base):
+    __tablename__ = "technical_levels"
+    __table_args__ = (
+        UniqueConstraint("ticker", "timeframe", name="uq_technical_levels_ticker_timeframe"),
+        Index("ix_technical_levels_ticker_updated", "ticker", "updated_at"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    asset_id: Mapped[int | None] = mapped_column(ForeignKey("assets.id", ondelete="SET NULL"), index=True)
+    ticker: Mapped[str] = mapped_column(String(32), index=True)
+    timeframe: Mapped[str] = mapped_column(String(40), default="6M", index=True)
+    support_levels_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    resistance_levels_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    breakout_level: Mapped[float | None] = mapped_column(Float)
+    breakdown_level: Mapped[float | None] = mapped_column(Float)
+    invalidation_level: Mapped[float | None] = mapped_column(Float)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, index=True)
+
+    asset = relationship("Asset")
+
+
+class TechnicalSignal(Base):
+    __tablename__ = "technical_signals"
+    __table_args__ = (Index("ix_technical_signals_ticker_timeframe_created", "ticker", "timeframe", "created_at"),)
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    asset_id: Mapped[int | None] = mapped_column(ForeignKey("assets.id", ondelete="SET NULL"), index=True)
+    ticker: Mapped[str] = mapped_column(String(32), index=True)
+    timeframe: Mapped[str] = mapped_column(String(40), default="6M", index=True)
+    signal_type: Mapped[str] = mapped_column(String(120), index=True)
+    direction: Mapped[str] = mapped_column(String(40), index=True)
+    confidence: Mapped[float] = mapped_column(Float, default=0.0, index=True)
+    evidence_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    invalidation_level: Mapped[float | None] = mapped_column(Float)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+
+    asset = relationship("Asset")
+
+
+class ChartPatternMemory(Base):
+    __tablename__ = "chart_pattern_memory"
+    __table_args__ = (Index("ix_chart_pattern_memory_ticker_pattern_created", "ticker", "pattern_type", "created_at"),)
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    asset_id: Mapped[int | None] = mapped_column(ForeignKey("assets.id", ondelete="SET NULL"), index=True)
+    ticker: Mapped[str] = mapped_column(String(32), index=True)
+    timeframe: Mapped[str] = mapped_column(String(40), default="6M", index=True)
+    pattern_type: Mapped[str] = mapped_column(String(120), index=True)
+    setup_embedding: Mapped[dict] = mapped_column(JsonType, default=dict)
+    outcome_1d: Mapped[float | None] = mapped_column(Float)
+    outcome_7d: Mapped[float | None] = mapped_column(Float)
+    outcome_30d: Mapped[float | None] = mapped_column(Float)
+    max_drawdown: Mapped[float | None] = mapped_column(Float)
+    success: Mapped[bool | None] = mapped_column(Boolean, index=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+
+    asset = relationship("Asset")
+
+
 class AccuracySnapshot(Base):
     __tablename__ = "accuracy_snapshots"
     __table_args__ = (Index("ix_accuracy_snapshots_scope_created", "scope", "created_at"),)

backend/app/services/chart_vision_engine.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+from typing import Any
+
+import requests
+
+from app.core.config import get_settings
+
+
+CHART_VISION_PROMPT = (
+    "You are an expert institutional technical analyst. Analyze this financial chart with maximum precision. "
+    "Identify trend, structure, support, resistance, breakout/breakdown, volume behavior, volatility compression, "
+    "candlestick signals, moving average behavior, momentum signals, divergences, continuation/reversal patterns, "
+    "and invalidation levels. Distinguish between what is visually observable and what is inferred. "
+    "Do not invent data not visible in the chart. Return structured JSON with: chart_type, timeframe_detected, "
+    "asset_detected, visible_indicators, trend_structure, support_levels, resistance_levels, chart_patterns, "
+    "candlestick_patterns, volume_analysis, momentum_interpretation, volatility_interpretation, bullish_evidence, "
+    "bearish_evidence, neutral_evidence, invalidation_levels, technical_summary, confidence, uncertainty_notes."
+)
+
+
+class ChartVisionEngine:
+    def __init__(self):
+        self.settings = get_settings()
+
+    def status(self) -> dict:
+        return {
+            "mode": self.settings.chart_vision_mode,
+            "primary_model": self.settings.chart_vision_model,
+            "fallback_model": self.settings.chart_vision_fallback_model,
+            "remote_configured": bool(self.settings.chart_vision_remote_url),
+            "min_confidence": self.settings.chart_vision_min_confidence,
+            "runtime_policy": "Vision is optional. If unavailable, deterministic OHLCV analysis remains active.",
+        }
+
+    def analyze_image(self, image_bytes: bytes, ticker: str | None = None, timeframe: str | None = None, ohlcv_hint: dict | None = None) -> dict:
+        image_hash = hashlib.sha256(image_bytes).hexdigest()
+        if self.settings.chart_vision_mode == "remote" and self.settings.chart_vision_remote_url:
+            remote = self._remote_inference(image_bytes, ticker=ticker, timeframe=timeframe, ohlcv_hint=ohlcv_hint)
+            remote["image_hash"] = image_hash
+            if confidence_meets_threshold(remote.get("confidence"), self.settings.chart_vision_min_confidence):
+                return normalize_visual_analysis(remote, image_hash, self.settings.chart_vision_model)
+            fallback = self._remote_inference(image_bytes, ticker=ticker, timeframe=timeframe, ohlcv_hint=ohlcv_hint, fallback=True)
+            fallback["image_hash"] = image_hash
+            return normalize_visual_analysis(fallback, image_hash, self.settings.chart_vision_fallback_model)
+        if self.settings.chart_vision_mode == "local":
+            local = self._local_inference(image_bytes, ticker=ticker, timeframe=timeframe, ohlcv_hint=ohlcv_hint)
+            local["image_hash"] = image_hash
+            return normalize_visual_analysis(local, image_hash, local.get("model_used", self.settings.chart_vision_model))
+        return disabled_visual_analysis(image_hash, ticker, timeframe)
+
+    def _remote_inference(self, image_bytes: bytes, ticker: str | None, timeframe: str | None, ohlcv_hint: dict | None, fallback: bool = False) -> dict:
+        model = self.settings.chart_vision_fallback_model if fallback else self.settings.chart_vision_model
+        headers = {"Content-Type": "application/json"}
+        if self.settings.chart_vision_remote_token:
+            headers["Authorization"] = f"Bearer {self.settings.chart_vision_remote_token}"
+        payload = {
+            "model": model,
+            "prompt": CHART_VISION_PROMPT,
+            "image_base64": base64.b64encode(image_bytes).decode("ascii"),
+            "ticker": ticker,
+            "timeframe": timeframe,
+            "ohlcv_hint": ohlcv_hint or {},
+            "response_format": "json",
+        }
+        try:
+            response = requests.post(self.settings.chart_vision_remote_url, headers=headers, json=payload, timeout=90)
+            response.raise_for_status()
+            data = response.json()
+            if isinstance(data, dict) and "visual_analysis" in data:
+                data = data["visual_analysis"]
+            if isinstance(data, str):
+                data = json.loads(data)
+            data["model_used"] = model
+            data["mode"] = "remote"
+            return data
+        except Exception as exc:
+            return unavailable_visual_analysis(ticker, timeframe, model, f"Remote chart vision failed: {type(exc).__name__}: {str(exc)}")
+
+    def _local_inference(self, image_bytes: bytes, ticker: str | None, timeframe: str | None, ohlcv_hint: dict | None) -> dict:
+        try:
+            import torch
+        except Exception as exc:
+            return unavailable_visual_analysis(ticker, timeframe, self.settings.chart_vision_model, f"PyTorch unavailable: {type(exc).__name__}: {str(exc)}")
+        if not torch.cuda.is_available():
+            return unavailable_visual_analysis(ticker, timeframe, self.settings.chart_vision_model, "No GPU detected. Local Qwen3-VL inference is disabled to keep the Space responsive.")
+        return unavailable_visual_analysis(
+            ticker,
+            timeframe,
+            self.settings.chart_vision_model,
+            "Local VLM adapter is configured but not activated in this CPU demo. Use CHART_VISION_MODE=remote for production-grade VLM serving.",
+        )
+
+
+def normalize_visual_analysis(payload: dict, image_hash: str, model_used: str) -> dict:
+    base = empty_visual_contract()
+    base.update({key: payload.get(key, base[key]) for key in base})
+    base["image_hash"] = image_hash
+    base["model_used"] = payload.get("model_used") or model_used
+    base["mode"] = payload.get("mode", "remote")
+    base["confidence"] = safe_confidence(base.get("confidence"))
+    base["uncertainty_notes"] = normalize_list(base.get("uncertainty_notes"))
+    return base
+
+
+def disabled_visual_analysis(image_hash: str, ticker: str | None, timeframe: str | None) -> dict:
+    payload = empty_visual_contract()
+    payload.update(
+        {
+            "image_hash": image_hash,
+            "model_used": "chart_vision_disabled",
+            "mode": "disabled",
+            "asset_detected": ticker or "",
+            "timeframe_detected": timeframe or "unknown",
+            "technical_summary": "Vision model unavailable, deterministic analysis active.",
+            "confidence": 0.0,
+            "uncertainty_notes": [
+                "CHART_VISION_MODE is disabled.",
+                "No visual levels are inferred from the uploaded chart.",
+                "Use deterministic OHLCV analysis for calculated technical evidence.",
+            ],
+        }
+    )
+    return payload
+
+
+def unavailable_visual_analysis(ticker: str | None, timeframe: str | None, model: str, reason: str) -> dict:
+    payload = empty_visual_contract()
+    payload.update(
+        {
+            "model_used": model,
+            "mode": "unavailable",
+            "asset_detected": ticker or "",
+            "timeframe_detected": timeframe or "unknown",
+            "technical_summary": "Vision model unavailable, deterministic analysis active.",
+            "confidence": 0.0,
+            "uncertainty_notes": [reason],
+        }
+    )
+    return payload
+
+
+def empty_visual_contract() -> dict[str, Any]:
+    return {
+        "chart_type": "unknown",
+        "timeframe_detected": "unknown",
+        "asset_detected": "",
+        "visible_indicators": [],
+        "trend_structure": {},
+        "support_levels": [],
+        "resistance_levels": [],
+        "chart_patterns": [],
+        "candlestick_patterns": [],
+        "volume_analysis": {},
+        "momentum_interpretation": {},
+        "volatility_interpretation": {},
+        "bullish_evidence": [],
+        "bearish_evidence": [],
+        "neutral_evidence": [],
+        "invalidation_levels": [],
+        "technical_summary": "",
+        "confidence": 0.0,
+        "uncertainty_notes": [],
+    }
+
+
+def safe_confidence(value: Any) -> float:
+    try:
+        numeric = float(value)
+        if numeric <= 1:
+            numeric *= 100
+        return round(max(0, min(100, numeric)), 1)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def confidence_meets_threshold(value: Any, threshold: float) -> bool:
+    confidence = safe_confidence(value)
+    threshold_pct = threshold * 100 if threshold <= 1 else threshold
+    return confidence >= threshold_pct
+
+
+def normalize_list(value: Any) -> list:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    return [str(value)]

backend/app/services/hybrid_chart_intelligence.py

@@ -0,0 +1,655 @@
+from __future__ import annotations
+
+import base64
+from datetime import datetime
+import hashlib
+from statistics import mean
+
+import pandas as pd
+from sqlalchemy import delete, desc, func, select
+from sqlalchemy.orm import Session
+
+from app.models import (
+    Asset,
+    ChartAnalysis,
+    ChartPatternMemory,
+    NewsArticle,
+    NewsAssetLink,
+    SentimentAnalysis,
+    TechnicalLevel,
+    TechnicalSignal,
+)
+from app.services.chart_vision_engine import ChartVisionEngine
+from app.services.financial_brain_learning import brain_asset_memory
+from app.services.technical_analysis_engine import TechnicalAnalysisEngine, normalize_frame
+from app.signals.engine import load_prices
+
+
+DISCLAIMER = "This is technical analysis, not financial advice."
+
+
+class HybridChartIntelligence:
+    def __init__(self):
+        self.technical = TechnicalAnalysisEngine()
+        self.vision = ChartVisionEngine()
+
+    def analyze_ticker(self, db: Session, asset: Asset, timeframe: str = "6M", period: str = "1y", include_visual: bool = True, persist: bool = True) -> dict:
+        prices = load_prices(db, asset.id)
+        frame = normalize_frame(prices, timeframe)
+        deterministic = self.technical.analyze(frame, timeframe=timeframe)
+        chart_image = generate_chart_svg_data_uri(asset.ticker, frame, deterministic)
+        visual = self.vision.analyze_image(data_uri_payload_bytes(chart_image), ticker=asset.ticker, timeframe=timeframe, ohlcv_hint=compact_ohlcv_hint(deterministic)) if include_visual else disabled_visual(asset.ticker, timeframe)
+        memory = safe_memory(db, asset)
+        sentiment = sentiment_context(db, asset)
+        similar = pattern_similarity(db, asset, deterministic, timeframe)
+        hybrid = build_hybrid_report(asset, timeframe, visual, deterministic, memory, sentiment, similar)
+        if persist:
+            persist_chart_analysis(db, asset, timeframe, period, chart_image, visual, deterministic, hybrid)
+        return {
+            "ticker": asset.ticker,
+            "timeframe": timeframe,
+            "period": period,
+            "chart_image": chart_image,
+            "price_series": price_series(frame),
+            "visual_analysis": visual,
+            "deterministic_analysis": deterministic,
+            "hybrid_analysis": hybrid,
+            "confidence": hybrid["confidence_score"],
+            "warnings": hybrid["warnings"],
+            "disclaimer": DISCLAIMER,
+        }
+
+    def analyze_uploaded_image(
+        self,
+        db: Session,
+        image_bytes: bytes,
+        ticker: str | None = None,
+        timeframe: str = "unknown",
+        ohlcv_rows: list[dict] | None = None,
+        persist: bool = True,
+    ) -> dict:
+        asset = db.scalar(select(Asset).where(Asset.ticker == ticker.upper())) if ticker else None
+        frame = pd.DataFrame(ohlcv_rows or [])
+        deterministic = self.technical.analyze(frame, timeframe=timeframe) if not frame.empty else {"status": "no_ohlcv_payload", "technical_summary": "No OHLCV payload was supplied; deterministic analysis unavailable."}
+        visual = self.vision.analyze_image(image_bytes, ticker=ticker, timeframe=timeframe, ohlcv_hint=compact_ohlcv_hint(deterministic))
+        memory = safe_memory(db, asset) if asset else {}
+        sentiment = sentiment_context(db, asset) if asset else {}
+        similar = pattern_similarity(db, asset, deterministic, timeframe) if asset else empty_similarity()
+        hybrid = build_hybrid_report(asset, timeframe, visual, deterministic, memory, sentiment, similar)
+        chart_image = f"data:image/unknown;base64,{base64.b64encode(image_bytes).decode('ascii')}"
+        if persist and asset:
+            persist_chart_analysis(db, asset, timeframe, timeframe, chart_image, visual, deterministic, hybrid, image_hash=hashlib.sha256(image_bytes).hexdigest())
+        return {
+            "ticker": ticker,
+            "timeframe": timeframe,
+            "visual_analysis": visual,
+            "deterministic_analysis": deterministic,
+            "hybrid_analysis": hybrid,
+            "confidence": hybrid["confidence_score"],
+            "warnings": hybrid["warnings"],
+            "disclaimer": DISCLAIMER,
+        }
+
+    def latest_report(self, db: Session, asset: Asset, timeframe: str = "6M") -> dict:
+        row = db.scalar(
+            select(ChartAnalysis)
+            .where(ChartAnalysis.ticker == asset.ticker, ChartAnalysis.timeframe == timeframe)
+            .order_by(desc(ChartAnalysis.created_at))
+            .limit(1)
+        )
+        if row:
+            return serialize_chart_analysis(row)
+        return self.analyze_ticker(db, asset, timeframe=timeframe, period=timeframe, include_visual=False, persist=True)
+
+    def levels(self, db: Session, asset: Asset, timeframe: str = "6M") -> dict:
+        row = db.scalar(select(TechnicalLevel).where(TechnicalLevel.ticker == asset.ticker, TechnicalLevel.timeframe == timeframe))
+        if not row:
+            self.analyze_ticker(db, asset, timeframe=timeframe, period=timeframe, include_visual=False, persist=True)
+            row = db.scalar(select(TechnicalLevel).where(TechnicalLevel.ticker == asset.ticker, TechnicalLevel.timeframe == timeframe))
+        return serialize_level(row) if row else {"ticker": asset.ticker, "timeframe": timeframe, "status": "unavailable"}
+
+    def signals(self, db: Session, asset: Asset, timeframe: str = "6M", limit: int = 30) -> list[dict]:
+        rows = db.scalars(
+            select(TechnicalSignal)
+            .where(TechnicalSignal.ticker == asset.ticker, TechnicalSignal.timeframe == timeframe)
+            .order_by(desc(TechnicalSignal.created_at))
+            .limit(limit)
+        ).all()
+        if not rows:
+            self.analyze_ticker(db, asset, timeframe=timeframe, period=timeframe, include_visual=False, persist=True)
+            rows = db.scalars(
+                select(TechnicalSignal)
+                .where(TechnicalSignal.ticker == asset.ticker, TechnicalSignal.timeframe == timeframe)
+                .order_by(desc(TechnicalSignal.created_at))
+                .limit(limit)
+            ).all()
+        return [serialize_signal(row) for row in rows]
+
+    def history(self, db: Session, asset: Asset, limit: int = 30) -> list[dict]:
+        rows = db.scalars(select(ChartAnalysis).where(ChartAnalysis.ticker == asset.ticker).order_by(desc(ChartAnalysis.created_at)).limit(limit)).all()
+        return [serialize_chart_analysis(row, compact=True) for row in rows]
+
+
+def build_hybrid_report(asset: Asset | None, timeframe: str, visual: dict, deterministic: dict, memory: dict, sentiment: dict, similar: dict) -> dict:
+    bullish = []
+    bearish = []
+    neutral = []
+    if deterministic.get("status") == "ready":
+        for signal in deterministic.get("signals", []):
+            target = bullish if signal.get("direction") == "bullish" else bearish if signal.get("direction") == "bearish" else neutral
+            target.append(signal.get("evidence", signal.get("signal_type", "technical signal")))
+        if deterministic.get("trend_direction") in {"uptrend", "uptrend_attempt"}:
+            bullish.append(f"Calculated trend is {deterministic.get('trend_direction')}.")
+        if deterministic.get("trend_direction") in {"downtrend", "downtrend_attempt"}:
+            bearish.append(f"Calculated trend is {deterministic.get('trend_direction')}.")
+    bullish += visual.get("bullish_evidence", [])[:4]
+    bearish += visual.get("bearish_evidence", [])[:4]
+    neutral += visual.get("neutral_evidence", [])[:4]
+    if sentiment.get("average_sentiment") is not None:
+        if sentiment["average_sentiment"] > 0.15:
+            bullish.append("Recent linked news sentiment is constructive.")
+        elif sentiment["average_sentiment"] < -0.15:
+            bearish.append("Recent linked news sentiment is negative.")
+        else:
+            neutral.append("Recent linked news sentiment is mixed.")
+    contradictions = contradiction_checks(visual, deterministic, sentiment)
+    confirmations = confirmation_checks(visual, deterministic, sentiment, similar)
+    confidence = hybrid_confidence(visual, deterministic, sentiment, similar, contradictions)
+    levels = deterministic.get("levels", {})
+    return {
+        "trend_summary": deterministic.get("technical_summary") or visual.get("technical_summary") or "Technical evidence is still being collected.",
+        "key_levels": {
+            "support_1": first_level(levels.get("support_levels"), 0),
+            "support_2": first_level(levels.get("support_levels"), 1),
+            "resistance_1": first_level(levels.get("resistance_levels"), 0),
+            "resistance_2": first_level(levels.get("resistance_levels"), 1),
+            "breakout_level": levels.get("breakout_level"),
+            "breakdown_level": levels.get("breakdown_level"),
+            "invalidation_level": levels.get("invalidation_level"),
+        },
+        "technical_signals": deterministic.get("signals", []),
+        "confirmation_signals": confirmations,
+        "contradiction_signals": contradictions,
+        "invalidation_level": levels.get("invalidation_level"),
+        "risk_zone": risk_zone(deterministic),
+        "opportunity_zone": opportunity_zone(deterministic),
+        "confidence_score": confidence,
+        "timeframe_relevance": timeframe_relevance(timeframe, deterministic),
+        "possible_scenarios": scenarios(deterministic, sentiment, similar),
+        "what_to_watch_next": watch_next(deterministic, sentiment, contradictions),
+        "bullish_evidence": dedupe(bullish)[:8],
+        "bearish_evidence": dedupe(bearish)[:8],
+        "neutral_evidence": dedupe(neutral)[:8],
+        "analyst_report": analyst_report(asset, deterministic, sentiment, similar, confidence),
+        "historical_similarity": similar,
+        "memory_context": {
+            "blum_memory_summary": memory.get("blum_memory_summary"),
+            "confidence_evolution": memory.get("confidence_evolution", [])[:5],
+        },
+        "evidence_policy": {
+            "calculated_data": deterministic.get("evidence_policy", {}).get("calculated_data", []),
+            "visual_observations": ["Qwen3-VL/InternVL visual output"] if visual.get("mode") in {"remote", "local"} else [],
+            "inference": ["hybrid confidence", "scenario framing", "breakout probability", "risk/reward interpretation"],
+            "hypothesis": ["historical similarity is probabilistic and not a forecast"],
+        },
+        "warnings": warnings(visual, deterministic),
+        "disclaimer": DISCLAIMER,
+    }
+
+
+def persist_chart_analysis(db: Session, asset: Asset, timeframe: str, period: str, chart_image: str, visual: dict, deterministic: dict, hybrid: dict, image_hash: str | None = None) -> None:
+    image_hash = image_hash or hashlib.sha256(chart_image.encode("utf-8")).hexdigest()
+    analysis = ChartAnalysis(
+        asset_id=asset.id,
+        ticker=asset.ticker,
+        timeframe=timeframe,
+        period=period,
+        image_hash=image_hash,
+        model_used=visual.get("model_used", "deterministic_technical_analysis"),
+        visual_analysis_json=visual,
+        deterministic_analysis_json=deterministic,
+        hybrid_analysis_json=hybrid,
+        chart_image=chart_image,
+        confidence=float(hybrid.get("confidence_score") or 0),
+    )
+    db.add(analysis)
+    persist_levels(db, asset, timeframe, deterministic)
+    persist_signals(db, asset, timeframe, deterministic)
+    persist_pattern_memory(db, asset, timeframe, deterministic, hybrid)
+    db.commit()
+
+
+def persist_levels(db: Session, asset: Asset, timeframe: str, deterministic: dict) -> None:
+    levels = deterministic.get("levels", {})
+    row = db.scalar(select(TechnicalLevel).where(TechnicalLevel.ticker == asset.ticker, TechnicalLevel.timeframe == timeframe))
+    if row is None:
+        row = TechnicalLevel(asset_id=asset.id, ticker=asset.ticker, timeframe=timeframe)
+        db.add(row)
+    row.asset_id = asset.id
+    row.support_levels_json = levels.get("support_levels", [])
+    row.resistance_levels_json = levels.get("resistance_levels", [])
+    row.breakout_level = levels.get("breakout_level")
+    row.breakdown_level = levels.get("breakdown_level")
+    row.invalidation_level = levels.get("invalidation_level")
+    row.updated_at = datetime.utcnow()
+
+
+def persist_signals(db: Session, asset: Asset, timeframe: str, deterministic: dict) -> None:
+    db.execute(delete(TechnicalSignal).where(TechnicalSignal.ticker == asset.ticker, TechnicalSignal.timeframe == timeframe))
+    invalidation = deterministic.get("levels", {}).get("invalidation_level")
+    for item in deterministic.get("signals", [])[:12]:
+        db.add(
+            TechnicalSignal(
+                asset_id=asset.id,
+                ticker=asset.ticker,
+                timeframe=timeframe,
+                signal_type=item.get("signal_type", "technical_signal"),
+                direction=item.get("direction", "neutral"),
+                confidence=float(item.get("confidence") or 0),
+                evidence_json=item,
+                invalidation_level=invalidation,
+            )
+        )
+
+
+def persist_pattern_memory(db: Session, asset: Asset, timeframe: str, deterministic: dict, hybrid: dict) -> None:
+    pattern = primary_pattern(deterministic)
+    db.add(
+        ChartPatternMemory(
+            asset_id=asset.id,
+            ticker=asset.ticker,
+            timeframe=timeframe,
+            pattern_type=pattern,
+            setup_embedding=pattern_embedding(deterministic, hybrid),
+            outcome_1d=None,
+            outcome_7d=None,
+            outcome_30d=None,
+            max_drawdown=None,
+            success=None,
+        )
+    )
+
+
+def sentiment_context(db: Session, asset: Asset) -> dict:
+    linked_ids = [row[0] for row in db.execute(select(NewsAssetLink.article_id).where(NewsAssetLink.asset_id == asset.id)).all()]
+    if not linked_ids:
+        return {"article_count": 0, "average_sentiment": None, "latest_news": []}
+    rows = db.execute(
+        select(SentimentAnalysis.score, NewsArticle.title, NewsArticle.source, NewsArticle.published_at)
+        .join(NewsArticle, NewsArticle.id == SentimentAnalysis.article_id)
+        .where(SentimentAnalysis.article_id.in_(linked_ids))
+        .order_by(desc(SentimentAnalysis.created_at))
+        .limit(30)
+    ).all()
+    scores = [float(score) for score, *_ in rows if score is not None]
+    return {
+        "article_count": len(rows),
+        "average_sentiment": round(mean(scores), 4) if scores else None,
+        "latest_news": [{"title": title, "source": source, "published_at": published_at.isoformat() if published_at else None} for _, title, source, published_at in rows[:6]],
+    }
+
+
+def pattern_similarity(db: Session, asset: Asset, deterministic: dict, timeframe: str) -> dict:
+    pattern = primary_pattern(deterministic)
+    rows = db.scalars(
+        select(ChartPatternMemory)
+        .where(ChartPatternMemory.pattern_type == pattern, ChartPatternMemory.ticker != asset.ticker)
+        .order_by(desc(ChartPatternMemory.created_at))
+        .limit(80)
+    ).all()
+    mature = [row for row in rows if row.success is not None]
+    success_rate = sum(1 for row in mature if row.success) / len(mature) if mature else None
+    returns_7d = [row.outcome_7d for row in mature if row.outcome_7d is not None]
+    drawdowns = [row.max_drawdown for row in mature if row.max_drawdown is not None]
+    return {
+        "pattern_type": pattern,
+        "similar_chart_setups": len(rows),
+        "mature_cases": len(mature),
+        "average_forward_return_7d": round(mean(returns_7d), 3) if returns_7d else None,
+        "success_rate": round(success_rate, 4) if success_rate is not None else None,
+        "average_drawdown": round(mean(drawdowns), 3) if drawdowns else None,
+        "reliability_score": reliability_score(len(mature), success_rate),
+        "explanation": "Chart pattern memory is populated from stored Blum chart analyses and matures as future OHLCV outcomes become available.",
+    }
+
+
+def generate_chart_svg_data_uri(ticker: str, frame: pd.DataFrame, deterministic: dict) -> str:
+    if frame.empty:
+        svg = "<svg xmlns='http://www.w3.org/2000/svg' width='960' height='520'><rect width='100%' height='100%' fill='#07090d'/><text x='40' y='80' fill='#ffb000'>No price data</text></svg>"
+        return "data:image/svg+xml;base64," + base64.b64encode(svg.encode("utf-8")).decode("ascii")
+    df = frame.tail(160).reset_index(drop=True)
+    close = df["close"].astype(float)
+    high = df["high"].astype(float)
+    low = df["low"].astype(float)
+    width = 960
+    height = 520
+    pad_x = 54
+    pad_y = 42
+    min_price = float(low.min())
+    max_price = float(high.max())
+    scale = (height - pad_y * 2) / max(max_price - min_price, 1e-9)
+
+    def x(index: int) -> float:
+        return pad_x + index * ((width - pad_x * 2) / max(len(df) - 1, 1))
+
+    def y(price: float) -> float:
+        return height - pad_y - ((price - min_price) * scale)
+
+    line_points = " ".join(f"{x(i):.2f},{y(float(price)):.2f}" for i, price in enumerate(close))
+    level_lines = []
+    levels = deterministic.get("levels", {})
+    for item in (levels.get("support_levels") or [])[:2]:
+        py = y(float(item["level"]))
+        level_lines.append(f"<line x1='{pad_x}' x2='{width-pad_x}' y1='{py:.2f}' y2='{py:.2f}' stroke='#20e070' stroke-width='1' stroke-dasharray='6 6'/>")
+    for item in (levels.get("resistance_levels") or [])[:2]:
+        py = y(float(item["level"]))
+        level_lines.append(f"<line x1='{pad_x}' x2='{width-pad_x}' y1='{py:.2f}' y2='{py:.2f}' stroke='#ff4d5e' stroke-width='1' stroke-dasharray='6 6'/>")
+    svg = f"""
+    <svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}">
+      <rect width="100%" height="100%" fill="#07090d"/>
+      <g stroke="rgba(255,255,255,.08)" stroke-width="1">
+        <line x1="{pad_x}" x2="{width-pad_x}" y1="{pad_y}" y2="{pad_y}"/>
+        <line x1="{pad_x}" x2="{width-pad_x}" y1="{height-pad_y}" y2="{height-pad_y}"/>
+        <line x1="{pad_x}" x2="{pad_x}" y1="{pad_y}" y2="{height-pad_y}"/>
+        <line x1="{width-pad_x}" x2="{width-pad_x}" y1="{pad_y}" y2="{height-pad_y}"/>
+      </g>
+      {''.join(level_lines)}
+      <polyline points="{line_points}" fill="none" stroke="#ffb000" stroke-width="2.4"/>
+      <text x="{pad_x}" y="28" fill="#eef3fa" font-family="Inter, system-ui" font-size="18" font-weight="800">{ticker} Technical Chart</text>
+      <text x="{width-pad_x-220}" y="28" fill="#8f9bad" font-family="Inter, system-ui" font-size="12">Generated by Blum Chart Analyst</text>
+    </svg>
+    """
+    return "data:image/svg+xml;base64," + base64.b64encode(svg.encode("utf-8")).decode("ascii")
+
+
+def data_uri_payload_bytes(data_uri: str) -> bytes:
+    if "," not in data_uri:
+        return data_uri.encode("utf-8")
+    return base64.b64decode(data_uri.split(",", 1)[1])
+
+
+def build_levels_overlay(deterministic: dict) -> dict:
+    levels = deterministic.get("levels", {})
+    return {
+        "support": levels.get("support_levels", [])[:3],
+        "resistance": levels.get("resistance_levels", [])[:3],
+        "breakout_level": levels.get("breakout_level"),
+        "breakdown_level": levels.get("breakdown_level"),
+        "invalidation_level": levels.get("invalidation_level"),
+    }
+
+
+def price_series(frame: pd.DataFrame) -> list[dict]:
+    if frame.empty:
+        return []
+    return [
+        {
+            "date": str(row.date),
+            "open": float(row.open) if row.open is not None else None,
+            "high": float(row.high) if row.high is not None else None,
+            "low": float(row.low) if row.low is not None else None,
+            "close": float(row.close),
+            "volume": float(row.volume) if row.volume is not None else None,
+        }
+        for row in frame.itertuples(index=False)
+    ]
+
+
+def compact_ohlcv_hint(deterministic: dict) -> dict:
+    return {
+        "status": deterministic.get("status"),
+        "trend_direction": deterministic.get("trend_direction"),
+        "levels": deterministic.get("levels", {}),
+        "momentum": deterministic.get("momentum", {}),
+        "volatility": deterministic.get("volatility", {}),
+    }
+
+
+def disabled_visual(ticker: str, timeframe: str) -> dict:
+    return {
+        "mode": "not_requested",
+        "model_used": "not_requested",
+        "asset_detected": ticker,
+        "timeframe_detected": timeframe,
+        "confidence": 0,
+        "technical_summary": "Visual interpretation was not requested for this run.",
+        "bullish_evidence": [],
+        "bearish_evidence": [],
+        "neutral_evidence": [],
+        "uncertainty_notes": ["Deterministic technical analysis only."],
+    }
+
+
+def safe_memory(db: Session, asset: Asset | None) -> dict:
+    if not asset:
+        return {}
+    try:
+        return brain_asset_memory(db, asset)
+    except Exception:
+        return {}
+
+
+def first_level(levels: list | None, index: int) -> float | None:
+    if not levels or len(levels) <= index:
+        return None
+    item = levels[index]
+    return item.get("level") if isinstance(item, dict) else item
+
+
+def confirmation_checks(visual: dict, deterministic: dict, sentiment: dict, similar: dict) -> list[str]:
+    checks = []
+    if visual.get("mode") in {"remote", "local"} and deterministic.get("status") == "ready":
+        checks.append("Visual chart interpretation and OHLCV engine are both available for cross-check.")
+    if deterministic.get("trend_direction") in {"uptrend", "uptrend_attempt"} and sentiment.get("average_sentiment", 0) > 0:
+        checks.append("Technical trend and linked news sentiment are aligned constructively.")
+    if similar.get("success_rate") is not None and similar["success_rate"] >= 0.55:
+        checks.append("Historical chart pattern memory has positive follow-through in matured cases.")
+    return checks or ["No high-conviction cross-domain confirmation is available yet."]
+
+
+def contradiction_checks(visual: dict, deterministic: dict, sentiment: dict) -> list[str]:
+    checks = []
+    if deterministic.get("trend_direction") in {"uptrend", "uptrend_attempt"} and sentiment.get("average_sentiment", 0) < -0.2:
+        checks.append("Price structure is constructive while linked news sentiment is negative.")
+    if deterministic.get("trend_direction") in {"downtrend", "downtrend_attempt"} and sentiment.get("average_sentiment", 0) > 0.2:
+        checks.append("Price structure is deteriorating while linked news sentiment is positive.")
+    visual_summary = str(visual.get("technical_summary", "")).lower()
+    if "bearish" in visual_summary and deterministic.get("trend_direction") in {"uptrend", "uptrend_attempt"}:
+        checks.append("Vision output appears more bearish than deterministic OHLCV trend structure.")
+    return checks
+
+
+def hybrid_confidence(visual: dict, deterministic: dict, sentiment: dict, similar: dict, contradictions: list[str]) -> float:
+    confidence = 35.0
+    if deterministic.get("status") == "ready":
+        confidence += 35
+        confidence += min(15, float(deterministic.get("trend_strength_score") or 0) * 0.15)
+    if visual.get("mode") in {"remote", "local"}:
+        confidence += min(12, float(visual.get("confidence") or 0) * 0.12)
+    if sentiment.get("article_count", 0) > 0:
+        confidence += 5
+    if similar.get("mature_cases", 0) >= 5:
+        confidence += min(8, similar["mature_cases"])
+    confidence -= len(contradictions) * 8
+    return round(max(0, min(100, confidence)), 1)
+
+
+def risk_zone(deterministic: dict) -> dict:
+    rr = deterministic.get("risk_reward_estimate", {})
+    return {
+        "zone": rr.get("nearest_support"),
+        "description": "Risk increases below nearest support or invalidation level.",
+        "downside_to_support_pct": rr.get("downside_to_support_pct"),
+    }
+
+
+def opportunity_zone(deterministic: dict) -> dict:
+    rr = deterministic.get("risk_reward_estimate", {})
+    return {
+        "zone": rr.get("nearest_resistance"),
+        "description": "Opportunity improves if price confirms above resistance with volume expansion.",
+        "upside_to_resistance_pct": rr.get("upside_to_resistance_pct"),
+    }
+
+
+def timeframe_relevance(timeframe: str, deterministic: dict) -> str:
+    if timeframe in {"1D", "5D", "1M"}:
+        return "short_term_execution_context"
+    if timeframe in {"3M", "6M", "YTD"}:
+        return "swing_to_position_context"
+    return "strategic_trend_context"
+
+
+def scenarios(deterministic: dict, sentiment: dict, similar: dict) -> list[dict]:
+    levels = deterministic.get("levels", {})
+    return [
+        {
+            "name": "Bullish confirmation",
+            "condition": f"Confirmed breakout above {levels.get('breakout_level')} with relative volume expansion.",
+            "impact": "Confidence rises if momentum and volume confirm the move.",
+        },
+        {
+            "name": "Bearish invalidation",
+            "condition": f"Failure below {levels.get('invalidation_level')} or breakdown level {levels.get('breakdown_level')}.",
+            "impact": "Setup weakens and risk controls become more important.",
+        },
+        {
+            "name": "Base-building continuation",
+            "condition": "Price remains above support while volatility compresses and news flow stays neutral-to-positive.",
+            "impact": "Setup remains on watch without requiring immediate directional conclusion.",
+        },
+    ]
+
+
+def watch_next(deterministic: dict, sentiment: dict, contradictions: list[str]) -> list[str]:
+    levels = deterministic.get("levels", {})
+    watch = [
+        f"Breakout level near {levels.get('breakout_level')}.",
+        f"Support and invalidation near {levels.get('invalidation_level')}.",
+        "Relative volume expansion on any breakout attempt.",
+        "RSI/MACD confirmation or divergence resolution.",
+    ]
+    if sentiment.get("article_count", 0) > 0:
+        watch.append("Whether news sentiment confirms or contradicts price action.")
+    if contradictions:
+        watch.append("Resolve cross-domain contradictions before increasing confidence.")
+    return watch
+
+
+def analyst_report(asset: Asset | None, deterministic: dict, sentiment: dict, similar: dict, confidence: float) -> str:
+    ticker = asset.ticker if asset else "the instrument"
+    levels = deterministic.get("levels", {})
+    trend = deterministic.get("trend_direction", "unknown")
+    momentum = deterministic.get("momentum", {}).get("state", "unknown")
+    volume = deterministic.get("volume", {}).get("volume_state", "unknown")
+    return (
+        f"Blum detects {trend.replace('_', ' ')} on {ticker}, with {momentum.replace('_', ' ')} momentum and {volume} volume. "
+        f"Resistance is near {levels.get('breakout_level')} and support is near {levels.get('invalidation_level')}. "
+        f"A confirmed breakout above resistance with relative volume expansion would increase technical confidence; failure below support would invalidate the setup. "
+        f"Current hybrid technical confidence is {confidence:.1f}/100. Historical chart memory found {similar.get('similar_chart_setups', 0)} similar stored setups."
+    )
+
+
+def warnings(visual: dict, deterministic: dict) -> list[str]:
+    output = [DISCLAIMER]
+    if visual.get("mode") not in {"remote", "local"}:
+        output.append("Vision model unavailable, deterministic analysis active.")
+    if deterministic.get("status") != "ready":
+        output.append("Deterministic technical analysis is limited because stored OHLCV data is insufficient.")
+    return output
+
+
+def primary_pattern(deterministic: dict) -> str:
+    patterns = deterministic.get("patterns", [])
+    if not patterns:
+        return deterministic.get("trend_direction", "unknown_pattern")
+    return patterns[0].get("pattern", "unknown_pattern")
+
+
+def pattern_embedding(deterministic: dict, hybrid: dict) -> dict:
+    return {
+        "trend": deterministic.get("trend_direction"),
+        "momentum": deterministic.get("momentum", {}).get("state"),
+        "volatility": deterministic.get("volatility", {}).get("regime"),
+        "breakout_probability": deterministic.get("breakout_probability", {}).get("score"),
+        "risk_reward": deterministic.get("risk_reward_estimate", {}).get("reward_to_risk"),
+        "confidence": hybrid.get("confidence_score"),
+    }
+
+
+def reliability_score(mature_cases: int, success_rate: float | None) -> float:
+    if not mature_cases or success_rate is None:
+        return 0.0
+    depth = min(35, mature_cases * 4)
+    return round(depth + success_rate * 65, 1)
+
+
+def empty_similarity() -> dict:
+    return {
+        "pattern_type": "unknown",
+        "similar_chart_setups": 0,
+        "mature_cases": 0,
+        "average_forward_return_7d": None,
+        "success_rate": None,
+        "average_drawdown": None,
+        "reliability_score": 0,
+        "explanation": "No ticker-linked chart pattern memory is available.",
+    }
+
+
+def dedupe(items: list) -> list:
+    seen = set()
+    out = []
+    for item in items:
+        text = str(item)
+        if text and text not in seen:
+            seen.add(text)
+            out.append(text)
+    return out
+
+
+def serialize_chart_analysis(row: ChartAnalysis, compact: bool = False) -> dict:
+    payload = {
+        "id": row.id,
+        "ticker": row.ticker,
+        "timeframe": row.timeframe,
+        "period": row.period,
+        "image_hash": row.image_hash,
+        "model_used": row.model_used,
+        "confidence": row.confidence,
+        "created_at": row.created_at.isoformat(),
+        "hybrid_analysis": row.hybrid_analysis_json,
+        "visual_analysis": row.visual_analysis_json,
+        "deterministic_analysis": row.deterministic_analysis_json,
+        "disclaimer": DISCLAIMER,
+    }
+    if not compact:
+        payload["chart_image"] = row.chart_image
+        payload["price_series"] = []
+    return payload
+
+
+def serialize_level(row: TechnicalLevel) -> dict:
+    return {
+        "ticker": row.ticker,
+        "timeframe": row.timeframe,
+        "support_levels": row.support_levels_json,
+        "resistance_levels": row.resistance_levels_json,
+        "breakout_level": row.breakout_level,
+        "breakdown_level": row.breakdown_level,
+        "invalidation_level": row.invalidation_level,
+        "updated_at": row.updated_at.isoformat(),
+    }
+
+
+def serialize_signal(row: TechnicalSignal) -> dict:
+    return {
+        "ticker": row.ticker,
+        "timeframe": row.timeframe,
+        "signal_type": row.signal_type,
+        "direction": row.direction,
+        "confidence": row.confidence,
+        "evidence": row.evidence_json,
+        "invalidation_level": row.invalidation_level,
+        "created_at": row.created_at.isoformat(),
+    }

backend/app/services/technical_analysis_engine.py

@@ -0,0 +1,560 @@
+from __future__ import annotations
+
+from datetime import datetime
+import math
+from statistics import mean
+
+import numpy as np
+import pandas as pd
+
+from app.signals.indicators import compute_indicators
+
+
+TIMEFRAME_LIMITS = {
+    "1D": 96,
+    "5D": 120,
+    "1M": 42,
+    "3M": 84,
+    "6M": 150,
+    "YTD": 260,
+    "1Y": 260,
+    "5Y": 1260,
+}
+
+
+class TechnicalAnalysisEngine:
+    def analyze(self, price_frame: pd.DataFrame, timeframe: str = "6M", benchmark_frame: pd.DataFrame | None = None) -> dict:
+        df = normalize_frame(price_frame, timeframe)
+        if df.empty or len(df) < 20:
+            return insufficient_analysis(timeframe, len(df))
+        close = df["close"].astype(float)
+        high = df["high"].astype(float)
+        low = df["low"].astype(float)
+        open_ = df["open"].astype(float)
+        volume = df["volume"].fillna(0).astype(float)
+        indicators = compute_indicators(df, benchmark_frame)
+        pivots = pivot_points(df)
+        levels = key_levels(df, pivots)
+        ma = moving_averages(close)
+        momentum = momentum_block(close, indicators)
+        volume_block = volume_analysis(volume, close)
+        volatility = volatility_block(df, indicators)
+        structure = trend_structure(df, pivots, ma, indicators)
+        patterns = pattern_detection(df, pivots, ma, levels, volatility, volume_block)
+        divergences = divergence_detection(df, indicators)
+        gaps = gap_detection(open_, close, high, low)
+        consolidation = consolidation_zones(df, volatility)
+        accumulation = accumulation_distribution(df)
+        risk_reward = risk_reward_estimate(close.iloc[-1], levels, volatility, structure)
+        breakout_probability = breakout_probability_score(structure, momentum, volume_block, volatility, levels, close.iloc[-1])
+        trend_strength = trend_strength_score(structure, momentum, volatility, volume_block, ma)
+        pullback = pullback_quality(close, ma, levels, indicators)
+        signals = technical_signals(structure, momentum, volume_block, volatility, patterns, divergences, breakout_probability, risk_reward)
+        report = analyst_summary(structure, momentum, volume_block, volatility, levels, signals, breakout_probability, risk_reward)
+        return {
+            "status": "ready",
+            "generated_at": datetime.utcnow().isoformat(),
+            "timeframe": timeframe,
+            "observed_rows": int(len(df)),
+            "last_price": round(float(close.iloc[-1]), 4),
+            "trend_direction": structure["trend_direction"],
+            "trend_structure": structure,
+            "moving_averages": ma,
+            "momentum": momentum,
+            "volatility": volatility,
+            "volume": volume_block,
+            "levels": levels,
+            "support_levels": levels["support_levels"],
+            "resistance_levels": levels["resistance_levels"],
+            "breakout_level": levels["breakout_level"],
+            "breakdown_level": levels["breakdown_level"],
+            "invalidation_level": levels["invalidation_level"],
+            "technical_indicators": {
+                "rsi": indicators.get("rsi"),
+                "macd": indicators.get("macd"),
+                "macd_signal": indicators.get("macd_signal"),
+                "macd_hist": indicators.get("macd_hist"),
+                "bollinger_upper": indicators.get("bollinger_upper"),
+                "bollinger_mid": indicators.get("bollinger_mid"),
+                "bollinger_lower": indicators.get("bollinger_lower"),
+                "atr": indicators.get("atr"),
+                "atr_percent": indicators.get("atr_percent"),
+                "adx": indicators.get("adx"),
+            },
+            "patterns": patterns,
+            "gap_detection": gaps,
+            "consolidation_zones": consolidation,
+            "accumulation_distribution": accumulation,
+            "divergences": divergences,
+            "breakout_probability": breakout_probability,
+            "pullback_quality": pullback,
+            "trend_strength_score": trend_strength,
+            "risk_reward_estimate": risk_reward,
+            "signals": signals,
+            "technical_summary": report,
+            "evidence_policy": {
+                "calculated_data": ["OHLCV-derived indicators", "support/resistance", "volatility", "volume", "risk/reward"],
+                "inference": ["trend quality", "breakout probability", "pullback quality", "pattern labels"],
+                "uncertainty": ["technical analysis is probabilistic", "levels are zones, not exact guarantees"],
+            },
+            "warning": "This is technical analysis, not financial advice.",
+        }
+
+
+def normalize_frame(price_frame: pd.DataFrame, timeframe: str) -> pd.DataFrame:
+    if price_frame is None or price_frame.empty:
+        return pd.DataFrame()
+    df = price_frame.sort_values("date").copy()
+    for column in ["open", "high", "low", "close"]:
+        if column not in df:
+            df[column] = df["close"]
+    if "volume" not in df:
+        df["volume"] = 0.0
+    df = df.dropna(subset=["close"])
+    limit = TIMEFRAME_LIMITS.get(timeframe.upper(), 150)
+    if timeframe.upper() == "YTD":
+        dates = pd.to_datetime(df["date"])
+        current_year = dates.iloc[-1].year
+        ytd = df[dates.dt.year == current_year]
+        return ytd.tail(limit) if len(ytd) >= 20 else df.tail(limit)
+    return df.tail(limit)
+
+
+def insufficient_analysis(timeframe: str, rows: int) -> dict:
+    return {
+        "status": "insufficient_price_history",
+        "generated_at": datetime.utcnow().isoformat(),
+        "timeframe": timeframe,
+        "observed_rows": rows,
+        "confidence": 0,
+        "technical_summary": "Not enough stored OHLCV rows to produce a professional technical analysis.",
+        "warning": "This is technical analysis, not financial advice.",
+    }
+
+
+def moving_averages(close: pd.Series) -> dict:
+    def ema(span: int) -> float | None:
+        return round(float(close.ewm(span=span, adjust=False).mean().iloc[-1]), 4) if len(close) >= max(3, span // 3) else None
+
+    def sma(window: int) -> float | None:
+        if len(close) < window:
+            return round(float(close.mean()), 4)
+        return round(float(close.rolling(window).mean().iloc[-1]), 4)
+
+    last = float(close.iloc[-1])
+    values = {
+        "ema9": ema(9),
+        "ema21": ema(21),
+        "ema50": ema(50),
+        "ema200": ema(200),
+        "sma20": sma(20),
+        "sma50": sma(50),
+        "sma200": sma(200),
+    }
+    values["price_vs_ema21_pct"] = pct(values["ema21"], last) if values["ema21"] else None
+    values["price_vs_sma50_pct"] = pct(values["sma50"], last) if values["sma50"] else None
+    values["alignment"] = ma_alignment(last, values)
+    return values
+
+
+def ma_alignment(last: float, ma: dict) -> str:
+    ema9 = ma.get("ema9") or last
+    ema21 = ma.get("ema21") or last
+    ema50 = ma.get("ema50") or last
+    sma200 = ma.get("sma200") or last
+    if last > ema9 > ema21 > ema50 > sma200:
+        return "bullish_stack"
+    if last < ema9 < ema21 < ema50 < sma200:
+        return "bearish_stack"
+    if last > ema21 and ema21 > ema50:
+        return "constructive"
+    if last < ema21 and ema21 < ema50:
+        return "deteriorating"
+    return "mixed"
+
+
+def pivot_points(df: pd.DataFrame, window: int = 3) -> dict:
+    highs = []
+    lows = []
+    high = df["high"].astype(float).reset_index(drop=True)
+    low = df["low"].astype(float).reset_index(drop=True)
+    dates = df["date"].reset_index(drop=True)
+    for index in range(window, len(df) - window):
+        h = high.iloc[index]
+        l = low.iloc[index]
+        if h >= high.iloc[index - window : index + window + 1].max():
+            highs.append({"index": index, "date": str(dates.iloc[index]), "price": round(float(h), 4)})
+        if l <= low.iloc[index - window : index + window + 1].min():
+            lows.append({"index": index, "date": str(dates.iloc[index]), "price": round(float(l), 4)})
+    return {"highs": highs[-10:], "lows": lows[-10:]}
+
+
+def key_levels(df: pd.DataFrame, pivots: dict) -> dict:
+    close = df["close"].astype(float)
+    high = df["high"].astype(float)
+    low = df["low"].astype(float)
+    last = float(close.iloc[-1])
+    pivot_supports = [item["price"] for item in pivots["lows"] if item["price"] <= last * 1.03]
+    pivot_resistances = [item["price"] for item in pivots["highs"] if item["price"] >= last * 0.97]
+    supports = sorted(set(round(float(value), 4) for value in pivot_supports + [low.tail(20).min(), close.tail(60).quantile(0.18)] if value < last), reverse=True)[:4]
+    resistances = sorted(set(round(float(value), 4) for value in pivot_resistances + [high.tail(20).max(), close.tail(60).quantile(0.82)] if value > last))[:4]
+    if not supports:
+        supports = [round(float(low.tail(30).min()), 4)]
+    if not resistances:
+        resistances = [round(float(high.tail(30).max()), 4)]
+    return {
+        "support_levels": [{"level": value, "distance_pct": round(pct(last, value), 2), "source": "pivot_or_distribution"} for value in supports],
+        "resistance_levels": [{"level": value, "distance_pct": round(pct(last, value), 2), "source": "pivot_or_distribution"} for value in resistances],
+        "breakout_level": resistances[0] if resistances else None,
+        "breakdown_level": supports[0] if supports else None,
+        "invalidation_level": supports[0] if supports else None,
+        "nearest_support": supports[0] if supports else None,
+        "nearest_resistance": resistances[0] if resistances else None,
+    }
+
+
+def trend_structure(df: pd.DataFrame, pivots: dict, ma: dict, indicators: dict) -> dict:
+    highs = pivots["highs"]
+    lows = pivots["lows"]
+    higher_highs = count_progression(highs, "up")
+    lower_highs = count_progression(highs, "down")
+    higher_lows = count_progression(lows, "up")
+    lower_lows = count_progression(lows, "down")
+    close = df["close"].astype(float)
+    slope_20 = series_slope(close.tail(min(40, len(close))))
+    alignment = ma.get("alignment", "mixed")
+    if higher_highs >= 2 and higher_lows >= 2 and alignment in {"bullish_stack", "constructive"}:
+        direction = "uptrend"
+    elif lower_highs >= 2 and lower_lows >= 2 and alignment in {"bearish_stack", "deteriorating"}:
+        direction = "downtrend"
+    elif abs(slope_20) < 0.08:
+        direction = "range_or_consolidation"
+    elif slope_20 > 0:
+        direction = "uptrend_attempt"
+    else:
+        direction = "downtrend_attempt"
+    return {
+        "trend_direction": direction,
+        "higher_highs": higher_highs,
+        "higher_lows": higher_lows,
+        "lower_highs": lower_highs,
+        "lower_lows": lower_lows,
+        "slope_20": round(slope_20, 4),
+        "ma_alignment": alignment,
+        "adx": indicators.get("adx"),
+        "structure_comment": structure_comment(direction, higher_highs, higher_lows, lower_highs, lower_lows),
+    }
+
+
+def momentum_block(close: pd.Series, indicators: dict) -> dict:
+    rsi = float(indicators.get("rsi") or 50)
+    macd_hist = float(indicators.get("macd_hist") or 0)
+    perf_5d = float(indicators.get("perf_5d") or 0)
+    perf_1m = float(indicators.get("perf_1m") or 0)
+    state = "neutral"
+    if rsi >= 58 and macd_hist > 0 and perf_5d > 0:
+        state = "improving"
+    if rsi >= 68:
+        state = "extended_positive"
+    if rsi <= 42 and macd_hist < 0:
+        state = "weakening"
+    if rsi <= 32:
+        state = "oversold"
+    return {
+        "state": state,
+        "rsi": round(rsi, 2),
+        "macd_hist": round(macd_hist, 4),
+        "perf_5d": round(perf_5d, 3),
+        "perf_1m": round(perf_1m, 3),
+        "rate_of_change_20": round(return_pct(close, min(20, len(close) - 1)), 3),
+    }
+
+
+def volume_analysis(volume: pd.Series, close: pd.Series) -> dict:
+    recent = volume.tail(10)
+    baseline = volume.tail(60).iloc[:-10] if len(volume) > 20 else volume
+    baseline_mean = float(baseline.mean()) if len(baseline) else 0.0
+    rel = float(recent.mean() / baseline_mean) if baseline_mean else 0.0
+    up_volume = volume[close.diff() > 0].tail(30).sum()
+    down_volume = volume[close.diff() < 0].tail(30).sum()
+    pressure = "balanced"
+    if up_volume > down_volume * 1.2:
+        pressure = "accumulation_bias"
+    if down_volume > up_volume * 1.2:
+        pressure = "distribution_bias"
+    return {
+        "relative_volume": round(rel, 3),
+        "volume_state": "expanding" if rel >= 1.25 else "contracting" if rel <= 0.75 else "normal",
+        "up_down_volume_pressure": pressure,
+        "latest_volume": round(float(volume.iloc[-1]), 2) if len(volume) else 0,
+        "average_volume_50": round(float(volume.tail(50).mean()), 2) if len(volume) else 0,
+    }
+
+
+def volatility_block(df: pd.DataFrame, indicators: dict) -> dict:
+    close = df["close"].astype(float)
+    returns = close.pct_change().dropna()
+    realized = float(returns.tail(30).std() * math.sqrt(252) * 100) if len(returns) > 5 else 0.0
+    atr_pct = float(indicators.get("atr_percent") or 0)
+    bb_upper = float(indicators.get("bollinger_upper") or 0)
+    bb_lower = float(indicators.get("bollinger_lower") or 0)
+    last = float(close.iloc[-1])
+    bb_width = ((bb_upper - bb_lower) / last * 100) if last and bb_upper and bb_lower else 0.0
+    historical_width = (close.rolling(20).std() / close.rolling(20).mean() * 100).dropna()
+    compression = bool(len(historical_width) and bb_width <= historical_width.tail(120).quantile(0.25))
+    regime = "normal"
+    if realized > 45 or atr_pct > 5:
+        regime = "high"
+    elif realized < 18 and atr_pct < 2.5:
+        regime = "low"
+    return {
+        "regime": regime,
+        "realized_volatility_30d": round(realized, 3),
+        "atr_percent": round(atr_pct, 3),
+        "bollinger_width_pct": round(bb_width, 3),
+        "volatility_compression": compression,
+    }
+
+
+def pattern_detection(df: pd.DataFrame, pivots: dict, ma: dict, levels: dict, volatility: dict, volume: dict) -> list[dict]:
+    close = df["close"].astype(float)
+    last = float(close.iloc[-1])
+    patterns = []
+    if volatility["volatility_compression"]:
+        patterns.append({"pattern": "volatility_compression", "direction": "neutral", "confidence": 66, "evidence": "Bollinger width is in the lower historical quartile."})
+    if levels.get("breakout_level") and last > float(levels["breakout_level"]) * 0.995 and volume["relative_volume"] >= 1.1:
+        patterns.append({"pattern": "breakout_test", "direction": "bullish", "confidence": 62, "evidence": "Price is pressing against nearest resistance with volume support."})
+    if levels.get("breakdown_level") and last < float(levels["breakdown_level"]) * 1.005:
+        patterns.append({"pattern": "support_test", "direction": "bearish", "confidence": 58, "evidence": "Price is testing nearest support; failure would weaken structure."})
+    if ma.get("alignment") == "bullish_stack":
+        patterns.append({"pattern": "moving_average_bullish_stack", "direction": "bullish", "confidence": 72, "evidence": "Price and moving averages are stacked in constructive order."})
+    if ma.get("alignment") == "bearish_stack":
+        patterns.append({"pattern": "moving_average_bearish_stack", "direction": "bearish", "confidence": 72, "evidence": "Price and moving averages are stacked in deteriorating order."})
+    if not patterns:
+        patterns.append({"pattern": "mixed_structure", "direction": "neutral", "confidence": 50, "evidence": "No dominant continuation or reversal pattern is statistically clear."})
+    return patterns
+
+
+def divergence_detection(df: pd.DataFrame, indicators: dict) -> dict:
+    close = df["close"].astype(float)
+    rsi_series = rsi_series_calc(close)
+    macd_hist = macd_hist_series(close)
+    price_lookback = close.tail(40)
+    bullish_rsi = bool(price_lookback.iloc[-1] <= price_lookback.quantile(0.35) and rsi_series.tail(40).iloc[-1] > rsi_series.tail(40).quantile(0.45))
+    bearish_rsi = bool(price_lookback.iloc[-1] >= price_lookback.quantile(0.65) and rsi_series.tail(40).iloc[-1] < rsi_series.tail(40).quantile(0.55))
+    bullish_macd = bool(price_lookback.iloc[-1] <= price_lookback.quantile(0.35) and macd_hist.tail(40).iloc[-1] > macd_hist.tail(40).quantile(0.45))
+    bearish_macd = bool(price_lookback.iloc[-1] >= price_lookback.quantile(0.65) and macd_hist.tail(40).iloc[-1] < macd_hist.tail(40).quantile(0.55))
+    return {
+        "price_rsi": "bullish_divergence" if bullish_rsi else "bearish_divergence" if bearish_rsi else "none_detected",
+        "price_macd": "bullish_divergence" if bullish_macd else "bearish_divergence" if bearish_macd else "none_detected",
+        "notes": "Divergence is inferred from recent quantile behavior and should be confirmed with price action.",
+    }
+
+
+def gap_detection(open_: pd.Series, close: pd.Series, high: pd.Series, low: pd.Series) -> dict:
+    if len(open_) < 3:
+        return {"latest_gap_pct": 0, "gap_type": "insufficient_history"}
+    latest_gap = (float(open_.iloc[-1]) / float(close.iloc[-2]) - 1) * 100 if close.iloc[-2] else 0
+    gap_type = "none"
+    if latest_gap > 1.5:
+        gap_type = "gap_up"
+    elif latest_gap < -1.5:
+        gap_type = "gap_down"
+    filled = bool(low.iloc[-1] <= close.iloc[-2] <= high.iloc[-1])
+    return {"latest_gap_pct": round(latest_gap, 3), "gap_type": gap_type, "gap_filled_intraday": filled}
+
+
+def consolidation_zones(df: pd.DataFrame, volatility: dict) -> list[dict]:
+    close = df["close"].astype(float)
+    zones = []
+    for window in [20, 40, 60]:
+        if len(close) < window:
+            continue
+        sample = close.tail(window)
+        width = (sample.max() / sample.min() - 1) * 100 if sample.min() else 0
+        if width <= max(8, volatility.get("atr_percent", 2) * 4):
+            zones.append({"window": window, "low": round(float(sample.min()), 4), "high": round(float(sample.max()), 4), "width_pct": round(width, 3)})
+    return zones[:3]
+
+
+def accumulation_distribution(df: pd.DataFrame) -> dict:
+    close = df["close"].astype(float)
+    volume = df["volume"].fillna(0).astype(float)
+    money_flow = ((close - close.shift()) * volume).tail(30).sum()
+    total_volume = volume.tail(30).sum() or 1
+    score = float(money_flow / total_volume)
+    state = "balanced"
+    if score > 0:
+        state = "accumulation_bias"
+    if score < 0:
+        state = "distribution_bias"
+    return {"state": state, "pressure_score": round(score, 4)}
+
+
+def risk_reward_estimate(last: float, levels: dict, volatility: dict, structure: dict) -> dict:
+    support = levels.get("nearest_support")
+    resistance = levels.get("nearest_resistance")
+    downside = abs(pct(last, support)) if support else None
+    upside = abs(pct(last, resistance)) if resistance else None
+    ratio = round((upside / downside), 2) if upside is not None and downside and downside > 0 else None
+    label = "unbalanced"
+    if ratio is not None and ratio >= 1.8:
+        label = "favorable"
+    elif ratio is not None and ratio >= 1.0:
+        label = "balanced"
+    if volatility["regime"] == "high":
+        label = f"{label}_high_volatility"
+    return {
+        "nearest_support": support,
+        "nearest_resistance": resistance,
+        "downside_to_support_pct": round(downside, 3) if downside is not None else None,
+        "upside_to_resistance_pct": round(upside, 3) if upside is not None else None,
+        "reward_to_risk": ratio,
+        "label": label,
+    }
+
+
+def breakout_probability_score(structure: dict, momentum: dict, volume: dict, volatility: dict, levels: dict, last: float) -> dict:
+    score = 45.0
+    if structure["trend_direction"] in {"uptrend", "uptrend_attempt"}:
+        score += 14
+    if momentum["state"] in {"improving", "extended_positive"}:
+        score += 12
+    if volume["volume_state"] == "expanding":
+        score += 10
+    if volatility["volatility_compression"]:
+        score += 8
+    resistance = levels.get("nearest_resistance")
+    if resistance:
+        distance = abs(pct(last, resistance))
+        if distance <= 3:
+            score += 6
+        elif distance > 12:
+            score -= 8
+    if momentum["state"] == "extended_positive":
+        score -= 5
+    return {"score": round(max(0, min(100, score)), 1), "method": "weighted trend, momentum, volume, volatility and distance-to-resistance model"}
+
+
+def pullback_quality(close: pd.Series, ma: dict, levels: dict, indicators: dict) -> dict:
+    last = float(close.iloc[-1])
+    ema21 = ma.get("ema21")
+    support = levels.get("nearest_support")
+    rsi = float(indicators.get("rsi") or 50)
+    quality = 50.0
+    if ema21 and abs(pct(last, ema21)) <= 3:
+        quality += 18
+    if support and abs(pct(last, support)) <= 4:
+        quality += 14
+    if 38 <= rsi <= 58:
+        quality += 12
+    if rsi > 70:
+        quality -= 18
+    return {"score": round(max(0, min(100, quality)), 1), "comment": "Higher score means pullback is closer to logical support without excessive momentum damage."}
+
+
+def trend_strength_score(structure: dict, momentum: dict, volatility: dict, volume: dict, ma: dict) -> float:
+    score = 45.0
+    if structure["trend_direction"] == "uptrend":
+        score += 22
+    elif structure["trend_direction"] == "downtrend":
+        score -= 18
+    elif structure["trend_direction"] in {"uptrend_attempt", "downtrend_attempt"}:
+        score += 4
+    if ma.get("alignment") == "bullish_stack":
+        score += 16
+    if ma.get("alignment") == "bearish_stack":
+        score -= 16
+    if momentum["state"] == "improving":
+        score += 10
+    if volume["volume_state"] == "expanding":
+        score += 5
+    if volatility["regime"] == "high":
+        score -= 8
+    return round(max(0, min(100, score)), 1)
+
+
+def technical_signals(structure: dict, momentum: dict, volume: dict, volatility: dict, patterns: list[dict], divergences: dict, breakout_probability: dict, risk_reward: dict) -> list[dict]:
+    signals = []
+    if breakout_probability["score"] >= 70:
+        signals.append({"signal_type": "breakout_watch", "direction": "bullish", "confidence": breakout_probability["score"], "evidence": "Trend, momentum, volume or compression support a breakout watch."})
+    if structure["trend_direction"] in {"downtrend", "downtrend_attempt"} and momentum["state"] in {"weakening", "oversold"}:
+        signals.append({"signal_type": "downtrend_pressure", "direction": "bearish", "confidence": 68, "evidence": "Structure and momentum remain weak."})
+    if volatility["volatility_compression"]:
+        signals.append({"signal_type": "volatility_compression", "direction": "neutral", "confidence": 64, "evidence": "Compressed volatility can precede directional expansion."})
+    if divergences["price_rsi"] != "none_detected" or divergences["price_macd"] != "none_detected":
+        direction = "bullish" if "bullish" in (divergences["price_rsi"] + divergences["price_macd"]) else "bearish"
+        signals.append({"signal_type": "momentum_divergence", "direction": direction, "confidence": 58, "evidence": f"RSI/MACD divergence state: {divergences['price_rsi']} / {divergences['price_macd']}."})
+    if risk_reward.get("label", "").startswith("favorable"):
+        signals.append({"signal_type": "favorable_risk_reward_zone", "direction": "neutral", "confidence": 60, "evidence": "Nearest support/resistance geometry is favorable, pending confirmation."})
+    if not signals:
+        strongest = max(patterns, key=lambda item: item.get("confidence", 0))
+        signals.append({"signal_type": strongest["pattern"], "direction": strongest["direction"], "confidence": strongest["confidence"], "evidence": strongest["evidence"]})
+    return signals
+
+
+def analyst_summary(structure: dict, momentum: dict, volume: dict, volatility: dict, levels: dict, signals: list[dict], breakout_probability: dict, risk_reward: dict) -> str:
+    support = levels.get("nearest_support")
+    resistance = levels.get("nearest_resistance")
+    return (
+        f"Blum detects a {structure['trend_direction'].replace('_', ' ')} with {momentum['state'].replace('_', ' ')} momentum. "
+        f"Nearest support is near {support if support is not None else 'n/a'} and resistance is near {resistance if resistance is not None else 'n/a'}. "
+        f"Volume is {volume['volume_state']} with {volume['up_down_volume_pressure'].replace('_', ' ')}. "
+        f"Volatility regime is {volatility['regime']} and breakout probability is {breakout_probability['score']:.1f}/100. "
+        f"Risk/reward is {risk_reward.get('label', 'not rated').replace('_', ' ')}. "
+        f"Primary signal: {signals[0]['signal_type'].replace('_', ' ')}."
+    )
+
+
+def structure_comment(direction: str, higher_highs: int, higher_lows: int, lower_highs: int, lower_lows: int) -> str:
+    return (
+        f"Structure classified as {direction}. Recent pivots show {higher_highs} higher highs, "
+        f"{higher_lows} higher lows, {lower_highs} lower highs and {lower_lows} lower lows."
+    )
+
+
+def count_progression(items: list[dict], direction: str) -> int:
+    count = 0
+    for previous, current in zip(items[-5:], items[-4:]):
+        if direction == "up" and current["price"] > previous["price"]:
+            count += 1
+        if direction == "down" and current["price"] < previous["price"]:
+            count += 1
+    return count
+
+
+def rsi_series_calc(close: pd.Series, window: int = 14) -> pd.Series:
+    delta = close.diff()
+    gain = delta.clip(lower=0).rolling(window).mean()
+    loss = -delta.clip(upper=0).rolling(window).mean()
+    rs = gain / loss.replace(0, np.nan)
+    return (100 - (100 / (1 + rs))).fillna(50)
+
+
+def macd_hist_series(close: pd.Series) -> pd.Series:
+    fast = close.ewm(span=12, adjust=False).mean()
+    slow = close.ewm(span=26, adjust=False).mean()
+    line = fast - slow
+    signal = line.ewm(span=9, adjust=False).mean()
+    return (line - signal).fillna(0)
+
+
+def series_slope(series: pd.Series) -> float:
+    if len(series) < 3:
+        return 0.0
+    y = series.astype(float).values
+    x = np.arange(len(y))
+    return float(np.polyfit(x, y, 1)[0] / max(abs(y[-1]), 1e-9) * 100)
+
+
+def return_pct(close: pd.Series, periods: int) -> float:
+    if len(close) <= periods or periods <= 0:
+        return 0.0
+    base = float(close.iloc[-periods - 1])
+    return (float(close.iloc[-1]) / base - 1) * 100 if base else 0.0
+
+
+def pct(start: float | None, end: float | None) -> float:
+    if start is None or end is None or not start:
+        return 0.0
+    return (float(end) / float(start) - 1) * 100

frontend/app/assets/[ticker]/view.tsx

@@ -6,6 +6,7 @@ import { AccuracyProfile, PricePoint, RelatedNews, Signal } from "@/lib/types";
 import { LoadingState } from "@/components/LoadingState";
 import { BlumMemoryPanel } from "@/components/BlumMemoryPanel";
 import { BreakdownBars } from "@/components/BreakdownBars";
+import { ChartAnalystPanel } from "@/components/ChartAnalystPanel";
 import { formatPercent, formatPrice, formatVolume, MarketSnapshotStrip } from "@/components/MarketSnapshotStrip";
 import { PlotPanel } from "@/components/PlotPanel";
 import { StatusBadge } from "@/components/StatusBadge";
@@ -107,6 +108,8 @@ export function AssetDetailClient({ ticker }: { ticker: string }) {
 
       <BlumMemoryPanel memory={brainMemory} />
 
+      <ChartAnalystPanel ticker={data.asset.ticker} prices={prices} />
+
       <section className="grid-2" style={{ marginTop: 12 }}>
         <PlotPanel
           title="Historical Price"

frontend/app/chart-analyst/page.tsx

@@ -0,0 +1,65 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import { api } from "@/lib/api";
+import { Asset, PricePoint } from "@/lib/types";
+import { ChartAnalystPanel } from "@/components/ChartAnalystPanel";
+import { LoadingState } from "@/components/LoadingState";
+
+export default function ChartAnalystPage() {
+  const [assets, setAssets] = useState<Asset[] | null>(null);
+  const [ticker, setTicker] = useState("NVDA");
+  const [prices, setPrices] = useState<PricePoint[]>([]);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    api.assets()
+      .then((rows) => {
+        setAssets(rows);
+        if (!rows.some((asset) => asset.ticker === ticker) && rows[0]) setTicker(rows[0].ticker);
+      })
+      .catch((err) => setError((err as Error).message));
+  }, []);
+
+  useEffect(() => {
+    if (!ticker) return;
+    api.asset(ticker)
+      .then((payload) => setPrices(payload.prices ?? []))
+      .catch(() => setPrices([]));
+  }, [ticker]);
+
+  const selected = useMemo(() => assets?.find((asset) => asset.ticker === ticker), [assets, ticker]);
+
+  if (error) return <div className="empty-state">API error: {error}</div>;
+  if (!assets) return <LoadingState label="Loading chart analyst" />;
+
+  return (
+    <>
+      <div className="page-header">
+        <div>
+          <div className="kicker">Chart Analyst</div>
+          <h1>Institutional technical chart intelligence.</h1>
+          <p>Hybrid analysis from deterministic OHLCV indicators, optional Qwen3-VL chart vision, sentiment context and Blum memory.</p>
+        </div>
+        <select className="input" value={ticker} onChange={(event) => setTicker(event.target.value)}>
+          {assets.map((asset) => <option key={asset.ticker} value={asset.ticker}>{asset.ticker} | {asset.name}</option>)}
+        </select>
+      </div>
+      {selected && (
+        <section className="instrument-card" style={{ marginBottom: 12 }}>
+          <div>
+            <span>Instrument</span>
+            <strong>{selected.ticker} | {selected.sector}</strong>
+            <p>{selected.name} | {selected.asset_type} | {selected.exchange} | {selected.country}</p>
+          </div>
+          <div className="market-strip compact">
+            <div><span>Price</span><strong>{selected.market_snapshot?.price ?? "n/a"}</strong></div>
+            <div><span>1D</span><strong>{selected.market_snapshot?.perf_1d ?? "n/a"}%</strong></div>
+            <div><span>Provider</span><strong>{selected.market_snapshot?.provider ?? "pending"}</strong></div>
+          </div>
+        </section>
+      )}
+      <ChartAnalystPanel ticker={ticker} prices={prices} />
+    </>
+  );
+}

frontend/app/globals.css

@@ -956,6 +956,71 @@ p { color: var(--muted); line-height: 1.55; }
   padding: 10px;
   font-size: 12px;
 }
+.chart-analyst-shell {
+  margin-top: 12px;
+}
+.compact-header {
+  margin-bottom: 12px;
+}
+.chart-snapshot-panel .brain-status-grid {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+.key-level-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 8px;
+}
+.key-level-grid div {
+  min-height: 66px;
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  padding: 9px;
+  background: #070a0f;
+}
+.key-level-grid span {
+  display: block;
+  color: var(--muted);
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: .08em;
+  font-weight: 900;
+}
+.key-level-grid strong {
+  display: block;
+  margin-top: 7px;
+  color: var(--amber);
+  font-size: 20px;
+}
+.evidence-columns {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 10px;
+}
+.evidence-columns h3 {
+  margin-bottom: 8px;
+  font-size: 13px;
+}
+.scenario-list {
+  display: grid;
+  gap: 8px;
+}
+.scenario-list div {
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  padding: 10px;
+  background: #070a0f;
+}
+.scenario-list strong {
+  display: block;
+  margin-bottom: 5px;
+  color: var(--text);
+}
+.scenario-list span {
+  display: block;
+  color: var(--muted);
+  font-size: 12px;
+  line-height: 1.4;
+}
 
 .control-row { display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 14px; }
 .button { border: 1px solid var(--line); background: #101722; color: var(--text); border-radius: 6px; padding: 9px 12px; font-weight: 900; cursor: pointer; }
@@ -993,7 +1058,7 @@ p { color: var(--muted); line-height: 1.55; }
   .system-card { position: static; margin-top: 14px; }
   .page-header { align-items: flex-start; flex-direction: column; }
   .header-actions { justify-content: flex-start; }
-  .hero, .grid-2, .grid-3, .grid-4, .live-grid, .realtime-strip, .deployment-banner, .diagnostic-grid, .instrument-card, .market-strip, .market-strip.compact, .brain-hero, .scenario-grid, .evidence-grid, .method-grid, .event-graph, .financial-brain-grid, .quality-lists, .macro-list, .executive-hero, .executive-command, .executive-grid, .narrative-grid, .sentiment-columns, .opportunity-card, .score-stack, .allocation-list div, .brain-status-grid, .brain-two-col { grid-template-columns: 1fr; }
+  .hero, .grid-2, .grid-3, .grid-4, .live-grid, .realtime-strip, .deployment-banner, .diagnostic-grid, .instrument-card, .market-strip, .market-strip.compact, .brain-hero, .scenario-grid, .evidence-grid, .method-grid, .event-graph, .financial-brain-grid, .quality-lists, .macro-list, .executive-hero, .executive-command, .executive-grid, .narrative-grid, .sentiment-columns, .opportunity-card, .score-stack, .allocation-list div, .brain-status-grid, .brain-two-col, .chart-snapshot-panel .brain-status-grid, .key-level-grid, .evidence-columns { grid-template-columns: 1fr; }
   .tape-row { grid-template-columns: 1fr; }
   .tape-meta { justify-content: flex-start; max-width: none; }
 }

frontend/app/methodology/page.tsx

@@ -78,6 +78,7 @@ const sections = [
   { 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: "Self-learning financial memory", body: "Blum evaluates signal outcomes after 1D, 3D, 7D, 14D and 30D, then stores accuracy memory, confidence adjustments, source reliability and reversible model weight versions. It updates parameters, not source code, and never executes trades." },
+  { title: "Chart Vision Technical Analyst", body: "Chart analysis combines deterministic OHLCV calculations with optional Qwen3-VL visual interpretation and InternVL3 fallback. If vision is unavailable, Blum clearly switches to deterministic technical analysis and does not invent visual levels." },
   { 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." },

frontend/components/AppShell.tsx

@@ -3,7 +3,7 @@
 import Link from "next/link";
 import { usePathname } from "next/navigation";
 import { useEffect, useState } from "react";
-import { BarChart3, Brain, Cpu, Database, Gauge, Network, Radar, Search, ShieldAlert, type LucideIcon } from "lucide-react";
+import { BarChart3, Brain, Cpu, Database, Gauge, LineChart, Network, Radar, Search, ShieldAlert, type LucideIcon } from "lucide-react";
 import clsx from "clsx";
 import { api } from "@/lib/api";
 import { SystemStatus } from "@/lib/types";
@@ -19,6 +19,7 @@ const nav: NavItem[] = [
   { href: "/", label: "Dashboard", icon: Gauge, aliases: ["/dashboard"] },
   { href: "/market-brain", label: "Market Brain", icon: Cpu },
   { href: "/stock-radar", label: "Radar", icon: Radar, aliases: ["/etf-radar", "/ipo-radar", "/assets"] },
+  { href: "/chart-analyst", label: "Chart Analyst", icon: LineChart },
   { href: "/themes", label: "Themes", icon: Network },
   { href: "/signal-lab", label: "Signal Lab", icon: Search },
   { href: "/methodology", label: "Methodology", icon: Brain }

frontend/components/ChartAnalystPanel.tsx

@@ -0,0 +1,291 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import { api } from "@/lib/api";
+import { ChartReport, PricePoint } from "@/lib/types";
+import { PlotPanel } from "./PlotPanel";
+
+const TIMEFRAMES = ["1D", "5D", "1M", "3M", "6M", "YTD", "1Y", "5Y"];
+
+export function ChartAnalystPanel({ ticker, prices = [] }: { ticker: string; prices?: PricePoint[] }) {
+  const [timeframe, setTimeframe] = useState("6M");
+  const [report, setReport] = useState<ChartReport | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+
+  const loadReport = async (tf = timeframe) => {
+    setError("");
+    try {
+      setReport(await api.chartTechnicalReport(ticker, tf));
+    } catch (err) {
+      setError((err as Error).message);
+    }
+  };
+
+  useEffect(() => {
+    loadReport(timeframe);
+  }, [ticker, timeframe]);
+
+  const analyze = async () => {
+    setBusy(true);
+    setError("");
+    try {
+      setReport(await api.chartAnalyzeTicker(ticker, timeframe, periodFor(timeframe), false));
+    } catch (err) {
+      setError((err as Error).message);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const chartPrices = useMemo(() => trimPrices(report?.price_series?.length ? report.price_series : prices, timeframe), [report, prices, timeframe]);
+  const hybrid = (report?.hybrid_analysis ?? {}) as ChartReport["hybrid_analysis"];
+  const deterministic = (report?.deterministic_analysis ?? {}) as Record<string, any>;
+  const levels = hybrid.key_levels ?? {};
+  const visual = report?.visual_analysis ?? {};
+  const plot = chartPlot(chartPrices, levels);
+
+  return (
+    <section className="chart-analyst-shell">
+      <div className="page-header compact-header">
+        <div>
+          <div className="kicker">Chart Vision Technical Analyst</div>
+          <h2>{ticker} technical chart intelligence.</h2>
+        </div>
+        <div className="header-actions">
+          <select className="input" value={timeframe} onChange={(event) => setTimeframe(event.target.value)}>
+            {TIMEFRAMES.map((item) => <option key={item}>{item}</option>)}
+          </select>
+          <button className="button primary" onClick={analyze} disabled={busy}>{busy ? "Analyzing..." : "Analyze chart"}</button>
+        </div>
+      </div>
+
+      {error && <div className="empty-state" style={{ marginBottom: 12 }}>Chart API warning: {error}</div>}
+
+      <section className="grid-2">
+        <PlotPanel
+          title="Price Structure With Key Levels"
+          data={plot.data}
+          layout={plot.layout}
+          height={430}
+          emptyMessage="Waiting for stored OHLCV data to render the chart."
+        />
+        <TechnicalSnapshot report={report} />
+      </section>
+
+      <section className="grid-2" style={{ marginTop: 12 }}>
+        <KeyLevels levels={levels} />
+        <SignalEvidence hybrid={hybrid} />
+      </section>
+
+      <section className="grid-2" style={{ marginTop: 12 }}>
+        <AnalystReport hybrid={hybrid} visual={visual} deterministic={deterministic} />
+        <HistoricalSimilarity similarity={hybrid.historical_similarity ?? {}} />
+      </section>
+    </section>
+  );
+}
+
+function TechnicalSnapshot({ report }: { report: ChartReport | null }) {
+  const d = report?.deterministic_analysis ?? {};
+  const h = (report?.hybrid_analysis ?? {}) as ChartReport["hybrid_analysis"];
+  const momentum = d.momentum ?? {};
+  const volatility = d.volatility ?? {};
+  const volume = d.volume ?? {};
+  const pattern = d.patterns?.[0]?.pattern ?? "pending";
+  return (
+    <div className="panel chart-snapshot-panel">
+      <div className="panel-head">
+        <span>Technical Snapshot</span>
+        <strong>{Number(h.confidence_score ?? report?.confidence ?? 0).toFixed(1)} confidence</strong>
+      </div>
+      <div className="brain-status-grid">
+        <SnapshotMetric label="Trend" value={String(d.trend_direction ?? "pending").replaceAll("_", " ")} />
+        <SnapshotMetric label="Momentum" value={String(momentum.state ?? "pending").replaceAll("_", " ")} />
+        <SnapshotMetric label="Volatility" value={String(volatility.regime ?? "pending").replaceAll("_", " ")} />
+        <SnapshotMetric label="Volume" value={String(volume.volume_state ?? "pending").replaceAll("_", " ")} />
+        <SnapshotMetric label="Pattern" value={String(pattern).replaceAll("_", " ")} />
+        <SnapshotMetric label="Breakout" value={`${Number(d.breakout_probability?.score ?? 0).toFixed(1)}/100`} />
+      </div>
+      <div className="brain-drift info">
+        <strong>{String(h.timeframe_relevance ?? "timeframe pending").replaceAll("_", " ")}</strong>
+        <span>{h.trend_summary ?? "Run chart analysis to produce a hybrid technical summary."}</span>
+      </div>
+      <p>{(report?.warnings ?? h.warnings)?.join(" ") ?? "Vision model status and deterministic analysis warnings will appear here."}</p>
+    </div>
+  );
+}
+
+function KeyLevels({ levels }: { levels: Record<string, any> }) {
+  return (
+    <div className="panel">
+      <div className="panel-head"><span>Key Levels</span><strong>zones, not guarantees</strong></div>
+      <div className="key-level-grid">
+        <Level label="Support 1" value={levels.support_1} />
+        <Level label="Support 2" value={levels.support_2} />
+        <Level label="Resistance 1" value={levels.resistance_1} />
+        <Level label="Resistance 2" value={levels.resistance_2} />
+        <Level label="Breakout" value={levels.breakout_level} />
+        <Level label="Breakdown" value={levels.breakdown_level} />
+        <Level label="Invalidation" value={levels.invalidation_level} />
+      </div>
+    </div>
+  );
+}
+
+function SignalEvidence({ hybrid }: { hybrid: any }) {
+  return (
+    <div className="panel">
+      <div className="panel-head"><span>Signal Evidence</span><strong>{hybrid.technical_signals?.length ?? 0} signals</strong></div>
+      <div className="evidence-columns">
+        <EvidenceList title="Bullish Evidence" rows={hybrid.bullish_evidence ?? []} />
+        <EvidenceList title="Bearish Evidence" rows={hybrid.bearish_evidence ?? []} />
+        <EvidenceList title="Neutral / Uncertain" rows={hybrid.neutral_evidence ?? []} />
+      </div>
+    </div>
+  );
+}
+
+function AnalystReport({ hybrid, visual, deterministic }: { hybrid: any; visual: Record<string, any>; deterministic: Record<string, any> }) {
+  return (
+    <div className="panel">
+      <div className="panel-head">
+        <span>Analyst Report</span>
+        <strong>{String(visual.mode ?? "deterministic").replaceAll("_", " ")}</strong>
+      </div>
+      <p>{hybrid.analyst_report ?? deterministic.technical_summary ?? "Run chart analysis to produce the analyst report."}</p>
+      <div className="scenario-list">
+        {(hybrid.possible_scenarios ?? []).map((scenario: any) => (
+          <div key={scenario.name}>
+            <strong>{scenario.name}</strong>
+            <span>{scenario.condition}</span>
+            <span>{scenario.impact}</span>
+          </div>
+        ))}
+      </div>
+      <div className="learning-event-list" style={{ marginTop: 10 }}>
+        {(hybrid.what_to_watch_next ?? []).slice(0, 6).map((item: string) => <span key={item}>{item}</span>)}
+      </div>
+    </div>
+  );
+}
+
+function HistoricalSimilarity({ similarity }: { similarity: Record<string, any> }) {
+  return (
+    <div className="panel">
+      <div className="panel-head">
+        <span>Historical Similarity</span>
+        <strong>{similarity.reliability_score ? `${Number(similarity.reliability_score).toFixed(1)} reliability` : "maturing"}</strong>
+      </div>
+      <div className="brain-status-grid">
+        <SnapshotMetric label="Similar Setups" value={similarity.similar_chart_setups ?? 0} />
+        <SnapshotMetric label="Mature Cases" value={similarity.mature_cases ?? 0} />
+        <SnapshotMetric label="7D Avg Return" value={formatPercent(similarity.average_forward_return_7d)} />
+        <SnapshotMetric label="Success Rate" value={ratio(similarity.success_rate)} />
+      </div>
+      <p>{similarity.explanation ?? "Chart pattern memory will mature as future OHLCV outcomes are observed."}</p>
+    </div>
+  );
+}
+
+function SnapshotMetric({ label, value }: { label: string; value: string | number }) {
+  return <div className="brain-metric"><span>{label}</span><strong>{value}</strong></div>;
+}
+
+function Level({ label, value }: { label: string; value: any }) {
+  return <div><span>{label}</span><strong>{formatLevel(value)}</strong></div>;
+}
+
+function EvidenceList({ title, rows }: { title: string; rows: string[] }) {
+  return (
+    <div>
+      <h3>{title}</h3>
+      <div className="learning-event-list">
+        {rows.length ? rows.slice(0, 6).map((item) => <span key={item}>{item}</span>) : <span>No confirmed evidence yet.</span>}
+      </div>
+    </div>
+  );
+}
+
+function chartPlot(prices: PricePoint[], levels: Record<string, any>) {
+  const x = prices.map((point) => point.date);
+  const shapes = levelShapes(levels, x);
+  return {
+    data: [
+      {
+        type: "candlestick",
+        x,
+        open: prices.map((point) => point.open ?? point.close),
+        high: prices.map((point) => point.high ?? point.close),
+        low: prices.map((point) => point.low ?? point.close),
+        close: prices.map((point) => point.close),
+        increasing: { line: { color: "#20e070" } },
+        decreasing: { line: { color: "#ff4d5e" } },
+        name: "OHLC"
+      },
+      {
+        type: "bar",
+        x,
+        y: prices.map((point) => point.volume ?? 0),
+        yaxis: "y2",
+        marker: { color: "rgba(77,216,255,.24)" },
+        name: "Volume"
+      }
+    ],
+    layout: {
+      shapes,
+      xaxis: { rangeslider: { visible: false }, gridcolor: "rgba(255,255,255,.06)" },
+      yaxis: { domain: [0.24, 1], gridcolor: "rgba(255,255,255,.06)" },
+      yaxis2: { domain: [0, 0.17], gridcolor: "rgba(255,255,255,.04)" },
+      showlegend: false
+    }
+  };
+}
+
+function levelShapes(levels: Record<string, any>, x: string[]) {
+  if (!x.length) return [];
+  const x0 = x[0];
+  const x1 = x[x.length - 1];
+  const candidates = [
+    { value: levels.support_1, color: "#20e070" },
+    { value: levels.support_2, color: "#20e070" },
+    { value: levels.resistance_1, color: "#ff4d5e" },
+    { value: levels.resistance_2, color: "#ff4d5e" },
+    { value: levels.invalidation_level, color: "#ffb000" }
+  ];
+  return candidates.filter((item) => item.value).map((item) => ({
+    type: "line",
+    xref: "x",
+    yref: "y",
+    x0,
+    x1,
+    y0: Number(item.value),
+    y1: Number(item.value),
+    line: { color: item.color, width: 1, dash: "dot" }
+  }));
+}
+
+function trimPrices(prices: PricePoint[], timeframe: string) {
+  const limits: Record<string, number> = { "1D": 96, "5D": 120, "1M": 42, "3M": 84, "6M": 150, "YTD": 260, "1Y": 260, "5Y": 1260 };
+  return prices.slice(-(limits[timeframe] ?? 150));
+}
+
+function periodFor(timeframe: string) {
+  const periods: Record<string, string> = { "1D": "5d", "5D": "1mo", "1M": "3mo", "3M": "6mo", "6M": "1y", "YTD": "1y", "1Y": "2y", "5Y": "5y" };
+  return periods[timeframe] ?? "1y";
+}
+
+function formatLevel(value: any) {
+  if (value === null || value === undefined || Number.isNaN(Number(value))) return "n/a";
+  return Number(value).toFixed(2);
+}
+
+function formatPercent(value: any) {
+  if (value === null || value === undefined || Number.isNaN(Number(value))) return "Pending";
+  return `${Number(value).toFixed(2)}%`;
+}
+
+function ratio(value: any) {
+  if (value === null || value === undefined || Number.isNaN(Number(value))) return "Pending";
+  return `${Math.round(Number(value) * 100)}%`;
+}

frontend/lib/api.ts

@@ -1,4 +1,4 @@
-import { AccuracyOverview, AccuracyProfile, Asset, BrainAccuracy, BrainAssetMemory, BrainEvaluation, BrainStatus, CommunitySentimentPayload, DashboardOverview, DataCoverage, ExecutiveDashboardPayload, IPORadar, LiveNewsArticle, MacroOverview, MarketBrain, MarketBrainHistoryRow, MarketNarrativePayload, MarketSentiment, OpportunityRadarPayload, PipelineStatus, PortfolioScenarioPayload, RelatedNews, Signal, SignalValidationReport, StockRadar, SystemStatus, WatchlistPayload } from "./types";
+import { AccuracyOverview, AccuracyProfile, Asset, BrainAccuracy, BrainAssetMemory, BrainEvaluation, BrainStatus, ChartReport, CommunitySentimentPayload, DashboardOverview, DataCoverage, ExecutiveDashboardPayload, IPORadar, LiveNewsArticle, MacroOverview, MarketBrain, MarketBrainHistoryRow, MarketNarrativePayload, MarketSentiment, OpportunityRadarPayload, PipelineStatus, PortfolioScenarioPayload, RelatedNews, Signal, SignalValidationReport, StockRadar, SystemStatus, WatchlistPayload } from "./types";
 
 const API_BASE = process.env.NEXT_PUBLIC_API_BASE ?? "";
 
@@ -43,6 +43,11 @@ export const api = {
   evaluateBrainSignals: (limit = 240) => postJson<any>(`/brain/evaluate-signals?limit=${limit}`, {}),
   recalculateBrainWeights: () => postJson<any>("/brain/recalculate-weights", {}),
   runLearningCycle: (limit = 240) => postJson<any>(`/brain/run-learning-cycle?limit=${limit}`, {}),
+  chartAnalyzeTicker: (ticker: string, timeframe = "6M", period = "1y", includeVisual = false) => getPostChart<ChartReport>(`/chart/analyze-ticker?ticker=${encodeURIComponent(ticker)}&timeframe=${encodeURIComponent(timeframe)}&period=${encodeURIComponent(period)}&include_visual=${includeVisual ? "true" : "false"}`),
+  chartTechnicalReport: (ticker: string, timeframe = "6M") => getJson<ChartReport>(`/chart/technical-report/${encodeURIComponent(ticker)}?timeframe=${encodeURIComponent(timeframe)}`),
+  chartLevels: (ticker: string, timeframe = "6M") => getJson<any>(`/chart/levels/${encodeURIComponent(ticker)}?timeframe=${encodeURIComponent(timeframe)}`),
+  chartSignals: (ticker: string, timeframe = "6M") => getJson<any[]>(`/chart/signals/${encodeURIComponent(ticker)}?timeframe=${encodeURIComponent(timeframe)}`),
+  chartHistory: (ticker: string, limit = 30) => getJson<any[]>(`/chart/history/${encodeURIComponent(ticker)}?limit=${limit}`),
   assets: () => getJson<Asset[]>("/assets"),
   asset: (ticker: string) => getJson<{ asset: Asset; market_snapshot: Asset["market_snapshot"]; prices: any[]; latest_signal: Signal | null; related_news: RelatedNews[] }>(`/assets/${encodeURIComponent(ticker)}`),
   overview: () => getJson<DashboardOverview>("/dashboard/overview"),
@@ -92,3 +97,7 @@ export const api = {
   runPipeline: () => postJson<any>("/pipeline/run", { refresh_prices: false, limit: 36 }),
   backtest: (ticker: string) => postJson<any>(`/backtest/${ticker}`, {})
 };
+
+function getPostChart<T>(path: string): Promise<T> {
+  return postJson<T>(path, {});
+}

frontend/lib/types.ts

@@ -261,6 +261,42 @@ export type BrainAccuracy = {
   disclaimer: string;
 };
 
+export type ChartReport = {
+  id?: number;
+  ticker: string;
+  timeframe: string;
+  period?: string;
+  chart_image?: string | null;
+  price_series?: PricePoint[];
+  visual_analysis: Record<string, any>;
+  deterministic_analysis: Record<string, any>;
+  hybrid_analysis: {
+    trend_summary?: string;
+    key_levels?: Record<string, number | null>;
+    technical_signals?: Array<Record<string, any>>;
+    confirmation_signals?: string[];
+    contradiction_signals?: string[];
+    invalidation_level?: number | null;
+    risk_zone?: Record<string, any>;
+    opportunity_zone?: Record<string, any>;
+    confidence_score?: number;
+    timeframe_relevance?: string;
+    possible_scenarios?: Array<Record<string, any>>;
+    what_to_watch_next?: string[];
+    bullish_evidence?: string[];
+    bearish_evidence?: string[];
+    neutral_evidence?: string[];
+    analyst_report?: string;
+    historical_similarity?: Record<string, any>;
+    warnings?: string[];
+    disclaimer?: string;
+  };
+  confidence: number;
+  warnings?: string[];
+  created_at?: string;
+  disclaimer: string;
+};
+
 export type Signal = {
   ticker: string;
   classification: string;

frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blum-ai-financial-intelligence-frontend",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "private": true,
   "scripts": {
     "dev": "next dev -p 3000",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "blum-ai-financial-intelligence",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "private": true,
   "scripts": {
     "frontend:dev": "npm --prefix frontend run dev",

requirements.txt

@@ -25,5 +25,6 @@ scikit-learn==1.6.0
 statsmodels==0.14.4
 pydantic==2.10.4
 pydantic-settings==2.7.0
+python-multipart==0.0.20
 apscheduler==3.11.0
 redis==5.2.1