nexo-brain 7.18.1 → 7.20.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.18.1",
+  "version": "7.20.0",
   "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.18.1` is the current packaged-runtime line. Patch release over v7.18.0 - packaged Brain runtimes now include the `local_context` package, so Desktop Local Memory and `nexo local-context` do not get stuck behind `ModuleNotFoundError` or zero-file status; the local-index service also keeps detecting newly mounted volumes automatically.
+Version `7.20.0` is the current packaged-runtime line. 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.
+
+Previously in `7.19.0`: minor release over v7.18.1 - bundle-managed installations (NEXO Desktop `brain-bundle/`) can now pin Brain to the host application release cycle via `NEXO_BRAIN_AUTO_UPDATE=false`, and the server auto-exits with code 75 on fingerprint mismatch so MCP clients respawn the server with the new code instead of leaving stale `server.py` processes alive.
+
+Previously in `7.18.1`: patch release over v7.18.0 - packaged Brain runtimes now include the `local_context` package, so Desktop Local Memory and `nexo local-context` do not get stuck behind `ModuleNotFoundError` or zero-file status; the local-index service also keeps detecting newly mounted volumes automatically.
 
 Previously in `7.18.0`: minor release over v7.17.8 - Brain adds the Local Context Layer: a local-only background memory index with checkpoints, extraction, graph links, embeddings, MCP/CLI controls, and pre-action evidence for NEXO agents.
 

package/package.json

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

@@ -5372,6 +5372,11 @@ def startup_preflight(*, entrypoint: str, interactive: bool = False) -> dict:
             return result
 
         try:
+            env_auto_update = os.environ.get("NEXO_BRAIN_AUTO_UPDATE", "").strip().lower()
+            if env_auto_update in ("0", "false", "off", "no"):
+                result["skipped_reason"] = "auto_update disabled via NEXO_BRAIN_AUTO_UPDATE env var"
+                _write_update_summary(result)
+                return result
             last_check = _read_last_check()
             now = time.time()
             schedule_file = _runtime_config_dir(NEXO_HOME) / "schedule.json"

package/src/cli.py

@@ -20,7 +20,7 @@ Entry points:
   nexo scripts run NAME_OR_PATH [-- args...]
   nexo scripts doctor [NAME_OR_PATH] [--json]
   nexo scripts call TOOL --input JSON [--json-output]
-  nexo local-context status|run-once|pause|resume|roots|exclusions|query|diagnostics|models [--json]
+  nexo local-context status|run-once|reconcile|pause|resume|roots|exclusions|query|diagnostics|models [--json]
   nexo automations reactivate NAME [--test-run] [--json]
   nexo skills list [--level ...] [--source-kind ...] [--json]
   nexo skills get ID [--json]
@@ -1291,6 +1291,18 @@ def _local_context_run_once(args) -> int:
     )
 
 
+def _local_context_reconcile(args) -> int:
+    import local_context
+    return _local_context_emit(
+        local_context.reconcile_live_changes(
+            asset_limit=int(getattr(args, "asset_limit", 2000) or 0),
+            dir_limit=int(getattr(args, "dir_limit", 300) or 0),
+            file_limit=int(getattr(args, "file_limit", 1000) or 0),
+        ),
+        args,
+    )
+
+
 def _local_context_control(args) -> int:
     import local_context
     command = str(getattr(args, "local_context_command", "") or "")
@@ -3154,6 +3166,12 @@ def main():
     local_context_run_p.add_argument("--process-limit", type=int, default=100, help="Maximum extraction/graph jobs to process")
     local_context_run_p.add_argument("--json", action="store_true", help="JSON output")
 
+    local_context_reconcile_p = local_context_sub.add_parser("reconcile", help="Reconcile changed, deleted and new local files")
+    local_context_reconcile_p.add_argument("--asset-limit", type=int, default=2000, help="Maximum known files to verify")
+    local_context_reconcile_p.add_argument("--dir-limit", type=int, default=300, help="Maximum known folders to verify")
+    local_context_reconcile_p.add_argument("--file-limit", type=int, default=1000, help="Maximum files to scan inside changed folders")
+    local_context_reconcile_p.add_argument("--json", action="store_true", help="JSON output")
+
     local_context_pause_p = local_context_sub.add_parser("pause", help="Pause local memory indexing")
     local_context_pause_p.add_argument("--json", action="store_true", help="JSON output")
 
@@ -3734,6 +3752,8 @@ def main():
             return _local_context_status(args)
         if args.local_context_command == "run-once":
             return _local_context_run_once(args)
+        if args.local_context_command == "reconcile":
+            return _local_context_reconcile(args)
         if args.local_context_command in {"pause", "resume", "clear-index"}:
             return _local_context_control(args)
         if args.local_context_command == "roots":

package/src/db/_schema.py

@@ -1972,6 +1972,36 @@ def _m63_local_context_layer(conn):
     )
 
 
+def _m64_local_context_live_dirs(conn):
+    """Track known folders so local context can detect new/deleted/changed files quickly."""
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS local_index_dirs (
+            dir_id TEXT PRIMARY KEY,
+            root_id INTEGER,
+            path TEXT NOT NULL UNIQUE,
+            display_path TEXT NOT NULL,
+            parent_path TEXT NOT NULL DEFAULT '',
+            quick_fingerprint TEXT NOT NULL DEFAULT '',
+            status TEXT NOT NULL DEFAULT 'active',
+            first_seen_at REAL NOT NULL,
+            last_seen_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            deleted_at REAL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_local_index_dirs_root_status
+            ON local_index_dirs(root_id, status);
+        CREATE INDEX IF NOT EXISTS idx_local_index_dirs_path
+            ON local_index_dirs(path);
+        CREATE INDEX IF NOT EXISTS idx_local_index_dirs_parent
+            ON local_index_dirs(parent_path);
+        CREATE INDEX IF NOT EXISTS idx_local_assets_updated
+            ON local_assets(updated_at);
+        """
+    )
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -2036,6 +2066,7 @@ MIGRATIONS = [
     (61, "memory_observations_fts", _m61_memory_observations_fts),
     (62, "memory_observations_fts_trigger_fix", _m62_memory_observations_fts_trigger_fix),
     (63, "local_context_layer", _m63_local_context_layer),
+    (64, "local_context_live_dirs", _m64_local_context_live_dirs),
 ]
 
 

package/src/local_context/__init__.py

@@ -19,6 +19,7 @@ from .api import (
     model_status,
     pause,
     purge_asset,
+    reconcile_live_changes,
     remove_exclusion,
     remove_root,
     resume,
@@ -41,6 +42,7 @@ __all__ = [
     "model_status",
     "pause",
     "purge_asset",
+    "reconcile_live_changes",
     "remove_exclusion",
     "remove_root",
     "resume",

package/src/local_context/api.py

@@ -5,6 +5,7 @@ import os
 import shutil
 import stat
 import hashlib
+import subprocess
 import sys
 from pathlib import Path
 from typing import Any
@@ -15,9 +16,17 @@ from db._schema import run_migrations
 from . import embeddings
 from .extractors import chunk_text, entities, extract_text, summarize
 from .logging import log_event, tail
-from .privacy import classify_path, should_extract
+from .privacy import classify_path, should_extract, should_skip_tree
 from .util import content_hash, json_dumps, json_loads, norm_path, now, quick_fingerprint, redact_path, stable_id, system_label, tokenize
 
+LOCAL_INDEX_SERVICE_LABEL = "com.nexo.local-index"
+LOCAL_INDEX_SCRIPT_NAME = "nexo-local-index.py"
+LOCAL_INDEX_WINDOWS_TASK = "NEXO Local Memory"
+LOCAL_INDEX_LINUX_UNIT = "nexo-local-index.service"
+DEFAULT_LIVE_ASSET_LIMIT = int(os.environ.get("NEXO_LOCAL_INDEX_LIVE_ASSET_LIMIT", "2000") or "2000")
+DEFAULT_LIVE_DIR_LIMIT = int(os.environ.get("NEXO_LOCAL_INDEX_LIVE_DIR_LIMIT", "300") or "300")
+DEFAULT_LIVE_FILE_LIMIT = int(os.environ.get("NEXO_LOCAL_INDEX_LIVE_FILE_LIMIT", "1000") or "1000")
+
 
 def ensure_ready() -> None:
     init_db()
@@ -199,6 +208,11 @@ def _is_excluded(path: str, exclusions: list[str]) -> bool:
     return any(value == item or value.startswith(item + os.sep) for item in exclusions)
 
 
+def _path_prefix(path: str) -> str:
+    normalized = norm_path(path)
+    return normalized + os.sep if normalized else os.sep
+
+
 def _file_type(path: Path) -> str:
     if path.is_dir():
         return "folder"
@@ -226,6 +240,65 @@ def _permission_state(path: Path) -> str:
     return "granted"
 
 
+def _dir_fingerprint(path: Path, stat_result: os.stat_result | None = None) -> str:
+    st = stat_result or path.stat()
+    ctime_ns = getattr(st, "st_ctime_ns", int(float(st.st_ctime) * 1_000_000_000))
+    return f"{int(st.st_mtime_ns)}:{int(ctime_ns)}"
+
+
+def _upsert_dir(
+    conn,
+    root_id: int,
+    path: Path,
+    seen_at: float,
+    stat_result: os.stat_result | None = None,
+) -> tuple[bool, str]:
+    raw_path = str(path)
+    normalized = norm_path(raw_path)
+    dir_id = stable_id("dir", normalized)
+    parent = norm_path(path.parent)
+    try:
+        fingerprint = _dir_fingerprint(path, stat_result)
+    except Exception:
+        return False, "error"
+    row = conn.execute(
+        "SELECT quick_fingerprint, status FROM local_index_dirs WHERE dir_id=?",
+        (dir_id,),
+    ).fetchone()
+    changed = not row or row["quick_fingerprint"] != fingerprint or row["status"] == "deleted"
+    conn.execute(
+        """
+        INSERT INTO local_index_dirs(
+          dir_id, root_id, path, display_path, parent_path, quick_fingerprint,
+          status, first_seen_at, last_seen_at, updated_at, deleted_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, NULL)
+        ON CONFLICT(dir_id) DO UPDATE SET
+          root_id=excluded.root_id,
+          path=excluded.path,
+          display_path=excluded.display_path,
+          parent_path=excluded.parent_path,
+          quick_fingerprint=excluded.quick_fingerprint,
+          status='active',
+          last_seen_at=excluded.last_seen_at,
+          updated_at=excluded.updated_at,
+          deleted_at=NULL
+        """,
+        (
+            dir_id,
+            root_id,
+            normalized,
+            raw_path,
+            parent,
+            fingerprint,
+            seen_at,
+            seen_at,
+            seen_at,
+        ),
+    )
+    return changed, fingerprint
+
+
 def _upsert_asset(conn, root_id: int, path: Path, seen_at: float, root_depth: int) -> tuple[str, bool, str]:
     raw_path = str(path)
     normalized = norm_path(raw_path)
@@ -315,6 +388,43 @@ def _upsert_asset(conn, root_id: int, path: Path, seen_at: float, root_depth: in
     return asset_id, changed, "ok"
 
 
+def _mark_asset_deleted(conn, asset_id: str, deleted_at: float | None = None) -> None:
+    deleted_at = deleted_at or now()
+    conn.execute(
+        "UPDATE local_assets SET status='deleted', deleted_at=?, updated_at=? WHERE asset_id=? AND status!='deleted'",
+        (deleted_at, deleted_at, asset_id),
+    )
+    conn.execute(
+        """
+        UPDATE local_index_jobs
+        SET status='done', last_error_code='asset_deleted', updated_at=?
+        WHERE asset_id=? AND status IN ('pending', 'running')
+        """,
+        (deleted_at, asset_id),
+    )
+
+
+def _mark_dir_subtree_deleted(conn, dir_path: str, deleted_at: float | None = None) -> int:
+    deleted_at = deleted_at or now()
+    normalized = norm_path(dir_path)
+    prefix = _path_prefix(normalized)
+    conn.execute(
+        """
+        UPDATE local_index_dirs
+        SET status='deleted', deleted_at=?, updated_at=?
+        WHERE status='active' AND (path=? OR path LIKE ?)
+        """,
+        (deleted_at, deleted_at, normalized, prefix + "%"),
+    )
+    rows = conn.execute(
+        "SELECT asset_id FROM local_assets WHERE status='active' AND (path=? OR path LIKE ?)",
+        (normalized, prefix + "%"),
+    ).fetchall()
+    for row in rows:
+        _mark_asset_deleted(conn, row["asset_id"], deleted_at)
+    return len(rows)
+
+
 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(
@@ -328,7 +438,17 @@ def enqueue_job(conn, asset_id: str, job_type: str, *, priority: int = 50) -> st
     return job_id
 
 
-def _iter_files(root: Path, exclusions: list[str], *, limit: int | None = None, start_after: str = ""):
+def _iter_files(
+    conn,
+    root_id: int,
+    root: Path,
+    exclusions: list[str],
+    *,
+    limit: int | None = None,
+    start_after: str = "",
+    seen_at: float | None = None,
+):
+    seen_at = seen_at or now()
     seen_dirs: set[tuple[int, int]] = set()
     count = 0
     stack = [root]
@@ -337,6 +457,8 @@ def _iter_files(root: Path, exclusions: list[str], *, limit: int | None = None,
         current = stack.pop()
         if _is_excluded(str(current), exclusions):
             continue
+        if current != root and should_skip_tree(str(current)):
+            continue
         try:
             st = current.stat()
         except Exception:
@@ -345,6 +467,7 @@ def _iter_files(root: Path, exclusions: list[str], *, limit: int | None = None,
         if key in seen_dirs:
             continue
         seen_dirs.add(key)
+        _upsert_dir(conn, root_id, current, seen_at, st)
         try:
             entries = sorted(current.iterdir(), key=lambda item: str(item).lower())
         except Exception:
@@ -356,6 +479,8 @@ def _iter_files(root: Path, exclusions: list[str], *, limit: int | None = None,
             if entry.is_symlink():
                 continue
             if entry.is_dir():
+                if should_skip_tree(str(entry)):
+                    continue
                 dirs.append(entry)
                 continue
             if entry.is_file():
@@ -417,6 +542,242 @@ def _clear_checkpoint(conn, root_id: int) -> None:
     conn.execute("DELETE FROM local_index_checkpoints WHERE root_id=? AND phase='quick_index'", (root_id,))
 
 
+def _reconcile_known_assets(conn, exclusions: list[str], *, limit: int) -> dict:
+    stats = {"checked": 0, "modified": 0, "deleted": 0, "excluded": 0, "offline": 0, "errors": 0}
+    if limit <= 0:
+        return stats
+    rows = conn.execute(
+        """
+        SELECT a.asset_id, a.path, a.root_id, a.quick_fingerprint, a.depth, r.root_path
+        FROM local_assets a
+        LEFT JOIN local_index_roots r ON r.id = a.root_id
+        WHERE a.status='active'
+        ORDER BY a.updated_at ASC
+        LIMIT ?
+        """,
+        (int(limit),),
+    ).fetchall()
+    seen_at = now()
+    for row in rows:
+        stats["checked"] += 1
+        path = str(row["path"])
+        root_path = Path(row["root_path"]).expanduser() if row["root_path"] else None
+        if _is_excluded(path, exclusions):
+            _mark_asset_deleted(conn, row["asset_id"], seen_at)
+            stats["excluded"] += 1
+            continue
+        if root_path is not None and not root_path.exists():
+            stats["offline"] += 1
+            continue
+        file_path = Path(path)
+        try:
+            if not file_path.exists() or not file_path.is_file():
+                _mark_asset_deleted(conn, row["asset_id"], seen_at)
+                stats["deleted"] += 1
+                continue
+            st = file_path.stat()
+            fingerprint = quick_fingerprint(file_path, st)
+        except Exception:
+            stats["errors"] += 1
+            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))
+            if changed:
+                stats["modified"] += 1
+            if state != "ok":
+                stats["errors"] += 1
+        else:
+            conn.execute("UPDATE local_assets SET updated_at=? WHERE asset_id=?", (seen_at, row["asset_id"]))
+    return stats
+
+
+def _prune_missing_children(
+    conn,
+    directory: Path,
+    seen_files: set[str],
+    seen_dirs: set[str],
+    seen_at: float,
+) -> tuple[int, int]:
+    parent = norm_path(directory)
+    deleted_files = 0
+    deleted_dirs = 0
+    file_rows = conn.execute(
+        "SELECT asset_id, path FROM local_assets WHERE parent_path=? AND status='active'",
+        (parent,),
+    ).fetchall()
+    for row in file_rows:
+        if row["path"] not in seen_files:
+            _mark_asset_deleted(conn, row["asset_id"], seen_at)
+            deleted_files += 1
+    dir_rows = conn.execute(
+        "SELECT path FROM local_index_dirs WHERE parent_path=? AND status='active'",
+        (parent,),
+    ).fetchall()
+    for row in dir_rows:
+        if row["path"] not in seen_dirs:
+            deleted_files += _mark_dir_subtree_deleted(conn, row["path"], seen_at)
+            deleted_dirs += 1
+    return deleted_files, deleted_dirs
+
+
+def _scan_known_directory(
+    conn,
+    root_id: int,
+    directory: Path,
+    root_depth: int,
+    exclusions: list[str],
+    stats: dict,
+    *,
+    file_limit: int,
+    dir_limit: int,
+) -> None:
+    stack = [directory]
+    seen_at = now()
+    scanned_dirs = 0
+    while stack and stats["files_scanned"] < file_limit and scanned_dirs < dir_limit:
+        current = stack.pop()
+        if _is_excluded(str(current), exclusions):
+            _mark_dir_subtree_deleted(conn, str(current), seen_at)
+            stats["excluded_dirs"] += 1
+            continue
+        if current != directory and should_skip_tree(str(current)):
+            continue
+        try:
+            st = current.stat()
+            if not current.is_dir():
+                continue
+            entries = sorted(current.iterdir(), key=lambda item: str(item).lower())
+        except Exception:
+            stats["errors"] += 1
+            continue
+        scanned_dirs += 1
+        stats["dirs_scanned"] += 1
+        _upsert_dir(conn, root_id, current, seen_at, st)
+        seen_files: set[str] = set()
+        seen_dirs: set[str] = set()
+        for entry in entries:
+            if _is_excluded(str(entry), exclusions):
+                continue
+            try:
+                if entry.is_symlink():
+                    continue
+                if entry.is_dir():
+                    if should_skip_tree(str(entry)):
+                        continue
+                    changed, _ = _upsert_dir(conn, root_id, entry, seen_at)
+                    seen_dirs.add(norm_path(entry))
+                    if changed and scanned_dirs + len(stack) < dir_limit:
+                        stack.append(entry)
+                    continue
+                if entry.is_file():
+                    seen_files.add(norm_path(entry))
+                    if stats["files_scanned"] >= file_limit:
+                        continue
+                    _, changed, state = _upsert_asset(conn, root_id, entry, seen_at, root_depth)
+                    stats["files_scanned"] += 1
+                    if changed:
+                        stats["files_changed"] += 1
+                    if state != "ok":
+                        stats["errors"] += 1
+            except Exception:
+                stats["errors"] += 1
+        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
+
+
+def _reconcile_known_dirs(conn, exclusions: list[str], *, dir_limit: int, file_limit: int) -> dict:
+    stats = {
+        "checked": 0,
+        "changed": 0,
+        "dirs_scanned": 0,
+        "files_scanned": 0,
+        "files_changed": 0,
+        "files_deleted": 0,
+        "dirs_deleted": 0,
+        "excluded_dirs": 0,
+        "offline": 0,
+        "errors": 0,
+    }
+    if dir_limit <= 0 or file_limit <= 0:
+        return stats
+    rows = conn.execute(
+        """
+        SELECT d.dir_id, d.path, d.quick_fingerprint, d.root_id, r.root_path, r.depth
+        FROM local_index_dirs d
+        LEFT JOIN local_index_roots r ON r.id = d.root_id
+        WHERE d.status='active'
+        ORDER BY d.updated_at ASC
+        LIMIT ?
+        """,
+        (int(dir_limit),),
+    ).fetchall()
+    seen_at = now()
+    for row in rows:
+        stats["checked"] += 1
+        dir_path = Path(row["path"])
+        root_path = Path(row["root_path"]).expanduser() if row["root_path"] else None
+        if _is_excluded(str(dir_path), exclusions):
+            stats["files_deleted"] += _mark_dir_subtree_deleted(conn, str(dir_path), seen_at)
+            stats["excluded_dirs"] += 1
+            continue
+        if root_path is not None and not root_path.exists():
+            stats["offline"] += 1
+            continue
+        try:
+            if not dir_path.exists() or not dir_path.is_dir():
+                stats["files_deleted"] += _mark_dir_subtree_deleted(conn, str(dir_path), seen_at)
+                stats["dirs_deleted"] += 1
+                continue
+            st = dir_path.stat()
+            fingerprint = _dir_fingerprint(dir_path, st)
+        except Exception:
+            stats["errors"] += 1
+            continue
+        if fingerprint != row["quick_fingerprint"]:
+            stats["changed"] += 1
+            _scan_known_directory(
+                conn,
+                int(row["root_id"] or 0),
+                dir_path,
+                int(row["depth"] or 2),
+                exclusions,
+                stats,
+                file_limit=file_limit,
+                dir_limit=dir_limit,
+            )
+        else:
+            conn.execute("UPDATE local_index_dirs SET updated_at=? WHERE dir_id=?", (seen_at, row["dir_id"]))
+    return stats
+
+
+def reconcile_live_changes(
+    *,
+    asset_limit: int = DEFAULT_LIVE_ASSET_LIMIT,
+    dir_limit: int = DEFAULT_LIVE_DIR_LIMIT,
+    file_limit: int = DEFAULT_LIVE_FILE_LIMIT,
+) -> dict:
+    conn = _conn()
+    if _is_paused():
+        return {"ok": True, "paused": True, "assets": {}, "dirs": {}}
+    exclusions = [row["path"] for row in list_exclusions()]
+    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()
+    changed_total = (
+        int(asset_stats.get("modified", 0))
+        + int(asset_stats.get("deleted", 0))
+        + int(asset_stats.get("excluded", 0))
+        + int(dir_stats.get("files_changed", 0))
+        + int(dir_stats.get("files_deleted", 0))
+        + 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}
+
+
 def scan_once(*, limit: int | None = None) -> dict:
     conn = _conn()
     if _is_paused():
@@ -445,7 +806,15 @@ def scan_once(*, limit: int | None = None) -> dict:
         cycle_started_at = float(checkpoint["cycle_started_at"])
         seen_for_root = 0
         last_seen_path = ""
-        for file_path in _iter_files(root_path, exclusions, limit=limit, start_after=str(checkpoint["current_path"] or "")):
+        for file_path in _iter_files(
+            conn,
+            root_id,
+            root_path,
+            exclusions,
+            limit=limit,
+            start_after=str(checkpoint["current_path"] or ""),
+            seen_at=cycle_started_at,
+        ):
             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)
             totals["seen"] += 1
@@ -620,12 +989,25 @@ def process_jobs(*, limit: int = 100) -> dict:
     return {"ok": True, "processed": processed, "failed": failed}
 
 
-def run_once(*, root: str | None = None, limit: int | None = None, process_limit: int = 100) -> dict:
+def run_once(
+    *,
+    root: str | None = None,
+    limit: int | None = None,
+    process_limit: int = 100,
+    live_asset_limit: int = DEFAULT_LIVE_ASSET_LIMIT,
+    live_dir_limit: int = DEFAULT_LIVE_DIR_LIMIT,
+    live_file_limit: int = DEFAULT_LIVE_FILE_LIMIT,
+) -> dict:
     if root:
         add_root(root)
+    live_result = reconcile_live_changes(
+        asset_limit=live_asset_limit,
+        dir_limit=live_dir_limit,
+        file_limit=live_file_limit,
+    )
     scan_result = scan_once(limit=limit)
     job_result = process_jobs(limit=process_limit)
-    return {"ok": True, "scan": scan_result, "jobs": job_result}
+    return {"ok": True, "live": live_result, "scan": scan_result, "jobs": job_result}
 
 
 def _problem_rows(conn) -> list[dict]:
@@ -653,6 +1035,136 @@ def _problem_rows(conn) -> list[dict]:
     ]
 
 
+def _command_output(args: list[str], *, timeout: int = 2) -> tuple[int, str, str]:
+    try:
+        result = subprocess.run(args, capture_output=True, text=True, timeout=timeout)
+    except FileNotFoundError as exc:
+        return 127, "", str(exc)
+    except subprocess.TimeoutExpired as exc:
+        return 124, exc.stdout or "", exc.stderr or "timeout"
+    except Exception as exc:
+        return 1, "", str(exc)
+    return result.returncode, result.stdout or "", result.stderr or ""
+
+
+def _process_running(pattern: str) -> bool:
+    if system_label() == "windows":
+        command = (
+            "$pattern = '" + pattern.replace("'", "''") + "'; "
+            "$match = Get-CimInstance Win32_Process | "
+            "Where-Object { $_.CommandLine -like \"*$pattern*\" } | "
+            "Select-Object -First 1 -ExpandProperty ProcessId; "
+            "if ($match) { Write-Output $match }"
+        )
+        code, stdout, _ = _command_output(["powershell", "-NoProfile", "-Command", command], timeout=4)
+        return code == 0 and bool(stdout.strip())
+
+    code, stdout, _ = _command_output(["pgrep", "-f", pattern], timeout=2)
+    if code == 0 and stdout.strip():
+        return True
+    code, stdout, _ = _command_output(["ps", "aux"], timeout=2)
+    return code == 0 and pattern in stdout
+
+
+def _macos_local_index_service_status() -> dict:
+    plist_path = Path.home() / "Library" / "LaunchAgents" / f"{LOCAL_INDEX_SERVICE_LABEL}.plist"
+    installed = plist_path.is_file()
+    running = False
+    active_process = False
+    pid = ""
+
+    code, stdout, _ = _command_output(["launchctl", "list"], timeout=2)
+    if code == 0:
+        for line in stdout.splitlines():
+            parts = line.split()
+            if len(parts) >= 3 and parts[-1] == LOCAL_INDEX_SERVICE_LABEL:
+                installed = True
+                pid = parts[0]
+                running = True
+                active_process = pid.isdigit() and int(pid) > 0
+                break
+
+    if not installed:
+        code, _, _ = _command_output(["launchctl", "print", f"gui/{os.getuid()}/{LOCAL_INDEX_SERVICE_LABEL}"], timeout=2)
+        installed = code == 0
+
+    if not active_process:
+        active_process = _process_running(LOCAL_INDEX_SCRIPT_NAME)
+    running = running or active_process
+
+    return {
+        "installed": installed,
+        "running": running,
+        "active_process": active_process,
+        "manager": "launchagent",
+        "label": LOCAL_INDEX_SERVICE_LABEL,
+        "pid": pid,
+        "config_path": str(plist_path),
+    }
+
+
+def _windows_local_index_service_status() -> dict:
+    command = (
+        "$task = Get-ScheduledTask -TaskName 'NEXO Local Memory' -ErrorAction SilentlyContinue; "
+        "if ($task) { Write-Output $task.State }"
+    )
+    code, stdout, _ = _command_output(["powershell", "-NoProfile", "-Command", command], timeout=4)
+    task_state = stdout.strip()
+    task_state_key = task_state.lower()
+    installed = code == 0 and bool(task_state)
+    active_process = task_state_key == "running"
+    if not active_process:
+        active_process = _process_running(LOCAL_INDEX_SCRIPT_NAME)
+    running = task_state_key in {"ready", "running"} or active_process
+    return {
+        "installed": installed,
+        "running": running,
+        "active_process": active_process,
+        "manager": "scheduled_task",
+        "task_name": LOCAL_INDEX_WINDOWS_TASK,
+        "task_state": task_state,
+    }
+
+
+def _linux_local_index_service_status() -> dict:
+    unit_dir = Path.home() / ".config" / "systemd" / "user"
+    unit_path = unit_dir / LOCAL_INDEX_LINUX_UNIT
+    timer_path = unit_dir / "nexo-local-index.timer"
+    installed = unit_path.is_file() or timer_path.is_file()
+
+    code, stdout, _ = _command_output(["systemctl", "--user", "is-active", LOCAL_INDEX_LINUX_UNIT], timeout=2)
+    unit_state = stdout.strip()
+    running = code == 0 and unit_state == "active"
+    active_process = _process_running(LOCAL_INDEX_SCRIPT_NAME)
+    running = running or active_process
+
+    return {
+        "installed": installed,
+        "running": running,
+        "active_process": active_process,
+        "manager": "systemd_user",
+        "unit": LOCAL_INDEX_LINUX_UNIT,
+        "unit_state": unit_state,
+        "config_path": str(unit_path),
+    }
+
+
+def _local_index_service_status() -> dict:
+    platform_value = system_label()
+    if platform_value == "macos":
+        service = _macos_local_index_service_status()
+    elif platform_value == "windows":
+        service = _windows_local_index_service_status()
+    else:
+        service = _linux_local_index_service_status()
+    service.setdefault("installed", False)
+    service.setdefault("running", False)
+    service["platform"] = platform_value
+    service["started_at"] = ""
+    service["last_heartbeat_at"] = ""
+    return service
+
+
 def status() -> dict:
     conn = _conn()
     paused = _is_paused()
@@ -670,16 +1182,11 @@ def status() -> dict:
     ).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")
     return {
         "ok": True,
-        "service": {
-            "installed": False,
-            "running": False,
-            "state": "paused" if paused else ("idle" if pending == 0 else "indexing"),
-            "platform": system_label(),
-            "started_at": "",
-            "last_heartbeat_at": "",
-        },
+        "service": service,
         "global": {
             "phase": "paused" if paused else ("idle" if pending == 0 else "light_extraction"),
             "percent": percent,
@@ -820,6 +1327,21 @@ def context_query(query: str, *, intent: str = "answer", limit: int = 12, eviden
         (f"%{query.lower()}%", int(limit)),
     ).fetchall()
     entities_payload = [dict(row) for row in entity_rows]
+    relations_payload: list[dict] = []
+    if seen_assets:
+        asset_ids = list(seen_assets)[: int(limit)]
+        placeholders = ",".join("?" for _ in asset_ids)
+        relation_rows = conn.execute(
+            f"""
+            SELECT relation_id, source_asset_id, target_ref, relation_type, confidence, evidence
+            FROM local_relations
+            WHERE active=1 AND source_asset_id IN ({placeholders})
+            ORDER BY confidence DESC
+            LIMIT ?
+            """,
+            [*asset_ids, int(limit) * 3],
+        ).fetchall()
+        relations_payload = [dict(row) for row in relation_rows]
     warnings = []
     if evidence_required and not evidence_refs:
         warnings.append("No local evidence found for this query.")
@@ -849,7 +1371,7 @@ def context_query(query: str, *, intent: str = "answer", limit: int = 12, eviden
         "summary": summary,
         "assets": assets,
         "entities": entities_payload,
-        "relations": [],
+        "relations": relations_payload,
         "chunks": chunks,
         "warnings": warnings,
         "evidence_refs": evidence_refs,
@@ -899,6 +1421,7 @@ def clear_index() -> dict:
         "local_chunks",
         "local_entities",
         "local_relations",
+        "local_index_dirs",
         "local_index_errors",
         "local_index_jobs",
         "local_asset_versions",

package/src/local_context/privacy.py

@@ -36,10 +36,24 @@ NOISY_PARTS = {
     "dist",
     "build",
     ".git",
+    ".venv",
+    "venv",
+    "env",
     ".cache",
     "cache",
     "coverage",
     "__pycache__",
+    ".tox",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".next",
+    ".nuxt",
+    ".turbo",
+    ".parcel-cache",
+    ".bun",
+    ".gradle",
+    "target",
 }
 
 SYSTEM_PARTS = {
@@ -71,6 +85,15 @@ def classify_path(path: str) -> tuple[int, str, str]:
     return 2, "normal", "default"
 
 
+def should_skip_tree(path: str) -> bool:
+    p = Path(path)
+    lowered = str(p).replace("\\", "/").lower()
+    parts = {part.lower() for part in p.parts}
+    if any(item in lowered for item in SYSTEM_PARTS):
+        return True
+    return bool(parts & NOISY_PARTS)
+
+
 def should_extract(path: str, depth: int) -> bool:
     if depth < 2:
         return False

package/src/runtime_power.py

@@ -920,7 +920,20 @@ def ensure_full_disk_access_choice(
         probe = probe_fn()
         if probe.get("granted") is True:
             verified = True
-            message = f"Full Disk Access verified via {probe.get('probe_path')}."
+            schedule[FULL_DISK_ACCESS_STATUS_KEY] = FULL_DISK_ACCESS_GRANTED
+            schedule[FULL_DISK_ACCESS_REASONS_KEY] = []
+            clear_full_disk_access_required_state()
+            save_schedule_config(schedule)
+            return {
+                "status": FULL_DISK_ACCESS_GRANTED,
+                "prompted": False,
+                "verified": True,
+                "settings_opened": False,
+                "reasons": [],
+                "schedule_file": str(SCHEDULE_FILE),
+                "message": "",
+                "relevant": False,
+            }
         else:
             status = FULL_DISK_ACCESS_LATER
             message = (

package/src/runtime_versioning.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import asyncio
 import contextlib
 import hashlib
 import json
 import os
 import re
 import shutil
+import sys
 import time
 from dataclasses import dataclass
 from pathlib import Path
@@ -814,6 +816,31 @@ def prime_process_fingerprint() -> str:
     return PROCESS_FINGERPRINT
 
 
+_DRIFT_AUTOEXIT_SCHEDULED = False
+_DRIFT_EXIT_CODE = 75
+_DRIFT_EXIT_DELAY_SECONDS = 0.5
+
+
+def _request_drift_exit() -> None:
+    try:
+        os._exit(_DRIFT_EXIT_CODE)
+    except Exception:
+        os._exit(1)
+
+
+def _schedule_drift_autoexit() -> None:
+    global _DRIFT_AUTOEXIT_SCHEDULED
+    if _DRIFT_AUTOEXIT_SCHEDULED:
+        return
+    _DRIFT_AUTOEXIT_SCHEDULED = True
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        _request_drift_exit()
+        return
+    loop.call_later(_DRIFT_EXIT_DELAY_SECONDS, _request_drift_exit)
+
+
 @dataclass
 class RestartRequiredMiddleware(Middleware):
     client: str = ""
@@ -893,4 +920,7 @@ class RestartRequiredMiddleware(Middleware):
             "reason": state["reason"],
             "client_action": state["client_action"],
         }
-        return await self._tool_result_for_restart_required(context, payload)
+        result = await self._tool_result_for_restart_required(context, payload)
+        if state.get("reason") == "fingerprint_mismatch":
+            _schedule_drift_autoexit()
+        return result

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

@@ -39,6 +39,9 @@ LOCK_FILE = LOG_DIR / "local-index.lock"
 LOCK_STALE_SECONDS = int(os.environ.get("NEXO_LOCAL_INDEX_LOCK_STALE_SECONDS", "1800") or "1800")
 SCAN_LIMIT = int(os.environ.get("NEXO_LOCAL_INDEX_SCAN_LIMIT", "1000") or "1000")
 PROCESS_LIMIT = int(os.environ.get("NEXO_LOCAL_INDEX_PROCESS_LIMIT", "200") or "200")
+LIVE_ASSET_LIMIT = int(os.environ.get("NEXO_LOCAL_INDEX_LIVE_ASSET_LIMIT", "2000") or "2000")
+LIVE_DIR_LIMIT = int(os.environ.get("NEXO_LOCAL_INDEX_LIVE_DIR_LIMIT", "300") or "300")
+LIVE_FILE_LIMIT = int(os.environ.get("NEXO_LOCAL_INDEX_LIVE_FILE_LIMIT", "1000") or "1000")
 
 
 def log(message: str) -> None:
@@ -79,7 +82,13 @@ def main() -> int:
     try:
         if os.environ.get("NEXO_LOCAL_INDEX_DISABLE_DEFAULT_ROOTS", "").strip() != "1":
             api.ensure_default_roots()
-        result = api.run_once(limit=SCAN_LIMIT, process_limit=PROCESS_LIMIT)
+        result = api.run_once(
+            limit=SCAN_LIMIT,
+            process_limit=PROCESS_LIMIT,
+            live_asset_limit=LIVE_ASSET_LIMIT,
+            live_dir_limit=LIVE_DIR_LIMIT,
+            live_file_limit=LIVE_FILE_LIMIT,
+        )
         log_event("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