nexo-brain 7.20.22 → 7.20.24

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.20.19",
+  "version": "7.20.24",
   "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/README.md

@@ -18,7 +18,11 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.20.19` is the current packaged-runtime line. Patch release over v7.20.18 — Local Memory status and long first-indexing runs stay stable during Desktop-managed updates; stale macOS Full Disk Access denials are cleared after a live access probe succeeds.
+Version `7.20.24` is the current packaged-runtime line. Patch release over v7.20.23 — Local Memory performance profile writes now tolerate active indexing, retry transient SQLite busy states, and shorten indexer write locks between processed files.
+
+Previously in `7.20.23`: patch release over v7.20.22 — Local Memory status reads the real split sidecar database read-only, reports retryable keyed failures without false zeroes, and keeps Desktop Spanish/English copy localized.
+
+Previously in `7.20.22`: patch release over v7.20.19 — Local Memory moved out of the main Brain database, MCP readiness verifies required tools, and split-aware Desktop backups validate the main DB and Local Memory sidecar separately.
 
 Previously in `7.20.18`: patch release over v7.20.17 — Desktop-managed setup now preserves a completed onboarding flag when Brain is later invoked with the non-interactive `--skip` bootstrap path.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.20.22",
+  "version": "7.20.24",
   "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

@@ -99,15 +99,13 @@ LOCAL_CONTEXT_BACKUP_TABLES = (
     "local_context_queries",
     "local_index_dirs",
 )
-PROTECTED_BACKUP_TABLES = CRITICAL_BACKUP_TABLES
+PROTECTED_BACKUP_TABLES = CRITICAL_BACKUP_TABLES + LOCAL_CONTEXT_BACKUP_TABLES
 
 
 def _backup_validation_tables(db_file: Path) -> tuple[str, ...]:
-    if db_file.name == "nexo.db":
-        return PROTECTED_BACKUP_TABLES
     if db_file.name == "local-context.db":
         return LOCAL_CONTEXT_BACKUP_TABLES
-    return ()
+    return PROTECTED_BACKUP_TABLES
 
 
 CLASSIFIER_INSTALL_TIMEOUT_SECONDS = 1800
@@ -1447,6 +1445,7 @@ def _self_heal_if_wiped() -> dict | None:
         from db_guard import (
             CRITICAL_TABLES,
             HOURLY_BACKUP_MAX_AGE,
+            LOCAL_CONTEXT_TABLES,
             MIN_REFERENCE_ROWS,
             PROTECTED_TABLES,
             db_looks_wiped,
@@ -1467,14 +1466,15 @@ def _self_heal_if_wiped() -> dict | None:
         return None
     if not db_looks_wiped(primary, PROTECTED_TABLES):
         return None
+    recovery_tables = PROTECTED_TABLES + LOCAL_CONTEXT_TABLES
     reference = find_best_hourly_backup(
         paths.backups_dir(),
         max_age_seconds=HOURLY_BACKUP_MAX_AGE,
-        tables=PROTECTED_TABLES,
+        tables=recovery_tables,
     ) or find_latest_hourly_backup(
         paths.backups_dir(),
         max_age_seconds=HOURLY_BACKUP_MAX_AGE,
-        tables=PROTECTED_TABLES,
+        tables=recovery_tables,
     )
     if reference is None:
         _log("self-heal: nexo.db looks wiped but no usable hourly backup found — skipping.")
@@ -1483,7 +1483,7 @@ def _self_heal_if_wiped() -> dict | None:
             "reason": "no_usable_hourly_backup",
             "primary_db": str(primary),
         }
-    ref_counts = db_row_counts(reference, PROTECTED_TABLES)
+    ref_counts = db_row_counts(reference, recovery_tables)
     ref_total = sum(v for v in ref_counts.values() if isinstance(v, int))
     if ref_total < MIN_REFERENCE_ROWS:
         _log(f"self-heal: reference backup {reference.name} has {ref_total} rows, below floor {MIN_REFERENCE_ROWS}")
@@ -1572,7 +1572,7 @@ def _self_heal_if_wiped() -> dict | None:
             "quiesce": quiesce_report,
             "resume": resume_report,
         }
-    valid, valid_err = validate_backup_matches_source(reference, primary, PROTECTED_TABLES)
+    valid, valid_err = validate_backup_matches_source(reference, primary, recovery_tables)
     if not valid:
         _log(f"self-heal: post-restore validation failed: {valid_err}")
         resume_report = _resume_quiesced()
@@ -1586,7 +1586,7 @@ def _self_heal_if_wiped() -> dict | None:
             "resume": resume_report,
         }
 
-    final_counts = db_row_counts(primary, PROTECTED_TABLES)
+    final_counts = db_row_counts(primary, recovery_tables)
     final_total = sum(v for v in final_counts.values() if isinstance(v, int))
     _log(f"self-heal: restored {final_total} critical rows from {reference.name}.")
     resume_report = _resume_quiesced()
@@ -3988,7 +3988,7 @@ def _auto_update_check_locked() -> dict:
 
     # Backfill runtime CLI modules for existing installs
     try:
-        for fname in ("cli.py", "script_registry.py", "skills_runtime.py", "cron_recovery.py", "client_preferences.py", "claude_cli.py", "agent_runner.py", "bootstrap_docs.py"):
+        for fname in ("cli.py", "script_registry.py", "skills_runtime.py", "cron_recovery.py", "client_preferences.py", "claude_cli.py", "agent_runner.py", "bootstrap_docs.py", "mcp_required_tools.py"):
             src_file = SRC_DIR / fname
             dest_file = NEXO_HOME / fname
             if src_file.is_file() and (not dest_file.exists() or src_file.stat().st_mtime > dest_file.stat().st_mtime):

package/src/cli.py

@@ -52,7 +52,17 @@ from pathlib import Path
 
 from runtime_home import export_resolved_nexo_home
 from runtime_versioning import build_mcp_status, clear_restart_required_marker
-from mcp_required_tools import BOOTSTRAP_REQUIRED_MCP_TOOLS, missing_required_tools
+try:
+    from mcp_required_tools import BOOTSTRAP_REQUIRED_MCP_TOOLS, missing_required_tools
+except ModuleNotFoundError as exc:
+    if getattr(exc, "name", "") != "mcp_required_tools":
+        raise
+    # Older installed runtimes can be missing modules added after their CLI was
+    # copied. Keep `nexo update` bootable so the sync can repair the runtime.
+    BOOTSTRAP_REQUIRED_MCP_TOOLS: tuple[str, ...] = ()
+
+    def missing_required_tools(_tool_names):
+        return []
 
 NEXO_HOME = export_resolved_nexo_home()
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent)))
@@ -3389,7 +3399,7 @@ def main():
 
     local_context_query_p = local_context_sub.add_parser("query", help="Query local memory evidence")
     local_context_query_p.add_argument("query", help="Question or search phrase")
-    local_context_query_p.add_argument("--intent", default="answer", help="Intent label stored with the query audit row")
+    local_context_query_p.add_argument("--intent", default="answer", help="Intent label included with the query result")
     local_context_query_p.add_argument("--limit", type=int, default=12, help="Maximum evidence rows")
     local_context_query_p.add_argument("--current-context", default="", help="Optional current conversation/task context")
     local_context_query_p.add_argument("--mode", choices=["compact", "full"], default="compact", help="Payload shape. Compact is safe for chat clients; full is for debugging.")

package/src/db_guard.py

@@ -86,12 +86,17 @@ LOCAL_CONTEXT_TABLES: tuple[str, ...] = (
     "local_index_dirs",
 )
 
-# Tables protected inside the operational Brain DB. Local memory now lives in
-# runtime/memory/local-context.db and is validated with LOCAL_CONTEXT_TABLES
-# separately; mixing both here makes old local-index backups look like the
-# source of truth for nexo.db and can block every update.
+# Tables protected inside the operational Brain DB. Keep this core-only:
+# callers that need local memory checks must request LOCAL_CONTEXT_TABLES or
+# RECOVERY_TABLES explicitly so normal Brain wipe detection is not skewed by
+# split local-memory databases.
 PROTECTED_TABLES: tuple[str, ...] = CRITICAL_TABLES
 
+# Recovery must still inspect legacy backups that carried local memory tables
+# inside nexo.db. This wider set is safe for row counts and restore validation,
+# but should not replace PROTECTED_TABLES in core wipe-diff callers.
+RECOVERY_TABLES: tuple[str, ...] = CRITICAL_TABLES + LOCAL_CONTEXT_TABLES
+
 # A reference backup must contain at least this many rows (summed across
 # CRITICAL_TABLES) before we will treat it as "proof the user has real data".
 # Otherwise we cannot distinguish a fresh install from a wipe.
@@ -211,7 +216,7 @@ def _table_count(conn: sqlite3.Connection, table: str) -> int | None:
     return int(result[0]) if result is not None else 0
 
 
-def db_row_counts(path: str | Path, tables: tuple[str, ...] = PROTECTED_TABLES) -> dict[str, int | None]:
+def db_row_counts(path: str | Path, tables: tuple[str, ...] = RECOVERY_TABLES) -> dict[str, int | None]:
     """Return {table: count} for a SQLite DB. Missing DB / missing tables map to None."""
     p = Path(path)
     counts: dict[str, int | None] = {t: None for t in tables}
@@ -253,11 +258,22 @@ def db_looks_wiped(
         size = p.stat().st_size
     except OSError:
         return False
+    counts = db_row_counts(p, tables)
     if size <= EMPTY_DB_SIZE_BYTES:
         # Small but not necessarily wiped — confirm via row counts.
-        counts = db_row_counts(p, tables)
-        return _all_tables_empty_or_missing(counts)
-    counts = db_row_counts(p, tables)
+        return _counts_look_wiped(counts)
+    return _counts_look_wiped(counts)
+
+
+def _counts_look_wiped(counts: dict[str, int | None]) -> bool:
+    """Treat Brain table loss as a wipe even if legacy local tables remain."""
+    critical_present = {
+        table: counts.get(table)
+        for table in CRITICAL_TABLES
+        if counts.get(table) is not None
+    }
+    if critical_present:
+        return _all_tables_empty_or_missing(critical_present)
     return _all_tables_empty_or_missing(counts)
 
 

package/src/doctor/providers/boot.py

@@ -44,6 +44,7 @@ def check_db_integrity(fix: bool = False) -> DoctorCheck:
     from db_guard import (
         CRITICAL_TABLES,
         EMPTY_DB_SIZE_BYTES,
+        LOCAL_CONTEXT_TABLES,
         MIN_REFERENCE_ROWS,
         PROTECTED_TABLES,
         db_looks_wiped,
@@ -98,6 +99,47 @@ def check_db_integrity(fix: bool = False) -> DoctorCheck:
     reference_counts = db_row_counts(reference, PROTECTED_TABLES) if reference else {}
     reference_rows = sum(v for v in reference_counts.values() if isinstance(v, int))
     protected_regression = diff_row_counts(db_path, reference, PROTECTED_TABLES) if reference else None
+    local_context_db = paths.memory_dir() / "local-context.db"
+    local_needs_reference = (
+        not local_context_db.is_file()
+        or db_looks_wiped(local_context_db, LOCAL_CONTEXT_TABLES)
+    )
+    local_reference = None
+    if local_needs_reference:
+        local_reference = (
+            find_best_hourly_backup(
+                paths.backups_dir(),
+                glob="local-context-*.db",
+                min_critical_rows=MIN_REFERENCE_ROWS,
+                tables=LOCAL_CONTEXT_TABLES,
+            )
+            or find_latest_hourly_backup(
+                paths.backups_dir(),
+                glob="local-context-*.db",
+                min_critical_rows=MIN_REFERENCE_ROWS,
+                tables=LOCAL_CONTEXT_TABLES,
+            )
+            or find_best_hourly_backup(
+                paths.backups_dir(),
+                glob="nexo-*.db",
+                min_critical_rows=MIN_REFERENCE_ROWS,
+                tables=LOCAL_CONTEXT_TABLES,
+            )
+            or find_latest_hourly_backup(
+                paths.backups_dir(),
+                glob="nexo-*.db",
+                min_critical_rows=MIN_REFERENCE_ROWS,
+                tables=LOCAL_CONTEXT_TABLES,
+            )
+        )
+    local_reference_counts = db_row_counts(local_reference, LOCAL_CONTEXT_TABLES) if local_reference else {}
+    local_reference_rows = sum(v for v in local_reference_counts.values() if isinstance(v, int))
+    local_regression = diff_row_counts(local_context_db, local_reference, LOCAL_CONTEXT_TABLES) if local_reference else None
+    recoverable_local_regression = bool(
+        local_reference
+        and local_regression
+        and local_regression.is_wipe()
+    )
     recoverable_regression = bool(
         reference
         and protected_regression
@@ -121,7 +163,7 @@ def check_db_integrity(fix: bool = False) -> DoctorCheck:
         )
     )
 
-    if quick_ok and not recoverable_wipe and not recoverable_regression:
+    if quick_ok and not recoverable_wipe and not recoverable_regression and not recoverable_local_regression:
         if looks_wiped and not reference:
             return DoctorCheck(
                 id="boot.db_integrity",
@@ -150,6 +192,11 @@ def check_db_integrity(fix: bool = False) -> DoctorCheck:
         evidence.append(f"Reference backup: {reference} ({reference_rows} protected rows)")
     if protected_regression:
         evidence.extend(protected_regression.summary_lines())
+    if local_reference:
+        evidence.append(f"Local memory DB: {local_context_db}")
+        evidence.append(f"Local memory reference: {local_reference} ({local_reference_rows} rows)")
+    if local_regression:
+        evidence.extend(["Local memory regression:", *local_regression.summary_lines()])
 
     if fix and recoverable_regression:
         report = restore_tables_from_backup(reference, db_path)
@@ -205,7 +252,49 @@ def check_db_integrity(fix: bool = False) -> DoctorCheck:
             repair_plan=["Run nexo recover --force --yes, then restart Desktop"],
         )
 
-    if recoverable_wipe or recoverable_regression:
+    if fix and recoverable_local_regression:
+        try:
+            local_context_db.parent.mkdir(parents=True, exist_ok=True)
+            if not local_context_db.exists():
+                sqlite3.connect(str(local_context_db)).close()
+        except Exception as exc:
+            return DoctorCheck(
+                id="boot.db_integrity",
+                tier="boot",
+                status="critical",
+                severity="error",
+                summary="Local memory sidecar repair failed",
+                evidence=evidence + [f"Cannot create local memory DB: {type(exc).__name__}: {exc}"],
+                repair_plan=["Close NEXO Desktop and run nexo doctor --tier boot --plane database_real --fix"],
+            )
+        report = restore_tables_from_backup(local_reference, local_context_db, tables=LOCAL_CONTEXT_TABLES)
+        if report.get("ok"):
+            restored = {
+                table: payload
+                for table, payload in (report.get("tables") or {}).items()
+                if isinstance(payload, dict) and payload.get("status") == "restored"
+            }
+            restored_rows = sum(int(payload.get("after") or 0) for payload in restored.values())
+            return DoctorCheck(
+                id="boot.db_integrity",
+                tier="boot",
+                status="healthy",
+                severity="info",
+                summary=f"Local memory sidecar restored from backup ({restored_rows} rows)",
+                evidence=evidence + [f"Restored local-memory sidecar tables: {len(restored)}"],
+                fixed=True,
+            )
+        return DoctorCheck(
+            id="boot.db_integrity",
+            tier="boot",
+            status="critical",
+            severity="error",
+            summary="Local memory sidecar repair failed",
+            evidence=evidence + [f"Restore errors: {report.get('errors') or []}"],
+            repair_plan=["Close NEXO Desktop and run nexo doctor --tier boot --plane database_real --fix"],
+        )
+
+    if recoverable_wipe or recoverable_regression or recoverable_local_regression:
         return DoctorCheck(
             id="boot.db_integrity",
             tier="boot",

package/src/local_context/api.py

@@ -4,15 +4,17 @@ import json
 import os
 import re
 import shutil
+import sqlite3
 import stat
 import hashlib
 import subprocess
 import sys
+import time
 from pathlib import Path
 from typing import Any
 
 from . import embeddings
-from .db import ensure_local_context_db, get_local_context_db
+from .db import LOCAL_CONTEXT_TABLES, close_local_context_db, connect_local_context_db_readonly, ensure_local_context_db, get_local_context_db
 from .extractors import chunk_text, contains_secret, entities, extract_text, summarize
 from .logging import log_event, tail
 from .privacy import classify_path, is_local_email_tree, is_queryable_path, should_extract, should_skip_file, should_skip_tree
@@ -32,6 +34,8 @@ DEFAULT_SYSTEM_ROOT_DEPTH = int(os.environ.get("NEXO_LOCAL_INDEX_SYSTEM_ROOT_DEP
 DEFAULT_CONTEXT_MAX_CHARS = int(os.environ.get("NEXO_LOCAL_CONTEXT_MAX_CHARS", "20000") or "20000")
 DEFAULT_ROUTER_MAX_CHARS = int(os.environ.get("NEXO_LOCAL_CONTEXT_ROUTER_MAX_CHARS", "6000") or "6000")
 DEFAULT_MAX_JOB_ATTEMPTS = int(os.environ.get("NEXO_LOCAL_INDEX_MAX_JOB_ATTEMPTS", "3") or "3")
+DEFAULT_SQLITE_BUSY_RETRY_ATTEMPTS = int(os.environ.get("NEXO_LOCAL_CONTEXT_BUSY_RETRY_ATTEMPTS", "5") or "5")
+DEFAULT_SQLITE_BUSY_RETRY_DELAY_SECONDS = float(os.environ.get("NEXO_LOCAL_CONTEXT_BUSY_RETRY_DELAY_SECONDS", "0.35") or "0.35")
 INITIAL_INDEX_COMPLETE_KEY = "initial_index_complete"
 INITIAL_INDEX_STARTED_AT_KEY = "initial_index_started_at"
 PERFORMANCE_PROFILE_KEY = "performance_profile"
@@ -40,7 +44,7 @@ VALID_CONTEXT_MODES = {"compact", "full"}
 PERFORMANCE_PROFILES: dict[str, dict[str, Any]] = {
     "low": {
         "profile": "low",
-        "label": "Bajo",
+        "label_key": "local_context.performance.low",
         "scan_limit": 250,
         "process_limit": 50,
         "live_asset_limit": 500,
@@ -51,7 +55,7 @@ PERFORMANCE_PROFILES: dict[str, dict[str, Any]] = {
     },
     "medium": {
         "profile": "medium",
-        "label": "Medio",
+        "label_key": "local_context.performance.medium",
         "scan_limit": 1000,
         "process_limit": 200,
         "live_asset_limit": DEFAULT_LIVE_ASSET_LIMIT,
@@ -62,7 +66,7 @@ PERFORMANCE_PROFILES: dict[str, dict[str, Any]] = {
     },
     "high": {
         "profile": "high",
-        "label": "Alto",
+        "label_key": "local_context.performance.high",
         "scan_limit": 3000,
         "process_limit": 600,
         "live_asset_limit": 5000,
@@ -73,7 +77,7 @@ PERFORMANCE_PROFILES: dict[str, dict[str, Any]] = {
     },
     "extreme": {
         "profile": "extreme",
-        "label": "Extremo",
+        "label_key": "local_context.performance.extreme",
         "scan_limit": 8000,
         "process_limit": 1500,
         "live_asset_limit": 10000,
@@ -94,6 +98,40 @@ def _conn():
     return get_local_context_db()
 
 
+def _read_conn():
+    conn = connect_local_context_db_readonly(timeout_ms=1200)
+    _validate_status_schema(conn)
+    return conn
+
+
+def _close_read_conn(conn) -> None:
+    try:
+        conn.close()
+    except Exception:
+        pass
+
+
+def _sqlite_is_busy(exc: BaseException) -> bool:
+    return isinstance(exc, sqlite3.OperationalError) and "locked" in str(exc).lower()
+
+
+def _with_sqlite_busy_retry(callback, *, attempts: int | None = None):
+    max_attempts = max(1, int(attempts or DEFAULT_SQLITE_BUSY_RETRY_ATTEMPTS))
+    last_exc = None
+    for attempt in range(max_attempts):
+        try:
+            return callback()
+        except sqlite3.OperationalError as exc:
+            if not _sqlite_is_busy(exc) or attempt >= max_attempts - 1:
+                raise
+            last_exc = exc
+            close_local_context_db()
+            time.sleep(DEFAULT_SQLITE_BUSY_RETRY_DELAY_SECONDS * (attempt + 1))
+    if last_exc:
+        raise last_exc
+    return None
+
+
 def add_root(path: str, *, mode: str = "normal", depth: int | None = None) -> dict:
     conn = _conn()
     root_path = norm_path(path)
@@ -136,8 +174,18 @@ def remove_root(path: str) -> dict:
     return {"ok": True, "root_path": root_path, "cleanup": cleanup}
 
 
-def list_roots() -> list[dict]:
-    conn = _conn()
+def list_roots(*, readonly: bool = True) -> list[dict]:
+    if not readonly:
+        conn = _conn()
+        return _list_roots_conn(conn)
+    conn = _read_conn()
+    try:
+        return _list_roots_conn(conn)
+    finally:
+        _close_read_conn(conn)
+
+
+def _list_roots_conn(conn) -> list[dict]:
     rows = conn.execute("SELECT * FROM local_index_roots WHERE status != 'removed' ORDER BY root_path").fetchall()
     return [dict(row) for row in rows]
 
@@ -265,7 +313,7 @@ def default_root_specs() -> list[tuple[str, int]]:
 
 
 def ensure_default_roots() -> dict:
-    existing = {row["root_path"]: row for row in list_roots()}
+    existing = {row["root_path"]: row for row in list_roots(readonly=False)}
     created = []
     updated = []
     for root, depth in default_root_specs():
@@ -285,7 +333,7 @@ def ensure_default_roots() -> dict:
                 updated.append({"root_path": existing_row["root_path"], "depth": depth})
             continue
         created.append(add_root(str(candidate), mode="normal", depth=depth))
-    return {"ok": True, "created": len(created), "updated": len(updated), "roots": list_roots()}
+    return {"ok": True, "created": len(created), "updated": len(updated), "roots": list_roots(readonly=False)}
 
 
 def _should_skip_mounted_root(candidate: Path) -> bool:
@@ -557,8 +605,18 @@ def remove_exclusion(path: str) -> dict:
     return {"ok": True, "path": excluded_path}
 
 
-def list_exclusions() -> list[dict]:
-    conn = _conn()
+def list_exclusions(*, readonly: bool = True) -> list[dict]:
+    if not readonly:
+        conn = _conn()
+        return _list_exclusions_conn(conn)
+    conn = _read_conn()
+    try:
+        return _list_exclusions_conn(conn)
+    finally:
+        _close_read_conn(conn)
+
+
+def _list_exclusions_conn(conn) -> list[dict]:
     rows = conn.execute("SELECT * FROM local_index_exclusions ORDER BY path").fetchall()
     return [dict(row) for row in rows]
 
@@ -575,9 +633,12 @@ def _set_state_conn(conn, key: str, value: str) -> None:
 
 
 def _set_state(key: str, value: str) -> None:
-    conn = _conn()
-    _set_state_conn(conn, key, value)
-    conn.commit()
+    def write_state() -> None:
+        conn = _conn()
+        _set_state_conn(conn, key, value)
+        conn.commit()
+
+    _with_sqlite_busy_retry(write_state)
 
 
 def _get_state_conn(conn, key: str, default: str = "") -> str:
@@ -700,6 +761,15 @@ def _ensure_initial_index_started_at(conn) -> float:
     return value
 
 
+def _initial_index_started_at_readonly(conn) -> float:
+    raw = _get_state_conn(conn, INITIAL_INDEX_STARTED_AT_KEY, "")
+    try:
+        value = float(raw or 0)
+    except Exception:
+        value = 0.0
+    return value if value > 0 else (_earliest_index_activity(conn) or 0.0)
+
+
 def _active_job_count(conn) -> int:
     row = conn.execute(
         """
@@ -711,20 +781,20 @@ def _active_job_count(conn) -> int:
     return int(row["total"] or 0)
 
 
-def _refresh_initial_index_complete(conn, initial_scan: dict | None = None, active_jobs: int | None = None) -> bool:
+def _refresh_initial_index_complete(conn, initial_scan: dict | None = None, active_jobs: int | None = None, *, readonly: bool = False) -> bool:
     if _initial_index_complete(conn):
         return True
     scan_state = initial_scan if initial_scan is not None else _initial_scan_status(conn)
     remaining = _active_job_count(conn) if active_jobs is None else int(active_jobs or 0)
     complete = bool(scan_state.get("complete")) and remaining == 0
-    if complete:
+    if complete and not readonly:
         _set_initial_index_complete(conn, True)
         conn.commit()
     return complete
 
 
 def _initial_scan_status(conn, roots: list[dict] | None = None) -> dict:
-    rows = roots if roots is not None else list_roots()
+    rows = roots if roots is not None else _list_roots_conn(conn)
     tracked = _effective_scan_roots([dict(row) for row in rows if str(row.get("status") or "active") not in {"removed", "offline"}])
     pending = [row for row in tracked if not _root_initial_scan_complete(conn, row)]
     checkpoints = conn.execute(
@@ -753,7 +823,12 @@ def resume() -> dict:
 
 
 def _is_paused() -> bool:
-    return _get_state("paused", "0") == "1"
+    conn = _conn()
+    return _is_paused_conn(conn)
+
+
+def _is_paused_conn(conn) -> bool:
+    return _get_state_conn(conn, "paused", "0") == "1"
 
 
 def _allow_explicit_blocked_root(path: str) -> bool:
@@ -1465,7 +1540,7 @@ def reconcile_live_changes(
     conn = _conn()
     if _is_paused():
         return {"ok": True, "paused": True, "assets": {}, "dirs": {}}
-    exclusions = [row["path"] for row in list_exclusions()]
+    exclusions = [row["path"] for row in list_exclusions(readonly=False)]
     asset_stats = _reconcile_known_assets(conn, exclusions, limit=int(asset_limit or 0))
     dir_stats = _reconcile_known_dirs(conn, exclusions, dir_limit=int(dir_limit or 0), file_limit=int(file_limit or 0))
     conn.commit()
@@ -1498,8 +1573,8 @@ def scan_once(*, limit: int | None = None) -> dict:
         log_event("info", "scan_skipped_paused", "Local memory scan skipped because indexing is paused")
         return {"ok": True, "paused": True, "roots": 0, "seen": 0, "changed": 0, "errors": 0, "partial": False}
     started = now()
-    roots = _effective_scan_roots(list_roots())
-    exclusions = [row["path"] for row in list_exclusions()]
+    roots = _effective_scan_roots(list_roots(readonly=False))
+    exclusions = [row["path"] for row in list_exclusions(readonly=False)]
     totals = {"roots": len(roots), "seen": 0, "changed": 0, "errors": 0, "partial": False}
     log_event("info", "scan_started", "Local memory scan started", roots=len(roots))
     for root in roots:
@@ -1697,6 +1772,7 @@ def process_jobs(*, limit: int = 100) -> dict:
             "UPDATE local_index_jobs SET status='running', claimed_by='local-process', lease_expires_at=?, updated_at=? WHERE job_id=?",
             (now() + 300, now(), job_id),
         )
+        conn.commit()
         try:
             if row["asset_status"] != "active":
                 raise FileNotFoundError(row["path"])
@@ -1706,6 +1782,7 @@ def process_jobs(*, limit: int = 100) -> dict:
                     (now(), job_id),
                 )
                 processed += 1
+                conn.commit()
                 continue
             if job_type == "light_extraction":
                 text, metadata = extract_text(Path(row["path"]))
@@ -1717,6 +1794,7 @@ def process_jobs(*, limit: int = 100) -> dict:
                         (now(), job_id),
                     )
                     processed += 1
+                    conn.commit()
                     continue
                 summary = summarize(text)
                 conn.execute(
@@ -1739,6 +1817,7 @@ def process_jobs(*, limit: int = 100) -> dict:
                 (now(), job_id),
             )
             processed += 1
+            conn.commit()
         except Exception as exc:
             failed += 1
             attempts = int(row["attempt_count"] or 0) + 1
@@ -1761,6 +1840,7 @@ def process_jobs(*, limit: int = 100) -> dict:
                 technical_detail=str(exc),
                 retryable=not terminal,
             )
+            conn.commit()
     conn.commit()
     if processed or failed:
         log_event("info", "jobs_processed", "Local memory jobs processed", processed=processed, failed=failed)
@@ -1793,7 +1873,7 @@ def run_once(
     effective_live_dir_limit = int(live_dir_limit if live_dir_limit is not None else config["live_dir_limit"])
     effective_live_file_limit = int(live_file_limit if live_file_limit is not None else config["live_file_limit"])
     conn = _conn()
-    initial_before = _initial_scan_status(conn, list_roots())
+    initial_before = _initial_scan_status(conn, list_roots(readonly=False))
     initial_index_before = _refresh_initial_index_complete(conn, initial_before)
     if initial_index_before:
         live_result = reconcile_live_changes(
@@ -1812,7 +1892,7 @@ def run_once(
     scan_result = scan_once(limit=effective_scan_limit)
     job_result = process_jobs(limit=effective_process_limit)
     conn_after = _conn()
-    initial_after = _initial_scan_status(conn_after, list_roots())
+    initial_after = _initial_scan_status(conn_after, list_roots(readonly=False))
     active_after = _active_job_count(conn_after)
     initial_index_after = _refresh_initial_index_complete(conn_after, initial_after, active_after)
     return {
@@ -1854,8 +1934,10 @@ def _problem_rows(conn) -> list[dict]:
     ).fetchall()
     problems = [
         {
-            "user_message": row["user_message"],
-            "recommended_action": "NEXO lo volvera a intentar mas tarde" if row["retryable"] else "Revisa permisos o archivo",
+            "user_message": "",
+            "message_key": "local_context.problem.file_read_failed",
+            "recommended_action": "",
+            "recommended_action_key": "local_context.retry_later" if row["retryable"] else "local_context.review_permissions_or_file",
             "technical_detail": row["technical_detail"],
             "support_code": row["error_code"],
             "severity": "warning",
@@ -1882,8 +1964,10 @@ def _problem_rows(conn) -> list[dict]:
     ).fetchall()
     problems.extend(
         {
-            "user_message": "La memoria local tuvo un problema temporal y NEXO la reintentara automaticamente",
-            "recommended_action": "No tienes que hacer nada. Si se repite, abre soporte y diagnostico para ver el detalle.",
+            "user_message": "",
+            "message_key": "local_context.problem.service_temporary",
+            "recommended_action": "",
+            "recommended_action_key": "local_context.retry_automatic",
             "technical_detail": f"{row['event']}: {row['message']} {row['metadata_json']}",
             "support_code": row["event"],
             "severity": "warning" if row["level"] == "warn" else "error",
@@ -2084,13 +2168,13 @@ def _service_cycle_observation(conn) -> dict:
     return observation
 
 
-def _index_timing(conn, *, done: int, active_jobs: int, percent: int) -> dict:
-    first_seen = _ensure_initial_index_started_at(conn)
+def _index_timing(conn, *, done: int, active_jobs: int, percent: int, readonly: bool = False) -> dict:
+    first_seen = _initial_index_started_at_readonly(conn) if readonly else _ensure_initial_index_started_at(conn)
     elapsed_seconds = max(0, int(now() - float(first_seen))) if first_seen else 0
     eta_seconds = None
     if elapsed_seconds > 0 and done > 0 and active_jobs > 0 and 0 < percent < 100:
         eta_seconds = max(0, int((elapsed_seconds / max(done, 1)) * active_jobs))
-    return {"elapsed_seconds": elapsed_seconds, "eta_seconds": eta_seconds}
+    return {"started_at": first_seen, "elapsed_seconds": elapsed_seconds, "eta_seconds": eta_seconds}
 
 
 def _service_scheduler_has_error(service: dict) -> bool:
@@ -2107,38 +2191,118 @@ def _service_problem(service: dict) -> dict | None:
     if not service.get("installed"):
         return {
             "support_code": "local_index_service_not_installed",
-            "user_message": "La memoria local aun no tiene activo el servicio en segundo plano",
-            "recommended_action": "Reabre NEXO Desktop o actualiza a la ultima version para instalarlo automaticamente.",
+            "user_message": "",
+            "message_key": "local_context.problem.service_not_installed",
+            "recommended_action": "",
+            "recommended_action_key": "local_context.reopen_or_update_desktop",
             "technical_detail": f"manager={service.get('manager')} platform={service.get('platform')}",
         }
     if not service.get("running"):
         return {
             "support_code": "local_index_service_not_running",
-            "user_message": "La memoria local no se esta actualizando en segundo plano",
-            "recommended_action": "NEXO intentara recuperarlo automaticamente. Si se repite, abre soporte y diagnostico.",
+            "user_message": "",
+            "message_key": "local_context.problem.service_not_running",
+            "recommended_action": "",
+            "recommended_action_key": "local_context.retry_automatic",
             "technical_detail": f"manager={service.get('manager')} platform={service.get('platform')}",
         }
     if _service_scheduler_has_error(service):
         code = service.get("last_exit_code") or service.get("last_task_result") or ""
         return {
             "support_code": "local_index_service_last_run_failed",
-            "user_message": "La ultima comprobacion de memoria local no termino correctamente",
-            "recommended_action": "NEXO lo volvera a intentar automaticamente.",
+            "user_message": "",
+            "message_key": "local_context.problem.service_last_run_failed",
+            "recommended_action": "",
+            "recommended_action_key": "local_context.retry_automatic",
             "technical_detail": f"last_result={code}",
         }
     if not service.get("healthy", True):
         return {
             "support_code": service.get("last_error_code") or "local_index_service_failed",
-            "user_message": "La memoria local tuvo un problema temporal y NEXO la reintentara automaticamente",
-            "recommended_action": "No tienes que hacer nada. Si se repite, abre soporte y diagnostico para ver el detalle.",
+            "user_message": "",
+            "message_key": "local_context.problem.service_temporary",
+            "recommended_action": "",
+            "recommended_action_key": "local_context.retry_automatic",
             "technical_detail": service.get("last_error_detail") or "",
         }
     return None
 
 
+def _status_read_error(exc: Exception, *, code: str = "local_context_status_unavailable") -> dict:
+    service = _local_index_service_status()
+    service_problem = _service_problem(service)
+    service["healthy"] = service_problem is None
+    service["state"] = "attention" if service_problem else "unavailable"
+    problems = []
+    if service_problem:
+        problems.append({
+            "user_message": service_problem["user_message"],
+            "message_key": service_problem.get("message_key", ""),
+            "recommended_action": service_problem["recommended_action"],
+            "recommended_action_key": service_problem.get("recommended_action_key", ""),
+            "technical_detail": service_problem["technical_detail"],
+            "support_code": service_problem["support_code"],
+            "severity": "warning",
+            "retryable": True,
+            "path": "",
+            "phase": "service",
+            "created_at": now(),
+        })
+    problems.append({
+        "user_message": "",
+        "message_key": "local_context.status_unavailable",
+        "recommended_action": "",
+        "recommended_action_key": "local_context.retry_automatic",
+        "technical_detail": str(exc),
+        "support_code": code,
+        "severity": "warning",
+        "retryable": True,
+        "path": "",
+        "phase": "status",
+        "created_at": now(),
+    })
+    return {
+        "ok": False,
+        "error": code,
+        "retryable": True,
+        "global": None,
+        "service": service,
+        "problems": problems,
+    }
+
+
+def _status_db_error_code(exc: Exception) -> str:
+    text = str(exc).lower()
+    if "locked" in text or "busy" in text:
+        return "local_context_db_busy"
+    if "no such table" in text or "no such column" in text or "schema missing" in text or "missing tables" in text:
+        return "local_context_db_schema_missing"
+    if "file is not a database" in text or "database disk image is malformed" in text:
+        return "local_context_db_invalid"
+    return "local_context_db_unreadable"
+
+
 def status() -> dict:
-    conn = _conn()
-    paused = _is_paused()
+    try:
+        conn = connect_local_context_db_readonly(timeout_ms=1200)
+    except FileNotFoundError as exc:
+        return _status_read_error(exc, code="local_context_db_missing")
+    except sqlite3.DatabaseError as exc:
+        return _status_read_error(exc, code=_status_db_error_code(exc))
+    try:
+        return _status_from_conn(conn, readonly=True)
+    except sqlite3.DatabaseError as exc:
+        return _status_read_error(exc, code=_status_db_error_code(exc))
+    finally:
+        try:
+            conn.close()
+        except Exception:
+            pass
+
+
+def _status_from_conn(conn, *, readonly: bool = False) -> dict:
+    _validate_status_schema(conn)
+    paused = _is_paused_conn(conn)
     assets = conn.execute(
         """
         SELECT COUNT(*) AS total, SUM(CASE WHEN a.status='active' THEN 1 ELSE 0 END) AS active
@@ -2166,10 +2330,10 @@ def status() -> dict:
     active_jobs = pending + running_jobs + failed_jobs
     total_jobs = active_jobs + done
     percent = 100 if total_jobs == 0 else int((done / max(total_jobs, 1)) * 100)
-    timing = _index_timing(conn, done=done, active_jobs=active_jobs, percent=percent)
-    roots = list_roots()
+    timing = _index_timing(conn, done=done, active_jobs=active_jobs, percent=percent, readonly=readonly)
+    roots = _list_roots_conn(conn)
     initial_scan = _initial_scan_status(conn, roots)
-    initial_index_complete = _refresh_initial_index_complete(conn, initial_scan, active_jobs)
+    initial_index_complete = _refresh_initial_index_complete(conn, initial_scan, active_jobs, readonly=readonly)
     volumes = []
     by_volume = conn.execute(
         """
@@ -2194,7 +2358,9 @@ def status() -> dict:
     if problem:
         problems.insert(0, {
             "user_message": problem["user_message"],
+            "message_key": problem.get("message_key", ""),
             "recommended_action": problem["recommended_action"],
+            "recommended_action_key": problem.get("recommended_action_key", ""),
             "technical_detail": problem["technical_detail"],
             "support_code": problem["support_code"],
             "severity": "warning",
@@ -2213,6 +2379,9 @@ def status() -> dict:
         phase = "idle"
     else:
         phase = "updating_changes"
+    index_started_at = _get_state_conn(conn, INITIAL_INDEX_STARTED_AT_KEY, "")
+    if not index_started_at and timing["started_at"]:
+        index_started_at = str(float(timing["started_at"]))
     return {
         "ok": True,
         "service": service,
@@ -2227,7 +2396,7 @@ def status() -> dict:
             "jobs_failed": failed_jobs,
             "elapsed_seconds": timing["elapsed_seconds"],
             "eta_seconds": timing["eta_seconds"],
-            "index_started_at": _get_state_conn(conn, INITIAL_INDEX_STARTED_AT_KEY, ""),
+            "index_started_at": index_started_at,
             "initial_scan_complete": bool(initial_index_complete),
             "initial_discovery_complete": bool(initial_scan["complete"]),
             "initial_index_complete": bool(initial_index_complete),
@@ -2239,7 +2408,7 @@ def status() -> dict:
         "initial_index_complete": bool(initial_index_complete),
         "volumes": volumes,
         "roots": roots,
-        "exclusions": list_exclusions(),
+        "exclusions": _list_exclusions_conn(conn),
         "problems": problems,
         "permissions": [],
         "models": model_status()["models"],
@@ -2247,6 +2416,18 @@ def status() -> dict:
     }
 
 
+def _validate_status_schema(conn) -> None:
+    placeholders = ",".join("?" for _ in LOCAL_CONTEXT_TABLES)
+    rows = conn.execute(
+        f"SELECT name FROM sqlite_master WHERE type='table' AND name IN ({placeholders})",
+        tuple(LOCAL_CONTEXT_TABLES),
+    ).fetchall()
+    found = {str(row["name"] if isinstance(row, sqlite3.Row) else row[0]) for row in rows}
+    missing = [table for table in LOCAL_CONTEXT_TABLES if table not in found]
+    if missing:
+        raise sqlite3.OperationalError("local context schema missing tables: " + ", ".join(missing[:8]))
+
+
 def diagnostics_tail(limit: int = 100) -> dict:
     return {"ok": True, "logs": tail(limit)}
 
@@ -2768,8 +2949,46 @@ def context_query(
     include_entities: bool = True,
     include_relations: bool = True,
     snippet_chars: int = 1200,
+    readonly: bool = True,
+    record_query: bool = False,
+) -> dict:
+    conn = _read_conn() if readonly else _conn()
+    close_conn = bool(readonly)
+    try:
+        return _context_query_conn(
+            conn,
+            query,
+            intent=intent,
+            limit=limit,
+            evidence_required=evidence_required,
+            current_context=current_context,
+            mode=mode,
+            max_chars=max_chars,
+            include_entities=include_entities,
+            include_relations=include_relations,
+            snippet_chars=snippet_chars,
+            record_query=bool(record_query and not readonly),
+        )
+    finally:
+        if close_conn:
+            _close_read_conn(conn)
+
+
+def _context_query_conn(
+    conn,
+    query: str,
+    *,
+    intent: str,
+    limit: int,
+    evidence_required: bool,
+    current_context: str,
+    mode: str,
+    max_chars: int,
+    include_entities: bool,
+    include_relations: bool,
+    snippet_chars: int,
+    record_query: bool,
 ) -> dict:
-    conn = _conn()
     clean_query = str(query or "").strip()
     normalized_mode, mode_warnings = _normalize_context_mode(mode)
     context_tail = _compact_text(current_context or "", max_chars=1000)
@@ -2843,21 +3062,22 @@ def context_query(
     summary = ""
     if assets:
         summary = f"Found {len(assets)} local asset(s) related to '{clean_query}'."
-    conn.execute(
-        """
-        INSERT INTO local_context_queries(query_hash, intent, result_count, confidence, warnings_json, created_at)
-        VALUES (?, ?, ?, ?, ?, ?)
-        """,
-        (
-            hashlib.sha256(clean_query.encode("utf-8", errors="ignore")).hexdigest(),
-            intent,
-            len(assets),
-            0.75 if evidence_refs else 0.0,
-            json_dumps(warnings),
-            now(),
-        ),
-    )
-    conn.commit()
+    if record_query:
+        conn.execute(
+            """
+            INSERT INTO local_context_queries(query_hash, intent, result_count, confidence, warnings_json, created_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                hashlib.sha256(clean_query.encode("utf-8", errors="ignore")).hexdigest(),
+                intent,
+                len(assets),
+                0.75 if evidence_refs else 0.0,
+                json_dumps(warnings),
+                now(),
+            ),
+        )
+        conn.commit()
     payload = {
         "ok": True,
         "query": clean_query,
@@ -2881,26 +3101,34 @@ def context_query(
     )
 
 
-def get_asset(asset_id: str) -> dict:
-    conn = _conn()
-    row = conn.execute("SELECT * FROM local_assets WHERE asset_id=?", (asset_id,)).fetchone()
-    if not row:
-        return {"ok": False, "error": "asset_not_found"}
-    return {"ok": True, "asset": dict(row)}
+def get_asset(asset_id: str, *, readonly: bool = True) -> dict:
+    conn = _read_conn() if readonly else _conn()
+    try:
+        row = conn.execute("SELECT * FROM local_assets WHERE asset_id=?", (asset_id,)).fetchone()
+        if not row:
+            return {"ok": False, "error": "asset_not_found"}
+        return {"ok": True, "asset": dict(row)}
+    finally:
+        if readonly:
+            _close_read_conn(conn)
 
 
-def get_neighbors(asset_id: str, *, limit: int = 30) -> dict:
-    conn = _conn()
-    rows = conn.execute(
-        """
-        SELECT * FROM local_relations
-        WHERE source_asset_id=? AND active=1
-        ORDER BY confidence DESC
-        LIMIT ?
-        """,
-        (asset_id, int(limit)),
-    ).fetchall()
-    return {"ok": True, "relations": [dict(row) for row in rows]}
+def get_neighbors(asset_id: str, *, limit: int = 30, readonly: bool = True) -> dict:
+    conn = _read_conn() if readonly else _conn()
+    try:
+        rows = conn.execute(
+            """
+            SELECT * FROM local_relations
+            WHERE source_asset_id=? AND active=1
+            ORDER BY confidence DESC
+            LIMIT ?
+            """,
+            (asset_id, int(limit)),
+        ).fetchall()
+        return {"ok": True, "relations": [dict(row) for row in rows]}
+    finally:
+        if readonly:
+            _close_read_conn(conn)
 
 
 def purge_asset(asset_id: str) -> dict:

package/src/local_context/db.py

@@ -5,6 +5,7 @@ import sqlite3
 import time
 from pathlib import Path
 from typing import Iterable
+from urllib.parse import quote
 
 import paths
 from db._schema import _m63_local_context_layer, _m64_local_context_live_dirs
@@ -79,6 +80,23 @@ def _connect(db_path: Path) -> sqlite3.Connection:
     return conn
 
 
+def connect_local_context_db_readonly(*, timeout_ms: int = 1200) -> sqlite3.Connection:
+    db_path = local_context_db_path()
+    if not db_path.is_file():
+        raise FileNotFoundError(str(db_path))
+    timeout = max(float(timeout_ms) / 1000.0, 0.1)
+    uri_path = quote(db_path.resolve().as_posix(), safe="/:")
+    uri_params = "mode=ro"
+    if not db_path.with_name(db_path.name + "-wal").exists() and not db_path.with_name(db_path.name + "-shm").exists():
+        uri_params += "&immutable=1"
+    uri = f"file:{uri_path}?{uri_params}"
+    conn = sqlite3.connect(uri, uri=True, timeout=timeout, check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    conn.execute(f"PRAGMA busy_timeout={max(100, int(timeout_ms))}")
+    conn.execute("PRAGMA query_only=ON")
+    return conn
+
+
 def _ensure_schema(conn: sqlite3.Connection) -> None:
     _m63_local_context_layer(conn)
     _m64_local_context_live_dirs(conn)

package/src/plugins/recover.py

@@ -35,6 +35,7 @@ from db_guard import (
     CRITICAL_TABLES,
     EMPTY_DB_SIZE_BYTES,
     HOURLY_BACKUP_GLOB,
+    LOCAL_CONTEXT_TABLES,
     MIN_REFERENCE_ROWS,
     PROTECTED_TABLES,
     WIPE_THRESHOLD_PCT,
@@ -48,6 +49,8 @@ from db_guard import (
     validate_backup_matches_source,
 )
 
+RECOVERY_TABLES = PROTECTED_TABLES + LOCAL_CONTEXT_TABLES
+
 # Path resolution moved to lazy helpers (AUDITOR-V700-PASS2 §11, B10 item 3)
 # to keep monkeypatched NEXO_HOME / paths.* fixtures honoured. PEP 562
 # ``__getattr__`` below preserves the legacy constant names for any caller
@@ -139,7 +142,7 @@ def _describe_backup(path: Path, kind: str) -> dict:
     counts: dict[str, int | None] = {}
     critical_rows = 0
     if size > EMPTY_DB_SIZE_BYTES:
-        counts = db_row_counts(path, PROTECTED_TABLES)
+        counts = db_row_counts(path, RECOVERY_TABLES)
         critical_rows = sum(v for v in counts.values() if isinstance(v, int))
     return {
         "path": str(path),
@@ -240,7 +243,7 @@ def recover(
     result["source"] = str(chosen)
     result["steps"].append(f"chose source: {chosen}")
 
-    source_counts = db_row_counts(chosen, PROTECTED_TABLES)
+    source_counts = db_row_counts(chosen, RECOVERY_TABLES)
     result["source_row_counts"] = {k: v for k, v in source_counts.items() if v is not None}
     source_total = sum(v for v in source_counts.values() if isinstance(v, int))
     if source_total < MIN_REFERENCE_ROWS:
@@ -317,7 +320,7 @@ def recover(
         return result
     result["steps"].append(f"restored {chosen.name} -> {target_path}")
 
-    valid, valid_err = validate_backup_matches_source(chosen, target_path, PROTECTED_TABLES)
+    valid, valid_err = validate_backup_matches_source(chosen, target_path, RECOVERY_TABLES)
     if not valid:
         result["errors"].append(f"post-restore validation failed: {valid_err}")
         if stopped_launchagents:
@@ -325,7 +328,7 @@ def recover(
         return result
     result["steps"].append("validated post-restore row counts")
 
-    final_counts = db_row_counts(target_path, PROTECTED_TABLES)
+    final_counts = db_row_counts(target_path, RECOVERY_TABLES)
     result["final_row_counts"] = {k: v for k, v in final_counts.items() if v is not None}
     if stopped_launchagents:
         result["resume"] = resume_nexo_launchagents(stopped_launchagents)

package/src/plugins/update.py

@@ -485,8 +485,14 @@ def _row_count_regression(pre: dict[str, int | None], post: dict[str, int | None
     drop >= WIPE_THRESHOLD_PCT across CRITICAL_TABLES, is treated as a wipe.
     """
     regressions: list[str] = []
-    pre_total = sum(v for v in pre.values() if isinstance(v, int))
-    post_total = sum(v for v in post.values() if isinstance(v, int))
+    pre_total = sum(
+        pre.get(table) for table in PROTECTED_TABLES
+        if isinstance(pre.get(table), int)
+    )
+    post_total = sum(
+        post.get(table) for table in PROTECTED_TABLES
+        if isinstance(post.get(table), int)
+    )
     for table in PROTECTED_TABLES:
         pre_v = pre.get(table)
         post_v = post.get(table)

package/src/server.py

@@ -810,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":
@@ -825,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_sessions.py

@@ -474,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,
@@ -783,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("")
@@ -884,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(
@@ -990,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)
@@ -1334,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)):
@@ -1375,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(