nexo-brain 1.7.0 → 2.1.0

package/src/cognitive/_core.py

@@ -11,10 +11,14 @@ from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Optional
 
-COGNITIVE_DB = os.path.join(os.path.dirname(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)
+
+COGNITIVE_DB = os.path.join(_data_dir, "cognitive.db")
 EMBEDDING_DIM = 768
-LAMBDA_STM = 0.1      # half-life ~7 days
-LAMBDA_LTM = 0.012    # half-life ~60 days
+LAMBDA_STM = 0.004126   # half-life = ln(2) / (7 * 24) ≈ 7 days
+LAMBDA_LTM = 0.000481  # half-life = ln(2) / (60 * 24) ≈ 60 days
 
 # Prediction Error Gate thresholds
 PE_GATE_REJECT = 0.85     # similarity > this → reject (not novel enough)

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/_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

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/crons/manifest.json

@@ -0,0 +1,106 @@
+{
+  "$schema": "NEXO cron manifest — synced by nexo_update to LaunchAgents (macOS) or systemd timers (Linux)",
+  "version": 2,
+  "crons": [
+    {
+      "id": "deep-sleep",
+      "script": "scripts/nexo-deep-sleep.sh",
+      "type": "shell",
+      "schedule": {"hour": 4, "minute": 30},
+      "description": "Overnight session analysis — 4 phases: collect, extract, synthesize, apply",
+      "core": true
+    },
+    {
+      "id": "sleep",
+      "script": "scripts/nexo-sleep.py",
+      "schedule": {"hour": 4, "minute": 0},
+      "description": "Nightly memory consolidation and dream cycle",
+      "core": true
+    },
+    {
+      "id": "cognitive-decay",
+      "script": "scripts/nexo-cognitive-decay.py",
+      "schedule": {"hour": 3, "minute": 0},
+      "description": "Memory decay — reduce strength of unaccessed memories",
+      "core": true
+    },
+    {
+      "id": "learning-housekeep",
+      "script": "scripts/nexo-learning-housekeep.py",
+      "schedule": {"hour": 3, "minute": 15},
+      "description": "Archive stale learnings, deduplicate, validate",
+      "core": true
+    },
+    {
+      "id": "immune",
+      "script": "scripts/nexo-immune.py",
+      "interval_seconds": 1800,
+      "description": "Health monitor — checks MCP, DB, services, auto-repairs",
+      "core": true
+    },
+    {
+      "id": "watchdog",
+      "script": "scripts/nexo-watchdog.sh",
+      "type": "shell",
+      "interval_seconds": 1800,
+      "description": "System health checks — snapshots, logs, alerts",
+      "core": true
+    },
+    {
+      "id": "self-audit",
+      "script": "scripts/nexo-daily-self-audit.py",
+      "schedule": {"hour": 7, "minute": 0},
+      "description": "Daily self-audit — validates learnings, protocols, drift",
+      "core": true
+    },
+    {
+      "id": "postmortem",
+      "script": "scripts/nexo-postmortem-consolidator.py",
+      "schedule": {"hour": 23, "minute": 30},
+      "description": "Consolidate session post-mortems into patterns",
+      "core": true
+    },
+    {
+      "id": "evolution",
+      "script": "scripts/nexo-evolution-run.py",
+      "schedule": {"hour": 5, "minute": 0, "weekday": 0},
+      "description": "Weekly self-improvement cycle — propose and evaluate changes",
+      "core": true
+    },
+    {
+      "id": "followup-hygiene",
+      "script": "scripts/nexo-followup-hygiene.py",
+      "schedule": {"hour": 5, "minute": 0},
+      "description": "Clean stale followups, archive completed, validate dates",
+      "core": true
+    },
+    {
+      "id": "synthesis",
+      "script": "scripts/nexo-synthesis.py",
+      "interval_seconds": 7200,
+      "description": "Periodic synthesis — cross-reference learnings, decisions, changes",
+      "core": true
+    },
+    {
+      "id": "auto-close-sessions",
+      "script": "scripts/nexo-auto-close-sessions.py",
+      "interval_seconds": 300,
+      "description": "Close stale sessions that lost their parent process",
+      "core": true
+    },
+    {
+      "id": "github-monitor",
+      "script": "scripts/nexo-github-monitor.py",
+      "schedule": {"hour": 8, "minute": 0},
+      "description": "Monitor GitHub repo — issues, PRs, stars, auto-respond",
+      "core": true
+    },
+    {
+      "id": "catchup",
+      "script": "scripts/nexo-catchup.py",
+      "schedule": {"hour": 8, "minute": 30},
+      "description": "Morning catchup briefing for the user",
+      "core": true
+    }
+  ]
+}

package/src/crons/sync.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""
+NEXO Cron Sync — Synchronize crons/manifest.json with system LaunchAgents (macOS).
+
+Called by nexo_update after pulling new code. Ensures:
+- New crons in manifest → installed
+- Removed crons from manifest → unloaded + deleted
+- Changed schedule/interval → plist updated + reloaded
+- Personal (non-core) crons → left untouched
+
+Usage:
+  python3 crons/sync.py [--dry-run]
+
+Environment:
+  NEXO_HOME — root of NEXO installation
+  NEXO_CODE — path to NEXO source (defaults to script parent's parent)
+"""
+
+import json
+import os
+import platform
+import plistlib
+import subprocess
+import sys
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent.parent)))
+MANIFEST = Path(__file__).resolve().parent / "manifest.json"
+LAUNCH_AGENTS_DIR = Path.home() / "Library" / "LaunchAgents"
+LABEL_PREFIX = "com.nexo."
+LOG_DIR = NEXO_HOME / "logs"
+
+
+def log(msg: str):
+    print(f"[cron-sync] {msg}", flush=True)
+
+
+def load_manifest() -> list[dict]:
+    with open(MANIFEST) as f:
+        data = json.load(f)
+    return data.get("crons", [])
+
+
+def build_plist(cron: dict) -> dict:
+    """Build a macOS LaunchAgent plist dict from a manifest entry."""
+    cron_id = cron["id"]
+    label = f"{LABEL_PREFIX}{cron_id}"
+    script_path = str(NEXO_CODE / cron["script"])
+    script_type = cron.get("type", "python")
+
+    if script_type == "shell":
+        program_args = ["/bin/bash", script_path]
+    else:
+        # Find python3
+        python_candidates = [
+            "/opt/homebrew/bin/python3",
+            "/usr/local/bin/python3",
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3",
+            "/usr/bin/python3",
+        ]
+        python_bin = "python3"
+        for p in python_candidates:
+            if Path(p).exists():
+                python_bin = p
+                break
+        program_args = [python_bin, script_path]
+
+    plist = {
+        "Label": label,
+        "ProgramArguments": program_args,
+        "StandardOutPath": str(LOG_DIR / f"{cron_id}-stdout.log"),
+        "StandardErrorPath": str(LOG_DIR / f"{cron_id}-stderr.log"),
+        "EnvironmentVariables": {
+            "PATH": "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:"
+                    + str(Path.home() / ".local" / "bin") + ":"
+                    + str(Path.home() / ".nvm/versions/node/v22.14.0/bin") + ":"
+                    + "/Library/Frameworks/Python.framework/Versions/3.12/bin",
+            "HOME": str(Path.home()),
+            "NEXO_HOME": str(NEXO_HOME),
+            "NEXO_CODE": str(NEXO_CODE),
+            "PYTHONUNBUFFERED": "1",
+        },
+    }
+
+    # Schedule
+    if "interval_seconds" in cron:
+        plist["StartInterval"] = cron["interval_seconds"]
+    elif "schedule" in cron:
+        cal = {}
+        s = cron["schedule"]
+        if "hour" in s:
+            cal["Hour"] = s["hour"]
+        if "minute" in s:
+            cal["Minute"] = s["minute"]
+        if "weekday" in s:
+            cal["Weekday"] = s["weekday"]
+        plist["StartCalendarInterval"] = cal
+
+    return plist
+
+
+def get_installed_nexo_crons() -> dict[str, Path]:
+    """Return dict of cron_id → plist_path for installed NEXO crons."""
+    installed = {}
+    if not LAUNCH_AGENTS_DIR.exists():
+        return installed
+    for f in LAUNCH_AGENTS_DIR.glob(f"{LABEL_PREFIX}*.plist"):
+        cron_id = f.stem.replace(LABEL_PREFIX, "")
+        installed[cron_id] = f
+    return installed
+
+
+def plist_needs_update(existing_path: Path, new_plist: dict) -> bool:
+    """Check if the installed plist differs from what we'd generate."""
+    try:
+        with open(existing_path, "rb") as f:
+            existing = plistlib.load(f)
+    except Exception:
+        return True
+
+    # Compare key fields
+    if existing.get("ProgramArguments") != new_plist.get("ProgramArguments"):
+        return True
+    if existing.get("StartInterval") != new_plist.get("StartInterval"):
+        return True
+    if existing.get("StartCalendarInterval") != new_plist.get("StartCalendarInterval"):
+        return True
+    return False
+
+
+def install_plist(label: str, plist: dict, plist_path: Path, dry_run: bool):
+    """Write plist and load it."""
+    if dry_run:
+        log(f"  DRY-RUN: would install {plist_path.name}")
+        return
+
+    # Unload if already loaded
+    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+
+    with open(plist_path, "wb") as f:
+        plistlib.dump(plist, f)
+
+    subprocess.run(["launchctl", "load", str(plist_path)], capture_output=True)
+    log(f"  Installed + loaded: {plist_path.name}")
+
+
+def unload_plist(plist_path: Path, dry_run: bool):
+    """Unload and remove a plist."""
+    if dry_run:
+        log(f"  DRY-RUN: would remove {plist_path.name}")
+        return
+
+    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+    plist_path.unlink(missing_ok=True)
+    log(f"  Removed: {plist_path.name}")
+
+
+def sync(dry_run: bool = False):
+    if platform.system() != "Darwin":
+        log("Not macOS — cron sync only supports LaunchAgents. Skipping.")
+        return
+
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    LAUNCH_AGENTS_DIR.mkdir(parents=True, exist_ok=True)
+
+    manifest_crons = load_manifest()
+    manifest_ids = {c["id"] for c in manifest_crons}
+    installed = get_installed_nexo_crons()
+
+    log(f"Manifest: {len(manifest_crons)} core crons")
+    log(f"Installed: {len(installed)} NEXO crons")
+
+    # 1. Install or update crons from manifest
+    for cron in manifest_crons:
+        cron_id = cron["id"]
+        label = f"{LABEL_PREFIX}{cron_id}"
+        plist_path = LAUNCH_AGENTS_DIR / f"{label}.plist"
+        new_plist = build_plist(cron)
+
+        if cron_id not in installed:
+            log(f"  NEW: {cron_id}")
+            install_plist(label, new_plist, plist_path, dry_run)
+        elif plist_needs_update(installed[cron_id], new_plist):
+            log(f"  UPDATE: {cron_id}")
+            install_plist(label, new_plist, plist_path, dry_run)
+        else:
+            log(f"  OK: {cron_id}")
+
+    # 2. Remove crons that are in installed but NOT in manifest and ARE core
+    #    (personal crons like shopify-backup, email-monitor are left alone)
+    for cron_id, plist_path in installed.items():
+        if cron_id not in manifest_ids:
+            # Check if this was previously a core cron by reading the plist
+            # If it points to NEXO_CODE scripts → it's core, safe to remove
+            try:
+                with open(plist_path, "rb") as f:
+                    existing = plistlib.load(f)
+                args = existing.get("ProgramArguments", [])
+                is_core = any(str(NEXO_CODE) in str(a) for a in args)
+            except Exception:
+                is_core = False
+
+            if is_core:
+                log(f"  REMOVE (no longer in manifest): {cron_id}")
+                unload_plist(plist_path, dry_run)
+            else:
+                log(f"  SKIP (personal): {cron_id}")
+
+    log("Sync complete.")
+
+
+if __name__ == "__main__":
+    dry_run = "--dry-run" in sys.argv
+    if dry_run:
+        log("DRY RUN MODE — no changes will be made")
+    sync(dry_run=dry_run)

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():
@@ -307,15 +308,29 @@ async def api_adaptive():
 
 @app.get("/api/sessions")
 async def api_sessions(limit: int = Query(10, ge=1, le=50)):
-    """Recent session diaries."""
+    """Recent session diaries + active sessions from sessions table."""
     db = _db()
     conn = db.get_db()
+    # Active sessions (from sessions table, not diaries)
+    active_rows = conn.execute(
+        "SELECT sid as session_id, task, last_update_epoch, claude_session_id "
+        "FROM sessions WHERE last_update_epoch > (strftime('%s','now') - 900) "
+        "ORDER BY last_update_epoch DESC"
+    ).fetchall()
+    active = [dict(r) for r in active_rows]
+    # Add last_heartbeat as ISO string for frontend
+    for a in active:
+        epoch = a.get("last_update_epoch", 0)
+        if epoch:
+            import datetime
+            a["last_heartbeat"] = datetime.datetime.fromtimestamp(epoch).isoformat()
+    # Recent diaries
     rows = conn.execute(
         "SELECT * FROM session_diary ORDER BY created_at DESC LIMIT ?",
         (limit,),
     ).fetchall()
     diaries = [dict(r) for r in rows]
-    return {"count": len(diaries), "sessions": diaries}
+    return {"count": len(diaries), "sessions": active, "diaries": diaries}
 
 
 @app.get("/api/kg/nodes")
@@ -602,6 +617,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}

package/src/dashboard/templates/dashboard.html

@@ -446,11 +446,12 @@
 
     // --- Overdue Items ---
     if (remindersData || followupsData) {
+      const excludeStatus = ['completed', 'COMPLETED', 'archived', 'deleted', 'DELETED', 'blocked', 'waiting'];
       const reminders = (remindersData?.reminders || []).filter(r =>
-        r.status === 'PENDING' && r.date && r.date < today
+        !excludeStatus.includes(r.status) && r.date && r.date <= today
       );
       const followups = (followupsData?.followups || []).filter(f =>
-        f.status === 'PENDING' && f.date && f.date < today
+        !excludeStatus.includes(f.status) && f.date && f.date <= today
       );
       const total = reminders.length + followups.length;
       const el = document.getElementById('overdue-count');

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"),
     ),
 )
 

package/src/db/_episodic.py

@@ -82,7 +82,7 @@ def auto_resolve_followups(change: dict) -> list[str]:
     conn = get_db()
     open_followups = conn.execute(
         "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETED%' "
-        "AND status != 'DELETED'"
+        "AND status NOT IN ('DELETED','archived','blocked','waiting')"
     ).fetchall()
 
     if not open_followups:
@@ -148,9 +148,7 @@ def update_change_commit(id: int, commit_ref: str) -> dict:
     fts_upsert("change", str(id), r.get("files",""), body, "change_log", commit=False)
 
     # Auto-resolve followups that match this change
-    resolved = auto_resolve_followups(r)
-    if resolved:
-        r["auto_resolved_followups"] = resolved
+    r["_auto_resolved"] = auto_resolve_followups(r)
     return r