nexo-brain 7.20.1 → 7.20.3

package/.claude-plugin/plugin.json

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

@@ -18,7 +18,9 @@
 
 [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.1` is the current packaged-runtime line. Patch release over v7.20.0 — the Local Context service now recovers from orphaned locks and mixed-version cycle failures instead of leaving the background index stuck.
+Version `7.20.2` is the current packaged-runtime line. Patch release over v7.20.1 — Local Context now requeues stalled work, reports real macOS/Windows background-service health, records scan errors and preserves Windows drive roots.
+
+Previously in `7.20.1`: patch release over v7.20.0 — the Local Context service now recovers from orphaned locks and mixed-version cycle failures instead of leaving the background index stuck.
 
 Previously in `7.20.0`: minor release over v7.19.0 — the Local Context index now reconciles known files and folders on every service cycle, so created, modified, deleted and newly excluded local files are reflected automatically between full scans.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.20.1",
+  "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),
     )
@@ -425,6 +546,48 @@ def _mark_dir_subtree_deleted(conn, dir_path: str, deleted_at: float | None = No
     return len(rows)
 
 
+def _record_index_error(
+    conn,
+    *,
+    asset_id: str = "",
+    path: str = "",
+    phase: str,
+    error_code: str,
+    user_message: str,
+    technical_detail: str,
+    retryable: bool = True,
+) -> None:
+    conn.execute(
+        """
+        INSERT INTO local_index_errors(asset_id, path, phase, error_code, user_message, technical_detail, retryable, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (asset_id, path, phase, error_code, user_message, technical_detail, 1 if retryable else 0, now()),
+    )
+
+
+def _record_scan_error(conn, stats: dict | None, path: str, phase: str, exc: Exception) -> None:
+    if stats is not None:
+        stats["errors"] = int(stats.get("errors", 0) or 0) + 1
+        logged = int(stats.get("_errors_logged", 0) or 0)
+        if logged >= 20:
+            return
+        stats["_errors_logged"] = logged + 1
+    _record_index_error(
+        conn,
+        path=path,
+        phase=phase,
+        error_code=type(exc).__name__,
+        user_message="Algunas carpetas o archivos no se pudieron leer",
+        technical_detail=str(exc),
+        retryable=True,
+    )
+
+
+def _public_stats(stats: dict) -> dict:
+    return {key: value for key, value in stats.items() if not str(key).startswith("_")}
+
+
 def enqueue_job(conn, asset_id: str, job_type: str, *, priority: int = 50) -> str:
     job_id = stable_id("job", f"{asset_id}:{job_type}")
     conn.execute(
@@ -447,6 +610,7 @@ def _iter_files(
     limit: int | None = None,
     start_after: str = "",
     seen_at: float | None = None,
+    stats: dict | None = None,
 ):
     seen_at = seen_at or now()
     seen_dirs: set[tuple[int, int]] = set()
@@ -461,7 +625,8 @@ def _iter_files(
             continue
         try:
             st = current.stat()
-        except Exception:
+        except Exception as exc:
+            _record_scan_error(conn, stats, str(current), "quick_index", exc)
             continue
         key = (getattr(st, "st_dev", 0), getattr(st, "st_ino", 0))
         if key in seen_dirs:
@@ -470,7 +635,8 @@ def _iter_files(
         _upsert_dir(conn, root_id, current, seen_at, st)
         try:
             entries = sorted(current.iterdir(), key=lambda item: str(item).lower())
-        except Exception:
+        except Exception as exc:
+            _record_scan_error(conn, stats, str(current), "quick_index", exc)
             continue
         dirs: list[Path] = []
         for entry in entries:
@@ -577,8 +743,8 @@ def _reconcile_known_assets(conn, exclusions: list[str], *, limit: int) -> dict:
                 continue
             st = file_path.stat()
             fingerprint = quick_fingerprint(file_path, st)
-        except Exception:
-            stats["errors"] += 1
+        except Exception as exc:
+            _record_scan_error(conn, stats, path, "live_reconcile", exc)
             continue
         if fingerprint != row["quick_fingerprint"]:
             _, changed, state = _upsert_asset(conn, int(row["root_id"] or 0), file_path, seen_at, int(row["depth"] or 2))
@@ -647,8 +813,8 @@ def _scan_known_directory(
             if not current.is_dir():
                 continue
             entries = sorted(current.iterdir(), key=lambda item: str(item).lower())
-        except Exception:
-            stats["errors"] += 1
+        except Exception as exc:
+            _record_scan_error(conn, stats, str(current), "live_reconcile", exc)
             continue
         scanned_dirs += 1
         stats["dirs_scanned"] += 1
@@ -679,8 +845,8 @@ def _scan_known_directory(
                         stats["files_changed"] += 1
                     if state != "ok":
                         stats["errors"] += 1
-            except Exception:
-                stats["errors"] += 1
+            except Exception as exc:
+                _record_scan_error(conn, stats, str(entry), "live_reconcile", exc)
         deleted_files, deleted_dirs = _prune_missing_children(conn, current, seen_files, seen_dirs, seen_at)
         stats["files_deleted"] += deleted_files
         stats["dirs_deleted"] += deleted_dirs
@@ -731,8 +897,8 @@ def _reconcile_known_dirs(conn, exclusions: list[str], *, dir_limit: int, file_l
                 continue
             st = dir_path.stat()
             fingerprint = _dir_fingerprint(dir_path, st)
-        except Exception:
-            stats["errors"] += 1
+        except Exception as exc:
+            _record_scan_error(conn, stats, str(dir_path), "live_reconcile", exc)
             continue
         if fingerprint != row["quick_fingerprint"]:
             stats["changed"] += 1
@@ -773,9 +939,18 @@ def reconcile_live_changes(
         + int(dir_stats.get("dirs_deleted", 0))
         + int(dir_stats.get("excluded_dirs", 0))
     )
-    if changed_total:
-        log_event("info", "live_reconcile_finished", "Local memory live changes reconciled", assets=asset_stats, dirs=dir_stats)
-    return {"ok": True, "assets": asset_stats, "dirs": dir_stats}
+    error_total = int(asset_stats.get("errors", 0) or 0) + int(dir_stats.get("errors", 0) or 0)
+    public_asset_stats = _public_stats(asset_stats)
+    public_dir_stats = _public_stats(dir_stats)
+    if changed_total or error_total:
+        log_event(
+            "warn" if error_total else "info",
+            "live_reconcile_finished",
+            "Local memory live changes reconciled",
+            assets=public_asset_stats,
+            dirs=public_dir_stats,
+        )
+    return {"ok": True, "assets": public_asset_stats, "dirs": public_dir_stats}
 
 
 def scan_once(*, limit: int | None = None) -> dict:
@@ -814,6 +989,7 @@ def scan_once(*, limit: int | None = None) -> dict:
             limit=limit,
             start_after=str(checkpoint["current_path"] or ""),
             seen_at=cycle_started_at,
+            stats=totals,
         ):
             asset_id, changed, state = _upsert_asset(conn, root_id, file_path, cycle_started_at, int(root["depth"] or 2))
             last_seen_path = norm_path(file_path)
@@ -833,7 +1009,7 @@ def scan_once(*, limit: int | None = None) -> dict:
                 path=redact_path(str(root_path)),
             )
             if last_seen_path:
-                _save_checkpoint(conn, root_id, last_seen_path, cycle_started_at=cycle_started_at, totals=totals)
+                _save_checkpoint(conn, root_id, last_seen_path, cycle_started_at=cycle_started_at, totals=_public_stats(totals))
         else:
             rows = conn.execute(
                 "SELECT asset_id FROM local_assets WHERE root_id=? AND status='active' AND last_seen_at < ?",
@@ -850,8 +1026,9 @@ def scan_once(*, limit: int | None = None) -> dict:
             (now(), now(), root_id),
         )
     conn.commit()
-    log_event("info", "scan_finished", "Local memory scan finished", **totals)
-    return {"ok": True, **totals}
+    public_totals = _public_stats(totals)
+    log_event("warn" if public_totals.get("errors") else "info", "scan_finished", "Local memory scan finished", **public_totals)
+    return {"ok": True, **public_totals}
 
 
 def _latest_version_id(conn, asset_id: str) -> str:
@@ -913,11 +1090,35 @@ def _replace_entities(conn, asset_id: str, version_id: str, values: list[str]) -
         )
 
 
+def _requeue_due_jobs(conn) -> dict:
+    current = now()
+    failed = conn.execute(
+        """
+        UPDATE local_index_jobs
+        SET status='pending', claimed_by='', lease_expires_at=NULL, updated_at=?
+        WHERE status='failed' AND (next_attempt_at IS NULL OR next_attempt_at <= ?)
+        """,
+        (current, current),
+    ).rowcount
+    expired = conn.execute(
+        """
+        UPDATE local_index_jobs
+        SET status='pending', claimed_by='', lease_expires_at=NULL, updated_at=?
+        WHERE status='running' AND lease_expires_at IS NOT NULL AND lease_expires_at <= ?
+        """,
+        (current, current),
+    ).rowcount
+    if failed or expired:
+        log_event("warn", "jobs_requeued", "Local memory recovered stalled jobs", failed=failed, expired=expired)
+    return {"failed": int(failed or 0), "expired": int(expired or 0)}
+
+
 def process_jobs(*, limit: int = 100) -> dict:
     conn = _conn()
     if _is_paused():
         log_event("info", "jobs_skipped_paused", "Local memory jobs skipped because indexing is paused")
         return {"ok": True, "paused": True, "processed": 0, "failed": 0}
+    recovered = _requeue_due_jobs(conn)
     rows = conn.execute(
         """
         SELECT j.*, a.path, a.depth, a.status AS asset_status
@@ -976,17 +1177,20 @@ def process_jobs(*, limit: int = 100) -> dict:
                 """,
                 (now() + 3600, type(exc).__name__, now(), job_id),
             )
-            conn.execute(
-                """
-                INSERT INTO local_index_errors(asset_id, path, phase, error_code, user_message, technical_detail, retryable, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, 1, ?)
-                """,
-                (asset_id, row["path"], job_type, type(exc).__name__, "Algunos archivos no se pudieron leer", str(exc), now()),
+            _record_index_error(
+                conn,
+                asset_id=asset_id,
+                path=row["path"],
+                phase=job_type,
+                error_code=type(exc).__name__,
+                user_message="Algunos archivos no se pudieron leer",
+                technical_detail=str(exc),
+                retryable=True,
             )
     conn.commit()
     if processed or failed:
         log_event("info", "jobs_processed", "Local memory jobs processed", processed=processed, failed=failed)
-    return {"ok": True, "processed": processed, "failed": failed}
+    return {"ok": True, "processed": processed, "failed": failed, "recovered": recovered}
 
 
 def run_once(
@@ -1000,6 +1204,12 @@ def run_once(
 ) -> dict:
     if root:
         add_root(root)
+    elif (
+        os.environ.get("NEXO_LOCAL_INDEX_DISABLE_DEFAULT_ROOTS", "").strip() != "1"
+        and os.environ.get("NEXO_SKIP_FS_INDEX", "").strip() != "1"
+        and not list_roots()
+    ):
+        ensure_default_roots()
     live_result = reconcile_live_changes(
         asset_limit=live_asset_limit,
         dir_limit=live_dir_limit,
@@ -1013,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()
@@ -1040,7 +1260,7 @@ def _problem_rows(conn) -> list[dict]:
         """
         SELECT created_at, level, event, message, metadata_json
         FROM local_index_logs
-        WHERE event IN ('service_cycle_failed', 'service_cycle_compat_fallback')
+        WHERE event IN ('service_cycle_failed', 'service_cycle_compat_fallback', 'service_cycle_skipped_lock')
           AND created_at > ?
         ORDER BY id DESC
         LIMIT 5
@@ -1101,6 +1321,7 @@ def _macos_local_index_service_status() -> dict:
     running = False
     active_process = False
     pid = ""
+    launchctl_status = ""
 
     code, stdout, _ = _command_output(["launchctl", "list"], timeout=2)
     if code == 0:
@@ -1109,6 +1330,7 @@ def _macos_local_index_service_status() -> dict:
             if len(parts) >= 3 and parts[-1] == LOCAL_INDEX_SERVICE_LABEL:
                 installed = True
                 pid = parts[0]
+                launchctl_status = parts[1]
                 running = True
                 active_process = pid.isdigit() and int(pid) > 0
                 break
@@ -1128,6 +1350,7 @@ def _macos_local_index_service_status() -> dict:
         "manager": "launchagent",
         "label": LOCAL_INDEX_SERVICE_LABEL,
         "pid": pid,
+        "last_exit_code": launchctl_status,
         "config_path": str(plist_path),
     }
 
@@ -1135,11 +1358,22 @@ def _macos_local_index_service_status() -> dict:
 def _windows_local_index_service_status() -> dict:
     command = (
         "$task = Get-ScheduledTask -TaskName 'NEXO Local Memory' -ErrorAction SilentlyContinue; "
-        "if ($task) { Write-Output $task.State }"
+        "$info = if ($task) { Get-ScheduledTaskInfo -TaskName 'NEXO Local Memory' -ErrorAction SilentlyContinue }; "
+        "if ($task) { "
+        "$lastRun = if ($info -and $info.LastRunTime) { $info.LastRunTime.ToString('o') } else { '' }; "
+        "$nextRun = if ($info -and $info.NextRunTime) { $info.NextRunTime.ToString('o') } else { '' }; "
+        "$lastResult = if ($info) { [string]$info.LastTaskResult } else { '' }; "
+        "Write-Output ($task.State.ToString() + '|' + $lastResult + '|' + $lastRun + '|' + $nextRun) "
+        "}"
     )
     code, stdout, _ = _command_output(["powershell", "-NoProfile", "-Command", command], timeout=4)
-    task_state = stdout.strip()
+    raw = stdout.strip()
+    parts = raw.split("|") if "|" in raw else [raw]
+    task_state = parts[0].strip() if parts else ""
     task_state_key = task_state.lower()
+    last_task_result = parts[1].strip() if len(parts) > 1 else ""
+    last_run_time = parts[2].strip() if len(parts) > 2 else ""
+    next_run_time = parts[3].strip() if len(parts) > 3 else ""
     installed = code == 0 and bool(task_state)
     active_process = task_state_key == "running"
     if not active_process:
@@ -1152,6 +1386,9 @@ def _windows_local_index_service_status() -> dict:
         "manager": "scheduled_task",
         "task_name": LOCAL_INDEX_WINDOWS_TASK,
         "task_state": task_state,
+        "last_task_result": last_task_result,
+        "last_run_time": last_run_time,
+        "next_run_time": next_run_time,
     }
 
 
@@ -1194,41 +1431,171 @@ def _local_index_service_status() -> dict:
     return service
 
 
+def _service_cycle_observation(conn) -> dict:
+    last_success = conn.execute(
+        "SELECT MAX(created_at) AS created_at FROM local_index_logs WHERE event='service_cycle_finished'"
+    ).fetchone()["created_at"] or 0
+    latest = conn.execute(
+        """
+        SELECT created_at, event, level, message, metadata_json
+        FROM local_index_logs
+        WHERE event IN ('service_cycle_finished', 'service_cycle_failed', 'service_cycle_compat_fallback', 'service_cycle_skipped_lock')
+        ORDER BY id DESC
+        LIMIT 1
+        """
+    ).fetchone()
+    latest_error = conn.execute(
+        """
+        SELECT created_at, event, level, message, metadata_json
+        FROM local_index_logs
+        WHERE event IN ('service_cycle_failed', 'service_cycle_compat_fallback', 'service_cycle_skipped_lock')
+          AND created_at > ?
+        ORDER BY id DESC
+        LIMIT 1
+        """,
+        (last_success,),
+    ).fetchone()
+    observation = {
+        "last_success_at": float(last_success or 0),
+        "last_error_at": 0,
+        "last_error_code": "",
+        "last_error_detail": "",
+        "healthy": latest_error is None,
+    }
+    if latest:
+        observation["last_heartbeat_at"] = float(latest["created_at"] or 0)
+    if latest_error:
+        observation["last_error_at"] = float(latest_error["created_at"] or 0)
+        observation["last_error_code"] = latest_error["event"]
+        observation["last_error_detail"] = f"{latest_error['message']} {latest_error['metadata_json']}"
+    return observation
+
+
+def _service_scheduler_has_error(service: dict) -> bool:
+    if service.get("manager") == "launchagent":
+        code = str(service.get("last_exit_code") or "").strip()
+        return bool(code and code not in {"0", "-"})
+    if service.get("manager") == "scheduled_task":
+        code = str(service.get("last_task_result") or "").strip()
+        return bool(code and code not in {"0"})
+    return False
+
+
+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.",
+            "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.",
+            "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.",
+            "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.",
+            "technical_detail": service.get("last_error_detail") or "",
+        }
+    return None
+
+
 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()
-    pending = conn.execute("SELECT COUNT(*) AS total FROM local_index_jobs WHERE status='pending'").fetchone()["total"]
-    done = conn.execute("SELECT COUNT(*) AS total FROM local_index_jobs WHERE status='done'").fetchone()["total"]
-    total_jobs = pending + done
+    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)
+    failed_jobs = int(job_counts.get("failed", 0) or 0)
+    done = int(job_counts.get("done", 0) or 0)
+    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)
     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"})
     service = _local_index_service_status()
-    service["state"] = "paused" if paused else ("idle" if pending == 0 else "indexing")
+    service.update(_service_cycle_observation(conn))
+    problem = _service_problem(service)
+    service["healthy"] = problem is None
+    service["state"] = "paused" if paused else ("attention" if problem else ("idle" if active_jobs == 0 else "indexing"))
+    problems = _problem_rows(conn)
+    if problem:
+        problems.insert(0, {
+            "user_message": problem["user_message"],
+            "recommended_action": problem["recommended_action"],
+            "technical_detail": problem["technical_detail"],
+            "support_code": problem["support_code"],
+            "severity": "warning",
+            "retryable": True,
+            "path": "",
+            "phase": "service",
+            "created_at": now(),
+        })
     return {
         "ok": True,
         "service": service,
         "global": {
-            "phase": "paused" if paused else ("idle" if pending == 0 else "light_extraction"),
+            "phase": "paused" if paused else ("service_attention" if problem else ("idle" if active_jobs == 0 else "light_extraction")),
             "percent": percent,
             "files_found": int(assets["total"] or 0),
             "files_processed": int(done or 0),
-            "changes_pending": int(pending or 0),
+            "changes_pending": int(active_jobs or 0),
+            "jobs_pending": pending,
+            "jobs_running": running_jobs,
+            "jobs_failed": failed_jobs,
             "elapsed_seconds": 0,
             "eta_seconds": None,
         },
         "volumes": volumes,
         "roots": roots,
         "exclusions": list_exclusions(),
-        "problems": _problem_rows(conn),
+        "problems": problems,
         "permissions": [],
         "models": model_status()["models"],
         "support_log_available": True,

package/src/local_context/util.py

@@ -15,7 +15,15 @@ def now() -> float:
 
 
 def norm_path(path: str | os.PathLike[str]) -> str:
-    return str(Path(path).expanduser()).rstrip(os.sep)
+    text = str(Path(path).expanduser())
+    if re.match(r"^[A-Za-z]:[\\/]*$", text):
+        return f"{text[0].upper()}:\\"
+    if text in {"/", "\\"}:
+        return text
+    stripped = text.rstrip("/\\")
+    if re.match(r"^[A-Za-z]:$", stripped):
+        return f"{stripped[0].upper()}:\\"
+    return stripped or text
 
 
 def stable_id(prefix: str, value: str) -> str:

package/src/scripts/nexo-local-index.py

@@ -51,6 +51,13 @@ def log(message: str) -> None:
         handle.write(line + "\n")
 
 
+def _log_event_best_effort(level: str, event: str, message: str, **metadata) -> None:
+    try:
+        log_event(level, event, message, **metadata)
+    except Exception as exc:
+        log(f"ERROR: failed to record local-index event {event}: {type(exc).__name__}: {exc}")
+
+
 def _read_lock() -> dict:
     try:
         return json.loads(LOCK_FILE.read_text(encoding="utf-8"))
@@ -121,7 +128,7 @@ def _run_index_cycle() -> dict:
         live_kwargs = ("live_asset_limit", "live_dir_limit", "live_file_limit")
         if not any(name in message for name in live_kwargs):
             raise
-        log_event(
+        _log_event_best_effort(
             "warn",
             "service_cycle_compat_fallback",
             "Local memory service used compatibility fallback",
@@ -134,17 +141,18 @@ def _run_index_cycle() -> dict:
 def main() -> int:
     if not acquire_lock():
         log("Skipped: previous local-index cycle is still running.")
+        _log_event_best_effort("warn", "service_cycle_skipped_lock", "Local memory service skipped because a previous cycle is still running")
         return 0
     try:
         if os.environ.get("NEXO_LOCAL_INDEX_DISABLE_DEFAULT_ROOTS", "").strip() != "1":
             api.ensure_default_roots()
         result = _run_index_cycle()
-        log_event("info", "service_cycle_finished", "Local memory service cycle finished", result=result)
+        _log_event_best_effort("info", "service_cycle_finished", "Local memory service cycle finished", result=result)
         log(json.dumps(result, ensure_ascii=False, sort_keys=True))
         return 0 if result.get("ok") else 2
     except Exception as exc:
-        log_event("error", "service_cycle_failed", "Local memory service cycle failed", error=type(exc).__name__)
         log(f"ERROR: {type(exc).__name__}: {exc}")
+        _log_event_best_effort("error", "service_cycle_failed", "Local memory service cycle failed", error=type(exc).__name__)
         return 2
     finally:
         release_lock()