nexo-brain 2.6.15 → 2.6.17

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.15",
+  "version": "2.6.17",
   "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,7 +38,26 @@ 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, and `2.6.15` hardens the installed-runtime migration path so existing users actually receive the managed bootstrap updates cleanly.
+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, and `2.6.17` finishes the annoying last-mile migration bugs for real existing installs:
+
+- 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.
+- Retrieval is smarter by default: HyDE and spreading activation now auto-enable when the query shape benefits, while exact lookups remain conservative.
+- 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.
+- 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
+
+| Capability | Claude Code | Codex | Claude Desktop |
+|------------|-------------|-------|----------------|
+| 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 |
+| `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 |
+| Recommended today | Yes | Supported | Shared-brain companion |
 
 ## The Problem
 
@@ -100,12 +119,25 @@ NEXO Brain uses **Ebbinghaus forgetting curves** — memories naturally fade ove
 - A lesson accessed 5 times in 2 weeks gets promoted to long-term memory — because repeated use proves it matters.
 - A dormant memory can be reactivated if something similar comes up — the "oh wait, I remember this" moment.
 
+On top of that baseline, NEXO now keeps a lightweight **per-memory profile**:
+
+- **stability** slows decay for memories that keep surviving retrieval and reinforcement
+- **difficulty** speeds decay slightly for memories that tend to be weak, noisy, or harder to reuse correctly
+
+That keeps the core Ebbinghaus model, but makes decay more individual and less purely global.
+
 ### Semantic Search (Finding by Meaning)
 
 NEXO Brain doesn't search by keywords. It searches by **meaning** using vector embeddings (fastembed, 768 dimensions).
 
 Example: If you search for "deploy problems", NEXO Brain will find a memory about "SSH connection timeout on production server" — even though they share zero words. This is how human associative memory works.
 
+Retrieval is now also smarter by default:
+
+- **HyDE auto mode** expands conceptual or ambiguous queries when that improves recall
+- **Spreading activation auto mode** adds a shallow associative boost for concept-heavy searches
+- **Exact lookup heuristics** keep both off for literal file paths, IDs, stack traces, and other precision-sensitive queries
+
 ### Metacognition (Thinking About Thinking)
 
 Before every code change, NEXO Brain asks itself: **"Have I made a mistake like this before?"**
@@ -156,6 +188,12 @@ Like a human brain, NEXO Brain has automated processes that run while you're not
 
 If your Mac was asleep during any scheduled process, NEXO Brain catches up in order when it wakes.
 
+Deep Sleep now also mixes **recent context with older context across a 60-day horizon**. Instead of only looking at the immediate past, it can surface:
+
+- recurring multi-week themes
+- cross-domain links between older learnings and current failures
+- stale followups and topics that keep being mentioned but never formalized
+
 ## Cognitive Cortex
 
 The Cortex is a middleware cognitive layer that makes the agent **think before acting**. It implements architectural inhibitory control — the agent cannot bypass reasoning.
@@ -235,21 +273,21 @@ NEXO Brain provides **150+ MCP tools** across 23 categories. These features impl
 |---------|-------------|
 | **Pin / Snooze / Archive** | Granular lifecycle states for memories. Pin = never decays (critical knowledge). Snooze = temporarily hidden (revisit later). Archive = cold storage (searchable but inactive). |
 | **Intelligent Chunking** | Adaptive chunking that respects sentence and paragraph boundaries. Produces semantically coherent chunks instead of arbitrary token splits, reducing retrieval noise. |
-| **Adaptive Decay** | Decay rate adapts per memory based on access patterns: frequently-accessed memories decay slower, rarely-accessed ones fade faster. Prevents permanent clutter while keeping active knowledge sharp. |
+| **Adaptive Decay** | Decay rate still follows Ebbinghaus as the base model, but now also adapts per memory using `stability` and `difficulty` profiles. Frequently reinforced memories become stickier; fragile memories fade sooner. |
 | **Auto-Migration** | Formal schema migration system (schema_migrations table) tracks all database changes. Safe, reversible schema evolution for production systems — upgrades never lose data. |
 | **Auto-Merge Duplicates** | Batch cosine deduplication during the 03:00 sleep cycle. Respects sibling discrimination — similar memories about different contexts are kept separate. |
-| **Memory Dreaming** | Discovers hidden connections between recent memories during the 03:00 sleep cycle. Surfaces non-obvious patterns like "these three bugs all relate to the same root cause." |
+| **Memory Dreaming** | Discovers hidden connections between recent memories during the 03:00 sleep cycle and now feeds a 60-day long-horizon Deep Sleep blend, so older patterns can reappear when they become relevant again. |
 
 ### Retrieval
 
 | Feature | What It Does |
 |---------|-------------|
-| **HyDE Query Expansion** | Generates hypothetical answer embeddings for richer semantic search. Instead of searching for "deploy error", it imagines what a helpful memory about deploy errors would look like, then searches for that. |
+| **HyDE Query Expansion** | Generates hypothetical answer embeddings for richer semantic search. NEXO now auto-enables HyDE for conceptual or ambiguous queries while keeping literal lookups conservative. |
 | **Hybrid Search (FTS5+BM25+RRF)** | Combines dense vector search with BM25 keyword search via Reciprocal Rank Fusion. Outperforms pure semantic search on precise terminology and code identifiers. |
 | **Cross-Encoder Reranking** | After initial vector retrieval, a cross-encoder model rescores candidates for precision. The top-k results are reordered by true semantic relevance before being returned to the agent. |
 | **Multi-Query Decomposition** | Complex questions are automatically split into sub-queries. Each component is retrieved independently, then fused for a higher-quality answer — improves recall on multi-faceted prompts. |
 | **Temporal Indexing** | Memories are indexed by time in addition to semantics. Time-sensitive queries ("what did we decide last Tuesday?") use temporal proximity scoring alongside semantic similarity. |
-| **Spreading Activation** | Graph-based co-activation network. Memories retrieved together reinforce each other's connections, building an associative web that improves over time. |
+| **Spreading Activation** | Graph-based co-activation network. NEXO now auto-enables a shallow spreading pass for concept-heavy queries, improving contextual recall without turning every exact lookup into a fuzzy search. |
 | **Recall Explanations** | Transparent score breakdown for every retrieval result. Shows exactly why a memory was returned: semantic similarity, recency, access frequency, and co-activation bonuses. |
 
 ### Proactive

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.15",
+  "version": "2.6.17",
   "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/agent_runner.py

@@ -4,9 +4,11 @@ from __future__ import annotations
 
 import json
 import os
+import shlex
 import shutil
 import subprocess
 import tempfile
+import tomllib
 from pathlib import Path
 
 from client_preferences import (
@@ -66,6 +68,10 @@ def _resolve_codex_cli() -> str:
     return shutil.which("codex") or ""
 
 
+def _codex_config_path() -> Path:
+    return Path.home() / ".codex" / "config.toml"
+
+
 def _headless_env(env: dict | None = None) -> dict:
     merged = os.environ.copy()
     if env:
@@ -84,6 +90,21 @@ def _load_client_bootstrap_prompt(client: str) -> str:
     return load_bootstrap_prompt(client, nexo_home=NEXO_HOME, user_home=Path.home())
 
 
+def _codex_managed_initial_messages_enabled() -> bool:
+    config_path = _codex_config_path()
+    if not config_path.is_file():
+        return False
+    try:
+        payload = tomllib.loads(config_path.read_text())
+    except Exception:
+        return False
+    return bool(
+        payload.get("nexo", {})
+        .get("codex", {})
+        .get("bootstrap_managed")
+    )
+
+
 def _codex_initial_messages_config(prompt_text: str) -> str:
     return f'initial_messages=[{{role="system",content={json.dumps(prompt_text, ensure_ascii=False)}}}]'
 
@@ -121,7 +142,7 @@ def build_interactive_client_command(
             )
         cmd = [codex_bin]
         bootstrap_prompt = _load_client_bootstrap_prompt(CLIENT_CODEX)
-        if bootstrap_prompt:
+        if bootstrap_prompt and not _codex_managed_initial_messages_enabled():
             cmd.extend(["-c", _codex_initial_messages_config(bootstrap_prompt)])
         if profile["model"]:
             cmd.extend(["-m", profile["model"]])
@@ -147,6 +168,53 @@ def launch_interactive_client(
     return subprocess.run(cmd, env=launch_env)
 
 
+def build_followup_terminal_shell_command(
+    followup_reference: str,
+    *,
+    client: str | None = None,
+    preferences: dict | None = None,
+    cwd: str | os.PathLike[str] | None = None,
+) -> tuple[str, str]:
+    prefs = preferences or load_client_preferences()
+    selected = resolve_terminal_client(client, preferences=prefs)
+    profile = resolve_client_runtime_profile(selected, preferences=prefs)
+    prompt = f"NEXO: execute followup from file $(cat {followup_reference})"
+
+    if selected == CLIENT_CLAUDE_CODE:
+        claude_bin = _resolve_claude_cli()
+        if not claude_bin:
+            raise TerminalClientUnavailableError(
+                "Claude Code launcher not found in PATH. Install `claude` first."
+            )
+        cmd = [claude_bin]
+        if profile["model"]:
+            cmd.extend(["--model", profile["model"]])
+        if profile["reasoning_effort"]:
+            cmd.extend(["--effort", profile["reasoning_effort"]])
+        cmd.extend(["--dangerously-skip-permissions", prompt])
+        return selected, shlex.join(cmd)
+
+    if selected == CLIENT_CODEX:
+        codex_bin = _resolve_codex_cli()
+        if not codex_bin:
+            raise TerminalClientUnavailableError(
+                "Codex launcher not found in PATH. Install `codex` first or reconfigure NEXO."
+            )
+        target_cwd = str(Path(cwd).expanduser()) if cwd else str(Path.home())
+        cmd = [codex_bin]
+        bootstrap_prompt = _load_client_bootstrap_prompt(CLIENT_CODEX)
+        if bootstrap_prompt and not _codex_managed_initial_messages_enabled():
+            cmd.extend(["-c", _codex_initial_messages_config(bootstrap_prompt)])
+        if profile["model"]:
+            cmd.extend(["-m", profile["model"]])
+        if profile["reasoning_effort"]:
+            cmd.extend(["-c", f'model_reasoning_effort="{profile["reasoning_effort"]}"'])
+        cmd.extend(["-C", target_cwd, prompt])
+        return selected, shlex.join(cmd)
+
+    raise TerminalClientUnavailableError(f"Unsupported terminal client: {selected}")
+
+
 def _resolve_runtime_model_and_effort(
     client: str,
     *,
@@ -270,7 +338,7 @@ def run_automation_prompt(
                 str(output_path),
             ]
             bootstrap_prompt = _load_client_bootstrap_prompt(CLIENT_CODEX)
-            if bootstrap_prompt:
+            if bootstrap_prompt and not _codex_managed_initial_messages_enabled():
                 cmd.extend(["-c", _codex_initial_messages_config(bootstrap_prompt)])
             if resolved_model:
                 cmd.extend(["-m", resolved_model])

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"
@@ -236,6 +238,7 @@ def sync_client_bootstrap(
             "action": "created",
             "path": str(target_path),
             "version": template_version,
+            "content": rendered,
         }
 
     existing = target_path.read_text()
@@ -275,6 +278,7 @@ def sync_client_bootstrap(
         "action": action,
         "path": str(target_path),
         "version": template_version,
+        "content": updated,
     }
 
 

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

@@ -8,6 +8,7 @@ import os
 import shutil
 import subprocess
 import sys
+import tomllib
 from pathlib import Path
 
 from bootstrap_docs import sync_client_bootstrap
@@ -19,6 +20,7 @@ try:
         normalize_backend_key,
         normalize_client_key,
         normalize_client_preferences,
+        resolve_client_runtime_profile,
     )
 except Exception:
     BACKEND_NONE = "none"
@@ -51,6 +53,13 @@ except Exception:
             "automation_backend": "claude_code",
         }
 
+    def resolve_client_runtime_profile(client: str, preferences: dict | None = None) -> dict:
+        defaults = {
+            "claude_code": {"model": "opus", "reasoning_effort": ""},
+            "codex": {"model": "gpt-5.4", "reasoning_effort": "xhigh"},
+        }
+        return dict(defaults.get(client, {}))
+
 
 
 def _user_home() -> Path:
@@ -71,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:
@@ -156,6 +167,118 @@ def _codex_config_path(home: Path | None = None) -> Path:
     return base / ".codex" / "config.toml"
 
 
+def _toml_key(key: str) -> str:
+    if key.replace("_", "").replace("-", "").isalnum():
+        return key
+    escaped = key.replace("\\", "\\\\").replace('"', '\\"')
+    return f'"{escaped}"'
+
+
+def _toml_scalar(value) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return json.dumps(value)
+    escaped = str(value).replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
+    return f'"{escaped}"'
+
+
+def _toml_inline_table(payload: dict) -> str:
+    parts = [f"{_toml_key(str(key))} = {_toml_value(value)}" for key, value in payload.items()]
+    return "{ " + ", ".join(parts) + " }"
+
+
+def _toml_value(value) -> str:
+    if isinstance(value, dict):
+        return _toml_inline_table(value)
+    if isinstance(value, list):
+        return "[" + ", ".join(_toml_value(item) for item in value) + "]"
+    return _toml_scalar(value)
+
+
+def _emit_toml_table(table: dict, prefix: tuple[str, ...] = ()) -> list[str]:
+    scalar_lines: list[str] = []
+    child_tables: list[tuple[str, dict]] = []
+    for key, value in table.items():
+        if isinstance(value, dict):
+            child_tables.append((str(key), value))
+        else:
+            scalar_lines.append(f"{_toml_key(str(key))} = {_toml_value(value)}")
+
+    lines: list[str] = []
+    emit_header = bool(prefix and (scalar_lines or not child_tables))
+    if emit_header:
+        lines.append("[" + ".".join(_toml_key(part) for part in prefix) + "]")
+    lines.extend(scalar_lines)
+
+    for child_key, child_value in child_tables:
+        child_lines = _emit_toml_table(child_value, prefix + (child_key,))
+        if child_lines:
+            if lines:
+                lines.append("")
+            lines.extend(child_lines)
+    return lines
+
+
+def _load_toml_object(path: Path) -> dict:
+    if not path.is_file():
+        return {}
+    try:
+        data = tomllib.loads(path.read_text())
+    except Exception as exc:
+        raise ValueError(f"Invalid TOML in {path}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise ValueError(f"Expected TOML table in {path}")
+    return data
+
+
+def _write_toml_object(path: Path, payload: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = _emit_toml_table(payload)
+    path.write_text("\n".join(lines).rstrip() + "\n")
+
+
+def _sync_codex_managed_config(
+    path: Path,
+    *,
+    bootstrap_prompt: str,
+    runtime_profile: dict | None,
+) -> dict:
+    payload = _load_toml_object(path)
+    action = "updated" if payload else "created"
+    runtime_profile = dict(runtime_profile or {})
+
+    if runtime_profile.get("model"):
+        payload["model"] = runtime_profile["model"]
+    if "reasoning_effort" in runtime_profile:
+        payload["model_reasoning_effort"] = runtime_profile.get("reasoning_effort") or ""
+
+    payload["initial_messages"] = [
+        {
+            "role": "system",
+            "content": bootstrap_prompt,
+        }
+    ] if bootstrap_prompt else []
+
+    nexo_table = payload.setdefault("nexo", {})
+    codex_table = nexo_table.setdefault("codex", {})
+    codex_table["bootstrap_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 ""
+
+    _write_toml_object(path, payload)
+    return {
+        "ok": True,
+        "action": action,
+        "path": str(path),
+        "bootstrap_managed": True,
+        "model": runtime_profile.get("model", ""),
+        "reasoning_effort": runtime_profile.get("reasoning_effort", "") or "",
+    }
+
+
 def _load_json_object(path: Path) -> dict:
     if not path.is_file():
         return {}
@@ -197,6 +320,7 @@ def sync_claude_code(
     python_path: str = "",
     operator_name: str = "",
     user_home: str | os.PathLike[str] | None = None,
+    preferences: dict | None = None,
 ) -> dict:
     server_config = build_server_config(
         nexo_home=nexo_home,
@@ -229,6 +353,7 @@ def sync_claude_desktop(
     python_path: str = "",
     operator_name: str = "",
     user_home: str | os.PathLike[str] | None = None,
+    preferences: dict | None = None,
 ) -> dict:
     server_config = build_server_config(
         nexo_home=nexo_home,
@@ -250,9 +375,12 @@ def sync_codex(
     python_path: str = "",
     operator_name: str = "",
     user_home: str | os.PathLike[str] | None = None,
+    preferences: dict | None = None,
 ) -> dict:
     nexo_home_path = Path(nexo_home).expanduser() if nexo_home else _default_nexo_home()
     home_path = Path(user_home).expanduser() if user_home else _user_home()
+    active_preferences = normalize_client_preferences(preferences)
+    runtime_profile = resolve_client_runtime_profile("codex", preferences=active_preferences)
     server_config = build_server_config(
         nexo_home=nexo_home_path,
         runtime_root=runtime_root,
@@ -276,6 +404,13 @@ def sync_codex(
             user_home=user_home,
         )
         result["bootstrap"] = bootstrap_result
+        if bootstrap_result.get("ok"):
+            prompt_text = bootstrap_result.get("content") or ""
+            result["config"] = _sync_codex_managed_config(
+                config_path,
+                bootstrap_prompt=prompt_text,
+                runtime_profile=runtime_profile,
+            )
         return result
 
     cmd = [codex_bin, "mcp", "add", "nexo"]
@@ -324,6 +459,12 @@ def sync_codex(
     if not bootstrap_result.get("ok"):
         sync_result["ok"] = False
         sync_result["error"] = bootstrap_result.get("error", "Codex bootstrap sync failed")
+        return sync_result
+    sync_result["config"] = _sync_codex_managed_config(
+        config_path,
+        bootstrap_prompt=bootstrap_result.get("content") or "",
+        runtime_profile=runtime_profile,
+    )
     return sync_result
 
 
@@ -372,6 +513,7 @@ def sync_all_clients(
                 python_path=python_path,
                 operator_name=operator_name,
                 user_home=user_home,
+                preferences=preferences,
             )
         except Exception as exc:
             return {"ok": False, "client": label, "error": str(exc)}

package/src/cognitive/__init__.py

@@ -10,14 +10,18 @@ constants are re-exported here for full backwards compatibility:
 # Core: DB, embedding, cosine, constants, tables, redaction
 from cognitive._core import (
     COGNITIVE_DB, EMBEDDING_DIM, LAMBDA_STM, LAMBDA_LTM,
+    DEFAULT_MEMORY_STABILITY, DEFAULT_MEMORY_DIFFICULTY,
     PE_GATE_REJECT, PE_GATE_REFINE, _gate_stats,
     DISCRIMINATING_ENTITIES,
     POSITIVE_SIGNALS, NEGATIVE_SIGNALS, URGENCY_SIGNALS,
     _get_db, _init_tables, _migrate_lifecycle, _migrate_co_activation,
+    _migrate_memory_personalization,
     _auto_migrate_embeddings,
     _get_model, _get_reranker, rerank_results,
     embed, cosine_similarity, _array_to_blob, _blob_to_array,
     extract_temporal_date, redact_secrets,
+    clamp_memory_stability, clamp_memory_difficulty,
+    initial_memory_profile, personalize_decay_rate, rehearsal_profile_update,
 )
 
 # Search