nexo-brain 1.6.0 → 2.0.0

package/src/cognitive/_decay.py

@@ -254,7 +254,7 @@ def dream_cycle(max_insights: int = 50) -> dict:
         })
 
     if len(recent_memories) < 2:
-        return {"insights_created": 0, "insights": [], "memories_scanned": len(recent_memories)}
+        return {"insights_created": 0, "insights": [], "memories_scanned": len(recent_memories), "candidates_found": 0}
 
     # 2. Get already-dreamed pairs to skip
     dreamed = set()

package/src/cognitive/_memory.py

@@ -398,18 +398,20 @@ def get_stats() -> dict:
     """Return statistics about the cognitive memory system."""
     db = _get_db()
 
-    stm_active = db.execute("SELECT COUNT(*) FROM stm_memories WHERE promoted_to_ltm = 0").fetchone()[0]
+    stm_active = db.execute("SELECT COUNT(*) FROM stm_memories WHERE lifecycle_state = 'active' AND promoted_to_ltm = 0").fetchone()[0]
+    stm_promoted = db.execute("SELECT COUNT(*) FROM stm_memories WHERE promoted_to_ltm = 1").fetchone()[0]
+    stm_total = db.execute("SELECT COUNT(*) FROM stm_memories WHERE lifecycle_state = 'active'").fetchone()[0]
     ltm_active = db.execute("SELECT COUNT(*) FROM ltm_memories WHERE is_dormant = 0").fetchone()[0]
     ltm_dormant = db.execute("SELECT COUNT(*) FROM ltm_memories WHERE is_dormant = 1").fetchone()[0]
 
-    avg_stm = db.execute("SELECT AVG(strength) FROM stm_memories WHERE promoted_to_ltm = 0").fetchone()[0] or 0.0
+    avg_stm = db.execute("SELECT AVG(strength) FROM stm_memories WHERE lifecycle_state = 'active' AND promoted_to_ltm = 0").fetchone()[0] or 0.0
     avg_ltm = db.execute("SELECT AVG(strength) FROM ltm_memories WHERE is_dormant = 0").fetchone()[0] or 0.0
 
     total_retrievals = db.execute("SELECT COUNT(*) FROM retrieval_log").fetchone()[0]
     avg_retrieval_score = db.execute("SELECT AVG(top_score) FROM retrieval_log").fetchone()[0] or 0.0
 
     top_domains_stm = db.execute(
-        "SELECT domain, COUNT(*) as cnt FROM stm_memories WHERE promoted_to_ltm = 0 AND domain != '' GROUP BY domain ORDER BY cnt DESC LIMIT 5"
+        "SELECT domain, COUNT(*) as cnt FROM stm_memories WHERE lifecycle_state = 'active' AND promoted_to_ltm = 0 AND domain != '' GROUP BY domain ORDER BY cnt DESC LIMIT 5"
     ).fetchall()
     top_domains_ltm = db.execute(
         "SELECT domain, COUNT(*) as cnt FROM ltm_memories WHERE is_dormant = 0 AND domain != '' GROUP BY domain ORDER BY cnt DESC LIMIT 5"
@@ -420,6 +422,8 @@ def get_stats() -> dict:
 
     return {
         "stm_active": stm_active,
+        "stm_promoted": stm_promoted,
+        "stm_total": stm_total,
         "ltm_active": ltm_active,
         "ltm_dormant": ltm_dormant,
         "avg_stm_strength": round(avg_stm, 3),

package/src/cognitive/_search.py

@@ -1,5 +1,6 @@
 """NEXO Cognitive — Search, retrieval, ranking."""
 import math
+import sqlite3
 import numpy as np
 from datetime import datetime
 from cognitive._core import _get_db, embed, cosine_similarity, _blob_to_array, _array_to_blob, _get_model, _get_reranker, rerank_results, EMBEDDING_DIM
@@ -112,11 +113,12 @@ def _rrf_fuse(vector_results: list[dict], bm25_results: list[dict],
 
         # If we have the original cosine score, blend it in to preserve semantic confidence
         if vec_result and "score" in vec_result:
-            # Weighted blend: RRF for ranking + cosine for confidence
-            result["score"] = 0.6 * vec_result["score"] + 0.4 * (rrf_score * k * 3)
+            # Weighted blend: cosine for confidence + RRF for ranking boost
+            rrf_normalized = min(1.0, rrf_score * k)  # normalize to 0-1 range
+            result["score"] = 0.7 * vec_result["score"] + 0.3 * rrf_normalized
         else:
-            # BM25-only result: use RRF score scaled to ~0.5-0.7 range
-            result["score"] = min(0.85, rrf_score * k * 3)
+            # BM25-only result: use RRF score scaled to ~0.3-0.7 range
+            result["score"] = min(0.75, rrf_score * k)
 
         result["bm25_boosted"] = key in bm25_lookup
         result["bm25_only"] = key not in vec_lookup
@@ -199,8 +201,8 @@ def _apply_temporal_boost(results: list[dict], query_text: str) -> list[dict]:
         # Bounded exponential decay boost
         boost = alpha * math.exp(-ln2 * age_days / half_life_days)
 
-        # Apply boost (capped at 1.0)
-        r["score"] = min(1.0, r["score"] + boost)
+        # Apply boost (capped at 0.95 — reserve 1.0 for exact matches only)
+        r["score"] = min(0.95, r["score"] + boost)
         if boost > 0.001:
             r["temporal_boost"] = round(boost, 4)
 
@@ -282,7 +284,7 @@ def _kg_boost_results(results: list[dict], max_boost: float = 0.08) -> list[dict
         for idx in ref_map.get(node_ref, []):
             r = results[idx]
             if r.get("score", 0) >= 0.45:  # Same relevance gate as temporal
-                r["score"] = min(1.0, r["score"] + boost)
+                r["score"] = min(0.95, r["score"] + boost)
                 r["kg_boost"] = round(boost, 4)
                 r["kg_connections"] = connections
 
@@ -613,7 +615,7 @@ def _rehearse_results(results: list[dict], skip_ids: set = None):
             continue
         table = "stm_memories" if r["store"] == "stm" else "ltm_memories"
         db.execute(
-            f"UPDATE {table} SET strength = 1.0, access_count = access_count + 1, last_accessed = ? WHERE id = ?",
+            f"UPDATE {table} SET strength = MIN(1.0, strength + 0.08), access_count = access_count + 1, last_accessed = ? WHERE id = ?",
             (now, r["id"])
         )
     db.commit()
@@ -834,7 +836,7 @@ def search(
     if is_temporal_query:
         for r in results:
             if r.get("temporal_date"):
-                r["score"] = min(1.0, r["score"] + 0.05)
+                r["score"] = min(0.95, r["score"] + 0.05)
 
     # Recency temporal boost: recent memories get additive bonus (query-adaptive)
     results = _apply_temporal_boost(results, query_text)
@@ -866,7 +868,7 @@ def search(
                 existing_hashes.add(co_hash)
                 if co_hash in neighbor_boosts:
                     boost = neighbor_boosts[co_hash]
-                    r["score"] = min(1.0, r["score"] + boost)
+                    r["score"] = min(0.95, r["score"] + boost)
                     r["co_activation_boost"] = boost
 
             # Add neighbor memories not already in results

package/src/cognitive/_trust.py

@@ -1,7 +1,7 @@
 """NEXO Cognitive — Trust scoring, sentiment, dissonance."""
 import re
 import numpy as np
-from datetime import datetime
+from datetime import datetime, timedelta
 from cognitive._core import _get_db, embed, cosine_similarity, _blob_to_array
 from cognitive._core import POSITIVE_SIGNALS, NEGATIVE_SIGNALS, URGENCY_SIGNALS
 
@@ -314,13 +314,13 @@ def detect_sentiment(text: str) -> dict:
         sentiment = "negative"
         intensity = min(1.0, 0.3 + neg_score * 0.15)
         if intensity > 0.7:
-            guidance = "MODE: Ultra-conciso. Cero explicaciones. Resolver y mostrar resultado."
+            guidance = "MODE: Ultra-concise. Zero explanations. Solve and show result."
         else:
             guidance = "MODE: Concise. Less context, more direct action."
     elif pos_score > neg_score and pos_score >= 1:
         sentiment = "positive"
         intensity = min(1.0, 0.3 + pos_score * 0.15)
-        guidance = "MODE: Normal. Buen momento para proponer ideas de backlog o mejoras."
+        guidance = "MODE: Normal. Good time to suggest backlog ideas or improvements."
     elif urgency_hits:
         sentiment = "urgent"
         intensity = 0.8

package/src/dashboard/app.py

@@ -10,6 +10,7 @@ Usage:
 import argparse
 import json
 import os
+import platform
 import subprocess
 import sys
 import time
@@ -22,7 +23,7 @@ from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
-# Add parent dir to path so we can import nexo-mcp modules
+# Add parent dir to path so we can import NEXO modules
 _PARENT = str(Path(__file__).resolve().parent.parent)
 if _PARENT not in sys.path:
     sys.path.insert(0, _PARENT)
@@ -63,7 +64,7 @@ async def create_tables():
 
 
 # ---------------------------------------------------------------------------
-# Lazy imports — modules live in the parent nexo-mcp directory
+# Lazy imports — modules live in the parent source directory
 # ---------------------------------------------------------------------------
 
 def _cognitive():
@@ -602,6 +603,11 @@ async def api_ops_execute(fid: str):
         return JSONResponse({"error": f"Followup {fid} not found"}, status_code=404)
     item = dict(row)
     description = item["description"].replace('"', '\\"').replace("'", "\\'")
+    if platform.system() != "Darwin":
+        return JSONResponse(
+            {"error": "This operation requires macOS (uses osascript to open Terminal)"},
+            status_code=501,
+        )
     script = f'tell application "Terminal" to do script "claude \\"NEXO: execute followup #{fid} — {description}\\""'
     subprocess.Popen(["osascript", "-e", script])
     return {"success": True, "followup_id": fid}
@@ -728,7 +734,7 @@ async def api_calendar(
 @app.get("/api/watchdog")
 async def api_watchdog():
     """Read watchdog status from file."""
-    nexo_home = os.environ.get("NEXO_HOME", str(Path.home() / "claude"))
+    nexo_home = os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))
     watchdog_path = Path(nexo_home) / "operations" / "watchdog-status.json"
     if not watchdog_path.exists():
         return JSONResponse(

package/src/dashboard/templates/dashboard.html

@@ -447,10 +447,10 @@
     // --- Overdue Items ---
     if (remindersData || followupsData) {
       const reminders = (remindersData?.reminders || []).filter(r =>
-        r.status === 'PENDIENTE' && r.date && r.date < today
+        r.status === 'PENDING' && r.date && r.date < today
       );
       const followups = (followupsData?.followups || []).filter(f =>
-        f.status === 'PENDIENTE' && f.date && f.date < today
+        f.status === 'PENDING' && f.date && f.date < today
       );
       const total = reminders.length + followups.length;
       const el = document.getElementById('overdue-count');
@@ -530,12 +530,12 @@
     if (remindersData || followupsData) {
       const items = [];
       (remindersData?.reminders || []).forEach(r => {
-        if (r.status === 'PENDIENTE' && r.date && r.date <= today) {
+        if (r.status === 'PENDING' && r.date && r.date <= today) {
           items.push({ ...r, _type: 'R', _overdue: r.date < today });
         }
       });
       (followupsData?.followups || []).forEach(f => {
-        if (f.status === 'PENDIENTE' && f.date && f.date <= today) {
+        if (f.status === 'PENDING' && f.date && f.date <= today) {
           items.push({ ...f, _type: 'F', _overdue: f.date < today });
         }
       });

package/src/dashboard/templates/operations.html

@@ -154,9 +154,9 @@
           onchange="loadOpsData()"
           class="bg-slate-800 border border-slate-700 rounded-lg px-2 py-1 text-xs text-slate-200 focus:outline-none focus:ring-1 focus:ring-violet-500"
         >
-          <option value="PENDIENTE">Pending</option>
+          <option value="PENDING">Pending</option>
           <option value="all">All</option>
-          <option value="COMPLETADO">Completed</option>
+          <option value="COMPLETED">Completed</option>
         </select>
       </div>
     </header>
@@ -380,7 +380,7 @@
     const today = getToday();
     const weekEnd = getWeekEnd();
     return {
-      overdue:  items.filter(i => i.date && i.date < today && i.status !== 'COMPLETADO'),
+      overdue:  items.filter(i => i.date && i.date < today && i.status !== 'COMPLETED'),
       today:    items.filter(i => i.date === today),
       week:     items.filter(i => i.date && i.date > today && i.date <= weekEnd),
       upcoming: items.filter(i => i.date && i.date > weekEnd),
@@ -393,9 +393,9 @@
   // -----------------------------------------------------------------------
   function renderItem(item, type) {
     const today = getToday();
-    const isOverdue  = item.date && item.date < today && item.status !== 'COMPLETADO';
+    const isOverdue  = item.date && item.date < today && item.status !== 'COMPLETED';
     const isToday    = item.date === today;
-    const isCompleted = item.status === 'COMPLETADO';
+    const isCompleted = item.status === 'COMPLETED';
 
     const dotColor   = isCompleted ? 'bg-emerald-400' : isOverdue ? 'bg-red-400' : isToday ? 'bg-amber-400' : 'bg-slate-500';
     const dateLabel  = relativeDate(item.date);
@@ -542,7 +542,7 @@
     const res = await fetch(url, {
       method: 'PUT',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ status: 'COMPLETADO' })
+      body: JSON.stringify({ status: 'COMPLETED' })
     });
     const data = await res.json();
     if (data.success) {

package/src/db/__init__.py

@@ -39,6 +39,7 @@ from db._reminders import (
     get_reminders, get_reminder,
     create_followup, update_followup, complete_followup, delete_followup,
     get_followups, get_followup,
+    find_similar_followups,
 )
 
 # Learnings
@@ -69,7 +70,7 @@ from db._entities import (
 
 # Episodic memory
 from db._episodic import (
-    cleanup_old_changes, log_change, search_changes, update_change_commit,
+    cleanup_old_changes, log_change, search_changes, update_change_commit, auto_resolve_followups,
     cleanup_old_decisions, log_decision, update_decision_outcome,
     get_memory_review_queue, find_decisions_by_context_ref, search_decisions,
     cleanup_old_diaries, write_session_diary,

package/src/db/_core.py

@@ -9,11 +9,15 @@ import datetime
 import pathlib
 import threading
 
+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.environ.get(
     "NEXO_TEST_DB",
     os.environ.get(
         "NEXO_DB",
-        os.path.join(os.path.dirname(os.path.abspath(__file__)), "nexo.db"),
+        os.path.join(_data_dir, "nexo.db"),
     ),
 )
 
@@ -168,7 +172,7 @@ def init_db():
             id TEXT PRIMARY KEY,
             date TEXT,
             description TEXT NOT NULL,
-            status TEXT NOT NULL DEFAULT 'PENDIENTE',
+            status TEXT NOT NULL DEFAULT 'PENDING',
             category TEXT DEFAULT 'general',
             created_at REAL NOT NULL,
             updated_at REAL NOT NULL
@@ -179,7 +183,7 @@ def init_db():
             date TEXT,
             description TEXT NOT NULL,
             verification TEXT DEFAULT '',
-            status TEXT NOT NULL DEFAULT 'PENDIENTE',
+            status TEXT NOT NULL DEFAULT 'PENDING',
             recurrence TEXT DEFAULT NULL,
             created_at REAL NOT NULL,
             updated_at REAL NOT NULL

package/src/db/_episodic.py

@@ -69,8 +69,73 @@ def search_changes(query: str = '', files: str = '', days: int = 30) -> list[dic
     return [dict(r) for r in rows]
 
 
+def auto_resolve_followups(change: dict) -> list[str]:
+    """Cross-reference a change_log entry with open followups. Auto-completes matches.
+
+    Matching logic:
+    1. File overlap: if change touched files mentioned in followup description
+    2. Keyword overlap: Jaccard similarity between change text and followup text
+    3. ID reference: if followup ID appears in the change's triggered_by/why fields
+
+    Returns list of followup IDs that were auto-resolved.
+    """
+    conn = get_db()
+    open_followups = conn.execute(
+        "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETED%' "
+        "AND status != 'DELETED'"
+    ).fetchall()
+
+    if not open_followups:
+        return []
+
+    change_text = " ".join(str(change.get(f, "")) for f in
+                           ["files", "what_changed", "why", "triggered_by", "affects"])
+    change_files = set(change.get("files", "").replace(",", " ").split())
+    change_tokens = {w.lower() for w in change_text.split() if len(w) > 3}
+
+    resolved = []
+    for f in open_followups:
+        fid = f["id"]
+        fdesc = f"{fid} {f['description']} {f['verification'] or ''}"
+        ftokens = {w.lower() for w in fdesc.split() if len(w) > 3}
+
+        # Check 1: followup ID explicitly in change trigger/why
+        if fid.lower() in change_text.lower():
+            resolved.append(fid)
+            continue
+
+        # Check 2: file overlap (any changed file mentioned in followup)
+        if change_files:
+            for cf in change_files:
+                basename = cf.rsplit("/", 1)[-1] if "/" in cf else cf
+                if basename and len(basename) > 4 and basename.lower() in fdesc.lower():
+                    resolved.append(fid)
+                    break
+            if fid in resolved:
+                continue
+
+        # Check 3: keyword similarity (asymmetric overlap >= 0.35)
+        if ftokens and change_tokens:
+            intersection = ftokens & change_tokens
+            smaller = min(len(ftokens), len(change_tokens))
+            score = len(intersection) / smaller if smaller else 0
+            if score >= 0.35:
+                resolved.append(fid)
+
+    # Auto-complete matched followups
+    from db._reminders import complete_followup
+    commit_ref = change.get("commit_ref", "")
+    for fid in resolved:
+        complete_followup(fid, result=f"Auto-resolved by change #{change.get('id', '?')} (commit {commit_ref[:8] if commit_ref else 'N/A'})")
+
+    return resolved
+
+
 def update_change_commit(id: int, commit_ref: str) -> dict:
-    """Link a change log entry to its git commit after commit."""
+    """Link a change log entry to its git commit after commit.
+
+    After linking, auto-resolves any open followups that match the change.
+    """
     conn = get_db()
     row = conn.execute("SELECT * FROM change_log WHERE id = ?", (id,)).fetchone()
     if not row:
@@ -81,6 +146,9 @@ def update_change_commit(id: int, commit_ref: str) -> dict:
     r = dict(row)
     body = f"{r.get('what_changed','')} {r.get('why','')} {r.get('triggered_by','')} {r.get('affects','')} {r.get('risks','')}"
     fts_upsert("change", str(id), r.get("files",""), body, "change_log", commit=False)
+
+    # Auto-resolve followups that match this change
+    r["_auto_resolved"] = auto_resolve_followups(r)
     return r
 
 

package/src/db/_fts.py

@@ -2,27 +2,27 @@
 import os, pathlib, sqlite3, threading, datetime
 from db._core import get_db, now_epoch, DB_PATH
 
+NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+
 # ── FTS5 Unified Search ──────────────────────────────────────────
 
 # Directories to index for unified search
 _FTS_MD_DIRS = [
-    os.path.expanduser("~/claude/docs"),
-    os.path.expanduser("~/claude/projects"),
-    os.path.expanduser("~/claude/memory"),
-    os.path.expanduser("~/claude/operations"),
-    os.path.expanduser("~/claude/learnings"),
-    os.path.expanduser("~/claude/brain"),
-    os.path.expanduser("~/claude/agents"),
-    os.path.expanduser("~/claude/skills"),
+    os.path.join(NEXO_HOME, "docs"),
+    os.path.join(NEXO_HOME, "projects"),
+    os.path.join(NEXO_HOME, "memory"),
+    os.path.join(NEXO_HOME, "operations"),
+    os.path.join(NEXO_HOME, "learnings"),
+    os.path.join(NEXO_HOME, "brain"),
+    os.path.join(NEXO_HOME, "agents"),
+    os.path.join(NEXO_HOME, "skills"),
 ]
 # Code repos: index source files (skip vendor, node_modules, etc.)
-_FTS_CODE_DIRS = [
-    (os.path.expanduser("~/Documents/_PhpstormProjects"), ["*.php", "*.js", "*.json", "*.py", "*.ts", "*.tsx"]),
-]
+_FTS_CODE_DIRS = []  # Users can add project dirs via nexo_index_add_dir
 _FTS_CODE_SKIP = {
     "vendor", "node_modules", ".git", "cache", "tmp", "logs", "uploads",
     "assets/img", "assets/fonts", ".next", "dist", "build", ".prisma",
-    "PROYECTOS ANTIGUOS", "public/build", ".turbo", "__pycache__",
+    "public/build", ".turbo", "__pycache__",
     "coverage", ".nyc_output", "storage/framework", "bootstrap/cache",
 }
 _FTS_MAX_FILE_SIZE = 50_000  # skip .md files >50KB