nexo-brain 7.19.0 → 7.20.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.19.0",
+  "version": "7.20.1",
   "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.19.0` is the current packaged-runtime line. 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.
+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.
+
+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.
+
+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.
 

package/package.json

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

@@ -23,6 +23,9 @@ 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:
@@ -205,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"
@@ -232,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)
@@ -321,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(
@@ -334,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]
@@ -353,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:
@@ -427,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():
@@ -455,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
@@ -630,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]:
@@ -647,7 +1019,7 @@ def _problem_rows(conn) -> list[dict]:
         LIMIT 20
         """
     ).fetchall()
-    return [
+    problems = [
         {
             "user_message": row["user_message"],
             "recommended_action": "NEXO lo volvera a intentar mas tarde" if row["retryable"] else "Revisa permisos o archivo",
@@ -661,6 +1033,35 @@ def _problem_rows(conn) -> list[dict]:
         }
         for row in rows
     ]
+    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
+    service_rows = conn.execute(
+        """
+        SELECT created_at, level, event, message, metadata_json
+        FROM local_index_logs
+        WHERE event IN ('service_cycle_failed', 'service_cycle_compat_fallback')
+          AND created_at > ?
+        ORDER BY id DESC
+        LIMIT 5
+        """,
+        (last_success,),
+    ).fetchall()
+    problems.extend(
+        {
+            "user_message": "La memoria local tuvo un problema temporal y NEXO la reintentara automaticamente",
+            "recommended_action": "No tienes que hacer nada. Si se repite, abre soporte y diagnostico para ver el detalle.",
+            "technical_detail": f"{row['event']}: {row['message']} {row['metadata_json']}",
+            "support_code": row["event"],
+            "severity": "warning" if row["level"] == "warn" else "error",
+            "retryable": True,
+            "path": "",
+            "phase": "service",
+            "created_at": row["created_at"],
+        }
+        for row in service_rows
+    )
+    return problems
 
 
 def _command_output(args: list[str], *, timeout: int = 2) -> tuple[int, str, str]:
@@ -955,6 +1356,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.")
@@ -984,7 +1400,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,
@@ -1034,6 +1450,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/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/scripts/deep-sleep/extract.py

@@ -70,6 +70,57 @@ TRANSIENT_ERROR_KINDS = {
 }
 REQUIRED_PROTOCOL_SUMMARY_KEYS = ("guard_check", "heartbeat", "change_log")
 
+# Compact few-shot rendered into the prompt on a `json_schema` retry. Keeps
+# the placeholder structure intact so the model sees the exact contract that
+# `_is_valid_extraction` enforces. Kept as a string to avoid pulling in a
+# template engine for a one-shot block.
+JSON_SCHEMA_FEWSHOT = (
+    "RETRY_HINT: the previous attempt produced JSON that did not match the "
+    "Deep Sleep extraction contract. The response must be a SINGLE JSON "
+    "object with the following minimum shape (extra keys allowed):\n"
+    "{\n"
+    '  "session_id": "<exact session id, string>",\n'
+    '  "findings": [ { "type": "...", "summary": "...", "evidence": "..." } ],\n'
+    '  "protocol_summary": {\n'
+    '    "guard_check": { "ran": true|false, "notes": "..." },\n'
+    '    "heartbeat":   { "count": 0, "notes": "..." },\n'
+    '    "change_log":  { "entries": 0, "notes": "..." }\n'
+    "  }\n"
+    "}\n"
+    "Mandatory: session_id is a non-empty string equal to {{SESSION_ID}}; "
+    "findings is a list of objects; protocol_summary contains the three "
+    "object keys above. Return ONLY the JSON object, no prose, no fences."
+)
+
+
+def _record_protocol_debt(
+    session_id: str,
+    *,
+    debt_type: str,
+    severity: str,
+    evidence: str,
+) -> None:
+    """Best-effort registration of an extraction failure as protocol debt.
+
+    Imported lazily so the extractor still runs in environments where the
+    DB layer is unavailable (e.g. partial installs, unit tests). Any error
+    inside the debt path is swallowed: we never want a debt-logging issue
+    to mask the real extraction failure already being reported.
+    """
+    try:
+        from db._protocol import create_protocol_debt
+    except Exception:  # pragma: no cover - best effort
+        return
+    try:
+        create_protocol_debt(
+            session_id,
+            debt_type,
+            severity=severity,
+            evidence=evidence[:3500],
+        )
+    except Exception as exc:  # pragma: no cover - best effort
+        print(f"    Warning: could not record protocol_debt: {exc}", file=sys.stderr)
+
 
 def _classify_cli_result(result) -> tuple[str, str]:
     """Return (kind, short_message) describing a failed automation backend call.
@@ -211,11 +262,18 @@ def analyze_session(
     date_dir: Path,
     shared_context_file: Path | None,
     session_txt_map: dict[str, str] | None = None,
+    *,
+    prior_error_kind: str = "",
 ) -> tuple[dict | None, str | None]:
     """Send a session to the automation backend for extraction analysis.
 
     Returns (parsed_result, error_kind). `error_kind` is only set on failure.
     See `_classify_cli_result` for possible values.
+
+    ``prior_error_kind`` is consumed by the retry path: when the previous
+    attempt failed validation with ``json_schema`` we append a few-shot of
+    the contract so the model sees the exact shape it must produce instead
+    of repeating the same structurally wrong payload.
     """
     session_file = find_session_file(session_id, date_dir, session_txt_map=session_txt_map)
     if not session_file:
@@ -236,6 +294,15 @@ def analyze_session(
     prompt = prompt_template.replace("{{CONTEXT_FILE}}", str(session_file))
     prompt = prompt.replace("{{SESSION_ID}}", session_id)
     prompt += shared_ctx_instruction
+    if prior_error_kind == "json_schema":
+        prompt += "\n\n" + JSON_SCHEMA_FEWSHOT.replace("{{SESSION_ID}}", session_id)
+
+    # Bootstrap the subagent with the day's deep-sleep dir as cwd so its
+    # default Read allowlist already covers the session transcript, the
+    # shared context, and the day's working files. Without this, the CLI
+    # subprocess inherits the parent's cwd (often "/") and fails with
+    # `cannot_comply` the first time it tries to Read the session file.
+    subagent_cwd = str(date_dir) if date_dir and Path(date_dir).exists() else None
 
     try:
         json_system_prompt = render_core_prompt(
@@ -246,6 +313,7 @@ def analyze_session(
         result = run_automation_prompt(
             prompt,
             caller="deep-sleep/extract",
+            cwd=subagent_cwd,
             timeout=CLAUDE_TIMEOUT,
             output_format="text",
             append_system_prompt=json_system_prompt,
@@ -276,6 +344,7 @@ def analyze_session(
             convert_result = run_automation_prompt(
                 convert_prompt,
                 caller="deep-sleep/extract",
+                cwd=subagent_cwd,
                 timeout=120,
                 output_format="text",
                 append_system_prompt=json_system_prompt,
@@ -471,6 +540,7 @@ def main():
                 date_dir,
                 shared_context_file,
                 session_txt_map=session_txt_map,
+                prior_error_kind=last_error_kind,
             )
             if result:
                 break
@@ -522,6 +592,21 @@ def main():
             }
             all_extractions.append(failed_entry)
             _save_checkpoint(checkpoint_file, failed_entry)
+            # Surface deterministic extractor failures as protocol debt so
+            # the aggregate self-audit cannot silently absorb the pattern.
+            # Severity escalates once the session is poisoned because by
+            # then it stops being a per-run hiccup and becomes a recurring
+            # runtime issue worth a louder signal.
+            _record_protocol_debt(
+                session_id,
+                debt_type=f"deep-sleep.extract.{last_error_kind}",
+                severity="error" if state == "poisoned" else "warn",
+                evidence=(
+                    f"date={target_date} state={state} attempts={new_count}/"
+                    f"{MAX_POISON_ATTEMPTS} kind={last_error_kind} "
+                    f"checkpoint={checkpoint_file}"
+                ),
+            )
             if state == "poisoned":
                 poisoned += 1
 

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:
@@ -48,6 +51,27 @@ def log(message: str) -> None:
         handle.write(line + "\n")
 
 
+def _read_lock() -> dict:
+    try:
+        return json.loads(LOCK_FILE.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def _pid_running(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
 def acquire_lock() -> bool:
     try:
         fd = os.open(str(LOCK_FILE), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
@@ -56,9 +80,16 @@ def acquire_lock() -> bool:
         return True
     except FileExistsError:
         try:
-            age = time.time() - LOCK_FILE.stat().st_mtime
+            lock = _read_lock()
+            pid = int(lock.get("pid") or 0)
+            age = time.time() - float(lock.get("created_at") or LOCK_FILE.stat().st_mtime)
+            if pid and not _pid_running(pid):
+                LOCK_FILE.unlink(missing_ok=True)
+                log(f"Removed stale local-index lock for dead pid {pid}.")
+                return acquire_lock()
             if age > LOCK_STALE_SECONDS:
                 LOCK_FILE.unlink(missing_ok=True)
+                log(f"Removed stale local-index lock older than {int(age)} seconds.")
                 return acquire_lock()
         except Exception:
             pass
@@ -67,11 +98,39 @@ def acquire_lock() -> bool:
 
 def release_lock() -> None:
     try:
+        lock = _read_lock()
+        pid = int(lock.get("pid") or 0)
+        if pid and pid != os.getpid():
+            return
         LOCK_FILE.unlink(missing_ok=True)
     except Exception:
         pass
 
 
+def _run_index_cycle() -> dict:
+    try:
+        return 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,
+        )
+    except TypeError as exc:
+        message = str(exc)
+        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(
+            "warn",
+            "service_cycle_compat_fallback",
+            "Local memory service used compatibility fallback",
+            error=message,
+        )
+        log(f"Compatibility fallback: api.run_once does not accept live reconcile limits ({message}).")
+        return api.run_once(limit=SCAN_LIMIT, process_limit=PROCESS_LIMIT)
+
+
 def main() -> int:
     if not acquire_lock():
         log("Skipped: previous local-index cycle is still running.")
@@ -79,7 +138,7 @@ 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 = _run_index_cycle()
         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