nexo-brain 0.3.3 → 0.3.5

package/package.json

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

@@ -241,17 +241,6 @@ def init_db():
             user_signals TEXT,
             summary TEXT NOT NULL
         );
-        CREATE TABLE IF NOT EXISTS session_diary_draft (
-            sid TEXT PRIMARY KEY,
-            summary_draft TEXT DEFAULT '',
-            tasks_seen TEXT DEFAULT '[]',
-            change_ids TEXT DEFAULT '[]',
-            decision_ids TEXT DEFAULT '[]',
-            last_context_hint TEXT DEFAULT '',
-            heartbeat_count INTEGER DEFAULT 0,
-            created_at TEXT DEFAULT (datetime('now')),
-            updated_at TEXT DEFAULT (datetime('now'))
-        );
 
         CREATE TABLE IF NOT EXISTS evolution_metrics (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -279,55 +268,8 @@ def init_db():
     """)
     # foreign_keys=ON is set in get_db() per-connection
 
-    # ── Schema migrations (idempotent) ────────────────────────────
-    _migrate_add_column(conn, "learnings", "reasoning", "TEXT")
-    _migrate_add_column(conn, "learnings", "prevention", "TEXT DEFAULT ''")
-    _migrate_add_column(conn, "learnings", "applies_to", "TEXT DEFAULT ''")
-    _migrate_add_column(conn, "learnings", "status", "TEXT DEFAULT 'active'")
-    _migrate_add_column(conn, "learnings", "review_due_at", "REAL")
-    _migrate_add_column(conn, "learnings", "last_reviewed_at", "REAL")
-    _migrate_add_column(conn, "followups", "reasoning", "TEXT")
-    _migrate_add_column(conn, "task_history", "reasoning", "TEXT")
-    _migrate_add_column(conn, "decisions", "status", "TEXT DEFAULT 'pending_review'")
-    _migrate_add_column(conn, "decisions", "review_due_at", "TEXT")
-    _migrate_add_column(conn, "decisions", "last_reviewed_at", "TEXT")
-    _migrate_add_index(conn, "idx_decisions_domain", "decisions", "domain")
-    _migrate_add_index(conn, "idx_decisions_created", "decisions", "created_at")
-    _migrate_add_index(conn, "idx_decisions_review_due", "decisions", "review_due_at")
-    _migrate_add_index(conn, "idx_session_diary_sid", "session_diary", "session_id")
-    _migrate_add_column(conn, "session_diary", "mental_state", "TEXT")
-    _migrate_add_column(conn, "session_diary", "domain", "TEXT")
-    _migrate_add_column(conn, "session_diary", "user_signals", "TEXT")
-    _migrate_add_column(conn, "session_diary", "self_critique", "TEXT")
-    _migrate_add_column(conn, "session_diary", "source", "TEXT DEFAULT 'claude'")
-    _migrate_add_index(conn, "idx_change_log_created", "change_log", "created_at")
-    _migrate_add_index(conn, "idx_change_log_files", "change_log", "files")
-    _migrate_add_index(conn, "idx_learnings_status", "learnings", "status")
-    _migrate_add_index(conn, "idx_learnings_review_due", "learnings", "review_due_at")
-
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS error_repetitions (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            new_learning_id INTEGER NOT NULL,
-            original_learning_id INTEGER NOT NULL,
-            similarity REAL NOT NULL,
-            area TEXT NOT NULL,
-            created_at TEXT DEFAULT (datetime('now'))
-        )
-    """)
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS guard_checks (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            session_id TEXT,
-            files TEXT,
-            area TEXT,
-            learnings_returned INTEGER DEFAULT 0,
-            blocking_rules_returned INTEGER DEFAULT 0,
-            created_at TEXT DEFAULT (datetime('now'))
-        )
-    """)
-    _migrate_add_index(conn, "idx_error_repetitions_area", "error_repetitions", "area")
-    _migrate_add_index(conn, "idx_guard_checks_session", "guard_checks", "session_id")
+    # ── Run formal migrations ────────────────────────────────────
+    run_migrations(conn)
 
     # ── FTS5 unified search index ────────────────────────────────
     conn.execute("""
@@ -779,6 +721,149 @@ def _migrate_add_index(conn, index_name: str, table: str, column: str):
     conn.commit()
 
 
+# ── Formal Migration System ─────────────────────────────────────
+#
+# Each migration is (version, name, callable). Migrations run once
+# and are tracked in schema_migrations. The version number MUST be
+# strictly increasing. Add new migrations at the end of the list.
+#
+# For users upgrading via npm/git, init_db() calls run_migrations()
+# automatically — no manual steps needed.
+
+def _m1_learnings_columns(conn):
+    _migrate_add_column(conn, "learnings", "reasoning", "TEXT")
+    _migrate_add_column(conn, "learnings", "prevention", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "learnings", "applies_to", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "learnings", "status", "TEXT DEFAULT 'active'")
+    _migrate_add_column(conn, "learnings", "review_due_at", "REAL")
+    _migrate_add_column(conn, "learnings", "last_reviewed_at", "REAL")
+
+def _m2_followups_reasoning(conn):
+    _migrate_add_column(conn, "followups", "reasoning", "TEXT")
+    _migrate_add_column(conn, "task_history", "reasoning", "TEXT")
+
+def _m3_decisions_review(conn):
+    _migrate_add_column(conn, "decisions", "status", "TEXT DEFAULT 'pending_review'")
+    _migrate_add_column(conn, "decisions", "review_due_at", "TEXT")
+    _migrate_add_column(conn, "decisions", "last_reviewed_at", "TEXT")
+    _migrate_add_index(conn, "idx_decisions_domain", "decisions", "domain")
+    _migrate_add_index(conn, "idx_decisions_created", "decisions", "created_at")
+    _migrate_add_index(conn, "idx_decisions_review_due", "decisions", "review_due_at")
+
+def _m4_session_diary_columns(conn):
+    _migrate_add_index(conn, "idx_session_diary_sid", "session_diary", "session_id")
+    _migrate_add_column(conn, "session_diary", "mental_state", "TEXT")
+    _migrate_add_column(conn, "session_diary", "domain", "TEXT")
+    _migrate_add_column(conn, "session_diary", "user_signals", "TEXT")
+    _migrate_add_column(conn, "session_diary", "self_critique", "TEXT")
+
+def _m5_change_log_indexes(conn):
+    _migrate_add_index(conn, "idx_change_log_created", "change_log", "created_at")
+    _migrate_add_index(conn, "idx_change_log_files", "change_log", "files")
+    _migrate_add_index(conn, "idx_learnings_status", "learnings", "status")
+    _migrate_add_index(conn, "idx_learnings_review_due", "learnings", "review_due_at")
+
+def _m6_error_guard_tables(conn):
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS error_repetitions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            new_learning_id INTEGER NOT NULL,
+            original_learning_id INTEGER NOT NULL,
+            similarity REAL NOT NULL,
+            area TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS guard_checks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT,
+            files TEXT,
+            area TEXT,
+            learnings_returned INTEGER DEFAULT 0,
+            blocking_rules_returned INTEGER DEFAULT 0,
+            created_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    _migrate_add_index(conn, "idx_error_repetitions_area", "error_repetitions", "area")
+    _migrate_add_index(conn, "idx_guard_checks_session", "guard_checks", "session_id")
+
+def _m7_diary_source_and_draft(conn):
+    _migrate_add_column(conn, "session_diary", "source", "TEXT DEFAULT 'claude'")
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS session_diary_draft (
+            sid TEXT PRIMARY KEY,
+            summary_draft TEXT DEFAULT '',
+            tasks_seen TEXT DEFAULT '[]',
+            change_ids TEXT DEFAULT '[]',
+            decision_ids TEXT DEFAULT '[]',
+            last_context_hint TEXT DEFAULT '',
+            heartbeat_count INTEGER DEFAULT 0,
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+
+
+# Migration registry — APPEND ONLY, never reorder or delete
+MIGRATIONS = [
+    (1, "learnings_columns", _m1_learnings_columns),
+    (2, "followups_reasoning", _m2_followups_reasoning),
+    (3, "decisions_review", _m3_decisions_review),
+    (4, "session_diary_columns", _m4_session_diary_columns),
+    (5, "change_log_indexes", _m5_change_log_indexes),
+    (6, "error_guard_tables", _m6_error_guard_tables),
+    (7, "diary_source_and_draft", _m7_diary_source_and_draft),
+]
+
+
+def run_migrations(conn=None):
+    """Run pending migrations. Tracks applied versions in schema_migrations.
+
+    Safe to call multiple times — skips already-applied migrations.
+    Called automatically by init_db() on every server start.
+    """
+    if conn is None:
+        conn = get_db()
+
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS schema_migrations (
+            version INTEGER PRIMARY KEY,
+            name TEXT NOT NULL,
+            applied_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    conn.commit()
+
+    applied = {r[0] for r in conn.execute("SELECT version FROM schema_migrations").fetchall()}
+
+    for version, name, fn in MIGRATIONS:
+        if version not in applied:
+            try:
+                fn(conn)
+                conn.execute(
+                    "INSERT INTO schema_migrations (version, name) VALUES (?, ?)",
+                    (version, name)
+                )
+                conn.commit()
+            except Exception as e:
+                # Log but don't crash — partial migration is better than no server
+                import sys
+                print(f"[MIGRATION] v{version} ({name}) failed: {e}", file=sys.stderr)
+
+    return len(MIGRATIONS) - len(applied)
+
+
+def get_schema_version() -> int:
+    """Return the highest applied migration version, or 0 if none."""
+    conn = get_db()
+    try:
+        row = conn.execute("SELECT MAX(version) FROM schema_migrations").fetchone()
+        return row[0] or 0
+    except Exception:
+        return 0
+
+
 def _gen_id(prefix: str, length: int = 8) -> str:
     """Generate a random ID like 'msg-a1b2c3' or 'q-x9y8z7w6'."""
     chars = string.ascii_lowercase + string.digits
@@ -2165,7 +2250,7 @@ def read_session_diary(session_id: str = '', last_n: int = 3, last_day: bool = F
     - session_id: returns entries for that specific session
     - last_day: returns ALL entries from the most recent day (multi-terminal aware)
     - last_n: returns last N entries (default)
-    - domain: filter by project context (project-a, project-b, nexo, other)
+    - domain: filter by project context (nexo, other)
     """
     conn = get_db()
     domain_clause = " AND domain = ?" if domain else ""

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: