nexo-brain 0.3.4 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "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,13 +30,13 @@ DISCRIMINATING_ENTITIES = {
     # OS / Environment
     "linux", "mac", "macos", "windows", "darwin", "ubuntu", "debian", "alpine",
     # Platforms
-    "shopify", "whatsapp", "chrome", "firefox",
+    "nexo", "other", "whatsapp", "chrome", "firefox",
     # Languages / Runtimes
     "python", "php", "javascript", "typescript", "node", "deno", "ruby",
     # Versions
     "v1", "v2", "v3", "v4", "v5", "5.6", "7.4", "8.0", "8.1", "8.2",
     # Infrastructure
-    "cloudrun", "gcloud", "vps", "local", "production", "staging",
+    "vps", "local", "production", "staging",
     # DB
     "mysql", "sqlite", "postgresql", "postgres", "redis",
 }
@@ -61,8 +61,8 @@ URGENCY_SIGNALS = {
     "rápido", "ya", "ahora", "urgente", "asap", "inmediatamente", "corre",
 }
 
-# Trust score events and their point values
-TRUST_EVENTS = {
+# Trust score events — default deltas (overridable via trust_event_config table)
+_DEFAULT_TRUST_EVENTS = {
     # Positive
     "explicit_thanks": +3,
     "delegation": +2,        # the user delegates new task without micromanaging
@@ -77,6 +77,113 @@ TRUST_EVENTS = {
     "forgot_followup": -4,   # Forgot to mark followup or execute it
 }
 
+# Lazy-loaded from DB (trust_event_config table overrides defaults)
+_trust_events_cache = None
+_trust_events_cache_ts = 0
+
+
+def get_trust_events() -> dict:
+    """Get trust events with deltas. DB overrides take priority over defaults."""
+    global _trust_events_cache, _trust_events_cache_ts
+    import time
+    now = time.time()
+    # Cache for 60s to avoid constant DB reads
+    if _trust_events_cache is not None and (now - _trust_events_cache_ts) < 60:
+        return _trust_events_cache
+
+    events = dict(_DEFAULT_TRUST_EVENTS)
+    try:
+        db = _get_db()
+        db.execute("""
+            CREATE TABLE IF NOT EXISTS trust_event_config (
+                event TEXT PRIMARY KEY,
+                delta REAL NOT NULL,
+                description TEXT DEFAULT '',
+                updated_at TEXT DEFAULT (datetime('now'))
+            )
+        """)
+        rows = db.execute("SELECT event, delta FROM trust_event_config").fetchall()
+        for r in rows:
+            events[r[0]] = r[1]
+    except Exception:
+        pass
+    _trust_events_cache = events
+    _trust_events_cache_ts = now
+    return events
+
+# For backward compat — code that reads TRUST_EVENTS directly
+TRUST_EVENTS = _DEFAULT_TRUST_EVENTS
+
+# Auto-detection patterns for trust events from user text
+# Each pattern: (event_name, keywords/phrases that trigger it, min_matches)
+TRUST_AUTO_PATTERNS = {
+    "explicit_thanks": {
+        "patterns": [
+            "gracias", "buen trabajo", "bien hecho", "perfecto", "genial",
+            "excelente", "fenomenal", "great job", "nice work", "thank",
+            "thanks", "awesome", "amazing", "love it", "me encanta",
+        ],
+        "min_matches": 1,
+    },
+    "correction": {
+        "patterns": [
+            "ya te dije", "ya te lo dije", "otra vez", "te he dicho",
+            "no es así", "eso no", "mal", "incorrecto", "equivocado",
+            "no no no", "that's wrong", "te aviso", "te avisé",
+            "2ª vez", "segunda vez", "te lo repito",
+        ],
+        "min_matches": 1,
+    },
+    "repeated_error": {
+        "patterns": [
+            "otra vez lo mismo", "siempre igual", "ya te lo dije antes",
+            "cuántas veces", "no aprendes", "same mistake", "again the same",
+            "ya van", "es la 2", "es la 3", "ya te avisé",
+        ],
+        "min_matches": 1,
+    },
+    "delegation": {
+        "patterns": [
+            "encárgate", "hazlo tú", "dale tú", "te lo dejo",
+            "manéjalo", "resuélvelo", "handle it", "take care of",
+            "you decide", "tú decides", "lo que veas", "como veas",
+        ],
+        "min_matches": 1,
+    },
+}
+
+
+def auto_detect_trust_events(text: str) -> list[dict]:
+    """Detect trust events from user text. Returns list of {event, delta, reason}.
+
+    Called automatically by heartbeat. Only fires once per event per heartbeat
+    to avoid double-counting.
+    """
+    if not text or len(text.strip()) < 5:
+        return []
+
+    text_lower = text.lower()
+    events = get_trust_events()
+    detected = []
+
+    for event_name, config in TRUST_AUTO_PATTERNS.items():
+        matches = [p for p in config["patterns"] if p in text_lower]
+        if len(matches) >= config["min_matches"]:
+            delta = events.get(event_name, _DEFAULT_TRUST_EVENTS.get(event_name, 0))
+            detected.append({
+                "event": event_name,
+                "delta": delta,
+                "reason": f"auto-detected: {', '.join(matches[:3])}",
+            })
+
+    # Priority: if repeated_error detected, remove correction (it's a superset)
+    event_names = {d["event"] for d in detected}
+    if "repeated_error" in event_names and "correction" in event_names:
+        detected = [d for d in detected if d["event"] != "correction"]
+    # If explicit_thanks and delegation both detected, keep both (they're independent)
+
+    return detected
+
 _model = None
 _conn = None
 
@@ -1956,7 +2063,7 @@ def resolve_dissonance(memory_id: int, resolution: str, context: str = "") -> st
     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': the user changed their 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.
@@ -2159,7 +2266,8 @@ def adjust_trust(event: str, context: str = "", custom_delta: float = None) -> d
     db = _get_db()
     old_score = get_trust_score()
 
-    delta = custom_delta if custom_delta is not None else TRUST_EVENTS.get(event, 0)
+    events = get_trust_events()
+    delta = custom_delta if custom_delta is not None else events.get(event, 0)
     if delta == 0 and custom_delta is None:
         return {"old_score": old_score, "delta": 0, "new_score": old_score, "event": event, "error": "unknown event"}
 

package/src/db.py

@@ -7,6 +7,7 @@ import secrets
 import string
 import datetime
 import pathlib
+import threading
 
 DB_PATH = os.environ.get(
     "NEXO_TEST_DB",
@@ -21,31 +22,35 @@ SESSION_STALE_SECONDS = 900    # 15 min (documented TTL)
 MESSAGE_TTL_SECONDS = 3600     # 1 hour
 QUESTION_TTL_SECONDS = 600     # 10 min
 
-# Shared connection per process — avoids file descriptor leak with multiple MCP sessions
+# Single shared connection per process with write serialization.
+# SQLite allows only one writer at a time. Using a shared connection with
+# check_same_thread=False and a write lock ensures:
+# - No FTS5 corruption from concurrent write connections
+# - Reads can happen freely (WAL allows concurrent readers)
+# - Writes are serialized via _write_lock to prevent 'database is locked' errors
 _shared_conn: sqlite3.Connection | None = None
+_write_lock = threading.RLock()  # RLock allows re-entrant locking (function A calls B, both serialize)
 
 
 def get_db() -> sqlite3.Connection:
-    """Get shared database connection with WAL mode. One connection per process.
-
-    Uses WAL2-style pragmas for safe multi-process concurrent access:
-    - WAL mode allows readers to not block writers
-    - busy_timeout prevents instant SQLITE_BUSY failures
-    - wal_autocheckpoint keeps WAL file from growing unbounded
-    - Autocommit via isolation_level=None prevents implicit transactions
-      that hold locks across multiple operations
+    """Get shared database connection with WAL mode.
+
+    Returns a _SerializedConnection wrapper that serializes all execute
+    calls via _write_lock, preventing race conditions and FTS5 corruption
+    under concurrent thread access.
     """
     global _shared_conn
     if _shared_conn is None:
-        _shared_conn = sqlite3.connect(
+        raw = sqlite3.connect(
             DB_PATH, timeout=30, check_same_thread=False,
             isolation_level=None,  # autocommit — no implicit BEGIN holding locks
         )
-        _shared_conn.execute("PRAGMA journal_mode=WAL")
-        _shared_conn.execute("PRAGMA busy_timeout=30000")
-        _shared_conn.execute("PRAGMA foreign_keys=ON")
-        _shared_conn.execute("PRAGMA wal_autocheckpoint=100")
-        _shared_conn.row_factory = sqlite3.Row
+        raw.execute("PRAGMA journal_mode=WAL")
+        raw.execute("PRAGMA busy_timeout=30000")
+        raw.execute("PRAGMA foreign_keys=ON")
+        raw.execute("PRAGMA wal_autocheckpoint=100")
+        raw.row_factory = sqlite3.Row
+        _shared_conn = _SerializedConnection(raw)
     return _shared_conn
 
 
@@ -60,6 +65,58 @@ def close_db():
         _shared_conn = None
 
 
+def _get_raw_conn() -> sqlite3.Connection:
+    """Get the raw unwrapped connection (for PRAGMA queries that need direct access)."""
+    conn = get_db()
+    if isinstance(conn, _SerializedConnection):
+        return conn._conn
+    return conn
+
+
+class _SerializedConnection:
+    """Wrapper around sqlite3.Connection that serializes all execute calls.
+
+    SQLite with a single shared connection and check_same_thread=False needs
+    serialization to prevent:
+    - Stale lastrowid when concurrent INSERTs happen
+    - FTS5 index corruption from concurrent writes
+    - 'NoneType' errors from interleaved INSERT+SELECT sequences
+
+    All execute/executemany/executescript calls go through _write_lock.
+    Property access (row_factory etc.) passes through directly.
+    """
+    def __init__(self, conn: sqlite3.Connection):
+        self._conn = conn
+
+    def execute(self, *args, **kwargs):
+        with _write_lock:
+            return self._conn.execute(*args, **kwargs)
+
+    def executemany(self, *args, **kwargs):
+        with _write_lock:
+            return self._conn.executemany(*args, **kwargs)
+
+    def executescript(self, *args, **kwargs):
+        with _write_lock:
+            return self._conn.executescript(*args, **kwargs)
+
+    def commit(self):
+        with _write_lock:
+            return self._conn.commit()
+
+    def close(self):
+        return self._conn.close()
+
+    def __getattr__(self, name):
+        return getattr(self._conn, name)
+
+    def __setattr__(self, name, value):
+        if name == '_conn':
+            super().__setattr__(name, value)
+        else:
+            setattr(self._conn, name, value)
+
+
 def init_db():
     """Create tables if they don't exist."""
     conn = get_db()

package/src/scripts/nexo-catchup.py

@@ -25,6 +25,7 @@ from datetime import datetime, timedelta
 from pathlib import Path
 
 HOME = Path.home()
+NEXO_HOME = os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))
 LOG_DIR = HOME / "claude" / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
 LOG_FILE = LOG_DIR / "catchup.log"
@@ -139,7 +140,7 @@ def main():
             subprocess.run(
                 [PYTHON_BREW if os.path.exists(PYTHON_BREW) else PYTHON_SYS, str(update_script)],
                 capture_output=True, text=True, timeout=60,
-                env={**os.environ, "HOME": str(HOME), "NEXO_HOME": str(HOME / "claude" / "nexo-mcp")}
+                env={**os.environ, "HOME": str(HOME), "NEXO_HOME": NEXO_HOME}
             )
         except Exception as e:
             log(f"  Update check failed: {e}")

package/src/scripts/nexo-cognitive-decay.py

@@ -2,14 +2,18 @@
 """NEXO Cognitive Decay — Daily Ebbinghaus sweep + STM→LTM promotion."""
 
 import json
+import os
 import sys
 from pathlib import Path
 from datetime import datetime
 
+NEXO_HOME = os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))
+sys.path.insert(0, NEXO_HOME)
+# Fallback for development installs
 sys.path.insert(0, str(Path.home() / "claude" / "nexo-mcp"))
 import cognitive
 
-STATE_FILE = Path.home() / "claude" / "operations" / ".catchup-state.json"
+STATE_FILE = Path(NEXO_HOME) / ".catchup-state.json"
 
 
 def update_catchup_state():

package/src/scripts/nexo-daily-self-audit.py

@@ -14,10 +14,11 @@ import hashlib
 from datetime import datetime, timedelta
 from pathlib import Path
 
-LOG_DIR = Path.home() / "claude" / "logs"
+NEXO_HOME_PATH = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+LOG_DIR = NEXO_HOME_PATH / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
 LOG_FILE = LOG_DIR / "self-audit.log"
-NEXO_DB = Path.home() / "claude" / "nexo-mcp" / "nexo.db"
+NEXO_DB = NEXO_HOME_PATH / "nexo.db"
 # Configure this to point to your main project repo for uncommitted-changes check
 PROJECT_REPO_DIR = Path(os.environ.get("NEXO_PROJECT_REPO", str(Path.home() / "projects" / "main")))
 HASH_REGISTRY = Path.home() / "claude" / "scripts" / ".watchdog-hashes"
@@ -245,7 +246,7 @@ def check_watchdog_registry():
 # ── Check 13: Snapshot drift on protected recovery files ────────────────
 def check_snapshot_sync():
     pairs = [
-        (Path.home() / "claude" / "nexo-mcp" / "db.py", SNAPSHOT_GOLDEN / "nexo-mcp" / "db.py"),
+        (NEXO_HOME_PATH / "db.py", SNAPSHOT_GOLDEN / "nexo-mcp" / "db.py"),
         (Path.home() / "claude" / "cortex" / "cortex-wrapper.py", SNAPSHOT_GOLDEN / "cortex" / "cortex-wrapper.py"),
         (Path.home() / "claude" / "cortex" / "evolution_cycle.py", SNAPSHOT_GOLDEN / "cortex" / "evolution_cycle.py"),
     ]
@@ -341,7 +342,7 @@ def check_watchdog_smoke():
 # ── Check 18: Cognitive memory health ────────────────────────────────
 def check_cognitive_health():
     """Check cognitive.db health and run weekly GC on Sundays."""
-    cognitive_db = Path.home() / "claude" / "nexo-mcp" / "cognitive.db"
+    cognitive_db = NEXO_HOME_PATH / "cognitive.db"
     if not cognitive_db.exists():
         finding("WARN", "cognitive", "cognitive.db not found")
         return
@@ -362,7 +363,7 @@ def check_cognitive_health():
 
     # Metrics report (spec section 9)
     try:
-        sys.path.insert(0, str(Path.home() / "claude" / "nexo-mcp"))
+        sys.path.insert(0, str(NEXO_HOME_PATH))
         import cognitive as cog
 
         metrics = cog.get_metrics(days=7)
@@ -403,7 +404,7 @@ def check_cognitive_health():
 
     # Phase triggers monitoring (spec section 10)
     try:
-        sys.path.insert(0, str(Path.home() / "claude" / "nexo-mcp"))
+        sys.path.insert(0, str(NEXO_HOME_PATH))
         import cognitive as cog
 
         db_cog = cog._get_db()
@@ -459,7 +460,7 @@ def check_cognitive_health():
     if datetime.now().weekday() == 6:
         log("  Running weekly cognitive GC (Sunday)...")
         try:
-            sys.path.insert(0, str(Path.home() / "claude" / "nexo-mcp"))
+            sys.path.insert(0, str(NEXO_HOME_PATH))
             import cognitive as cog
 
             # 1. Delete STM with strength < 0.1 and > 30 days

package/src/scripts/nexo-immune.py

@@ -60,6 +60,7 @@ CLAUDE_DIR = HOME / "claude"
 COORD_DIR = CLAUDE_DIR / "coordination"
 BRAIN_DIR = CLAUDE_DIR / "brain"
 SCRIPTS_DIR = CLAUDE_DIR / "scripts"
+NEXO_HOME = os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))
 
 IMMUNE_STATUS = COORD_DIR / "immune-status.json"
 IMMUNE_LOG = COORD_DIR / "immune-log.json"
@@ -368,8 +369,8 @@ def check_databases():
     results = []
 
     dbs = [
-        ("nexo.db", Path.home() / "claude" / "nexo-mcp" / "nexo.db"),
-        ("cognitive.db", Path.home() / "claude" / "nexo-mcp" / "cognitive.db"),
+        ("nexo.db", Path(NEXO_HOME) / "nexo.db"),
+        ("cognitive.db", Path(NEXO_HOME) / "cognitive.db"),
         ("claude-mem.db", CLAUDE_MEM_DB),
     ]
 

package/src/scripts/nexo-postmortem-consolidator.py

@@ -26,12 +26,15 @@ from collections import Counter
 from datetime import datetime, date, timedelta
 from pathlib import Path
 
-# Add nexo-mcp to path for cognitive engine
+# Add NEXO_HOME to path for cognitive engine
+NEXO_HOME = os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))
+sys.path.insert(0, NEXO_HOME)
+# Fallback for development installs
 sys.path.insert(0, str(Path.home() / "claude" / "nexo-mcp"))
 
 HOME = Path.home()
-NEXO_DB = HOME / "claude" / "nexo-mcp" / "nexo.db"
-SESSION_BUFFER = HOME / "claude" / "brain" / "session_buffer.jsonl"
+NEXO_DB = Path(NEXO_HOME) / "nexo.db"
+SESSION_BUFFER = Path(NEXO_HOME) / "brain" / "session_buffer.jsonl"
 MEMORY_DIR = HOME / ".claude" / "projects" / f"-Users-{os.environ.get('USER', 'user')}" / "memory"
 MEMORY_INDEX = MEMORY_DIR / "MEMORY.md"
 CONSOLIDATION_LOG = HOME / "claude" / "logs" / "postmortem-consolidation.log"

package/src/scripts/nexo-sleep.py

@@ -54,8 +54,9 @@ HEARTBEAT_LOG = COORD_DIR / "heartbeat-log.json"
 REFLECTION_LOG = COORD_DIR / "reflection-log.json"
 SLEEP_LOG = COORD_DIR / "sleep-log.json"
 
+NEXO_HOME = os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))
 MEMORY_MD = Path.home() / ".claude" / "projects" / f"-Users-{os.environ.get('USER', 'user')}" / "memory" / "MEMORY.md"
-NEXO_DB = Path.home() / "claude" / "nexo-mcp" / "nexo.db"
+NEXO_DB = Path(NEXO_HOME) / "nexo.db"
 CLAUDE_MEM_DB = Path.home() / ".claude-mem" / "claude-mem.db"
 CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
 

package/src/scripts/nexo-synthesis.py

@@ -21,8 +21,9 @@ from pathlib import Path
 HOME = Path.home()
 CLAUDE_DIR = HOME / "claude"
 COORD_DIR = CLAUDE_DIR / "coordination"
+NEXO_HOME = os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))
 
-NEXO_DB = HOME / "claude" / "nexo-mcp" / "nexo.db"
+NEXO_DB = Path(NEXO_HOME) / "nexo.db"
 CLAUDE_MEM_DB = HOME / ".claude-mem" / "claude-mem.db"
 
 OUTPUT_FILE = COORD_DIR / "daily-synthesis.md"

package/src/server.py

@@ -52,7 +52,7 @@ mcp = FastMCP(
     name="nexo",
     instructions=(
         "NEXO operational server. Provides session coordination, "
-        "reminders, followups, and menu for user operations.\n\n"
+        "reminders, followups, and menu for the user's operations.\n\n"
         "When working with tool results, write down any important information "
         "you might need later in your response, as the original tool result "
         "may be cleared later."
@@ -75,15 +75,16 @@ def nexo_startup(task: str = "Startup") -> str:
 
 
 @mcp.tool
-def nexo_heartbeat(sid: str, task: str) -> str:
-    """Update session task, check inbox and pending questions.
+def nexo_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
+    """Update session task, check inbox and pending questions. Auto-detects trust events.
 
     Call this at the START of every user interaction (before doing work).
     Args:
         sid: Your session ID from nexo_startup.
         task: Brief description of current work (5-10 words).
+        context_hint: Last 2-3 sentences from the user or current topic. Used for sentiment detection, trust auto-scoring, and mid-session RAG. ALWAYS provide this for best results.
     """
-    return handle_heartbeat(sid, task)
+    return handle_heartbeat(sid, task, context_hint)
 
 
 @mcp.tool
@@ -312,7 +313,7 @@ def nexo_learning_add(category: str, title: str, content: str, reasoning: str =
     """Add a new learning (resolved error, pattern, gotcha).
 
     Args:
-        category: One of: general, code, infrastructure, api, database, security, deployment, testing, performance, ux.
+        category: One of: nexo-ops, infrastructure, security, brain-engine, other.
         title: Short title for the learning.
         content: Full description with context and solution.
         reasoning: WHY this matters — what led to discovering this (optional).

package/src/tools_sessions.py

@@ -102,6 +102,19 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
         except Exception:
             pass
 
+    # Auto-detect trust events from context_hint
+    if context_hint and len(context_hint.strip()) >= 10:
+        try:
+            import cognitive
+            auto_events = cognitive.auto_detect_trust_events(context_hint)
+            for ae in auto_events:
+                result = cognitive.adjust_trust(ae["event"], ae["reason"], ae["delta"])
+                if result.get("delta", 0) != 0:
+                    parts.append("")
+                    parts.append(f"TRUST AUTO: {result['old_score']:.0f} → {result['new_score']:.0f} ({result['delta']:+.0f}) [{ae['event']}] {ae['reason']}")
+        except Exception:
+            pass  # Auto-trust is best-effort
+
     # Mid-session RAG: if context_hint provided, check for context shift
     if context_hint and len(context_hint.strip()) >= 15:
         try: