Fix live-forward paper runtime deploy

.gitattributes

@@ -39,3 +39,28 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .upload-venv/lib/python3.13/site-packages/pip/_vendor/distlib/w64-arm.exe filter=lfs diff=lfs merge=lfs -text
 .upload-venv/lib/python3.13/site-packages/pip/_vendor/distlib/w64.exe filter=lfs diff=lfs merge=lfs -text
 .upload-venv/lib/python3.13/site-packages/yaml/_yaml.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/0.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/1.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/10.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/11.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/12.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/13.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/2.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/6.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/7.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/8.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/9.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/index.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/client-production/index.pack.old filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/0.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/1.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/10.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/2.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/3.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/4.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/5.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/6.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/7.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/8.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/index.pack filter=lfs diff=lfs merge=lfs -text
+frontend/.next/cache/webpack/server-production/index.pack.old filter=lfs diff=lfs merge=lfs -text

.next/trace

@@ -1,2 +1 @@
 [{"name":"generate-buildid","duration":134,"timestamp":87872497011,"id":4,"parentId":1,"tags":{},"startTime":1782192543160,"traceId":"74c71a2e401cebbb"},{"name":"load-custom-routes","duration":113,"timestamp":87872497220,"id":5,"parentId":1,"tags":{},"startTime":1782192543160,"traceId":"74c71a2e401cebbb"},{"name":"next-build","duration":48980,"timestamp":87872449545,"id":1,"tags":{"buildMode":"default","isTurboBuild":"false","version":"14.2.35","isTurbopack":false},"startTime":1782192543112,"traceId":"74c71a2e401cebbb"}]
-[{"name":"generate-buildid","duration":139,"timestamp":107902785130,"id":4,"parentId":1,"tags":{},"startTime":1782212573555,"traceId":"5254ca5a348315b0"},{"name":"load-custom-routes","duration":121,"timestamp":107902785349,"id":5,"parentId":1,"tags":{},"startTime":1782212573555,"traceId":"5254ca5a348315b0"},{"name":"next-build","duration":41482,"timestamp":107902744802,"id":1,"tags":{"buildMode":"default","isTurboBuild":"false","version":"14.2.35","isTurbopack":false},"startTime":1782212573514,"traceId":"5254ca5a348315b0"}]

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.20.0"
+    app_version: str = "2.1.0"
     environment: str = Field(default="demo", alias="ENVIRONMENT")
     database_url: str = Field(
         default="postgresql+psycopg2://postgres:postgres@127.0.0.1:5432/blum",
@@ -31,6 +31,9 @@ class Settings(BaseSettings):
     max_update_assets: int = Field(default=160, alias="BLUM_MAX_UPDATE_ASSETS")
     enable_live_startup: bool = Field(default=True, alias="BLUM_ENABLE_LIVE_STARTUP")
     enable_autonomous_engine: bool = Field(default=True, alias="BLUM_ENABLE_AUTONOMOUS_ENGINE")
+    startup_run_full_autonomous: bool = Field(default=False, alias="BLUM_STARTUP_RUN_FULL_AUTONOMOUS")
+    blum_autonomous_max_seconds_per_job: int = Field(default=120, alias="BLUM_AUTONOMOUS_MAX_SECONDS_PER_JOB")
+    blum_autonomous_max_items_per_job: int = Field(default=50, alias="BLUM_AUTONOMOUS_MAX_ITEMS_PER_JOB")
     autonomous_cycle_minutes: int = Field(default=20, alias="BLUM_AUTONOMOUS_CYCLE_MINUTES")
     autonomous_repair_limit: int = Field(default=80, alias="BLUM_AUTONOMOUS_REPAIR_LIMIT")
     seed_historical_prices_on_startup: bool = Field(default=True, alias="BLUM_SEED_HISTORICAL_PRICES_ON_STARTUP")
@@ -49,6 +52,13 @@ class Settings(BaseSettings):
     learning_min_history_years: int = Field(default=3, alias="LEARNING_MIN_HISTORY_YEARS")
     learning_asset_universe: str = Field(default="stocks,etfs", alias="LEARNING_ASSET_UNIVERSE")
     learning_evaluation_mode: str = Field(default="walk_forward", alias="LEARNING_EVALUATION_MODE")
+    learning_random_sample_ratio: float = Field(default=0.40, alias="LEARNING_RANDOM_SAMPLE_RATIO")
+    learning_alpha_loss_sample_ratio: float = Field(default=0.30, alias="LEARNING_ALPHA_LOSS_SAMPLE_RATIO")
+    learning_factor_focus_sample_ratio: float = Field(default=0.20, alias="LEARNING_FACTOR_FOCUS_SAMPLE_RATIO")
+    learning_capital_preservation_sample_ratio: float = Field(default=0.10, alias="LEARNING_CAPITAL_PRESERVATION_SAMPLE_RATIO")
+    professional_learning_enabled: bool = Field(default=True, alias="BLUM_PROFESSIONAL_LEARNING_ENABLED")
+    professional_learning_minutes: int = Field(default=30, alias="BLUM_PROFESSIONAL_LEARNING_MINUTES")
+    professional_learning_batch_size: int = Field(default=20, alias="BLUM_PROFESSIONAL_LEARNING_BATCH_SIZE")
     blum_model_cycle_minutes: int = Field(default=5, alias="BLUM_MODEL_CYCLE_MINUTES")
     blum_model_cycle_limit: int = Field(default=160, alias="BLUM_MODEL_CYCLE_LIMIT")
     fundamentals_refresh_minutes: int = Field(default=720, alias="BLUM_FUNDAMENTALS_REFRESH_MINUTES")
@@ -62,6 +72,7 @@ class Settings(BaseSettings):
     refresh_price_period: str = Field(default="6mo", alias="BLUM_REFRESH_PRICE_PERIOD")
     sec_user_agent: str = Field(default="Blum-AI-Financial-Intelligence research demo", alias="BLUM_SEC_USER_AGENT")
     blum_model_repository: str = Field(default="Italianhype/Blum", alias="BLUM_MODEL_REPOSITORY")
+    blum_analyst_repository: str = Field(default="Italianhype/Blum-Analyst", alias="BLUM_ANALYST_REPOSITORY")
     training_export_dir: str = Field(default="/tmp/blum_training_exports", alias="BLUM_TRAINING_EXPORT_DIR")
     enable_hf_dataset_catalog: bool = Field(default=True, alias="BLUM_ENABLE_HF_DATASET_CATALOG")
     hf_dataset_refresh_hours: int = Field(default=24, alias="BLUM_HF_DATASET_REFRESH_HOURS")

backend/app/main.py

@@ -9,7 +9,15 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 
-from app.api.routes import router
+from app.api.routers import (
+    alpha_router,
+    analyst_router,
+    brain_router,
+    legacy_router,
+    paper_trading_router,
+    runtime_router,
+    training_router,
+)
 from app.core.config import get_settings
 from app.core.database import SessionLocal
 from app.services.bootstrap import bootstrap_database
@@ -38,7 +46,13 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-app.include_router(router)
+app.include_router(brain_router)
+app.include_router(training_router)
+app.include_router(paper_trading_router)
+app.include_router(alpha_router)
+app.include_router(runtime_router)
+app.include_router(analyst_router)
+app.include_router(legacy_router)
 
 
 @app.middleware("http")
@@ -67,6 +81,13 @@ async def performance_timing_middleware(request: Request, call_next):
                 duration_ms,
                 {"method": request.method, "path": request.url.path, "referer": request.headers.get("referer", "")[:180]},
             )
+        if request.method.upper() == "GET" and "persist=true" in request.url.query.lower():
+            response.headers["X-BLUM-GET-SIDE-EFFECT-RISK"] = "true"
+            performance_recorder.record_dashboard_widget(
+                "performance.GET_ENDPOINT_SIDE_EFFECT_DETECTED",
+                duration_ms,
+                {"method": request.method, "path": request.url.path, "query": request.url.query[:180]},
+            )
         return response
     finally:
         duration_ms = (time.perf_counter() - started) * 1000
@@ -106,6 +127,13 @@ def is_heavy_recalculation_call(method: str, path: str) -> bool:
         "/business-quality/recalculate",
         "/decision-intelligence/superiority/recalculate",
         "/learning-intelligence/self-improvement/generate",
+        "/api/meta-cognition/recalculate",
+        "/api/meta-cognition/factor-importance/recalculate",
+        "/api/meta-cognition/evaluate",
+        "/api/meta-cognition/capital-preservation/evaluate",
+        "/api/meta-cognition/learning-focus/generate",
+        "/api/meta-cognition/noise/detect",
+        "/snapshots/produce",
     )
     return any(fragment in path for fragment in heavy_fragments)
 

backend/app/services/autonomous_engine.py

@@ -34,6 +34,7 @@ from app.services.macro import update_macro_snapshots
 from app.services.market_data import MarketDataService
 from app.services.market_sniper import MarketSniperEngine
 from app.services.persistence import backup_embedded_postgres_if_configured
+from app.services.research_planner import AutonomousResearchPlanner
 from app.services.trading_game import TradingGameSimulator
 from app.signals.engine import SignalEngine
 
@@ -85,6 +86,7 @@ class AutonomousResearchEngine:
         stage("etf_intelligence", lambda: update_etf_trends(db))
         stage("ipo_radar", lambda: update_ipo_radar(db, limit_per_form=55))
         stage("accuracy_audit", lambda: run_accuracy_audit(db, limit=settings.max_update_assets))
+        stage("research_planner", lambda: AutonomousResearchPlanner().generate(db, persist=True))
         if settings.enable_learning_loop:
             stage("blum_financial_model", lambda: run_model_learning_cycle(db, limit=settings.blum_model_cycle_limit))
             stage("blum_learning_loop", lambda: LearningLoopService().run_batch(db, batch_size=settings.learning_batch_size, trigger="autonomous_engine"))

backend/app/services/blum_financial_model.py

@@ -96,7 +96,7 @@ def model_status(db: Session) -> dict:
     }
 
 
-def run_model_learning_cycle(db: Session, limit: int = 120) -> dict:
+def run_model_learning_cycle(db: Session, limit: int = 120, backup: bool = True) -> dict:
     signals = db.scalars(select(SignalSnapshot).order_by(desc(SignalSnapshot.created_at)).limit(limit)).all()
     skipped = 0
     before_count = count(db, BlumKnowledgeRecord.id)
@@ -127,7 +127,11 @@ def run_model_learning_cycle(db: Session, limit: int = 120) -> dict:
     )
     db.add(event)
     db.commit()
-    backup_result = backup_embedded_postgres_if_configured(reason="blum_model_autonomous_cycle")
+    backup_result = (
+        backup_embedded_postgres_if_configured(reason="blum_model_autonomous_cycle")
+        if backup
+        else {"status": "skipped", "reason": "frequent professional learning cycles do not run full embedded database backups"}
+    )
     return {
         "status": "ok",
         "signals_seen": len(signals),

backend/app/services/bootstrap.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import csv
 from datetime import date
 import gzip
+from gzip import BadGzipFile
 from pathlib import Path
 
 from sqlalchemy import func, select
@@ -67,31 +68,49 @@ def seed_historical_prices(db: Session) -> dict:
             "inserted_rows": 0,
             "message": "Historical price cache is not packaged in this build.",
         }
+    pointer = git_lfs_pointer_summary(HISTORICAL_PRICE_CACHE)
+    if pointer:
+        return invalid_historical_cache_response(
+            "git_lfs_pointer",
+            (
+                "Historical price cache is a Git LFS pointer, not the resolved gzip payload. "
+                "Run `git lfs pull` in development or ensure the Space resolves LFS assets. "
+                "Startup continues without synthetic market data."
+            ),
+            pointer,
+        )
     asset_ids = dict(db.execute(select(Asset.ticker, Asset.id)).all())
     inserted = 0
     skipped = 0
     tickers: set[str] = set()
     rows: list[dict] = []
-    with gzip.open(HISTORICAL_PRICE_CACHE, "rt", newline="", encoding="utf-8") as handle:
-        reader = csv.DictReader(handle)
-        for item in reader:
-            ticker = (item.get("ticker") or "").upper()
-            asset_id = asset_ids.get(ticker)
-            if not asset_id:
-                skipped += 1
-                continue
-            row = price_row_from_cache(asset_id, item)
-            if not row:
-                skipped += 1
-                continue
-            tickers.add(ticker)
-            rows.append(row)
-            if len(rows) >= 5000:
-                inserted += insert_price_rows(db, rows)
-                rows.clear()
-    if rows:
-        inserted += insert_price_rows(db, rows)
-    db.commit()
+    try:
+        with gzip.open(HISTORICAL_PRICE_CACHE, "rt", newline="", encoding="utf-8") as handle:
+            reader = csv.DictReader(handle)
+            for item in reader:
+                ticker = (item.get("ticker") or "").upper()
+                asset_id = asset_ids.get(ticker)
+                if not asset_id:
+                    skipped += 1
+                    continue
+                row = price_row_from_cache(asset_id, item)
+                if not row:
+                    skipped += 1
+                    continue
+                tickers.add(ticker)
+                rows.append(row)
+                if len(rows) >= 5000:
+                    inserted += insert_price_rows(db, rows)
+                    rows.clear()
+        if rows:
+            inserted += insert_price_rows(db, rows)
+        db.commit()
+    except (BadGzipFile, EOFError, OSError, UnicodeDecodeError, csv.Error) as exc:
+        db.rollback()
+        return invalid_historical_cache_response(
+            "invalid",
+            f"Historical price cache could not be loaded ({type(exc).__name__}). Startup continues without synthetic market data.",
+        )
     return {
         "enabled": True,
         "cache_status": "loaded",
@@ -121,6 +140,35 @@ def seed_startup_accuracy(db: Session) -> dict:
     return {"enabled": True, **run_accuracy_audit(db, limit=get_settings().max_update_assets)}
 
 
+def git_lfs_pointer_summary(path: Path) -> dict | None:
+    try:
+        head = path.read_bytes()[:220]
+    except OSError:
+        return None
+    if not head.startswith(b"version https://git-lfs.github.com/spec/v1"):
+        return None
+    text = head.decode("utf-8", errors="replace")
+    summary = {"pointer_detected": True}
+    for line in text.splitlines():
+        if line.startswith("oid "):
+            summary["oid"] = line.split(" ", 1)[1]
+        elif line.startswith("size "):
+            summary["expected_size"] = line.split(" ", 1)[1]
+    return summary
+
+
+def invalid_historical_cache_response(cache_status: str, message: str, diagnostics: dict | None = None) -> dict:
+    return {
+        "enabled": True,
+        "cache_status": cache_status,
+        "cache_file": HISTORICAL_PRICE_CACHE.name,
+        "inserted_rows": 0,
+        "diagnostics": diagnostics or {},
+        "message": message,
+        "data_policy": "No synthetic prices are created when packaged OHLCV cache is unavailable.",
+    }
+
+
 def price_row_from_cache(asset_id: int, item: dict) -> dict | None:
     try:
         close = float(item["close"])

backend/app/services/dashboard.py

@@ -6,6 +6,7 @@ from sqlalchemy.orm import Session
 from app.models import Asset, ETFTrend, NewsArticle, PriceHistory, SentimentAnalysis, SignalSnapshot
 from app.services.accuracy import latest_accuracy_snapshot, market_accuracy_overview, signal_validation_report
 from app.services.data_continuity import data_coverage_report
+from app.services.dashboard_snapshots import DashboardSnapshotService
 from app.services.macro import macro_overview
 from app.services.market_data import market_snapshot_for_asset
 from app.services.performance import performance_recorder
@@ -14,6 +15,19 @@ from app.services.realtime import realtime_status
 
 
 def dashboard_overview(db: Session) -> dict:
+    with performance_recorder.dashboard_widget("dashboard.snapshot_lookup", snapshot_type="dashboard_overview_summary"):
+        snapshot = DashboardSnapshotService().latest(db, "dashboard_overview_summary")
+    if snapshot["payload"]:
+        payload = dict(snapshot["payload"])
+        payload["snapshot_status"] = snapshot["status"]
+        payload["snapshot_created_at"] = snapshot.get("created_at")
+        payload["snapshot_warnings"] = snapshot.get("warnings", [])
+        payload["runtime_policy"] = "snapshot_first_no_live_recalculation"
+        return payload
+    return empty_dashboard_overview(snapshot)
+
+
+def build_dashboard_overview_live(db: Session) -> dict:
     with performance_recorder.dashboard_widget("dashboard.load_signal_candidates"):
         signals = db.scalars(select(SignalSnapshot).order_by(desc(SignalSnapshot.created_at), desc(SignalSnapshot.blum_score)).limit(80)).all()
     with performance_recorder.dashboard_widget("dashboard.rank_latest_signals", signal_count=len(signals)):
@@ -80,6 +94,35 @@ def dashboard_overview(db: Session) -> dict:
     }
 
 
+def empty_dashboard_overview(snapshot: dict) -> dict:
+    return {
+        "snapshot_status": snapshot.get("status", "missing"),
+        "snapshot_created_at": snapshot.get("created_at"),
+        "snapshot_warnings": [snapshot.get("warning") or "dashboard_overview_summary snapshot is not ready"],
+        "runtime_policy": "snapshot_first_no_live_recalculation",
+        "market_pulse": {
+            "asset_count": 0,
+            "article_count": 0,
+            "average_sentiment": 0,
+            "signal_count": 0,
+            "classification_mix": {},
+            "price_row_count": 0,
+        },
+        "data_coverage": {"status": "missing_snapshot"},
+        "accuracy": {"status": "missing_snapshot"},
+        "macro": {"status": "missing_snapshot"},
+        "validation": {"status": "missing_snapshot"},
+        "readiness": {"status": "missing_snapshot"},
+        "realtime": {"status": "unknown"},
+        "todays_strongest_signals": [],
+        "narrative_breakouts": [],
+        "technical_breakouts": [],
+        "sentiment_divergence": [],
+        "watchlist_candidates": [],
+        "etf_rotation_leaders": [],
+    }
+
+
 def signal_payload(signal: SignalSnapshot, db: Session | None = None) -> dict:
     with performance_recorder.dashboard_widget("dashboard.signal_payload", ticker=signal.ticker):
         payload = {

backend/app/services/dashboard_snapshots.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime, timedelta
+from datetime import date, datetime, timedelta
 import time
 
 from sqlalchemy import desc, select
@@ -38,6 +38,7 @@ class DashboardSnapshotService:
             "is_stale": is_stale,
             "payload": row.payload_json or {},
             "source_modules": row.source_modules_json or {},
+            "missing_sections": getattr(row, "missing_sections_json", None) or [],
             "computation_duration_ms": row.computation_duration_ms,
             "warnings": row.warnings_json or [],
         }
@@ -51,6 +52,7 @@ class DashboardSnapshotService:
         source_modules: dict | None = None,
         ttl_seconds: int = 300,
         warnings: list[str] | None = None,
+        missing_sections: list[str] | None = None,
         computation_duration_ms: float | None = None,
     ) -> dict:
         started = time.perf_counter()
@@ -58,11 +60,12 @@ class DashboardSnapshotService:
             snapshot_type=snapshot_type,
             created_at=datetime.utcnow(),
             expires_at=datetime.utcnow() + timedelta(seconds=max(1, ttl_seconds)),
-            payload_json=payload,
-            source_modules_json=source_modules or {},
+            payload_json=json_safe(payload),
+            source_modules_json=json_safe(source_modules or {}),
+            missing_sections_json=json_safe(missing_sections or []),
             is_stale=False,
             computation_duration_ms=computation_duration_ms,
-            warnings_json=warnings or [],
+            warnings_json=json_safe(warnings or []),
         )
         if row.computation_duration_ms is None:
             row.computation_duration_ms = round((time.perf_counter() - started) * 1000, 3)
@@ -82,3 +85,22 @@ def record_snapshot_cache(snapshot_type: str, *, hit: bool, status: str) -> None
         )
     except Exception:
         pass
+
+
+def json_safe(value):
+    if isinstance(value, (datetime, date)):
+        return value.isoformat()
+    if isinstance(value, dict):
+        return {str(key): json_safe(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [json_safe(item) for item in value]
+    if isinstance(value, tuple):
+        return [json_safe(item) for item in value]
+    try:
+        import numpy as np
+
+        if isinstance(value, np.generic):
+            return json_safe(value.item())
+    except Exception:
+        pass
+    return value

backend/app/services/financial_chat.py

@@ -33,6 +33,8 @@ from app.services.fundamentals import fundamentals_for_asset
 from app.services.live import market_sentiment
 from app.services.learning_loop import LearningDashboardService
 from app.services.learning_intelligence import LearningIntelligenceDashboardService
+from app.services.alpha_recovery import AlphaRecoveryDashboardService
+from app.services.meta_cognition import MetaCognitionEngine
 from app.services.capital_allocation import AdaptiveCapitalAllocationEngine
 from app.services.decision_intelligence import DecisionIntelligenceDashboardService
 from app.services.market_data import market_snapshot_for_asset
@@ -487,6 +489,8 @@ def trading_game_context_for_chat(db: Session) -> dict:
             "learning_intelligence": LearningIntelligenceDashboardService().dashboard(db),
             "decision_intelligence": DecisionIntelligenceDashboardService().dashboard(db),
             "capital_allocation": AdaptiveCapitalAllocationEngine().dashboard(db),
+            "alpha_recovery": AlphaRecoveryDashboardService().dashboard(db),
+            "meta_cognition": MetaCognitionEngine().summary(db),
             "pnl_breakdown": PnLBreakdownService().game_breakdown(db),
             "reality_check": TradingGameRealityCheckService().evaluate(db),
             "failures": engine.failures(db, limit=12),
@@ -1477,6 +1481,8 @@ def build_trading_game_response(language: str, context: dict) -> dict:
     learning_intelligence = context.get("learning_intelligence") or {}
     decision_intelligence = context.get("decision_intelligence") or {}
     capital_allocation = context.get("capital_allocation") or {}
+    alpha_recovery = context.get("alpha_recovery") or {}
+    meta_cognition = context.get("meta_cognition") or {}
     if not game:
         message = "BLUM non ha ancora un Trading Game persistito. Serve almeno un ciclo Sniper/Learning Loop per creare simulazioni P/L reali." if language == "it" else "BLUM does not have a persisted Trading Game yet. It needs at least one Sniper/Learning Loop cycle to create real P/L simulations."
         return build_error_response(language, message, [])
@@ -1505,6 +1511,8 @@ def build_trading_game_response(language: str, context: dict) -> dict:
             {"key": "learning_intelligence", "title": "Learning Intelligence", "bullets": learning_intelligence_lines(learning_intelligence, language)},
             {"key": "decision_intelligence", "title": "Decision Intelligence", "bullets": decision_intelligence_lines(decision_intelligence, language)},
             {"key": "capital_allocation", "title": "Capital Allocation Intelligence", "bullets": capital_allocation_lines(capital_allocation, language)},
+            {"key": "alpha_recovery", "title": "Alpha Recovery", "bullets": alpha_recovery_lines(alpha_recovery, language)},
+            {"key": "meta_cognition", "title": "Meta-Cognition", "bullets": meta_cognition_lines(meta_cognition, language)},
             {"key": "trade_ledger", "title": "Trade ledger", "bullets": trade_ledger_lines(ledger_rows, language)},
             {"key": "intelligence_metrics", "title": "Trading intelligence", "bullets": intelligence_metric_lines(intelligence_metrics, rolling_metrics, metrics_by_setup, language)},
             {"key": "live_forward", "title": "Storico vs live paper", "bullets": historical_live_lines(live_forward, historical_vs_live, language)},
@@ -1545,6 +1553,8 @@ def build_trading_game_response(language: str, context: dict) -> dict:
             {"key": "learning_intelligence", "title": "Learning Intelligence", "bullets": learning_intelligence_lines(learning_intelligence, language)},
             {"key": "decision_intelligence", "title": "Decision Intelligence", "bullets": decision_intelligence_lines(decision_intelligence, language)},
             {"key": "capital_allocation", "title": "Capital Allocation Intelligence", "bullets": capital_allocation_lines(capital_allocation, language)},
+            {"key": "alpha_recovery", "title": "Alpha Recovery", "bullets": alpha_recovery_lines(alpha_recovery, language)},
+            {"key": "meta_cognition", "title": "Meta-Cognition", "bullets": meta_cognition_lines(meta_cognition, language)},
             {"key": "trade_ledger", "title": "Trade Ledger", "bullets": trade_ledger_lines(ledger_rows, language)},
             {"key": "intelligence_metrics", "title": "Trading Intelligence", "bullets": intelligence_metric_lines(intelligence_metrics, rolling_metrics, metrics_by_setup, language)},
             {"key": "live_forward", "title": "Historical vs Live Paper", "bullets": historical_live_lines(live_forward, historical_vs_live, language)},
@@ -1574,7 +1584,7 @@ def build_trading_game_response(language: str, context: dict) -> dict:
         "executive_view": summary,
         "risk_reward_view": f"Expectancy {format_number(game.get('expectancy_r'))}R, drawdown {format_signed(game.get('max_drawdown'))}%.",
         "data_quality": {"sample_warning": sample_warning, "trades": game.get("trade_count"), "reproducibility": reproducibility, "cycles": cycle_stats, "live_sample_warning": (historical_vs_live.get("sample_warning") if isinstance(historical_vs_live, dict) else None)},
-        "learning_loop_memory": {"trading_game": game, "lessons": lessons[:6], "latest_trades": trades[:6], "ledger": ledger_rows[:8], "reality_check": reality_check, "cycles": cycle_stats, "intelligence_metrics": intelligence_metrics, "historical_vs_live": historical_vs_live, "learning_intelligence": learning_intelligence, "decision_intelligence": decision_intelligence, "capital_allocation": capital_allocation},
+        "learning_loop_memory": {"trading_game": game, "lessons": lessons[:6], "latest_trades": trades[:6], "ledger": ledger_rows[:8], "reality_check": reality_check, "cycles": cycle_stats, "intelligence_metrics": intelligence_metrics, "historical_vs_live": historical_vs_live, "learning_intelligence": learning_intelligence, "decision_intelligence": decision_intelligence, "capital_allocation": capital_allocation, "alpha_recovery": alpha_recovery, "meta_cognition": meta_cognition},
         "answer_to_user": summary,
     }
 
@@ -1691,6 +1701,100 @@ def capital_allocation_lines(payload: dict, language: str) -> list[str]:
     return dedupe_warnings(lines)
 
 
+def alpha_recovery_lines(payload: dict, language: str) -> list[str]:
+    if not payload or payload.get("status") == "unavailable":
+        return ["Alpha Recovery non disponibile: non invento perche BLUM perde o vince alpha." if language == "it" else "Alpha Recovery is unavailable; I will not invent why BLUM won or lost alpha."]
+    truth = (payload.get("truth_layer") or {}).get("lines") or []
+    attribution = payload.get("latest_attribution") or {}
+    attribution_summary = attribution.get("summary") or {}
+    top_category = attribution_summary.get("top_category")
+    missed = ((payload.get("missed_winners") or {}).get("rows") or [])[:3]
+    actions = ((payload.get("recovery_actions") or {}).get("rows") or [])[:3]
+    methodology_rows = ((payload.get("latest_methodology") or {}).get("rows") or [])[:3]
+    invalid = [row for row in methodology_rows if not row.get("methodology_valid")]
+    if language == "it":
+        lines = list(truth[:3]) or ["Evidenza insufficiente: servono benchmark validati e trade ledger prima di attribuire perdita alpha."]
+        if invalid:
+            lines.append("Alcuni benchmark non sono validi per apprendimento: BLUM blocca conclusioni di recovery su quei confronti.")
+        if top_category:
+            lines.append(f"Causa misurata principale: {str(top_category).replace('_', ' ')}.")
+        if missed:
+            lines.append("Missed winners da replay: " + ", ".join(f"{row.get('ticker')} ({format_signed(row.get('benchmark_relative_return'))}%)" for row in missed))
+        if actions:
+            lines.append(f"Azione recovery proposta: {actions[0].get('recommended_action')} | stato {actions[0].get('status')}.")
+        return dedupe_warnings(lines)
+    lines = list(truth[:3]) or ["Insufficient evidence: validated benchmarks and trade ledger data are required before attributing alpha loss."]
+    if invalid:
+        lines.append("Some benchmarks are not valid for learning; BLUM blocks recovery conclusions on those comparisons.")
+    if top_category:
+        lines.append(f"Main measured cause: {str(top_category).replace('_', ' ')}.")
+    if missed:
+        lines.append("Missed winners for replay: " + ", ".join(f"{row.get('ticker')} ({format_signed(row.get('benchmark_relative_return'))}%)" for row in missed))
+    if actions:
+        lines.append(f"Recovery action proposed: {actions[0].get('recommended_action')} | status {actions[0].get('status')}.")
+    return dedupe_warnings(lines)
+
+
+def meta_cognition_lines(payload: dict, language: str) -> list[str]:
+    if not payload or payload.get("status") == "unavailable":
+        return ["Meta-Cognition non disponibile: non invento quali fattori creano o distruggono alpha." if language == "it" else "Meta-Cognition is unavailable; I will not invent which factors create or destroy alpha."]
+    snapshot_payload = ((payload.get("snapshot") or {}).get("payload") or {}) if isinstance(payload.get("snapshot"), dict) else {}
+    factor_summary = ((payload.get("factor_importance") or {}).get("summary") or {})
+    focus_rows = ((payload.get("learning_focus") or {}).get("rows") or [])
+    noise_rows = ((payload.get("noise") or {}).get("rows") or [])
+    preservation_summary = ((payload.get("capital_preservation") or {}).get("summary") or {})
+    events_summary = ((payload.get("events") or {}).get("summary") or {})
+    conclusion = payload.get("conclusion") or snapshot_payload.get("meta_cognition_conclusion") or {}
+
+    top_alpha = snapshot_payload.get("top_alpha_factor") or first_payload(factor_summary.get("top_alpha_creators"))
+    top_destroyer = snapshot_payload.get("top_alpha_destroyer") or first_payload(factor_summary.get("top_alpha_destroyers"))
+    noisiest = snapshot_payload.get("noisiest_factor") or first_payload(factor_summary.get("noisiest_factors")) or first_payload(noise_rows)
+    focus = snapshot_payload.get("next_learning_focus") or first_payload(focus_rows)
+    preservation = snapshot_payload.get("strongest_capital_preservation_rule") or first_payload(preservation_summary.get("top_preservers"))
+
+    if language == "it":
+        lines = []
+        if top_alpha:
+            lines.append(f"Fattore che sta creando piu alpha misurabile: {top_alpha.get('factor_name', 'n/a')} | contributo {format_number(top_alpha.get('alpha_contribution'))} | campione {top_alpha.get('sample_size', 'n/a')}.")
+        if top_destroyer:
+            lines.append(f"Fattore che sta distruggendo piu alpha: {top_destroyer.get('factor_name', 'n/a')} | perdita {format_number(top_destroyer.get('alpha_loss_contribution'))} | azione {top_destroyer.get('recommended_weight_action', 'n/a')}.")
+        if noisiest:
+            lines.append(f"Fattore/modulo piu rumoroso: {noisiest.get('factor_name') or noisiest.get('module_name', 'n/a')} | noise {format_number(noisiest.get('noise_score'))}/100 | severita {noisiest.get('severity', 'n/a')}.")
+        if preservation:
+            lines.append(f"Regola no-trade piu utile: {preservation.get('ticker', preservation.get('factor_name', 'n/a'))} | capitale preservato {format_money(preservation.get('capital_preserved'))} | quality {format_number(preservation.get('quality_score'))}/100.")
+        if focus:
+            lines.append(f"Prossimo focus Learning Loop: {focus.get('priority_type', 'focus')} su {focus.get('target', 'n/a')} | valore atteso {format_number(focus.get('expected_learning_value'))}/100.")
+        if conclusion.get("summary"):
+            lines.append(str(conclusion.get("summary")))
+        if events_summary.get("events"):
+            lines.append(f"Azioni di learning valutate: {events_summary.get('events')} | miglioramenti {events_summary.get('improvements', 0)} | peggioramenti {events_summary.get('degradations', 0)}.")
+        return dedupe_warnings(lines or ["Evidenza meta-cognitiva insufficiente: serve ledger, benchmark validi e piu campioni prima di attribuire alpha ai fattori."])
+
+    lines = []
+    if top_alpha:
+        lines.append(f"Top measured alpha-creating factor: {top_alpha.get('factor_name', 'n/a')} | contribution {format_number(top_alpha.get('alpha_contribution'))} | sample {top_alpha.get('sample_size', 'n/a')}.")
+    if top_destroyer:
+        lines.append(f"Top measured alpha-destroying factor: {top_destroyer.get('factor_name', 'n/a')} | loss {format_number(top_destroyer.get('alpha_loss_contribution'))} | action {top_destroyer.get('recommended_weight_action', 'n/a')}.")
+    if noisiest:
+        lines.append(f"Noisiest factor/module: {noisiest.get('factor_name') or noisiest.get('module_name', 'n/a')} | noise {format_number(noisiest.get('noise_score'))}/100 | severity {noisiest.get('severity', 'n/a')}.")
+    if preservation:
+        lines.append(f"Strongest no-trade preservation rule: {preservation.get('ticker', preservation.get('factor_name', 'n/a'))} | preserved {format_money(preservation.get('capital_preserved'))} | quality {format_number(preservation.get('quality_score'))}/100.")
+    if focus:
+        lines.append(f"Next Learning Loop focus: {focus.get('priority_type', 'focus')} on {focus.get('target', 'n/a')} | expected value {format_number(focus.get('expected_learning_value'))}/100.")
+    if conclusion.get("summary"):
+        lines.append(str(conclusion.get("summary")))
+    if events_summary.get("events"):
+        lines.append(f"Learning actions evaluated: {events_summary.get('events')} | improvements {events_summary.get('improvements', 0)} | degradations {events_summary.get('degradations', 0)}.")
+    return dedupe_warnings(lines or ["Insufficient meta-cognition evidence: BLUM needs a ledger, valid benchmarks and more samples before attributing alpha to factors."])
+
+
+def first_payload(value: object) -> dict:
+    if isinstance(value, list) and value:
+        first = value[0]
+        return first if isinstance(first, dict) else {}
+    return value if isinstance(value, dict) else {}
+
+
 def trade_ledger_lines(rows: list[dict], language: str) -> list[str]:
     if not rows:
         return ["BLUM ha metriche di gioco, ma il trade ledger dettagliato non e ancora disponibile." if language == "it" else "BLUM has game-level metrics, but the detailed trade ledger is not available yet."]
@@ -2484,7 +2588,7 @@ def infer_intent(message: str, mode: str | None = None) -> str:
         return "fundamental_analysis"
     if any(term in normalized for term in ["tesi", "thesis", "convinzione", "conviction", "ancora valida", "still valid", "sopravviss", "survival", "decay", "decad", "bull bear neutral", "tesi bull", "tesi bear", "tesi neutral", "motore", "engine vote", "sta migliorando", "dove ha sbagliato", "reasoning core", "batte spy", "batte qqq", "vs spy", "vs qqq"]):
         return "reasoning_memory_question"
-    if any(term in normalized for term in ["capitale virtuale", "trading game", "sta battendo", "batte il mercato", "benchmark", "drawdown", "profit factor", "expectancy", "p/l", "pl ", "peggior errore", "andato a zero", "rischio per trade", "riproducibil", "reproducib", "win rate", "quali trade", "trade hanno", "dove e entrato", "dove e uscito", "entrato blum", "uscito blum", "per azione", "fortuna", "profitto arriva", "ledger", "trade piu importante", "100 eur", "10,000", "10000", "target cycle", "ciclo capitale", "cicli capitale", "quante volte", "live paper", "forward paper", "storico vs live", "historical vs live", "sta migliorando", "intelligence growth", "missed entry", "stop hit", "target hit", "trading power", "power score", "dove e scarso", "piu scarso", "weakness", "self improvement", "auto miglior", "prossima azione", "baseline semplice", "stiamo battendo spy", "stiamo battendo qqq", "best opportunity", "migliore opportunita", "opportunita migliore", "ha scelto il migliore", "decision superiority", "superiorita decisionale", "alpha capture", "opportunita mancata", "missed opportunity", "business quality", "qualita business", "moat", "management quality", "portfolio quality", "qualita portafoglio", "contribuisce piu alpha", "contribution", "concentrazione portfolio", "capital allocation", "cash allocation", "cash reserve", "quanto capitale", "quanto allocare", "peso capitale", "sizing logic", "logica di sizing"]):
+    if any(term in normalized for term in ["capitale virtuale", "trading game", "sta battendo", "batte il mercato", "benchmark", "drawdown", "profit factor", "expectancy", "p/l", "pl ", "peggior errore", "andato a zero", "rischio per trade", "riproducibil", "reproducib", "win rate", "quali trade", "trade hanno", "dove e entrato", "dove e uscito", "entrato blum", "uscito blum", "per azione", "fortuna", "profitto arriva", "ledger", "trade piu importante", "100 eur", "10,000", "10000", "target cycle", "ciclo capitale", "cicli capitale", "quante volte", "live paper", "forward paper", "storico vs live", "historical vs live", "sta migliorando", "intelligence growth", "missed entry", "stop hit", "target hit", "trading power", "power score", "dove e scarso", "piu scarso", "weakness", "self improvement", "auto miglior", "prossima azione", "baseline semplice", "stiamo battendo spy", "stiamo battendo qqq", "best opportunity", "migliore opportunita", "opportunita migliore", "ha scelto il migliore", "decision superiority", "superiorita decisionale", "alpha capture", "opportunita mancata", "missed opportunity", "business quality", "qualita business", "moat", "management quality", "portfolio quality", "qualita portafoglio", "contribuisce piu alpha", "contribution", "concentrazione portfolio", "capital allocation", "cash allocation", "cash reserve", "quanto capitale", "quanto allocare", "peso capitale", "sizing logic", "logica di sizing", "alpha loss", "alpha recovery", "perche perdiamo", "perché perdiamo", "perdiamo contro", "why are we losing", "why losing", "qqq", "spy", "missed winners", "winners mancati", "opportunita mancate", "opportunità mancate", "recovery action", "azioni recovery", "perdita alpha", "alpha perso", "lose alpha", "meta cognition", "meta-cognition", "meta cognizione", "meta-cognizione", "fattore alpha", "factor alpha", "quale fattore", "which factor", "fattore rumoroso", "noisy factor", "modulo rumoroso", "cosa deve imparare", "what should blum learn", "imparare adesso", "learn next", "trust technical", "fidarsi dei tecnici", "capital preservation", "preservazione capitale", "no-trade rule", "regola no trade"]):
         return "trading_game"
     if any(term in normalized for term in ["sniper", "entrabile", "meglio aspettare", "ingresso", "entry", "risk/reward", "uscita", "exit", "target", "invalidazione", "invalidation", "profitto", "take profit"]):
         return "market_sniper"

backend/app/services/learning_loop.py

@@ -17,11 +17,15 @@ from app.core.config import get_settings
 from app.models import (
     Asset,
     FundamentalSnapshot,
+    FeedbackLoopAudit,
     HistoricalPrediction,
+    CapitalPreservationAlpha,
+    LearningFocusPriority,
     LearningEvent,
     LearningMetric,
     LearningRun,
     MacroSnapshot,
+    MissedWinner,
     MistakeAnalysis,
     ModelVersion,
     NewsArticle,
@@ -30,6 +34,7 @@ from app.models import (
     PriceHistory,
     SignalPerformance,
     StrategyMemory,
+    TradingGameTrade,
 )
 from app.services.technical_analysis_engine import TechnicalAnalysisEngine
 
@@ -54,6 +59,10 @@ BASE_SIGNAL_WEIGHTS = {
     "regime": 0.05,
 }
 
+MIN_MODEL_VERSION_OUTCOMES = 30
+MIN_MODEL_VERSION_SIGNAL_ROWS = 3
+MIN_MODEL_VERSION_SIGNAL_SAMPLE = 3
+
 ERROR_TYPES = {
     "technical_false_breakout",
     "overbought_signal_ignored",
@@ -86,10 +95,17 @@ class LearningLoopService:
         self.memory = StrategyMemoryService()
         self.model_scores = ModelScoreService()
 
-    def run_batch(self, db: Session, batch_size: int | None = None, trigger: str = "manual") -> dict:
+    def run_batch(
+        self,
+        db: Session,
+        batch_size: int | None = None,
+        trigger: str = "manual",
+        sniper_simulation_limit: int | None = None,
+    ) -> dict:
         requested_batch = int(batch_size or settings.learning_batch_size)
-        batch = max(1, min(requested_batch, settings.learning_batch_size, 500))
-        daily_guard = self.daily_guard(db, batch)
+        configured_batch = max(1, min(requested_batch, settings.learning_batch_size, 500))
+        daily_guard = self.daily_guard(db, configured_batch)
+        batch = max(1, int(daily_guard.get("effective_batch", configured_batch) or configured_batch))
         run_id = f"learn-{datetime.utcnow().strftime('%Y%m%d%H%M%S')}-{uuid4().hex[:8]}"
         run = LearningRun(
             run_id=run_id,
@@ -104,26 +120,26 @@ class LearningLoopService:
         db.flush()
 
         if not daily_guard["allowed"]:
-            run.status = "skipped"
+            run.status = "budget_wait"
             run.completed_at = datetime.utcnow()
-            run.summary = {"reason": daily_guard["reason"], "requested_batch_size": requested_batch}
+            run.summary = {"reason": daily_guard["reason"], "requested_batch_size": requested_batch, "daily_guard": daily_guard}
             event = LearningEvent(
-                event_type="blum_learning_loop_skipped",
+                event_type="blum_learning_loop_budget_wait",
                 severity="Warning",
-                title="BLUM Learning Loop skipped by daily guard",
+                title="BLUM Learning Loop waiting for daily budget",
                 description=daily_guard["reason"],
                 payload={"run_id": run_id, "guard": daily_guard},
             )
             db.add(event)
             db.commit()
-            return {"status": "skipped", "run_id": run_id, "guard": daily_guard}
+            return {"status": "budget_wait", "run_id": run_id, "guard": daily_guard}
 
         reports: list[dict] = []
         errors: list[dict] = []
         seen_samples: set[tuple[str, str]] = set()
         for _ in range(batch):
             try:
-                sample = self.sampler.random_sample(db, seen_samples=seen_samples)
+                sample = self.sampler.blended_sample(db, seen_samples=seen_samples, trigger=trigger)
                 if not sample:
                     errors.append({"stage": "sample", "error": "No eligible historical sample found."})
                     continue
@@ -135,9 +151,16 @@ class LearningLoopService:
         sniper_learning = {"status": "skipped", "reason": "No reports created."}
         if reports:
             try:
-                from app.services.market_sniper import MarketSniperEngine
-
-                sniper_learning = MarketSniperEngine().simulate(db, limit=min(300, max(60, len(reports) * len(TIMEFRAMES) * 6)))
+                limit = sniper_simulation_limit if sniper_simulation_limit is not None else min(300, max(60, len(reports) * len(TIMEFRAMES) * 6))
+                if limit > 0:
+                    from app.services.market_sniper import MarketSniperEngine
+
+                    sniper_learning = MarketSniperEngine().simulate(db, limit=limit)
+                else:
+                    sniper_learning = {
+                        "status": "deferred",
+                        "reason": "Sniper R-multiple simulation is deferred for this bounded learning lane.",
+                    }
             except Exception as exc:
                 sniper_learning = {"status": "degraded", "error": f"{type(exc).__name__}: {exc}"}
 
@@ -156,6 +179,7 @@ class LearningLoopService:
             "latest_reports": reports[-5:],
             "dashboard_metrics": metrics,
             "model_version": model_version,
+            "learning_mode": "alpha_loss_replay" if trigger == "alpha_loss_replay" else "random_point_in_time",
             "market_sniper_learning": sniper_learning,
         }
         run.anti_overfitting_report = anti_overfitting
@@ -174,10 +198,13 @@ class LearningLoopService:
             "status": run.status,
             "run_id": run_id,
             "batch_size": batch,
+            "requested_batch_size": requested_batch,
+            "daily_guard": daily_guard,
             "reports_created": len(reports),
             "errors": errors[:8],
             "metrics": metrics,
             "model_version": model_version,
+            "learning_mode": "alpha_loss_replay" if trigger == "alpha_loss_replay" else "random_point_in_time",
             "market_sniper_learning": sniper_learning,
             "anti_overfitting": anti_overfitting,
             "disclaimer": "Research learning loop only. It improves calibration and robustness; it does not create guaranteed market predictions.",
@@ -187,7 +214,12 @@ class LearningLoopService:
         context = self.point_in_time.context_for(db, sample["asset"], sample["analysis_date"])
         prediction_context = dict(context)
         prediction_context.pop("future_prices", None)
-        prediction_payload = self.predictor.predict(prediction_context)
+        sample_metadata = dict(sample)
+        sample_metadata["run_trigger"] = run.trigger
+        sample_metadata["evaluation_mode"] = run.evaluation_mode
+        sample_metadata["learning_mode_metadata"] = learning_mode_metadata(run.trigger, sample_metadata)
+        prediction_payload = self.predictor.predict(prediction_context, db=db, sample_metadata=sample_metadata)
+        feedback_payload = prediction_payload.get("feedback_loop", {})
         prediction = HistoricalPrediction(
             learning_run_id=run.id,
             asset_id=sample["asset"].id,
@@ -203,7 +235,12 @@ class LearningLoopService:
             point_in_time_context=json_safe(context),
             expected_direction=prediction_payload["prediction"]["dominant_direction"],
             confidence=prediction_payload["prediction"]["aggregate_confidence"],
-            model_version="blum-learning-loop-v1",
+            model_version=feedback_payload.get("model_version_used") or "base-static",
+            model_version_used=feedback_payload.get("model_version_used") or "base-static",
+            weights_used=json_safe(feedback_payload.get("weights_used") or {}),
+            learning_memory_used=json_safe(feedback_payload.get("learning_memory_used") or {}),
+            strategy_memory_used=json_safe(feedback_payload.get("strategy_memory_used") or {}),
+            research_priority_used=json_safe(feedback_payload.get("research_priority_used") or {}),
             data_quality_score=context["data_quality_score"],
         )
         db.add(prediction)
@@ -264,6 +301,7 @@ class LearningLoopService:
             memory_updates.extend(self.memory.update_from_outcome(db, context, frame_prediction, outcome_payload, analysis))
 
         self.memory.update_signal_performance(db, context, prediction_payload, outcomes)
+        feedback_audit = FeedbackLoopAuditService().record(db, prediction, prediction_payload, outcomes, memory_updates)
         report = {
             "asset": prediction.ticker,
             "analysis_date": prediction.analysis_date.isoformat(),
@@ -280,20 +318,35 @@ class LearningLoopService:
             "mistakes": mistakes,
             "lessons_learned": [item["lesson"] for item in memory_updates],
             "memory_updates": memory_updates,
+            "feedback_loop_audit": feedback_audit,
         }
         return json_safe(report)
 
     def daily_guard(self, db: Session, requested_batch: int) -> dict:
         start = datetime.combine(datetime.utcnow().date(), time.min)
         today_predictions = int(db.scalar(select(func.coalesce(func.sum(LearningRun.predictions_created), 0)).where(LearningRun.started_at >= start)) or 0)
-        projected = today_predictions + requested_batch
-        allowed = projected <= settings.learning_max_daily_runs
+        max_daily = max(0, int(settings.learning_max_daily_runs))
+        remaining = max(0, max_daily - today_predictions)
+        effective_batch = min(max(1, requested_batch), remaining) if remaining else 0
+        projected = today_predictions + effective_batch
+        allowed = effective_batch > 0
+        partial = allowed and effective_batch < requested_batch
         return {
             "allowed": allowed,
             "today_predictions": today_predictions,
             "requested_batch": requested_batch,
-            "max_daily_runs": settings.learning_max_daily_runs,
-            "reason": "within daily limit" if allowed else "Learning max daily run guard prevents overfitting and excessive repeated sampling.",
+            "effective_batch": effective_batch,
+            "remaining_daily_budget": remaining,
+            "projected_predictions": projected,
+            "max_daily_runs": max_daily,
+            "partial_batch": partial,
+            "reason": (
+                "within daily limit"
+                if allowed and not partial
+                else "partial batch: using remaining daily learning budget to keep training without overfitting"
+                if partial
+                else "daily learning budget exhausted; waiting for next UTC window instead of oversampling the same day"
+            ),
         }
 
 
@@ -301,6 +354,92 @@ class HistoricalSamplerService:
     def __init__(self) -> None:
         self.rng = random.Random(self.seed())
 
+    def blended_sample(self, db: Session, seen_samples: set[tuple[str, str]] | None = None, trigger: str = "manual") -> dict | None:
+        if trigger == "alpha_loss_replay":
+            return self.alpha_loss_sample(db, seen_samples=seen_samples) or self.random_sample(db, seen_samples=seen_samples)
+        roll = self.rng.random()
+        random_ratio = clamp_ratio(settings.learning_random_sample_ratio)
+        alpha_ratio = clamp_ratio(settings.learning_alpha_loss_sample_ratio)
+        factor_ratio = clamp_ratio(settings.learning_factor_focus_sample_ratio)
+        preservation_ratio = clamp_ratio(settings.learning_capital_preservation_sample_ratio)
+        total = max(0.01, random_ratio + alpha_ratio + factor_ratio + preservation_ratio)
+        random_cut = random_ratio / total
+        alpha_cut = random_cut + alpha_ratio / total
+        factor_cut = alpha_cut + factor_ratio / total
+        if roll < random_cut:
+            return self.random_sample(db, seen_samples=seen_samples)
+        if roll < alpha_cut:
+            return self.alpha_loss_sample(db, seen_samples=seen_samples) or self.random_sample(db, seen_samples=seen_samples)
+        if roll < factor_cut:
+            return self.focus_priority_sample(db, seen_samples=seen_samples) or self.random_sample(db, seen_samples=seen_samples)
+        return self.capital_preservation_sample(db, seen_samples=seen_samples) or self.random_sample(db, seen_samples=seen_samples)
+
+    def alpha_loss_sample(self, db: Session, seen_samples: set[tuple[str, str]] | None = None) -> dict | None:
+        missed = db.scalars(
+            select(MissedWinner)
+            .order_by(desc(MissedWinner.benchmark_relative_return), desc(MissedWinner.created_at))
+            .limit(120)
+        ).all()
+        for row in missed:
+            asset = db.scalar(select(Asset).where(Asset.ticker == row.ticker, Asset.is_active.is_(True)).limit(1))
+            if not asset:
+                continue
+            sample = self.sample_for_asset(db, asset, preferred_date=as_date(row.decision_date), seen_samples=seen_samples)
+            if sample:
+                sample["sampling_reason"] = "alpha_loss_replay"
+                sample["missed_winner_id"] = row.id
+                sample["benchmark_relative_return"] = row.benchmark_relative_return
+                return sample
+        return None
+
+    def focus_priority_sample(self, db: Session, seen_samples: set[tuple[str, str]] | None = None) -> dict | None:
+        priorities = db.scalars(
+            select(LearningFocusPriority)
+            .where(LearningFocusPriority.status.in_(["proposed", "active"]))
+            .order_by(desc(LearningFocusPriority.expected_learning_value), desc(LearningFocusPriority.created_at))
+            .limit(80)
+        ).all()
+        for priority in priorities:
+            target = str(priority.target or "").upper()
+            asset = db.scalar(select(Asset).where(Asset.ticker == target, Asset.is_active.is_(True)).limit(1))
+            if not asset:
+                asset = db.scalar(select(Asset).where(Asset.sector.ilike(priority.target), Asset.is_active.is_(True)).limit(1))
+            if not asset:
+                linked_trade = db.scalar(
+                    select(TradingGameTrade)
+                    .where(TradingGameTrade.setup_type == priority.target)
+                    .order_by(desc(TradingGameTrade.created_at))
+                    .limit(1)
+                )
+                asset = db.scalar(select(Asset).where(Asset.ticker == linked_trade.ticker, Asset.is_active.is_(True)).limit(1)) if linked_trade else None
+            if not asset:
+                continue
+            sample = self.sample_for_asset(db, asset, preferred_date=None, seen_samples=seen_samples)
+            if sample:
+                sample["sampling_reason"] = "learning_focus_priority"
+                sample["learning_focus_priority_id"] = priority.id
+                sample["priority_type"] = priority.priority_type
+                return sample
+        return None
+
+    def capital_preservation_sample(self, db: Session, seen_samples: set[tuple[str, str]] | None = None) -> dict | None:
+        rows = db.scalars(
+            select(CapitalPreservationAlpha)
+            .where(CapitalPreservationAlpha.missed_gain > CapitalPreservationAlpha.avoided_loss)
+            .order_by(desc(CapitalPreservationAlpha.missed_gain), desc(CapitalPreservationAlpha.created_at))
+            .limit(80)
+        ).all()
+        for row in rows:
+            asset = db.scalar(select(Asset).where(Asset.ticker == row.ticker, Asset.is_active.is_(True)).limit(1))
+            if not asset:
+                continue
+            sample = self.sample_for_asset(db, asset, preferred_date=as_date(row.decision_date), seen_samples=seen_samples)
+            if sample:
+                sample["sampling_reason"] = "capital_preservation_replay"
+                sample["capital_preservation_alpha_id"] = row.id
+                return sample
+        return None
+
     def random_sample(self, db: Session, seen_samples: set[tuple[str, str]] | None = None) -> dict | None:
         universe = {item.strip().lower() for item in settings.learning_asset_universe.split(",") if item.strip()}
         asset_types = []
@@ -313,32 +452,37 @@ class HistoricalSamplerService:
 
         candidates = db.scalars(select(Asset).where(Asset.is_active.is_(True), Asset.asset_type.in_(asset_types))).all()
         self.rng.shuffle(candidates)
-        min_rows = max(252, settings.learning_min_history_years * 252)
         for asset in candidates:
-            stats = db.execute(
-                select(func.count(PriceHistory.id), func.min(PriceHistory.date), func.max(PriceHistory.date)).where(PriceHistory.asset_id == asset.id)
-            ).one()
-            count, first_date, last_date = int(stats[0] or 0), as_date(stats[1]), as_date(stats[2])
-            if count < min_rows or not first_date or not last_date:
+            sample = self.sample_for_asset(db, asset, preferred_date=None, seen_samples=seen_samples)
+            if sample:
+                return sample
+        return None
+
+    def sample_for_asset(self, db: Session, asset: Asset, preferred_date: date | None, seen_samples: set[tuple[str, str]] | None = None) -> dict | None:
+        min_rows = max(252, settings.learning_min_history_years * 252)
+        stats = db.execute(
+            select(func.count(PriceHistory.id), func.min(PriceHistory.date), func.max(PriceHistory.date)).where(PriceHistory.asset_id == asset.id)
+        ).one()
+        count, first_date, last_date = int(stats[0] or 0), as_date(stats[1]), as_date(stats[2])
+        if count < min_rows or not first_date or not last_date:
+            return None
+        earliest = first_date + timedelta(days=max(365, settings.learning_min_history_years * 365))
+        latest = last_date - timedelta(days=TIMEFRAMES["long"]["horizon_days"] * 2 + 30)
+        if earliest >= latest:
+            return None
+        preferred_candidates: list[date] = []
+        if preferred_date and earliest <= preferred_date <= latest:
+            preferred_candidates.extend([preferred_date, preferred_date - timedelta(days=3), preferred_date + timedelta(days=3)])
+        span = (latest - earliest).days
+        preferred_candidates.extend(earliest + timedelta(days=self.rng.randint(0, max(1, span))) for _ in range(8))
+        for candidate_date in preferred_candidates:
+            analysis_date = nearest_trading_date(db, asset, max(earliest, min(candidate_date, latest)), latest)
+            if not analysis_date:
                 continue
-            earliest = first_date + timedelta(days=max(365, settings.learning_min_history_years * 365))
-            latest = last_date - timedelta(days=TIMEFRAMES["long"]["horizon_days"] * 2 + 30)
-            if earliest >= latest:
+            key = (asset.ticker, analysis_date.isoformat())
+            if seen_samples and key in seen_samples:
                 continue
-            span = (latest - earliest).days
-            for _ in range(8):
-                analysis_date = nearest_trading_date(
-                    db,
-                    asset,
-                    earliest + timedelta(days=self.rng.randint(0, max(1, span))),
-                    latest,
-                )
-                if not analysis_date:
-                    continue
-                key = (asset.ticker, analysis_date.isoformat())
-                if seen_samples and key in seen_samples:
-                    continue
-                return {"asset": asset, "analysis_date": analysis_date, "first_price_date": first_date, "last_price_date": last_date, "sample_rows": count}
+            return {"asset": asset, "analysis_date": analysis_date, "first_price_date": first_date, "last_price_date": last_date, "sample_rows": count}
         return None
 
     def seed(self) -> int:
@@ -480,12 +624,18 @@ class PointInTimeDataService:
 
 
 class PredictionEngine:
-    def predict(self, context: dict) -> dict:
+    def predict(self, context: dict, db: Session | None = None, sample_metadata: dict | None = None) -> dict:
         technical = context["technical"]
         signal_scores = self.signal_scores(context)
-        aggregate_score = weighted_score(signal_scores, BASE_SIGNAL_WEIGHTS)
+        sample_metadata = sample_metadata or {}
+        feedback = self.feedback_context(db, context, signal_scores, sample_metadata)
+        weights_used = feedback["weights_used"]
+        aggregate_score = weighted_score(signal_scores, weights_used)
         dominant_direction = direction_from_score(aggregate_score, technical)
-        confidence = confidence_from_evidence(aggregate_score, context["data_quality_score"], context["market_context"], technical)
+        base_confidence = confidence_from_evidence(aggregate_score, context["data_quality_score"], context["market_context"], technical)
+        confidence = round(clamp(base_confidence + feedback["confidence_adjustment"], 15, 88), 1)
+        feedback["base_confidence"] = base_confidence
+        feedback["final_confidence"] = confidence
         timeframes = {
             timeframe: self.timeframe_prediction(timeframe, config, context, signal_scores, aggregate_score, dominant_direction, confidence)
             for timeframe, config in TIMEFRAMES.items()
@@ -502,9 +652,68 @@ class PredictionEngine:
                 "reasoning": self.reasoning(context, signal_scores, dominant_direction),
             },
             "timeframes": timeframes,
+            "feedback_loop": feedback,
+            "model_version_used": feedback["model_version_used"],
+            "weights_used": weights_used,
+            "learning_memory_used": feedback["learning_memory_used"],
+            "strategy_memory_used": feedback["strategy_memory_used"],
+            "research_priority_used": feedback["research_priority_used"],
+            "learning_mode_metadata": feedback["learning_mode_metadata"],
             "anti_leakage": context["point_in_time_policy"],
         }
 
+    def feedback_context(self, db: Session | None, context: dict, signal_scores: dict, sample_metadata: dict) -> dict:
+        model_version_used, weights_used, weight_source = active_weight_context(db)
+        signal_memory = signal_performance_context(db, context, signal_scores)
+        strategy_memory = strategy_memory_context(db, context)
+        research_priority = research_priority_context(db, sample_metadata)
+        mode_metadata = sample_metadata.get("learning_mode_metadata") or learning_mode_metadata(sample_metadata.get("run_trigger"), sample_metadata)
+        confidence_adjustment = round(
+            clamp(
+                signal_memory["confidence_delta"] + strategy_memory["confidence_delta"] + research_priority.get("confidence_delta", 0.0),
+                -14.0,
+                14.0,
+            ),
+            2,
+        )
+        return {
+            "model_version_used": model_version_used,
+            "weight_source": weight_source,
+            "weights_used": weights_used,
+            "learning_memory_used": {
+                "signal_performance": signal_memory["rows"],
+                "confidence_delta": signal_memory["confidence_delta"],
+                "policy": "SignalPerformance reliability changes confidence only when enough outcome evidence exists.",
+            },
+            "strategy_memory_used": {
+                "rows": strategy_memory["rows"],
+                "confidence_delta": strategy_memory["confidence_delta"],
+                "policy": "StrategyMemory lessons modify confidence when their stored conditions match the current point-in-time setup.",
+            },
+            "research_priority_used": research_priority,
+            "learning_mode_metadata": mode_metadata,
+            "confidence_adjustment": confidence_adjustment,
+            "policy": "PredictionEngine uses active learned weights when available; otherwise BASE_SIGNAL_WEIGHTS. Learning memory changes confidence, not source code.",
+        }
+
+    def baseline_prediction(self, context: dict) -> dict:
+        signal_scores = self.signal_scores(context)
+        weights = normalize_weights(BASE_SIGNAL_WEIGHTS)
+        aggregate_score = weighted_score(signal_scores, weights)
+        direction = direction_from_score(aggregate_score, context["technical"])
+        confidence = confidence_from_evidence(aggregate_score, context["data_quality_score"], context["market_context"], context["technical"])
+        return {
+            "model_version_used": "base-static",
+            "weights_used": weights,
+            "aggregate_score": round(aggregate_score, 2),
+            "aggregate_confidence": confidence,
+            "dominant_direction": direction,
+            "actionability": feedback_actionability(direction, confidence, aggregate_score),
+            "confidence_adjustment": 0.0,
+            "memory_adjustment_used": False,
+            "policy": "Counterfactual baseline uses BASE_SIGNAL_WEIGHTS and ignores learned memory/confidence adjustments.",
+        }
+
     def signal_scores(self, context: dict) -> dict:
         technical = context["technical"]
         indicators = technical.get("technical_indicators") or {}
@@ -775,19 +984,43 @@ class StrategyMemoryService:
 class ModelScoreService:
     def recalculate(self, db: Session) -> dict:
         rows = db.scalars(select(SignalPerformance).order_by(desc(SignalPerformance.updated_at)).limit(600)).all()
-        if not rows:
-            return {"status": "insufficient_sample", "version": None}
         previous = active_model_version(db)
+        anti = self.anti_overfitting_report(db)
+        eligible_rows = [row for row in rows if int(row.sample_count or 0) >= MIN_MODEL_VERSION_SIGNAL_SAMPLE]
+        if (
+            int(anti.get("sample_count", 0) or 0) < MIN_MODEL_VERSION_OUTCOMES
+            or len(eligible_rows) < MIN_MODEL_VERSION_SIGNAL_ROWS
+        ):
+            return {
+                "status": "insufficient_evidence",
+                "version": previous.version if previous else None,
+                "active_version": previous.version if previous else None,
+                "thresholds": {
+                    "min_outcomes": MIN_MODEL_VERSION_OUTCOMES,
+                    "min_signal_rows": MIN_MODEL_VERSION_SIGNAL_ROWS,
+                    "min_signal_sample": MIN_MODEL_VERSION_SIGNAL_SAMPLE,
+                },
+                "evidence": {"outcomes": anti.get("sample_count", 0), "eligible_signal_rows": len(eligible_rows)},
+                "anti_overfitting": anti,
+                "policy": "No ModelVersion is created until enough outcome and signal reliability evidence exists.",
+            }
         previous_weights = previous.weights if previous else BASE_SIGNAL_WEIGHTS
         new_weights = dict(BASE_SIGNAL_WEIGHTS)
         for signal_name in new_weights:
-            matching = [row for row in rows if row.signal_name == signal_name and row.sample_count >= 3]
+            matching = [row for row in rows if row.signal_name == signal_name and row.sample_count >= MIN_MODEL_VERSION_SIGNAL_SAMPLE]
             if not matching:
                 continue
             avg_reliability = mean(row.reliability_score for row in matching)
             new_weights[signal_name] = max(0.03, new_weights[signal_name] + (avg_reliability - 50) / 1000)
         new_weights = normalize_weights(new_weights)
-        anti = self.anti_overfitting_report(db)
+        if previous and max(abs(safe_float(new_weights.get(key)) - safe_float((previous.weights or {}).get(key))) for key in BASE_SIGNAL_WEIGHTS) < 0.001:
+            return {
+                "status": "stable",
+                "version": previous.version,
+                "weights": previous.weights,
+                "anti_overfitting": anti,
+                "policy": "No new ModelVersion created because learned weights did not materially change.",
+            }
         version = f"learning-{datetime.utcnow().strftime('%Y%m%d%H%M%S')}"
         row = ModelVersion(
             version=version,
@@ -844,6 +1077,181 @@ class ModelScoreService:
         }
 
 
+class FeedbackLoopAuditService:
+    def record(
+        self,
+        db: Session,
+        prediction: HistoricalPrediction,
+        prediction_payload: dict,
+        outcomes: list[dict],
+        memory_updates: list[dict],
+    ) -> dict:
+        feedback = prediction_payload.get("feedback_loop", {})
+        usable = [row for row in outcomes if row.get("outcome_label") in {"correct", "wrong", "neutral"}]
+        correct = sum(1 for row in usable if row.get("outcome_label") == "correct")
+        wrong = sum(1 for row in usable if row.get("outcome_label") == "wrong")
+        returns = [safe_float(row.get("realized_return")) for row in usable if row.get("realized_return") is not None]
+        evidence_grade = "medium" if len(usable) >= 3 else "low" if usable else "insufficient"
+        learned = {
+            "memory_updates": memory_updates[:12],
+            "signal_performance_used": (feedback.get("learning_memory_used") or {}).get("signal_performance", []),
+            "strategy_memory_used": (feedback.get("strategy_memory_used") or {}).get("rows", []),
+        }
+        counterfactual = self.counterfactual_audit(prediction, prediction_payload, outcomes)
+        comparison = counterfactual.get("outcome_comparison", {})
+        changed_decision = bool(
+            (counterfactual.get("differences") or {}).get("direction_changed")
+            or (counterfactual.get("differences") or {}).get("actionability_changed")
+            or safe_float((counterfactual.get("differences") or {}).get("score_delta")) != 0.0
+            or safe_float((counterfactual.get("differences") or {}).get("confidence_delta")) != 0.0
+        )
+        improved = bool(comparison.get("improvement_detected"))
+        changes = {
+            "model_version_used": feedback.get("model_version_used"),
+            "weights_used": feedback.get("weights_used"),
+            "confidence_adjustment": feedback.get("confidence_adjustment"),
+            "base_confidence": feedback.get("base_confidence"),
+            "final_confidence": feedback.get("final_confidence"),
+            "research_priority_used": feedback.get("research_priority_used"),
+            "learning_mode_metadata": feedback.get("learning_mode_metadata"),
+            "counterfactual_audit": counterfactual,
+        }
+        decision = {
+            "prediction_id": prediction.id,
+            "ticker": prediction.ticker,
+            "analysis_date": iso(prediction.analysis_date),
+            "direction": prediction.expected_direction,
+            "confidence": prediction.confidence,
+            "aggregate_score": (prediction_payload.get("prediction") or {}).get("aggregate_score"),
+            "actionability": counterfactual.get("learned_prediction", {}).get("actionability"),
+        }
+        outcome_payload = {
+            "correct": correct,
+            "wrong": wrong,
+            "neutral": sum(1 for row in usable if row.get("outcome_label") == "neutral"),
+            "average_realized_return": round(mean(returns), 4) if returns else None,
+            "outcomes": {row.get("timeframe"): row.get("outcome_label") for row in outcomes},
+            "baseline_direction_correct": comparison.get("baseline_direction_correct"),
+            "learned_direction_correct": comparison.get("learned_direction_correct"),
+            "baseline_actionability": comparison.get("baseline_actionability"),
+            "learned_actionability": comparison.get("learned_actionability"),
+            "baseline_would_trade": comparison.get("baseline_would_trade"),
+            "learned_would_trade": comparison.get("learned_would_trade"),
+            "avoided_loss": comparison.get("avoided_loss"),
+            "missed_gain": comparison.get("missed_gain"),
+            "improvement_reason": comparison.get("improvement_reason"),
+        }
+        summary = (
+            f"{prediction.ticker} used {feedback.get('model_version_used', 'base-static')} with "
+            f"confidence adjustment {safe_float(feedback.get('confidence_adjustment')):.2f}; "
+            f"changed_decision={changed_decision}, improved={improved}. "
+            f"reason={comparison.get('improvement_reason', 'counterfactual_not_available')}."
+        )
+        row = FeedbackLoopAudit(
+            prediction_id=prediction.id,
+            ticker=prediction.ticker,
+            model_version_used=feedback.get("model_version_used") or "base-static",
+            learned_knowledge_json=json_safe(learned),
+            changes_applied_json=json_safe(changes),
+            future_decision_json=json_safe(decision),
+            outcome_json=json_safe(outcome_payload),
+            improvement_detected=improved,
+            evidence_grade=evidence_grade,
+            summary=summary,
+        )
+        db.add(row)
+        return {
+            "status": "recorded",
+            "prediction_id": prediction.id,
+            "model_version_used": row.model_version_used,
+            "what_was_learned": learned,
+            "what_changed": changes,
+            "future_decision_used_change": decision,
+            "counterfactual_audit": counterfactual,
+            "outcome": outcome_payload,
+            "improvement_detected": improved,
+            "evidence_grade": evidence_grade,
+            "summary": summary,
+        }
+
+    def counterfactual_audit(self, prediction: HistoricalPrediction, prediction_payload: dict, outcomes: list[dict]) -> dict:
+        context = dict(prediction.point_in_time_context or {})
+        context.pop("future_prices", None)
+        baseline = PredictionEngine().baseline_prediction(context) if context else {}
+        learned_prediction = prediction_payload.get("prediction") or {}
+        baseline_actionability = baseline.get("actionability")
+        learned_actionability = feedback_actionability(
+            learned_prediction.get("dominant_direction"),
+            learned_prediction.get("aggregate_confidence"),
+            learned_prediction.get("aggregate_score"),
+        )
+        learned = {
+            "model_version_used": (prediction_payload.get("feedback_loop") or {}).get("model_version_used") or "base-static",
+            "weights_used": prediction_payload.get("weights_used") or {},
+            "aggregate_score": learned_prediction.get("aggregate_score"),
+            "aggregate_confidence": learned_prediction.get("aggregate_confidence"),
+            "dominant_direction": learned_prediction.get("dominant_direction"),
+            "actionability": learned_actionability,
+            "confidence_adjustment": (prediction_payload.get("feedback_loop") or {}).get("confidence_adjustment", 0.0),
+            "memory_adjustment_used": bool((prediction_payload.get("feedback_loop") or {}).get("confidence_adjustment")),
+        }
+        baseline_correct = direction_correctness_summary(baseline.get("dominant_direction"), outcomes)
+        learned_correct = direction_correctness_summary(learned.get("dominant_direction"), outcomes)
+        baseline_would_trade = feedback_would_trade(baseline_actionability)
+        learned_would_trade = feedback_would_trade(learned_actionability)
+        returns = [safe_float(row.get("realized_return")) for row in outcomes if row.get("realized_return") is not None]
+        average_return = mean(returns) if returns else 0.0
+        avoided_loss = round(abs(average_return), 4) if baseline_would_trade and not learned_would_trade and average_return < 0 else 0.0
+        missed_gain = round(average_return, 4) if baseline_would_trade and not learned_would_trade and average_return > 0 else 0.0
+        improvement_detected, improvement_reason = counterfactual_improvement_reason(
+            baseline_correct,
+            learned_correct,
+            baseline_would_trade,
+            learned_would_trade,
+            average_return,
+            avoided_loss,
+            missed_gain,
+        )
+        comparison = {
+            "score_delta": round(safe_float(learned.get("aggregate_score")) - safe_float(baseline.get("aggregate_score")), 4),
+            "confidence_delta": round(safe_float(learned.get("aggregate_confidence")) - safe_float(baseline.get("aggregate_confidence")), 4),
+            "direction_changed": baseline.get("dominant_direction") != learned.get("dominant_direction"),
+            "actionability_changed": baseline_actionability != learned_actionability,
+        }
+        return {
+            "baseline_prediction": baseline,
+            "learned_prediction": learned,
+            "differences": comparison,
+            "outcome_comparison": {
+                "outcome_labels": {row.get("timeframe"): row.get("outcome_label") for row in outcomes},
+                "realized_returns": {row.get("timeframe"): row.get("realized_return") for row in outcomes},
+                "learned_direction": learned.get("dominant_direction"),
+                "baseline_direction": baseline.get("dominant_direction"),
+                "baseline_direction_correct": baseline_correct["direction_correct"],
+                "learned_direction_correct": learned_correct["direction_correct"],
+                "baseline_correct_count": baseline_correct["correct_count"],
+                "learned_correct_count": learned_correct["correct_count"],
+                "baseline_actionability": baseline_actionability,
+                "learned_actionability": learned_actionability,
+                "baseline_would_trade": baseline_would_trade,
+                "learned_would_trade": learned_would_trade,
+                "avoided_loss": avoided_loss,
+                "missed_gain": missed_gain,
+                "improvement_detected": improvement_detected,
+                "improvement_reason": improvement_reason,
+                "policy": "Outcome is observed after prediction persistence; baseline is recomputed only from point-in-time context.",
+            },
+        }
+
+    def report(self, db: Session, limit: int = 20) -> dict:
+        rows = db.scalars(select(FeedbackLoopAudit).order_by(desc(FeedbackLoopAudit.created_at)).limit(limit)).all()
+        return {
+            "status": "ready" if rows else "insufficient_evidence",
+            "rows": [serialize_feedback_audit(row) for row in rows],
+            "policy": "FeedbackLoopAudit is persisted by background learning runs and never computed by GET page render.",
+        }
+
+
 class LearningDashboardService:
     def dashboard(self, db: Session) -> dict:
         latest_run = db.scalar(select(LearningRun).order_by(desc(LearningRun.started_at)).limit(1))
@@ -866,6 +1274,7 @@ class LearningDashboardService:
             "strategy_memory": self.strategy_memory(db),
             "mistakes": self.mistake_summary(db),
             "model_versions": [serialize_model_version(row) for row in db.scalars(select(ModelVersion).order_by(desc(ModelVersion.created_at)).limit(8)).all()],
+            "feedback_loop_audit": FeedbackLoopAuditService().report(db, limit=8),
             "trading_game": trading_game,
             "policy": "BLUM Learning Loop optimizes calibration and robustness, not artificial 100% winrate.",
         }
@@ -1302,6 +1711,227 @@ def active_model_version(db: Session) -> ModelVersion | None:
     return db.scalar(select(ModelVersion).where(ModelVersion.is_active.is_(True)).order_by(desc(ModelVersion.created_at)).limit(1))
 
 
+def active_weight_context(db: Session | None) -> tuple[str, dict, str]:
+    if db is not None:
+        row = active_model_version(db)
+        if row and isinstance(row.weights, dict) and row.weights:
+            return row.version, model_weights_with_fallback(row.weights), "active_model_version"
+    return "base-static", normalize_weights(BASE_SIGNAL_WEIGHTS), "base_signal_weights"
+
+
+def learning_mode_metadata(trigger: str | None, sample_metadata: dict | None = None) -> dict:
+    sample_metadata = sample_metadata or {}
+    sampling_reason = sample_metadata.get("sampling_reason") or "random_point_in_time"
+    mode = "training_replay" if sampling_reason in {"alpha_loss_replay", "learning_focus_priority", "capital_preservation_replay"} or trigger == "alpha_loss_replay" else "walk_forward_validation"
+    if trigger == "paper_forward" or sample_metadata.get("mode") == "paper_forward":
+        mode = "paper_forward"
+    return {
+        "mode": mode,
+        "training_replay": mode == "training_replay",
+        "walk_forward_validation": mode == "walk_forward_validation",
+        "paper_forward": mode == "paper_forward",
+        "trigger": trigger or sample_metadata.get("run_trigger") or "unknown",
+        "sampling_reason": sampling_reason,
+        "evaluation_mode": sample_metadata.get("evaluation_mode") or settings.learning_evaluation_mode,
+        "policy": "Mode metadata is descriptive. It changes audit traceability, not source code or frontend execution.",
+    }
+
+
+def feedback_actionability(direction: str | None, confidence: float | None, score: float | None = None) -> str:
+    confidence_value = safe_float(confidence)
+    score_value = safe_float(score)
+    if direction == "neutral" or confidence_value < 35:
+        return "watch"
+    if confidence_value >= 68 and direction in {"bullish", "bearish"} and abs(score_value - 50) >= 10:
+        return "active_setup"
+    if confidence_value >= 54 and direction in {"bullish", "bearish"}:
+        return "wait_for_trigger"
+    return "watch"
+
+
+def feedback_would_trade(actionability: str | None) -> bool:
+    return actionability in {"active_setup", "wait_for_trigger", "actionable_if_confirmed"}
+
+
+def direction_correctness_summary(direction: str | None, outcomes: list[dict]) -> dict:
+    rows = [row for row in outcomes if row.get("realized_return") is not None]
+    if not rows:
+        return {"direction_correct": None, "correct_count": 0, "wrong_count": 0, "sample_count": 0}
+    correct = sum(1 for row in rows if direction_matches_return(direction, safe_float(row.get("realized_return"))))
+    wrong = len(rows) - correct
+    return {
+        "direction_correct": correct > wrong,
+        "correct_count": correct,
+        "wrong_count": wrong,
+        "sample_count": len(rows),
+    }
+
+
+def direction_matches_return(direction: str | None, realized_return: float) -> bool:
+    if direction == "bullish":
+        return realized_return > 0
+    if direction == "bearish":
+        return realized_return < 0
+    if direction == "neutral":
+        return abs(realized_return) <= 1.0
+    return False
+
+
+def counterfactual_improvement_reason(
+    baseline_correct: dict,
+    learned_correct: dict,
+    baseline_would_trade: bool,
+    learned_would_trade: bool,
+    average_return: float,
+    avoided_loss: float,
+    missed_gain: float,
+) -> tuple[bool, str]:
+    baseline_count = int(baseline_correct.get("correct_count") or 0)
+    learned_count = int(learned_correct.get("correct_count") or 0)
+    if learned_count > baseline_count:
+        return True, "learned_direction_more_correct_than_baseline"
+    if learned_count < baseline_count:
+        return False, "learned_direction_less_correct_than_baseline"
+    if avoided_loss > 0:
+        return True, "learned_actionability_avoided_baseline_loss"
+    if missed_gain > 0:
+        return False, "learned_actionability_missed_baseline_gain"
+    if learned_would_trade and not baseline_would_trade and average_return > 0:
+        return True, "learned_actionability_captured_gain_baseline_would_skip"
+    if learned_would_trade and not baseline_would_trade and average_return < 0:
+        return False, "learned_actionability_entered_losing_trade_baseline_would_skip"
+    return False, "no_counterfactual_improvement_detected"
+
+
+def model_weights_with_fallback(weights: dict) -> dict:
+    merged = dict(BASE_SIGNAL_WEIGHTS)
+    for key in BASE_SIGNAL_WEIGHTS:
+        if key in weights:
+            merged[key] = safe_float(weights.get(key)) if weights.get(key) is not None else BASE_SIGNAL_WEIGHTS[key]
+    return normalize_weights(merged)
+
+
+def signal_performance_context(db: Session | None, context: dict, signal_scores: dict) -> dict:
+    if db is None or not signal_scores:
+        return {"rows": [], "confidence_delta": 0.0}
+    regime = context.get("market_context", {}).get("market_regime", "Unknown")
+    rows = db.scalars(
+        select(SignalPerformance)
+        .where(SignalPerformance.signal_name.in_(list(signal_scores.keys())), SignalPerformance.market_regime == regime)
+        .order_by(desc(SignalPerformance.sample_count), desc(SignalPerformance.updated_at))
+        .limit(80)
+    ).all()
+    grouped: dict[str, list[SignalPerformance]] = defaultdict(list)
+    for row in rows:
+        grouped[row.signal_name].append(row)
+    payloads = []
+    deltas = []
+    for signal_name, signal_rows in grouped.items():
+        sample_count = sum(int(row.sample_count or 0) for row in signal_rows)
+        reliability = mean(float(row.reliability_score or 50.0) for row in signal_rows)
+        false_positives = sum(int(row.false_positive_count or 0) for row in signal_rows)
+        false_positive_rate = false_positives / max(1, sample_count)
+        enough_evidence = sample_count >= MIN_MODEL_VERSION_SIGNAL_SAMPLE
+        delta = clamp((reliability - 50.0) / 8.0 - false_positive_rate * 4.0, -5.0, 5.0) if enough_evidence else 0.0
+        payloads.append(
+            {
+                "signal_name": signal_name,
+                "market_regime": regime,
+                "sample_count": sample_count,
+                "reliability_score": round(reliability, 2),
+                "false_positive_rate": round(false_positive_rate, 4),
+                "signal_score": signal_scores.get(signal_name),
+                "confidence_delta": round(delta, 3),
+                "used": enough_evidence,
+            }
+        )
+        if enough_evidence:
+            deltas.append(delta)
+    total_delta = clamp(sum(deltas) / max(1, len(deltas)) * 1.4, -8.0, 8.0) if deltas else 0.0
+    return {"rows": payloads[:16], "confidence_delta": round(total_delta, 3)}
+
+
+def strategy_memory_context(db: Session | None, context: dict) -> dict:
+    if db is None:
+        return {"rows": [], "confidence_delta": 0.0}
+    rows = db.scalars(select(StrategyMemory).order_by(desc(StrategyMemory.reliability_score), desc(StrategyMemory.updated_at)).limit(120)).all()
+    applicable = []
+    deltas = []
+    for row in rows:
+        if not strategy_memory_matches(row, context):
+            continue
+        sample_count = int(row.sample_count or 0)
+        enough_evidence = sample_count >= 3
+        positive = int(row.positive_count or 0)
+        negative = int(row.negative_count or 0)
+        reliability = safe_float(row.reliability_score) if row.reliability_score is not None else 50.0
+        delta = clamp((reliability - 50.0) / 10.0, -4.0, 4.0) if enough_evidence else 0.0
+        if negative > positive and enough_evidence:
+            delta = min(delta, -1.5)
+        applicable.append(
+            {
+                "memory_key": row.memory_key,
+                "category": row.category,
+                "lesson": row.lesson,
+                "sample_count": sample_count,
+                "positive_count": positive,
+                "negative_count": negative,
+                "reliability_score": reliability,
+                "confidence_delta": round(delta, 3),
+                "used": enough_evidence,
+            }
+        )
+        if enough_evidence:
+            deltas.append(delta)
+    total_delta = clamp(sum(deltas), -6.0, 6.0) if deltas else 0.0
+    return {"rows": applicable[:12], "confidence_delta": round(total_delta, 3)}
+
+
+def strategy_memory_matches(row: StrategyMemory, context: dict) -> bool:
+    conditions = row.conditions or {}
+    technical = context.get("technical") or {}
+    indicators = technical.get("technical_indicators") or {}
+    volume = technical.get("volume") or {}
+    fundamentals = context.get("fundamentals") or {}
+    if "rsi_gt" in conditions and safe_float(indicators.get("rsi")) > safe_float(conditions.get("rsi_gt")):
+        return True
+    if "relative_volume_gt" in conditions and safe_float(volume.get("relative_volume")) > safe_float(conditions.get("relative_volume_gt")):
+        return True
+    if conditions.get("fundamentals") == "not_point_in_time_verified" and fundamentals.get("status") != "ready":
+        return True
+    if row.category in {"general_calibration", "volume_confirmation"}:
+        return True
+    return False
+
+
+def research_priority_context(db: Session | None, sample_metadata: dict) -> dict:
+    priority_id = sample_metadata.get("learning_focus_priority_id")
+    if db is not None and priority_id:
+        row = db.get(LearningFocusPriority, priority_id)
+        if row:
+            return {
+                "status": "used",
+                "id": row.id,
+                "priority_type": row.priority_type,
+                "target": row.target,
+                "reason": row.reason,
+                "expected_learning_value": row.expected_learning_value,
+                "urgency": row.urgency,
+                "sample_gap": row.sample_gap,
+                "sampling_reason": sample_metadata.get("sampling_reason"),
+                "confidence_delta": 0.0,
+            }
+    if sample_metadata.get("sampling_reason"):
+        return {
+            "status": "used",
+            "sampling_reason": sample_metadata.get("sampling_reason"),
+            "priority_type": sample_metadata.get("priority_type"),
+            "missed_winner_id": sample_metadata.get("missed_winner_id"),
+            "confidence_delta": 0.0,
+        }
+    return {"status": "not_applicable", "confidence_delta": 0.0}
+
+
 def normalize_weights(weights: dict[str, float]) -> dict[str, float]:
     total = sum(max(0.0, float(value)) for value in weights.values()) or 1.0
     return {key: round(max(0.0, float(value)) / total, 4) for key, value in weights.items()}
@@ -1372,6 +2002,11 @@ def serialize_prediction(row: HistoricalPrediction) -> dict:
         "market_regime": row.market_regime,
         "volatility_regime": row.volatility_regime,
         "data_quality_score": row.data_quality_score,
+        "model_version_used": row.model_version_used,
+        "weights_used": row.weights_used,
+        "learning_memory_used": row.learning_memory_used,
+        "strategy_memory_used": row.strategy_memory_used,
+        "research_priority_used": row.research_priority_used,
         "prediction": row.prediction_payload.get("prediction", {}) if row.prediction_payload else {},
         "timeframes": row.prediction_payload.get("timeframes", {}) if row.prediction_payload else {},
         "created_at": iso(row.created_at),
@@ -1423,6 +2058,24 @@ def serialize_model_version(row: ModelVersion) -> dict:
     }
 
 
+def serialize_feedback_audit(row: FeedbackLoopAudit) -> dict:
+    return {
+        "id": row.id,
+        "prediction_id": row.prediction_id,
+        "ticker": row.ticker,
+        "model_version_used": row.model_version_used,
+        "what_was_learned": row.learned_knowledge_json,
+        "what_changed": row.changes_applied_json,
+        "counterfactual_audit": (row.changes_applied_json or {}).get("counterfactual_audit"),
+        "future_decision_used_change": row.future_decision_json,
+        "outcome": row.outcome_json,
+        "improvement_detected": row.improvement_detected,
+        "evidence_grade": row.evidence_grade,
+        "summary": row.summary,
+        "created_at": iso(row.created_at),
+    }
+
+
 def fundamental_reason(fundamentals: dict) -> str:
     if fundamentals.get("status") == "ready":
         return f"Point-in-time verified fundamentals available with quality score {fundamentals.get('quality_score')}."
@@ -1509,6 +2162,10 @@ def clamp(value: float, low: float = 0.0, high: float = 100.0) -> float:
     return max(low, min(high, float(value)))
 
 
+def clamp_ratio(value: float) -> float:
+    return max(0.0, min(1.0, safe_float(value)))
+
+
 def round_float(value) -> float | None:
     return round(safe_float(value), 4) if value is not None else None
 

backend/app/services/learning_summary.py

@@ -3,16 +3,23 @@ from __future__ import annotations
 from datetime import datetime
 import time
 
-from sqlalchemy import desc, select
+from sqlalchemy import desc, inspect, select
 from sqlalchemy.orm import Session
 
 from app.models import (
     BlumTradingPowerScore,
     DashboardSnapshot,
+    CapitalPreservationAlpha,
     LearningBenchmarkComparison,
+    LearningFactorImportance,
+    LearningFocusPriority,
     LearningRun,
+    LearningStrengthWeaknessMap,
+    ReasoningNoiseFlag,
     TradingCapitalCycle,
     TradingGame,
+    TradingIntelligenceMetric,
+    TradeLearningEvidence,
 )
 from app.services.dashboard_snapshots import DashboardSnapshotService
 from app.services.performance import performance_recorder
@@ -30,6 +37,21 @@ class LearningSummaryService:
         started = time.perf_counter()
         missing_sections: list[str] = []
         warnings: list[str] = []
+        snapshot_types = [
+            "learning_summary",
+            "trading_game_summary",
+            "benchmark_summary",
+            "intelligence_growth_summary",
+            "truth_panel_summary",
+            "meta_cognition_summary",
+        ]
+        snapshots = {snapshot_type: DashboardSnapshotService().latest(db, snapshot_type) for snapshot_type in snapshot_types}
+        stale_snapshots = [snapshot_type for snapshot_type, payload in snapshots.items() if payload.get("status") == "stale"]
+        missing_snapshots = [snapshot_type for snapshot_type, payload in snapshots.items() if payload.get("status") == "missing"]
+        if stale_snapshots:
+            warnings.append(f"Using stale dashboard snapshots for: {', '.join(stale_snapshots)}.")
+        if missing_snapshots:
+            warnings.append(f"Dashboard snapshots not available yet for: {', '.join(missing_snapshots)}.")
 
         power = db.scalar(select(BlumTradingPowerScore).order_by(desc(BlumTradingPowerScore.calculated_at)).limit(1))
         if power is None:
@@ -54,35 +76,63 @@ class LearningSummaryService:
         if latest_run is None:
             missing_sections.append("latest_learning_run")
 
+        latest_metric = db.scalar(select(TradingIntelligenceMetric).order_by(desc(TradingIntelligenceMetric.calculated_at)).limit(1))
+        if latest_metric is None:
+            missing_sections.append("trading_intelligence_metrics")
+
+        top_weakness = db.scalar(select(LearningStrengthWeaknessMap).order_by(desc(LearningStrengthWeaknessMap.weakness_score), desc(LearningStrengthWeaknessMap.calculated_at)).limit(1))
+        latest_lesson = db.scalar(select(TradeLearningEvidence).order_by(desc(TradeLearningEvidence.created_at)).limit(1))
+
         benchmarks = list(db.scalars(select(LearningBenchmarkComparison).order_by(desc(LearningBenchmarkComparison.calculated_at)).limit(24)).all())
         benchmark_summary = summarize_benchmarks(benchmarks)
         if not benchmarks:
             missing_sections.append("benchmark_summary")
 
         live_snapshot = DashboardSnapshotService().latest(db, "live_vs_historical_summary")
+        meta_snapshot = snapshots.get("meta_cognition_summary") or {}
         if live_snapshot["status"] == "missing":
             warnings.append("Live vs historical summary snapshot is missing.")
+        if meta_snapshot.get("status") == "missing":
+            warnings.append("Meta-Cognition summary snapshot is missing.")
 
         current_capital = getattr(current_cycle, "final_capital", None) if current_cycle else getattr(game, "current_capital", None)
         target_capital = getattr(current_cycle, "target_capital", None) if current_cycle else getattr(game, "target_capital", None)
         target_progress = safe_progress(current_capital, target_capital)
+        current_cycle_payload = serialize_cycle(current_cycle)
         truth_panel_lines = build_truth_panel(power, benchmark_summary, warnings, benchmarks)
+        truth_snapshot = snapshots.get("truth_panel_summary", {})
+        truth_snapshot_payload = truth_snapshot.get("payload") or {}
+        if truth_snapshot_payload.get("truth_panel"):
+            truth_panel_lines = truth_snapshot_payload["truth_panel"]
+        last_snapshot_timestamp = latest_snapshot_timestamp(snapshots)
+        backend_training_status = training_status(latest_run, snapshots)
         payload = {
             "status": "initializing" if missing_sections else "ready",
             "generated_at": datetime.utcnow().isoformat(),
             "summary_duration_ms": round((time.perf_counter() - started) * 1000, 3),
+            "learning_loop_status": getattr(latest_run, "status", None) or "not_started",
             "trading_power_score": power.score if power else None,
             "trading_power_classification": power.classification if power else "initializing",
+            "current_capital_cycle": current_cycle_payload,
             "current_capital": current_capital,
             "target_capital": target_capital,
             "target_progress": target_progress,
+            "win_rate": first_not_none(getattr(latest_metric, "win_rate", None), getattr(game, "win_rate", None)),
+            "expectancy_r": first_not_none(getattr(latest_metric, "expectancy_r", None), getattr(current_cycle, "expectancy_r", None), getattr(game, "expectancy_r", None)),
             "completed_target_cycles": getattr(game, "target_cycles_completed", 0) if game else 0,
             "bankrupt_cycles": getattr(game, "bankrupt_cycles", 0) if game else 0,
             "latest_learning_run_status": getattr(latest_run, "status", None) or "not_started",
             "latest_learning_run_at": latest_run.started_at.isoformat() if latest_run and latest_run.started_at else None,
             "benchmark_summary": benchmark_summary,
             "live_vs_historical_summary": live_snapshot,
+            "live_vs_historical_status": live_snapshot.get("status", "missing"),
+            "top_weakness": serialize_weakness(top_weakness),
+            "latest_lesson_learned": serialize_lesson(latest_lesson),
             "truth_panel": truth_panel_lines,
+            "what_blum_should_learn_next": what_blum_should_learn_next(db, meta_snapshot),
+            "backend_training_status": backend_training_status,
+            "last_snapshot_timestamp": last_snapshot_timestamp,
+            "snapshots": summarize_snapshots(snapshots),
             "warnings": warnings,
             "missing_sections": missing_sections,
             "data_freshness": {
@@ -90,13 +140,15 @@ class LearningSummaryService:
                 "game_updated_at": game.updated_at.isoformat() if game and game.updated_at else None,
                 "learning_run_started_at": latest_run.started_at.isoformat() if latest_run and latest_run.started_at else None,
                 "benchmark_calculated_at": max((row.calculated_at for row in benchmarks if row.calculated_at), default=None).isoformat() if benchmarks else None,
+                "trading_intelligence_calculated_at": latest_metric.calculated_at.isoformat() if latest_metric and latest_metric.calculated_at else None,
+                "last_snapshot_timestamp": last_snapshot_timestamp,
             },
-            "is_recalculation_running": False,
+            "is_recalculation_running": backend_training_status["is_recalculation_running"],
             "suggested_next_step": "Use background workers or explicit recalculation buttons to refresh missing summaries." if missing_sections else "Summary is ready.",
             "performance": {
                 "budget_ms": 300,
                 "duration_ms": round((time.perf_counter() - started) * 1000, 3),
-                "source": "latest_precomputed_rows_only",
+                "source": "snapshots_first_latest_precomputed_rows_only",
             },
         }
         performance_recorder.record_dashboard_widget(
@@ -150,6 +202,160 @@ def build_truth_panel(power: BlumTradingPowerScore | None, benchmark_summary: di
     return output[:7]
 
 
+def what_blum_should_learn_next(db: Session, meta_snapshot: dict) -> dict:
+    snapshot_payload = meta_snapshot.get("payload") or {}
+    if snapshot_payload:
+        return {
+            "status": meta_snapshot.get("status", "ready"),
+            "top_alpha_creating_factor": compact_factor(snapshot_payload.get("top_alpha_factor")),
+            "top_alpha_destroying_factor": compact_factor(snapshot_payload.get("top_alpha_destroyer")),
+            "noisiest_factor": compact_factor(snapshot_payload.get("noisiest_factor")),
+            "most_undervalued_factor": compact_factor(snapshot_payload.get("most_undervalued_factor")),
+            "strongest_capital_preservation_rule": compact_preservation(snapshot_payload.get("strongest_capital_preservation_rule")),
+            "weakest_current_module": compact_noise(snapshot_payload.get("weakest_current_module")),
+            "next_learning_focus": compact_focus(snapshot_payload.get("next_learning_focus")),
+            "conclusion": snapshot_payload.get("meta_cognition_conclusion", {}).get("summary") or "Meta-Cognition snapshot available.",
+            "source": "snapshot",
+        }
+    if not all(table_exists(db, model.__tablename__) for model in [LearningFactorImportance, LearningFocusPriority, ReasoningNoiseFlag, CapitalPreservationAlpha]):
+        return {
+            "status": "missing",
+            "top_alpha_creating_factor": None,
+            "top_alpha_destroying_factor": None,
+            "noisiest_factor": None,
+            "most_undervalued_factor": None,
+            "strongest_capital_preservation_rule": None,
+            "weakest_current_module": None,
+            "next_learning_focus": None,
+            "conclusion": "Meta-Cognition tables are not available yet; showing the rest of the Learning snapshot without recalculation.",
+            "source": "schema_not_ready",
+        }
+    factor_rows = db.scalars(select(LearningFactorImportance).order_by(desc(LearningFactorImportance.calculated_at)).limit(40)).all()
+    focus = db.scalar(
+        select(LearningFocusPriority)
+        .where(LearningFocusPriority.status.in_(["proposed", "active"]))
+        .order_by(desc(LearningFocusPriority.expected_learning_value), desc(LearningFocusPriority.created_at))
+        .limit(1)
+    )
+    noise = db.scalar(select(ReasoningNoiseFlag).where(ReasoningNoiseFlag.status == "open").order_by(desc(ReasoningNoiseFlag.created_at)).limit(1))
+    preservation = db.scalar(select(CapitalPreservationAlpha).order_by(desc(CapitalPreservationAlpha.capital_preserved), desc(CapitalPreservationAlpha.created_at)).limit(1))
+    top_alpha = max(factor_rows, key=lambda row: row.alpha_contribution, default=None)
+    top_loss = max(factor_rows, key=lambda row: row.alpha_loss_contribution, default=None)
+    noisiest = max(factor_rows, key=lambda row: row.noise_score, default=None)
+    undervalued = max(factor_rows, key=lambda row: row.undervaluation_score, default=None)
+    return {
+        "status": "ready" if factor_rows or focus or noise or preservation else "missing",
+        "top_alpha_creating_factor": compact_factor_obj(top_alpha),
+        "top_alpha_destroying_factor": compact_factor_obj(top_loss),
+        "noisiest_factor": compact_factor_obj(noisiest),
+        "most_undervalued_factor": compact_factor_obj(undervalued),
+        "strongest_capital_preservation_rule": compact_preservation_obj(preservation),
+        "weakest_current_module": compact_noise_obj(noise),
+        "next_learning_focus": compact_focus_obj(focus),
+        "conclusion": "Meta-Cognition snapshot missing; showing latest stored evidence only." if factor_rows else "Meta-Cognition evidence is not available yet.",
+        "source": "latest_rows_no_recalculation",
+    }
+
+
+def table_exists(db: Session, table_name: str) -> bool:
+    try:
+        return inspect(db.get_bind()).has_table(table_name)
+    except Exception:
+        return False
+
+
+def compact_factor(item: dict | None) -> dict | None:
+    if not item:
+        return None
+    return {
+        "factor_name": item.get("factor_name"),
+        "sample_size": item.get("sample_size"),
+        "confidence": item.get("confidence"),
+        "recommended_weight_action": item.get("recommended_weight_action"),
+        "alpha_contribution": item.get("alpha_contribution"),
+        "alpha_loss_contribution": item.get("alpha_loss_contribution"),
+        "noise_score": item.get("noise_score"),
+    }
+
+
+def compact_factor_obj(row: LearningFactorImportance | None) -> dict | None:
+    return compact_factor({
+        "factor_name": row.factor_name,
+        "sample_size": row.sample_size,
+        "confidence": row.confidence,
+        "recommended_weight_action": row.recommended_weight_action,
+        "alpha_contribution": row.alpha_contribution,
+        "alpha_loss_contribution": row.alpha_loss_contribution,
+        "noise_score": row.noise_score,
+    }) if row else None
+
+
+def compact_focus(item: dict | None) -> dict | None:
+    if not item:
+        return None
+    return {
+        "priority_type": item.get("priority_type"),
+        "target": item.get("target"),
+        "expected_learning_value": item.get("expected_learning_value"),
+        "urgency": item.get("urgency"),
+        "reason": item.get("reason"),
+    }
+
+
+def compact_focus_obj(row: LearningFocusPriority | None) -> dict | None:
+    return compact_focus({
+        "priority_type": row.priority_type,
+        "target": row.target,
+        "expected_learning_value": row.expected_learning_value,
+        "urgency": row.urgency,
+        "reason": row.reason,
+    }) if row else None
+
+
+def compact_preservation(item: dict | None) -> dict | None:
+    if not item:
+        return None
+    return {
+        "ticker": item.get("ticker"),
+        "setup_type": item.get("setup_type"),
+        "capital_preserved": item.get("capital_preserved"),
+        "opportunity_cost": item.get("opportunity_cost"),
+        "quality_score": item.get("quality_score"),
+    }
+
+
+def compact_preservation_obj(row: CapitalPreservationAlpha | None) -> dict | None:
+    return compact_preservation({
+        "ticker": row.ticker,
+        "setup_type": row.setup_type,
+        "capital_preserved": row.capital_preserved,
+        "opportunity_cost": row.opportunity_cost,
+        "quality_score": row.quality_score,
+    }) if row else None
+
+
+def compact_noise(item: dict | None) -> dict | None:
+    if not item:
+        return None
+    return {
+        "factor_name": item.get("factor_name"),
+        "module_name": item.get("module_name"),
+        "noise_type": item.get("noise_type"),
+        "severity": item.get("severity"),
+        "recommended_action": item.get("recommended_action"),
+    }
+
+
+def compact_noise_obj(row: ReasoningNoiseFlag | None) -> dict | None:
+    return compact_noise({
+        "factor_name": row.factor_name,
+        "module_name": row.module_name,
+        "noise_type": row.noise_type,
+        "severity": row.severity,
+        "recommended_action": row.recommended_action,
+    }) if row else None
+
+
 def safe_progress(capital: float | None, target: float | None) -> float | None:
     if capital is None or target is None or target <= 0:
         return None
@@ -158,3 +364,98 @@ def safe_progress(capital: float | None, target: float | None) -> float | None:
 
 def format_number(value: float | None) -> str:
     return "n/a" if value is None else f"{value:.2f}"
+
+
+def first_not_none(*values):
+    for value in values:
+        if value is not None:
+            return value
+    return None
+
+
+def serialize_cycle(row: TradingCapitalCycle | None) -> dict | None:
+    if row is None:
+        return None
+    return {
+        "id": row.id,
+        "cycle_number": row.cycle_number,
+        "status": row.status,
+        "started_at": row.started_at.isoformat() if row.started_at else None,
+        "ended_at": row.ended_at.isoformat() if row.ended_at else None,
+        "start_capital": row.start_capital,
+        "target_capital": row.target_capital,
+        "final_capital": row.final_capital,
+        "trades_count": row.trades_count,
+        "wins": row.wins,
+        "losses": row.losses,
+        "missed_entries": row.missed_entries,
+        "target_hits": row.target_hits,
+        "stop_hits": row.stop_hits,
+        "expectancy_r": row.expectancy_r,
+        "excess_return_vs_benchmark": row.excess_return_vs_benchmark,
+        "updated_at": row.updated_at.isoformat() if row.updated_at else None,
+    }
+
+
+def serialize_weakness(row: LearningStrengthWeaknessMap | None) -> dict | None:
+    if row is None:
+        return None
+    return {
+        "dimension": row.dimension,
+        "entity": row.entity,
+        "weakness_score": row.weakness_score,
+        "strength_score": row.strength_score,
+        "sample_size": row.sample_size,
+        "main_problem": row.main_problem,
+        "recommended_action": row.recommended_action,
+        "priority": row.priority,
+        "calculated_at": row.calculated_at.isoformat() if row.calculated_at else None,
+    }
+
+
+def serialize_lesson(row: TradeLearningEvidence | None) -> dict | None:
+    if row is None:
+        return None
+    return {
+        "ticker": row.ticker,
+        "setup_type": row.setup_type,
+        "lesson_type": row.lesson_type,
+        "observation": row.observation,
+        "sample_size": row.sample_size,
+        "affected_module": row.affected_module,
+        "confidence": row.confidence,
+        "created_at": row.created_at.isoformat() if row.created_at else None,
+    }
+
+
+def summarize_snapshots(snapshots: dict[str, dict]) -> dict:
+    output = {}
+    for snapshot_type, payload in snapshots.items():
+        output[snapshot_type] = {
+            "status": payload.get("status"),
+            "created_at": payload.get("created_at"),
+            "expires_at": payload.get("expires_at"),
+            "is_stale": payload.get("is_stale"),
+            "warnings": payload.get("warnings") or ([payload.get("warning")] if payload.get("warning") else []),
+        }
+    return output
+
+
+def latest_snapshot_timestamp(snapshots: dict[str, dict]) -> str | None:
+    timestamps = [payload.get("created_at") for payload in snapshots.values() if payload.get("created_at")]
+    return max(timestamps) if timestamps else None
+
+
+def training_status(latest_run: LearningRun | None, snapshots: dict[str, dict]) -> dict:
+    running_statuses = {"running", "queued", "processing", "in_progress"}
+    status = getattr(latest_run, "status", None) or "not_started"
+    running = status in running_statuses
+    stale_count = sum(1 for payload in snapshots.values() if payload.get("status") == "stale")
+    return {
+        "mode": "backend_scheduler_independent",
+        "status": "running" if running else status,
+        "is_recalculation_running": running,
+        "frontend_policy": "read_only_snapshot_observer",
+        "stale_snapshot_count": stale_count,
+        "latest_run_id": getattr(latest_run, "run_id", None),
+    }

backend/app/services/performance.py

@@ -424,7 +424,12 @@ def top_bottlenecks(api_events: list[dict[str, Any]], db_events: list[dict[str,
 
 
 def learning_page_load_summary(api_events: list[dict[str, Any]], widget_events: list[dict[str, Any]], frontend_widget_events: list[dict[str, Any]]) -> dict[str, Any]:
-    frontend_api_events = [event for event in frontend_widget_events if str(event.get("name", "")).startswith("frontend.api.")]
+    all_frontend_api_events = [event for event in frontend_widget_events if str(event.get("name", "")).startswith("frontend.api.")]
+    frontend_api_events = [
+        event for event in all_frontend_api_events
+        if str((event.get("metadata") or {}).get("route") or "").startswith("/learning")
+        and bool((event.get("metadata") or {}).get("initial_learning_window"))
+    ]
     status_counts: dict[str, int] = defaultdict(int)
     for event in frontend_api_events:
         status_counts[str((event.get("metadata") or {}).get("status") or "unknown")] += 1
@@ -450,6 +455,7 @@ def learning_page_load_summary(api_events: list[dict[str, Any]], widget_events:
     ]
     return {
         "frontend_request_count": len(frontend_api_events),
+        "unscoped_frontend_request_count": len(all_frontend_api_events),
         "duplicate_request_count": status_counts.get("deduped", 0),
         "cache_hit_count": status_counts.get("cache_hit", 0) + status_counts.get("cache", 0),
         "status_counts": dict(status_counts),

backend/app/services/trade_transparency.py

@@ -51,41 +51,79 @@ class TradeLedgerService:
         limit: int = 200,
         offset: int = 0,
         refresh: bool = True,
+        use_snapshot: bool = True,
+        include_trace: bool = False,
     ) -> dict:
+        if use_snapshot and self._can_use_ledger_snapshot(
+            ticker=ticker,
+            setup_type=setup_type,
+            outcome_label=outcome_label,
+            start_date=start_date,
+            end_date=end_date,
+            min_r=min_r,
+            max_r=max_r,
+            only_open=only_open,
+            only_closed=only_closed,
+            sort_by=sort_by,
+        ):
+            from app.services.trading_game_runtime import TradingGameRuntimeSnapshotService
+
+            snapshot_payload = TradingGameRuntimeSnapshotService().ledger_from_snapshot(db, game_id=game_id, limit=limit, offset=offset)
+            if snapshot_payload is not None:
+                return snapshot_payload
         game = self.game(db, game_id)
         if not game:
             return {"status": "no_game", "rows": [], "summary": {}, "policy": TRANSPARENCY_POLICY}
+        from app.services.trading_game_runtime import RuntimeTrace, payload_size_bytes
+
+        trace = RuntimeTrace("trading_game_ledger_live_read")
         if refresh:
-            self.refresh_game_transparency(db, game, commit=False, persist_reality=False)
-        query = select(TradingGameTrade).where(TradingGameTrade.game_id == game.id)
-        if ticker:
-            query = query.where(TradingGameTrade.ticker == ticker.upper())
-        if setup_type:
-            query = query.where(TradingGameTrade.setup_type == setup_type)
-        if outcome_label:
-            query = query.where(TradingGameTrade.outcome_label == outcome_label)
-        parsed_start = parse_date(start_date)
-        parsed_end = parse_date(end_date)
-        if parsed_start:
-            query = query.where(TradingGameTrade.entry_date >= parsed_start)
-        if parsed_end:
-            query = query.where(TradingGameTrade.entry_date <= parsed_end)
-        if min_r is not None:
-            query = query.where(TradingGameTrade.realized_r_multiple >= min_r)
-        if max_r is not None:
-            query = query.where(TradingGameTrade.realized_r_multiple <= max_r)
-        if only_open:
-            query = query.where(TradingGameTrade.exit_date.is_(None))
-        if only_closed:
-            query = query.where(TradingGameTrade.exit_date.is_not(None))
-        total = int(db.scalar(select(func.count()).select_from(query.subquery())) or 0)
-        query = order_trade_query(query, sort_by).limit(limit).offset(offset)
-        rows = db.scalars(query).all()
-        return {
+            with trace.phase("refresh_transparency"):
+                self.refresh_game_transparency(db, game, commit=False, persist_reality=False)
+        with trace.phase("base_trade_query"):
+            query = select(TradingGameTrade).where(TradingGameTrade.game_id == game.id)
+            if ticker:
+                query = query.where(TradingGameTrade.ticker == ticker.upper())
+            if setup_type:
+                query = query.where(TradingGameTrade.setup_type == setup_type)
+            if outcome_label:
+                query = query.where(TradingGameTrade.outcome_label == outcome_label)
+            parsed_start = parse_date(start_date)
+            parsed_end = parse_date(end_date)
+            if parsed_start:
+                query = query.where(TradingGameTrade.entry_date >= parsed_start)
+            if parsed_end:
+                query = query.where(TradingGameTrade.entry_date <= parsed_end)
+            if min_r is not None:
+                query = query.where(TradingGameTrade.realized_r_multiple >= min_r)
+            if max_r is not None:
+                query = query.where(TradingGameTrade.realized_r_multiple <= max_r)
+            if only_open:
+                query = query.where(TradingGameTrade.exit_date.is_(None))
+            if only_closed:
+                query = query.where(TradingGameTrade.exit_date.is_not(None))
+            total = int(db.scalar(select(func.count()).select_from(query.subquery())) or 0)
+            query = order_trade_query(query, sort_by).limit(limit).offset(offset)
+            rows = db.scalars(query).all()
+        with trace.phase("attribution_loading"):
+            attribution_count = 0
+        with trace.phase("evidence_loading"):
+            evidence_count = 0
+        with trace.phase("benchmark_loading"):
+            benchmark_count = sum(1 for row in rows if row.benchmark_return_same_period is not None or row.benchmark_return is not None)
+        with trace.phase("quality_loading"):
+            quality_count = sum(1 for row in rows if row.trade_quality_score is not None)
+        with trace.phase("prediction_loading"):
+            prediction_count = sum(1 for row in rows if row.thesis_id)
+        with trace.phase("serialization"):
+            serialized_rows = [self.serialize_trade(db, row) for row in rows]
+            summary = self.summary_for_game(db, game)
+        payload = {
             "status": "ok",
+            "snapshot_status": "miss",
             "game": serialize_game_header(game),
-            "summary": self.summary_for_game(db, game),
-            "rows": [self.serialize_trade(db, row) for row in rows],
+            "summary": summary,
+            "rows": serialized_rows,
             "total": total,
             "limit": limit,
             "offset": offset,
@@ -104,6 +142,27 @@ class TradeLedgerService:
             },
             "policy": TRANSPARENCY_POLICY,
         }
+        with trace.phase("json_generation"):
+            response_size = payload_size_bytes(payload)
+        trace.add(
+            snapshot_miss=True,
+            base_trade_query_count=2,
+            attribution_loading_queries=0,
+            evidence_loading_queries=0,
+            benchmark_loading_queries=0,
+            quality_loading_queries=0,
+            prediction_loading_queries=0,
+            attribution_rows=attribution_count,
+            evidence_rows=evidence_count,
+            benchmark_rows=benchmark_count,
+            quality_rows=quality_count,
+            prediction_links=prediction_count,
+            row_count=len(rows),
+            total_trades=total,
+            response_size_bytes=response_size,
+        )
+        payload["runtime_trace"] = trace.payload()
+        return payload
 
     def detail(self, db: Session, trade_id: int) -> dict:
         trade = db.get(TradingGameTrade, trade_id)
@@ -233,6 +292,33 @@ class TradeLedgerService:
             return db.get(TradingGame, game_id)
         return db.scalar(select(TradingGame).where(TradingGame.status == "active").order_by(desc(TradingGame.started_at)).limit(1)) or db.scalar(select(TradingGame).order_by(desc(TradingGame.started_at)).limit(1))
 
+    def _can_use_ledger_snapshot(
+        self,
+        *,
+        ticker: str | None,
+        setup_type: str | None,
+        outcome_label: str | None,
+        start_date: str | None,
+        end_date: str | None,
+        min_r: float | None,
+        max_r: float | None,
+        only_open: bool,
+        only_closed: bool,
+        sort_by: str,
+    ) -> bool:
+        return (
+            ticker is None
+            and setup_type is None
+            and outcome_label is None
+            and start_date is None
+            and end_date is None
+            and min_r is None
+            and max_r is None
+            and not only_open
+            and not only_closed
+            and sort_by == "created_at_desc"
+        )
+
     def serialize_trade(self, db: Session, trade: TradingGameTrade) -> dict:
         return {
             "trade_id": trade.id,
@@ -430,22 +516,61 @@ class TradeQualityEvaluator:
 
 
 class EquityCurveAnnotationService:
-    def annotated_equity(self, db: Session, game_id: int | None = None, limit: int = 800) -> dict:
+    def annotated_equity(
+        self,
+        db: Session,
+        game_id: int | None = None,
+        limit: int = 800,
+        *,
+        refresh: bool = False,
+        use_snapshot: bool = True,
+        include_trace: bool = False,
+    ) -> dict:
+        if use_snapshot:
+            from app.services.trading_game_runtime import TradingGameRuntimeSnapshotService
+
+            snapshot_payload = TradingGameRuntimeSnapshotService().equity_from_snapshot(db, game_id=game_id, limit=limit)
+            if snapshot_payload is not None:
+                return snapshot_payload
         game = TradeLedgerService().game(db, game_id)
         if not game:
             return {"status": "no_game", "equity_curve_points": [], "benchmark_curve_points": [], "annotations": []}
-        trades = db.scalars(select(TradingGameTrade).where(TradingGameTrade.game_id == game.id).order_by(TradingGameTrade.created_at)).all()
-        self.refresh(db, game, trades)
-        points = db.scalars(select(TradingGameEquityCurve).where(TradingGameEquityCurve.game_id == game.id).order_by(TradingGameEquityCurve.created_at).limit(limit)).all()
-        annotations = db.scalars(select(EquityCurveAnnotation).where(EquityCurveAnnotation.game_id == game.id).order_by(EquityCurveAnnotation.timestamp).limit(limit)).all()
-        return {
-            "status": "ok",
-            "game": serialize_game_header(game),
-            "equity_curve_points": [serialize_equity_point(row) for row in points],
-            "benchmark_curve_points": [{"timestamp": iso(row.equity_date or row.created_at), "value": row.benchmark_equity, "return": row.benchmark_return} for row in points],
-            "annotations": [serialize_annotation(row) for row in annotations],
-            "policy": "Markers connect equity movement to trade entries, exits, drawdowns, rule events and benchmark divergence when those events exist.",
-        }
+        from app.services.trading_game_runtime import RuntimeTrace, payload_size_bytes
+
+        trace = RuntimeTrace("equity_curve_annotated_live_read")
+        if refresh:
+            with trace.phase("annotation_refresh"):
+                trades = db.scalars(select(TradingGameTrade).where(TradingGameTrade.game_id == game.id).order_by(TradingGameTrade.created_at)).all()
+                self.refresh(db, game, trades)
+        with trace.phase("equity_points_loading"):
+            points = db.scalars(select(TradingGameEquityCurve).where(TradingGameEquityCurve.game_id == game.id).order_by(TradingGameEquityCurve.created_at).limit(limit)).all()
+        with trace.phase("annotations_loading"):
+            annotations = db.scalars(select(EquityCurveAnnotation).where(EquityCurveAnnotation.game_id == game.id).order_by(EquityCurveAnnotation.timestamp).limit(limit)).all()
+        with trace.phase("benchmark_loading"):
+            benchmark_curve_points = [{"timestamp": iso(row.equity_date or row.created_at), "value": row.benchmark_equity, "return": row.benchmark_return} for row in points]
+        with trace.phase("serialization"):
+            payload = {
+                "status": "ok",
+                "snapshot_status": "miss",
+                "game": serialize_game_header(game),
+                "equity_curve_points": [serialize_equity_point(row) for row in points],
+                "benchmark_curve_points": benchmark_curve_points,
+                "annotations": [serialize_annotation(row) for row in annotations],
+                "policy": "Markers connect equity movement to trade entries, exits, drawdowns, rule events and benchmark divergence when those events exist.",
+            }
+        with trace.phase("json_generation"):
+            size = payload_size_bytes(payload)
+        trace.add(
+            snapshot_miss=True,
+            equity_points_queries=1,
+            annotations_queries=1,
+            benchmark_loading_queries=0,
+            point_count=len(points),
+            annotation_count=len(annotations),
+            response_size_bytes=size,
+        )
+        payload["runtime_trace"] = trace.payload()
+        return payload
 
     def refresh(self, db: Session, game: TradingGame, trades: list[TradingGameTrade]) -> None:
         for trade in trades:

backend/app/services/trading_game.py

@@ -428,6 +428,7 @@ class TradingGameSimulator:
                 "simulation": simulation.simulation_payload,
                 "prediction_id": prediction.id if prediction else None,
                 "market_regime": prediction.market_regime if prediction else "unknown",
+                "feedback_loop": prediction_feedback_payload(prediction),
                 "guardrails": guardrails(),
             },
         )
@@ -624,6 +625,26 @@ def trade_reproducibility_score(simulation: ExecutionSimulation, prediction: His
     return round(clamp(score), 2)
 
 
+def prediction_feedback_payload(prediction: HistoricalPrediction | None) -> dict:
+    if not prediction:
+        return {
+            "status": "missing_prediction",
+            "policy": "No HistoricalPrediction was linked to this simulated trade.",
+        }
+    feedback = (prediction.prediction_payload or {}).get("feedback_loop") or {}
+    return {
+        "status": "ready",
+        "model_version_used": prediction.model_version_used or prediction.model_version or "base-static",
+        "weights_used": prediction.weights_used or feedback.get("weights_used") or {},
+        "confidence_adjustment": feedback.get("confidence_adjustment", 0.0),
+        "learning_memory_used": prediction.learning_memory_used or feedback.get("learning_memory_used") or {},
+        "strategy_memory_used": prediction.strategy_memory_used or feedback.get("strategy_memory_used") or {},
+        "research_priority_used": prediction.research_priority_used or feedback.get("research_priority_used") or {},
+        "learning_mode_metadata": feedback.get("learning_mode_metadata") or (prediction.prediction_payload or {}).get("learning_mode_metadata") or {},
+        "policy": "Paper trade payload records the prediction feedback loop metadata; it does not recalculate learning during trade rendering.",
+    }
+
+
 def decision_state_for(simulation: ExecutionSimulation, reproducibility: float) -> str:
     if reproducibility < 42:
         return "avoid"

backend/tests/test_learning_performance_architecture.py

@@ -9,8 +9,12 @@ from app.models import (
     DashboardSnapshot,
     LearningBenchmarkComparison,
     LearningRun,
+    LearningStrengthWeaknessMap,
     TradingCapitalCycle,
     TradingGame,
+    TradingGameTrade,
+    TradingIntelligenceMetric,
+    TradeLearningEvidence,
 )
 from app.services.dashboard_snapshots import DashboardSnapshotService
 from app.services.learning_summary import LearningSummaryService, build_truth_panel, safe_progress, summarize_benchmarks
@@ -41,8 +45,12 @@ def test_learning_summary_returns_partial_payload_without_precomputed_rows():
         DashboardSnapshot,
         LearningBenchmarkComparison,
         LearningRun,
+        LearningStrengthWeaknessMap,
         TradingCapitalCycle,
         TradingGame,
+        TradingGameTrade,
+        TradingIntelligenceMetric,
+        TradeLearningEvidence,
     ]:
         model.__table__.create(bind=engine)
 
@@ -51,6 +59,9 @@ def test_learning_summary_returns_partial_payload_without_precomputed_rows():
 
     assert payload["status"] == "initializing"
     assert "trading_power_score" in payload["missing_sections"]
+    assert "trading_intelligence_metrics" in payload["missing_sections"]
+    assert payload["backend_training_status"]["frontend_policy"] == "read_only_snapshot_observer"
+    assert "snapshots" in payload
     assert payload["truth_panel"][0].startswith("Not enough precomputed evidence")
 
 
@@ -74,9 +85,69 @@ def test_learning_page_keeps_heavy_work_out_of_initial_render():
     page = Path(__file__).resolve().parents[2] / "frontend" / "app" / "learning" / "page.tsx"
     text = page.read_text()
 
-    assert "setTimeout(loadVisibleTables" not in text
-    assert "IntersectionObserver" in text
+    assert text.strip() == 'export { default } from "../training-ground/page";'
+
+    training_page = Path(__file__).resolve().parents[2] / "frontend" / "app" / "training-ground" / "page.tsx"
+    training_text = training_page.read_text()
+    initial_effect = training_text.split("useEffect(() => {", 1)[1].split("}, []);", 1)[0]
+
+    assert "api.traderTrainingGround()" in initial_effect
+    assert initial_effect.count("api.") == 1
+    assert "api.tradingGameLedger" not in training_text
+    assert "api.alphaRecoveryDashboard()" not in training_text
+    assert "api.metaCognitionSummary()" not in training_text
     assert "recalculateLearningTradingPower" not in text
     assert "recalculateDecisionSuperiority" not in text
     assert "recalculateBusinessQuality" not in text
     assert "recalculatePortfolioIntelligence" not in text
+    assert "recalculateAlphaRecovery" not in text
+    assert "metaCognitionRecalculate" not in text
+
+
+def test_deep_diagnostics_uses_human_readable_renderer_not_raw_json_dump():
+    page = Path(__file__).resolve().parents[2] / "frontend" / "components" / "DiagnosticPanelRenderer.tsx"
+    text = page.read_text()
+
+    assert "compactPreview" not in text
+    assert "JSON.stringify(compactPreview" not in text
+    assert "DiagnosticPanelRenderer" in text
+    assert "Show raw JSON" in text
+
+
+def test_diagnostic_panel_renderer_hides_raw_json_by_default():
+    renderer = Path(__file__).resolve().parents[2] / "frontend" / "components" / "DiagnosticPanelRenderer.tsx"
+    text = renderer.read_text()
+
+    assert "export function DiagnosticPanelRenderer" in text
+    assert "function ReliabilityByRegimeRenderer" in text
+    assert "function EnsembleStatusRenderer" in text
+    assert "export function SampleSizeWarning" in text
+    assert "export function WeightDistributionTable" in text
+    assert "Show raw JSON" in text
+    assert "Hide raw JSON" in text
+    assert "open && <pre" in text
+
+
+def test_diagnostic_renderer_exposes_evidence_warnings_and_tables():
+    renderer = Path(__file__).resolve().parents[2] / "frontend" / "components" / "DiagnosticPanelRenderer.tsx"
+    text = renderer.read_text()
+
+    assert "Small sample size: treat as weak evidence." in text
+    assert "Reliability is promising but not durable without more samples." in text
+    assert "Negative average return with positive excess return needs review." in text
+    assert "DiagnosticTable" in text
+    assert "Engine" in text
+    assert "Hit Rate" in text
+    assert "Excess vs Benchmark" in text
+    assert "Confidence Penalty" in text
+
+
+def test_frontend_blocks_heavy_learning_post_during_initial_render():
+    api_file = Path(__file__).resolve().parents[2] / "frontend" / "lib" / "api.ts"
+    text = api_file.read_text()
+
+    assert "blocked_heavy_frontend_recalculation" in text
+    assert "LEARNING_INITIAL_RENDER_GUARD_MS" in text
+    assert '"/api/capital-allocation/recalculate"' in text
+    assert '"/api/alpha-recovery/recalculate"' in text
+    assert '"/api/meta-cognition/recalculate"' in text

backend/tests/test_performance_diagnostics.py

@@ -35,9 +35,11 @@ def test_performance_recorder_builds_diagnostics():
 def test_performance_recorder_exposes_learning_page_load_diagnostics():
     recorder = PerformanceRecorder()
     now = datetime.utcnow()
-    recorder.record_frontend_widget("frontend.api.GET./api/learning-intelligence/summary", 120.0, {"status": "ok", "source": "fetchBlum"})
-    recorder.record_frontend_widget("frontend.api.GET./api/trading-game/status", 0.4, {"status": "cache_hit", "source": "fetchBlum"})
-    recorder.record_frontend_widget("frontend.api.GET./api/trading-game/status", 0.2, {"status": "deduped", "source": "fetchBlum"})
+    learning_meta = {"source": "fetchBlum", "route": "/learning", "initial_learning_window": True}
+    recorder.record_frontend_widget("frontend.api.GET./api/learning-intelligence/summary", 120.0, {"status": "ok", **learning_meta})
+    recorder.record_frontend_widget("frontend.api.GET./api/trading-game/status", 0.4, {"status": "cache_hit", **learning_meta})
+    recorder.record_frontend_widget("frontend.api.GET./api/trading-game/status", 0.2, {"status": "deduped", **learning_meta})
+    recorder.record_frontend_widget("frontend.api.GET./dashboard/overview", 800.0, {"status": "ok", "source": "fetchBlum", "route": "/", "initial_learning_window": False})
     recorder.record_dashboard_widget(
         "performance.heavy_recalculation_triggered_during_page_load",
         3400.0,
@@ -49,6 +51,7 @@ def test_performance_recorder_exposes_learning_page_load_diagnostics():
     summary = payload["initial_learning_page_load"]
 
     assert summary["frontend_request_count"] == 3
+    assert summary["unscoped_frontend_request_count"] == 4
     assert summary["cache_hit_count"] == 1
     assert summary["duplicate_request_count"] == 1
     assert summary["heavy_post_calls_during_page_load"][0]["path"] == "/api/business-quality/recalculate"

frontend/.next/BUILD_ID

@@ -0,0 +1 @@
+wZUVLKXl_CiOxUlt_FdXC

frontend/.next/app-build-manifest.json

@@ -0,0 +1,199 @@
+{
+  "pages": {
+    "/_not-found/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/app/_not-found/page-8194a34fe9d5ebe2.js"
+    ],
+    "/layout": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/css/02bd12e03544ea91.css",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/app/layout-c302ea2b37a37766.js"
+    ],
+    "/backtest/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/app/backtest/page-60b494c3f5caeab7.js"
+    ],
+    "/chart-analyst/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/75-8c48549bc3f12b00.js",
+      "static/chunks/app/chart-analyst/page-422122938e79d615.js"
+    ],
+    "/chat/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/145-04bdfe555d73caf0.js",
+      "static/chunks/app/chat/page-01bb723eea532598.js"
+    ],
+    "/chatbot/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/145-04bdfe555d73caf0.js",
+      "static/chunks/app/chatbot/page-ec86bf53c052af5b.js"
+    ],
+    "/learning/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/app/learning/page-fb9d9a3de58b413d.js"
+    ],
+    "/methodology/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/app/methodology/page-f0ef96f8ef7d3450.js"
+    ],
+    "/ipo-radar/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/app/ipo-radar/page-37bfbd97573d6050.js"
+    ],
+    "/market-brain/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/app/market-brain/page-a3c75d13701833bc.js"
+    ],
+    "/narratives/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/433-89ff72e62f774508.js",
+      "static/chunks/app/narratives/page-f858506c5d5d372d.js"
+    ],
+    "/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/96-ce8c57cd15d50941.js",
+      "static/chunks/app/page-d0db9a93fb4af9a5.js"
+    ],
+    "/etf-radar/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/app/etf-radar/page-cb504f6343d399db.js"
+    ],
+    "/performance/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/app/performance/page-72d89cf8fa4bd0b1.js"
+    ],
+    "/signal-lab/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/app/signal-lab/page-a2f85a5c0d0847cd.js"
+    ],
+    "/sniper/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/app/sniper/page-66e545665c88da6b.js"
+    ],
+    "/stock-radar/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/app/stock-radar/page-6e7f483858d9a39e.js"
+    ],
+    "/themes/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/433-89ff72e62f774508.js",
+      "static/chunks/app/themes/page-9af78316fbb208f8.js"
+    ],
+    "/dashboard/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/96-ce8c57cd15d50941.js",
+      "static/chunks/app/dashboard/page-d9577bde4b3301c9.js"
+    ],
+    "/assets/[ticker]/page": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/2200cc46-bb2e82a2a422da49.js",
+      "static/chunks/945-dfa5efbc7dfb2860.js",
+      "static/chunks/main-app-80b65e8c4f383000.js",
+      "static/chunks/183-66f1efcf12b29a02.js",
+      "static/chunks/651-5689242ae9b0ffc6.js",
+      "static/chunks/908-fe3c8e03f00ace4e.js",
+      "static/chunks/75-8c48549bc3f12b00.js",
+      "static/chunks/app/assets/[ticker]/page-3687f8c7fa1ef7c8.js"
+    ]
+  }
+}

frontend/.next/app-path-routes-manifest.json

@@ -0,0 +1 @@
+{"/_not-found/page":"/_not-found","/backtest/page":"/backtest","/chart-analyst/page":"/chart-analyst","/chat/page":"/chat","/chatbot/page":"/chatbot","/learning/page":"/learning","/methodology/page":"/methodology","/ipo-radar/page":"/ipo-radar","/market-brain/page":"/market-brain","/narratives/page":"/narratives","/page":"/","/etf-radar/page":"/etf-radar","/performance/page":"/performance","/signal-lab/page":"/signal-lab","/sniper/page":"/sniper","/stock-radar/page":"/stock-radar","/themes/page":"/themes","/dashboard/page":"/dashboard","/assets/[ticker]/page":"/assets/[ticker]"}

frontend/.next/build-manifest.json

@@ -0,0 +1,32 @@
+{
+  "polyfillFiles": [
+    "static/chunks/polyfills-42372ed130431b0a.js"
+  ],
+  "devFiles": [],
+  "ampDevFiles": [],
+  "lowPriorityFiles": [
+    "static/wZUVLKXl_CiOxUlt_FdXC/_buildManifest.js",
+    "static/wZUVLKXl_CiOxUlt_FdXC/_ssgManifest.js"
+  ],
+  "rootMainFiles": [
+    "static/chunks/webpack-aeb5c49f88887156.js",
+    "static/chunks/2200cc46-bb2e82a2a422da49.js",
+    "static/chunks/945-dfa5efbc7dfb2860.js",
+    "static/chunks/main-app-80b65e8c4f383000.js"
+  ],
+  "pages": {
+    "/_app": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/framework-6e06c675866dc992.js",
+      "static/chunks/main-d4dac7885e92ed7d.js",
+      "static/chunks/pages/_app-0c3037849002a4aa.js"
+    ],
+    "/_error": [
+      "static/chunks/webpack-aeb5c49f88887156.js",
+      "static/chunks/framework-6e06c675866dc992.js",
+      "static/chunks/main-d4dac7885e92ed7d.js",
+      "static/chunks/pages/_error-a647cd2c75dc4dc7.js"
+    ]
+  },
+  "ampFirstPages": []
+}

frontend/.next/cache/webpack/client-production/0.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64c20a49f6c3005f093ae1cf65d33529c0a59bbd35ba5ad023bca0d3cb434afa
+size 118293334

frontend/.next/cache/webpack/client-production/1.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e03aa28adc6a768648f515402a900fe14c6752847d7d964a1929cb3004a9b6c
+size 868911

frontend/.next/cache/webpack/client-production/10.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71fce4cef0b4b1f91d826885a2588f7734eb1eed4dd69e70ba1700cac0783b0a
+size 8511085

frontend/.next/cache/webpack/client-production/11.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d59a7fd7a8c5256381e9719bc1e090967de13243d63add7c753a130867cc3927
+size 1294746

frontend/.next/cache/webpack/client-production/12.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d140048b49b2aa71f6dcca9123f6e4fde88898eef94c98d37246bf2188adc8e
+size 3857837

frontend/.next/cache/webpack/client-production/13.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6e722d889d1adf3361080549c4442a68aa9b575dbdb84465f319c8f06f86c74
+size 9983794

frontend/.next/cache/webpack/client-production/2.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bda4f125628c87fda9af6581649974e2231693f2fbb1a0989920194d4b3daa6
+size 1249964

frontend/.next/cache/webpack/client-production/6.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57c5d14b0f12b9dd3ec358cf64e42e813c43ef4e62aedae8f38b4e6372cbae52
+size 6614985

frontend/.next/cache/webpack/client-production/7.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aaaa8c24f9ecde0e1428c5de84f15d7950323267d01fa36f5fc56859043395c2
+size 108202

frontend/.next/cache/webpack/client-production/8.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2944bcbd152b577f7950f35c27cfbdd36f4d52134dff689a8b78f17ad4104cce
+size 1112198

frontend/.next/cache/webpack/client-production/9.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1e183c17cb5b8d257c1dbe1dcc04e84ce501d2d1a7ca7b66d2e0125327079e4
+size 1062275

frontend/.next/cache/webpack/client-production/index.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:943c09107fb7bebabb49c02a0e84e94e938d4a94071f3c7746b3bab30ce503ba
+size 5360825

frontend/.next/cache/webpack/client-production/index.pack.old

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b801d39452a502fce5ff9ea86dc9f12dd0c7acf45995880e368d15d8a2aa687b
+size 5359015

frontend/.next/cache/webpack/server-production/0.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbc928f3fe56a2511ce7ada8c42eabadf0939456e4e986640298317ff1701e12
+size 19157446

frontend/.next/cache/webpack/server-production/1.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6e9570f82bbe9b380b8f3fb99a5696f151db001f6f69084595c8f908f9918e5
+size 1227512

frontend/.next/cache/webpack/server-production/10.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b562e5e3f5cb6d15b73a0ab664a9282aae91e6e728a8147a9ff433aca27c7aa7
+size 484820

frontend/.next/cache/webpack/server-production/2.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:565d9a97b0e7643692ad87c36fe861e2bb92e0f9562b73008fdd7449c3d8d306
+size 1378163

frontend/.next/cache/webpack/server-production/3.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92873e01aee48539364ba76c413082cf9ac240cad900f375e6237cc1ff8ab900
+size 1467753

frontend/.next/cache/webpack/server-production/4.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:80f2429d58fd2de77209e8d1d9a1411721a9a394bd4ea35456d453ecd82941b1
+size 11907910

frontend/.next/cache/webpack/server-production/5.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee5ee084edc5d07c06db017a493f328ff249612ec351a5aae1f25edcbcbe8aea
+size 1497242

frontend/.next/cache/webpack/server-production/6.pack

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09db955bc8f95822127420242b6a8baab0b2bb169b92c1d505db64cd1d770e66
+size 6031704