nexo-brain 7.17.7 → 7.18.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.17.7",
+  "version": "7.18.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.17.7` is the current packaged-runtime line. Patch release over v7.17.6 - macOS TCC privacy denials now become a guided Full Disk Access permission state instead of an unexplained cron failure, with Desktop-ready status written for user action.
+Version `7.18.0` is the current packaged-runtime line. 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.
+
+Previously in `7.17.8`: patch release over v7.17.7 - standalone `nexo chat` now surfaces macOS Full Disk Access guidance, and Brain clears stale permission state after a live access probe succeeds.
+
+Previously in `7.17.7`: patch release over v7.17.6 - macOS TCC privacy denials now become a guided Full Disk Access permission state instead of an unexplained cron failure, with Desktop-ready status written for user action.
 
 Previously in `7.17.6`: patch release over v7.17.5 - cron health diagnostics are clearer for macOS TCC approval, and catch-up fallback executions now stay visible in `cron_runs` even on legacy or partially migrated runtimes.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.17.7",
+  "version": "7.18.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/cli.py

@@ -20,6 +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 automations reactivate NAME [--test-run] [--json]
   nexo skills list [--level ...] [--source-kind ...] [--json]
   nexo skills get ID [--json]
@@ -1269,6 +1270,135 @@ def _scripts_call(args):
         return 1
 
 
+def _local_context_emit(payload: dict, args) -> int:
+    return _print_json_or_text(payload, as_json=bool(getattr(args, "json", False)))
+
+
+def _local_context_status(args) -> int:
+    import local_context
+    return _local_context_emit(local_context.status(), args)
+
+
+def _local_context_run_once(args) -> int:
+    import local_context
+    return _local_context_emit(
+        local_context.run_once(
+            root=getattr(args, "root", "") or None,
+            limit=getattr(args, "limit", None),
+            process_limit=int(getattr(args, "process_limit", 100) or 100),
+        ),
+        args,
+    )
+
+
+def _local_context_control(args) -> int:
+    import local_context
+    command = str(getattr(args, "local_context_command", "") or "")
+    if command == "pause":
+        return _local_context_emit(local_context.pause(), args)
+    if command == "resume":
+        return _local_context_emit(local_context.resume(), args)
+    if command == "clear-index":
+        return _local_context_emit(local_context.clear_index(), args)
+    return _local_context_emit({"ok": False, "error": f"unsupported control command: {command}"}, args)
+
+
+def _local_context_roots(args) -> int:
+    import local_context
+    command = str(getattr(args, "local_context_roots_command", "") or "")
+    if command == "list":
+        return _local_context_emit({"ok": True, "roots": local_context.list_roots()}, args)
+    if command == "add":
+        return _local_context_emit(
+            local_context.add_root(
+                getattr(args, "path", ""),
+                mode=getattr(args, "mode", "normal") or "normal",
+                depth=getattr(args, "depth", None),
+            ),
+            args,
+        )
+    if command == "remove":
+        return _local_context_emit(local_context.remove_root(getattr(args, "path", "")), args)
+    return _local_context_emit({"ok": False, "error": f"unsupported roots command: {command}"}, args)
+
+
+def _local_context_exclusions(args) -> int:
+    import local_context
+    command = str(getattr(args, "local_context_exclusions_command", "") or "")
+    if command == "list":
+        return _local_context_emit({"ok": True, "exclusions": local_context.list_exclusions()}, args)
+    if command == "add":
+        return _local_context_emit(
+            local_context.add_exclusion(
+                getattr(args, "path", ""),
+                reason=getattr(args, "reason", "user") or "user",
+            ),
+            args,
+        )
+    if command == "remove":
+        return _local_context_emit(local_context.remove_exclusion(getattr(args, "path", "")), args)
+    return _local_context_emit({"ok": False, "error": f"unsupported exclusions command: {command}"}, args)
+
+
+def _local_context_query(args) -> int:
+    import local_context
+    return _local_context_emit(
+        local_context.context_query(
+            getattr(args, "query", "") or "",
+            intent=getattr(args, "intent", "answer") or "answer",
+            limit=int(getattr(args, "limit", 12) or 12),
+            evidence_required=not bool(getattr(args, "no_evidence_required", False)),
+            current_context=getattr(args, "current_context", "") or "",
+        ),
+        args,
+    )
+
+
+def _local_context_diagnostics(args) -> int:
+    import local_context
+    return _local_context_emit(
+        local_context.diagnostics_tail(limit=int(getattr(args, "limit", 100) or 100)),
+        args,
+    )
+
+
+def _local_context_models(args) -> int:
+    import local_context
+    command = str(getattr(args, "local_context_models_command", "") or "status")
+    if command == "warmup":
+        return _local_context_emit(
+            local_context.warmup_models(local_files_only=not bool(getattr(args, "allow_download", False))),
+            args,
+        )
+    return _local_context_emit(local_context.model_status(), args)
+
+
+def _local_context_service_config(args) -> int:
+    from local_context import api as local_context_api
+    return _local_context_emit(
+        local_context_api.render_service_config(getattr(args, "platform", "") or None),
+        args,
+    )
+
+
+def _local_context_asset(args) -> int:
+    import local_context
+    command = str(getattr(args, "local_context_asset_command", "") or "")
+    if command == "get":
+        return _local_context_emit(local_context.get_asset(getattr(args, "asset_id", "")), args)
+    if command == "neighbors":
+        return _local_context_emit(
+            local_context.get_neighbors(
+                getattr(args, "asset_id", ""),
+                limit=int(getattr(args, "limit", 30) or 30),
+            ),
+            args,
+        )
+    if command == "purge":
+        return _local_context_emit(local_context.purge_asset(getattr(args, "asset_id", "")), args)
+    return _local_context_emit({"ok": False, "error": f"unsupported asset command: {command}"}, args)
+
+
 def _recover(args):
     """Delegate to plugins.recover.cli_main so the logic lives in one place."""
     from plugins.recover import cli_main as _recover_cli_main
@@ -2187,6 +2317,29 @@ def _prompt_for_terminal_client(
         print("Invalid choice. Try again.", file=sys.stderr)
 
 
+def _ensure_chat_full_disk_access_notice(*, interactive: bool | None = None) -> dict:
+    runtime_power = _load_runtime_power_support()
+    if interactive is None:
+        interactive = bool(getattr(sys.stdin, "isatty", lambda: False)())
+    try:
+        choice = runtime_power["ensure_full_disk_access_choice"](
+            interactive=interactive,
+            reason="chat",
+            output_fn=lambda message: print(message, file=sys.stderr),
+        )
+    except EOFError:
+        return {
+            "status": "later",
+            "prompted": False,
+            "reasons": [],
+            "message": "Full Disk Access setup skipped because stdin closed.",
+        }
+    message = str(choice.get("message") or "").strip()
+    if message and (choice.get("prompted") or choice.get("relevant")):
+        print(f"[NEXO] Full Disk Access: {message}", file=sys.stderr)
+    return choice
+
+
 def _chat(args):
     target = args.path or "."
     selected_client = getattr(args, "client", None)
@@ -2211,6 +2364,11 @@ def _chat(args):
     except Exception:
         pass
 
+    try:
+        _ensure_chat_full_disk_access_notice()
+    except Exception as exc:
+        print(f"[NEXO] Full Disk Access check warning: {exc}", file=sys.stderr)
+
     try:
         from client_preferences import (
             detect_installed_clients,
@@ -2984,6 +3142,89 @@ def main():
     call_p.add_argument("--input", default="{}", help="JSON input payload")
     call_p.add_argument("--json-output", action="store_true", help="Force JSON output")
 
+    local_context_parser = sub.add_parser("local-context", help="Manage the local memory index")
+    local_context_sub = local_context_parser.add_subparsers(dest="local_context_command")
+
+    local_context_status_p = local_context_sub.add_parser("status", help="Show local memory index status")
+    local_context_status_p.add_argument("--json", action="store_true", help="JSON output")
+
+    local_context_run_p = local_context_sub.add_parser("run-once", help="Run one incremental scan/extract cycle")
+    local_context_run_p.add_argument("--root", default="", help="Optional folder to add before running")
+    local_context_run_p.add_argument("--limit", type=int, default=None, help="Maximum files to scan in this cycle")
+    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_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")
+
+    local_context_resume_p = local_context_sub.add_parser("resume", help="Resume local memory indexing")
+    local_context_resume_p.add_argument("--json", action="store_true", help="JSON output")
+
+    local_context_clear_p = local_context_sub.add_parser("clear-index", help="Clear the local memory index")
+    local_context_clear_p.add_argument("--json", action="store_true", help="JSON output")
+
+    local_context_roots_p = local_context_sub.add_parser("roots", help="Manage included folders")
+    local_context_roots_sub = local_context_roots_p.add_subparsers(dest="local_context_roots_command")
+    local_context_roots_list_p = local_context_roots_sub.add_parser("list", help="List included folders")
+    local_context_roots_list_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_roots_add_p = local_context_roots_sub.add_parser("add", help="Add an included folder")
+    local_context_roots_add_p.add_argument("path", help="Folder path")
+    local_context_roots_add_p.add_argument("--mode", choices=["normal", "developer", "complete"], default="normal", help="Indexing mode")
+    local_context_roots_add_p.add_argument("--depth", type=int, default=None, help="Privacy depth override")
+    local_context_roots_add_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_roots_remove_p = local_context_roots_sub.add_parser("remove", help="Remove an included folder")
+    local_context_roots_remove_p.add_argument("path", help="Folder path")
+    local_context_roots_remove_p.add_argument("--json", action="store_true", help="JSON output")
+
+    local_context_exclusions_p = local_context_sub.add_parser("exclusions", help="Manage excluded folders")
+    local_context_exclusions_sub = local_context_exclusions_p.add_subparsers(dest="local_context_exclusions_command")
+    local_context_exclusions_list_p = local_context_exclusions_sub.add_parser("list", help="List excluded folders")
+    local_context_exclusions_list_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_exclusions_add_p = local_context_exclusions_sub.add_parser("add", help="Add an excluded folder")
+    local_context_exclusions_add_p.add_argument("path", help="Folder path")
+    local_context_exclusions_add_p.add_argument("--reason", default="user", help="Reason label")
+    local_context_exclusions_add_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_exclusions_remove_p = local_context_exclusions_sub.add_parser("remove", help="Remove an excluded folder")
+    local_context_exclusions_remove_p.add_argument("path", help="Folder path")
+    local_context_exclusions_remove_p.add_argument("--json", action="store_true", help="JSON output")
+
+    local_context_query_p = local_context_sub.add_parser("query", help="Query local memory evidence")
+    local_context_query_p.add_argument("query", help="Question or search phrase")
+    local_context_query_p.add_argument("--intent", default="answer", help="Intent label stored with the query audit row")
+    local_context_query_p.add_argument("--limit", type=int, default=12, help="Maximum evidence rows")
+    local_context_query_p.add_argument("--current-context", default="", help="Optional current conversation/task context")
+    local_context_query_p.add_argument("--no-evidence-required", action="store_true", help="Allow empty evidence results")
+    local_context_query_p.add_argument("--json", action="store_true", help="JSON output")
+
+    local_context_diagnostics_p = local_context_sub.add_parser("diagnostics", help="Tail local memory diagnostic events")
+    local_context_diagnostics_p.add_argument("--limit", type=int, default=100, help="Maximum log rows")
+    local_context_diagnostics_p.add_argument("--json", action="store_true", help="JSON output")
+
+    local_context_service_p = local_context_sub.add_parser("service-config", help="Render macOS/Windows service config metadata")
+    local_context_service_p.add_argument("--platform", choices=["", "macos", "windows", "linux"], default="", help="Override platform")
+    local_context_service_p.add_argument("--json", action="store_true", help="JSON output")
+
+    local_context_models_p = local_context_sub.add_parser("models", help="Show or warm local model profiles")
+    local_context_models_sub = local_context_models_p.add_subparsers(dest="local_context_models_command")
+    local_context_models_status_p = local_context_models_sub.add_parser("status", help="Show local model status")
+    local_context_models_status_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_models_warmup_p = local_context_models_sub.add_parser("warmup", help="Warm local model profiles without network by default")
+    local_context_models_warmup_p.add_argument("--allow-download", action="store_true", help="Allow model downloads")
+    local_context_models_warmup_p.add_argument("--json", action="store_true", help="JSON output")
+
+    local_context_asset_p = local_context_sub.add_parser("asset", help="Inspect or purge one indexed asset")
+    local_context_asset_sub = local_context_asset_p.add_subparsers(dest="local_context_asset_command")
+    local_context_asset_get_p = local_context_asset_sub.add_parser("get", help="Get indexed asset details")
+    local_context_asset_get_p.add_argument("asset_id", help="Asset id")
+    local_context_asset_get_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_asset_neighbors_p = local_context_asset_sub.add_parser("neighbors", help="Get graph neighbors")
+    local_context_asset_neighbors_p.add_argument("asset_id", help="Asset id")
+    local_context_asset_neighbors_p.add_argument("--limit", type=int, default=30, help="Maximum relation rows")
+    local_context_asset_neighbors_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_asset_purge_p = local_context_asset_sub.add_parser("purge", help="Purge one indexed asset")
+    local_context_asset_purge_p.add_argument("asset_id", help="Asset id")
+    local_context_asset_purge_p.add_argument("--json", action="store_true", help="JSON output")
+
     automations_parser = sub.add_parser("automations", help="Manage Desktop-facing automations")
     automations_sub = automations_parser.add_subparsers(dest="automations_command")
 
@@ -3488,6 +3729,40 @@ def main():
         else:
             scripts_parser.print_help()
             return 0
+    elif args.command == "local-context":
+        if args.local_context_command == "status":
+            return _local_context_status(args)
+        if args.local_context_command == "run-once":
+            return _local_context_run_once(args)
+        if args.local_context_command in {"pause", "resume", "clear-index"}:
+            return _local_context_control(args)
+        if args.local_context_command == "roots":
+            if not args.local_context_roots_command:
+                local_context_roots_p.print_help()
+                return 0
+            return _local_context_roots(args)
+        if args.local_context_command == "exclusions":
+            if not args.local_context_exclusions_command:
+                local_context_exclusions_p.print_help()
+                return 0
+            return _local_context_exclusions(args)
+        if args.local_context_command == "query":
+            return _local_context_query(args)
+        if args.local_context_command == "diagnostics":
+            return _local_context_diagnostics(args)
+        if args.local_context_command == "service-config":
+            return _local_context_service_config(args)
+        if args.local_context_command == "models":
+            if not args.local_context_models_command:
+                args.local_context_models_command = "status"
+            return _local_context_models(args)
+        if args.local_context_command == "asset":
+            if not args.local_context_asset_command:
+                local_context_asset_p.print_help()
+                return 0
+            return _local_context_asset(args)
+        local_context_parser.print_help()
+        return 0
     elif args.command == "automations":
         if args.automations_command == "list":
             return _automations_list(args)

package/src/crons/manifest.json

@@ -302,6 +302,19 @@
       "run_on_boot": true,
       "run_on_wake": true
     },
+    {
+      "id": "local-index",
+      "script": "scripts/nexo-local-index.py",
+      "interval_seconds": 60,
+      "description": "Local Context Layer indexing cycle for on-device memory",
+      "core": true,
+      "recovery_policy": "restart",
+      "idempotent": true,
+      "max_catchup_age": 600,
+      "stuck_after_seconds": 900,
+      "run_on_boot": true,
+      "run_on_wake": true
+    },
     {
       "id": "email-monitor",
       "script": "scripts/nexo-email-monitor.py",

package/src/db/_schema.py

@@ -1765,6 +1765,213 @@ def _m62_memory_observations_fts_trigger_fix(conn):
     )
 
 
+def _m63_local_context_layer(conn):
+    """Local Context Layer storage for on-device memory indexing."""
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS local_index_roots (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            root_path TEXT NOT NULL UNIQUE,
+            display_path TEXT NOT NULL,
+            mode TEXT NOT NULL DEFAULT 'normal',
+            depth INTEGER NOT NULL DEFAULT 2,
+            status TEXT NOT NULL DEFAULT 'active',
+            last_scan_at REAL,
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_index_exclusions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            path TEXT NOT NULL UNIQUE,
+            display_path TEXT NOT NULL,
+            reason TEXT NOT NULL DEFAULT 'user',
+            created_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_index_jobs (
+            job_id TEXT PRIMARY KEY,
+            asset_id TEXT NOT NULL,
+            job_type TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending',
+            priority INTEGER NOT NULL DEFAULT 50,
+            claimed_by TEXT NOT NULL DEFAULT '',
+            lease_expires_at REAL,
+            attempt_count INTEGER NOT NULL DEFAULT 0,
+            next_attempt_at REAL,
+            last_error_code TEXT NOT NULL DEFAULT '',
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_index_checkpoints (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            root_id INTEGER,
+            phase TEXT NOT NULL DEFAULT 'quick_index',
+            current_path TEXT NOT NULL DEFAULT '',
+            total_seen INTEGER NOT NULL DEFAULT 0,
+            total_changed INTEGER NOT NULL DEFAULT 0,
+            total_errors INTEGER NOT NULL DEFAULT 0,
+            eta_seconds REAL,
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_index_state (
+            key TEXT PRIMARY KEY,
+            value TEXT NOT NULL,
+            updated_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_index_errors (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            asset_id TEXT NOT NULL DEFAULT '',
+            path TEXT NOT NULL DEFAULT '',
+            phase TEXT NOT NULL,
+            error_code TEXT NOT NULL,
+            user_message TEXT NOT NULL DEFAULT '',
+            technical_detail TEXT NOT NULL DEFAULT '',
+            retryable INTEGER NOT NULL DEFAULT 1,
+            created_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_index_logs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            created_at REAL NOT NULL,
+            level TEXT NOT NULL,
+            event TEXT NOT NULL,
+            message TEXT NOT NULL,
+            metadata_json TEXT NOT NULL DEFAULT '{}'
+        );
+
+        CREATE TABLE IF NOT EXISTS local_assets (
+            asset_id TEXT PRIMARY KEY,
+            root_id INTEGER,
+            path TEXT NOT NULL UNIQUE,
+            display_path TEXT NOT NULL,
+            parent_path TEXT NOT NULL DEFAULT '',
+            volume_id TEXT NOT NULL DEFAULT '',
+            file_type TEXT NOT NULL DEFAULT 'file',
+            extension TEXT NOT NULL DEFAULT '',
+            size_bytes INTEGER NOT NULL DEFAULT 0,
+            created_at_fs REAL,
+            modified_at_fs REAL,
+            quick_fingerprint TEXT NOT NULL DEFAULT '',
+            depth INTEGER NOT NULL DEFAULT 2,
+            depth_reason TEXT NOT NULL DEFAULT 'default',
+            phase TEXT NOT NULL DEFAULT 'quick_index',
+            status TEXT NOT NULL DEFAULT 'active',
+            privacy_class TEXT NOT NULL DEFAULT 'normal',
+            permission_state TEXT NOT NULL DEFAULT 'unknown',
+            first_seen_at REAL NOT NULL,
+            last_seen_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            deleted_at REAL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_asset_versions (
+            version_id TEXT PRIMARY KEY,
+            asset_id TEXT NOT NULL,
+            quick_fingerprint TEXT NOT NULL DEFAULT '',
+            content_hash TEXT NOT NULL DEFAULT '',
+            size_bytes INTEGER NOT NULL DEFAULT 0,
+            modified_at_fs REAL,
+            summary TEXT NOT NULL DEFAULT '',
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            created_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_chunks (
+            chunk_id TEXT PRIMARY KEY,
+            asset_id TEXT NOT NULL,
+            version_id TEXT NOT NULL,
+            chunk_index INTEGER NOT NULL DEFAULT 0,
+            text TEXT NOT NULL DEFAULT '',
+            token_count INTEGER NOT NULL DEFAULT 0,
+            created_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_entities (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            entity_id TEXT NOT NULL,
+            asset_id TEXT NOT NULL,
+            version_id TEXT NOT NULL,
+            name TEXT NOT NULL,
+            entity_type TEXT NOT NULL DEFAULT 'entity',
+            confidence REAL NOT NULL DEFAULT 0.5,
+            evidence TEXT NOT NULL DEFAULT '',
+            created_at REAL NOT NULL,
+            UNIQUE(entity_id, asset_id, version_id)
+        );
+
+        CREATE TABLE IF NOT EXISTS local_relations (
+            relation_id TEXT PRIMARY KEY,
+            source_asset_id TEXT NOT NULL,
+            target_asset_id TEXT NOT NULL DEFAULT '',
+            target_ref TEXT NOT NULL DEFAULT '',
+            relation_type TEXT NOT NULL,
+            confidence REAL NOT NULL DEFAULT 0.5,
+            evidence TEXT NOT NULL DEFAULT '',
+            active INTEGER NOT NULL DEFAULT 1,
+            created_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_embeddings (
+            embedding_id TEXT PRIMARY KEY,
+            asset_id TEXT NOT NULL,
+            chunk_id TEXT NOT NULL,
+            model_id TEXT NOT NULL,
+            model_revision TEXT NOT NULL DEFAULT '',
+            dimension INTEGER NOT NULL,
+            vector_json TEXT NOT NULL,
+            created_at REAL NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS local_context_queries (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            query_hash TEXT NOT NULL,
+            intent TEXT NOT NULL DEFAULT 'answer',
+            result_count INTEGER NOT NULL DEFAULT 0,
+            confidence REAL NOT NULL DEFAULT 0.0,
+            warnings_json TEXT NOT NULL DEFAULT '[]',
+            created_at REAL NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_local_index_roots_status
+            ON local_index_roots(status);
+        CREATE INDEX IF NOT EXISTS idx_local_index_jobs_status_priority
+            ON local_index_jobs(status, priority, created_at);
+        CREATE INDEX IF NOT EXISTS idx_local_index_jobs_asset
+            ON local_index_jobs(asset_id);
+        CREATE INDEX IF NOT EXISTS idx_local_index_errors_created
+            ON local_index_errors(created_at);
+        CREATE INDEX IF NOT EXISTS idx_local_index_logs_created
+            ON local_index_logs(created_at);
+        CREATE INDEX IF NOT EXISTS idx_local_assets_root_status
+            ON local_assets(root_id, status);
+        CREATE INDEX IF NOT EXISTS idx_local_assets_path
+            ON local_assets(path);
+        CREATE INDEX IF NOT EXISTS idx_local_assets_parent
+            ON local_assets(parent_path);
+        CREATE INDEX IF NOT EXISTS idx_local_assets_volume
+            ON local_assets(volume_id);
+        CREATE INDEX IF NOT EXISTS idx_local_versions_asset
+            ON local_asset_versions(asset_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_local_chunks_asset
+            ON local_chunks(asset_id);
+        CREATE INDEX IF NOT EXISTS idx_local_entities_name
+            ON local_entities(name);
+        CREATE INDEX IF NOT EXISTS idx_local_entities_asset
+            ON local_entities(asset_id);
+        CREATE INDEX IF NOT EXISTS idx_local_relations_source
+            ON local_relations(source_asset_id, relation_type);
+        CREATE INDEX IF NOT EXISTS idx_local_embeddings_chunk
+            ON local_embeddings(chunk_id);
+        """
+    )
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -1828,6 +2035,7 @@ MIGRATIONS = [
     (60, "memory_observations", _m60_memory_observations),
     (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),
 ]
 
 

package/src/local_context/__init__.py

@@ -0,0 +1,50 @@
+"""Local Context Layer runtime.
+
+This package owns the local index used by Brain before Nero answers or acts.
+It is intentionally local-only: no scanner, extractor, embedding or resolver
+path calls an external API.
+"""
+
+from .api import (
+    add_exclusion,
+    add_root,
+    clear_index,
+    context_query,
+    diagnostics_tail,
+    ensure_default_roots,
+    get_asset,
+    get_neighbors,
+    list_exclusions,
+    list_roots,
+    model_status,
+    pause,
+    purge_asset,
+    remove_exclusion,
+    remove_root,
+    resume,
+    run_once,
+    status,
+    warmup_models,
+)
+
+__all__ = [
+    "add_exclusion",
+    "add_root",
+    "clear_index",
+    "context_query",
+    "diagnostics_tail",
+    "ensure_default_roots",
+    "get_asset",
+    "get_neighbors",
+    "list_exclusions",
+    "list_roots",
+    "model_status",
+    "pause",
+    "purge_asset",
+    "remove_exclusion",
+    "remove_root",
+    "resume",
+    "run_once",
+    "status",
+    "warmup_models",
+]