nexo-brain 7.20.25 → 7.21.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.20.25",
+  "version": "7.21.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,9 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.20.25` is the current packaged-runtime line. Patch release over v7.20.24 — Local Context now uses the pinned local BGE embedding model when available, automatically refreshes old hash embeddings, prioritizes known documents before lower-value files, and treats the Desktop-owned Qwen local-presence model as optional in standalone Brain installs.
+Version `7.21.0` is the current packaged-runtime line. Minor release over v7.20.25 - MCP now starts through a thin compatibility adapter backed by one resident local Runtime Service, reducing duplicate Brain processes and SQLite contention across Claude Code, Codex, Claude Desktop, and NEXO Desktop. The release also fingerprints Runtime Service state for safe update cutover, keeps document-first Local Memory scanning, and verifies bundled local LLM files before marking them installed.
+
+Previously in `7.20.25`: patch release over v7.20.24 — Local Context now uses the pinned local BGE embedding model when available, automatically refreshes old hash embeddings, prioritizes known documents before lower-value files, and treats the Desktop-owned Qwen local-presence model as optional in standalone Brain installs.
 
 Previously in `7.20.24`: patch release over v7.20.23 — Local Memory performance profile writes now tolerate active indexing, retry transient SQLite busy states, and shorten indexer write locks between processed files.
 

package/bin/nexo-brain.js

@@ -3879,12 +3879,32 @@ async function runSetup() {
         const slug = (spec.name || "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
         const targetDir = path.join(runtimeModelsDir, slug, spec.revision);
         fs.mkdirSync(targetDir, { recursive: true });
+        const missingFiles = [];
         for (const f of (spec.required_files || [])) {
           const src = path.join(sourceDir, f.path);
           const dst = path.join(targetDir, f.path);
-          if (fs.existsSync(src) && !fs.existsSync(dst)) {
+          if (!fs.existsSync(src)) {
+            missingFiles.push(f.path);
+            continue;
+          }
+          fs.mkdirSync(path.dirname(dst), { recursive: true });
+          if (!fs.existsSync(dst) || (f.size && fs.statSync(dst).size !== f.size)) {
             fs.copyFileSync(src, dst);
           }
+          if (f.size && fs.statSync(dst).size !== f.size) {
+            missingFiles.push(`${f.path}:size`);
+            continue;
+          }
+          if (f.sha256) {
+            const actual = crypto.createHash("sha256").update(fs.readFileSync(dst)).digest("hex");
+            if (actual !== f.sha256) {
+              missingFiles.push(`${f.path}:sha256`);
+            }
+          }
+        }
+        if (missingFiles.length) {
+          log(`  WARN: bundled LLM model ${spec.name} incomplete (${missingFiles.join(", ")})`);
+          continue;
         }
         // Write the lock file to match revision (avoids re-download).
         fs.writeFileSync(path.join(targetDir, ".nexo-model-lock.json"), JSON.stringify({

package/package.json

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

@@ -3988,7 +3988,7 @@ def _auto_update_check_locked() -> dict:
 
     # Backfill runtime CLI modules for existing installs
     try:
-        for fname in ("cli.py", "script_registry.py", "skills_runtime.py", "cron_recovery.py", "client_preferences.py", "claude_cli.py", "agent_runner.py", "bootstrap_docs.py", "mcp_required_tools.py"):
+        for fname in ("cli.py", "script_registry.py", "skills_runtime.py", "cron_recovery.py", "client_preferences.py", "claude_cli.py", "agent_runner.py", "bootstrap_docs.py", "mcp_required_tools.py", "runtime_service.py"):
             src_file = SRC_DIR / fname
             dest_file = NEXO_HOME / fname
             if src_file.is_file() and (not dest_file.exists() or src_file.stat().st_mtime > dest_file.stat().st_mtime):

package/src/local_context/api.py

@@ -71,6 +71,47 @@ EMAIL_DOCUMENT_SUFFIXES = {
     ".emlx",
     ".msg",
 }
+HIGH_VALUE_DIRECTORY_NAMES = {
+    "users",
+    "home",
+    "desktop",
+    "documents",
+    "downloads",
+    "documentos",
+    "escritorio",
+    "descargas",
+    "icloud drive",
+    "onedrive",
+    "google drive",
+    "dropbox",
+    "creative cloud files",
+    "clientes",
+    "clients",
+    "facturas",
+    "invoices",
+    "contratos",
+    "contracts",
+    "projects",
+    "proyectos",
+    "work",
+    "trabajo",
+}
+LOW_VALUE_DIRECTORY_NAMES = {
+    "applications",
+    "library",
+    "system",
+    "private",
+    "usr",
+    "var",
+    "opt",
+    "windows",
+    "program files",
+    "program files (x86)",
+    "programdata",
+    "appdata",
+    ".cache",
+    "caches",
+}
 RERANKER_MODEL_SPEC = "cross-encoder-reranker"
 PERFORMANCE_PROFILES: dict[str, dict[str, Any]] = {
     "low": {
@@ -1247,12 +1288,29 @@ def _extraction_priority(path: Path) -> int:
     return 45
 
 
+def _directory_scan_priority(path: Path) -> int:
+    name = path.name.strip().lower()
+    if name in {"users", "home"}:
+        return 0
+    if name in HIGH_VALUE_DIRECTORY_NAMES:
+        return 10
+    if "icloud" in name or "onedrive" in name or "google drive" in name:
+        return 10
+    if is_local_email_tree(str(path)):
+        return 65
+    if name in LOW_VALUE_DIRECTORY_NAMES:
+        return 90
+    return 40
+
+
 def _scan_entry_sort_key(item: Path) -> tuple[int, int, str]:
     try:
         is_file = item.is_file()
     except Exception:
         is_file = False
-    return (0 if not is_file else 1, -_extraction_priority(item) if is_file else 0, str(item).lower())
+    if is_file:
+        return (1, -_extraction_priority(item), str(item).lower())
+    return (0, _directory_scan_priority(item), str(item).lower())
 
 
 def _iter_files(

package/src/runtime_service.py

@@ -0,0 +1,426 @@
+from __future__ import annotations
+"""Resident runtime service and MCP proxy bootstrap.
+
+The public MCP entrypoint remains ``server.py`` for compatibility.  By
+default, that entrypoint becomes a thin stdio proxy and forwards calls to a
+single resident FastMCP service over loopback HTTP.  The resident process is
+the only MCP process that initializes Brain, opens SQLite, and runs tool
+handlers.
+"""
+
+import asyncio
+import json
+import os
+import signal
+import socket
+import subprocess
+import sys
+import time
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
+
+import paths
+
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 17872
+PORT_SCAN_LIMIT = 30
+SERVICE_PATH = "/mcp"
+SERVICE_ENV = "NEXO_RUNTIME_SERVICE"
+DIRECT_ENV = "NEXO_MCP_DIRECT"
+ADAPTER_ENV = "NEXO_MCP_RUNTIME_ADAPTER"
+STATE_FILE = "runtime-service.json"
+LOCK_FILE = "runtime-service.lock"
+LOG_FILE = "runtime-service.log"
+
+
+def env_flag(name: str, *, default: bool = False) -> bool:
+    value = os.environ.get(name)
+    if value is None:
+        return default
+    return str(value).strip().lower() in {"1", "true", "yes", "on", "y", "si"}
+
+
+def service_host() -> str:
+    return str(os.environ.get("NEXO_RUNTIME_HOST", DEFAULT_HOST) or DEFAULT_HOST).strip()
+
+
+def service_path() -> str:
+    raw = str(os.environ.get("NEXO_RUNTIME_MCP_PATH", SERVICE_PATH) or SERVICE_PATH).strip()
+    return raw if raw.startswith("/") else f"/{raw}"
+
+
+def service_url(host: str | None = None, port: int | None = None, path: str | None = None) -> str:
+    return f"http://{host or service_host()}:{int(port or service_port())}{path or service_path()}"
+
+
+def service_state_path() -> Path:
+    root = paths.runtime_state_dir()
+    root.mkdir(parents=True, exist_ok=True)
+    return root / STATE_FILE
+
+
+def service_log_path() -> Path:
+    root = paths.logs_dir()
+    root.mkdir(parents=True, exist_ok=True)
+    return root / LOG_FILE
+
+
+def service_lock_path() -> Path:
+    root = paths.runtime_state_dir()
+    root.mkdir(parents=True, exist_ok=True)
+    return root / LOCK_FILE
+
+
+@contextmanager
+def service_start_lock(*, timeout: float = 10.0):
+    path = service_lock_path()
+    handle = path.open("a+")
+    deadline = time.monotonic() + max(timeout, 0.5)
+    locked = False
+    try:
+        while not locked:
+            try:
+                if os.name == "nt":
+                    import msvcrt
+
+                    handle.seek(0)
+                    if not handle.read(1):
+                        handle.write("0")
+                        handle.flush()
+                    handle.seek(0)
+                    msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+                else:
+                    import fcntl
+
+                    fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+                locked = True
+            except (BlockingIOError, OSError):
+                if time.monotonic() >= deadline:
+                    raise TimeoutError(f"Timed out waiting for NEXO runtime service lock: {path}")
+                time.sleep(0.1)
+        handle.seek(0)
+        handle.truncate()
+        handle.write(f"{os.getpid()}:{time.time()}\n")
+        handle.flush()
+        yield
+    finally:
+        if locked:
+            try:
+                if os.name == "nt":
+                    import msvcrt
+
+                    handle.seek(0)
+                    msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+                else:
+                    import fcntl
+
+                    fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+            except Exception:
+                pass
+        try:
+            handle.close()
+        except Exception:
+            pass
+
+
+def read_service_state() -> dict[str, Any]:
+    try:
+        path = service_state_path()
+        if not path.is_file():
+            return {}
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def write_service_state(state: dict[str, Any]) -> None:
+    path = service_state_path()
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    payload = dict(state)
+    payload.update(current_runtime_identity())
+    payload["updated_at"] = time.time()
+    tmp.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def is_runtime_service_process() -> bool:
+    return env_flag(SERVICE_ENV)
+
+
+def should_use_mcp_adapter() -> bool:
+    if is_runtime_service_process():
+        return False
+    if env_flag(DIRECT_ENV):
+        return False
+    if not env_flag(ADAPTER_ENV, default=True):
+        return False
+    transport = str(os.environ.get("NEXO_MCP_TRANSPORT", "stdio") or "stdio").strip().lower()
+    return transport == "stdio"
+
+
+def service_port() -> int:
+    raw = os.environ.get("NEXO_RUNTIME_PORT")
+    if raw:
+        try:
+            return int(raw)
+        except Exception:
+            pass
+    state = read_service_state()
+    try:
+        port = int(state.get("port") or 0)
+        if port > 0:
+            return port
+    except Exception:
+        pass
+    return DEFAULT_PORT
+
+
+def pid_is_running(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except Exception:
+        return False
+
+
+def _port_is_free(host: str, port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(0.2)
+        try:
+            sock.bind((host, port))
+            return True
+        except OSError:
+            return False
+
+
+def choose_service_port(host: str | None = None) -> int:
+    host = host or service_host()
+    preferred = service_port()
+    for offset in range(PORT_SCAN_LIMIT):
+        port = preferred + offset
+        if _port_is_free(host, port):
+            return port
+    raise RuntimeError(f"No free NEXO runtime service port in range {preferred}-{preferred + PORT_SCAN_LIMIT - 1}")
+
+
+async def _probe_service_async(url: str, *, timeout: float = 1.5) -> bool:
+    from fastmcp import Client
+
+    try:
+        client = Client(url, timeout=timeout, init_timeout=timeout)
+        async with client:
+            return bool(await client.ping())
+    except Exception:
+        return False
+
+
+def probe_service(url: str, *, timeout: float = 1.5) -> bool:
+    try:
+        return bool(asyncio.run(_probe_service_async(url, timeout=timeout)))
+    except RuntimeError:
+        # If an event loop is already active, fall back to a tiny socket probe.
+        try:
+            host_port = url.split("//", 1)[1].split("/", 1)[0]
+            host, port_text = host_port.rsplit(":", 1)
+            with socket.create_connection((host, int(port_text)), timeout=timeout):
+                return True
+        except Exception:
+            return False
+
+
+def current_server_path() -> Path:
+    return Path(__file__).resolve().with_name("server.py")
+
+
+def current_runtime_identity() -> dict[str, str]:
+    try:
+        from runtime_versioning import compute_mcp_runtime_fingerprint, read_version_for_path
+
+        root = current_server_path().parent
+        version = read_version_for_path(root) or read_version_for_path(root.parent)
+        return {
+            "runtime_version": version,
+            "runtime_fingerprint": compute_mcp_runtime_fingerprint(root, use_cache=True),
+            "server_path": str(current_server_path()),
+        }
+    except Exception:
+        return {"runtime_version": "", "runtime_fingerprint": "", "server_path": str(current_server_path())}
+
+
+def state_matches_current_runtime(state: dict[str, Any]) -> bool:
+    if not state:
+        return False
+    current = current_runtime_identity()
+    state_server = str(state.get("server_path") or "").strip()
+    if state_server and state_server != current["server_path"]:
+        return False
+
+    current_fp = str(current.get("runtime_fingerprint") or "").strip()
+    state_fp = str(state.get("runtime_fingerprint") or "").strip()
+    if current_fp and state_fp and current_fp != state_fp:
+        return False
+
+    current_version = str(current.get("runtime_version") or "").strip()
+    state_version = str(state.get("runtime_version") or "").strip()
+    if current_version and state_version and current_version != state_version:
+        return False
+    return True
+
+
+def _terminate_pid(pid: int, *, timeout: float = 3.0) -> dict[str, Any]:
+    if pid <= 0:
+        return {"terminated": False, "reason": "no_pid"}
+    if not pid_is_running(pid):
+        return {"terminated": False, "reason": "not_running"}
+    try:
+        if os.name == "nt":
+            subprocess.run(
+                ["taskkill", "/PID", str(pid), "/T", "/F"],
+                capture_output=True,
+                text=True,
+                timeout=max(timeout, 1.0),
+            )
+        else:
+            os.kill(pid, signal.SIGTERM)
+            deadline = time.monotonic() + max(timeout, 0.2)
+            while time.monotonic() < deadline:
+                if not pid_is_running(pid):
+                    return {"terminated": True, "pid": pid, "signal": "SIGTERM"}
+                time.sleep(0.1)
+            if hasattr(signal, "SIGKILL"):
+                os.kill(pid, signal.SIGKILL)
+        return {"terminated": True, "pid": pid}
+    except Exception as exc:
+        return {"terminated": False, "pid": pid, "error": str(exc)[:300]}
+
+
+def stop_runtime_service(*, reason: str = "stop", timeout: float = 3.0) -> dict[str, Any]:
+    state = read_service_state()
+    pid = int(state.get("pid") or 0) if str(state.get("pid") or "").isdigit() else 0
+    result = _terminate_pid(pid, timeout=timeout)
+    result["reason"] = reason
+    result["state_path"] = str(service_state_path())
+    try:
+        service_state_path().unlink(missing_ok=True)
+        result["state_removed"] = True
+    except Exception as exc:
+        result["state_removed"] = False
+        result["state_error"] = str(exc)[:300]
+    return result
+
+
+def _service_env(port: int, host: str) -> dict[str, str]:
+    env = os.environ.copy()
+    env[SERVICE_ENV] = "1"
+    env["NEXO_MCP_TRANSPORT"] = "streamable-http"
+    env["NEXO_MCP_HOST"] = host
+    env["NEXO_MCP_PORT"] = str(port)
+    env["NEXO_MCP_PATH"] = service_path()
+    # A probe client may inherit a deliberately tiny plugin mode.  The service
+    # should use the normal runtime defaults unless explicitly overridden.
+    if "NEXO_RUNTIME_SERVICE_PLUGIN_MODE" in env:
+        env["NEXO_MCP_PLUGIN_MODE"] = env["NEXO_RUNTIME_SERVICE_PLUGIN_MODE"]
+    return env
+
+
+def _spawn_service_process(port: int, host: str) -> subprocess.Popen:
+    log_path = service_log_path()
+    log_file = open(log_path, "ab", buffering=0)
+    kwargs: dict[str, Any] = {
+        "cwd": str(current_server_path().parent),
+        "env": _service_env(port, host),
+        "stdin": subprocess.DEVNULL,
+        "stdout": log_file,
+        "stderr": log_file,
+    }
+    if os.name == "nt":
+        kwargs["creationflags"] = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
+    else:
+        kwargs["start_new_session"] = True
+    return subprocess.Popen([sys.executable, str(current_server_path())], **kwargs)
+
+
+def ensure_runtime_service(*, wait_seconds: float = 10.0) -> str:
+    with service_start_lock(timeout=wait_seconds):
+        host = service_host()
+        state = read_service_state()
+        state_url = str(state.get("url") or "")
+        state_pid = int(state.get("pid") or 0) if str(state.get("pid") or "").isdigit() else 0
+        if state_url and (state_pid <= 0 or pid_is_running(state_pid)):
+            if state_matches_current_runtime(state) and probe_service(state_url):
+                return state_url
+            if state_pid > 0:
+                stop_runtime_service(reason="stale_runtime")
+
+        port = choose_service_port(host)
+        url = service_url(host, port)
+        proc = _spawn_service_process(port, host)
+        write_service_state(
+            {
+                "pid": proc.pid,
+                "port": port,
+                "host": host,
+                "path": service_path(),
+                "url": url,
+                "server_path": str(current_server_path()),
+                "started_at": time.time(),
+                "mode": "runtime-service",
+            }
+        )
+
+        deadline = time.monotonic() + max(wait_seconds, 0.5)
+        delay = 0.15
+        while time.monotonic() < deadline:
+            if proc.poll() is not None:
+                break
+            if probe_service(url):
+                return url
+            time.sleep(delay)
+            delay = min(delay * 1.5, 1.0)
+
+        code = proc.poll()
+        raise RuntimeError(
+            "NEXO runtime service did not become ready"
+            + (f" (exit={code})" if code is not None else "")
+            + f"; log={service_log_path()}"
+        )
+
+
+def runtime_service_status() -> dict[str, Any]:
+    state = read_service_state()
+    current = current_runtime_identity()
+    url = str(state.get("url") or "")
+    pid = int(state.get("pid") or 0) if str(state.get("pid") or "").isdigit() else 0
+    alive = pid_is_running(pid)
+    ready = bool(url and probe_service(url, timeout=0.8))
+    return {
+        "ok": ready,
+        "mode": "service" if is_runtime_service_process() else "adapter",
+        "pid": pid,
+        "pid_alive": alive,
+        "url": url,
+        "stale": bool(state and not state_matches_current_runtime(state)),
+        "runtime_version": current.get("runtime_version", ""),
+        "runtime_fingerprint": current.get("runtime_fingerprint", ""),
+        "state_runtime_version": str(state.get("runtime_version") or ""),
+        "state_runtime_fingerprint": str(state.get("runtime_fingerprint") or ""),
+        "state_path": str(service_state_path()),
+        "log_path": str(service_log_path()),
+        "server_path": str(current_server_path()),
+    }
+
+
+def run_mcp_proxy_adapter(*, name: str, instructions: str, run_kwargs: dict[str, Any]) -> None:
+    from fastmcp.server import create_proxy
+
+    url = ensure_runtime_service()
+    proxy = create_proxy(url, name=name, instructions=instructions)
+    proxy.run(**run_kwargs)

package/src/runtime_versioning.py

@@ -732,6 +732,16 @@ def build_mcp_status(*, client: str = "") -> dict:
     marker = state["marker"]
     installed_fp = state.get("installed_fingerprint", "")
     process_fp = state.get("process_fingerprint", "")
+    try:
+        from runtime_service import runtime_service_status
+
+        service_status = runtime_service_status()
+    except Exception as exc:
+        service_status = {
+            "ok": False,
+            "error": "runtime_service_status_unavailable",
+            "message": str(exc)[:300],
+        }
     return {
         "ok": True,
         "schema_version": MCP_STATUS_SCHEMA_VERSION,
@@ -755,6 +765,7 @@ def build_mcp_status(*, client: str = "") -> dict:
         "marker_exists": bool(marker.get("exists")),
         "marker_corrupt": bool(marker.get("corrupt")),
         "continuity_api_level": CONTINUITY_API_LEVEL,
+        "runtime_service": service_status,
         "version_match": (
             bool(state["installed_version"])
             and bool(state["process_version"])

package/src/server.py

@@ -117,6 +117,13 @@ from runtime_versioning import (
     prime_process_fingerprint,
     prime_process_version,
 )
+from runtime_service import (
+    is_runtime_service_process,
+    run_mcp_proxy_adapter,
+    runtime_service_status,
+    should_use_mcp_adapter,
+    write_service_state,
+)
 from local_context import api as local_context_api
 from local_context.db import close_local_context_db
 
@@ -766,6 +773,12 @@ def nexo_status(keyword: str = "") -> str:
     return handle_status(keyword if keyword else None)
 
 
+@mcp.tool
+def nexo_runtime_service_status() -> str:
+    """Return the resident NEXO Runtime Service status for diagnostics."""
+    return json.dumps(runtime_service_status(), indent=2, ensure_ascii=False)
+
+
 @mcp.tool
 def nexo_local_index_status() -> str:
     """Return local memory index status for Desktop settings and support diagnostics."""
@@ -2300,5 +2313,32 @@ def nexo_create_app_token(
 
 
 if __name__ == "__main__":
-    _server_init()
-    mcp.run(**_run_kwargs_from_env())
+    if should_use_mcp_adapter():
+        run_mcp_proxy_adapter(
+            name="nexo",
+            instructions=render_core_prompt(
+                "server-mcp-instructions",
+                assistant_name=_get_ctx().assistant_name,
+            ),
+            run_kwargs=_run_kwargs_from_env(),
+        )
+    else:
+        _server_init()
+        run_kwargs = _run_kwargs_from_env()
+        if is_runtime_service_process():
+            host = str(run_kwargs.get("host") or os.environ.get("NEXO_MCP_HOST", "127.0.0.1"))
+            port = int(run_kwargs.get("port") or os.environ.get("NEXO_MCP_PORT", "0") or 0)
+            path = str(run_kwargs.get("path") or os.environ.get("NEXO_MCP_PATH", "/mcp"))
+            write_service_state(
+                {
+                    "pid": os.getpid(),
+                    "port": port,
+                    "host": host,
+                    "path": path,
+                    "url": f"http://{host}:{port}{path}",
+                    "server_path": str(os.path.abspath(__file__)),
+                    "started_at": time.time(),
+                    "mode": "runtime-service",
+                }
+            )
+        mcp.run(**run_kwargs)

package/tool-enforcement-map.json

@@ -2383,6 +2383,21 @@
       },
       "triggers_after": []
     },
+    "nexo_runtime_service_status": {
+      "description": "Return resident Runtime Service health, PID, version, fingerprint and state paths",
+      "category": "system",
+      "source": "server",
+      "requires": [],
+      "provides": [
+        "runtime_service_status"
+      ],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
     "nexo_media_memory_add": {
       "description": "Store non-text artifact metadata",
       "category": "media",