nexo-brain 7.20.21 → 7.20.23

package/src/scripts/nexo-backup.sh

@@ -8,24 +8,130 @@ if [ ! -d "$BACKUP_DIR" ] && [ -d "$NEXO_HOME/backups" ]; then
 fi
 WEEKLY_DIR="$BACKUP_DIR/weekly"
 DB="$NEXO_HOME/runtime/data/nexo.db"
-RETENTION_HOURS=48
+LOCAL_CONTEXT_DB="$NEXO_HOME/runtime/memory/local-context.db"
+LOCK_FILE="$NEXO_HOME/runtime/logs/local-index.lock"
+RETENTION_HOURS="${NEXO_BACKUP_RETENTION_HOURS:-24}"
+KEEP_LAST="${NEXO_BACKUP_KEEP_LAST:-3}"
+FAMILY_KEEP_LAST="${NEXO_BACKUP_FAMILY_KEEP_LAST:-2}"
+LOCAL_CONTEXT_RETENTION_HOURS="${NEXO_LOCAL_CONTEXT_BACKUP_RETENTION_HOURS:-24}"
+LOCAL_CONTEXT_KEEP_LAST="${NEXO_LOCAL_CONTEXT_BACKUP_KEEP_LAST:-2}"
+BUSY_TIMEOUT_MS="${NEXO_BACKUP_BUSY_TIMEOUT_MS:-5000}"
+RECENT_BACKUP_HOURS="${NEXO_BACKUP_RECENT_BACKUP_HOURS:-6}"
 
 mkdir -p "$BACKUP_DIR" "$WEEKLY_DIR"
 
+cleanup_backups() {
+    python3 - "$BACKUP_DIR" "$RETENTION_HOURS" "$KEEP_LAST" "$FAMILY_KEEP_LAST" "$LOCAL_CONTEXT_RETENTION_HOURS" "$LOCAL_CONTEXT_KEEP_LAST" <<'PY'
+from __future__ import annotations
+
+import shutil
+import sys
+import time
+from pathlib import Path
+
+base = Path(sys.argv[1])
+retention_hours = max(1, int(sys.argv[2]))
+keep_last = max(1, int(sys.argv[3]))
+family_keep_last = max(1, int(sys.argv[4]))
+local_context_retention_hours = max(1, int(sys.argv[5]))
+local_context_keep_last = max(1, int(sys.argv[6]))
+now = time.time()
+
+def delete_path(path: Path) -> None:
+    try:
+        if path.is_dir():
+            shutil.rmtree(path)
+        else:
+            path.unlink()
+    except FileNotFoundError:
+        pass
+    except Exception as exc:
+        print(f"NEXO backup cleanup warning: {path}: {exc}", file=sys.stderr)
+
+for tmp in base.glob("*.tmp.*"):
+    try:
+        if now - tmp.stat().st_mtime > 1800:
+            delete_path(tmp)
+    except FileNotFoundError:
+        pass
+
+hourlies = sorted(base.glob("nexo-*.db"), key=lambda p: p.stat().st_mtime if p.exists() else 0, reverse=True)
+for backup in hourlies[keep_last:]:
+    try:
+        age_hours = (now - backup.stat().st_mtime) / 3600
+    except FileNotFoundError:
+        continue
+    if age_hours > retention_hours:
+        delete_path(backup)
+
+local_context_hourlies = sorted(
+    base.glob("local-context-*.db"),
+    key=lambda p: p.stat().st_mtime if p.exists() else 0,
+    reverse=True,
+)
+for backup in local_context_hourlies[local_context_keep_last:]:
+    try:
+        age_hours = (now - backup.stat().st_mtime) / 3600
+    except FileNotFoundError:
+        continue
+    if age_hours > local_context_retention_hours:
+        delete_path(backup)
+
+for pattern in (
+    "pre-backfill-owner-*",
+    "pre-update-*",
+    "pre-autoupdate-*",
+    "pre-restore-*",
+    "app-reinstall-*",
+    "app-install-*",
+    "desktop-local-install-*",
+    "code-tree-*",
+):
+    entries = sorted(base.glob(pattern), key=lambda p: p.stat().st_mtime if p.exists() else 0, reverse=True)
+    for entry in entries[family_keep_last:]:
+        delete_path(entry)
+
+weekly = base / "weekly"
+if weekly.exists():
+    for backup in weekly.glob("weekly-*.db"):
+        try:
+            if now - backup.stat().st_mtime > 90 * 24 * 3600:
+                delete_path(backup)
+        except FileNotFoundError:
+            pass
+PY
+}
+
+has_recent_backup() {
+    find "$BACKUP_DIR" -maxdepth 1 -name "nexo-*.db" -mmin "-$((RECENT_BACKUP_HOURS * 60))" -print -quit | grep -q .
+}
+
+has_recent_local_context_backup() {
+    find "$BACKUP_DIR" -maxdepth 1 -name "local-context-*.db" -mmin "-$((RECENT_BACKUP_HOURS * 60))" -print -quit | grep -q .
+}
+
+cleanup_backups
+
 # Hourly backup
 TIMESTAMP=$(date +%Y-%m-%d-%H%M)
 BACKUP_FILE="$BACKUP_DIR/nexo-$TIMESTAMP.db"
 TMP_BACKUP="$BACKUP_FILE.tmp.$$"
 rm -f "$TMP_BACKUP"
-if sqlite3 -cmd ".timeout 60000" "$DB" <<SQL
-PRAGMA busy_timeout=60000;
+if sqlite3 -cmd ".timeout $BUSY_TIMEOUT_MS" "$DB" <<SQL
+PRAGMA busy_timeout=$BUSY_TIMEOUT_MS;
 .backup '$TMP_BACKUP'
 SQL
 then
     mv "$TMP_BACKUP" "$BACKUP_FILE"
 else
     rm -f "$TMP_BACKUP"
-    echo "NEXO backup failed: database busy or unavailable" >&2
+    if has_recent_backup; then
+        echo "NEXO backup skipped: database busy and a recent backup exists" >&2
+        cleanup_backups
+        exit 0
+    fi
+    echo "NEXO backup failed: database busy or unavailable and no recent backup exists" >&2
+    cleanup_backups
     exit 1
 fi
 
@@ -36,6 +142,24 @@ if [ ! -f "$WEEKLY_FILE" ] && [ "$(date +%u)" = "7" ] && [ -f "$BACKUP_FILE" ];
     cp "$BACKUP_FILE" "$WEEKLY_FILE"
 fi
 
-# Cleanup: hourly >48h, weekly >90 days
-find "$BACKUP_DIR" -maxdepth 1 -name "nexo-*.db" -mmin +$((RETENTION_HOURS * 60)) -delete
-find "$WEEKLY_DIR" -name "weekly-*.db" -mtime +90 -delete
+# Local memory backup: separate and aggressively rotated so the index cannot
+# block core DB backups or fill the disk with duplicate multi-GB snapshots.
+if [ -f "$LOCAL_CONTEXT_DB" ]; then
+    LOCAL_CONTEXT_BACKUP_FILE="$BACKUP_DIR/local-context-$TIMESTAMP.db"
+    LOCAL_CONTEXT_TMP_BACKUP="$LOCAL_CONTEXT_BACKUP_FILE.tmp.$$"
+    rm -f "$LOCAL_CONTEXT_TMP_BACKUP"
+    if [ -f "$LOCK_FILE" ] && find "$LOCK_FILE" -mmin -30 -print -quit | grep -q . && has_recent_local_context_backup; then
+        echo "NEXO local memory backup skipped: index is active and a recent local backup exists"
+    elif sqlite3 -cmd ".timeout $BUSY_TIMEOUT_MS" "$LOCAL_CONTEXT_DB" <<SQL
+PRAGMA busy_timeout=$BUSY_TIMEOUT_MS;
+.backup '$LOCAL_CONTEXT_TMP_BACKUP'
+SQL
+    then
+        mv "$LOCAL_CONTEXT_TMP_BACKUP" "$LOCAL_CONTEXT_BACKUP_FILE"
+    else
+        rm -f "$LOCAL_CONTEXT_TMP_BACKUP"
+        echo "NEXO local memory backup warning: local-context database busy or unavailable" >&2
+    fi
+fi
+
+cleanup_backups

package/src/server.py

@@ -5,6 +5,7 @@ import os
 import signal
 import sys
 import json
+import time
 
 from fastmcp import FastMCP
 from core_prompts import render_core_prompt
@@ -94,10 +95,15 @@ from tools_automation_sessions import (
 from plugins.cortex import handle_cortex_check
 from plugins.guard import handle_guard_check
 from plugins.protocol import (
+    handle_confidence_check,
+    handle_protocol_debt_resolve,
     handle_task_acknowledge_guard,
     handle_task_close,
     handle_task_open,
 )
+from plugins.episodic_memory import handle_session_diary_read
+from plugins.cards import handle_card_match
+from plugins.skills import handle_skill_match
 from plugins.workflow import (
     handle_workflow_open,
     handle_workflow_update,
@@ -112,10 +118,12 @@ from runtime_versioning import (
     prime_process_version,
 )
 from local_context import api as local_context_api
+from local_context.db import close_local_context_db
 
 
 # ── Graceful shutdown: close DB on any termination signal ──────────
 def _shutdown_handler(signum, frame):
+    close_local_context_db()
     close_db()
     sys.exit(0)
 
@@ -184,11 +192,23 @@ def _restore_valid_db_backup() -> bool:
 def _init_db_or_exit() -> None:
     import sqlite3
 
-    try:
-        init_db()
-        return
-    except sqlite3.DatabaseError as exc:
-        print(f"[NEXO] DB init failed: {exc}", file=sys.stderr)
+    for attempt in range(3):
+        try:
+            init_db()
+            return
+        except sqlite3.OperationalError as exc:
+            message = str(exc).lower()
+            if "locked" in message or "busy" in message:
+                if attempt < 2:
+                    time.sleep(0.25 * (attempt + 1))
+                    continue
+                print(f"[NEXO] DB init temporarily busy: {exc}", file=sys.stderr)
+                raise SystemExit(75)
+            print(f"[NEXO] DB init failed: {exc}", file=sys.stderr)
+            break
+        except sqlite3.DatabaseError as exc:
+            print(f"[NEXO] DB init failed: {exc}", file=sys.stderr)
+            break
 
     restored = False
     try:
@@ -439,6 +459,76 @@ def nexo_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
     return handle_heartbeat(sid, task, context_hint)
 
 
+@mcp.tool
+def nexo_session_diary_read(
+    session_id: str = "",
+    last_n: int = 3,
+    last_day: bool = False,
+    domain: str = "",
+    brief: bool = False,
+) -> str:
+    """Read recent session diaries for context continuity."""
+    return handle_session_diary_read(session_id, last_n, last_day, domain, brief)
+
+
+@mcp.tool
+def nexo_confidence_check(
+    goal: str,
+    task_type: str = "answer",
+    area: str = "",
+    context_hint: str = "",
+    constraints: str = "[]",
+    evidence_refs: str = "[]",
+    unknowns: str = "[]",
+    verification_step: str = "",
+    stakes: str = "",
+) -> str:
+    """Decide whether an answer should proceed directly or be verified first."""
+    return handle_confidence_check(
+        goal,
+        task_type,
+        area,
+        context_hint,
+        constraints,
+        evidence_refs,
+        unknowns,
+        verification_step,
+        stakes,
+    )
+
+
+@mcp.tool
+def nexo_protocol_debt_resolve(
+    debt_ids: str = "",
+    task_id: str = "",
+    session_id: str = "",
+    debt_types: str = "",
+    resolution: str = "",
+    debt_id: str = "",
+) -> str:
+    """Resolve protocol debt records by id or filters."""
+    return handle_protocol_debt_resolve(debt_ids, task_id, session_id, debt_types, resolution, debt_id)
+
+
+@mcp.tool
+def nexo_card_match(
+    query: str,
+    limit: int = 5,
+    include_protocol: bool = True,
+    locale: str = "es",
+    category: str = "",
+    business_type: str = "",
+) -> str:
+    """Find official NEXO protocol cards for a user request."""
+    return handle_card_match(query, limit, include_protocol, locale, category, business_type)
+
+
+@mcp.tool
+def nexo_skill_match(task: str, level: str = "") -> str:
+    """Find reusable NEXO skills for the current task."""
+    return handle_skill_match(task, level)
+
+
 @mcp.tool
 def nexo_stop(sid: str) -> str:
     """Cleanly close a session. Removes it from active sessions immediately.
@@ -720,7 +810,7 @@ def nexo_local_index_roots(action: str = "list", path: str = "", mode: str = "no
     """List, add or remove local memory roots."""
     normalized = str(action or "list").strip().lower()
     if normalized == "list":
-        result = {"ok": True, "roots": local_context_api.list_roots()}
+        result = {"ok": True, "roots": local_context_api.list_roots(readonly=True)}
     elif normalized == "add":
         result = local_context_api.add_root(path, mode=mode, depth=depth)
     elif normalized == "remove":
@@ -735,7 +825,7 @@ def nexo_local_index_exclusions(action: str = "list", path: str = "", reason: st
     """List, add or remove local memory exclusions."""
     normalized = str(action or "list").strip().lower()
     if normalized == "list":
-        result = {"ok": True, "exclusions": local_context_api.list_exclusions()}
+        result = {"ok": True, "exclusions": local_context_api.list_exclusions(readonly=True)}
     elif normalized == "add":
         result = local_context_api.add_exclusion(path, reason=reason)
     elif normalized == "remove":

package/src/tools_reminders.py

@@ -2,6 +2,7 @@
 
 from db import get_reminders, get_followups
 from datetime import date
+from interactive_db import interactive_db_timeout, is_db_busy
 
 
 def _is_due(date_str: str) -> bool:
@@ -22,21 +23,49 @@ def handle_reminders(filter_type: str = "due") -> str:
         filter_type: 'due', 'all', 'followups', 'completed', 'deleted', 'history', 'any'
     """
     parts = []
+    warnings: list[str] = []
 
-    if filter_type in ("due", "all", "completed", "deleted", "history", "any"):
-        r = _format_reminders(filter_type)
-        if r:
-            parts.append(r)
+    with interactive_db_timeout():
+        if filter_type in ("due", "all", "completed", "deleted", "history", "any"):
+            r = _format_reminders_safe(filter_type, warnings)
+            if r:
+                parts.append(r)
 
-    if filter_type in ("due", "all", "followups", "completed", "deleted", "history", "any"):
-        f = _format_followups(filter_type)
-        if f:
-            parts.append(f)
+        if filter_type in ("due", "all", "followups", "completed", "deleted", "history", "any"):
+            f = _format_followups_safe(filter_type, warnings)
+            if f:
+                parts.append(f)
 
     result = "\n\n".join(parts)
+    if warnings:
+        prefix = "REMINDERS DEGRADED:\n  " + "\n  ".join(warnings)
+        prefix += "\n  Continue with the user request; reminders will catch up shortly."
+        return f"{prefix}\n\n{result}" if result else prefix
     return result if result else "No pending reminders."
 
 
+def _format_reminders_safe(filter_type: str, warnings: list[str]) -> str:
+    try:
+        return _format_reminders(filter_type)
+    except Exception as exc:
+        if is_db_busy(exc):
+            warnings.append("reminders skipped because the local brain database is busy")
+        else:
+            warnings.append(f"reminders skipped ({type(exc).__name__})")
+        return ""
+
+
+def _format_followups_safe(filter_type: str, warnings: list[str]) -> str:
+    try:
+        return _format_followups(filter_type)
+    except Exception as exc:
+        if is_db_busy(exc):
+            warnings.append("followups skipped because the local brain database is busy")
+        else:
+            warnings.append(f"followups skipped ({type(exc).__name__})")
+        return ""
+
+
 def _format_reminders(filter_type: str) -> str:
     """Format reminders from database."""
     rows = get_reminders(filter_type)

package/src/tools_sessions.py

@@ -425,17 +425,6 @@ def handle_startup(
     sid = _generate_sid()
     startup_warnings: list[str] = []
     cleaned = _safe_interactive("stale-session cleanup", clean_stale_sessions, 0, startup_warnings)
-    if startup_warnings:
-        lines = [f"SID: {sid}"]
-        conversation = str(conversation_id or "").strip()
-        if conversation:
-            lines.append(f"CONVERSATION_ID: {conversation}")
-        lines.append("")
-        lines.append("STARTUP DEGRADED:")
-        for warning in startup_warnings[:4]:
-            lines.append(f"  {warning}")
-        lines.append("  Continue responding; retry nexo_heartbeat shortly for full context.")
-        return "\n".join(lines)
     linked_session_id = (session_token or claude_session_id or "").strip()
     # v6.0.7 hotfix: when the caller did not pass an explicit UUID, fall back to
     # the Claude Code SessionStart UUID written by the SessionStart hook to
@@ -485,9 +474,12 @@ def handle_startup(
         startup_warnings,
     )
     memory_maintenance = None
-    if _env_flag("NEXO_MEMORY_MAINTENANCE_IN_STARTUP", default=False):
+    try:
+        backfill_limit = int(os.environ.get("NEXO_MEMORY_STARTUP_BACKFILL_LIMIT", "0") or "0")
+    except Exception:
+        backfill_limit = 0
+    if _env_flag("NEXO_MEMORY_MAINTENANCE_IN_STARTUP", default=False) or backfill_limit > 0:
         try:
-            backfill_limit = int(os.environ.get("NEXO_MEMORY_STARTUP_BACKFILL_LIMIT", "0") or "0")
             memory_maintenance = maintain_memory_observations(
                 process_limit=int(os.environ.get("NEXO_MEMORY_STARTUP_PROCESS_LIMIT", "20") or "20"),
                 retry_failed=True,
@@ -794,7 +786,7 @@ def _handle_heartbeat_inner(sid: str, task: str, context_hint: str = '') -> str:
             if bundle.get("has_matches"):
                 parts.append("")
                 parts.append(format_pre_action_context_bundle(bundle, compact=True))
-            if _env_flag("NEXO_HEARTBEAT_LOCAL_CONTEXT", default=False) and append_local_context_evidence is not None:
+            if _env_flag("NEXO_HEARTBEAT_LOCAL_CONTEXT", default=True) and append_local_context_evidence is not None:
                 local_rendered = append_local_context_evidence("", recent_query, limit=4).strip()
                 if local_rendered:
                     parts.append("")
@@ -895,7 +887,7 @@ def _handle_heartbeat_inner(sid: str, task: str, context_hint: str = '') -> str:
 
     # ── Drive/Curiosity: detect signals from context_hint (best-effort) ──
     try:
-        if _env_flag("NEXO_DRIVE_IN_HEARTBEAT", default=False) and context_hint and len(context_hint.strip()) >= 15:
+        if _env_flag("NEXO_DRIVE_IN_HEARTBEAT", default=True) and context_hint and len(context_hint.strip()) >= 15:
             from tools_drive import detect_drive_signal as _detect_drive
             _drive_allow_llm = _env_flag("NEXO_DRIVE_LLM_IN_HEARTBEAT", default=False)
             _drive_result = _detect_drive(
@@ -1001,7 +993,7 @@ def _handle_heartbeat_inner(sid: str, task: str, context_hint: str = '') -> str:
     # adaptive_log row per heartbeat. Wrapped in best-effort try/except so
     # a failure here cannot block the heartbeat itself.
     try:
-        if _env_flag("NEXO_HEARTBEAT_ADAPTIVE_MODE", default=False) and context_hint and len(context_hint.strip()) >= 5:
+        if _env_flag("NEXO_HEARTBEAT_ADAPTIVE_MODE", default=True) and context_hint and len(context_hint.strip()) >= 5:
             from plugins.adaptive_mode import compute_mode
             from cognitive._trust import detect_sentiment
             sentiment = detect_sentiment(context_hint)
@@ -1345,9 +1337,7 @@ def _hint_suggests_correction(hint: str, *, correction_detector=None) -> bool:
     text = (hint or "").strip()
     if not text:
         return False
-    detector = correction_detector if correction_detector is not None else (
-        _detect_correction_semantic if _env_flag("NEXO_HEARTBEAT_SEMANTIC_DETECTORS", default=False) else None
-    )
+    detector = correction_detector if correction_detector is not None else _detect_correction_semantic
     if detector is not None:
         try:
             if bool(detector(text)):
@@ -1386,6 +1376,8 @@ def _hint_suggests_correction(hint: str, *, correction_detector=None) -> bool:
 
 def _recent_learning_capture_exists(conn, sid: str, window_seconds: int = 300) -> bool:
     """Check whether a recent learning was captured manually or via protocol task close."""
+    if conn is None:
+        conn = get_db()
     cutoff_epoch = time.time() - window_seconds
 
     row = conn.execute(