Harden Blum autonomous learning persistence

README.md

@@ -191,6 +191,7 @@ The reasoning model APIs are backend-only:
 - `POST /model/capture/{ticker}`
 - `POST /model/capture-all`
 - `POST /model/evaluate-outcomes`
+- `POST /model/run-learning-cycle`
 - `GET /model/knowledge`
 - `GET /model/knowledge/{record_id}`
 - `GET /model/memory/search?q=...`
@@ -208,6 +209,8 @@ Training export uses JSONL and targets future Hugging Face training workflows fo
 
 The objective is not to predict stock prices. The objective is to learn how Blum reasons: explain, contextualize, compare, critique, calibrate confidence and improve future thesis quality.
 
+The autonomous Blum Financial Model cycle is server-side and evidence-bound. When `BLUM_ENABLE_LEARNING_LOOP=true`, it runs on startup, during market refresh and on its own interval controlled by `BLUM_MODEL_CYCLE_MINUTES` and `BLUM_MODEL_CYCLE_LIMIT`. Each cycle captures recent signal reasoning, evaluates matured thesis outcomes, refreshes training examples and logs a `blum_model_autonomous_cycle` learning event. It updates database memory only; it does not self-modify source code and it does not execute trades.
+
 ## Chart Vision Technical Analyst
 
 Blum includes a dedicated technical chart intelligence module. It is designed to read financial chart images when a vision model is configured, but it never relies only on visual interpretation.
@@ -439,9 +442,11 @@ Optional self-learning cadence:
 ```bash
 export BLUM_ENABLE_LEARNING_LOOP=true
 export BLUM_LEARNING_LOOP_MINUTES=360
+export BLUM_MODEL_CYCLE_MINUTES=5
+export BLUM_MODEL_CYCLE_LIMIT=120
 ```
 
-The learning loop only updates database memory, confidence adjustments and reversible scoring-weight versions.
+The learning loops only update database memory, confidence adjustments, proprietary reasoning examples and reversible scoring-weight versions.
 
 ## Docker
 
@@ -459,6 +464,8 @@ docker run --rm -p 7860:7860 \
   blum-ai-financial-intelligence
 ```
 
+For Hugging Face Docker demos without an external database, the startup script writes periodic embedded PostgreSQL backups to `/data/blum/embedded_postgres_blum.sql` and restores them on startup when the public schema is empty. This protects the learning memory only when Hugging Face persistent storage is enabled for the `/data` mount. The strict no-reset configuration is still an external `DATABASE_URL`.
+
 ## Hugging Face Spaces Deployment
 
 Use a Docker Space. Upload the repository with:
@@ -477,6 +484,7 @@ The UI exposes `/system/status` in the sidebar and dashboard. If the GUI looks u
 
 - `app_version` must show the latest deployed version.
 - `feature_set` must show the expected feature bundle.
+- `persistence.mode` must be `external_postgres` for strict no-reset durability, or `embedded_postgres` with a populated backup file plus persistent `/data` storage for demo durability.
 - `Financial Brain` shows `fallback mode` unless `BLUM_ENABLE_FINANCIAL_BRAIN_MODEL=true`.
 - Hugging Face serves the previous Docker image until the new build finishes successfully.
 - Existing Market Brain snapshots should be regenerated with `Run brain` after a deployment.

backend/app/api/routes.py

@@ -71,6 +71,7 @@ from app.services.blum_financial_model import (
     narrative_memory,
     quality_overview,
     regime_memory,
+    run_model_learning_cycle,
     self_critique_for_record,
     semantic_reasoning_search,
     training_manifest,
@@ -132,7 +133,7 @@ def system_status(db: Session = Depends(get_db)) -> dict:
     return {
         "service": "blum-ai-financial-intelligence",
         "app_version": settings.app_version,
-        "feature_set": "proprietary-blum-financial-model-v0.7.0",
+        "feature_set": "persistent-autonomous-blum-financial-model-v0.7.1",
         "environment": settings.environment,
         "generated_at": datetime.utcnow().isoformat(),
         "hugging_face": {
@@ -153,11 +154,14 @@ def system_status(db: Session = Depends(get_db)) -> dict:
             "accuracy_audit_minutes": settings.accuracy_audit_minutes,
             "learning_loop_enabled": settings.enable_learning_loop,
             "learning_loop_minutes": settings.learning_loop_minutes,
+            "blum_model_cycle_minutes": settings.blum_model_cycle_minutes,
+            "blum_model_cycle_limit": settings.blum_model_cycle_limit,
             "chart_vision_mode": settings.chart_vision_mode,
             "chart_vision_min_confidence": settings.chart_vision_min_confidence,
             "fundamentals_refresh_minutes": settings.fundamentals_refresh_minutes,
             "macro_refresh_minutes": settings.macro_refresh_minutes,
         },
+        "persistence": database_persistence_status(),
         "active_models": {
             "finbert": settings.finbert_model,
             "embeddings": settings.embedding_model,
@@ -228,11 +232,33 @@ 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 must be regenerated with Run brain or full pipeline after a new deployment.",
-            "Browser cache can keep old static Next.js chunks; hard refresh if app_version is not 0.7.0.",
+            "Browser cache can keep old static Next.js chunks; hard refresh if app_version is not 0.7.1.",
         ],
     }
 
 
+def database_persistence_status() -> dict:
+    backup_file = os.getenv("BLUM_EMBEDDED_POSTGRES_BACKUP_FILE")
+    backup_exists = bool(backup_file and os.path.exists(backup_file))
+    backup_size = os.path.getsize(backup_file) if backup_exists and backup_file else 0
+    uses_external_database = bool(os.getenv("DATABASE_URL")) and not backup_file
+    mode = "external_postgres" if uses_external_database else "embedded_postgres"
+    return {
+        "mode": mode,
+        "external_database_configured": uses_external_database,
+        "embedded_backup_file": backup_file,
+        "embedded_backup_exists": backup_exists,
+        "embedded_backup_size_bytes": backup_size,
+        "embedded_backup_interval_seconds": int(os.getenv("BLUM_DB_BACKUP_SECONDS", "300")),
+        "persistent_dir": os.getenv("BLUM_PERSIST_DIR", "/data/blum"),
+        "strict_no_reset_mode": uses_external_database,
+        "durability_note": (
+            "External DATABASE_URL is the strict no-reset mode. Embedded PostgreSQL backup can recover learning state only "
+            "when Hugging Face persistent storage is enabled for the /data mount."
+        ),
+    }
+
+
 @router.get("/brain/status")
 def financial_brain_status(db: Session = Depends(get_db)) -> dict:
     return brain_status(db)
@@ -309,6 +335,11 @@ def blum_model_evaluate_outcomes(limit: int = Query(default=250, ge=1, le=2000),
     return evaluate_thesis_outcomes(db, limit=limit)
 
 
+@router.post("/model/run-learning-cycle")
+def blum_model_run_learning_cycle(limit: int = Query(default=120, ge=1, le=2000), db: Session = Depends(get_db)) -> dict:
+    return run_model_learning_cycle(db, limit=limit)
+
+
 @router.get("/model/knowledge")
 def blum_model_knowledge_records(
     ticker: str | None = Query(default=None),

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.7.0"
+    app_version: str = "0.7.1"
     environment: str = Field(default="demo", alias="ENVIRONMENT")
     database_url: str = Field(
         default="postgresql+psycopg2://postgres:postgres@127.0.0.1:5432/blum",
@@ -40,6 +40,8 @@ class Settings(BaseSettings):
     accuracy_audit_minutes: int = Field(default=240, alias="BLUM_ACCURACY_AUDIT_MINUTES")
     enable_learning_loop: bool = Field(default=True, alias="BLUM_ENABLE_LEARNING_LOOP")
     learning_loop_minutes: int = Field(default=360, alias="BLUM_LEARNING_LOOP_MINUTES")
+    blum_model_cycle_minutes: int = Field(default=5, alias="BLUM_MODEL_CYCLE_MINUTES")
+    blum_model_cycle_limit: int = Field(default=120, alias="BLUM_MODEL_CYCLE_LIMIT")
     fundamentals_refresh_minutes: int = Field(default=720, alias="BLUM_FUNDAMENTALS_REFRESH_MINUTES")
     macro_refresh_minutes: int = Field(default=240, alias="BLUM_MACRO_REFRESH_MINUTES")
     stale_price_max_age_days: int = Field(default=7, alias="BLUM_STALE_PRICE_MAX_AGE_DAYS")

backend/app/services/blum_financial_model.py

@@ -72,6 +72,47 @@ def model_status(db: Session) -> dict:
     }
 
 
+def run_model_learning_cycle(db: Session, limit: int = 120) -> dict:
+    signals = db.scalars(select(SignalSnapshot).order_by(desc(SignalSnapshot.created_at)).limit(limit)).all()
+    skipped = 0
+    before_count = count(db, BlumKnowledgeRecord.id)
+    for signal in signals:
+        asset = signal.asset or db.get(Asset, signal.asset_id)
+        if asset is None:
+            skipped += 1
+            continue
+        capture_signal_reasoning(db, signal, asset)
+    db.flush()
+    captured = max(0, count(db, BlumKnowledgeRecord.id) - before_count)
+    outcome_result = evaluate_thesis_outcomes(db, limit=limit)
+    dataset_result = build_training_dataset(db, limit=limit, min_quality=55.0)
+    event = LearningEvent(
+        event_type="blum_model_autonomous_cycle",
+        severity="Info",
+        title="Blum Financial Model autonomous cycle completed",
+        description="Captured latest reasoning, evaluated matured thesis outcomes and refreshed proprietary training examples.",
+        payload={
+            "signals_seen": len(signals),
+            "knowledge_records_created": captured,
+            "signals_skipped": skipped,
+            "outcomes": outcome_result,
+            "dataset": dataset_result,
+        },
+    )
+    db.add(event)
+    db.commit()
+    return {
+        "status": "ok",
+        "signals_seen": len(signals),
+        "knowledge_records_created": captured,
+        "signals_skipped": skipped,
+        "outcomes": outcome_result,
+        "dataset": dataset_result,
+        "learning_event_id": event.id,
+        "disclaimer": DISCLAIMER,
+    }
+
+
 def capture_latest_asset_reasoning(db: Session, asset: Asset, source_type: str = "manual_capture") -> dict:
     signal = db.scalar(
         select(SignalSnapshot)

backend/app/services/realtime.py

@@ -10,6 +10,7 @@ from app.core.config import get_settings
 from app.core.database import SessionLocal
 from app.ingestion.news_ingestor import NewsIngestor
 from app.services.accuracy import run_accuracy_audit
+from app.services.blum_financial_model import run_model_learning_cycle
 from app.services.data_continuity import repair_data_gaps
 from app.services.etf import update_etf_trends
 from app.services.fundamentals import update_fundamentals
@@ -52,6 +53,7 @@ def start_realtime_services() -> None:
     _scheduler.add_job(run_ipo_refresh, "interval", minutes=settings.ipo_refresh_minutes, id="ipo_refresh", replace_existing=True, max_instances=1)
     if settings.enable_learning_loop:
         _scheduler.add_job(run_learning_cycle_job, "interval", minutes=settings.learning_loop_minutes, id="financial_brain_learning", replace_existing=True, max_instances=1)
+        _scheduler.add_job(run_blum_model_cycle_job, "interval", minutes=settings.blum_model_cycle_minutes, id="blum_financial_model_cycle", replace_existing=True, max_instances=1)
     _scheduler.start()
     with _state_lock:
         _state["started"] = True
@@ -73,7 +75,8 @@ def run_startup_pipeline() -> None:
     def work(db):
         pipeline = PipelineService().run(db, limit=settings.startup_pipeline_limit, period=settings.historical_price_period)
         learning = run_learning_cycle(db, limit=settings.max_update_assets * 6) if settings.enable_learning_loop else {}
-        return {"pipeline": pipeline, "financial_brain_learning": learning}
+        model_learning = run_model_learning_cycle(db, limit=settings.blum_model_cycle_limit) if settings.enable_learning_loop else {}
+        return {"pipeline": pipeline, "financial_brain_learning": learning, "blum_financial_model": model_learning}
 
     _run_job("startup_pipeline", work)
 
@@ -88,7 +91,8 @@ def run_market_refresh() -> None:
         signals = SignalEngine().run(db, limit=settings.max_update_assets)
         etf = update_etf_trends(db)
         learning = run_learning_cycle(db, limit=settings.max_update_assets * 6) if settings.enable_learning_loop else {}
-        return {"market_update": market, "signal_run": signals, "etf_update": etf, "financial_brain_learning": learning}
+        model_learning = run_model_learning_cycle(db, limit=settings.blum_model_cycle_limit) if settings.enable_learning_loop else {}
+        return {"market_update": market, "signal_run": signals, "etf_update": etf, "financial_brain_learning": learning, "blum_financial_model": model_learning}
 
     _run_job("market_refresh", work)
 
@@ -120,6 +124,10 @@ def run_learning_cycle_job() -> None:
     _run_job("financial_brain_learning", lambda db: run_learning_cycle(db, limit=settings.max_update_assets * 6))
 
 
+def run_blum_model_cycle_job() -> None:
+    _run_job("blum_financial_model_cycle", lambda db: run_model_learning_cycle(db, limit=settings.blum_model_cycle_limit))
+
+
 def _run_job(job_name: str, work):
     with _state_lock:
         if _state["running"]:

frontend/lib/types.ts

@@ -144,9 +144,24 @@ export type SystemStatus = {
     startup_accuracy_seed_enabled?: boolean;
     data_gap_repair_minutes?: number;
     accuracy_audit_minutes?: number;
+    learning_loop_enabled?: boolean;
+    learning_loop_minutes?: number;
+    blum_model_cycle_minutes?: number;
+    blum_model_cycle_limit?: number;
     fundamentals_refresh_minutes?: number;
     macro_refresh_minutes?: number;
   };
+  persistence?: {
+    mode: string;
+    external_database_configured: boolean;
+    embedded_backup_file?: string | null;
+    embedded_backup_exists: boolean;
+    embedded_backup_size_bytes: number;
+    embedded_backup_interval_seconds: number;
+    persistent_dir: string;
+    strict_no_reset_mode: boolean;
+    durability_note: string;
+  };
   active_models: {
     finbert: string;
     embeddings: string;

frontend/package.json

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

package.json

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

scripts/start.sh

@@ -2,13 +2,51 @@
 set -euo pipefail
 
 export PORT="${PORT:-7860}"
+export BLUM_PERSIST_DIR="${BLUM_PERSIST_DIR:-/data/blum}"
+export BLUM_DB_BACKUP_SECONDS="${BLUM_DB_BACKUP_SECONDS:-300}"
+
+backup_embedded_postgres() {
+  if [[ -n "${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE:-}" ]]; then
+    mkdir -p "$(dirname "${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE}")" || true
+    if su postgres -c "pg_dump blum" > "${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE}.tmp"; then
+      mv "${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE}.tmp" "${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE}"
+      echo "Embedded PostgreSQL backup updated at ${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE}."
+    else
+      echo "Embedded PostgreSQL backup failed; keeping previous backup if present."
+      rm -f "${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE}.tmp"
+    fi
+  fi
+}
+
+start_backup_loop() {
+  if [[ -n "${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE:-}" ]]; then
+    (
+      while true; do
+        sleep "${BLUM_DB_BACKUP_SECONDS}"
+        backup_embedded_postgres
+      done
+    ) &
+  fi
+}
 
 if [[ -z "${DATABASE_URL:-}" ]]; then
   echo "No DATABASE_URL provided. Starting embedded PostgreSQL for the Hugging Face Docker demo."
+  mkdir -p "${BLUM_PERSIST_DIR}" || true
   service postgresql start
   su postgres -c "psql -tc \"SELECT 1 FROM pg_database WHERE datname='blum'\" | grep -q 1 || createdb blum"
   su postgres -c "psql -c \"ALTER USER postgres PASSWORD 'postgres';\""
+  export BLUM_EMBEDDED_POSTGRES_BACKUP_FILE="${BLUM_PERSIST_DIR}/embedded_postgres_blum.sql"
+  TABLE_COUNT="$(su postgres -c "psql -d blum -tAc \"SELECT count(*) FROM information_schema.tables WHERE table_schema='public';\"" | tr -d '[:space:]')"
+  if [[ "${TABLE_COUNT:-0}" == "0" && -s "${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE}" ]]; then
+    echo "Restoring embedded PostgreSQL backup from ${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE}."
+    su postgres -c "psql -d blum" < "${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE}" || echo "Backup restore failed; continuing with migrations."
+  elif [[ ! -s "${BLUM_EMBEDDED_POSTGRES_BACKUP_FILE}" ]]; then
+    echo "No embedded PostgreSQL backup found yet. A new backup will be written periodically."
+  else
+    echo "Embedded PostgreSQL already contains tables; skipping restore."
+  fi
   export DATABASE_URL="postgresql+psycopg2://postgres:postgres@127.0.0.1:5432/blum"
+  start_backup_loop
 else
   echo "Using external PostgreSQL DATABASE_URL."
 fi