nexo-brain 0.7.0 → 0.8.0

package/README.md

@@ -1,12 +1,12 @@
 # NEXO Brain — Your AI Gets a Brain
 
-[![npm v0.6.0](https://img.shields.io/npm/v/nexo-brain?label=npm&color=purple)](https://www.npmjs.com/package/nexo-brain)
+[![npm v0.8.0](https://img.shields.io/npm/v/nexo-brain?label=npm&color=purple)](https://www.npmjs.com/package/nexo-brain)
 [![F1 0.588 on LoCoMo](https://img.shields.io/badge/LoCoMo_F1-0.588-brightgreen)](https://github.com/wazionapps/nexo/blob/main/benchmarks/locomo/results/)
 [![+55% vs GPT-4](https://img.shields.io/badge/vs_GPT--4-%2B55%25-blue)](https://github.com/snap-research/locomo/issues/33)
 [![GitHub stars](https://img.shields.io/github/stars/wazionapps/nexo?style=social)](https://github.com/wazionapps/nexo/stargazers)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-> **v0.6.0** — Now ships with **full orchestration**: 5 automated hooks, mandatory post-mortem with self-critique, pre-compaction context preservation, reflection engine, and auto-migration. Plus: F1 **0.588** on [LoCoMo](https://github.com/snap-research/locomo) (ACL 2024) — outperforms GPT-4 by 55%. Runs on CPU. [Full results](benchmarks/locomo/results/)
+> **v0.8.0** — Knowledge Graph (988 bi-temporal nodes, D3 visualization), Web Dashboard (6 pages at localhost:6174), Cross-Platform support (Linux + Windows), Smart dedup with event-sourced edges, and 4 new KG tools.
 
 **NEXO Brain transforms any MCP-compatible AI agent from a stateless assistant into a cognitive partner that remembers, learns, forgets, adapts, and builds a relationship with you over time.**
 
@@ -132,7 +132,7 @@ If your Mac was asleep during any scheduled process, NEXO Brain catches up in or
 
 ## Cognitive Features
 
-NEXO Brain provides 21 cognitive tools on top of the 76 base tools, totaling **97+ MCP tools**. These features implement cognitive science concepts that go beyond basic memory:
+NEXO Brain provides 25 cognitive tools on top of the 76 base tools, totaling **109+ MCP tools**. These features implement cognitive science concepts that go beyond basic memory:
 
 ### Input Pipeline
 
@@ -198,7 +198,7 @@ NEXO Brain was evaluated on [LoCoMo](https://github.com/snap-research/locomo) (A
 
 Full results in [`benchmarks/locomo/results/`](benchmarks/locomo/results/).
 
-## Full Orchestration System (v0.6.0)
+## Full Orchestration System (v0.7.0)
 
 Memory alone doesn't make a co-operator. What makes the difference is the **behavioral loop** — the automated discipline that ensures every session starts informed, runs with guardrails, and ends with self-reflection.
 
@@ -257,6 +257,33 @@ npx nexo-brain  # detects v0.5.0, migrates automatically
 - **Never touches your data** (memories, learnings, preferences)
 - Saves updated CLAUDE.md as reference (doesn't overwrite customizations)
 
+## Knowledge Graph & Dashboard (v0.8.0)
+
+### Knowledge Graph
+A bi-temporal entity-relationship graph with 988 nodes and 896 edges. Entities and relationships carry both valid-time (when the fact was true) and system-time (when it was recorded), enabling temporal queries like "what did we know about X last Tuesday?". BFS traversal discovers multi-hop connections between concepts. Event-sourced edges with smart dedup (ADD/UPDATE/NOOP) prevent redundant writes while preserving full history.
+
+4 new MCP tools: `nexo_kg_query` (SPARQL-like queries), `nexo_kg_path` (shortest path between entities), `nexo_kg_neighbors` (direct connections), `nexo_kg_stats` (graph metrics).
+
+### Web Dashboard
+A visual interface at `localhost:6174` with 6 pages: Overview (system health at a glance), Graph (interactive D3.js visualization of the knowledge graph), Memory (browse and search all memory stores), Somatic (pain map per file/area), Adaptive (personality signals and weights), and Sessions (active and historical sessions). Built with FastAPI backend and D3.js frontend.
+
+### Cross-Platform Support
+v0.8.0 adds full Linux and Windows support. The installer detects the platform and configures the appropriate process manager (LaunchAgents on macOS, systemd on Linux, Task Scheduler on Windows). Opportunistic maintenance runs cognitive processes when resources are available.
+
+### Storage Router
+A new abstraction layer routes storage operations through a unified interface, making the system multi-tenant ready. Each operator's data is isolated while sharing the same cognitive engine.
+
+## Learned Weights & Somatic Markers (v0.7.0)
+
+### Adaptive Learned Weights
+Signal weights learn from real user feedback via Ridge regression. A 2-week shadow mode observes before activating. Weight momentum (85/15 blend) prevents personality whiplash. Automatic rollback if correction rate doubles.
+
+### Somatic Markers (Pain Memory)
+Files and areas that cause repeated errors accumulate a risk score (0.0–1.0). The guard system warns on HIGH RISK (>0.5) and CRITICAL RISK (>0.8), lowering thresholds for more paranoid checking. Clean guard checks reduce risk multiplicatively (×0.7). Nightly decay (×0.95) ensures old pain fades.
+
+### Adaptive Personality v2
+6 weighted signals: vibe, corrections, brevity, topic, tool errors, git diff. Emergency keywords bypass hysteresis. Severity-weighted decay. Manual override via `nexo_adaptive_override`.
+
 ## Quick Start
 
 ### Claude Code (Primary)
@@ -305,7 +332,7 @@ That's it. No need to run `claude` manually. Atlas will greet you immediately
 | Component | What | Where |
 |-----------|------|-------|
 | Cognitive engine | Python: fastembed, numpy, vector search | pip packages |
-| MCP server | 97+ tools for memory, cognition, learning, guard | ~/.nexo/ |
+| MCP server | 105+ tools for memory, cognition, learning, guard | ~/.nexo/ |
 | Plugins | Guard, episodic memory, cognitive memory, entities, preferences | ~/.nexo/plugins/ |
 | Hooks (5) | SessionStart briefing, Stop post-mortem, PostToolUse capture, PreCompact checkpoint, Caffeinate | ~/.nexo/hooks/ |
 | Reflection engine | Processes session buffer, extracts patterns, updates user model | ~/.nexo/scripts/ |
@@ -316,14 +343,14 @@ That's it. No need to run `claude` manually. Atlas will greet you immediately
 
 ### Requirements
 
-- **macOS** (Linux support planned)
+- **macOS, Linux, or Windows**
 - **Node.js 18+** (for the installer)
-- **Claude Opus (latest version) strongly recommended.** NEXO Brain provides 97+ MCP tools across 17 categories. This cognitive load requires a top-tier model with large context window. Smaller models (Haiku, Sonnet) may struggle with tool selection and produce inconsistent results. Opus handles all 97+ tools without hesitation.
+- **Claude Opus (latest version) strongly recommended.** NEXO Brain provides 109+ MCP tools across 17 categories. This cognitive load requires a top-tier model with large context window. Smaller models (Haiku, Sonnet) may struggle with tool selection and produce inconsistent results. Opus handles all 105+ tools without hesitation.
 - Python 3, Homebrew, and Claude Code are installed automatically if missing.
 
 ## Architecture
 
-### 97+ MCP Tools across 17 Categories
+### 109+ MCP Tools across 19 Categories
 
 | Category | Count | Tools | Purpose |
 |----------|-------|-------|---------|
@@ -345,6 +372,8 @@ That's it. No need to run `claude` manually. Atlas will greet you immediately
 | Agents | 5 | get, create, update, delete, list | Agent delegation registry |
 | Backup | 3 | now, list, restore | SQLite data safety |
 | Evolution | 5 | propose, approve, reject, status, history | Self-improvement proposals |
+| Adaptive & Somatic (4) | nexo_adaptive_weights, nexo_adaptive_override, nexo_somatic_check, nexo_somatic_stats |
+| Knowledge Graph | 4 | kg_query, kg_path, kg_neighbors, kg_stats | Bi-temporal entity-relationship graph |
 
 ### Plugin System
 
@@ -402,7 +431,7 @@ NEXO Brain is designed as an MCP server. Claude Code is the primary supported cl
 npx nexo-brain
 ```
 
-All 97+ tools are available immediately after installation. The installer configures Claude Code's `~/.claude/settings.json` automatically.
+All 105+ tools are available immediately after installation. The installer configures Claude Code's `~/.claude/settings.json` automatically.
 
 ### OpenClaw
 

package/bin/nexo-brain.js

@@ -70,8 +70,8 @@ async function main() {
 
   // Check prerequisites
   const platform = process.platform;
-  if (platform !== "darwin") {
-    log("NEXO currently supports macOS only. Linux support coming soon.");
+  if (platform !== "darwin" && platform !== "linux" && platform !== "win32") {
+    log(`Unsupported platform: ${platform}. NEXO supports macOS, Linux, and Windows.`);
     process.exit(1);
   }
 
@@ -105,6 +105,7 @@ async function main() {
         // Update core Python files
         const srcDir = path.join(__dirname, "..", "src");
         ["server.py", "db.py", "plugin_loader.py", "cognitive.py",
+         "knowledge_graph.py", "kg_populate.py", "maintenance.py", "storage_router.py",
          "tools_sessions.py", "tools_coordination.py", "tools_reminders.py",
          "tools_reminders_crud.py", "tools_learnings.py", "tools_credentials.py",
          "tools_task_history.py", "tools_menu.py"].forEach((f) => {
@@ -126,6 +127,27 @@ async function main() {
         }
         log("  Plugins updated.");
 
+        // Update dashboard
+        const dashSrc = path.join(srcDir, "dashboard");
+        const dashDest = path.join(NEXO_HOME, "dashboard");
+        if (fs.existsSync(dashSrc)) {
+          fs.mkdirSync(dashDest, { recursive: true });
+          const copyDir = (src, dest) => {
+            fs.readdirSync(src).forEach(item => {
+              const srcPath = path.join(src, item);
+              const destPath = path.join(dest, item);
+              if (fs.statSync(srcPath).isDirectory()) {
+                fs.mkdirSync(destPath, { recursive: true });
+                copyDir(srcPath, destPath);
+              } else {
+                fs.copyFileSync(srcPath, destPath);
+              }
+            });
+          };
+          copyDir(dashSrc, dashDest);
+          log("  Dashboard updated.");
+        }
+
         // Update scripts
         const scriptsSrc = path.join(srcDir, "scripts");
         const scriptsDest = path.join(NEXO_HOME, "scripts");
@@ -590,8 +612,9 @@ Operator name: ${operatorName}
   fs.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
   log("MCP server + hooks configured in Claude Code settings.");
 
-  // Step 7: Install LaunchAgents
+  // Step 7: Install LaunchAgents (macOS only)
   log("Setting up automated processes...");
+  if (platform === "darwin") {
   fs.mkdirSync(LAUNCH_AGENTS, { recursive: true });
 
   const agents = [
@@ -724,6 +747,10 @@ Operator name: ${operatorName}
     } catch {}
     log("Caffeinate enabled — Mac will stay awake for cognitive processes.");
   }
+  } else {
+    log("Non-macOS platform: background tasks will run via catch-up on startup.");
+    log("  No OS scheduler configured — NEXO runs maintenance when MCP starts.");
+  }
 
   // Step 8: Create shell alias so user can just type the operator's name
   log("Creating shell alias...");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — Cognitive co-operator for Claude Code. Atkinson-Shiffrin memory, semantic RAG, trust scoring, and metacognitive error prevention.",
   "bin": {

package/src/cognitive.py

@@ -30,7 +30,7 @@ DISCRIMINATING_ENTITIES = {
     # OS / Environment
     "linux", "mac", "macos", "windows", "darwin", "ubuntu", "debian", "alpine",
     # Platforms
-    "shopify", "wazion", "whatsapp", "chrome", "firefox",
+    "shopify", "whatsapp", "chrome", "firefox",
     # Languages / Runtimes
     "python", "php", "javascript", "typescript", "node", "deno", "ruby",
     # Versions
@@ -65,12 +65,12 @@ URGENCY_SIGNALS = {
 _DEFAULT_TRUST_EVENTS = {
     # Positive
     "explicit_thanks": +3,
-    "delegation": +2,        # the user delegates new task without micromanaging
-    "paradigm_shift": +2,    # the user teaches, NEXO learns
+    "delegation": +2,        # User delegates new task without micromanaging
+    "paradigm_shift": +2,    # User teaches, NEXO learns
     "sibling_detected": +3,  # NEXO avoided context error on its own
     "proactive_action": +2,  # NEXO did something useful without being asked
     # Negative
-    "correction": -3,        # the user corrects NEXO
+    "correction": -3,        # User corrects NEXO
     "repeated_error": -7,    # Error on something NEXO already had a learning for
     "override": -5,          # NEXO's memory was wrong
     "correction_fatigue": -10, # Same memory corrected 3+ times
@@ -395,7 +395,7 @@ def _init_tables(conn: sqlite3.Connection):
             created_at TEXT DEFAULT (datetime('now'))
         );
 
-        -- Sentiment readings: the user's detected mood per interaction
+        -- Sentiment readings: User's detected mood per interaction
         CREATE TABLE IF NOT EXISTS sentiment_log (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             sentiment TEXT NOT NULL,       -- 'positive', 'negative', 'neutral', 'urgent'
@@ -421,13 +421,13 @@ def _init_tables(conn: sqlite3.Connection):
             status TEXT DEFAULT 'pending'
         );
 
-        -- Correction tracking: when the user overrides a memory's guidance
+        -- Correction tracking: when User overrides a memory's guidance
         CREATE TABLE IF NOT EXISTS memory_corrections (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             memory_id INTEGER NOT NULL,
             store TEXT NOT NULL,           -- 'stm' or 'ltm'
             correction_type TEXT NOT NULL, -- 'override', 'exception', 'paradigm_shift'
-            context TEXT DEFAULT '',       -- what the user said
+            context TEXT DEFAULT '',       -- what User said
             created_at TEXT DEFAULT (datetime('now'))
         );
     """)
@@ -494,6 +494,39 @@ def _init_tables(conn: sqlite3.Connection):
     """)
     conn.execute("CREATE INDEX IF NOT EXISTS idx_somatic_target ON somatic_markers(target)")
 
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS kg_nodes (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            node_type TEXT NOT NULL,
+            node_ref TEXT NOT NULL,
+            label TEXT NOT NULL,
+            properties TEXT DEFAULT '{}',
+            created_at TEXT DEFAULT (datetime('now')),
+            UNIQUE(node_type, node_ref)
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_nodes_type ON kg_nodes(node_type)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_nodes_label ON kg_nodes(label)")
+
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS kg_edges (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            source_id INTEGER NOT NULL REFERENCES kg_nodes(id),
+            target_id INTEGER NOT NULL REFERENCES kg_nodes(id),
+            relation TEXT NOT NULL,
+            weight REAL DEFAULT 1.0,
+            confidence REAL DEFAULT 1.0,
+            valid_from TEXT DEFAULT (datetime('now')),
+            valid_until TEXT DEFAULT NULL,
+            source_memory_id TEXT DEFAULT '',
+            properties TEXT DEFAULT '{}',
+            created_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_edges_source ON kg_edges(source_id)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_edges_target ON kg_edges(target_id)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_edges_relation ON kg_edges(relation)")
+
     conn.commit()
 
 
@@ -2511,12 +2544,12 @@ def get_siblings(memory_id: int) -> list[dict]:
 def detect_dissonance(new_instruction: str, min_score: float = 0.65) -> list[dict]:
     """Detect cognitive dissonance: find LTM memories that contradict a new instruction.
 
-    When the user gives a new instruction that conflicts with established LTM memories
+    When User gives a new instruction that conflicts with established LTM memories
     (strength > 0.8), this function surfaces the conflict so NEXO can verbalize it
     rather than silently obeying or silently resisting.
 
     Args:
-        new_instruction: The new instruction or preference from the user
+        new_instruction: The new instruction or preference from User
         min_score: Minimum cosine similarity to consider as potential conflict
 
     Returns:
@@ -2551,12 +2584,12 @@ def detect_dissonance(new_instruction: str, min_score: float = 0.65) -> list[dic
 
 
 def resolve_dissonance(memory_id: int, resolution: str, context: str = "") -> str:
-    """Resolve a cognitive dissonance by applying the user's decision.
+    """Resolve a cognitive dissonance by applying User's decision.
 
     Args:
         memory_id: The LTM memory that conflicts with the new instruction
         resolution: One of:
-            - 'paradigm_shift': the user changed his mind permanently. Decay old memory,
+            - 'paradigm_shift': User changed his mind permanently. Decay old memory,
               new instruction becomes the standard.
             - 'exception': This is a one-time override. Keep old memory as standard.
             - 'override': Old memory was wrong. Mark as corrupted and decay to dormant.
@@ -2607,7 +2640,7 @@ def resolve_dissonance(memory_id: int, resolution: str, context: str = "") -> st
 def check_correction_fatigue() -> list[dict]:
     """Find memories corrected 3+ times in the last 7 days — mark as 'under review'.
 
-    These memories are unreliable: the user keeps overriding them, suggesting
+    These memories are unreliable: User keeps overriding them, suggesting
     the memory itself may be wrong or outdated.
 
     Returns:
@@ -2655,7 +2688,7 @@ def check_correction_fatigue() -> list[dict]:
 
 
 def detect_sentiment(text: str) -> dict:
-    """Analyze the user's text for sentiment signals.
+    """Analyze User's text for sentiment signals.
 
     Returns detected sentiment, intensity, and action guidance for NEXO.
     Not a model — keyword + heuristic based. Fast and deterministic.
@@ -2719,7 +2752,7 @@ def detect_sentiment(text: str) -> dict:
 
 
 def log_sentiment(text: str) -> dict:
-    """Detect and log the user's sentiment. Returns the detection result."""
+    """Detect and log User's sentiment. Returns the detection result."""
     result = detect_sentiment(text)
     if result["sentiment"] != "neutral":
         db = _get_db()

package/src/dashboard/app.py

@@ -0,0 +1,277 @@
+"""NEXO Brain Dashboard — FastAPI app for inspecting cognitive state.
+
+Local dashboard: graphs, memories, somatic markers, trust, adaptive personality.
+Runs on-demand (not embedded in MCP stdio). Opens browser automatically.
+
+Usage:
+    python3 -m dashboard.app [--port 6174] [--no-browser]
+"""
+
+import argparse
+import json
+import os
+import sys
+import webbrowser
+from pathlib import Path
+
+from fastapi import FastAPI, Query, Request
+from fastapi.responses import HTMLResponse, JSONResponse
+
+# Add parent dir to path so we can import nexo-mcp modules
+_PARENT = str(Path(__file__).resolve().parent.parent)
+if _PARENT not in sys.path:
+    sys.path.insert(0, _PARENT)
+
+app = FastAPI(title="NEXO Brain Dashboard", version="1.0.0")
+
+TEMPLATES_DIR = Path(__file__).resolve().parent / "templates"
+
+# ---------------------------------------------------------------------------
+# Lazy imports — modules live in the parent nexo-mcp directory
+# ---------------------------------------------------------------------------
+
+def _cognitive():
+    import cognitive
+    return cognitive
+
+def _knowledge_graph():
+    import knowledge_graph as kg
+    return kg
+
+def _db():
+    import db as nexo_db
+    return nexo_db
+
+def _adaptive():
+    from plugins import adaptive_mode
+    return adaptive_mode
+
+
+# ---------------------------------------------------------------------------
+# HTML page routes — serve template files
+# ---------------------------------------------------------------------------
+
+def _render_template(name: str) -> HTMLResponse:
+    """Read a template file and return as HTML."""
+    path = TEMPLATES_DIR / name
+    if not path.exists():
+        return HTMLResponse(
+            f"<html><body><h1>Template not found: {name}</h1>"
+            f"<p>Create it at <code>{path}</code></p></body></html>",
+            status_code=200,
+        )
+    return HTMLResponse(path.read_text(encoding="utf-8"))
+
+
+@app.get("/", response_class=HTMLResponse)
+async def page_overview():
+    return _render_template("overview.html")
+
+
+@app.get("/graph", response_class=HTMLResponse)
+async def page_graph():
+    return _render_template("graph.html")
+
+
+@app.get("/memory", response_class=HTMLResponse)
+async def page_memory():
+    return _render_template("memory.html")
+
+
+@app.get("/somatic", response_class=HTMLResponse)
+async def page_somatic():
+    return _render_template("somatic.html")
+
+
+@app.get("/adaptive", response_class=HTMLResponse)
+async def page_adaptive():
+    return _render_template("adaptive.html")
+
+
+@app.get("/sessions", response_class=HTMLResponse)
+async def page_sessions():
+    return _render_template("sessions.html")
+
+
+# ---------------------------------------------------------------------------
+# API endpoints — JSON
+# ---------------------------------------------------------------------------
+
+@app.get("/api/stats")
+async def api_stats():
+    """Overview: trust score, memory counts, KG stats."""
+    cog = _cognitive()
+    kg = _knowledge_graph()
+
+    trust = cog.get_trust_score()
+    cog_stats = cog.get_stats()
+    kg_stats = kg.stats()
+    gate_stats = cog.get_gate_stats()
+
+    return {
+        "trust_score": trust,
+        "cognitive": cog_stats,
+        "knowledge_graph": kg_stats,
+        "prediction_gate": gate_stats,
+    }
+
+
+@app.get("/api/graph")
+async def api_graph(
+    center: int = Query(None, description="Center node ID for subgraph"),
+    depth: int = Query(2, ge=1, le=5, description="Traversal depth"),
+    node_type: str = Query(None, description="Filter by node type"),
+    node_ref: str = Query(None, description="Find node by type+ref"),
+):
+    """Subgraph for D3 visualization."""
+    kg = _knowledge_graph()
+
+    # If node_type+node_ref given, resolve to center ID
+    if center is None and node_type and node_ref:
+        node = kg.get_node(node_type, node_ref)
+        # Fallback: try with type prefix (refs stored as "area:wazion", "file:path")
+        if not node:
+            node = kg.get_node(node_type, f"{node_type}:{node_ref}")
+        if node:
+            center = node["id"]
+
+    if center is None:
+        # Return full graph stats + top connected nodes as starting points
+        s = kg.stats()
+        return {
+            "nodes": [],
+            "edges": [],
+            "hints": s.get("most_connected", []),
+            "stats": {
+                "total_nodes": s["nodes"],
+                "total_edges": s["edges_active"],
+            },
+        }
+
+    subgraph = kg.extract_subgraph(center, depth=depth)
+    return subgraph
+
+
+@app.get("/api/memories")
+async def api_memories(
+    q: str = Query("", description="Search query"),
+    store: str = Query("both", description="stm, ltm, or both"),
+    limit: int = Query(20, ge=1, le=100),
+):
+    """Memory search via cognitive engine."""
+    cog = _cognitive()
+
+    if not q:
+        return {"results": [], "message": "Provide ?q= parameter to search"}
+
+    results = cog.search(q, top_k=limit, stores=store)
+    # Serialize — results may contain numpy arrays or sqlite Rows
+    serialized = []
+    for r in results:
+        item = dict(r) if hasattr(r, "keys") else r
+        # Remove embedding blob if present
+        item.pop("embedding", None)
+        item.pop("vec", None)
+        serialized.append(item)
+    return {"query": q, "store": store, "count": len(serialized), "results": serialized}
+
+
+@app.get("/api/somatic")
+async def api_somatic():
+    """Somatic marker risk scores."""
+    cog = _cognitive()
+    top_risks = cog.somatic_top_risks(limit=20)
+    return {"risks": top_risks}
+
+
+@app.get("/api/trust")
+async def api_trust():
+    """Trust score history (last 30 days)."""
+    cog = _cognitive()
+    current = cog.get_trust_score()
+    history = cog.get_trust_history(days=30)
+    return {
+        "current_score": current,
+        "history": history,
+    }
+
+
+@app.get("/api/adaptive")
+async def api_adaptive():
+    """Adaptive personality: current weight state + mode history."""
+    adp = _adaptive()
+    state = adp._load_state()
+    # Get recent history from DB
+    db = _db()
+    conn = db.get_db()
+    rows = conn.execute(
+        "SELECT * FROM adaptive_log ORDER BY timestamp DESC LIMIT 50"
+    ).fetchall()
+    history = [dict(r) for r in rows]
+    return {
+        "state": state,
+        "weights": adp.WEIGHTS,
+        "modes": {k: v["description"] for k, v in adp.MODES.items()},
+        "history": history,
+    }
+
+
+@app.get("/api/sessions")
+async def api_sessions(limit: int = Query(10, ge=1, le=50)):
+    """Recent session diaries."""
+    db = _db()
+    conn = db.get_db()
+    rows = conn.execute(
+        "SELECT * FROM session_diary ORDER BY created_at DESC LIMIT ?",
+        (limit,),
+    ).fetchall()
+    diaries = [dict(r) for r in rows]
+    return {"count": len(diaries), "sessions": diaries}
+
+
+@app.get("/api/kg/nodes")
+async def api_kg_nodes(
+    node_type: str = Query(None, description="Filter by node type"),
+    limit: int = Query(100, ge=1, le=500),
+):
+    """List KG nodes, optionally filtered by type."""
+    kg = _knowledge_graph()
+    db = kg._get_db()
+    if node_type:
+        rows = db.execute(
+            "SELECT * FROM kg_nodes WHERE node_type = ? ORDER BY id DESC LIMIT ?",
+            (node_type, limit),
+        ).fetchall()
+    else:
+        rows = db.execute(
+            "SELECT * FROM kg_nodes ORDER BY id DESC LIMIT ?", (limit,)
+        ).fetchall()
+    nodes = [dict(r) for r in rows]
+    return {"count": len(nodes), "nodes": nodes}
+
+
+# ---------------------------------------------------------------------------
+# Main — run with uvicorn
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(description="NEXO Brain Dashboard")
+    parser.add_argument("--port", type=int, default=6174, help="Port (default: 6174)")
+    parser.add_argument("--no-browser", action="store_true", help="Don't open browser")
+    args = parser.parse_args()
+
+    if not args.no_browser:
+        # Open browser after a short delay (uvicorn will be starting)
+        import threading
+        def _open():
+            import time
+            time.sleep(1.2)
+            webbrowser.open(f"http://localhost:{args.port}")
+        threading.Thread(target=_open, daemon=True).start()
+
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=args.port, log_level="info")
+
+
+if __name__ == "__main__":
+    main()