Deploy BLUM v1.0.0 alpha operating system

CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## v1.0.0 | alpha-operating-system
+
+- Promoted runtime identity from `market-sniper-engine-v1` to `alpha-operating-system`.
+- Added Trading Game readiness diagnostics so the Learning page explains whether evidence is ready, building, stale, insufficient, failed or data-quality blocked.
+- Added compact brain command endpoints for Command Center capability status, learning evolution, benchmark truth and copy readiness.
+- Added Alpha Readiness, Edge Map and Alpha Gates read-only services.
+- Added paper-copy persistent models and paper-copy operating endpoints.
+- Updated Learning Trading Game tab to load readiness first and avoid permanent generic loading.
+- Updated Copy Trading page to read the paper-copy operating summary.
+- Preserved existing Trading Game, Learning Loop, Market Sniper, Decision Intelligence and snapshot-first runtime behavior.
+

MIGRATION_v1.0.0.md

@@ -0,0 +1,23 @@
+# BLUM v1.0.0 Migration Notes
+
+Apply Alembic revision:
+
+```bash
+cd backend
+alembic upgrade head
+```
+
+New durable tables:
+
+- `trading_game_readiness_snapshots`
+- `alpha_readiness_snapshots`
+- `alpha_gate_snapshots`
+- `edge_map_snapshots`
+- `paper_copy_strategies`
+- `paper_copy_portfolios`
+- `paper_copy_orders`
+- `paper_copy_positions`
+- `paper_copy_portfolio_snapshots`
+
+The new endpoints can work with empty tables and return `INSUFFICIENT_EVIDENCE`, `WAITING_FOR_SOURCE_DATA` or candidate-only states. This is intentional: the UI should observe backend progress, not force training or recalculation during render.
+

README.md

@@ -1534,26 +1534,62 @@ The Space serves the FastAPI backend and the exported Next.js frontend on port `
 
 Backtesting is included for research validation only. It reports historical hit rate, average forward return over 5D/20D/60D, max adverse excursion, max favorable excursion and false positives. It does not predict or guarantee future returns.
 
+## BLUM v1.0.0 Alpha Operating System
+
+`v1.0.0 | alpha-operating-system` turns BLUM's existing learning, trading, benchmark and meta-cognition layers into a clearer operating layer:
+
+- `GET /brain/command-summary` returns the compact Command Center brain state.
+- `GET /brain/capabilities` exposes capability rows for trading, decision, business, portfolio, alpha and paper-copy readiness.
+- `GET /brain/evolution` reads stored Trading Power snapshots.
+- `GET /trading-game/readiness` explains why Trading Game evidence is ready, building, stale, insufficient, failed or data-quality blocked.
+- `GET /alpha/readiness`, `GET /alpha/edge-map` and `GET /alpha/gates` expose strict alpha-readiness evidence without running recalculation.
+- `GET /paper-copy/summary`, `GET /paper-copy/strategies`, `GET /paper-copy/positions`, `GET /paper-copy/readiness` and `GET /paper-copy/portfolio/{id}` expose paper-only copy intelligence state.
+
+The release preserves the snapshot-first runtime architecture: Command, Learning and Copy surfaces read lightweight stored evidence and do not trigger training, recalculation, broker activity or heavy Trading Game rebuilds during render.
+
+## Trading Game Readiness
+
+The Learning page now asks `GET /api/trading-game/readiness` before loading equity, ledger and benchmark details. The UI must never remain in generic loading. It shows one of:
+
+- `READY`
+- `BUILDING`
+- `WAITING_FOR_SOURCE_DATA`
+- `STALE_BUT_USABLE`
+- `FAILED`
+- `INSUFFICIENT_EVIDENCE`
+- `DATA_QUALITY_BLOCKED`
+
+Readiness includes source decision counts, source trade counts, eligible trade counts, ledger/equity/benchmark snapshot status, worker status, blocker, next required action, evidence grade and methodology version. It is diagnostic evidence, not a trading signal.
+
 ## Command Brain Level
 
-The Command Center includes a lightweight `BLUM Brain Level` panel powered by `GET /api/learning-intelligence/summary`. It is snapshot-first and shows:
+The Command Center includes a lightweight `BLUM Brain Level` panel powered primarily by `GET /brain/command-summary`. It is snapshot-first and shows:
 
 - current learning status and latest run timestamp;
 - Trading Power / evidence classification when precomputed;
 - Trading Game capital progress, win rate and expectancy R;
 - benchmark pressure versus stored market benchmarks;
-- latest weakness, latest lesson and next learning focus.
+- latest weakness, latest lesson and next learning focus;
+- alpha readiness and paper-copy readiness.
 
 This panel does not run training, recalculation or heavy diagnostics. It is intended to answer quickly whether BLUM's learning evidence is improving, deteriorating or still insufficient.
 
-## Copy Trading Intelligence
+## Paper Copy Trading Intelligence
 
-`/copy-trading` is a paper-only intelligence surface for conditional mirror plans. The backend exposes:
+`/copy-trading` is a paper-only intelligence surface for conditional mirror plans. The backend keeps the original compatibility endpoints:
 
 - `GET /api/copy-trading/status`
 - `GET /api/copy-trading/candidates`
 - `GET /api/copy-trading/dashboard`
 
+and adds the v1.0 paper-copy operating endpoints:
+
+- `GET /paper-copy/summary`
+- `GET /paper-copy/readiness`
+- `GET /paper-copy/strategies`
+- `GET /paper-copy/positions`
+- `GET /paper-copy/portfolio/{portfolio_id}`
+
 The service reads persisted `TradePlan`, `SniperScore` and Trading Game evidence. It does not recalculate signals, connect to brokers, place orders or claim performance. A candidate is downgraded when it is missing entry trigger, invalidation or target/risk-plan evidence.
 
 The output is designed to answer:
@@ -1563,7 +1599,7 @@ The output is designed to answer:
 - which setups are blocked by risk-plan gaps or weak actionability;
 - what BLUM has learned from recent paper trades tied to the same ticker.
 
-Copy Trading Intelligence is a decision-audit layer, not an execution system.
+Paper Copy Trading Intelligence is a decision-audit layer and paper portfolio research surface, not an execution system. It never connects to a broker and never emits direct financial advice.
 
 ## Limitations
 

RELEASE_NOTES_v1.0.0.md

@@ -0,0 +1,24 @@
+# BLUM v1.0.0 Release Notes
+
+Release identity: `v1.0.0 | alpha-operating-system`
+
+## What Changed
+
+- BLUM now exposes a compact Alpha Operating System layer around the existing runtime.
+- Trading Game evidence has a readiness state before the UI tries to load heavy evidence.
+- Command Center can show the level of BLUM's brain through capability, benchmark, learning and copy-readiness summaries.
+- Alpha Readiness measures whether stored evidence is mature enough to discuss possible edge.
+- Alpha Gates block unsupported claims when samples, benchmarks or live paper evidence are missing.
+- Paper Copy Trading is now modeled as a paper-only operating layer with durable schema support.
+
+## What Did Not Change
+
+- No broker integration was added.
+- No real trades are executed.
+- Existing Trading Game, Learning Loop, Sniper, Decision, Portfolio, Alpha Recovery and Meta-Cognition logic remain backward compatible.
+- GET endpoints remain read-only and do not run heavy recalculation.
+
+## Validation Standard
+
+Performance and alpha claims are still evidence-bound. BLUM must say insufficient evidence when samples, benchmark comparisons or live paper validation are not mature.
+

backend/alembic/versions/0026_alpha_operating_system.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+
+revision = "0026_alpha_operating_system"
+down_revision = "0025_tg_runtime_snap"
+branch_labels = None
+depends_on = None
+
+
+json_type = postgresql.JSONB(astext_type=sa.Text())
+
+
+def create_index(table: str, columns: list[str], suffix: str | None = None) -> None:
+    name = f"ix_{table}_{suffix or '_'.join(columns)}"
+    if len(name) > 63:
+        name = f"ix_{table[:30]}_{(suffix or '_'.join(columns))[:22]}"
+    op.create_index(name, table, columns)
+
+
+def upgrade() -> None:
+    op.create_table(
+        "trading_game_readiness_snapshots",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("game_id", sa.Integer(), nullable=True),
+        sa.Column("status", sa.String(length=80), nullable=False, server_default="WAITING_FOR_SOURCE_DATA"),
+        sa.Column("evidence_grade", sa.String(length=80), nullable=False, server_default="insufficient"),
+        sa.Column("blocker", sa.Text(), nullable=False, server_default=""),
+        sa.Column("next_required_action", sa.Text(), nullable=False, server_default=""),
+        sa.Column("payload_json", json_type, nullable=True),
+        sa.Column("warnings_json", json_type, nullable=True),
+        sa.Column("methodology_version", sa.String(length=80), nullable=False, server_default="trading-game-readiness-v1"),
+        sa.Column("generated_at", sa.DateTime(), nullable=False),
+        sa.Column("expires_at", sa.DateTime(), nullable=True),
+        sa.Column("is_stale", sa.Boolean(), nullable=False, server_default=sa.false()),
+        sa.ForeignKeyConstraint(["game_id"], ["trading_games.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    create_index("trading_game_readiness_snapshots", ["generated_at"], "generated")
+    create_index("trading_game_readiness_snapshots", ["status", "evidence_grade"], "status_grade")
+    create_index("trading_game_readiness_snapshots", ["game_id", "generated_at"], "game_generated")
+
+    op.create_table(
+        "alpha_readiness_snapshots",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("status", sa.String(length=80), nullable=False, server_default="INSUFFICIENT_EVIDENCE"),
+        sa.Column("alpha_readiness_score", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("evidence_grade", sa.String(length=80), nullable=False, server_default="insufficient"),
+        sa.Column("classification", sa.String(length=120), nullable=False, server_default="not_ready"),
+        sa.Column("payload_json", json_type, nullable=True),
+        sa.Column("warnings_json", json_type, nullable=True),
+        sa.Column("methodology_version", sa.String(length=80), nullable=False, server_default="alpha-readiness-v1"),
+        sa.Column("generated_at", sa.DateTime(), nullable=False),
+        sa.Column("expires_at", sa.DateTime(), nullable=True),
+        sa.Column("is_stale", sa.Boolean(), nullable=False, server_default=sa.false()),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    create_index("alpha_readiness_snapshots", ["generated_at"], "generated")
+    create_index("alpha_readiness_snapshots", ["alpha_readiness_score", "evidence_grade"], "score")
+
+    op.create_table(
+        "alpha_gate_snapshots",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("gate_name", sa.String(length=120), nullable=False),
+        sa.Column("status", sa.String(length=80), nullable=False, server_default="blocked"),
+        sa.Column("score", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("payload_json", json_type, nullable=True),
+        sa.Column("warnings_json", json_type, nullable=True),
+        sa.Column("generated_at", sa.DateTime(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    create_index("alpha_gate_snapshots", ["generated_at"], "generated")
+    create_index("alpha_gate_snapshots", ["gate_name", "status"], "status")
+
+    op.create_table(
+        "edge_map_snapshots",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("scope", sa.String(length=120), nullable=False, server_default="global"),
+        sa.Column("evidence_grade", sa.String(length=80), nullable=False, server_default="insufficient"),
+        sa.Column("payload_json", json_type, nullable=True),
+        sa.Column("warnings_json", json_type, nullable=True),
+        sa.Column("generated_at", sa.DateTime(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    create_index("edge_map_snapshots", ["generated_at"], "generated")
+    create_index("edge_map_snapshots", ["scope", "evidence_grade"], "scope")
+
+    op.create_table(
+        "paper_copy_strategies",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("strategy_id", sa.String(length=100), nullable=False),
+        sa.Column("name", sa.String(length=180), nullable=False, server_default="BLUM Paper Copy Strategy"),
+        sa.Column("status", sa.String(length=80), nullable=False, server_default="paper_only"),
+        sa.Column("strategy_type", sa.String(length=120), nullable=False, server_default="conditional_copy_watchlist"),
+        sa.Column("copyability_score", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("risk_budget_percent", sa.Float(), nullable=False, server_default="1"),
+        sa.Column("max_open_positions", sa.Integer(), nullable=False, server_default="5"),
+        sa.Column("rules_json", json_type, nullable=True),
+        sa.Column("evidence_json", json_type, nullable=True),
+        sa.Column("warnings_json", json_type, nullable=True),
+        sa.Column("paper_only", sa.Boolean(), nullable=False, server_default=sa.true()),
+        sa.Column("no_broker_execution", sa.Boolean(), nullable=False, server_default=sa.true()),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("strategy_id"),
+    )
+    create_index("paper_copy_strategies", ["strategy_id"], "strategy_id")
+    create_index("paper_copy_strategies", ["status", "created_at"], "status_created")
+    create_index("paper_copy_strategies", ["copyability_score"], "score")
+
+    op.create_table(
+        "paper_copy_portfolios",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("portfolio_id", sa.String(length=100), nullable=False),
+        sa.Column("strategy_id", sa.Integer(), nullable=True),
+        sa.Column("status", sa.String(length=80), nullable=False, server_default="paper_active"),
+        sa.Column("starting_capital", sa.Float(), nullable=False, server_default="100"),
+        sa.Column("current_capital", sa.Float(), nullable=False, server_default="100"),
+        sa.Column("cash", sa.Float(), nullable=False, server_default="100"),
+        sa.Column("exposure", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("realized_pnl", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("unrealized_pnl", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("benchmark_ticker", sa.String(length=32), nullable=False, server_default="SPY"),
+        sa.Column("risk_state", sa.String(length=80), nullable=False, server_default="conservative"),
+        sa.Column("evidence_json", json_type, nullable=True),
+        sa.Column("warnings_json", json_type, nullable=True),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(), nullable=False),
+        sa.ForeignKeyConstraint(["strategy_id"], ["paper_copy_strategies.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("portfolio_id"),
+    )
+    create_index("paper_copy_portfolios", ["portfolio_id"], "portfolio_id")
+    create_index("paper_copy_portfolios", ["status", "updated_at"], "status_updated")
+    create_index("paper_copy_portfolios", ["strategy_id"], "strategy")
+
+    op.create_table(
+        "paper_copy_orders",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("portfolio_id", sa.Integer(), nullable=True),
+        sa.Column("strategy_id", sa.Integer(), nullable=True),
+        sa.Column("source_trade_plan_id", sa.Integer(), nullable=True),
+        sa.Column("ticker", sa.String(length=32), nullable=False),
+        sa.Column("side", sa.String(length=40), nullable=False, server_default="paper_buy"),
+        sa.Column("status", sa.String(length=80), nullable=False, server_default="planned"),
+        sa.Column("order_type", sa.String(length=80), nullable=False, server_default="conditional_paper"),
+        sa.Column("trigger_condition", sa.Text(), nullable=False, server_default=""),
+        sa.Column("paper_price", sa.Float(), nullable=True),
+        sa.Column("paper_quantity", sa.Float(), nullable=True),
+        sa.Column("risk_amount", sa.Float(), nullable=True),
+        sa.Column("invalidation_level", sa.Float(), nullable=True),
+        sa.Column("target_1", sa.Float(), nullable=True),
+        sa.Column("target_2", sa.Float(), nullable=True),
+        sa.Column("evidence_json", json_type, nullable=True),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.ForeignKeyConstraint(["portfolio_id"], ["paper_copy_portfolios.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(["strategy_id"], ["paper_copy_strategies.id"], ondelete="SET NULL"),
+        sa.ForeignKeyConstraint(["source_trade_plan_id"], ["trade_plans.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    create_index("paper_copy_orders", ["portfolio_id", "created_at"], "portfolio_created")
+    create_index("paper_copy_orders", ["ticker", "status"], "ticker_status")
+    create_index("paper_copy_orders", ["strategy_id"], "strategy")
+    create_index("paper_copy_orders", ["source_trade_plan_id"], "source_plan")
+
+    op.create_table(
+        "paper_copy_positions",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("portfolio_id", sa.Integer(), nullable=True),
+        sa.Column("strategy_id", sa.Integer(), nullable=True),
+        sa.Column("source_order_id", sa.Integer(), nullable=True),
+        sa.Column("ticker", sa.String(length=32), nullable=False),
+        sa.Column("status", sa.String(length=80), nullable=False, server_default="open"),
+        sa.Column("quantity", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("entry_price", sa.Float(), nullable=True),
+        sa.Column("current_price", sa.Float(), nullable=True),
+        sa.Column("market_value", sa.Float(), nullable=True),
+        sa.Column("unrealized_pnl", sa.Float(), nullable=True),
+        sa.Column("realized_pnl", sa.Float(), nullable=True),
+        sa.Column("invalidation_level", sa.Float(), nullable=True),
+        sa.Column("target_1", sa.Float(), nullable=True),
+        sa.Column("target_2", sa.Float(), nullable=True),
+        sa.Column("opened_at", sa.DateTime(), nullable=True),
+        sa.Column("closed_at", sa.DateTime(), nullable=True),
+        sa.Column("evidence_json", json_type, nullable=True),
+        sa.ForeignKeyConstraint(["portfolio_id"], ["paper_copy_portfolios.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(["strategy_id"], ["paper_copy_strategies.id"], ondelete="SET NULL"),
+        sa.ForeignKeyConstraint(["source_order_id"], ["paper_copy_orders.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    create_index("paper_copy_positions", ["portfolio_id", "status"], "portfolio_status")
+    create_index("paper_copy_positions", ["ticker", "opened_at"], "ticker_opened")
+    create_index("paper_copy_positions", ["strategy_id"], "strategy")
+    create_index("paper_copy_positions", ["source_order_id"], "source_order")
+
+    op.create_table(
+        "paper_copy_portfolio_snapshots",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("portfolio_id", sa.Integer(), nullable=True),
+        sa.Column("strategy_id", sa.Integer(), nullable=True),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("capital", sa.Float(), nullable=True),
+        sa.Column("exposure", sa.Float(), nullable=True),
+        sa.Column("open_positions", sa.Integer(), nullable=False, server_default="0"),
+        sa.Column("pending_orders", sa.Integer(), nullable=False, server_default="0"),
+        sa.Column("copyability_score", sa.Float(), nullable=False, server_default="0"),
+        sa.Column("evidence_grade", sa.String(length=80), nullable=False, server_default="insufficient"),
+        sa.Column("payload_json", json_type, nullable=True),
+        sa.Column("warnings_json", json_type, nullable=True),
+        sa.ForeignKeyConstraint(["portfolio_id"], ["paper_copy_portfolios.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(["strategy_id"], ["paper_copy_strategies.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    create_index("paper_copy_portfolio_snapshots", ["portfolio_id", "created_at"], "portfolio_created")
+    create_index("paper_copy_portfolio_snapshots", ["copyability_score", "evidence_grade"], "score")
+    create_index("paper_copy_portfolio_snapshots", ["strategy_id"], "strategy")
+
+
+def downgrade() -> None:
+    op.drop_table("paper_copy_portfolio_snapshots")
+    op.drop_table("paper_copy_positions")
+    op.drop_table("paper_copy_orders")
+    op.drop_table("paper_copy_portfolios")
+    op.drop_table("paper_copy_strategies")
+    op.drop_table("edge_map_snapshots")
+    op.drop_table("alpha_gate_snapshots")
+    op.drop_table("alpha_readiness_snapshots")
+    op.drop_table("trading_game_readiness_snapshots")

backend/app/api/routes.py

@@ -143,6 +143,15 @@ from app.services.alpha_recovery import (
     BenchmarkMethodologyValidator,
     MissedWinnersEngine,
 )
+from app.services.alpha_operating_system import (
+    AlphaGateService,
+    AlphaReadinessEngine,
+    BrainCommandSummaryService,
+    EdgeMapService,
+    PaperCopyTradingService,
+    TradingGameReadinessService,
+    V1_FEATURE_SET,
+)
 from app.services.autonomous_engine import AutonomousResearchEngine, latest_autonomous_status
 from app.services.blum_financial_model import (
     build_training_dataset,
@@ -324,6 +333,21 @@ def brain_runtime_state(db: Session = Depends(get_db)) -> dict:
     return CentralBrainRuntime().state(db)
 
 
+@router.get("/brain/command-summary")
+def brain_command_summary(db: Session = Depends(get_db)) -> dict:
+    return BrainCommandSummaryService().summary(db)
+
+
+@router.get("/brain/capabilities")
+def brain_capabilities(db: Session = Depends(get_db)) -> dict:
+    return BrainCommandSummaryService().capabilities(db)
+
+
+@router.get("/brain/evolution")
+def brain_evolution(db: Session = Depends(get_db)) -> dict:
+    return BrainCommandSummaryService().evolution(db)
+
+
 @router.get("/snapshots/health")
 def snapshots_health(db: Session = Depends(get_db)) -> dict:
     return SnapshotWatchdogService().health(db, queue_rebuild=False)
@@ -390,7 +414,7 @@ def system_status(db: Session = Depends(get_db)) -> dict:
     return {
         "service": "blum-ai-financial-intelligence",
         "app_version": settings.app_version,
-        "feature_set": "market-sniper-engine-v1",
+        "feature_set": V1_FEATURE_SET,
         "environment": settings.environment,
         "generated_at": datetime.utcnow().isoformat(),
         "hugging_face": {
@@ -627,7 +651,7 @@ def system_status(db: Session = Depends(get_db)) -> dict:
             "Hugging Face serves the previous image until the Docker build finishes successfully.",
             "The finance-domain 7B model is disabled by default unless BLUM_ENABLE_FINANCIAL_BRAIN_MODEL=true.",
             "Existing snapshots are refreshed by the autonomous engine after a successful deployment.",
-            "Browser cache can keep old static Next.js chunks; hard refresh if app_version is not 0.20.0.",
+            "Browser cache can keep old static Next.js chunks; hard refresh if app_version is not 1.0.0.",
         ],
     }
 
@@ -815,6 +839,12 @@ def trading_game_status(db: Session = Depends(get_db)) -> dict:
     return TradingGameSimulator().status(db)
 
 
+@router.get("/trading-game/readiness")
+@router.get("/api/trading-game/readiness")
+def trading_game_readiness(db: Session = Depends(get_db)) -> dict:
+    return TradingGameReadinessService().readiness(db)
+
+
 @router.get("/api/copy-trading/status")
 def copy_trading_status(db: Session = Depends(get_db)) -> dict:
     return CopyTradingIntelligenceService().status(db)
@@ -830,6 +860,54 @@ def copy_trading_dashboard(limit: int = Query(default=25, ge=1, le=100), db: Ses
     return CopyTradingIntelligenceService().dashboard(db, limit=limit)
 
 
+@router.get("/alpha/readiness")
+@router.get("/api/alpha/readiness")
+def alpha_readiness(db: Session = Depends(get_db)) -> dict:
+    return AlphaReadinessEngine().readiness(db)
+
+
+@router.get("/alpha/edge-map")
+@router.get("/api/alpha/edge-map")
+def alpha_edge_map(limit: int = Query(default=12, ge=1, le=50), db: Session = Depends(get_db)) -> dict:
+    return EdgeMapService().edge_map(db, limit=limit)
+
+
+@router.get("/alpha/gates")
+@router.get("/api/alpha/gates")
+def alpha_gates(db: Session = Depends(get_db)) -> dict:
+    return AlphaGateService().gates(db)
+
+
+@router.get("/paper-copy/summary")
+@router.get("/api/paper-copy/summary")
+def paper_copy_summary(limit: int = Query(default=12, ge=1, le=50), db: Session = Depends(get_db)) -> dict:
+    return PaperCopyTradingService().summary(db, limit=limit)
+
+
+@router.get("/paper-copy/readiness")
+@router.get("/api/paper-copy/readiness")
+def paper_copy_readiness(db: Session = Depends(get_db)) -> dict:
+    return PaperCopyTradingService().readiness(db)
+
+
+@router.get("/paper-copy/strategies")
+@router.get("/api/paper-copy/strategies")
+def paper_copy_strategies(limit: int = Query(default=40, ge=1, le=100), db: Session = Depends(get_db)) -> dict:
+    return PaperCopyTradingService().strategies(db, limit=limit)
+
+
+@router.get("/paper-copy/positions")
+@router.get("/api/paper-copy/positions")
+def paper_copy_positions(limit: int = Query(default=80, ge=1, le=200), db: Session = Depends(get_db)) -> dict:
+    return PaperCopyTradingService().positions(db, limit=limit)
+
+
+@router.get("/paper-copy/portfolio/{portfolio_id}")
+@router.get("/api/paper-copy/portfolio/{portfolio_id}")
+def paper_copy_portfolio(portfolio_id: str, db: Session = Depends(get_db)) -> dict:
+    return PaperCopyTradingService().portfolio(db, portfolio_id=portfolio_id)
+
+
 @router.post("/api/trading-game/run")
 def trading_game_run(
     batch_size: int = Query(default=settings.trading_game_batch_size, ge=1, le=500),

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 = "1.0.0"
     environment: str = Field(default="demo", alias="ENVIRONMENT")
     database_url: str = Field(
         default="postgresql+psycopg2://postgres:postgres@127.0.0.1:5432/blum",

backend/app/models.py

@@ -3186,3 +3186,214 @@ class CapitalInteractionRisk(Base):
     evidence_json: Mapped[dict] = mapped_column(JsonType, default=dict)
 
     game = relationship("TradingGame")
+
+
+class TradingGameReadinessSnapshot(Base):
+    __tablename__ = "trading_game_readiness_snapshots"
+    __table_args__ = (
+        Index("ix_tg_readiness_generated", "generated_at"),
+        Index("ix_tg_readiness_status_grade", "status", "evidence_grade"),
+        Index("ix_tg_readiness_game_generated", "game_id", "generated_at"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    game_id: Mapped[int | None] = mapped_column(ForeignKey("trading_games.id", ondelete="SET NULL"), index=True)
+    status: Mapped[str] = mapped_column(String(80), default="WAITING_FOR_SOURCE_DATA", index=True)
+    evidence_grade: Mapped[str] = mapped_column(String(80), default="insufficient", index=True)
+    blocker: Mapped[str] = mapped_column(Text, default="")
+    next_required_action: Mapped[str] = mapped_column(Text, default="")
+    payload_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    warnings_json: Mapped[list] = mapped_column(JsonType, default=list)
+    methodology_version: Mapped[str] = mapped_column(String(80), default="trading-game-readiness-v1", index=True)
+    generated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+    expires_at: Mapped[datetime | None] = mapped_column(DateTime, index=True)
+    is_stale: Mapped[bool] = mapped_column(Boolean, default=False, index=True)
+
+    game = relationship("TradingGame")
+
+
+class AlphaReadinessSnapshot(Base):
+    __tablename__ = "alpha_readiness_snapshots"
+    __table_args__ = (
+        Index("ix_alpha_readiness_generated", "generated_at"),
+        Index("ix_alpha_readiness_score", "alpha_readiness_score", "evidence_grade"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    status: Mapped[str] = mapped_column(String(80), default="INSUFFICIENT_EVIDENCE", index=True)
+    alpha_readiness_score: Mapped[float] = mapped_column(Float, default=0.0, index=True)
+    evidence_grade: Mapped[str] = mapped_column(String(80), default="insufficient", index=True)
+    classification: Mapped[str] = mapped_column(String(120), default="not_ready", index=True)
+    payload_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    warnings_json: Mapped[list] = mapped_column(JsonType, default=list)
+    methodology_version: Mapped[str] = mapped_column(String(80), default="alpha-readiness-v1", index=True)
+    generated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+    expires_at: Mapped[datetime | None] = mapped_column(DateTime, index=True)
+    is_stale: Mapped[bool] = mapped_column(Boolean, default=False, index=True)
+
+
+class AlphaGateSnapshot(Base):
+    __tablename__ = "alpha_gate_snapshots"
+    __table_args__ = (
+        Index("ix_alpha_gate_generated", "generated_at"),
+        Index("ix_alpha_gate_status", "gate_name", "status"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    gate_name: Mapped[str] = mapped_column(String(120), index=True)
+    status: Mapped[str] = mapped_column(String(80), default="blocked", index=True)
+    score: Mapped[float] = mapped_column(Float, default=0.0, index=True)
+    payload_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    warnings_json: Mapped[list] = mapped_column(JsonType, default=list)
+    generated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+
+
+class EdgeMapSnapshot(Base):
+    __tablename__ = "edge_map_snapshots"
+    __table_args__ = (
+        Index("ix_edge_map_generated", "generated_at"),
+        Index("ix_edge_map_scope", "scope", "evidence_grade"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    scope: Mapped[str] = mapped_column(String(120), default="global", index=True)
+    evidence_grade: Mapped[str] = mapped_column(String(80), default="insufficient", index=True)
+    payload_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    warnings_json: Mapped[list] = mapped_column(JsonType, default=list)
+    generated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+
+
+class PaperCopyStrategy(Base):
+    __tablename__ = "paper_copy_strategies"
+    __table_args__ = (
+        Index("ix_paper_copy_strategy_status_created", "status", "created_at"),
+        Index("ix_paper_copy_strategy_score", "copyability_score"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    strategy_id: Mapped[str] = mapped_column(String(100), unique=True, index=True)
+    name: Mapped[str] = mapped_column(String(180), default="BLUM Paper Copy Strategy")
+    status: Mapped[str] = mapped_column(String(80), default="paper_only", index=True)
+    strategy_type: Mapped[str] = mapped_column(String(120), default="conditional_copy_watchlist", index=True)
+    copyability_score: Mapped[float] = mapped_column(Float, default=0.0, index=True)
+    risk_budget_percent: Mapped[float] = mapped_column(Float, default=1.0)
+    max_open_positions: Mapped[int] = mapped_column(Integer, default=5)
+    rules_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    evidence_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    warnings_json: Mapped[list] = mapped_column(JsonType, default=list)
+    paper_only: Mapped[bool] = mapped_column(Boolean, default=True, index=True)
+    no_broker_execution: Mapped[bool] = mapped_column(Boolean, default=True, index=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, index=True)
+
+
+class PaperCopyPortfolio(Base):
+    __tablename__ = "paper_copy_portfolios"
+    __table_args__ = (
+        Index("ix_paper_copy_portfolio_status_updated", "status", "updated_at"),
+        Index("ix_paper_copy_portfolio_strategy", "strategy_id"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    portfolio_id: Mapped[str] = mapped_column(String(100), unique=True, index=True)
+    strategy_id: Mapped[int | None] = mapped_column(ForeignKey("paper_copy_strategies.id", ondelete="SET NULL"), index=True)
+    status: Mapped[str] = mapped_column(String(80), default="paper_active", index=True)
+    starting_capital: Mapped[float] = mapped_column(Float, default=100.0)
+    current_capital: Mapped[float] = mapped_column(Float, default=100.0, index=True)
+    cash: Mapped[float] = mapped_column(Float, default=100.0)
+    exposure: Mapped[float] = mapped_column(Float, default=0.0)
+    realized_pnl: Mapped[float] = mapped_column(Float, default=0.0)
+    unrealized_pnl: Mapped[float] = mapped_column(Float, default=0.0)
+    benchmark_ticker: Mapped[str] = mapped_column(String(32), default="SPY", index=True)
+    risk_state: Mapped[str] = mapped_column(String(80), default="conservative", index=True)
+    evidence_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    warnings_json: Mapped[list] = mapped_column(JsonType, default=list)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, index=True)
+
+    strategy = relationship("PaperCopyStrategy")
+
+
+class PaperCopyOrder(Base):
+    __tablename__ = "paper_copy_orders"
+    __table_args__ = (
+        Index("ix_paper_copy_orders_portfolio_created", "portfolio_id", "created_at"),
+        Index("ix_paper_copy_orders_ticker_status", "ticker", "status"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    portfolio_id: Mapped[int | None] = mapped_column(ForeignKey("paper_copy_portfolios.id", ondelete="CASCADE"), index=True)
+    strategy_id: Mapped[int | None] = mapped_column(ForeignKey("paper_copy_strategies.id", ondelete="SET NULL"), index=True)
+    source_trade_plan_id: Mapped[int | None] = mapped_column(ForeignKey("trade_plans.id", ondelete="SET NULL"), index=True)
+    ticker: Mapped[str] = mapped_column(String(32), index=True)
+    side: Mapped[str] = mapped_column(String(40), default="paper_buy", index=True)
+    status: Mapped[str] = mapped_column(String(80), default="planned", index=True)
+    order_type: Mapped[str] = mapped_column(String(80), default="conditional_paper", index=True)
+    trigger_condition: Mapped[str] = mapped_column(Text, default="")
+    paper_price: Mapped[float | None] = mapped_column(Float)
+    paper_quantity: Mapped[float | None] = mapped_column(Float)
+    risk_amount: Mapped[float | None] = mapped_column(Float)
+    invalidation_level: Mapped[float | None] = mapped_column(Float)
+    target_1: Mapped[float | None] = mapped_column(Float)
+    target_2: Mapped[float | None] = mapped_column(Float)
+    evidence_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+
+    portfolio = relationship("PaperCopyPortfolio")
+    strategy = relationship("PaperCopyStrategy")
+    source_trade_plan = relationship("TradePlan")
+
+
+class PaperCopyPosition(Base):
+    __tablename__ = "paper_copy_positions"
+    __table_args__ = (
+        Index("ix_paper_copy_positions_portfolio_status", "portfolio_id", "status"),
+        Index("ix_paper_copy_positions_ticker_opened", "ticker", "opened_at"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    portfolio_id: Mapped[int | None] = mapped_column(ForeignKey("paper_copy_portfolios.id", ondelete="CASCADE"), index=True)
+    strategy_id: Mapped[int | None] = mapped_column(ForeignKey("paper_copy_strategies.id", ondelete="SET NULL"), index=True)
+    source_order_id: Mapped[int | None] = mapped_column(ForeignKey("paper_copy_orders.id", ondelete="SET NULL"), index=True)
+    ticker: Mapped[str] = mapped_column(String(32), index=True)
+    status: Mapped[str] = mapped_column(String(80), default="open", index=True)
+    quantity: Mapped[float] = mapped_column(Float, default=0.0)
+    entry_price: Mapped[float | None] = mapped_column(Float)
+    current_price: Mapped[float | None] = mapped_column(Float)
+    market_value: Mapped[float | None] = mapped_column(Float)
+    unrealized_pnl: Mapped[float | None] = mapped_column(Float)
+    realized_pnl: Mapped[float | None] = mapped_column(Float)
+    invalidation_level: Mapped[float | None] = mapped_column(Float)
+    target_1: Mapped[float | None] = mapped_column(Float)
+    target_2: Mapped[float | None] = mapped_column(Float)
+    opened_at: Mapped[datetime | None] = mapped_column(DateTime, index=True)
+    closed_at: Mapped[datetime | None] = mapped_column(DateTime, index=True)
+    evidence_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+
+    portfolio = relationship("PaperCopyPortfolio")
+    strategy = relationship("PaperCopyStrategy")
+    source_order = relationship("PaperCopyOrder")
+
+
+class PaperCopyPortfolioSnapshot(Base):
+    __tablename__ = "paper_copy_portfolio_snapshots"
+    __table_args__ = (
+        Index("ix_paper_copy_portfolio_snapshots_portfolio_created", "portfolio_id", "created_at"),
+        Index("ix_paper_copy_portfolio_snapshots_score", "copyability_score", "evidence_grade"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    portfolio_id: Mapped[int | None] = mapped_column(ForeignKey("paper_copy_portfolios.id", ondelete="CASCADE"), index=True)
+    strategy_id: Mapped[int | None] = mapped_column(ForeignKey("paper_copy_strategies.id", ondelete="SET NULL"), index=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, index=True)
+    capital: Mapped[float | None] = mapped_column(Float)
+    exposure: Mapped[float | None] = mapped_column(Float)
+    open_positions: Mapped[int] = mapped_column(Integer, default=0)
+    pending_orders: Mapped[int] = mapped_column(Integer, default=0)
+    copyability_score: Mapped[float] = mapped_column(Float, default=0.0, index=True)
+    evidence_grade: Mapped[str] = mapped_column(String(80), default="insufficient", index=True)
+    payload_json: Mapped[dict] = mapped_column(JsonType, default=dict)
+    warnings_json: Mapped[list] = mapped_column(JsonType, default=list)
+
+    portfolio = relationship("PaperCopyPortfolio")
+    strategy = relationship("PaperCopyStrategy")

backend/app/services/alpha_operating_system.py

@@ -0,0 +1,815 @@
+from __future__ import annotations
+
+from collections import Counter, defaultdict
+from datetime import datetime
+from statistics import mean
+from typing import Any
+
+from sqlalchemy import desc, func, select
+from sqlalchemy.orm import Session
+
+from app.models import (
+    AlphaLossAttribution,
+    AlphaRecoveryAction,
+    BackgroundJobState,
+    BlumTradingPowerScore,
+    BusinessQualityScore,
+    DashboardSnapshot,
+    DecisionSuperiorityScore,
+    EquityCurveSnapshot,
+    LearningBenchmarkComparison,
+    LearningFocusPriority,
+    LearningRun,
+    LearningStrengthWeaknessMap,
+    PaperCopyOrder,
+    PaperCopyPortfolio,
+    PaperCopyPortfolioSnapshot,
+    PaperCopyPosition,
+    PaperCopyStrategy,
+    PortfolioQualityScore,
+    SniperScore,
+    TradeLearningEvidence,
+    TradePlan,
+    TradingGame,
+    TradingGameLedgerSnapshot,
+    TradingGameReadinessSnapshot,
+    TradingGameTrade,
+    TradingIntelligenceMetric,
+)
+from app.services.copy_trading_intelligence import COPY_TRADING_POLICY, CopyTradingIntelligenceService
+from app.services.dashboard_snapshots import DashboardSnapshotService
+from app.services.learning_summary import LearningSummaryService
+
+
+V1_VERSION = "1.0.0"
+V1_FEATURE_SET = "alpha-operating-system"
+READINESS_METHODOLOGY = "trading-game-readiness-v1"
+ALPHA_METHODOLOGY = "alpha-readiness-v1"
+
+
+class TradingGameReadinessService:
+    """Explains why the Trading Game can or cannot render usable evidence.
+
+    GET endpoints call `readiness`, which is bounded and read-only. Snapshot
+    producer jobs may call `snapshot_payload` and persist it through the generic
+    dashboard snapshot table.
+    """
+
+    def readiness(self, db: Session) -> dict:
+        game = latest_game(db)
+        ledger = latest_row(db, TradingGameLedgerSnapshot)
+        equity = latest_row(db, EquityCurveSnapshot)
+        latest_trade = db.scalar(select(TradingGameTrade).order_by(desc(TradingGameTrade.created_at)).limit(1))
+        source_decision_count = int(db.scalar(select(func.count(TradePlan.id))) or 0)
+        source_sniper_count = int(db.scalar(select(func.count(SniperScore.id))) or 0)
+        source_trade_count = int(db.scalar(select(func.count(TradingGameTrade.id))) or 0)
+        completed_trade_count = int(db.scalar(select(func.count(TradingGameTrade.id)).where(TradingGameTrade.exit_date.is_not(None))) or 0)
+        open_trade_count = int(db.scalar(select(func.count(TradingGameTrade.id)).where(TradingGameTrade.exit_date.is_(None))) or 0)
+        eligible_trade_count = int(
+            db.scalar(
+                select(func.count(TradingGameTrade.id)).where(
+                    TradingGameTrade.entry_price.is_not(None),
+                    TradingGameTrade.position_size > 0,
+                    TradingGameTrade.invalidation_level.is_not(None),
+                )
+            )
+            or 0
+        )
+        latest_job = latest_background_job(db, "blum_trading_game")
+        latest_snapshot_job = latest_background_job(db, "snapshot_producer")
+        ledger_status = snapshot_status(ledger)
+        equity_status = snapshot_status(equity)
+        warnings: list[str] = []
+        blocker = ""
+        next_action = "Backend learning and snapshot workers can continue normally."
+
+        if game is None:
+            status = "WAITING_FOR_SOURCE_DATA"
+            blocker = "No TradingGame row exists yet."
+            next_action = "Let the backend Trading Game worker create the first paper game."
+        elif source_trade_count == 0 and source_decision_count == 0 and source_sniper_count == 0:
+            status = "WAITING_FOR_SOURCE_DATA"
+            blocker = "No source decisions, sniper scores or trades exist yet."
+            next_action = "Let Market Sniper and Learning Loop generate source decisions."
+        elif source_trade_count == 0:
+            status = "BUILDING"
+            blocker = "Trade plans or sniper evidence exist, but no paper trades are stored yet."
+            next_action = "Let the Trading Game worker convert eligible decisions into paper trades."
+        elif ledger is None or equity is None:
+            status = "BUILDING"
+            blocker = "Trading Game rows exist, but ledger/equity snapshots are not ready."
+            next_action = "Run the snapshot producer in background; do not block the UI."
+            warnings.append("Trading evidence exists but snapshots are missing.")
+        elif ledger_status == "failed" or equity_status == "failed":
+            status = "FAILED"
+            blocker = "A required Trading Game snapshot is marked failed."
+            next_action = "Check snapshot producer logs and rebuild the affected snapshot."
+        elif ledger_status == "stale" or equity_status == "stale":
+            status = "STALE_BUT_USABLE"
+            warnings.append("Trading Game snapshot is stale; UI can render while refresh catches up.")
+        elif eligible_trade_count < 3:
+            status = "INSUFFICIENT_EVIDENCE"
+            blocker = "Fewer than three eligible trades have full risk plan evidence."
+            next_action = "Keep collecting paper trades before drawing performance conclusions."
+        else:
+            status = "READY"
+
+        data_quality_blockers = []
+        if source_trade_count and eligible_trade_count == 0:
+            data_quality_blockers.append("stored trades lack entry/risk/invalidation fields")
+        if data_quality_blockers:
+            status = "DATA_QUALITY_BLOCKED"
+            blocker = "; ".join(data_quality_blockers)
+            next_action = "Repair trade transparency enrichment before evaluating performance."
+
+        evidence_grade = evidence_grade_for(completed_trade_count, live_trade_count=db_live_trade_count(db), has_benchmark=has_benchmark_rows(db))
+        payload = {
+            "status": status,
+            "generated_at": datetime.utcnow().isoformat(),
+            "methodology_version": READINESS_METHODOLOGY,
+            "game_id": game.game_id if game else None,
+            "game_pk": game.id if game else None,
+            "source_decision_count": source_decision_count + source_sniper_count,
+            "source_trade_plan_count": source_decision_count,
+            "source_sniper_score_count": source_sniper_count,
+            "source_trade_count": source_trade_count,
+            "completed_trade_count": completed_trade_count,
+            "open_trade_count": open_trade_count,
+            "eligible_trade_count": eligible_trade_count,
+            "ledger_snapshot_status": ledger_status,
+            "equity_snapshot_status": equity_status,
+            "benchmark_snapshot_status": benchmark_snapshot_status(db),
+            "last_trade_at": latest_trade.created_at.isoformat() if latest_trade and latest_trade.created_at else None,
+            "last_ledger_snapshot_at": ledger.created_at.isoformat() if ledger and ledger.created_at else None,
+            "last_equity_snapshot_at": equity.created_at.isoformat() if equity and equity.created_at else None,
+            "worker_status": {
+                "trading_game": serialize_job(latest_job),
+                "snapshot_producer": serialize_job(latest_snapshot_job),
+            },
+            "worker_phase": latest_job.stage_name if latest_job else None,
+            "blocker": blocker,
+            "next_required_action": next_action,
+            "evidence_grade": evidence_grade,
+            "warnings": warnings,
+            "ui_state_policy": "Never show permanent generic loading. Render one of READY, BUILDING, WAITING_FOR_SOURCE_DATA, STALE_BUT_USABLE, FAILED, INSUFFICIENT_EVIDENCE, DATA_QUALITY_BLOCKED.",
+        }
+        return payload
+
+    def latest_snapshot(self, db: Session) -> dict:
+        row = latest_row(db, TradingGameReadinessSnapshot)
+        if row is None:
+            return {"status": "missing", "payload": None}
+        return {
+            "status": "stale" if is_stale(row) else "ready",
+            "payload": row.payload_json or {},
+            "created_at": row.generated_at.isoformat() if row.generated_at else None,
+            "expires_at": row.expires_at.isoformat() if row.expires_at else None,
+            "warnings": row.warnings_json or [],
+        }
+
+
+class BrainCommandSummaryService:
+    """Compact status of BLUM's brain for the Command page."""
+
+    def summary(self, db: Session) -> dict:
+        learning = LearningSummaryService().summary(db)
+        readiness = TradingGameReadinessService().readiness(db)
+        alpha = AlphaReadinessEngine().readiness(db)
+        paper = PaperCopyTradingService().summary(db, limit=8)
+        latest_power = latest_row(db, BlumTradingPowerScore)
+        latest_decision = latest_row(db, DecisionSuperiorityScore)
+        latest_business = latest_row(db, BusinessQualityScore)
+        latest_portfolio = latest_row(db, PortfolioQualityScore)
+        latest_metric = latest_row(db, TradingIntelligenceMetric)
+        latest_run = latest_row(db, LearningRun)
+        weakness = db.scalar(select(LearningStrengthWeaknessMap).order_by(desc(LearningStrengthWeaknessMap.weakness_score), desc(LearningStrengthWeaknessMap.calculated_at)).limit(1))
+        focus = db.scalar(
+            select(LearningFocusPriority)
+            .where(LearningFocusPriority.status.in_(["active", "proposed"]))
+            .order_by(desc(LearningFocusPriority.expected_learning_value), desc(LearningFocusPriority.created_at))
+            .limit(1)
+        )
+        capabilities = capability_matrix(
+            trading_power=latest_power,
+            decision=latest_decision,
+            business=latest_business,
+            portfolio=latest_portfolio,
+            metric=latest_metric,
+            readiness=readiness,
+            alpha=alpha,
+            paper=paper,
+        )
+        score_values = [item["score"] for item in capabilities if item["score"] is not None]
+        brain_score = round(mean(score_values), 2) if score_values else None
+        warnings = list(learning.get("warnings") or [])[:3] + alpha.get("warnings", [])[:3] + paper.get("warnings", [])[:3]
+        return {
+            "status": "ready" if brain_score is not None else "initializing",
+            "version": V1_VERSION,
+            "feature_set": V1_FEATURE_SET,
+            "generated_at": datetime.utcnow().isoformat(),
+            "brain_capability_score": brain_score,
+            "brain_classification": classify_brain_score(brain_score),
+            "brain_status_strip": {
+                "learning_status": learning.get("learning_loop_status"),
+                "trading_game_readiness": readiness.get("status"),
+                "alpha_readiness": alpha.get("status"),
+                "paper_copy_readiness": paper.get("readiness", {}).get("status"),
+                "latest_run_at": learning.get("latest_learning_run_at"),
+            },
+            "learning_evolution": {
+                "latest_run_status": getattr(latest_run, "status", None) if latest_run else learning.get("latest_learning_run_status"),
+                "win_rate": learning.get("win_rate"),
+                "expectancy_r": learning.get("expectancy_r"),
+                "target_progress": learning.get("target_progress"),
+                "trading_power_score": learning.get("trading_power_score"),
+                "trading_power_classification": learning.get("trading_power_classification"),
+            },
+            "capability_matrix": capabilities,
+            "benchmark_truth": learning.get("benchmark_summary"),
+            "improvement_regression": {
+                "top_weakness": serialize_weakness(weakness),
+                "next_focus": serialize_focus(focus),
+                "latest_lesson": learning.get("latest_lesson_learned"),
+                "truth_panel": learning.get("truth_panel") or [],
+            },
+            "copy_readiness": paper.get("readiness"),
+            "warnings": dedupe(warnings),
+            "data_freshness": {
+                "learning_summary": learning.get("generated_at"),
+                "trading_game_readiness": readiness.get("generated_at"),
+                "alpha_readiness": alpha.get("generated_at"),
+                "paper_copy": paper.get("generated_at"),
+            },
+            "policy": "Command reads compact evidence summaries only. It does not trigger learning, recalculation, trading or broker execution.",
+        }
+
+    def capabilities(self, db: Session) -> dict:
+        summary = self.summary(db)
+        return {"status": summary["status"], "rows": summary["capability_matrix"], "generated_at": summary["generated_at"]}
+
+    def evolution(self, db: Session) -> dict:
+        rows = db.scalars(select(BlumTradingPowerScore).order_by(desc(BlumTradingPowerScore.calculated_at)).limit(30)).all()
+        return {
+            "status": "ready" if rows else "insufficient_evidence",
+            "rows": [
+                {
+                    "calculated_at": row.calculated_at.isoformat() if row.calculated_at else None,
+                    "score": row.score,
+                    "classification": row.classification,
+                    "benchmark_relative_score": row.benchmark_relative_score,
+                    "learning_velocity_score": row.learning_velocity_score,
+                }
+                for row in rows
+            ],
+            "policy": "Evolution uses stored Trading Power snapshots only.",
+        }
+
+
+class AlphaReadinessEngine:
+    """Strict alpha readiness summary from stored evidence only."""
+
+    def readiness(self, db: Session) -> dict:
+        power = latest_row(db, BlumTradingPowerScore)
+        decision = latest_row(db, DecisionSuperiorityScore)
+        portfolio = latest_row(db, PortfolioQualityScore)
+        benchmark_rows = db.scalars(select(LearningBenchmarkComparison).order_by(desc(LearningBenchmarkComparison.calculated_at)).limit(20)).all()
+        trade_count = int(db.scalar(select(func.count(TradingGameTrade.id))) or 0)
+        live_count = db_live_trade_count(db)
+        warnings: list[str] = []
+        components = {
+            "trading_power": getattr(power, "score", None),
+            "decision_superiority": getattr(decision, "score", None),
+            "portfolio_quality": getattr(portfolio, "portfolio_quality_score", None),
+            "benchmark_evidence": benchmark_component(benchmark_rows),
+            "sample_depth": sample_depth_score(trade_count),
+            "live_validation": sample_depth_score(live_count),
+        }
+        values = [value for value in components.values() if value is not None]
+        score = round(mean(values), 2) if values else 0.0
+        if trade_count < 30:
+            score = min(score, 60.0)
+            warnings.append("insufficient_trade_sample_caps_alpha_readiness_at_60")
+        if live_count < 10:
+            score = min(score, 75.0)
+            warnings.append("live_forward_evidence_is_not_mature")
+        if not benchmark_rows:
+            score = min(score, 50.0)
+            warnings.append("benchmark_comparison_missing")
+        evidence_grade = evidence_grade_for(trade_count, live_count, bool(benchmark_rows))
+        status = "READY_FOR_RESEARCH" if score >= 60 and evidence_grade not in {"insufficient", "very_low"} else "INSUFFICIENT_EVIDENCE"
+        return {
+            "status": status,
+            "generated_at": datetime.utcnow().isoformat(),
+            "methodology_version": ALPHA_METHODOLOGY,
+            "alpha_readiness_score": score,
+            "classification": classify_alpha_score(score),
+            "evidence_grade": evidence_grade,
+            "components": components,
+            "benchmark_summary": benchmark_truth(benchmark_rows),
+            "sample": {"trades": trade_count, "live_forward_trades": live_count, "benchmarks": len(benchmark_rows)},
+            "warnings": dedupe(warnings),
+            "truth_layer": alpha_truth(score, benchmark_rows, trade_count, live_count),
+            "policy": "No alpha claim is valid without benchmark-relative evidence, sample size and live paper validation.",
+        }
+
+
+class EdgeMapService:
+    """Lightweight map of where stored Trading Game evidence appears strongest/weakest."""
+
+    def edge_map(self, db: Session, limit: int = 12) -> dict:
+        rows = db.scalars(select(TradingGameTrade).order_by(desc(TradingGameTrade.created_at)).limit(500)).all()
+        by_setup = aggregate_edges(rows, "setup_type")
+        by_sector = aggregate_edges(rows, "sector")
+        by_regime = aggregate_edges(rows, "market_regime_at_entry")
+        return {
+            "status": "ready" if rows else "insufficient_evidence",
+            "generated_at": datetime.utcnow().isoformat(),
+            "sample_size": len(rows),
+            "evidence_grade": evidence_grade_for(len(rows), db_live_trade_count(db), has_benchmark_rows(db)),
+            "best_setups": sorted(by_setup, key=lambda item: item["edge_score"], reverse=True)[:limit],
+            "weakest_setups": sorted(by_setup, key=lambda item: item["edge_score"])[:limit],
+            "best_sectors": sorted(by_sector, key=lambda item: item["edge_score"], reverse=True)[:limit],
+            "weakest_sectors": sorted(by_sector, key=lambda item: item["edge_score"])[:limit],
+            "regimes": sorted(by_regime, key=lambda item: item["edge_score"], reverse=True)[:limit],
+            "warnings": ["sample_size_low"] if len(rows) < 50 else [],
+            "policy": "Edge map is descriptive stored evidence, not a prediction or guarantee.",
+        }
+
+
+class AlphaGateService:
+    """Converts evidence into transparent gates before BLUM can call a setup copyable."""
+
+    def gates(self, db: Session) -> dict:
+        alpha = AlphaReadinessEngine().readiness(db)
+        readiness = TradingGameReadinessService().readiness(db)
+        paper = PaperCopyTradingService().summary(db, limit=5)
+        gates = [
+            gate("sample_depth", alpha["sample"]["trades"] >= 30, alpha["sample"]["trades"], ">= 30 stored paper trades"),
+            gate("live_validation", alpha["sample"]["live_forward_trades"] >= 10, alpha["sample"]["live_forward_trades"], ">= 10 live forward paper trades"),
+            gate("benchmark_evidence", alpha["sample"]["benchmarks"] > 0, alpha["sample"]["benchmarks"], "benchmark rows exist"),
+            gate("trading_game_renderable", readiness["status"] in {"READY", "STALE_BUT_USABLE", "INSUFFICIENT_EVIDENCE"}, readiness["status"], "Trading Game evidence can render"),
+            gate("paper_copy_guardrails", paper["paper_only"] and paper["no_broker_execution"], "paper_only", "no broker execution"),
+        ]
+        return {
+            "status": "ready",
+            "generated_at": datetime.utcnow().isoformat(),
+            "alpha_readiness_score": alpha["alpha_readiness_score"],
+            "all_required_gates_passed": all(item["passed"] for item in gates if item["required"]),
+            "rows": gates,
+            "policy": "Gates are pre-trade research controls. They do not authorize real trading.",
+        }
+
+
+class PaperCopyTradingService:
+    """Paper-only copy trading operating layer.
+
+    This wraps existing CopyTradingIntelligenceService evidence and exposes
+    durable portfolio/strategy state when present. It never connects to brokers.
+    """
+
+    def readiness(self, db: Session) -> dict:
+        candidate_payload = CopyTradingIntelligenceService().candidates(db, limit=20)
+        strategy_count = int(db.scalar(select(func.count(PaperCopyStrategy.id))) or 0)
+        portfolio_count = int(db.scalar(select(func.count(PaperCopyPortfolio.id))) or 0)
+        position_count = int(db.scalar(select(func.count(PaperCopyPosition.id))) or 0)
+        order_count = int(db.scalar(select(func.count(PaperCopyOrder.id))) or 0)
+        copyable = [row for row in candidate_payload.get("rows", []) if row.get("copy_readiness") in {"copy_ready_if_triggered", "wait_for_trigger"}]
+        status = "READY_FOR_PAPER_MONITORING" if copyable else "WAITING_FOR_COPYABLE_SETUPS"
+        warnings = []
+        if not strategy_count:
+            warnings.append("no_durable_paper_copy_strategy_created_yet")
+        if not portfolio_count:
+            warnings.append("no_durable_paper_copy_portfolio_created_yet")
+        return {
+            "status": status,
+            "candidate_count": len(candidate_payload.get("rows", [])),
+            "copyable_candidate_count": len(copyable),
+            "strategy_count": strategy_count,
+            "portfolio_count": portfolio_count,
+            "open_position_count": position_count,
+            "pending_order_count": order_count,
+            "warnings": warnings,
+        }
+
+    def summary(self, db: Session, limit: int = 12) -> dict:
+        dashboard = CopyTradingIntelligenceService().dashboard(db, limit=limit)
+        readiness = self.readiness(db)
+        latest_strategy = latest_row(db, PaperCopyStrategy)
+        latest_portfolio = latest_row(db, PaperCopyPortfolio)
+        latest_snapshot = latest_row(db, PaperCopyPortfolioSnapshot)
+        return {
+            "status": dashboard.get("status", "ok"),
+            "generated_at": datetime.utcnow().isoformat(),
+            "mode": "paper_copy_operating_system",
+            "paper_only": True,
+            "no_broker_execution": True,
+            "readiness": readiness,
+            "summary": dashboard.get("summary", {}),
+            "rows": dashboard.get("rows", []),
+            "strategy": serialize_paper_strategy(latest_strategy),
+            "portfolio": serialize_paper_portfolio(latest_portfolio),
+            "portfolio_snapshot": serialize_paper_snapshot(latest_snapshot),
+            "guardrails": dashboard.get("guardrails", []),
+            "truth_layer": dashboard.get("truth_layer", []),
+            "warnings": readiness.get("warnings", []),
+            "policy": COPY_TRADING_POLICY,
+        }
+
+    def strategies(self, db: Session, limit: int = 40) -> dict:
+        rows = db.scalars(select(PaperCopyStrategy).order_by(desc(PaperCopyStrategy.created_at)).limit(limit)).all()
+        if not rows:
+            summary = self.summary(db, limit=8)
+            return {
+                "status": "no_durable_strategy_yet",
+                "rows": [],
+                "candidate_strategy": strategy_candidate_from_summary(summary),
+                "policy": COPY_TRADING_POLICY,
+            }
+        return {"status": "ready", "rows": [serialize_paper_strategy(row) for row in rows], "policy": COPY_TRADING_POLICY}
+
+    def positions(self, db: Session, limit: int = 80) -> dict:
+        rows = db.scalars(select(PaperCopyPosition).order_by(desc(PaperCopyPosition.opened_at)).limit(limit)).all()
+        return {"status": "ready" if rows else "empty", "rows": [serialize_paper_position(row) for row in rows], "policy": COPY_TRADING_POLICY}
+
+    def portfolio(self, db: Session, portfolio_id: str) -> dict:
+        row = db.scalar(select(PaperCopyPortfolio).where(PaperCopyPortfolio.portfolio_id == portfolio_id).limit(1))
+        if row is None:
+            return {"status": "not_found", "portfolio_id": portfolio_id, "policy": COPY_TRADING_POLICY}
+        positions = db.scalars(select(PaperCopyPosition).where(PaperCopyPosition.portfolio_id == row.id).order_by(desc(PaperCopyPosition.opened_at)).limit(80)).all()
+        snapshots = db.scalars(select(PaperCopyPortfolioSnapshot).where(PaperCopyPortfolioSnapshot.portfolio_id == row.id).order_by(desc(PaperCopyPortfolioSnapshot.created_at)).limit(80)).all()
+        return {
+            "status": "ready",
+            "portfolio": serialize_paper_portfolio(row),
+            "positions": [serialize_paper_position(item) for item in positions],
+            "snapshots": [serialize_paper_snapshot(item) for item in snapshots],
+            "policy": COPY_TRADING_POLICY,
+        }
+
+
+def latest_game(db: Session) -> TradingGame | None:
+    return db.scalar(select(TradingGame).order_by(desc(TradingGame.updated_at)).limit(1))
+
+
+def latest_row(db: Session, model):
+    order_column = None
+    for name in ["created_at", "generated_at", "calculated_at", "updated_at"]:
+        if hasattr(model, name):
+            order_column = getattr(model, name)
+            break
+    if order_column is None:
+        return db.scalar(select(model).limit(1))
+    return db.scalar(select(model).order_by(desc(order_column)).limit(1))
+
+
+def latest_background_job(db: Session, job_name: str) -> BackgroundJobState | None:
+    return db.scalar(select(BackgroundJobState).where(BackgroundJobState.job_name == job_name).order_by(desc(BackgroundJobState.last_started_at)).limit(1))
+
+
+def snapshot_status(row: Any | None) -> str:
+    if row is None:
+        return "missing"
+    if getattr(row, "is_stale", False):
+        return "stale"
+    expires = getattr(row, "expires_at", None)
+    if expires and expires < datetime.utcnow():
+        return "stale"
+    if (getattr(row, "payload_json", None) or {}).get("status") == "failed":
+        return "failed"
+    return "ready"
+
+
+def benchmark_snapshot_status(db: Session) -> str:
+    snapshot = db.scalar(select(DashboardSnapshot).where(DashboardSnapshot.snapshot_type == "benchmark_summary").order_by(desc(DashboardSnapshot.created_at)).limit(1))
+    if snapshot is None:
+        return "missing"
+    return "stale" if is_stale(snapshot) else "ready"
+
+
+def is_stale(row: Any) -> bool:
+    expires = getattr(row, "expires_at", None)
+    return bool(getattr(row, "is_stale", False) or (expires is not None and expires < datetime.utcnow()))
+
+
+def db_live_trade_count(db: Session) -> int:
+    return int(db.scalar(select(func.count(TradingGameTrade.id)).where(TradingGameTrade.mode.like("%live%"))) or 0)
+
+
+def has_benchmark_rows(db: Session) -> bool:
+    return bool(db.scalar(select(LearningBenchmarkComparison.id).limit(1)))
+
+
+def evidence_grade_for(trades: int, live_trade_count: int, has_benchmark: bool) -> str:
+    if trades < 10:
+        return "insufficient"
+    if trades < 30:
+        return "very_low"
+    if trades < 100:
+        return "low" if not has_benchmark else "medium_low"
+    if live_trade_count < 30:
+        return "medium"
+    return "strong"
+
+
+def benchmark_component(rows: list[LearningBenchmarkComparison]) -> float | None:
+    if not rows:
+        return None
+    values = []
+    for row in rows:
+        excess = row.excess_return
+        if excess is None:
+            continue
+        values.append(max(0.0, min(100.0, 50.0 + float(excess))))
+    return round(mean(values), 2) if values else None
+
+
+def sample_depth_score(count: int) -> float:
+    if count <= 0:
+        return 0.0
+    if count >= 250:
+        return 100.0
+    return round(min(100.0, count / 2.5), 2)
+
+
+def benchmark_truth(rows: list[LearningBenchmarkComparison]) -> dict:
+    latest: dict[str, LearningBenchmarkComparison] = {}
+    for row in rows:
+        latest.setdefault(row.benchmark_name, row)
+    return {
+        name: {
+            "result_label": row.result_label,
+            "excess_return": row.excess_return,
+            "sample_size": row.sample_size,
+            "statistical_confidence": row.statistical_confidence,
+        }
+        for name, row in latest.items()
+    }
+
+
+def alpha_truth(score: float, rows: list[LearningBenchmarkComparison], trade_count: int, live_count: int) -> list[str]:
+    lines = [f"Alpha Readiness is {score:.1f}/100 from stored evidence only."]
+    if not rows:
+        lines.append("Benchmark evidence is missing, so no outperformance claim is valid.")
+    if trade_count < 30:
+        lines.append("Trade sample is too small for durable conclusions.")
+    if live_count < 10:
+        lines.append("Live paper validation is not mature yet.")
+    under = [row for row in rows if row.result_label == "underperforming"]
+    if under:
+        lines.append(f"BLUM is underperforming {under[0].benchmark_name} on the latest stored comparison.")
+    return lines[:5]
+
+
+def classify_alpha_score(score: float) -> str:
+    if score < 25:
+        return "not_ready"
+    if score < 50:
+        return "experimental"
+    if score < 70:
+        return "research_candidate"
+    if score < 85:
+        return "paper_evidence_promising"
+    return "requires_external_validation"
+
+
+def classify_brain_score(score: float | None) -> str:
+    if score is None:
+        return "initializing"
+    if score < 25:
+        return "evidence poor"
+    if score < 50:
+        return "learning but weak"
+    if score < 70:
+        return "research grade"
+    if score < 85:
+        return "strong paper evidence"
+    return "advanced, needs external validation"
+
+
+def capability_matrix(
+    *,
+    trading_power: BlumTradingPowerScore | None,
+    decision: DecisionSuperiorityScore | None,
+    business: BusinessQualityScore | None,
+    portfolio: PortfolioQualityScore | None,
+    metric: TradingIntelligenceMetric | None,
+    readiness: dict,
+    alpha: dict,
+    paper: dict,
+) -> list[dict]:
+    return [
+        capability("Trading Intelligence", getattr(trading_power, "score", None), getattr(trading_power, "classification", None), sample_from_metric(metric), "paper P/L, expectancy, benchmark context"),
+        capability("Decision Superiority", getattr(decision, "score", None), getattr(decision, "classification", None), None, "opportunity recall, precision and ranking accuracy"),
+        capability("Business Quality", getattr(business, "business_quality_score", None), getattr(business, "ticker", None), None, "fundamental quality evidence"),
+        capability("Portfolio Intelligence", getattr(portfolio, "portfolio_quality_score", None), None, None, "risk contribution, concentration and capital efficiency"),
+        capability("Trading Game Readiness", readiness_score(readiness.get("status")), readiness.get("status"), readiness.get("completed_trade_count"), "ledger, equity and benchmark renderability"),
+        capability("Alpha Readiness", alpha.get("alpha_readiness_score"), alpha.get("classification"), alpha.get("sample", {}).get("trades"), "strict capped alpha evidence"),
+        capability("Paper Copy Readiness", copy_score_from_summary(paper), paper.get("readiness", {}).get("status"), paper.get("readiness", {}).get("candidate_count"), "paper-only mirror candidates"),
+    ]
+
+
+def capability(name: str, score: float | None, status: str | None, sample_size: int | None, evidence: str) -> dict:
+    return {
+        "name": name,
+        "score": round(float(score), 2) if score is not None else None,
+        "status": status or "initializing",
+        "sample_size": sample_size,
+        "evidence": evidence,
+        "warning": "insufficient evidence" if sample_size is not None and sample_size < 30 else "",
+    }
+
+
+def readiness_score(status: str | None) -> float:
+    return {
+        "READY": 82.0,
+        "STALE_BUT_USABLE": 68.0,
+        "INSUFFICIENT_EVIDENCE": 45.0,
+        "BUILDING": 35.0,
+        "WAITING_FOR_SOURCE_DATA": 20.0,
+        "DATA_QUALITY_BLOCKED": 15.0,
+        "FAILED": 0.0,
+    }.get(status or "", 20.0)
+
+
+def copy_score_from_summary(summary: dict) -> float | None:
+    value = (summary.get("summary") or {}).get("average_readiness_score")
+    return float(value) if value is not None else None
+
+
+def sample_from_metric(metric: TradingIntelligenceMetric | None) -> int | None:
+    return metric.trades_count if metric else None
+
+
+def aggregate_edges(rows: list[TradingGameTrade], attr: str) -> list[dict]:
+    groups: dict[str, list[TradingGameTrade]] = defaultdict(list)
+    for row in rows:
+        key = getattr(row, attr, None) or "unknown"
+        groups[str(key)].append(row)
+    output = []
+    for key, group in groups.items():
+        r_values = [float(row.realized_r_multiple) for row in group if row.realized_r_multiple is not None]
+        excess_values = [float(row.excess_return_vs_benchmark) for row in group if row.excess_return_vs_benchmark is not None]
+        wins = sum(1 for row in group if (row.realized_r_multiple or 0) > 0 or row.outcome_label in {"win", "target_hit"})
+        sample = len(group)
+        avg_r = mean(r_values) if r_values else 0.0
+        avg_excess = mean(excess_values) if excess_values else 0.0
+        edge_score = max(0.0, min(100.0, 50.0 + avg_r * 12.0 + avg_excess * 0.8 + (wins / max(1, sample) - 0.5) * 30.0))
+        output.append(
+            {
+                "entity": key,
+                "sample_size": sample,
+                "win_rate": round(wins / max(1, sample), 4),
+                "average_r": round(avg_r, 4),
+                "average_excess_return": round(avg_excess, 4),
+                "edge_score": round(edge_score, 2),
+                "evidence_grade": "weak" if sample < 20 else "medium" if sample < 80 else "strong",
+            }
+        )
+    return output
+
+
+def gate(name: str, passed: bool, observed: Any, requirement: str, required: bool = True) -> dict:
+    return {
+        "gate": name,
+        "passed": bool(passed),
+        "required": required,
+        "observed": observed,
+        "requirement": requirement,
+        "status": "pass" if passed else "blocked",
+    }
+
+
+def serialize_job(row: BackgroundJobState | None) -> dict | None:
+    if row is None:
+        return None
+    return {
+        "job_name": row.job_name,
+        "stage_name": row.stage_name,
+        "status": row.status,
+        "last_started_at": row.last_started_at.isoformat() if row.last_started_at else None,
+        "last_completed_at": row.last_completed_at.isoformat() if row.last_completed_at else None,
+        "duration_ms": row.duration_ms,
+        "items_processed": row.items_processed,
+        "error_message": row.error_message,
+    }
+
+
+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,
+    }
+
+
+def serialize_focus(row: LearningFocusPriority | None) -> dict | None:
+    if row is None:
+        return None
+    return {
+        "priority_type": row.priority_type,
+        "target": row.target,
+        "reason": row.reason,
+        "expected_learning_value": row.expected_learning_value,
+        "urgency": row.urgency,
+        "status": row.status,
+    }
+
+
+def serialize_paper_strategy(row: PaperCopyStrategy | None) -> dict | None:
+    if row is None:
+        return None
+    return {
+        "id": row.id,
+        "strategy_id": row.strategy_id,
+        "name": row.name,
+        "status": row.status,
+        "strategy_type": row.strategy_type,
+        "copyability_score": row.copyability_score,
+        "risk_budget_percent": row.risk_budget_percent,
+        "max_open_positions": row.max_open_positions,
+        "paper_only": row.paper_only,
+        "no_broker_execution": row.no_broker_execution,
+        "updated_at": row.updated_at.isoformat() if row.updated_at else None,
+    }
+
+
+def serialize_paper_portfolio(row: PaperCopyPortfolio | None) -> dict | None:
+    if row is None:
+        return None
+    return {
+        "id": row.id,
+        "portfolio_id": row.portfolio_id,
+        "status": row.status,
+        "starting_capital": row.starting_capital,
+        "current_capital": row.current_capital,
+        "cash": row.cash,
+        "exposure": row.exposure,
+        "realized_pnl": row.realized_pnl,
+        "unrealized_pnl": row.unrealized_pnl,
+        "benchmark_ticker": row.benchmark_ticker,
+        "risk_state": row.risk_state,
+        "updated_at": row.updated_at.isoformat() if row.updated_at else None,
+    }
+
+
+def serialize_paper_position(row: PaperCopyPosition) -> dict:
+    return {
+        "id": row.id,
+        "ticker": row.ticker,
+        "status": row.status,
+        "quantity": row.quantity,
+        "entry_price": row.entry_price,
+        "current_price": row.current_price,
+        "market_value": row.market_value,
+        "unrealized_pnl": row.unrealized_pnl,
+        "realized_pnl": row.realized_pnl,
+        "invalidation_level": row.invalidation_level,
+        "target_1": row.target_1,
+        "target_2": row.target_2,
+        "opened_at": row.opened_at.isoformat() if row.opened_at else None,
+        "closed_at": row.closed_at.isoformat() if row.closed_at else None,
+    }
+
+
+def serialize_paper_snapshot(row: PaperCopyPortfolioSnapshot | None) -> dict | None:
+    if row is None:
+        return None
+    return {
+        "id": row.id,
+        "created_at": row.created_at.isoformat() if row.created_at else None,
+        "capital": row.capital,
+        "exposure": row.exposure,
+        "open_positions": row.open_positions,
+        "pending_orders": row.pending_orders,
+        "copyability_score": row.copyability_score,
+        "evidence_grade": row.evidence_grade,
+        "payload": row.payload_json or {},
+        "warnings": row.warnings_json or [],
+    }
+
+
+def strategy_candidate_from_summary(summary: dict) -> dict:
+    rows = summary.get("rows") or []
+    scores = [row.get("copy_readiness_score") for row in rows if row.get("copy_readiness_score") is not None]
+    return {
+        "name": "BLUM Paper Copy Strategy Candidate",
+        "strategy_type": "conditional_copy_watchlist",
+        "copyability_score": round(mean(scores), 2) if scores else 0.0,
+        "candidate_count": len(rows),
+        "rules": [
+            "paper only",
+            "copy only if trigger and invalidation exist",
+            "risk budget remains educational and capped",
+            "no broker execution",
+        ],
+    }
+
+
+def dedupe(items: list[str]) -> list[str]:
+    return list(dict.fromkeys([str(item) for item in items if item]))

backend/app/services/central_brain_runtime.py

@@ -58,6 +58,12 @@ CRITICAL_SNAPSHOT_TYPES = [
     "capital_allocation_summary",
     "alpha_recovery_summary",
     "meta_cognition_summary",
+    "trading_game_readiness",
+    "brain_command_summary",
+    "alpha_readiness_summary",
+    "alpha_edge_map_summary",
+    "alpha_gates_summary",
+    "paper_copy_summary",
     "trading_game_ledger_snapshot",
     "equity_curve_snapshot",
 ]
@@ -355,6 +361,30 @@ class SnapshotProducerService:
             from app.services.meta_cognition import MetaCognitionEngine
 
             return MetaCognitionEngine().summary(db)
+        if snapshot_type == "trading_game_readiness":
+            from app.services.alpha_operating_system import TradingGameReadinessService
+
+            return TradingGameReadinessService().readiness(db)
+        if snapshot_type == "brain_command_summary":
+            from app.services.alpha_operating_system import BrainCommandSummaryService
+
+            return BrainCommandSummaryService().summary(db)
+        if snapshot_type == "alpha_readiness_summary":
+            from app.services.alpha_operating_system import AlphaReadinessEngine
+
+            return AlphaReadinessEngine().readiness(db)
+        if snapshot_type == "alpha_edge_map_summary":
+            from app.services.alpha_operating_system import EdgeMapService
+
+            return EdgeMapService().edge_map(db)
+        if snapshot_type == "alpha_gates_summary":
+            from app.services.alpha_operating_system import AlphaGateService
+
+            return AlphaGateService().gates(db)
+        if snapshot_type == "paper_copy_summary":
+            from app.services.alpha_operating_system import PaperCopyTradingService
+
+            return PaperCopyTradingService().summary(db)
         missing_sections.append("unknown_snapshot_type")
         return {"status": "unknown_snapshot_type", "snapshot_type": snapshot_type}
 

backend/tests/test_alpha_operating_system.py

@@ -0,0 +1,163 @@
+from datetime import date, datetime
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session
+
+from app.core.database import Base
+from app.models import (
+    LearningBenchmarkComparison,
+    SniperScore,
+    TradePlan,
+    TradingGame,
+    TradingGameTrade,
+)
+from app.services.alpha_operating_system import (
+    AlphaGateService,
+    AlphaReadinessEngine,
+    BrainCommandSummaryService,
+    EdgeMapService,
+    PaperCopyTradingService,
+    TradingGameReadinessService,
+)
+from app.services.trading_game_runtime import TradingGameRuntimeSnapshotService
+
+
+def setup_db() -> Session:
+    engine = create_engine("sqlite:///:memory:", future=True)
+    Base.metadata.create_all(engine)
+    return Session(engine)
+
+
+def test_trading_game_readiness_explains_missing_source_data():
+    with setup_db() as db:
+        payload = TradingGameReadinessService().readiness(db)
+
+    assert payload["status"] == "WAITING_FOR_SOURCE_DATA"
+    assert "No TradingGame row" in payload["blocker"]
+    assert payload["evidence_grade"] == "insufficient"
+
+
+def test_trading_game_readiness_ready_when_snapshots_and_eligible_trades_exist():
+    with setup_db() as db:
+        game = TradingGame(game_id="readiness-test", current_capital=105.0, target_capital=10000.0)
+        db.add(game)
+        db.flush()
+        for index in range(3):
+            db.add(
+                TradingGameTrade(
+                    game_id=game.id,
+                    ticker=f"T{index}",
+                    setup_type="momentum_breakout",
+                    entry_date=date(2025, 1, 2 + index),
+                    exit_date=date(2025, 1, 5 + index),
+                    entry_price=100.0,
+                    position_size=0.2,
+                    invalidation_level=96.0,
+                    realized_r_multiple=1.0,
+                    net_pnl_eur=1.0,
+                    outcome_label="target_hit",
+                    created_at=datetime.utcnow(),
+                )
+            )
+        db.commit()
+        TradingGameRuntimeSnapshotService().produce_ledger_snapshot(db, game_id=game.id, limit=10)
+        TradingGameRuntimeSnapshotService().produce_equity_snapshot(db, game_id=game.id, limit=10)
+
+        payload = TradingGameReadinessService().readiness(db)
+
+    assert payload["status"] == "READY"
+    assert payload["eligible_trade_count"] == 3
+    assert payload["ledger_snapshot_status"] == "ready"
+    assert payload["equity_snapshot_status"] == "ready"
+
+
+def test_alpha_readiness_is_capped_without_live_and_benchmark_depth():
+    with setup_db() as db:
+        game = TradingGame(game_id="alpha-test", current_capital=150.0)
+        db.add(game)
+        db.flush()
+        for index in range(12):
+            db.add(
+                TradingGameTrade(
+                    game_id=game.id,
+                    ticker=f"A{index}",
+                    setup_type="pullback_to_trend",
+                    realized_r_multiple=2.0,
+                    excess_return_vs_benchmark=4.0,
+                    outcome_label="target_hit",
+                    created_at=datetime.utcnow(),
+                )
+            )
+        db.commit()
+
+        payload = AlphaReadinessEngine().readiness(db)
+
+    assert payload["status"] == "INSUFFICIENT_EVIDENCE"
+    assert payload["alpha_readiness_score"] <= 60
+    assert "benchmark_comparison_missing" in payload["warnings"]
+
+
+def test_alpha_gates_require_benchmark_and_live_samples():
+    with setup_db() as db:
+        payload = AlphaGateService().gates(db)
+
+    blocked = [row for row in payload["rows"] if not row["passed"]]
+    assert blocked
+    assert payload["all_required_gates_passed"] is False
+
+
+def test_edge_map_uses_stored_trade_outcomes_without_recalculation():
+    with setup_db() as db:
+        game = TradingGame(game_id="edge-test")
+        db.add(game)
+        db.flush()
+        db.add_all(
+            [
+                TradingGameTrade(game_id=game.id, ticker="NVDA", setup_type="momentum_breakout", sector="Technology", realized_r_multiple=2.0, excess_return_vs_benchmark=5.0, outcome_label="target_hit"),
+                TradingGameTrade(game_id=game.id, ticker="AAPL", setup_type="momentum_breakout", sector="Technology", realized_r_multiple=-1.0, excess_return_vs_benchmark=-2.0, outcome_label="stopped_out"),
+            ]
+        )
+        db.commit()
+
+        payload = EdgeMapService().edge_map(db)
+
+    assert payload["status"] == "ready"
+    assert payload["best_setups"][0]["entity"] == "momentum_breakout"
+    assert payload["sample_size"] == 2
+
+
+def test_paper_copy_summary_is_paper_only_and_reuses_trade_plan_evidence():
+    with setup_db() as db:
+        db.add(
+            TradePlan(
+                ticker="NVDA",
+                setup_type="momentum_breakout",
+                actionability="actionable_if_confirmed",
+                entry_trigger="close above resistance with relative volume > 1.5x",
+                invalidation_level=120.0,
+                target_1=140.0,
+                confidence=72.0,
+                historical_setup_reliability=60.0,
+            )
+        )
+        db.commit()
+
+        payload = PaperCopyTradingService().summary(db, limit=5)
+
+    assert payload["paper_only"] is True
+    assert payload["no_broker_execution"] is True
+    assert payload["readiness"]["status"] == "READY_FOR_PAPER_MONITORING"
+    assert payload["rows"][0]["ticker"] == "NVDA"
+
+
+def test_brain_command_summary_is_compact_and_truth_first():
+    with setup_db() as db:
+        db.add(LearningBenchmarkComparison(benchmark_name="SPY", result_label="underperforming", excess_return=-4.2, sample_size=12, statistical_confidence="low evidence"))
+        db.add(SniperScore(ticker="AMD", setup_type="pullback_to_trend", actionability="wait_for_trigger", sniper_score=68.0, confidence=60.0))
+        db.commit()
+
+        payload = BrainCommandSummaryService().summary(db)
+
+    assert payload["feature_set"] == "alpha-operating-system"
+    assert "capability_matrix" in payload
+    assert payload["policy"].startswith("Command reads compact evidence")

frontend/app/copy-trading/page.tsx

@@ -15,7 +15,7 @@ export default function CopyTradingPage() {
   useEffect(() => {
     let mounted = true;
     setLoading(true);
-    api.copyTradingDashboard(25)
+    api.paperCopySummary(25)
       .then((payload) => {
         if (mounted) setData(payload);
       })
@@ -47,7 +47,7 @@ export default function CopyTradingPage() {
           { label: "Mode", value: data?.mode ?? "paper_copy_intelligence", tone: "info" },
           { label: "Guardrail", value: data?.paper_only ? "paper only" : "blocked", tone: data?.paper_only ? "positive" : "negative" },
           { label: "Candidates", value: String(summary?.candidate_count ?? rows.length), tone: rows.length ? "positive" : "attention" },
-          { label: "Execution", value: data?.no_broker_execution ? "disabled" : "unknown", tone: "attention" },
+          { label: "Readiness", value: data?.readiness?.status ?? "building", tone: "attention" },
         ]}
       />
 
@@ -58,6 +58,26 @@ export default function CopyTradingPage() {
         <MetricCard label="Blocked" value={summary?.blocked ?? 0} subvalue="Avoid/reduce/insufficient risk plan" icon={<ShieldAlert size={15} />} tone="negative" />
       </section>
 
+      <section className="grid-2" style={{ marginBottom: 12 }}>
+        <BloombergPanel title="Paper Copy Operating State" value={data?.readiness?.status ?? "pending"} subtitle="Durable state remains paper-only and brokerless">
+          <div className="professional-grid-3">
+            <MetricCard label="Strategies" value={data?.readiness?.strategy_count ?? 0} />
+            <MetricCard label="Portfolios" value={data?.readiness?.portfolio_count ?? 0} />
+            <MetricCard label="Open Positions" value={data?.readiness?.open_position_count ?? 0} />
+          </div>
+          <p>{data?.policy ?? "Paper copy intelligence is informational only."}</p>
+        </BloombergPanel>
+
+        <BloombergPanel title="Latest Paper Portfolio" value={data?.portfolio?.portfolio_id ?? "not created"} subtitle="Paper capital state is shown only when stored">
+          <div className="professional-grid-3">
+            <MetricCard label="Capital" value={formatCurrency(data?.portfolio?.current_capital)} />
+            <MetricCard label="Exposure" value={formatCurrency(data?.portfolio?.exposure)} />
+            <MetricCard label="Risk State" value={data?.portfolio?.risk_state ?? "n/a"} />
+          </div>
+          {!!data?.warnings?.length && <p>{data.warnings.slice(0, 3).join(" | ")}</p>}
+        </BloombergPanel>
+      </section>
+
       <section className="grid-2" style={{ marginBottom: 12 }}>
         <BloombergPanel title="Truth Layer" value="research only" subtitle="What BLUM is allowed to say">
           <div className="brain-list dense">
@@ -156,3 +176,8 @@ function formatPrice(value: any) {
   if (value === null || value === undefined || Number.isNaN(Number(value))) return "n/a";
   return Number(value).toFixed(2);
 }
+
+function formatCurrency(value: any) {
+  if (value === null || value === undefined || Number.isNaN(Number(value))) return "n/a";
+  return `${Number(value).toFixed(2)} EUR`;
+}

frontend/app/dashboard/page.tsx

@@ -41,7 +41,7 @@ export default function DashboardPage() {
   const [pipelineStatus, setPipelineStatus] = useState<PipelineStatus | null>(null);
   const [systemStatus, setSystemStatus] = useState<SystemStatus | null>(null);
   const [brainStatus, setBrainStatus] = useState<BrainStatus | null>(null);
-  const [learningSummary, setLearningSummary] = useState<any | null>(null);
+  const [commandSummary, setCommandSummary] = useState<any | null>(null);
   const [executive, setExecutive] = useState<ExecutiveDashboardPayload | null>(null);
   const [error, setError] = useState("");
   const [liveError, setLiveError] = useState("");
@@ -53,7 +53,7 @@ export default function DashboardPage() {
       const overview = await api.overview();
       setData(overview);
 
-      const [newsResult, sentimentResult, statusResult, systemResult, executiveResult, brainResult, learningResult] =
+      const [newsResult, sentimentResult, statusResult, systemResult, executiveResult, brainResult, commandResult] =
         await Promise.allSettled([
           api.liveNews(60),
           api.marketSentiment(48),
@@ -61,7 +61,7 @@ export default function DashboardPage() {
           api.systemStatus(),
           api.executiveDashboard(),
           api.brainStatus(),
-          api.learningSummary()
+          api.brainCommandSummary()
         ] as const);
 
       if (newsResult.status === "fulfilled") setLiveNews(newsResult.value);
@@ -70,7 +70,7 @@ export default function DashboardPage() {
       if (systemResult.status === "fulfilled") setSystemStatus(systemResult.value);
       if (executiveResult.status === "fulfilled") setExecutive(executiveResult.value);
       if (brainResult.status === "fulfilled") setBrainStatus(brainResult.value);
-      if (learningResult.status === "fulfilled") setLearningSummary(learningResult.value);
+      if (commandResult.status === "fulfilled") setCommandSummary(commandResult.value);
 
       setLiveError(
         [
@@ -80,7 +80,7 @@ export default function DashboardPage() {
           systemResult.status === "rejected" ? `system ${errorMessage(systemResult.reason)}` : "",
           executiveResult.status === "rejected" ? `executive ${errorMessage(executiveResult.reason)}` : "",
           brainResult.status === "rejected" ? `brain ${errorMessage(brainResult.reason)}` : "",
-          learningResult.status === "rejected" ? `learning ${errorMessage(learningResult.reason)}` : ""
+          commandResult.status === "rejected" ? `command ${errorMessage(commandResult.reason)}` : ""
         ]
           .filter(Boolean)
           .join(" | ")
@@ -234,7 +234,7 @@ export default function DashboardPage() {
         />
       </section>
 
-      <BrainLevelPanel summary={learningSummary} accuracy={data.accuracy} brainStatus={brainStatus} />
+      <BrainLevelPanel summary={commandSummary} accuracy={data.accuracy} brainStatus={brainStatus} />
 
       <section className="market-command-layout">
         <div className="market-pulse-grid">
@@ -340,13 +340,16 @@ export default function DashboardPage() {
 }
 
 function BrainLevelPanel({ summary, accuracy, brainStatus }: { summary: any; accuracy?: AccuracyOverview; brainStatus: BrainStatus | null }) {
-  const benchmarks = Object.entries(summary?.benchmark_summary?.major_benchmarks ?? {}).slice(0, 4) as Array<[string, any]>;
-  const whatNext = summary?.what_blum_should_learn_next ?? {};
-  const topWeakness = summary?.top_weakness;
-  const latestLesson = summary?.latest_lesson_learned;
-  const tradingPower = summary?.trading_power_score ?? accuracy?.blum_confidence_score;
-  const powerLabel = summary?.trading_power_classification ?? accuracy?.confidence_label ?? "evidence building";
+  const learning = summary?.learning_evolution ?? summary ?? {};
+  const improvement = summary?.improvement_regression ?? {};
+  const benchmarks = Object.entries(summary?.benchmark_truth?.major_benchmarks ?? summary?.benchmark_summary?.major_benchmarks ?? {}).slice(0, 4) as Array<[string, any]>;
+  const whatNext = summary?.what_blum_should_learn_next ?? improvement;
+  const topWeakness = improvement?.top_weakness ?? summary?.top_weakness;
+  const latestLesson = improvement?.latest_lesson ?? summary?.latest_lesson_learned;
+  const tradingPower = summary?.brain_capability_score ?? learning?.trading_power_score ?? accuracy?.blum_confidence_score;
+  const powerLabel = summary?.brain_classification ?? learning?.trading_power_classification ?? accuracy?.confidence_label ?? "evidence building";
   const evidenceStatus = evidenceLabel(summary);
+  const statusStrip = summary?.brain_status_strip ?? {};
   return (
     <BloombergPanel
       title="BLUM Brain Level"
@@ -361,10 +364,10 @@ function BrainLevelPanel({ summary, accuracy, brainStatus }: { summary: any; acc
             <span>{powerLabel}</span>
           </div>
           <div className="brain-level-facts">
-            <MetricCard label="Learning status" value={summary?.learning_loop_status ?? brainStatus?.learning_state ?? "pending"} subvalue={`latest ${formatDateTime(summary?.latest_learning_run_at)}`} tone="info" />
-            <MetricCard label="Win / Expectancy" value={`${formatPct(summary?.win_rate)} / ${formatR(summary?.expectancy_r)}`} subvalue="paper Trading Game evidence" tone="attention" />
-            <MetricCard label="Capital progress" value={formatPct(summary?.target_progress)} subvalue={`${summary?.completed_target_cycles ?? 0} target cycles | ${summary?.bankrupt_cycles ?? 0} bankrupt`} tone="positive" />
-            <MetricCard label="Evidence level" value={evidenceStatus} subvalue={summary?.live_vs_historical_status ?? "live evidence pending"} tone={evidenceStatus.includes("weak") ? "attention" : "info"} />
+            <MetricCard label="Learning status" value={statusStrip?.learning_status ?? learning?.latest_run_status ?? brainStatus?.learning_state ?? "pending"} subvalue={`latest ${formatDateTime(statusStrip?.latest_run_at ?? learning?.latest_run_at)}`} tone="info" />
+            <MetricCard label="Win / Expectancy" value={`${formatPct(learning?.win_rate)} / ${formatR(learning?.expectancy_r)}`} subvalue="paper Trading Game evidence" tone="attention" />
+            <MetricCard label="Capital progress" value={formatPct(learning?.target_progress)} subvalue={`copy ${statusStrip?.paper_copy_readiness ?? "pending"} | alpha ${statusStrip?.alpha_readiness ?? "pending"}`} tone="positive" />
+            <MetricCard label="Evidence level" value={evidenceStatus} subvalue={statusStrip?.trading_game_readiness ?? summary?.live_vs_historical_status ?? "live evidence pending"} tone={evidenceStatus.includes("weak") ? "attention" : "info"} />
           </div>
         </div>
 
@@ -390,8 +393,8 @@ function BrainLevelPanel({ summary, accuracy, brainStatus }: { summary: any; acc
             </div>
             <div>
               <span className="regime-badge tone-positive">next focus</span>
-              <strong>{whatNext?.next_learning_focus?.target ?? whatNext?.conclusion?.summary ?? "No active focus priority"}</strong>
-              <p>{whatNext?.next_learning_focus?.reason ?? "When evidence is sufficient, BLUM will show which factor/module should be studied next."}</p>
+              <strong>{whatNext?.next_learning_focus?.target ?? whatNext?.target ?? whatNext?.conclusion?.summary ?? "No active focus priority"}</strong>
+              <p>{whatNext?.next_learning_focus?.reason ?? whatNext?.reason ?? "When evidence is sufficient, BLUM will show which factor/module should be studied next."}</p>
             </div>
           </div>
         </div>
@@ -616,9 +619,11 @@ function formatR(value: unknown) {
 function evidenceLabel(summary: any) {
   if (!summary) return "loading";
   const warnings = summary?.warnings ?? [];
+  if (summary?.brain_status_strip?.alpha_readiness === "INSUFFICIENT_EVIDENCE") return "weak evidence";
+  if (summary?.brain_capability_score == null && summary?.trading_power_score == null) return "initializing";
   if (summary?.live_vs_historical_status === "missing") return "weak evidence";
   if (warnings.length > 2) return "limited evidence";
-  if (summary?.trading_power_score == null) return "initializing";
+  if (summary?.brain_capability_score == null && summary?.trading_power_score == null) return "initializing";
   return "tracked evidence";
 }
 

frontend/app/learning/page.tsx

@@ -59,6 +59,14 @@ export default function LearningPage() {
     async function loadTradingGame() {
       setTradingLoading(true);
       setTradingError("");
+      const readiness = await api.tradingGameReadiness();
+      if (!mounted) return;
+      const canLoadEvidence = ["READY", "STALE_BUT_USABLE", "INSUFFICIENT_EVIDENCE"].includes(readiness?.status);
+      if (!canLoadEvidence) {
+        setTrading({ readiness });
+        setTradingLoading(false);
+        return;
+      }
       const [equityResult, ledgerResult, ledgerSummaryResult, realityCheckResult, benchmarkResult] = await Promise.allSettled([
         api.tradingGameAnnotatedEquity(240),
         api.tradingGameLedger(25),
@@ -68,6 +76,7 @@ export default function LearningPage() {
       ] as const);
       if (!mounted) return;
       setTrading({
+        readiness,
         equity: equityResult.status === "fulfilled" ? equityResult.value : null,
         ledger: ledgerResult.status === "fulfilled" ? ledgerResult.value : null,
         ledgerSummary: ledgerSummaryResult.status === "fulfilled" ? ledgerSummaryResult.value : null,
@@ -141,6 +150,7 @@ export default function LearningPage() {
   const ledgerSummary = trading?.ledgerSummary?.summary ?? trading?.ledger?.summary ?? {};
   const realityCheck = trading?.realityCheck ?? {};
   const benchmark = trading?.benchmark ?? summary?.benchmark_summary ?? {};
+  const tradingReadiness = trading?.readiness ?? null;
   const truthPanel = summary?.truth_panel ?? [];
 
   return (
@@ -192,6 +202,7 @@ export default function LearningPage() {
           realityCheck={realityCheck}
           benchmark={benchmark}
           equityPayload={trading?.equity}
+          readiness={tradingReadiness}
           onRetry={() => setTrading(null)}
           onLoadMore={loadMoreLedger}
         />
@@ -325,10 +336,46 @@ function OverviewTab({ summary, loading, error, truthPanel, onRefresh }: { summa
   );
 }
 
-function TradingGameTab({ summary, cycle, loading, error, equityChart, equityPayload, ledgerRows, ledgerSummary, realityCheck, benchmark, onRetry, onLoadMore }: any) {
+function TradingGameTab({ summary, cycle, loading, error, equityChart, equityPayload, readiness, ledgerRows, ledgerSummary, realityCheck, benchmark, onRetry, onLoadMore }: any) {
   const equityInfo = equityPayloadSummary(equityPayload, equityChart);
+  const readinessStatus = readiness?.status ?? (loading ? "BUILDING" : "UNKNOWN");
+  const canShowEvidence = ["READY", "STALE_BUT_USABLE", "INSUFFICIENT_EVIDENCE"].includes(readinessStatus);
   return (
     <>
+      <section className={`panel trading-readiness-panel readiness-${String(readinessStatus).toLowerCase()}`}>
+        <div className="panel-head">
+          <span>Trading Game Readiness</span>
+          <strong>{readinessStatus.replaceAll("_", " ")}</strong>
+        </div>
+        <div className="evidence-grid">
+          <SmallDatum label="Evidence Grade" value={readiness?.evidence_grade ?? "pending"} />
+          <SmallDatum label="Source Decisions" value={readiness?.source_decision_count ?? "n/a"} />
+          <SmallDatum label="Trades" value={readiness?.source_trade_count ?? "n/a"} />
+          <SmallDatum label="Eligible Trades" value={readiness?.eligible_trade_count ?? "n/a"} />
+          <SmallDatum label="Ledger Snapshot" value={readiness?.ledger_snapshot_status ?? "n/a"} />
+          <SmallDatum label="Equity Snapshot" value={readiness?.equity_snapshot_status ?? "n/a"} />
+        </div>
+        {(readiness?.blocker || readiness?.next_required_action) && (
+          <p>
+            {readiness?.blocker ? `${readiness.blocker} ` : ""}
+            {readiness?.next_required_action ?? ""}
+          </p>
+        )}
+        {(readiness?.warnings ?? []).length > 0 && (
+          <div className="status-row">
+            {(readiness?.warnings ?? []).slice(0, 4).map((warning: string) => <StatusBadge key={warning} label={warning} />)}
+          </div>
+        )}
+      </section>
+
+      {!canShowEvidence && (
+        <div className="empty-state" style={{ marginTop: 12 }}>
+          Trading evidence is not renderable yet. The backend can keep building it autonomously; the UI will not trigger heavy work from this page.
+        </div>
+      )}
+
+      {canShowEvidence && (
+      <>
       <AsyncPanel title="Trading Game Evidence" loading={loading && !ledgerRows.length} error={error} updatedAt={summary?.data_freshness?.game_updated_at} onRetry={onRetry} fallback="Loading focused trading evidence">
         <section className="grid-3">
           <div className="panel">
@@ -399,6 +446,8 @@ function TradingGameTab({ summary, cycle, loading, error, equityChart, equityPay
           {ledgerRows.length === 0 && <div className="empty-state">No trade ledger rows loaded yet.</div>}
         </div>
       </section>
+      </>
+      )}
     </>
   );
 }

frontend/lib/api.ts

@@ -199,6 +199,9 @@ export const api = {
     postJson<any>("/performance/frontend-widget", payload),
   systemStatus: () => getJson<SystemStatus>("/system/status"),
   brainRuntimeState: () => getJson<any>("/brain/runtime-state"),
+  brainCommandSummary: () => getJson<any>("/brain/command-summary"),
+  brainCapabilities: () => getJson<any>("/brain/capabilities"),
+  brainEvolution: () => getJson<any>("/brain/evolution"),
   snapshotsHealth: () => getJson<any>("/snapshots/health"),
   produceSnapshots: (snapshotType?: string, maxItems = 8) =>
     postJson<any>(`/snapshots/produce?max_items=${maxItems}${snapshotType ? `&snapshot_type=${encodeURIComponent(snapshotType)}` : ""}`, {}),
@@ -239,9 +242,18 @@ export const api = {
   sniperMetrics: () => getJson<any>("/api/sniper/metrics"),
   sniperLessons: (limit = 40) => getJson<any[]>(`/api/sniper/lessons?limit=${limit}`),
   tradingGameStatus: () => getJson<any>("/api/trading-game/status"),
+  tradingGameReadiness: () => getJson<any>("/api/trading-game/readiness"),
   copyTradingStatus: () => getJson<any>("/api/copy-trading/status"),
   copyTradingCandidates: (limit = 25) => getJson<any>(`/api/copy-trading/candidates?limit=${limit}`),
   copyTradingDashboard: (limit = 25) => getJson<any>(`/api/copy-trading/dashboard?limit=${limit}`),
+  alphaReadiness: () => getJson<any>("/api/alpha/readiness"),
+  alphaEdgeMap: (limit = 12) => getJson<any>(`/api/alpha/edge-map?limit=${limit}`),
+  alphaGates: () => getJson<any>("/api/alpha/gates"),
+  paperCopySummary: (limit = 12) => getJson<any>(`/api/paper-copy/summary?limit=${limit}`),
+  paperCopyReadiness: () => getJson<any>("/api/paper-copy/readiness"),
+  paperCopyStrategies: (limit = 40) => getJson<any>(`/api/paper-copy/strategies?limit=${limit}`),
+  paperCopyPositions: (limit = 80) => getJson<any>(`/api/paper-copy/positions?limit=${limit}`),
+  paperCopyPortfolio: (portfolioId: string) => getJson<any>(`/api/paper-copy/portfolio/${encodeURIComponent(portfolioId)}`),
   tradingGameRun: (batchSize = 60) => postJson<any>(`/api/trading-game/run?batch_size=${batchSize}`, {}),
   tradingGameReset: () => postJson<any>("/api/trading-game/reset", {}),
   tradingGameEquity: (limit = 500, gameId?: number) => getJson<any[]>(`/api/trading-game/equity?limit=${limit}${gameId ? `&game_id=${gameId}` : ""}`),

frontend/package.json

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

package.json

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