nexo-brain 2.6.16 → 2.6.18

package/.claude-plugin/plugin.json

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

@@ -38,11 +38,17 @@ That means NEXO now manages not only the shared runtime and MCP wiring, but also
 - For Codex specifically, `nexo chat` and Codex headless automation inject the current bootstrap explicitly, so Codex starts as NEXO even when plain global Codex startup is inconsistent about global instructions.
 - Deep Sleep now reads both Claude Code and Codex transcript stores, so overnight analysis still works even when the user spends the day in Codex.
 
-Version `2.6.14` closes those parity gaps in practice, `2.6.15` hardens the installed-runtime migration path so existing users actually receive the managed bootstrap updates cleanly, and `2.6.16` pushes the system further in three directions:
+Version `2.6.14` closes those parity gaps in practice, `2.6.15` hardens the installed-runtime migration path so existing users actually receive the managed bootstrap updates cleanly, `2.6.16` pushes the system further in three directions, `2.6.17` finishes the annoying last-mile migration bugs for real existing installs, and `2.6.18` tightens the remaining practical gaps around manual Codex use, Deep Sleep horizon artifacts, and retrieval honesty:
 
 - Codex now gets managed global bootstrap/model sync in `~/.codex/config.toml`, so sessions opened outside `nexo chat` are much less likely to start as plain Codex.
+- Codex config now also persists a managed `mcp_servers.nexo` entry, so the shared brain survives even if ad-hoc Codex MCP state drifts.
+- Runtime doctor now audits recent Codex sessions for real startup discipline and verifies Claude Desktop shared-brain metadata explicitly instead of treating both as invisible best-effort wiring.
 - Retrieval is smarter by default: HyDE and spreading activation now auto-enable when the query shape benefits, while exact lookups remain conservative.
+- Retrieval explanations now surface confidence and the auto-strategy that fired, while associative expansion trims itself back to `top_k` instead of leaking low-signal neighbors.
 - Deep Sleep now blends recent context with older context over a 60-day horizon, and memory decay now tracks per-memory `stability` and `difficulty` instead of relying only on global decay constants.
+- Deep Sleep now also carries project-priority weighting into its long-horizon context and writes reusable weekly/monthly summary artifacts instead of reasoning only day by day.
+- Existing installs that already had NEXO connected to Codex now backfill that client state automatically during update/sync, so the managed Codex bootstrap actually lands without manual cleanup.
+- Bootstrap docs now fall back to the operator name `NEXO` when local metadata is blank, avoiding broken headings in `CLAUDE.md` and `AGENTS.md`.
 
 ### Client Capability Matrix
 
@@ -50,11 +56,12 @@ Version `2.6.14` closes those parity gaps in practice, `2.6.15` hardens the inst
 |------------|-------------|-------|----------------|
 | Shared brain / MCP runtime | Yes | Yes | Yes |
 | Managed bootstrap document | `~/.claude/CLAUDE.md` | `~/.codex/AGENTS.md` | Not applicable |
-| Global startup bootstrap sync | Native via hooks + bootstrap | Managed via bootstrap + Codex config `initial_messages` | MCP only |
+| Global startup bootstrap sync | Native via hooks + bootstrap | Managed via bootstrap + Codex config `initial_messages` + `mcp_servers.nexo` | Managed MCP-only shared-brain metadata |
 | `nexo chat` terminal client | Yes | Yes | No |
 | Background automation backend | Recommended | Supported | No |
 | Raw transcript source for Deep Sleep | Yes | Yes | No |
 | Native hook depth | Deepest | Partial, compensated | None |
+| Runtime doctor parity audit | Yes | Yes | Shared-brain only |
 | Recommended today | Yes | Supported | Shared-brain companion |
 
 ## The Problem
@@ -191,6 +198,9 @@ Deep Sleep now also mixes **recent context with older context across a 60-day ho
 - recurring multi-week themes
 - cross-domain links between older learnings and current failures
 - stale followups and topics that keep being mentioned but never formalized
+- weighted project pressure based on diary activity, followups, learnings, and decision outcomes
+
+It now also writes **weekly and monthly Deep Sleep summaries** so the overnight system can reuse higher-horizon signals instead of rediscovering everything from scratch every day.
 
 ## Cognitive Cortex
 

package/package.json

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

@@ -1434,10 +1434,19 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
 
         schedule_path = dest / "config" / "schedule.json"
         schedule_payload = json.loads(schedule_path.read_text()) if schedule_path.exists() else {}
+        normalized_preferences = normalize_client_preferences(schedule_payload)
+        if normalized_preferences != {
+            key: schedule_payload.get(key)
+            for key in normalized_preferences
+        }:
+            merged_schedule = dict(schedule_payload)
+            merged_schedule.update(normalized_preferences)
+            schedule_path.parent.mkdir(parents=True, exist_ok=True)
+            schedule_path.write_text(json.dumps(merged_schedule, indent=2, ensure_ascii=False) + "\n")
         client_sync_result = sync_all_clients(
             nexo_home=dest,
             runtime_root=dest,
-            preferences=normalize_client_preferences(schedule_payload),
+            preferences=normalized_preferences,
         )
         if client_sync_result.get("ok"):
             actions.append("client-sync")

package/src/bootstrap_docs.py

@@ -73,7 +73,9 @@ def _resolve_operator_name(nexo_home: Path, explicit: str = "") -> str:
     version_file = nexo_home / "version.json"
     if version_file.is_file():
         try:
-            return str(json.loads(version_file.read_text()).get("operator_name", "")).strip()
+            candidate = str(json.loads(version_file.read_text()).get("operator_name", "")).strip()
+            if candidate:
+                return candidate
         except Exception:
             pass
     return "NEXO"

package/src/client_preferences.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import os
 import shutil
 import sys
+import tomllib
 from pathlib import Path
 
 from runtime_power import load_schedule_config, save_schedule_config
@@ -51,6 +52,14 @@ def _user_home() -> Path:
     return Path(os.environ.get("HOME", str(Path.home()))).expanduser()
 
 
+def _codex_config_path(home: Path) -> Path:
+    return home / ".codex" / "config.toml"
+
+
+def _codex_bootstrap_path(home: Path) -> Path:
+    return home / ".codex" / "AGENTS.md"
+
+
 def _coerce_bool(value, default: bool) -> bool:
     if isinstance(value, bool):
         return value
@@ -127,6 +136,56 @@ def normalize_interactive_clients(value) -> dict[str, bool]:
     return normalized
 
 
+def _codex_artifacts_suggest_nexo_management(home: Path) -> bool:
+    bootstrap_path = _codex_bootstrap_path(home)
+    if bootstrap_path.is_file():
+        try:
+            bootstrap_text = bootstrap_path.read_text()
+        except Exception:
+            bootstrap_text = ""
+        if (
+            "nexo-codex-agents-version:" in bootstrap_text
+            or "NEXO Shared Brain for Codex" in bootstrap_text
+            or "<!-- nexo:core:start -->" in bootstrap_text
+        ):
+            return True
+
+    config_path = _codex_config_path(home)
+    if not config_path.is_file():
+        return False
+
+    try:
+        payload = tomllib.loads(config_path.read_text())
+    except Exception:
+        try:
+            raw_text = config_path.read_text()
+        except Exception:
+            return False
+        return "[mcp_servers.nexo]" in raw_text or "[nexo.codex]" in raw_text
+
+    if not isinstance(payload, dict):
+        return False
+    mcp_servers = payload.get("mcp_servers")
+    if isinstance(mcp_servers, dict) and "nexo" in mcp_servers:
+        return True
+    nexo_table = payload.get("nexo")
+    if isinstance(nexo_table, dict) and "codex" in nexo_table:
+        return True
+    return False
+
+
+def _backfill_interactive_clients(
+    interactive_clients: dict[str, bool],
+    *,
+    user_home: str | os.PathLike[str] | None = None,
+) -> dict[str, bool]:
+    normalized = dict(interactive_clients)
+    home = Path(user_home).expanduser() if user_home else _user_home()
+    if not normalized.get(CLIENT_CODEX, False) and _codex_artifacts_suggest_nexo_management(home):
+        normalized[CLIENT_CODEX] = True
+    return normalized
+
+
 def normalize_default_terminal_client(value, interactive_clients: dict[str, bool] | None = None) -> str:
     interactive_clients = normalize_interactive_clients(interactive_clients or {})
     candidate = normalize_client_key(value)
@@ -210,9 +269,16 @@ def normalize_client_runtime_profiles(value) -> dict[str, dict[str, str]]:
     return normalized
 
 
-def normalize_client_preferences(schedule: dict | None = None) -> dict:
+def normalize_client_preferences(
+    schedule: dict | None = None,
+    *,
+    user_home: str | os.PathLike[str] | None = None,
+) -> dict:
     schedule = dict(schedule or {})
-    interactive_clients = normalize_interactive_clients(schedule.get("interactive_clients"))
+    interactive_clients = _backfill_interactive_clients(
+        normalize_interactive_clients(schedule.get("interactive_clients")),
+        user_home=user_home,
+    )
     automation_enabled = normalize_automation_enabled(schedule.get("automation_enabled"))
     default_terminal_client = normalize_default_terminal_client(
         schedule.get("default_terminal_client"),

package/src/client_sync.py

@@ -80,10 +80,12 @@ def _resolve_operator_name(nexo_home: Path, explicit: str = "") -> str:
     version_file = nexo_home / "version.json"
     if version_file.is_file():
         try:
-            return str(json.loads(version_file.read_text()).get("operator_name", "")).strip()
+            candidate = str(json.loads(version_file.read_text()).get("operator_name", "")).strip()
+            if candidate:
+                return candidate
         except Exception:
             pass
-    return ""
+    return "NEXO"
 
 
 def _resolve_runtime_root(nexo_home: Path, runtime_root: str | os.PathLike[str] | None = None) -> Path:
@@ -241,10 +243,12 @@ def _sync_codex_managed_config(
     *,
     bootstrap_prompt: str,
     runtime_profile: dict | None,
+    server_config: dict | None,
 ) -> dict:
     payload = _load_toml_object(path)
     action = "updated" if payload else "created"
     runtime_profile = dict(runtime_profile or {})
+    server_config = dict(server_config or {})
 
     if runtime_profile.get("model"):
         payload["model"] = runtime_profile["model"]
@@ -261,10 +265,19 @@ def _sync_codex_managed_config(
     nexo_table = payload.setdefault("nexo", {})
     codex_table = nexo_table.setdefault("codex", {})
     codex_table["bootstrap_managed"] = True
+    codex_table["mcp_managed"] = True
     codex_table["bootstrap_bytes"] = len(bootstrap_prompt.encode("utf-8")) if bootstrap_prompt else 0
     if runtime_profile.get("model"):
         codex_table["managed_model"] = runtime_profile["model"]
     codex_table["managed_reasoning_effort"] = runtime_profile.get("reasoning_effort", "") or ""
+    if server_config:
+        mcp_servers = payload.setdefault("mcp_servers", {})
+        mcp_servers["nexo"] = {
+            "command": server_config.get("command", ""),
+            "args": list(server_config.get("args", []) or []),
+            "env": dict(server_config.get("env", {}) or {}),
+        }
+        codex_table["managed_server_command"] = server_config.get("command", "")
 
     _write_toml_object(path, payload)
     return {
@@ -272,6 +285,7 @@ def _sync_codex_managed_config(
         "action": action,
         "path": str(path),
         "bootstrap_managed": True,
+        "mcp_managed": True,
         "model": runtime_profile.get("model", ""),
         "reasoning_effort": runtime_profile.get("reasoning_effort", "") or "",
     }
@@ -294,7 +308,7 @@ def _write_json_object(path: Path, payload: dict) -> None:
     path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
 
 
-def _sync_json_client(path: Path, server_config: dict, label: str) -> dict:
+def _sync_json_client(path: Path, server_config: dict, label: str, *, managed_metadata: dict | None = None) -> dict:
     payload = _load_json_object(path)
     mcp_servers = payload.setdefault("mcpServers", {})
     if not isinstance(mcp_servers, dict):
@@ -302,6 +316,12 @@ def _sync_json_client(path: Path, server_config: dict, label: str) -> dict:
         payload["mcpServers"] = mcp_servers
     action = "updated" if "nexo" in mcp_servers else "created"
     mcp_servers["nexo"] = server_config
+    if managed_metadata is not None:
+        nexo_meta = payload.setdefault("nexo", {})
+        if not isinstance(nexo_meta, dict):
+            nexo_meta = {}
+            payload["nexo"] = nexo_meta
+        nexo_meta.update(managed_metadata)
     _write_json_object(path, payload)
     return {
         "ok": True,
@@ -311,6 +331,18 @@ def _sync_json_client(path: Path, server_config: dict, label: str) -> dict:
     }
 
 
+def _claude_desktop_managed_metadata(server_config: dict, *, operator_name: str) -> dict:
+    return {
+        "claude_desktop": {
+            "shared_brain_managed": True,
+            "shared_brain_mode": "mcp_only",
+            "managed_operator": operator_name or server_config.get("env", {}).get("NEXO_NAME", "") or "NEXO",
+            "managed_runtime_home": server_config.get("env", {}).get("NEXO_HOME", ""),
+            "managed_runtime_root": server_config.get("env", {}).get("NEXO_CODE", ""),
+        }
+    }
+
+
 def sync_claude_code(
     *,
     nexo_home: str | os.PathLike[str] | None = None,
@@ -359,10 +391,15 @@ def sync_claude_desktop(
         python_path=python_path,
         operator_name=operator_name,
     )
+    resolved_name = server_config.get("env", {}).get("NEXO_NAME", "") or _resolve_operator_name(
+        Path(nexo_home).expanduser() if nexo_home else _default_nexo_home(),
+        explicit=operator_name,
+    )
     return _sync_json_client(
         _claude_desktop_config_path(Path(user_home).expanduser() if user_home else None),
         server_config,
         "claude_desktop",
+        managed_metadata=_claude_desktop_managed_metadata(server_config, operator_name=resolved_name),
     )
 
 
@@ -408,6 +445,7 @@ def sync_codex(
                 config_path,
                 bootstrap_prompt=prompt_text,
                 runtime_profile=runtime_profile,
+                server_config=server_config,
             )
         return result
 
@@ -423,29 +461,12 @@ def sync_codex(
         timeout=30,
         env=env,
     )
-    if result.returncode != 0:
-        result = {
-            "ok": False,
-            "client": "codex",
-            "path": str(config_path),
-            "error": (result.stderr or result.stdout or "codex mcp add failed").strip(),
-        }
-        bootstrap_result = sync_client_bootstrap(
-            "codex",
-            nexo_home=nexo_home,
-            operator_name=operator_name,
-            user_home=user_home,
-        )
-        result["bootstrap"] = bootstrap_result
-        if not bootstrap_result.get("ok"):
-            result["error"] = f"{result['error']}; bootstrap: {bootstrap_result.get('error', 'unknown error')}"
-        return result
     sync_result = {
         "ok": True,
         "client": "codex",
         "action": "updated",
         "path": str(config_path),
-        "mode": "cli",
+        "mode": "cli" if result.returncode == 0 else "config_only",
     }
     bootstrap_result = sync_client_bootstrap(
         "codex",
@@ -462,7 +483,10 @@ def sync_codex(
         config_path,
         bootstrap_prompt=bootstrap_result.get("content") or "",
         runtime_profile=runtime_profile,
+        server_config=server_config,
     )
+    if result.returncode != 0:
+        sync_result["warning"] = (result.stderr or result.stdout or "codex mcp add failed").strip()
     return sync_result
 
 

package/src/cognitive/_search.py

@@ -159,6 +159,7 @@ _HISTORICAL_CUES = frozenset({
 _EXACT_LOOKUP_RE = re.compile(
     r"(/|\\|::|\.[A-Za-z0-9]+|#L\d+|line \d+|error[: ]|exception|traceback|0x[0-9a-fA-F]+|[A-Z]{2,}-\d+)"
 )
+_MIN_NEIGHBOR_BOOST = 0.035
 
 
 def _apply_temporal_boost(results: list[dict], query_text: str) -> list[dict]:
@@ -254,6 +255,14 @@ def _auto_spreading_depth(query_text: str, source_type_filter: str = "") -> int:
     return 0
 
 
+def _result_confidence(score: float) -> str:
+    if score >= 0.82:
+        return "high"
+    if score >= 0.66:
+        return "medium"
+    return "low"
+
+
 # ============================================================================
 # FEATURE 0.5: Knowledge Graph Boost
 # Memories connected to more KG nodes (files, areas, other learnings) are
@@ -928,13 +937,23 @@ def search(
                     r["co_activation_boost"] = boost
 
             # Add neighbor memories not already in results
-            new_neighbor_hashes = set(neighbor_boosts.keys()) - existing_hashes
+            new_neighbor_hashes = {
+                nh
+                for nh, boost in neighbor_boosts.items()
+                if nh not in existing_hashes and boost >= _MIN_NEIGHBOR_BOOST
+            }
             if new_neighbor_hashes:
+                ranked_new_neighbors = sorted(
+                    new_neighbor_hashes,
+                    key=lambda nh: neighbor_boosts.get(nh, 0.0),
+                    reverse=True,
+                )[: max(1, min(3, top_k // 3 or 1))]
+                allowed_new_neighbors = set(ranked_new_neighbors)
                 for store_name, table in [("stm", "stm_memories"), ("ltm", "ltm_memories")]:
                     rows = db.execute(f"SELECT * FROM {table}").fetchall()
                     for row in rows:
                         nh = _canonical_co_id(store_name, row["id"])
-                        if nh in new_neighbor_hashes:
+                        if nh in allowed_new_neighbors:
                             boost = neighbor_boosts[nh]
                             results.append({
                                 "store": store_name,
@@ -951,10 +970,11 @@ def search(
                                 "co_activation_boost": boost,
                                 "lifecycle_state": row.get("lifecycle_state", "active"),
                             })
-                            new_neighbor_hashes.discard(nh)
+                            allowed_new_neighbors.discard(nh)
 
             # Re-sort after applying boosts
             results.sort(key=lambda x: x["score"], reverse=True)
+            results = results[:top_k]
 
     # Add rank explanations
     for rank, r in enumerate(results, 1):
@@ -970,6 +990,7 @@ def search(
         if resolved_use_hyde:
             ranking_desc = "hyde_centroid_similarity"
         parts = [f"Ranked #{rank}: {ranking_desc}={score:.3f}"]
+        parts.append(f"confidence={_result_confidence(score)}")
         parts.append(f"store={store}, strength={strength:.2f}, accesses={access_count}")
         if r.get("kg_boost"):
             parts.append(f"kg_boost=+{r['kg_boost']:.3f} ({r.get('kg_connections', 0)} edges)")
@@ -979,6 +1000,12 @@ def search(
             parts.append("hyde=auto")
         if spreading_depth is None and resolved_spreading_depth > 0:
             parts.append(f"spreading=auto:{resolved_spreading_depth}")
+        if use_hyde is None and resolved_use_hyde and spreading_depth is None and resolved_spreading_depth > 0:
+            parts.append("auto_strategy=semantic+associative recall")
+        elif use_hyde is None and resolved_use_hyde:
+            parts.append("auto_strategy=semantic expansion")
+        elif spreading_depth is None and resolved_spreading_depth > 0:
+            parts.append("auto_strategy=associative expansion")
         if created:
             parts.append(f"created={created[:10]}")
         if tags: