nexo-brain 3.1.1 → 3.1.3

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/auto_update.py

@@ -1198,6 +1198,7 @@ def _backup_runtime_tree(dest: Path = NEXO_HOME) -> str:
         "evolution_cycle.py", "migrate_embeddings.py", "auto_close_sessions.py",
         "client_sync.py",
         "client_preferences.py", "agent_runner.py", "bootstrap_docs.py",
+        "hook_guardrails.py", "protocol_settings.py", "public_evolution_queue.py",
         "auto_update.py", "tools_sessions.py", "tools_coordination.py",
         "tools_reminders.py", "tools_reminders_crud.py", "tools_learnings.py",
         "tools_credentials.py", "tools_task_history.py", "tools_menu.py",
@@ -1248,6 +1249,7 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
         "evolution_cycle.py", "migrate_embeddings.py", "auto_close_sessions.py",
         "client_sync.py",
         "client_preferences.py", "agent_runner.py", "bootstrap_docs.py",
+        "hook_guardrails.py", "protocol_settings.py", "public_evolution_queue.py",
         "auto_update.py", "tools_sessions.py", "tools_coordination.py",
         "tools_reminders.py", "tools_reminders_crud.py", "tools_learnings.py",
         "tools_credentials.py", "tools_task_history.py", "tools_menu.py",

package/src/cron_recovery.py

@@ -6,6 +6,8 @@ import os
 import plistlib
 import sqlite3
 import contextlib
+import hashlib
+import socket
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
@@ -31,6 +33,55 @@ def _load_json(path: Path, default):
     return default
 
 
+def _schedule_machine_id() -> str:
+    schedule = _load_json(SCHEDULE_FILE, {})
+    if isinstance(schedule, dict):
+        public = schedule.get("public_contribution")
+        if isinstance(public, dict):
+            candidate = str(public.get("machine_id") or "").strip().lower()
+            if candidate:
+                return candidate
+    candidate = socket.gethostname().strip().lower()
+    return candidate or "nexo-machine"
+
+
+def _stable_schedule_bucket(key: str, modulo: int) -> int:
+    if modulo <= 0:
+        return 0
+    digest = hashlib.sha256(f"{_schedule_machine_id()}::{key}".encode("utf-8")).digest()
+    return int.from_bytes(digest[:8], "big") % modulo
+
+
+def resolve_declared_schedule(cron: dict) -> dict:
+    schedule = cron.get("schedule")
+    if not isinstance(schedule, dict):
+        return {}
+
+    resolved = dict(schedule)
+    strategy = str(cron.get("schedule_strategy") or resolved.pop("strategy", "")).strip().lower()
+    if strategy != "machine_weekly_spread":
+        return resolved
+
+    if not {"hour", "minute", "weekday"} <= resolved.keys():
+        return resolved
+
+    total_week_minutes = 7 * 24 * 60
+    base_total = (
+        (int(resolved.get("weekday", 0)) % 7) * 1440
+        + (int(resolved.get("hour", 0)) % 24) * 60
+        + (int(resolved.get("minute", 0)) % 60)
+    )
+    offset = _stable_schedule_bucket(str(cron.get("id") or "cron"), total_week_minutes)
+    slot_total = (base_total + offset) % total_week_minutes
+    weekday, minute_of_day = divmod(slot_total, 1440)
+    hour, minute = divmod(minute_of_day, 60)
+    return {
+        "weekday": weekday,
+        "hour": hour,
+        "minute": minute,
+    }
+
+
 def load_enabled_crons() -> list[dict]:
     manifest_candidates = [
         NEXO_HOME / "crons" / "manifest.json",
@@ -215,7 +266,7 @@ def effective_schedule(cron: dict) -> dict:
         return {
             "source": "manifest",
             "schedule_type": "calendar",
-            "calendar": cron["schedule"],
+            "calendar": resolve_declared_schedule(cron),
             "run_at_load": should_run_at_load(cron),
         }
     return {

package/src/crons/manifest.json

@@ -107,6 +107,7 @@
     {
       "id": "evolution",
       "script": "scripts/nexo-evolution-run.py",
+      "schedule_strategy": "machine_weekly_spread",
       "schedule": {"hour": 5, "minute": 0, "weekday": 0},
       "description": "Weekly self-improvement cycle — propose and evaluate changes",
       "core": true,

package/src/crons/sync.py

@@ -31,7 +31,7 @@ _runtime_root = Path(os.environ.get("NEXO_CODE", str(_DEFAULT_RUNTIME_ROOT)))
 if str(_runtime_root) not in sys.path:
     sys.path.insert(0, str(_runtime_root))
 
-from cron_recovery import should_run_at_load
+from cron_recovery import resolve_declared_schedule, should_run_at_load
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 SOURCE_ROOT = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent.parent)))
@@ -242,7 +242,7 @@ def build_plist(cron: dict) -> dict:
         plist["StartInterval"] = cron["interval_seconds"]
     elif "schedule" in cron and not cron.get("keep_alive"):
         cal = {}
-        s = cron["schedule"]
+        s = resolve_declared_schedule(cron)
         if "hour" in s:
             cal["Hour"] = s["hour"]
         if "minute" in s:
@@ -443,7 +443,7 @@ StandardError=append:{stderr_log}
         elif "interval_seconds" in cron:
             timer_spec = f"OnUnitActiveSec={cron['interval_seconds']}s\nOnBootSec=60s"
         elif "schedule" in cron:
-            s = cron["schedule"]
+            s = resolve_declared_schedule(cron)
             h, m = s.get("hour", 0), s.get("minute", 0)
             if "weekday" in s:
                 # Manifest weekday uses launchd convention: 0=Sunday … 6=Saturday (7=Sunday alias)

package/src/dashboard/app.py

@@ -745,18 +745,21 @@ async def api_reminders_list(
 ):
     """List reminders."""
     db = _db()
-    conn = db.get_db()
-    query = "SELECT * FROM reminders WHERE 1=1"
-    params = []
+    reminders = db.get_reminders("any")
     if status:
-        query += " AND status = ?"
-        params.append(status)
+        if status in {"any", "all", "history"}:
+            pass
+        elif status == "completed":
+            reminders = [r for r in reminders if str(r.get("status") or "").startswith("COMPLETED")]
+        elif status == "deleted":
+            reminders = [r for r in reminders if r.get("status") == "DELETED"]
+        else:
+            reminders = [r for r in reminders if r.get("status") == status]
+    else:
+        reminders = [r for r in reminders if r.get("status") != "DELETED"]
     if category:
-        query += " AND category = ?"
-        params.append(category)
-    query += " ORDER BY created_at DESC"
-    rows = conn.execute(query, params).fetchall()
-    reminders = [dict(r) for r in rows]
+        reminders = [r for r in reminders if r.get("category") == category]
+    reminders = sorted(reminders, key=lambda item: item.get("updated_at") or item.get("created_at") or 0, reverse=True)
     return {"count": len(reminders), "reminders": reminders}
 
 
@@ -766,59 +769,60 @@ async def api_reminders_create(body: ReminderCreate):
     db = _db()
     conn = db.get_db()
     rid = _next_reminder_id(conn)
-    now = time.time()
-    conn.execute(
-        "INSERT INTO reminders (id, description, date, status, category, created_at, updated_at) VALUES (?,?,?,?,?,?,?)",
-        (rid, body.description, body.date, "PENDING", body.category or "general", now, now),
+    result = db.create_reminder(
+        rid,
+        body.description,
+        date=body.date,
+        category=body.category or "general",
     )
-    conn.commit()
-    row = conn.execute("SELECT * FROM reminders WHERE id = ?", (rid,)).fetchone()
-    return {"success": True, "reminder": dict(row)}
+    if not result or "error" in result:
+        return JSONResponse({"error": result.get("error", "Failed to create reminder")}, status_code=400)
+    return {"success": True, "reminder": result}
+
+
+@app.get("/api/reminders/{rid}")
+async def api_reminders_get(rid: str):
+    """Get a reminder with history."""
+    db = _db()
+    row = db.get_reminder(rid, include_history=True)
+    if not row:
+        return JSONResponse({"error": f"Reminder {rid} not found"}, status_code=404)
+    return {"success": True, "reminder": row}
 
 
 @app.put("/api/reminders/{rid}")
 async def api_reminders_update(rid: str, body: ReminderUpdate):
     """Update a reminder."""
     db = _db()
-    conn = db.get_db()
-    row = conn.execute("SELECT * FROM reminders WHERE id = ?", (rid,)).fetchone()
+    row = db.get_reminder(rid)
     if not row:
         return JSONResponse({"error": f"Reminder {rid} not found"}, status_code=404)
-    fields = []
-    params = []
+    fields = {}
     if body.description is not None:
-        fields.append("description = ?")
-        params.append(body.description)
+        fields["description"] = body.description
     if body.date is not None:
-        fields.append("date = ?")
-        params.append(body.date)
+        fields["date"] = body.date
     if body.status is not None:
-        fields.append("status = ?")
-        params.append(body.status)
+        fields["status"] = body.status
     if body.category is not None:
-        fields.append("category = ?")
-        params.append(body.category)
+        fields["category"] = body.category
     if not fields:
-        return {"success": True, "reminder": dict(row)}
-    fields.append("updated_at = ?")
-    params.append(time.time())
-    params.append(rid)
-    conn.execute(f"UPDATE reminders SET {', '.join(fields)} WHERE id = ?", params)
-    conn.commit()
-    row = conn.execute("SELECT * FROM reminders WHERE id = ?", (rid,)).fetchone()
-    return {"success": True, "reminder": dict(row)}
+        return {"success": True, "reminder": row}
+    result = db.update_reminder(rid, history_actor="dashboard", **fields)
+    if not result or "error" in result:
+        return JSONResponse({"error": result.get("error", f"Reminder {rid} not found")}, status_code=400)
+    return {"success": True, "reminder": result}
 
 
 @app.delete("/api/reminders/{rid}")
 async def api_reminders_delete(rid: str):
-    """Delete a reminder."""
+    """Soft-delete a reminder."""
     db = _db()
-    conn = db.get_db()
-    row = conn.execute("SELECT * FROM reminders WHERE id = ?", (rid,)).fetchone()
+    row = db.get_reminder(rid)
     if not row:
         return JSONResponse({"error": f"Reminder {rid} not found"}, status_code=404)
-    conn.execute("DELETE FROM reminders WHERE id = ?", (rid,))
-    conn.commit()
+    db.add_reminder_note(rid, "Soft-deleted from dashboard.", actor="dashboard")
+    db.delete_reminder(rid)
     return {"success": True, "deleted_id": rid}
 
 
@@ -847,15 +851,19 @@ async def api_followups_list(
 ):
     """List followups."""
     db = _db()
-    conn = db.get_db()
-    query = "SELECT * FROM followups WHERE 1=1"
-    params = []
+    followups = db.get_followups("any")
     if status:
-        query += " AND status = ?"
-        params.append(status)
-    query += " ORDER BY created_at DESC"
-    rows = conn.execute(query, params).fetchall()
-    followups = [dict(r) for r in rows]
+        if status in {"any", "all", "history"}:
+            pass
+        elif status == "completed":
+            followups = [r for r in followups if str(r.get("status") or "").startswith("COMPLETED")]
+        elif status == "deleted":
+            followups = [r for r in followups if r.get("status") == "DELETED"]
+        else:
+            followups = [r for r in followups if r.get("status") == status]
+    else:
+        followups = [r for r in followups if r.get("status") != "DELETED"]
+    followups = sorted(followups, key=lambda item: item.get("updated_at") or item.get("created_at") or 0, reverse=True)
     return {"count": len(followups), "followups": followups}
 
 
@@ -865,62 +873,63 @@ async def api_followups_create(body: FollowupCreate):
     db = _db()
     conn = db.get_db()
     fid = _next_followup_id(conn)
-    now = time.time()
-    conn.execute(
-        "INSERT INTO followups (id, description, date, verification, status, reasoning, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?)",
-        (fid, body.description, body.date, body.verification, "PENDING", body.reasoning, now, now),
+    result = db.create_followup(
+        fid,
+        body.description,
+        date=body.date,
+        verification=body.verification or "",
+        reasoning=body.reasoning or "",
     )
-    conn.commit()
-    row = conn.execute("SELECT * FROM followups WHERE id = ?", (fid,)).fetchone()
-    return {"success": True, "followup": dict(row)}
+    if not result or "error" in result:
+        return JSONResponse({"error": result.get("error", "Failed to create followup")}, status_code=400)
+    return {"success": True, "followup": result}
+
+
+@app.get("/api/followups/{fid}")
+async def api_followups_get(fid: str):
+    """Get a followup with history."""
+    db = _db()
+    row = db.get_followup(fid, include_history=True)
+    if not row:
+        return JSONResponse({"error": f"Followup {fid} not found"}, status_code=404)
+    return {"success": True, "followup": row}
 
 
 @app.put("/api/followups/{fid}")
 async def api_followups_update(fid: str, body: FollowupUpdate):
     """Update a followup."""
     db = _db()
-    conn = db.get_db()
-    row = conn.execute("SELECT * FROM followups WHERE id = ?", (fid,)).fetchone()
+    row = db.get_followup(fid)
     if not row:
         return JSONResponse({"error": f"Followup {fid} not found"}, status_code=404)
-    fields = []
-    params = []
+    fields = {}
     if body.description is not None:
-        fields.append("description = ?")
-        params.append(body.description)
+        fields["description"] = body.description
     if body.date is not None:
-        fields.append("date = ?")
-        params.append(body.date)
+        fields["date"] = body.date
     if body.status is not None:
-        fields.append("status = ?")
-        params.append(body.status)
+        fields["status"] = body.status
     if body.verification is not None:
-        fields.append("verification = ?")
-        params.append(body.verification)
+        fields["verification"] = body.verification
     if body.reasoning is not None:
-        fields.append("reasoning = ?")
-        params.append(body.reasoning)
+        fields["reasoning"] = body.reasoning
     if not fields:
-        return {"success": True, "followup": dict(row)}
-    fields.append("updated_at = ?")
-    params.append(time.time())
-    params.append(fid)
-    conn.execute(f"UPDATE followups SET {', '.join(fields)} WHERE id = ?", params)
-    conn.commit()
-    row = conn.execute("SELECT * FROM followups WHERE id = ?", (fid,)).fetchone()
-    return {"success": True, "followup": dict(row)}
+        return {"success": True, "followup": row}
+    result = db.update_followup(fid, history_actor="dashboard", **fields)
+    if not result or "error" in result:
+        return JSONResponse({"error": result.get("error", f"Followup {fid} not found")}, status_code=400)
+    return {"success": True, "followup": result}
 
 
 @app.delete("/api/followups/{fid}")
 async def api_followups_delete(fid: str):
-    """Delete a followup."""
+    """Soft-delete a followup."""
     db = _db()
-    conn = db.get_db()
-    row = conn.execute("SELECT * FROM followups WHERE id = ?", (fid,)).fetchone()
+    row = db.get_followup(fid)
     if not row:
         return JSONResponse({"error": f"Followup {fid} not found"}, status_code=404)
-    conn.execute("DELETE FROM followups WHERE id = ?", (fid,))
-    conn.commit()
+    db.add_followup_note(fid, "Soft-deleted from dashboard.", actor="dashboard")
+    db.delete_followup(fid)
     return {"success": True, "deleted_id": fid}
 
 
@@ -933,36 +942,49 @@ async def api_ops_move(body: MoveRequest):
     """Move an item between reminders and followups."""
     db = _db()
     conn = db.get_db()
-    now = time.time()
 
     if body.direction == "to_followup":
-        # Read from reminders
-        row = conn.execute("SELECT * FROM reminders WHERE id = ?", (body.id,)).fetchone()
-        if not row:
+        item = db.get_reminder(body.id)
+        if not item:
             return JSONResponse({"error": f"Reminder {body.id} not found"}, status_code=404)
-        item = dict(row)
         fid = _next_followup_id(conn)
-        conn.execute(
-            "INSERT INTO followups (id, description, date, status, created_at, updated_at) VALUES (?,?,?,?,?,?)",
-            (fid, item["description"], item.get("date"), "PENDING", now, now),
+        created = db.create_followup(
+            fid,
+            item["description"],
+            date=item.get("date"),
+            reasoning=f"Moved from reminder {body.id} via dashboard.",
         )
-        conn.execute("DELETE FROM reminders WHERE id = ?", (body.id,))
-        conn.commit()
+        if not created or "error" in created:
+            return JSONResponse({"error": created.get("error", "Failed to create followup")}, status_code=400)
+        db.add_followup_note(fid, f"Created from reminder {body.id} via dashboard move.", actor="dashboard")
+        db.add_reminder_note(body.id, f"Moved to followup {fid} via dashboard.", actor="dashboard")
+        db.delete_reminder(body.id)
         return {"success": True, "new_id": fid, "direction": "to_followup"}
 
     elif body.direction == "to_reminder":
-        # Read from followups
-        row = conn.execute("SELECT * FROM followups WHERE id = ?", (body.id,)).fetchone()
-        if not row:
+        item = db.get_followup(body.id)
+        if not item:
             return JSONResponse({"error": f"Followup {body.id} not found"}, status_code=404)
-        item = dict(row)
         rid = _next_reminder_id(conn)
-        conn.execute(
-            "INSERT INTO reminders (id, description, date, status, category, created_at, updated_at) VALUES (?,?,?,?,?,?,?)",
-            (rid, item["description"], item.get("date"), "PENDING", "general", now, now),
+        created = db.create_reminder(
+            rid,
+            item["description"],
+            date=item.get("date"),
+            category="general",
         )
-        conn.execute("DELETE FROM followups WHERE id = ?", (body.id,))
-        conn.commit()
+        if not created or "error" in created:
+            return JSONResponse({"error": created.get("error", "Failed to create reminder")}, status_code=400)
+        migration_note = f"Created from followup {body.id} via dashboard move."
+        extra = []
+        if item.get("verification"):
+            extra.append(f"Previous verification: {item['verification']}")
+        if item.get("reasoning"):
+            extra.append(f"Previous reasoning: {item['reasoning']}")
+        if extra:
+            migration_note += " " + " ".join(extra)
+        db.add_reminder_note(rid, migration_note, actor="dashboard")
+        db.add_followup_note(body.id, f"Moved to reminder {rid} via dashboard.", actor="dashboard")
+        db.delete_followup(body.id)
         return {"success": True, "new_id": rid, "direction": "to_reminder"}
 
     else:
@@ -977,7 +999,10 @@ async def api_ops_execute(fid: str):
     """Execute a followup by opening Terminal with the configured NEXO client."""
     db = _db()
     conn = db.get_db()
-    row = conn.execute("SELECT * FROM followups WHERE id = ?", (fid,)).fetchone()
+    row = conn.execute(
+        "SELECT * FROM followups WHERE id = ? AND status != 'DELETED'",
+        (fid,),
+    ).fetchone()
     if not row:
         return JSONResponse({"error": f"Followup {fid} not found"}, status_code=404)
     item = dict(row)
@@ -1092,12 +1117,12 @@ async def api_calendar(
     month_prefix = f"{year}-{month:02d}%"
 
     reminder_rows = conn.execute(
-        "SELECT *, 'reminder' as item_type FROM reminders WHERE date LIKE ? ORDER BY date ASC",
+        "SELECT *, 'reminder' as item_type FROM reminders WHERE date LIKE ? AND status != 'DELETED' ORDER BY date ASC",
         (month_prefix,),
     ).fetchall()
 
     followup_rows = conn.execute(
-        "SELECT *, 'followup' as item_type FROM followups WHERE date LIKE ? ORDER BY date ASC",
+        "SELECT *, 'followup' as item_type FROM followups WHERE date LIKE ? AND status != 'DELETED' ORDER BY date ASC",
         (month_prefix,),
     ).fetchall()
 

package/src/db/__init__.py

@@ -36,10 +36,11 @@ from db._sessions import (
 # Reminders and followups
 from db._reminders import (
     create_reminder, update_reminder, complete_reminder, delete_reminder,
-    get_reminders, get_reminder,
+    restore_reminder, add_reminder_note, get_reminders, get_reminder, get_reminder_history,
     create_followup, update_followup, complete_followup, delete_followup,
-    get_followups, get_followup,
+    restore_followup, add_followup_note, get_followups, get_followup, get_followup_history,
     find_similar_followups,
+    add_item_history, get_item_history, validate_item_read_token,
 )
 
 # Learnings

package/src/db/_core.py

@@ -190,6 +190,26 @@ def init_db():
             updated_at REAL NOT NULL
         );
 
+        CREATE TABLE IF NOT EXISTS item_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            item_type TEXT NOT NULL,
+            item_id TEXT NOT NULL,
+            event_type TEXT NOT NULL,
+            note TEXT DEFAULT '',
+            actor TEXT DEFAULT '',
+            metadata TEXT DEFAULT '{}',
+            created_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS item_read_tokens (
+            token TEXT PRIMARY KEY,
+            item_type TEXT NOT NULL,
+            item_id TEXT NOT NULL,
+            history_seq INTEGER DEFAULT 0,
+            issued_at REAL NOT NULL,
+            expires_at REAL NOT NULL
+        );
+
         CREATE TABLE IF NOT EXISTS learnings (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             category TEXT NOT NULL,
@@ -415,4 +435,3 @@ def _multi_word_like(query: str, columns: list[str]) -> tuple[str, list]:
         word_conditions.append(f"({col_or})")
         params.extend([pattern] * len(columns))
     return " AND ".join(word_conditions), params
-