nexo-brain 7.20.2 → 7.20.3

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.20.2",
+  "version": "7.20.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": "7.20.2",
+  "version": "7.20.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/doctor/providers/runtime.py

@@ -3833,6 +3833,66 @@ def check_automation_caller_coverage(days: int = 7) -> DoctorCheck:
     )
 
 
+def check_local_index_hygiene(fix: bool = False) -> DoctorCheck:
+    try:
+        from local_context import api as local_context_api
+
+        result = local_context_api.local_index_hygiene(fix=fix)
+        residue = result.get("residue") or {}
+        cleanup = result.get("cleanup") or {}
+        suspect_roots = [str(path) for path in result.get("removed_roots") or []]
+        residue_total = sum(int(residue.get(key, 0) or 0) for key in ("assets", "jobs", "errors", "dirs", "checkpoints"))
+        cleanup_total = sum(int(cleanup.get(key, 0) or 0) for key in ("assets", "jobs", "errors", "dirs", "checkpoints"))
+        evidence = [
+            "suspect_installer_roots=" + str(len(suspect_roots)),
+            "residue=" + json.dumps(residue, sort_keys=True),
+            "cleanup=" + json.dumps(cleanup, sort_keys=True),
+        ]
+        evidence.extend(f"root={path}" for path in suspect_roots[:5])
+        if residue_total == 0 and not suspect_roots:
+            return DoctorCheck(
+                id="runtime.local_index_hygiene",
+                tier="runtime",
+                status="healthy",
+                severity="info",
+                summary="Local memory index hygiene is clean",
+                evidence=evidence,
+                repair_plan=[],
+            )
+        if fix:
+            return DoctorCheck(
+                id="runtime.local_index_hygiene",
+                tier="runtime",
+                status="healthy",
+                severity="info",
+                summary="Local memory index hygiene repaired",
+                evidence=evidence,
+                repair_plan=[],
+                fixed=cleanup_total > 0 or bool(suspect_roots),
+            )
+        return DoctorCheck(
+            id="runtime.local_index_hygiene",
+            tier="runtime",
+            status="degraded",
+            severity="warn",
+            summary="Local memory index has stale removed-root residue",
+            evidence=evidence,
+            repair_plan=["Run `nexo doctor --tier runtime --fix` to purge stale local memory roots and installer-volume residue"],
+            escalation_prompt="Local memory status may show stale pending or failed jobs from removed roots.",
+        )
+    except Exception as exc:
+        return DoctorCheck(
+            id="runtime.local_index_hygiene",
+            tier="runtime",
+            status="degraded",
+            severity="warn",
+            summary="Local memory index hygiene could not be checked",
+            evidence=[str(exc)],
+            repair_plan=["Inspect local_context.api.local_index_hygiene and runtime DB tables"],
+            escalation_prompt="Support cannot verify local memory index residue.",
+        )
+
+
 def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
     """Run all runtime-tier checks. Read-only by default."""
     return [
@@ -3854,6 +3914,7 @@ def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
         safe_check(check_automation_telemetry),
         safe_check(check_automation_caller_coverage),
         safe_check(check_state_watchers),
+        safe_check(check_local_index_hygiene, fix=fix),
         safe_check(check_release_artifact_sync),
         safe_check(check_release_trace_hygiene),
         safe_check(check_launchagent_inventory),

package/src/local_context/__init__.py

@@ -16,6 +16,7 @@ from .api import (
     get_neighbors,
     list_exclusions,
     list_roots,
+    local_index_hygiene,
     model_status,
     pause,
     purge_asset,
@@ -39,6 +40,7 @@ __all__ = [
     "get_neighbors",
     "list_exclusions",
     "list_roots",
+    "local_index_hygiene",
     "model_status",
     "pause",
     "purge_asset",

package/src/local_context/api.py

@@ -64,9 +64,10 @@ def remove_root(path: str) -> dict:
     conn = _conn()
     root_path = norm_path(path)
     conn.execute("UPDATE local_index_roots SET status='removed', updated_at=? WHERE root_path=?", (now(), root_path))
+    cleanup = _purge_removed_root_payloads(conn, root_paths=[root_path])
     conn.commit()
-    log_event("info", "root_removed", "Root removed", path=redact_path(root_path))
-    return {"ok": True, "root_path": root_path}
+    log_event("info", "root_removed", "Root removed", path=redact_path(root_path), cleanup=cleanup)
+    return {"ok": True, "root_path": root_path, "cleanup": cleanup}
 
 
 def list_roots() -> list[dict]:
@@ -108,6 +109,8 @@ def _mounted_volume_roots() -> list[str]:
         try:
             if candidate.name.startswith(".") or not candidate.is_dir():
                 continue
+            if _should_skip_mounted_root(candidate):
+                continue
             resolved = candidate.resolve()
             if resolved == root_resolved:
                 continue
@@ -137,6 +140,124 @@ def ensure_default_roots() -> dict:
     return {"ok": True, "created": len(created), "roots": list_roots()}
 
 
+def _should_skip_mounted_root(candidate: Path) -> bool:
+    name = candidate.name.strip().lower()
+    if name in {"nexo desktop", "nexo desktop beta"} or name.startswith("nexo desktop "):
+        return True
+    try:
+        app_bundles = [child.name.lower() for child in candidate.iterdir() if child.suffix.lower() == ".app"]
+    except Exception:
+        app_bundles = []
+    if any(name.startswith("nexo desktop") for name in app_bundles):
+        installer_markers = (
+            candidate / ".background",
+            candidate / "Applications",
+            candidate / ".DS_Store",
+        )
+        if any(marker.exists() for marker in installer_markers):
+            return True
+    return False
+
+
+def _removed_root_filters(conn, *, root_paths: list[str] | None = None) -> tuple[list[int], list[str]]:
+    if root_paths:
+        placeholders = ",".join("?" for _ in root_paths)
+        rows = conn.execute(
+            f"SELECT id, root_path FROM local_index_roots WHERE root_path IN ({placeholders}) AND status='removed'",
+            tuple(root_paths),
+        ).fetchall()
+    else:
+        rows = conn.execute("SELECT id, root_path FROM local_index_roots WHERE status='removed'").fetchall()
+    return [int(row["id"]) for row in rows], [str(row["root_path"]) for row in rows]
+
+
+def _removed_root_payload_counts(conn, *, root_paths: list[str] | None = None) -> dict:
+    root_ids, removed_paths = _removed_root_filters(conn, root_paths=root_paths)
+    if not root_ids and not removed_paths:
+        return {"assets": 0, "jobs": 0, "errors": 0, "dirs": 0, "checkpoints": 0}
+    asset_filter, params = _removed_root_asset_filter(root_ids, removed_paths)
+    if not asset_filter:
+        return {"assets": 0, "jobs": 0, "errors": 0, "dirs": 0, "checkpoints": 0}
+    asset_subquery = f"SELECT asset_id FROM local_assets WHERE {asset_filter}"
+    assets = int(conn.execute(f"SELECT COUNT(*) AS total FROM local_assets WHERE {asset_filter}", tuple(params)).fetchone()["total"] or 0)
+    jobs = int(conn.execute(f"SELECT COUNT(*) AS total FROM local_index_jobs WHERE asset_id IN ({asset_subquery})", tuple(params)).fetchone()["total"] or 0)
+    errors = int(conn.execute(f"SELECT COUNT(*) AS total FROM local_index_errors WHERE asset_id IN ({asset_subquery})", tuple(params)).fetchone()["total"] or 0)
+    for path in removed_paths:
+        errors += int(conn.execute("SELECT COUNT(*) AS total FROM local_index_errors WHERE asset_id='' AND (path = ? OR path LIKE ?)", (path, f"{path}/%")).fetchone()["total"] or 0)
+    dirs = 0
+    checkpoints = 0
+    if root_ids:
+        root_placeholders = ",".join("?" for _ in root_ids)
+        dirs = int(conn.execute(f"SELECT COUNT(*) AS total FROM local_index_dirs WHERE root_id IN ({root_placeholders})", tuple(root_ids)).fetchone()["total"] or 0)
+        checkpoints = int(conn.execute(f"SELECT COUNT(*) AS total FROM local_index_checkpoints WHERE root_id IN ({root_placeholders})", tuple(root_ids)).fetchone()["total"] or 0)
+    return {"assets": assets, "jobs": jobs, "errors": errors, "dirs": dirs, "checkpoints": checkpoints}
+
+
+def _removed_root_asset_filter(root_ids: list[int], removed_paths: list[str]) -> tuple[str, list[Any]]:
+    filters: list[str] = []
+    params: list[Any] = []
+    if root_ids:
+        root_placeholders = ",".join("?" for _ in root_ids)
+        filters.append(f"root_id IN ({root_placeholders})")
+        params.extend(root_ids)
+    for path in removed_paths:
+        filters.append("(path = ? OR path LIKE ?)")
+        params.extend([path, f"{path}/%"])
+    return " OR ".join(filters), params
+
+
+def _purge_removed_root_payloads(conn, *, root_paths: list[str] | None = None) -> dict:
+    root_ids, removed_paths = _removed_root_filters(conn, root_paths=root_paths)
+    if not root_ids and not removed_paths:
+        return {"assets": 0, "jobs": 0, "errors": 0, "dirs": 0, "checkpoints": 0}
+
+    asset_filter, params = _removed_root_asset_filter(root_ids, removed_paths)
+    if not asset_filter:
+        return {"assets": 0, "jobs": 0, "errors": 0, "dirs": 0, "checkpoints": 0}
+    asset_subquery = f"SELECT asset_id FROM local_assets WHERE {asset_filter}"
+    counts = _removed_root_payload_counts(conn, root_paths=root_paths)
+
+    for table in ("local_embeddings", "local_chunks", "local_entities", "local_asset_versions"):
+        conn.execute(f"DELETE FROM {table} WHERE asset_id IN ({asset_subquery})", tuple(params))
+    conn.execute(f"DELETE FROM local_relations WHERE source_asset_id IN ({asset_subquery})", tuple(params))
+    conn.execute(f"DELETE FROM local_relations WHERE target_ref IN ({asset_subquery})", tuple(params))
+    conn.execute(f"DELETE FROM local_index_jobs WHERE asset_id IN ({asset_subquery})", tuple(params))
+    conn.execute(f"DELETE FROM local_index_errors WHERE asset_id IN ({asset_subquery})", tuple(params))
+
+    for path in removed_paths:
+        conn.execute("DELETE FROM local_index_errors WHERE path = ? OR path LIKE ?", (path, f"{path}/%"))
+
+    if root_ids:
+        root_placeholders = ",".join("?" for _ in root_ids)
+        conn.execute(f"DELETE FROM local_index_dirs WHERE root_id IN ({root_placeholders})", tuple(root_ids))
+        conn.execute(f"DELETE FROM local_index_checkpoints WHERE root_id IN ({root_placeholders})", tuple(root_ids))
+    conn.execute(f"DELETE FROM local_assets WHERE {asset_filter}", tuple(params))
+    return counts
+
+
+def local_index_hygiene(*, fix: bool = False) -> dict:
+    conn = _conn()
+    removed_paths: list[str] = []
+    for row in conn.execute("SELECT id, root_path FROM local_index_roots").fetchall():
+        path = str(row["root_path"] or "")
+        if _should_skip_mounted_root(Path(path)):
+            removed_paths.append(path)
+            if fix:
+                conn.execute("UPDATE local_index_roots SET status='removed', updated_at=? WHERE id=?", (now(), row["id"]))
+    before = _removed_root_payload_counts(conn)
+    cleanup = {"assets": 0, "jobs": 0, "errors": 0, "dirs": 0, "checkpoints": 0}
+    if fix:
+        cleanup = _purge_removed_root_payloads(conn)
+    conn.commit()
+    if fix and (removed_paths or any(int(cleanup.get(key, 0) or 0) for key in ("assets", "jobs", "errors", "dirs", "checkpoints"))):
+        log_event("info", "index_hygiene_repaired", "Local memory index hygiene repaired", roots=[redact_path(path) for path in removed_paths], cleanup=cleanup)
+    return {"ok": True, "fix": fix, "removed_roots": removed_paths, "residue": before, "cleanup": cleanup}
+
+
+def repair_index_hygiene() -> dict:
+    return local_index_hygiene(fix=True)
+
+
 def add_exclusion(path: str, *, reason: str = "user") -> dict:
     conn = _conn()
     excluded_path = norm_path(path)
@@ -398,7 +519,7 @@ def _mark_asset_deleted(conn, asset_id: str, deleted_at: float | None = None) ->
         """
         UPDATE local_index_jobs
         SET status='done', last_error_code='asset_deleted', updated_at=?
-        WHERE asset_id=? AND status IN ('pending', 'running')
+        WHERE asset_id=? AND status IN ('pending', 'running', 'failed')
         """,
         (deleted_at, asset_id),
     )
@@ -1102,9 +1223,19 @@ def run_once(
 def _problem_rows(conn) -> list[dict]:
     rows = conn.execute(
         """
-        SELECT path, phase, error_code, user_message, technical_detail, retryable, created_at
-        FROM local_index_errors
-        ORDER BY id DESC
+        SELECT e.path, e.phase, e.error_code, e.user_message, e.technical_detail, e.retryable, e.created_at
+        FROM local_index_errors e
+        LEFT JOIN local_assets a ON a.asset_id=e.asset_id
+        LEFT JOIN local_index_roots r ON r.id=a.root_id
+        WHERE COALESCE(r.status, 'active') != 'removed'
+          AND NOT EXISTS (
+            SELECT 1
+            FROM local_index_roots rr
+            WHERE rr.status='removed'
+              AND e.path != ''
+              AND (e.path = rr.root_path OR e.path LIKE rr.root_path || '/%')
+          )
+        ORDER BY e.id DESC
         LIMIT 20
         """
     ).fetchall()
@@ -1387,9 +1518,24 @@ def status() -> dict:
     conn = _conn()
     paused = _is_paused()
     assets = conn.execute(
-        "SELECT COUNT(*) AS total, SUM(CASE WHEN status='active' THEN 1 ELSE 0 END) AS active FROM local_assets"
+        """
+        SELECT COUNT(*) AS total, SUM(CASE WHEN a.status='active' THEN 1 ELSE 0 END) AS active
+        FROM local_assets a
+        LEFT JOIN local_index_roots r ON r.id=a.root_id
+        WHERE COALESCE(r.status, 'active') != 'removed'
+        """
     ).fetchone()
-    job_rows = conn.execute("SELECT status, COUNT(*) AS total FROM local_index_jobs GROUP BY status").fetchall()
+    job_rows = conn.execute(
+        """
+        SELECT j.status, COUNT(*) AS total
+        FROM local_index_jobs j
+        JOIN local_assets a ON a.asset_id=j.asset_id
+        LEFT JOIN local_index_roots r ON r.id=a.root_id
+        WHERE a.status='active'
+          AND COALESCE(r.status, 'active') != 'removed'
+        GROUP BY j.status
+        """
+    ).fetchall()
     job_counts = {row["status"]: int(row["total"] or 0) for row in job_rows}
     pending = int(job_counts.get("pending", 0) or 0)
     running_jobs = int(job_counts.get("running", 0) or 0)
@@ -1401,7 +1547,15 @@ def status() -> dict:
     roots = list_roots()
     volumes = []
     by_volume = conn.execute(
-        "SELECT volume_id, COUNT(*) AS files FROM local_assets WHERE status='active' GROUP BY volume_id ORDER BY volume_id"
+        """
+        SELECT a.volume_id, COUNT(*) AS files
+        FROM local_assets a
+        LEFT JOIN local_index_roots r ON r.id=a.root_id
+        WHERE a.status='active'
+          AND COALESCE(r.status, 'active') != 'removed'
+        GROUP BY a.volume_id
+        ORDER BY a.volume_id
+        """
     ).fetchall()
     for row in by_volume:
         volumes.append({"id": row["volume_id"], "label": row["volume_id"] or "Disk", "files": row["files"], "status": "active"})