nexo-brain 1.5.4 → 1.7.0

package/src/auto_close_sessions.py

@@ -21,8 +21,9 @@ from db import (
     SESSION_STALE_SECONDS,
 )
 
-LOG_DIR = os.path.expanduser("~/claude/operations/tool-logs")
-AUTO_CLOSE_LOG = os.path.expanduser("~/claude/coordination/auto-close.log")
+NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+LOG_DIR = os.path.join(NEXO_HOME, "operations", "tool-logs")
+AUTO_CLOSE_LOG = os.path.join(NEXO_HOME, "coordination", "auto-close.log")
 
 
 def get_tool_log_summary(sid: str) -> str:
@@ -120,6 +121,7 @@ def main():
 
     orphans = get_orphan_sessions(SESSION_STALE_SECONDS)
     if not orphans:
+        print(f"[{datetime.datetime.now().isoformat(timespec='seconds')}] No stale sessions")
         return
 
     for session in orphans:

package/src/cognitive/_core.py

@@ -11,7 +11,7 @@ from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Optional
 
-COGNITIVE_DB = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cognitive.db")
+COGNITIVE_DB = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "cognitive.db")
 EMBEDDING_DIM = 768
 LAMBDA_STM = 0.1      # half-life ~7 days
 LAMBDA_LTM = 0.012    # half-life ~60 days

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

@@ -112,11 +112,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 +200,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 +283,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 +614,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 +835,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 +867,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

@@ -316,7 +316,7 @@ def detect_sentiment(text: str) -> dict:
         if intensity > 0.7:
             guidance = "MODE: Ultra-conciso. Cero explicaciones. Resolver y mostrar resultado."
         else:
-            guidance = "MODE: Conciso. Menos contexto, más acción directa."
+            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)
@@ -324,7 +324,7 @@ def detect_sentiment(text: str) -> dict:
     elif urgency_hits:
         sentiment = "urgent"
         intensity = 0.8
-        guidance = "MODE: Acción inmediata. Sin preámbulos."
+        guidance = "MODE: Immediate action. No preambles."
     else:
         sentiment = "neutral"
         intensity = 0.5