nexo-brain 0.10.0-beta.1 → 0.10.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.10.0-beta.1",
+  "version": "0.10.0-beta.2",
   "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", "wazion", "project-a", "project-b", "whatsapp", "chrome", "firefox",
+    "shopify", "whatsapp", "chrome", "firefox", "slack", "notion", "github",
     # 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
-    "server", "cloudrun", "gcloud", "vps", "local", "production", "staging",
+    "cloudrun", "gcloud", "aws", "azure", "vps", "local", "production", "staging",
     # DB
     "mysql", "sqlite", "postgresql", "postgres", "redis",
 }
@@ -65,12 +65,12 @@ URGENCY_SIGNALS = {
 _DEFAULT_TRUST_EVENTS = {
     # Positive
     "explicit_thanks": +3,
-    "delegation": +2,        # Francisco delegates new task without micromanaging
-    "paradigm_shift": +2,    # Francisco teaches, NEXO learns
+    "delegation": +2,        # User delegates new task without micromanaging
+    "paradigm_shift": +2,    # User teaches, agent learns
     "sibling_detected": +3,  # NEXO avoided context error on its own
     "proactive_action": +2,  # NEXO did something useful without being asked
     # Negative
-    "correction": -3,        # Francisco corrects NEXO
+    "correction": -3,        # User corrects agent
     "repeated_error": -7,    # Error on something NEXO already had a learning for
     "override": -5,          # NEXO's memory was wrong
     "correction_fatigue": -10, # Same memory corrected 3+ times
@@ -395,7 +395,7 @@ def _init_tables(conn: sqlite3.Connection):
             created_at TEXT DEFAULT (datetime('now'))
         );
 
-        -- Sentiment readings: Francisco's detected mood per interaction
+        -- Sentiment readings: User.s detected mood per interaction
         CREATE TABLE IF NOT EXISTS sentiment_log (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             sentiment TEXT NOT NULL,       -- 'positive', 'negative', 'neutral', 'urgent'
@@ -421,13 +421,13 @@ def _init_tables(conn: sqlite3.Connection):
             status TEXT DEFAULT 'pending'
         );
 
-        -- Correction tracking: when Francisco overrides a memory's guidance
+        -- Correction tracking: when user overrides a memory's guidance
         CREATE TABLE IF NOT EXISTS memory_corrections (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             memory_id INTEGER NOT NULL,
             store TEXT NOT NULL,           -- 'stm' or 'ltm'
             correction_type TEXT NOT NULL, -- 'override', 'exception', 'paradigm_shift'
-            context TEXT DEFAULT '',       -- what Francisco said
+            context TEXT DEFAULT '',       -- what user said
             created_at TEXT DEFAULT (datetime('now'))
         );
     """)
@@ -732,35 +732,140 @@ def bm25_search(query_text: str, stores: str = "both", top_k: int = 20,
 
 def _rrf_fuse(vector_results: list[dict], bm25_results: list[dict],
               k: int = 60, alpha: float = 0.7) -> list[dict]:
-    """Reciprocal Rank Fusion: boost vector results with BM25 keyword matches.
+    """Reciprocal Rank Fusion: merge vector and BM25 results.
 
-    BM25 only BOOSTS existing vector results — never adds new ones.
-    This preserves vector search recall while improving precision for keyword-heavy queries.
+    Unlike the old version that only boosted vector-found results, this now
+    ALSO ADDS BM25-only results. This is critical for vocabulary mismatches
+    where semantic search misses but keyword search finds the right memory
+    (e.g., user says 'backend', memory contains 'FastAPI dashboard localhost:6174').
 
-    RRF score = vector_score + (1-alpha) * 1/(k + bm25_rank) for items found by both.
-    Items only in vector results keep their original score.
+    RRF score = alpha * 1/(k + vec_rank) + (1-alpha) * 1/(k + bm25_rank)
+    Items found by only one source get a penalty rank for the missing source.
     """
-    # Build BM25 lookup by (store, id)
+    # Build lookups by (store, id)
+    vec_lookup = {}
+    for rank, r in enumerate(vector_results):
+        key = (r["store"], r["id"])
+        vec_lookup[key] = (rank + 1, r)
+
     bm25_lookup = {}
     for rank, r in enumerate(bm25_results):
         key = (r["store"], r["id"])
-        bm25_lookup[key] = rank + 1  # 1-based rank
+        if key not in bm25_lookup:  # keep best rank
+            bm25_lookup[key] = (rank + 1, r)
+
+    # Merge all unique keys
+    all_keys = set(vec_lookup.keys()) | set(bm25_lookup.keys())
+    miss_rank = max(len(vector_results), len(bm25_results)) + 10  # penalty rank for missing source
 
-    # Boost vector results that also appear in BM25
     fused = []
-    for r in vector_results:
-        result = r.copy()
-        key = (r["store"], r["id"])
-        if key in bm25_lookup:
-            bm25_rank = bm25_lookup[key]
-            boost = (1 - alpha) * (1.0 / (k + bm25_rank))
-            result["score"] = r["score"] + boost
-            result["bm25_boosted"] = True
+    for key in all_keys:
+        vec_rank, vec_result = vec_lookup.get(key, (miss_rank, None))
+        bm25_rank, bm25_result = bm25_lookup.get(key, (miss_rank, None))
+
+        # Use whichever result has the data
+        base = vec_result if vec_result else bm25_result
+        result = base.copy()
+
+        rrf_score = alpha * (1.0 / (k + vec_rank)) + (1 - alpha) * (1.0 / (k + bm25_rank))
+
+        # 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)
+        else:
+            # BM25-only result: use RRF score scaled to ~0.5-0.7 range
+            result["score"] = min(0.85, rrf_score * k * 3)
+
+        result["bm25_boosted"] = key in bm25_lookup
+        result["bm25_only"] = key not in vec_lookup
+        result["rrf_score"] = rrf_score
         fused.append(result)
 
+    # Sort by score descending
+    fused.sort(key=lambda x: x["score"], reverse=True)
     return fused
 
 
+# ── Temporal Boosting ────────────────────────────────────────────────
+# Recent memories get a bounded additive boost at query time.
+# Design from multi-AI debate (GPT-5.4 + Gemini 3.1 Pro + Claude Opus 4.6):
+# - Additive, not multiplicative (preserves old strong matches)
+# - Relevance-gated (only boost if already above threshold)
+# - Query-adaptive alpha (operational queries get more boost)
+
+# Operational keywords that suggest the user wants recent/active things
+_OPERATIONAL_CUES = frozenset({
+    "current", "latest", "now", "running", "active", "today", "yesterday",
+    "tonight", "backend", "server", "dashboard", "service", "localhost",
+    "anoche", "ayer", "ahora", "actual", "corriendo", "activo", "hoy",
+    "madrugada", "esta mañana", "last night", "this morning",
+})
+
+# Historical keywords that suggest the user wants old things
+_HISTORICAL_CUES = frozenset({
+    "ago", "month", "months", "year", "years", "previous", "earlier",
+    "cuando", "hace", "meses", "año", "anterior", "antes",
+})
+
+
+def _apply_temporal_boost(results: list[dict], query_text: str) -> list[dict]:
+    """Apply bounded temporal boost to retrieval results.
+
+    Recent memories (hours/days) get a small additive bonus, but only if they
+    already have a reasonable relevance score (gated at 0.45). This prevents
+    recent junk from outranking strong old matches.
+
+    The boost decays with a 3-day half-life:
+        boost = alpha * exp(-ln(2) * age_days / 3)
+
+    Alpha is query-adaptive:
+        - Operational queries ('backend', 'active', 'today'): alpha = 0.06
+        - Default queries: alpha = 0.02
+        - Historical queries ('ago', 'months', 'year'): alpha = 0.0 (disabled)
+    """
+    if not results:
+        return results
+
+    # Determine alpha based on query intent
+    query_tokens = set(query_text.lower().split())
+    if query_tokens & _HISTORICAL_CUES:
+        return results  # No temporal boost for historical queries
+    elif query_tokens & _OPERATIONAL_CUES:
+        alpha = 0.06
+    else:
+        alpha = 0.02
+
+    now = datetime.now()
+    ln2 = math.log(2)
+    half_life_days = 3.0
+
+    for r in results:
+        # Only boost if already reasonably relevant (relevance gate)
+        if r.get("score", 0) < 0.45:
+            continue
+
+        # Calculate age in days
+        created_str = r.get("created_at", "")
+        if not created_str:
+            continue
+        try:
+            created = datetime.fromisoformat(created_str.replace("Z", "+00:00").replace("+00:00", ""))
+            age_days = max(0, (now - created).total_seconds() / 86400)
+        except (ValueError, TypeError):
+            continue
+
+        # 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)
+        if boost > 0.001:
+            r["temporal_boost"] = round(boost, 4)
+
+    return results
+
+
 
 # ============================================================================
 # FEATURE 1: HyDE Query Expansion (adapted from Vestige hyde.rs)
@@ -1283,6 +1388,9 @@ def search(
             if r.get("temporal_date"):
                 r["score"] = min(1.0, r["score"] + 0.05)
 
+    # Recency temporal boost: recent memories get additive bonus (query-adaptive)
+    results = _apply_temporal_boost(results, query_text)
+
     # Sort by score descending, take top-20 for reranking
     results.sort(key=lambda x: x.get("score", 0), reverse=True)
 
@@ -2544,12 +2652,12 @@ def get_siblings(memory_id: int) -> list[dict]:
 def detect_dissonance(new_instruction: str, min_score: float = 0.65) -> list[dict]:
     """Detect cognitive dissonance: find LTM memories that contradict a new instruction.
 
-    When Francisco gives a new instruction that conflicts with established LTM memories
+    When User gives a new instruction that conflicts with established LTM memories
     (strength > 0.8), this function surfaces the conflict so NEXO can verbalize it
     rather than silently obeying or silently resisting.
 
     Args:
-        new_instruction: The new instruction or preference from Francisco
+        new_instruction: The new instruction or preference from user
         min_score: Minimum cosine similarity to consider as potential conflict
 
     Returns:
@@ -2584,12 +2692,12 @@ def detect_dissonance(new_instruction: str, min_score: float = 0.65) -> list[dic
 
 
 def resolve_dissonance(memory_id: int, resolution: str, context: str = "") -> str:
-    """Resolve a cognitive dissonance by applying Francisco's decision.
+    """Resolve a cognitive dissonance by applying the user.s decision.
 
     Args:
         memory_id: The LTM memory that conflicts with the new instruction
         resolution: One of:
-            - 'paradigm_shift': Francisco changed his mind permanently. Decay old memory,
+            - 'paradigm_shift': 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.
@@ -2640,7 +2748,7 @@ def resolve_dissonance(memory_id: int, resolution: str, context: str = "") -> st
 def check_correction_fatigue() -> list[dict]:
     """Find memories corrected 3+ times in the last 7 days — mark as 'under review'.
 
-    These memories are unreliable: Francisco keeps overriding them, suggesting
+    These memories are unreliable: User keeps overriding them, suggesting
     the memory itself may be wrong or outdated.
 
     Returns:
@@ -2688,7 +2796,7 @@ def check_correction_fatigue() -> list[dict]:
 
 
 def detect_sentiment(text: str) -> dict:
-    """Analyze Francisco's text for sentiment signals.
+    """Analyze user's text for sentiment signals.
 
     Returns detected sentiment, intensity, and action guidance for NEXO.
     Not a model — keyword + heuristic based. Fast and deterministic.
@@ -2727,17 +2835,17 @@ 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-concise. Zero explanations. Resolve and show result."
+            guidance = "MODE: Ultra-conciso. Cero explicaciones. Resolver y mostrar resultado."
         else:
-            guidance = "MODE: Concise. Less context, more direct action."
+            guidance = "MODE: Conciso. Menos contexto, más acción directa."
     elif pos_score > neg_score and pos_score >= 1:
         sentiment = "positive"
         intensity = min(1.0, 0.3 + pos_score * 0.15)
-        guidance = "MODE: Normal. Good moment to propose backlog ideas or improvements."
+        guidance = "MODE: Normal. Buen momento para proponer ideas de backlog o mejoras."
     elif urgency_hits:
         sentiment = "urgent"
         intensity = 0.8
-        guidance = "MODE: Immediate action. No preamble."
+        guidance = "MODE: Acción inmediata. Sin preámbulos."
     else:
         sentiment = "neutral"
         intensity = 0.5
@@ -2752,7 +2860,7 @@ def detect_sentiment(text: str) -> dict:
 
 
 def log_sentiment(text: str) -> dict:
-    """Detect and log Francisco's sentiment. Returns the detection result."""
+    """Detect and log user's sentiment. Returns the detection result."""
     result = detect_sentiment(text)
     if result["sentiment"] != "neutral":
         db = _get_db()