nexo-brain 0.3.5 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.3.5",
+  "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/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"