nexo-brain 3.2.0 → 4.0.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "3.2.0",
+  "version": "4.0.1",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -87,6 +87,16 @@ Versions `3.1.7` through `3.2.0` close the recent-memory gap:
 - when even that misses, NEXO now exposes raw transcript fallback tools for Claude Code and Codex session stores
 - NEXO can now inspect itself through a live system catalog derived from canonical sources instead of relying only on stale docs or operator memory
 
+Version `4.0.1` keeps the 4.0 release aligned across channels while preserving the next memory-surface gap closure:
+
+- non-text artifacts now have a first-class multimodal reference layer instead of living outside the memory model
+- pre-compaction auto-flush now persists actionable session state before context compression can erase it
+- the claim graph now behaves like a public knowledge wiki with evidence, freshness, verification state, and linting
+- operators can export a readable markdown memory bundle instead of trusting only opaque database state
+- user adaptation now uses a richer inspectable user-state model instead of leaning only on shallow sentiment heuristics
+- retrieval exposes more public knobs for hybrid weighting, decomposition, dreams, and dormant-memory handling
+- newer memory layers now declare an explicit backend contract rather than silently hardcoding storage assumptions forever
+
 ### Client Capability Matrix
 
 | Capability | Claude Code | Codex | Claude Desktop |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "3.2.0",
+  "version": "4.0.1",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/agent_runner.py

@@ -275,6 +275,7 @@ def _headless_env(env: dict | None = None) -> dict:
     if env:
         merged.update(env)
     merged["NEXO_HEADLESS"] = "1"
+    merged["NEXO_AUTOMATION"] = "1"
     merged.pop("CLAUDECODE", None)
     merged.pop("CLAUDE_CODE", None)
     return merged

package/src/auto_update.py

@@ -1211,6 +1211,28 @@ def _runtime_flat_files(base_dir: Path) -> list[str]:
     return ordered
 
 
+def _installed_scripts_classification(dest: Path) -> dict[str, str]:
+    scripts_dest = dest / "scripts"
+    if dest != NEXO_HOME or not scripts_dest.is_dir():
+        return {}
+    try:
+        from script_registry import classify_scripts_dir
+
+        entries = classify_scripts_dir().get("entries", [])
+    except Exception as e:
+        _log(f"script ownership inspection skipped: {e}")
+        return {}
+
+    ownership: dict[str, str] = {}
+    for entry in entries:
+        path_value = entry.get("path")
+        classification = str(entry.get("classification", "") or "")
+        if not path_value or not classification:
+            continue
+        ownership[Path(str(path_value)).name] = classification
+    return ownership
+
+
 def _backup_runtime_tree(dest: Path = NEXO_HOME) -> str:
     timestamp = time.strftime("%Y-%m-%d-%H%M%S")
     backup_dir = NEXO_HOME / "backups" / f"runtime-tree-{timestamp}"
@@ -1258,6 +1280,9 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
     flat_files = _runtime_flat_files(src_dir)
     copied_packages = 0
     copied_files = 0
+    copied_scripts = 0
+    script_conflicts: list[dict[str, str]] = []
+    installed_script_classes = _installed_scripts_classification(dest)
 
     _emit_progress(progress_fn, "Copying core packages...")
     for pkg in packages:
@@ -1303,9 +1328,27 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
                     shutil.rmtree(str(dst), ignore_errors=True)
                 shutil.copytree(str(item), str(dst), ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
             elif item.is_file():
+                existing_class = installed_script_classes.get(item.name, "")
+                if dst.exists() and existing_class in {"personal", "non-script"}:
+                    script_conflicts.append(
+                        {
+                            "name": item.name,
+                            "path": str(dst),
+                            "classification": existing_class,
+                            "reason": "existing runtime entry is not core-managed",
+                        }
+                    )
+                    continue
                 shutil.copy2(str(item), str(dst))
                 if item.suffix == ".sh":
                     dst.chmod(0o755)
+                copied_scripts += 1
+
+    if script_conflicts:
+        _emit_progress(
+            progress_fn,
+            f"Preserved {len(script_conflicts)} personal runtime script collision(s); core scripts were not overwritten.",
+        )
 
     _emit_progress(progress_fn, "Copying templates and version metadata...")
     templates_src = repo_dir / "templates"
@@ -1345,6 +1388,8 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
     return {
         "packages": copied_packages,
         "files": copied_files,
+        "scripts": copied_scripts,
+        "script_conflicts": script_conflicts,
         "source": str(src_dir),
         "repo": str(repo_dir),
     }
@@ -1597,10 +1642,18 @@ def manual_sync_update(*, interactive: bool = False, allow_source_pull: bool = T
             "updated": True,
             "packages": copy_stats["packages"],
             "files": copy_stats["files"],
+            "scripts": copy_stats.get("scripts", 0),
             "actions": actions,
+            "warnings": [],
+            "script_conflicts": copy_stats.get("script_conflicts", []),
             "source": copy_stats["source"],
             "repo": copy_stats["repo"],
         })
+        if copy_stats.get("script_conflicts"):
+            sync_result["actions"].append(f"preserved-personal-scripts:{len(copy_stats['script_conflicts'])}")
+            sync_result["warnings"].append(
+                f"Preserved {len(copy_stats['script_conflicts'])} personal runtime script collision(s) in NEXO_HOME/scripts"
+            )
         _emit_progress(progress_fn, "Runtime update completed.")
     except Exception as e:
         _emit_progress(progress_fn, "Update failed; restoring previous runtime state...")

package/src/claim_graph.py

@@ -39,6 +39,72 @@ def _blob_to_array(blob: bytes) -> np.ndarray:
     return np.frombuffer(blob, dtype=np.float32)
 
 
+def _table_columns(table_name: str) -> set[str]:
+    db = _get_db()
+    rows = db.execute(f"PRAGMA table_info({table_name})").fetchall()
+    return {str(row["name"]) for row in rows}
+
+
+def _ensure_column(table_name: str, column_sql: str) -> None:
+    name = column_sql.split()[0]
+    if name in _table_columns(table_name):
+        return
+    db = _get_db()
+    db.execute(f"ALTER TABLE {table_name} ADD COLUMN {column_sql}")
+    db.commit()
+
+
+def _parse_timestamp(raw: str | None) -> datetime | None:
+    if not raw:
+        return None
+    value = str(raw).strip().replace("Z", "+00:00")
+    try:
+        dt = datetime.fromisoformat(value)
+    except Exception:
+        try:
+            dt = datetime.strptime(value, "%Y-%m-%d %H:%M:%S")
+        except Exception:
+            return None
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)
+
+
+def _compute_freshness(row: dict) -> tuple[float, str, int]:
+    freshness_days = max(1, int(row.get("freshness_days") or 30))
+    status = str(row.get("verification_status") or "unverified")
+    anchor = (
+        _parse_timestamp(row.get("verified_at"))
+        or _parse_timestamp(row.get("last_reviewed_at"))
+        or _parse_timestamp(row.get("updated_at"))
+        or _parse_timestamp(row.get("created_at"))
+        or datetime.now(timezone.utc)
+    )
+    age_days = max(0, int((datetime.now(timezone.utc) - anchor).total_seconds() // 86400))
+    score = max(0.0, 1.0 - (age_days / float(freshness_days)))
+    if status == "contradicted":
+        score = min(score, 0.05)
+    elif status == "outdated":
+        score = min(score, 0.25)
+    if age_days > freshness_days:
+        state = "stale"
+    elif age_days > max(1, freshness_days // 2):
+        state = "aging"
+    else:
+        state = "fresh"
+    return round(score, 3), state, age_days
+
+
+def _claim_with_derived_fields(row: dict) -> dict:
+    item = dict(row)
+    item.pop("embedding", None)
+    score, state, age_days = _compute_freshness(item)
+    item["freshness_score"] = score
+    item["freshness_state"] = state
+    item["age_days"] = age_days
+    return item
+
+
 def init_tables():
     """Create claim graph tables if they don't exist."""
     db = _get_db()
@@ -55,6 +121,10 @@ def init_tables():
             verification_status TEXT DEFAULT 'unverified',
             verified_at TEXT,
             domain TEXT DEFAULT '',
+            evidence TEXT DEFAULT '',
+            freshness_days INTEGER DEFAULT 30,
+            freshness_score REAL DEFAULT 1.0,
+            last_reviewed_at TEXT,
             created_at TEXT DEFAULT (datetime('now')),
             updated_at TEXT DEFAULT (datetime('now'))
         );
@@ -75,12 +145,17 @@ def init_tables():
         CREATE INDEX IF NOT EXISTS idx_claim_links_source ON claim_links(source_claim_id);
         CREATE INDEX IF NOT EXISTS idx_claim_links_target ON claim_links(target_claim_id);
     """)
+    _ensure_column("claims", "evidence TEXT DEFAULT ''")
+    _ensure_column("claims", "freshness_days INTEGER DEFAULT 30")
+    _ensure_column("claims", "freshness_score REAL DEFAULT 1.0")
+    _ensure_column("claims", "last_reviewed_at TEXT")
     db.commit()
 
 
 def add_claim(text: str, source_type: str = "", source_id: str = "",
               source_memory_store: str = "", source_memory_id: int = 0,
-              confidence: float = 1.0, domain: str = "") -> dict:
+              confidence: float = 1.0, domain: str = "",
+              evidence: str = "", freshness_days: int = 30) -> dict:
     """Add an atomic claim to the graph.
 
     Returns the claim dict with id, or existing claim if duplicate detected.
@@ -98,17 +173,23 @@ def add_claim(text: str, source_type: str = "", source_id: str = "",
         # Update confidence if new source provides additional evidence
         dup = existing[0]
         new_conf = min(1.0, dup["confidence"] + 0.1)
-        db.execute("UPDATE claims SET confidence = ?, updated_at = datetime('now') WHERE id = ?",
-                   (new_conf, dup["id"]))
+        merged_evidence = str(dup.get("evidence") or "").strip()
+        new_evidence = str(evidence or "").strip()
+        if new_evidence and new_evidence not in merged_evidence:
+            merged_evidence = f"{merged_evidence}\n{new_evidence}".strip()
+        db.execute(
+            "UPDATE claims SET confidence = ?, evidence = ?, freshness_days = ?, freshness_score = 1.0, updated_at = datetime('now') WHERE id = ?",
+            (new_conf, merged_evidence, max(1, int(freshness_days or 30)), dup["id"]),
+        )
         db.commit()
         return {"id": dup["id"], "action": "merged", "confidence": new_conf}
 
     cursor = db.execute(
         """INSERT INTO claims (text, embedding, source_type, source_id,
-           source_memory_store, source_memory_id, confidence, domain)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+           source_memory_store, source_memory_id, confidence, domain, evidence, freshness_days, freshness_score)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1.0)""",
         (text, blob, source_type, source_id, source_memory_store,
-         source_memory_id, confidence, domain)
+         source_memory_id, confidence, domain, str(evidence or "").strip(), max(1, int(freshness_days or 30)))
     )
     db.commit()
     return {"id": cursor.lastrowid, "action": "added", "confidence": confidence}
@@ -131,8 +212,7 @@ def find_similar_claims(text: str, threshold: float = 0.8, limit: int = 10) -> l
         vec = _blob_to_array(row["embedding"])
         score = _cosine_similarity(query_vec, vec)
         if score >= threshold:
-            d = dict(row)
-            d.pop("embedding", None)
+            d = _claim_with_derived_fields(dict(row))
             d["similarity"] = round(score, 4)
             results.append(d)
 
@@ -225,15 +305,13 @@ def verify_claim(claim_id: int, status: str = "confirmed") -> dict:
 
     db.execute(
         "UPDATE claims SET verification_status = ?, verified_at = datetime('now'), "
-        "updated_at = datetime('now') WHERE id = ?",
+        "last_reviewed_at = datetime('now'), freshness_score = 1.0, updated_at = datetime('now') WHERE id = ?",
         (status, claim_id)
     )
     db.commit()
     row = db.execute("SELECT * FROM claims WHERE id = ?", (claim_id,)).fetchone()
     if row:
-        d = dict(row)
-        d.pop("embedding", None)
-        return d
+        return _claim_with_derived_fields(dict(row))
     return {"error": f"Claim {claim_id} not found"}
 
 
@@ -246,8 +324,7 @@ def get_claim(claim_id: int) -> Optional[dict]:
     if not row:
         return None
 
-    d = dict(row)
-    d.pop("embedding", None)
+    d = _claim_with_derived_fields(dict(row))
 
     # Get links
     outgoing = db.execute(
@@ -290,7 +367,41 @@ def search_claims(query: str = "", domain: str = "", status: str = "",
         f"domain, created_at FROM claims WHERE {where} ORDER BY created_at DESC LIMIT ?",
         params + [limit]
     ).fetchall()
-    return [dict(r) for r in rows]
+    return [_claim_with_derived_fields(dict(r)) for r in rows]
+
+
+def lint_claims(max_age_days: int = 30, limit: int = 20) -> list[dict]:
+    """Return stale, weak, or contradictory claims that need review."""
+    db = _get_db()
+    init_tables()
+
+    rows = db.execute(
+        "SELECT * FROM claims ORDER BY updated_at DESC, created_at DESC LIMIT 500"
+    ).fetchall()
+    results = []
+    for row in rows:
+        item = _claim_with_derived_fields(dict(row))
+        reasons = []
+        if item["verification_status"] == "unverified" and item["age_days"] >= max_age_days:
+            reasons.append("unverified-too-old")
+        if item["freshness_state"] == "stale":
+            reasons.append("stale")
+        if item["verification_status"] in {"contradicted", "outdated"}:
+            reasons.append(item["verification_status"])
+        if not str(item.get("evidence") or "").strip():
+            reasons.append("missing-evidence")
+        if reasons:
+            item["lint_reasons"] = reasons
+            results.append(item)
+    results.sort(
+        key=lambda item: (
+            "contradicted" not in item["lint_reasons"],
+            "stale" not in item["lint_reasons"],
+            item["freshness_score"],
+            -item["age_days"],
+        )
+    )
+    return results[: max(1, int(limit or 20))]
 
 
 def stats() -> dict:
@@ -313,6 +424,7 @@ def stats() -> dict:
     contradictions = db.execute(
         "SELECT COUNT(*) FROM claim_links WHERE relation = 'contradicts'"
     ).fetchone()[0]
+    stale = len(lint_claims(max_age_days=30, limit=10000))
 
     return {
         "total_claims": total,
@@ -320,4 +432,5 @@ def stats() -> dict:
         "by_domain": by_domain,
         "total_links": links,
         "contradictions": contradictions,
+        "lint_attention": stale,
     }

package/src/cognitive/_trust.py

@@ -1,7 +1,7 @@
 """NEXO Cognitive — Trust scoring, sentiment, dissonance."""
 import re
 import numpy as np
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from cognitive._core import _get_db, embed, cosine_similarity, _blob_to_array
 from cognitive._core import POSITIVE_SIGNALS, NEGATIVE_SIGNALS, URGENCY_SIGNALS
 
@@ -412,7 +412,7 @@ def adjust_trust(event: str, context: str = "", custom_delta: float = None) -> d
 def get_trust_history(days: int = 7) -> dict:
     """Get trust score history and sentiment summary."""
     db = _get_db()
-    cutoff = (datetime.utcnow() - timedelta(days=days)).isoformat()
+    cutoff = (datetime.now(timezone.utc) - timedelta(days=days)).isoformat()
 
     # Trust events
     events = db.execute(

package/src/compaction_memory.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+"""Pre-compaction auto-flush helpers."""
+
+import json
+from pathlib import Path
+
+from db import get_db
+from db._hot_context import capture_context_event
+from memory_backends import get_backend
+
+
+def init_tables() -> None:
+    conn = get_db()
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS session_auto_flush (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            task TEXT DEFAULT '',
+            current_goal TEXT DEFAULT '',
+            summary TEXT DEFAULT '',
+            next_step TEXT DEFAULT '',
+            metadata TEXT DEFAULT '{}',
+            source TEXT DEFAULT 'pre-compact-hook',
+            backend_key TEXT DEFAULT 'sqlite',
+            created_at TEXT DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_session_auto_flush_sid ON session_auto_flush(session_id);
+        CREATE INDEX IF NOT EXISTS idx_session_auto_flush_created ON session_auto_flush(created_at);
+        """
+    )
+    conn.commit()
+
+
+def _load_tool_entries(log_file: str = "", last_diary_ts: str = "") -> list[dict]:
+    path = Path(log_file).expanduser()
+    if not path.is_file():
+        return []
+    entries: list[dict] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for raw_line in handle:
+            raw_line = raw_line.strip()
+            if not raw_line:
+                continue
+            try:
+                item = json.loads(raw_line)
+            except Exception:
+                continue
+            ts = str(item.get("timestamp", "") or "")
+            if last_diary_ts and ts and ts < last_diary_ts:
+                continue
+            entries.append(item)
+    return entries
+
+
+def _derive_bundle(task: str, current_goal: str, entries: list[dict]) -> dict:
+    tool_counts: dict[str, int] = {}
+    modified_files: list[str] = []
+    git_actions: list[str] = []
+    last_briefs: list[str] = []
+    for entry in entries:
+        name = str(entry.get("tool_name", "?") or "?")
+        tool_counts[name] = tool_counts.get(name, 0) + 1
+        payload = entry.get("tool_input") or {}
+        if isinstance(payload, dict):
+            file_path = str(payload.get("file_path") or payload.get("path") or "").strip()
+            if file_path:
+                modified_files.append(file_path.split("/")[-1])
+            if name == "Bash":
+                cmd = str(payload.get("command") or "").strip()
+                if cmd:
+                    if "git " in cmd:
+                        git_actions.append(cmd[:120])
+                    if len(last_briefs) < 5:
+                        last_briefs.append(cmd[:120])
+            else:
+                for _, value in list(payload.items())[:1]:
+                    text = str(value).strip()
+                    if text:
+                        last_briefs.append(text[:120])
+                        break
+    top_tools = sorted(tool_counts.items(), key=lambda item: (-item[1], item[0]))[:5]
+    top_tools_str = ", ".join(f"{name} x{count}" for name, count in top_tools) or "no tool activity"
+    unique_files = sorted({name for name in modified_files if name})[:12]
+    file_str = ", ".join(unique_files) if unique_files else "no file writes detected"
+    next_step = (current_goal or "").strip() or (task or "").strip() or "Resume from tool logs and hot context."
+    summary = (
+        f"Auto-flush captured {len(entries)} tool calls. "
+        f"Top tools: {top_tools_str}. "
+        f"Files: {file_str}."
+    )
+    return {
+        "summary": summary,
+        "next_step": next_step[:400],
+        "metadata": {
+            "entry_count": len(entries),
+            "top_tools": top_tools,
+            "modified_files": unique_files,
+            "git_actions": git_actions[:10],
+            "recent_inputs": last_briefs[:10],
+        },
+    }
+
+
+def record_auto_flush(
+    *,
+    session_id: str,
+    task: str = "",
+    current_goal: str = "",
+    log_file: str = "",
+    last_diary_ts: str = "",
+    source: str = "pre-compact-hook",
+) -> dict:
+    init_tables()
+    entries = _load_tool_entries(log_file=log_file, last_diary_ts=last_diary_ts)
+    if not entries and not task.strip() and not current_goal.strip():
+        return {"skipped": True, "reason": "no task and no tool activity"}
+
+    bundle = _derive_bundle(task, current_goal, entries)
+    conn = get_db()
+    backend = get_backend()
+    cursor = conn.execute(
+        """
+        INSERT INTO session_auto_flush (
+            session_id, task, current_goal, summary, next_step, metadata, source, backend_key
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            session_id.strip() or "unknown",
+            task.strip(),
+            current_goal.strip(),
+            bundle["summary"],
+            bundle["next_step"],
+            json.dumps(bundle["metadata"], ensure_ascii=True, sort_keys=True),
+            source.strip() or "pre-compact-hook",
+            backend.key,
+        ),
+    )
+    conn.commit()
+    flush_id = int(cursor.lastrowid)
+
+    try:
+        capture_context_event(
+            event_type="auto_flush",
+            title=(task or current_goal or f"auto-flush {session_id}")[:160],
+            summary=bundle["summary"][:600],
+            body=bundle["next_step"][:1600],
+            context_key=f"session:{session_id}",
+            context_title=(task or current_goal or session_id)[:160],
+            context_summary=bundle["summary"][:600],
+            context_type="session",
+            state="active",
+            actor="system",
+            source_type="session",
+            source_id=session_id,
+            session_id=session_id,
+            metadata={"auto_flush_id": flush_id, **bundle["metadata"]},
+        )
+    except Exception:
+        pass
+
+    try:
+        import cognitive
+
+        cognitive.ingest(
+            f"Auto-flush for session {session_id}. {bundle['summary']} Next step: {bundle['next_step']}",
+            "auto_flush",
+            f"AF{flush_id}",
+            (task or current_goal or f"auto-flush {session_id}")[:120],
+            "nexo",
+        )
+    except Exception:
+        pass
+
+    row = conn.execute("SELECT * FROM session_auto_flush WHERE id = ?", (flush_id,)).fetchone()
+    result = dict(row) if row else {"id": flush_id}
+    try:
+        result["metadata"] = json.loads(result.get("metadata") or "{}")
+    except Exception:
+        result["metadata"] = {}
+    return result
+
+
+def list_auto_flushes(session_id: str = "", limit: int = 20) -> list[dict]:
+    init_tables()
+    conn = get_db()
+    if session_id.strip():
+        rows = conn.execute(
+            "SELECT * FROM session_auto_flush WHERE session_id = ? ORDER BY created_at DESC, id DESC LIMIT ?",
+            (session_id.strip(), max(1, int(limit or 20))),
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT * FROM session_auto_flush ORDER BY created_at DESC, id DESC LIMIT ?",
+            (max(1, int(limit or 20)),),
+        ).fetchall()
+    results = []
+    for row in rows:
+        item = dict(row)
+        try:
+            item["metadata"] = json.loads(item.get("metadata") or "{}")
+        except Exception:
+            item["metadata"] = {}
+        results.append(item)
+    return results
+
+
+def auto_flush_stats(days: int = 7) -> dict:
+    init_tables()
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT source, COUNT(*) AS cnt FROM session_auto_flush WHERE created_at >= datetime('now', ?) GROUP BY source",
+        (f"-{max(1, int(days or 7))} days",),
+    ).fetchall()
+    total = int(
+        conn.execute(
+            "SELECT COUNT(*) FROM session_auto_flush WHERE created_at >= datetime('now', ?)",
+            (f"-{max(1, int(days or 7))} days",),
+        ).fetchone()[0]
+    )
+    return {
+        "window_days": max(1, int(days or 7)),
+        "total": total,
+        "by_source": {row["source"]: row["cnt"] for row in rows},
+        "backend": get_backend().key,
+    }

package/src/dashboard/app.py

@@ -14,6 +14,7 @@ import subprocess
 import sys
 import time
 import webbrowser
+from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Optional
 
@@ -30,27 +31,16 @@ if _PARENT not in sys.path:
 
 from agent_runner import AgentRunnerError, build_followup_terminal_shell_command
 
-app = FastAPI(title="NEXO Brain Dashboard", version="3.0.1")
-
 TEMPLATES_DIR = Path(__file__).resolve().parent / "templates"
 STATIC_DIR = Path(__file__).resolve().parent / "static"
 
-# Mount static files
-STATIC_DIR.mkdir(exist_ok=True)
-app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
-
 # Jinja2 environment
 jinja_env = Environment(
     loader=FileSystemLoader(str(TEMPLATES_DIR)),
     autoescape=True,
 )
 
-# ---------------------------------------------------------------------------
-# Startup — create dashboard_notes table
-# ---------------------------------------------------------------------------
-
-@app.on_event("startup")
-async def create_tables():
+def _create_tables() -> None:
     db = _db()
     conn = db.get_db()
     conn.execute("""
@@ -71,6 +61,19 @@ async def create_tables():
     conn.commit()
 
 
+@asynccontextmanager
+async def _dashboard_lifespan(_: FastAPI):
+    _create_tables()
+    yield
+
+
+app = FastAPI(title="NEXO Brain Dashboard", version="3.0.1", lifespan=_dashboard_lifespan)
+
+# Mount static files
+STATIC_DIR.mkdir(exist_ok=True)
+app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+
+
 # ---------------------------------------------------------------------------
 # Lazy imports — modules live in the parent source directory
 # ---------------------------------------------------------------------------