nexo-brain 1.7.0 → 2.0.0

package/src/hooks/session-start.sh

@@ -48,7 +48,7 @@ from datetime import date
 today_str = '$TODAY'
 weekday = '$WEEKDAY'
 nexo_home = os.environ.get('NEXO_HOME', os.path.expanduser('~/.nexo'))
-db_path = os.path.join(nexo_home, 'nexo.db')
+db_path = os.path.join(nexo_home, 'data', 'nexo.db')
 
 lines = []
 lines.append(f'## Date: {today_str} ({weekday})')
@@ -212,7 +212,11 @@ except Exception as e:
 fi
 
 # ─── Cortex Report: what happened while user was away ───
-CORTEX_BRIEFING="$NEXO_HOME/cortex/last-briefing.json"
+# Check brain/ (canonical) first, fall back to cortex/ (legacy)
+CORTEX_BRIEFING="$NEXO_HOME/brain/last-briefing.json"
+if [ ! -f "$CORTEX_BRIEFING" ] && [ -f "$NEXO_HOME/cortex/last-briefing.json" ]; then
+    CORTEX_BRIEFING="$NEXO_HOME/cortex/last-briefing.json"
+fi
 if [ -f "$CORTEX_BRIEFING" ]; then
     CORTEX_SECTION=$(python3 -c "
 import json

package/src/hooks/session-stop.sh

@@ -25,7 +25,8 @@ TOOL_LOG="$NEXO_HOME/operations/tool-logs/${TODAY}.jsonl"
 python3 -c "
 import sys, json, os
 nexo_home = os.environ.get('NEXO_HOME', os.path.expanduser('~/.nexo'))
-sys.path.insert(0, os.path.join(nexo_home, 'nexo-mcp'))
+nexo_code = os.environ.get('NEXO_CODE', nexo_home)
+sys.path.insert(0, nexo_code)
 os.environ['NEXO_SKIP_FS_INDEX'] = '1'
 from db import init_db, get_db, get_active_sessions, upsert_diary_draft, get_diary_draft
 init_db()

package/src/kg_populate.py

@@ -13,7 +13,10 @@ from db import get_db
 
 def _cognitive_db():
     """Direct cognitive.db connection (for somatic_markers)."""
-    path = os.path.join(os.path.dirname(__file__), "cognitive.db")
+    nexo_home = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+    data_dir = os.path.join(nexo_home, "data")
+    os.makedirs(data_dir, exist_ok=True)
+    path = os.path.join(data_dir, "cognitive.db")
     conn = sqlite3.connect(path)
     conn.row_factory = sqlite3.Row
     return conn

package/src/migrate_embeddings.py

@@ -15,7 +15,10 @@ import sys
 import time
 import numpy as np
 
-DB_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cognitive.db")
+NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+_data_dir = os.path.join(NEXO_HOME, "data")
+os.makedirs(_data_dir, exist_ok=True)
+DB_PATH = os.path.join(_data_dir, "cognitive.db")
 BACKUP_PATH = DB_PATH + ".bak-384dims-pre-upgrade"
 
 MODELS = {

package/src/plugin_loader.py

@@ -1,6 +1,7 @@
 """Dynamic plugin loader for NEXO MCP server."""
 
 import importlib
+import importlib.util
 import os
 import signal
 import sys
@@ -9,7 +10,12 @@ import time
 from db import get_db
 from fastmcp.tools import Tool
 
-PLUGINS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins")
+SERVER_DIR = os.path.dirname(os.path.abspath(__file__))
+PLUGINS_DIR = os.path.join(SERVER_DIR, "plugins")
+
+# Personal plugins directory: NEXO_HOME/plugins/ (env var, defaults to ~/.nexo/)
+NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+PERSONAL_PLUGINS_DIR = os.path.join(NEXO_HOME, "plugins")
 
 PLUGIN_LOAD_TIMEOUT = 10  # seconds per plugin
 
@@ -22,41 +28,95 @@ def _timeout_handler(signum, frame):
     raise _PluginTimeout("Plugin loading timed out")
 
 
+def _ensure_src_in_path():
+    """Ensure server src/ is in sys.path so personal plugins can import db, cognitive, etc."""
+    if SERVER_DIR not in sys.path:
+        sys.path.insert(0, SERVER_DIR)
+
+
 def load_all_plugins(mcp) -> int:
-    """Load all plugins from plugins/ directory at startup. Returns total tools loaded."""
-    if not os.path.isdir(PLUGINS_DIR):
-        return 0
+    """Load all plugins from repo and personal directories at startup. Returns total tools loaded."""
+    _ensure_src_in_path()
     total = 0
-    for f in sorted(os.listdir(PLUGINS_DIR)):
-        if f.endswith(".py") and f != "__init__.py":
+
+    # Collect plugins: repo first, personal overrides
+    plugin_map = {}  # filename -> (dir_path, source_label)
+
+    # 1. Repo plugins (base)
+    if os.path.isdir(PLUGINS_DIR):
+        for f in sorted(os.listdir(PLUGINS_DIR)):
+            if f.endswith(".py") and f != "__init__.py":
+                plugin_map[f] = (PLUGINS_DIR, "repo")
+
+    # 2. Personal plugins (override if same filename)
+    if os.path.isdir(PERSONAL_PLUGINS_DIR):
+        for f in sorted(os.listdir(PERSONAL_PLUGINS_DIR)):
+            if f.endswith(".py") and f != "__init__.py":
+                source = "personal (override)" if f in plugin_map else "personal"
+                plugin_map[f] = (PERSONAL_PLUGINS_DIR, source)
+
+    # Load all in sorted order
+    for f in sorted(plugin_map):
+        plugins_dir, source_label = plugin_map[f]
+        try:
+            old_handler = signal.signal(signal.SIGALRM, _timeout_handler)
+            signal.alarm(PLUGIN_LOAD_TIMEOUT)
             try:
-                old_handler = signal.signal(signal.SIGALRM, _timeout_handler)
-                signal.alarm(PLUGIN_LOAD_TIMEOUT)
-                try:
-                    n = load_plugin(mcp, f)
-                    total += n
-                finally:
-                    signal.alarm(0)
-                    signal.signal(signal.SIGALRM, old_handler)
-            except _PluginTimeout:
-                print(f"[PLUGIN TIMEOUT] {f}: skipped after {PLUGIN_LOAD_TIMEOUT}s", file=sys.stderr)
-            except Exception as e:
-                print(f"[PLUGIN ERROR] {f}: {e}", file=sys.stderr)
+                n = load_plugin(mcp, f, plugins_dir=plugins_dir)
+                total += n
+                print(f"[PLUGIN LOADED] {f} ({n} tools) from {source_label}: {plugins_dir}", file=sys.stderr)
+            finally:
+                signal.alarm(0)
+                signal.signal(signal.SIGALRM, old_handler)
+        except _PluginTimeout:
+            print(f"[PLUGIN TIMEOUT] {f}: skipped after {PLUGIN_LOAD_TIMEOUT}s", file=sys.stderr)
+        except Exception as e:
+            print(f"[PLUGIN ERROR] {f}: {e}", file=sys.stderr)
     return total
 
 
-def load_plugin(mcp, filename: str) -> int:
-    """Load or reload a single plugin. Returns number of tools registered."""
+def load_plugin(mcp, filename: str, plugins_dir: str | None = None) -> int:
+    """Load or reload a single plugin. Returns number of tools registered.
+
+    Args:
+        plugins_dir: Directory to load from. If None, searches repo PLUGINS_DIR first,
+                     then PERSONAL_PLUGINS_DIR. Personal plugins are loaded via
+                     importlib.util.spec_from_file_location.
+    """
     if not filename.endswith(".py"):
         filename += ".py"
 
-    filepath = os.path.join(PLUGINS_DIR, filename)
-    if not os.path.isfile(filepath):
-        raise FileNotFoundError(f"Plugin not found: {filepath}")
+    if plugins_dir is not None:
+        filepath = os.path.join(plugins_dir, filename)
+        if not os.path.isfile(filepath):
+            raise FileNotFoundError(f"Plugin not found: {filepath}")
+    else:
+        # Search repo first, then personal
+        repo_path = os.path.join(PLUGINS_DIR, filename)
+        personal_path = os.path.join(PERSONAL_PLUGINS_DIR, filename)
+        if os.path.isfile(repo_path):
+            plugins_dir = PLUGINS_DIR
+            filepath = repo_path
+        elif os.path.isfile(personal_path):
+            plugins_dir = PERSONAL_PLUGINS_DIR
+            filepath = personal_path
+        else:
+            raise FileNotFoundError(
+                f"Plugin not found in repo ({PLUGINS_DIR}) or personal ({PERSONAL_PLUGINS_DIR}): {filename}"
+            )
 
     module_name = f"plugins.{filename[:-3]}"
 
-    if module_name in sys.modules:
+    # For personal plugins (outside repo), use spec_from_file_location
+    if plugins_dir != PLUGINS_DIR:
+        _ensure_src_in_path()
+        spec = importlib.util.spec_from_file_location(module_name, filepath)
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Cannot create module spec for {filepath}")
+        mod = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = mod
+        spec.loader.exec_module(mod)
+    elif module_name in sys.modules:
         mod = importlib.reload(sys.modules[module_name])
     else:
         mod = importlib.import_module(module_name)
@@ -73,13 +133,18 @@ def load_plugin(mcp, filename: str) -> int:
         mcp.add_tool(t)
         tool_names.append(name)
 
-    _update_registry(filename, len(tool_names), ",".join(tool_names), "manual")
+    source_label = "personal" if plugins_dir != PLUGINS_DIR else "repo"
+    _update_registry(filename, len(tool_names), ",".join(tool_names), source_label)
 
     return len(tool_names)
 
 
 def remove_plugin(mcp, filename: str) -> list[str]:
-    """Remove a plugin: unregister its tools, delete file, clean registry."""
+    """Unregister a plugin's tools from MCP and clean the registry.
+
+    Does NOT delete plugin files — only unregisters tools to avoid
+    accidental deletion of code from repo or personal directories.
+    """
     if not filename.endswith(".py"):
         filename += ".py"
 
@@ -100,10 +165,6 @@ def remove_plugin(mcp, filename: str) -> list[str]:
     module_name = f"plugins.{filename[:-3]}"
     sys.modules.pop(module_name, None)
 
-    filepath = os.path.join(PLUGINS_DIR, filename)
-    if os.path.isfile(filepath):
-        os.remove(filepath)
-
     conn = get_db()
     conn.execute("DELETE FROM plugins WHERE filename = ?", (filename,))
     conn.commit()
@@ -112,12 +173,17 @@ def remove_plugin(mcp, filename: str) -> list[str]:
 
 
 def list_plugins() -> list[dict]:
-    """List all registered plugins."""
+    """List all registered plugins with source info (repo/personal)."""
     conn = get_db()
     rows = conn.execute(
         "SELECT filename, tools_count, tool_names, loaded_at, created_by FROM plugins ORDER BY filename"
     ).fetchall()
-    return [dict(r) for r in rows]
+    result = []
+    for r in rows:
+        d = dict(r)
+        d["source"] = d.get("created_by", "repo")
+        result.append(d)
+    return result
 
 
 def _update_registry(filename: str, tools_count: int, tool_names: str, created_by: str):
@@ -128,8 +194,8 @@ def _update_registry(filename: str, tools_count: int, tool_names: str, created_b
         conn.execute(
             "INSERT INTO plugins (filename, tools_count, tool_names, loaded_at, created_by) "
             "VALUES (?, ?, ?, ?, ?) "
-            "ON CONFLICT(filename) DO UPDATE SET tools_count=?, tool_names=?, loaded_at=?",
-            (filename, tools_count, tool_names, now, created_by, tools_count, tool_names, now),
+            "ON CONFLICT(filename) DO UPDATE SET tools_count=?, tool_names=?, loaded_at=?, created_by=?",
+            (filename, tools_count, tool_names, now, created_by, tools_count, tool_names, now, created_by),
         )
         conn.commit()
     except Exception as e:

package/src/plugins/agents.py

@@ -15,7 +15,7 @@ def handle_agent_create(id: str, name: str, specialization: str, model: str = "s
                         tools: str = "", context_files: str = "", rules: str = "") -> str:
     """Register a new agent in the registry."""
     create_agent(id, name, specialization, model, tools, context_files, rules)
-    return f"Agente '{id}' ({name}) registered. Model: {model}"
+    return f"Agent '{id}' ({name}) registered. Model: {model}"
 
 def handle_agent_update(id: str, name: str = "", specialization: str = "", model: str = "",
                         tools: str = "", context_files: str = "", rules: str = "") -> str:
@@ -32,7 +32,7 @@ def handle_agent_list() -> str:
     """List all registered agents."""
     agents = list_agents()
     if not agents: return "No agents registered."
-    lines = ["AGENTES REGISTRADOS:"]
+    lines = ["REGISTERED AGENTS:"]
     for a in agents:
         lines.append(f"  {a['id']} — {a['name']} ({a['model']}) — {a['specialization'][:60]}")
     return "\n".join(lines)

package/src/plugins/backup.py

@@ -5,8 +5,9 @@ import time
 import glob
 from db import get_db
 
-DB_PATH = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "nexo.db"))
-BACKUP_DIR = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "backups"))
+NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+DB_PATH = os.path.join(NEXO_HOME, "data", "nexo.db")
+BACKUP_DIR = os.path.join(NEXO_HOME, "backups")
 
 RETENTION_DAYS = 7
 
@@ -33,10 +34,10 @@ def handle_backup_now() -> str:
 def handle_backup_list() -> str:
     """List available backups with dates and sizes."""
     if not os.path.isdir(BACKUP_DIR):
-        return "Sin backups."
+        return "No backups."
     files = sorted(glob.glob(os.path.join(BACKUP_DIR, "nexo-*.db")), reverse=True)
     if not files:
-        return "Sin backups."
+        return "No backups."
     lines = [f"BACKUPS ({len(files)}):"]
     total_size = 0
     for f in files:

package/src/plugins/core_rules.py

@@ -12,7 +12,11 @@ def _get_db():
 def _seed_if_empty():
     """Seed rules from JSON if table is empty (first run after migration)."""
     conn = _get_db()
-    count = conn.execute("SELECT COUNT(*) FROM core_rules WHERE is_active = 1").fetchone()[0]
+    try:
+        count = conn.execute("SELECT COUNT(*) FROM core_rules WHERE is_active = 1").fetchone()[0]
+    except Exception:
+        # Table doesn't exist yet — migrations haven't run. Bail gracefully.
+        return
     if count > 0:
         return
 

package/src/plugins/episodic_memory.py

@@ -39,7 +39,7 @@ def handle_decision_log(domain: str, decision: str, alternatives: str = '',
     if domain not in valid_domains:
         return f"ERROR: domain must be one of: {', '.join(sorted(valid_domains))}"
     if confidence not in ('high', 'medium', 'low'):
-        return f"ERROR: confidence debe ser high, medium, o low"
+        return f"ERROR: confidence must be high, medium, or low"
 
     sid = session_id or 'unknown'
     result = log_decision(sid, domain, decision, alternatives, based_on, confidence, context_ref)
@@ -84,7 +84,7 @@ def handle_decision_outcome(id: int, outcome: str) -> str:
         (id,)
     )
     conn.commit()
-    return f"Decision #{id} outcome registrado: {outcome[:100]}"
+    return f"Decision #{id} outcome recorded: {outcome[:100]}"
 
 
 def handle_decision_search(query: str = '', domain: str = '', days: int = 30) -> str:
@@ -297,7 +297,7 @@ def handle_change_log(files: str, what_changed: str, why: str,
         session_id: Current session ID
     """
     if not files or not what_changed or not why:
-        return "ERROR: files, what_changed, y why son obligatorios"
+        return "ERROR: files, what_changed, and why are required"
     sid = session_id or 'unknown'
     result = log_change(sid, files, what_changed, why, triggered_by, affects, risks, verify, commit_ref)
     if "error" in result:
@@ -313,7 +313,7 @@ def handle_change_log(files: str, what_changed: str, why: str,
         on_change_log(change_id, files, "")
     except Exception:
         pass
-    msg = f"Change #{change_id} registrado: {files[:60]} — {what_changed[:60]}"
+    msg = f"Change #{change_id} recorded: {files[:60]} — {what_changed[:60]}"
     if not commit_ref:
         msg += f"\n⚠ NO COMMIT. Use nexo_change_commit({change_id}, 'hash') after push, or 'server-direct' if it was a direct server edit."
     return msg
@@ -351,6 +351,9 @@ def handle_change_search(query: str = '', files: str = '', days: int = 30) -> st
 def handle_change_commit(id: int, commit_ref: str) -> str:
     """Link a change log entry to its git commit hash after committing.
 
+    After linking, automatically resolves any open followups that match
+    the change (by file overlap, keyword similarity, or explicit ID reference).
+
     Args:
         id: Change log entry ID
         commit_ref: Git commit hash
@@ -358,7 +361,13 @@ def handle_change_commit(id: int, commit_ref: str) -> str:
     result = update_change_commit(id, commit_ref)
     if "error" in result:
         return f"ERROR: {result['error']}"
-    return f"Change #{id} vinculado a commit {commit_ref[:8]}"
+
+    msg = f"Change #{id} vinculado a commit {commit_ref[:8]}"
+    auto_resolved = result.get("_auto_resolved", [])
+    if auto_resolved:
+        ids = ", ".join(auto_resolved)
+        msg += f"\n✅ AUTO-RESOLVED followups: {ids}"
+    return msg
 
 
 def handle_recall(query: str, days: int = 30) -> str:

package/src/plugins/evolution.py

@@ -1,5 +1,6 @@
 """Evolution plugin — NEXO self-improvement tools for interactive sessions."""
 
+import os
 from db import get_latest_metrics, get_evolution_history, update_evolution_log_status, get_db
 
 
@@ -59,9 +60,12 @@ def handle_evolution_propose() -> str:
     import json
     from pathlib import Path
     nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-    obj_file = nexo_home / "cortex" / "evolution-objective.json"
+    # Check brain/ (canonical) first, fall back to cortex/ (legacy)
+    obj_file = nexo_home / "brain" / "evolution-objective.json"
     if not obj_file.exists():
-        return "ERROR: evolution-objective.json not found"
+        obj_file = nexo_home / "cortex" / "evolution-objective.json"
+    if not obj_file.exists():
+        return "ERROR: evolution-objective.json not found. Run the installer or create one in ~/.nexo/brain/"
     try:
         obj = json.loads(obj_file.read_text())
         if not obj.get("evolution_enabled", True):

package/src/plugins/guard.py

@@ -110,16 +110,22 @@ def handle_guard_check(files: str = "", area: str = "", include_schemas: str = "
                 w = r["weight"] or 0.5
                 result["learnings"].append({"id": r["id"], "category": r["category"], "rule": r["title"], "priority": pri, "weight": w})
 
-    # 3. Universal rules (SIEMPRE, NUNCA, ANTES, always, never)
+    # 3. Universal rules — only from matching area or nexo-ops (not ALL learnings)
+    universal_categories = {"nexo-ops"}
+    if area:
+        universal_categories.add(area)
+    placeholders = ",".join("?" for _ in universal_categories)
     rows = conn.execute(
-        "SELECT id, category, title, content FROM learnings WHERE "
-        "content LIKE '%SIEMPRE%' OR content LIKE '%NUNCA%' OR content LIKE '%ANTES%' "
-        "OR content LIKE '%always%' OR content LIKE '%never%'"
+        f"SELECT id, category, title, content, priority FROM learnings WHERE "
+        f"category IN ({placeholders}) AND ("
+        f"content LIKE '%SIEMPRE%' OR content LIKE '%NUNCA%' OR content LIKE '%ANTES%' "
+        f"OR content LIKE '%always%' OR content LIKE '%never%')",
+        tuple(universal_categories)
     ).fetchall()
     for r in rows:
         if r["id"] not in seen_ids:
             seen_ids.add(r["id"])
-            result["universal_rules"].append({"id": r["id"], "rule": r["title"], "category": r["category"]})
+            result["universal_rules"].append({"id": r["id"], "rule": r["title"], "category": r["category"], "priority": r["priority"] or "medium"})
 
     # 4. DB schemas if files contain SQL keywords
     if include_schemas_bool and file_list:
@@ -173,8 +179,9 @@ def handle_guard_check(files: str = "", area: str = "", include_schemas: str = "
             })
             continue
 
-        # Path (b): Aggressive — learning TITLE contains prohibition keywords
-        if BLOCKING_KEYWORDS.search(learning["rule"]):
+        # Path (b): Only promote to blocking if high/critical priority AND title has prohibition keyword
+        pri = learning.get("priority", "medium")
+        if pri in ("critical", "high") and BLOCKING_KEYWORDS.search(learning["rule"]):
             blocking_seen.add(lid)
             result["blocking_rules"].append({
                 "id": lid, "rule": learning["rule"], "repetitions": rep_count,
@@ -297,8 +304,9 @@ def handle_guard_check(files: str = "", area: str = "", include_schemas: str = "
         lines.append("")
 
     if result["learnings"]:
-        lines.append(f"RELEVANT LEARNINGS ({len(result['learnings'])}):")
-        for l in result["learnings"][:15]:
+        shown = result["learnings"][:10]  # Cap at 10, not 15
+        lines.append(f"RELEVANT LEARNINGS ({len(result['learnings'])}, showing {len(shown)}):")
+        for l in shown:
             lines.append(f"  #{l['id']} [{l['category']}] {l['rule']}")
         lines.append("")
 
@@ -310,8 +318,9 @@ def handle_guard_check(files: str = "", area: str = "", include_schemas: str = "
         lines.append("")
 
     if result["universal_rules"]:
-        lines.append(f"UNIVERSAL RULES ({len(result['universal_rules'])}):")
-        for r in result["universal_rules"][:10]:
+        shown_u = result["universal_rules"][:5]  # Cap at 5
+        lines.append(f"UNIVERSAL RULES ({len(result['universal_rules'])}, showing {len(shown_u)}):")
+        for r in shown_u:
             lines.append(f"  #{r['id']} {r['rule']}")
         lines.append("")