nexo-brain 7.9.13 → 7.9.15

package/README.md

@@ -18,7 +18,7 @@
 
 [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.9.13` is the current packaged-runtime line. Patch release over `7.9.12`: the remaining lifecycle/enforcement system prompts are now centralized in the core prompt catalog, operator-facing guard/followup/diary outputs are forced back into the operator language even when the base prompt is English, packaged installs recover the missing Guardian default preset, and the startup Guardian Health briefing now queries `hook_runs` correctly instead of reporting false green states. Coordinated Desktop release: v0.28.14.
+Version `7.9.14` is the current packaged-runtime line. Patch release over `7.9.13`: `task_close(done)` now hard-blocks missing verify/change-log/cortex evidence instead of silently degrading to debt-only closes, self-audit auto-drains stale `protocol_debt` every day, and Codex session parity now flags partial bootstrap/startup/heartbeat drift instead of passing as healthy when only one recent session behaved correctly. Coordinated Desktop release remains v0.28.14.
 
 Previously in `7.9.5`: patch release that fixes canonical diary confirmation for Desktop: Brain resolves the Desktop/Claude session UUID through NEXO SID aliases before checking `session_diary`, so archive/delete/app-exit can confirm diaries written by `nexo_session_diary_write` under the active `nexo-...` SID. Verification: `pytest tests/test_lifecycle_events.py` (28 passing) plus coordinated Desktop v0.28.6 shutdown/archive/delete/app-exit checks.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.13",
+  "version": "7.9.15",
   "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/cognitive/_core.py

@@ -558,8 +558,9 @@ def _get_model():
     """Lazy-load fastembed TextEmbedding model."""
     global _model
     if _model is None:
-        from fastembed import TextEmbedding
-        _model = TextEmbedding("BAAI/bge-base-en-v1.5")
+        from local_models import build_fastembed_embedding
+
+        _model = build_fastembed_embedding("bge-base-embeddings")
     return _model
 
 
@@ -568,8 +569,9 @@ def _get_reranker():
     global _reranker
     if _reranker is None:
         try:
-            from fastembed.rerank.cross_encoder import TextCrossEncoder
-            _reranker = TextCrossEncoder("Xenova/ms-marco-MiniLM-L-6-v2")
+            from local_models import build_fastembed_reranker
+
+            _reranker = build_fastembed_reranker("cross-encoder-reranker")
         except Exception:
             _reranker = False  # Mark as unavailable
     return _reranker if _reranker is not False else None

package/src/db/_protocol.py

@@ -195,6 +195,10 @@ def create_cortex_evaluation(
     goal_profile_id: str = "",
     goal_profile_labels=None,
     goal_profile_weights=None,
+    heuristic_choice: str = "",
+    heuristic_reasoning: str = "",
+    critique_payload=None,
+    decision_mode: str = "heuristic",
     selected_choice: str = "",
     selection_reason: str = "",
     selection_source: str = "recommended",
@@ -206,8 +210,9 @@ def create_cortex_evaluation(
                session_id, task_id, goal, task_type, area, impact_level, context_hint,
                alternatives, scores, recommended_choice, recommended_reasoning, linked_outcome_id,
                goal_profile_id, goal_profile_labels, goal_profile_weights,
+               heuristic_choice, heuristic_reasoning, critique_payload, decision_mode,
                selected_choice, selection_reason, selection_source
-           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
         (
             session_id.strip(),
             task_id.strip(),
@@ -224,6 +229,10 @@ def create_cortex_evaluation(
             goal_profile_id.strip(),
             _as_json(goal_profile_labels or []),
             _as_json(goal_profile_weights or {}),
+            (heuristic_choice or recommended_choice).strip(),
+            (heuristic_reasoning or recommended_reasoning).strip(),
+            _as_json(critique_payload or {}),
+            (decision_mode or "heuristic").strip(),
             (selected_choice or recommended_choice).strip(),
             (selection_reason or recommended_reasoning).strip(),
             (selection_source or "recommended").strip(),

package/src/db/_schema.py

@@ -909,6 +909,14 @@ def _m38_evolution_log_proposal_payload(conn):
     _migrate_add_column(conn, "evolution_log", "proposal_payload", "TEXT DEFAULT NULL")
 
 
+def _m55_cortex_critique_trace(conn):
+    """Persist heuristic-vs-LLM critique traces for Cortex decisions."""
+    _migrate_add_column(conn, "cortex_evaluations", "heuristic_choice", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "cortex_evaluations", "heuristic_reasoning", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "cortex_evaluations", "critique_payload", "TEXT DEFAULT '{}'")
+    _migrate_add_column(conn, "cortex_evaluations", "decision_mode", "TEXT DEFAULT 'heuristic'")
+
+
 def _m39_hook_runs(conn):
     """Persist hook lifecycle observability — closes Fase 3 item 7.
 
@@ -1479,6 +1487,7 @@ MIGRATIONS = [
     (52, "lifecycle_canonical_plan", _m52_lifecycle_canonical_plan),
     (53, "session_conversation_identity", _m53_session_conversation_identity),
     (54, "continuity_snapshots", _m54_continuity_snapshots),
+    (55, "cortex_critique_trace", _m55_cortex_critique_trace),
 ]
 
 

package/src/doctor/providers/runtime.py

@@ -2112,14 +2112,32 @@ def check_codex_session_parity() -> DoctorCheck:
     status = "healthy"
     severity = "info"
     repair_plan: list[str] = []
-    if audit["bootstrap_sessions"] == 0:
+    missing_bootstrap = max(0, audit["files"] - audit["bootstrap_sessions"])
+    missing_startup = max(0, audit["files"] - audit["startup_sessions"])
+    missing_heartbeat = max(0, audit["files"] - audit["heartbeat_sessions"])
+    if missing_bootstrap:
         status = "degraded"
         severity = "warn"
-        repair_plan.append("Run `nexo update` or `nexo clients sync` so plain Codex sessions inherit the managed bootstrap")
-    if audit["startup_sessions"] == 0:
+        repair_plan.append(
+            "Run `nexo update` or `nexo clients sync` so every Codex session inherits the managed bootstrap, not just a subset"
+        )
+    if missing_startup:
+        status = "degraded"
+        severity = "warn"
+        repair_plan.append(
+            "Use `nexo chat` or keep the global Codex bootstrap intact so every Codex session actually calls `nexo_startup`"
+        )
+    if missing_heartbeat:
         status = "degraded"
         severity = "warn"
-        repair_plan.append("Use `nexo chat` or keep the global Codex bootstrap intact so sessions actually call `nexo_startup`")
+        repair_plan.append("Keep `nexo_heartbeat` on every user turn so restored/plain Codex sessions do not drift off-protocol")
+    if missing_bootstrap or missing_startup or missing_heartbeat:
+        evidence.append(
+            "session drift: "
+            f"{missing_bootstrap} missing bootstrap, "
+            f"{missing_startup} missing startup, "
+            f"{missing_heartbeat} missing heartbeat"
+        )
 
     return DoctorCheck(
         id="runtime.codex_sessions",

package/src/local_model_manifest.json

@@ -0,0 +1,113 @@
+{
+  "version": 1,
+  "models": [
+    {
+      "name": "bge-base-embeddings",
+      "kind": "fastembed_embedding",
+      "model_id": "BAAI/bge-base-en-v1.5",
+      "source_repo": "qdrant/bge-base-en-v1.5-onnx-q",
+      "revision": "738cad1c108e2f23649db9e44b2eab988626493b",
+      "model_file": "model_optimized.onnx",
+      "source": "src/cognitive/_core.py",
+      "required_files": [
+        {
+          "path": "config.json",
+          "size": 740,
+          "sha256": "86f84a5285de7f1ee673f712387219ef1e261ec27dcd870e793a80f9da1aaa3b"
+        },
+        {
+          "path": "model_optimized.onnx",
+          "size": 217824172,
+          "sha256": "4e556722bc4f65716c544c8a931f1e90fb3f866e5741fd93a96f051d673339c7"
+        },
+        {
+          "path": "special_tokens_map.json",
+          "size": 695,
+          "sha256": "5d5b662e421ea9fac075174bb0688ee0d9431699900b90662acd44b2a350503a"
+        },
+        {
+          "path": "tokenizer.json",
+          "size": 711396,
+          "sha256": "d241a60d5e8f04cc1b2b3e9ef7a4921b27bf526d9f6050ab90f9267a1f9e5c66"
+        },
+        {
+          "path": "tokenizer_config.json",
+          "size": 1242,
+          "sha256": "0b29c7bfc889e53b36d9dd3e686dd4300f6525110eaa98c76a5dafceb2029f53"
+        }
+      ]
+    },
+    {
+      "name": "bge-small-embeddings",
+      "kind": "fastembed_embedding",
+      "model_id": "BAAI/bge-small-en-v1.5",
+      "source_repo": "qdrant/bge-small-en-v1.5-onnx-q",
+      "revision": "52398278842ec682c6f32300af41344b1c0b0bb2",
+      "model_file": "model_optimized.onnx",
+      "source": "src/migrate_embeddings.py",
+      "required_files": [
+        {
+          "path": "config.json",
+          "size": 706,
+          "sha256": "13582bcf2effc85b7bf3d3f5532e686bc1c9ce86bb009d10f0ec33cbe92299dd"
+        },
+        {
+          "path": "model_optimized.onnx",
+          "size": 66465124,
+          "sha256": "51f1bd0addd6e859e42c2c8021a5e5461385bb676a649f4b269aa445449f2431"
+        },
+        {
+          "path": "special_tokens_map.json",
+          "size": 695,
+          "sha256": "5d5b662e421ea9fac075174bb0688ee0d9431699900b90662acd44b2a350503a"
+        },
+        {
+          "path": "tokenizer.json",
+          "size": 711396,
+          "sha256": "d241a60d5e8f04cc1b2b3e9ef7a4921b27bf526d9f6050ab90f9267a1f9e5c66"
+        },
+        {
+          "path": "tokenizer_config.json",
+          "size": 1242,
+          "sha256": "0b29c7bfc889e53b36d9dd3e686dd4300f6525110eaa98c76a5dafceb2029f53"
+        }
+      ]
+    },
+    {
+      "name": "cross-encoder-reranker",
+      "kind": "fastembed_reranker",
+      "model_id": "Xenova/ms-marco-MiniLM-L-6-v2",
+      "source_repo": "Xenova/ms-marco-MiniLM-L-6-v2",
+      "revision": "a09144355adeed5f58c8ed011d209bf8ee5a1fec",
+      "model_file": "onnx/model.onnx",
+      "source": "src/cognitive/_core.py",
+      "required_files": [
+        {
+          "path": "config.json",
+          "size": 824,
+          "sha256": "d827779a72d27ae68cf878a6fc2e954542663fe21ca515d9f4783fc96be2d37e"
+        },
+        {
+          "path": "onnx/model.onnx",
+          "size": 90992115,
+          "sha256": "c623d0bcb99f4622beb413eaef00cfbe5db20df9f1dd982da4b4f26022881870"
+        },
+        {
+          "path": "special_tokens_map.json",
+          "size": 125,
+          "sha256": "b6d346be366a7d1d48332dbc9fdf3bf8960b5d879522b7799ddba59e76237ee3"
+        },
+        {
+          "path": "tokenizer.json",
+          "size": 711396,
+          "sha256": "d241a60d5e8f04cc1b2b3e9ef7a4921b27bf526d9f6050ab90f9267a1f9e5c66"
+        },
+        {
+          "path": "tokenizer_config.json",
+          "size": 1242,
+          "sha256": "0b29c7bfc889e53b36d9dd3e686dd4300f6525110eaa98c76a5dafceb2029f53"
+        }
+      ]
+    }
+  ]
+}

package/src/local_models.py

@@ -0,0 +1,247 @@
+"""Pinned local model management for Brain embeddings + reranker.
+
+FastEmbed's built-in registry resolves supported models by friendly name, but
+its downloader tracks the current upstream repo head unless the caller builds a
+stronger contract around it. This module provides that stronger contract:
+
+- source repo pinned by immutable revision SHA
+- required files + sha256 checksums stored in-repo
+- deterministic materialization under ``~/.nexo/runtime/models``
+- FastEmbed instantiated via ``specific_model_path`` so runtime loads the exact
+  downloaded artifacts instead of following a floating registry download
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import shutil
+import tempfile
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+import paths
+
+
+MANIFEST_PATH = Path(__file__).resolve().with_name("local_model_manifest.json")
+MODEL_LOCK_FILENAME = ".nexo-model-lock.json"
+
+
+@dataclass(frozen=True)
+class LocalModelFile:
+    path: str
+    size: int
+    sha256: str
+
+
+@dataclass(frozen=True)
+class LocalModelSpec:
+    name: str
+    kind: str
+    model_id: str
+    source_repo: str
+    revision: str
+    model_file: str
+    source: str
+    required_files: tuple[LocalModelFile, ...]
+
+
+def _slugify(value: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "-", value.strip().lower()).strip("-")
+
+
+def _hash_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _lock_payload(spec: LocalModelSpec) -> dict[str, Any]:
+    return {
+        "name": spec.name,
+        "kind": spec.kind,
+        "model_id": spec.model_id,
+        "source_repo": spec.source_repo,
+        "revision": spec.revision,
+        "model_file": spec.model_file,
+        "required_files": [
+            {"path": item.path, "size": item.size, "sha256": item.sha256}
+            for item in spec.required_files
+        ],
+    }
+
+
+@lru_cache(maxsize=1)
+def _load_manifest() -> dict[str, LocalModelSpec]:
+    payload = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+    specs: dict[str, LocalModelSpec] = {}
+    for raw in payload.get("models", []) or []:
+        files = tuple(LocalModelFile(**item) for item in raw.get("required_files", []) or [])
+        spec = LocalModelSpec(
+            name=str(raw["name"]),
+            kind=str(raw["kind"]),
+            model_id=str(raw["model_id"]),
+            source_repo=str(raw["source_repo"]),
+            revision=str(raw["revision"]),
+            model_file=str(raw["model_file"]),
+            source=str(raw["source"]),
+            required_files=files,
+        )
+        specs[spec.name] = spec
+    return specs
+
+
+def get_local_model_spec(name: str) -> LocalModelSpec:
+    try:
+        return _load_manifest()[name]
+    except KeyError as exc:  # pragma: no cover - defensive
+        raise KeyError(f"unknown local model spec: {name}") from exc
+
+
+def list_local_model_specs(kind: str | None = None) -> list[LocalModelSpec]:
+    specs = list(_load_manifest().values())
+    if kind:
+        specs = [spec for spec in specs if spec.kind == kind]
+    return specs
+
+
+def models_dir() -> Path:
+    root = paths.models_dir()
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def managed_model_dir(spec: LocalModelSpec) -> Path:
+    return models_dir() / _slugify(spec.name) / spec.revision
+
+
+def verify_local_model_dir(spec: LocalModelSpec, root: Path | None = None) -> dict[str, Any]:
+    target = root or managed_model_dir(spec)
+    problems: list[str] = []
+    if not target.exists():
+        problems.append("missing directory")
+    for file_spec in spec.required_files:
+        file_path = target / file_spec.path
+        if not file_path.exists():
+            problems.append(f"missing file:{file_spec.path}")
+            continue
+        size = file_path.stat().st_size
+        if size != file_spec.size:
+            problems.append(f"size mismatch:{file_spec.path}:{size}!={file_spec.size}")
+            continue
+        actual_hash = _hash_file(file_path)
+        if actual_hash != file_spec.sha256:
+            problems.append(f"sha256 mismatch:{file_spec.path}:{actual_hash}!={file_spec.sha256}")
+    lock_path = target / MODEL_LOCK_FILENAME
+    if lock_path.exists():
+        try:
+            payload = json.loads(lock_path.read_text(encoding="utf-8"))
+            if payload.get("revision") != spec.revision or payload.get("source_repo") != spec.source_repo:
+                problems.append("lock metadata mismatch")
+        except Exception:
+            problems.append("invalid lock metadata")
+    return {"ok": not problems, "path": str(target), "problems": problems}
+
+
+def _copy_required_files(snapshot_dir: Path, target_dir: Path, spec: LocalModelSpec) -> None:
+    for file_spec in spec.required_files:
+        source_path = snapshot_dir / file_spec.path
+        if not source_path.exists():
+            raise FileNotFoundError(f"snapshot missing required file: {file_spec.path}")
+        destination = target_dir / file_spec.path
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source_path, destination)
+    (target_dir / MODEL_LOCK_FILENAME).write_text(
+        json.dumps(_lock_payload(spec), indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+
+def ensure_local_model(
+    name: str,
+    *,
+    local_files_only: bool = False,
+    force_redownload: bool = False,
+) -> Path:
+    spec = get_local_model_spec(name)
+    target_dir = managed_model_dir(spec)
+    verification = verify_local_model_dir(spec, target_dir)
+    if verification["ok"] and not force_redownload:
+        return target_dir
+    if target_dir.exists():
+        shutil.rmtree(target_dir, ignore_errors=True)
+
+    from huggingface_hub import snapshot_download
+
+    cache_dir = models_dir() / "_hf-cache"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    snapshot_dir = Path(
+        snapshot_download(
+            repo_id=spec.source_repo,
+            revision=spec.revision,
+            allow_patterns=[item.path for item in spec.required_files],
+            cache_dir=str(cache_dir),
+            local_files_only=local_files_only,
+        )
+    )
+
+    target_parent = target_dir.parent
+    target_parent.mkdir(parents=True, exist_ok=True)
+    tmp_dir = Path(
+        tempfile.mkdtemp(
+            prefix=f".{_slugify(spec.name)}-{spec.revision[:12]}.",
+            dir=str(target_parent),
+        )
+    )
+    try:
+        _copy_required_files(snapshot_dir, tmp_dir, spec)
+        verification = verify_local_model_dir(spec, tmp_dir)
+        if not verification["ok"]:
+            raise ValueError("; ".join(verification["problems"]))
+        os.replace(tmp_dir, target_dir)
+    except Exception:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+        raise
+    return target_dir
+
+
+def build_fastembed_embedding(name: str):
+    spec = get_local_model_spec(name)
+    if spec.kind != "fastembed_embedding":
+        raise ValueError(f"{name} is not a fastembed embedding model")
+    from fastembed import TextEmbedding
+
+    target_dir = ensure_local_model(name)
+    return TextEmbedding(spec.model_id, specific_model_path=str(target_dir))
+
+
+def build_fastembed_reranker(name: str):
+    spec = get_local_model_spec(name)
+    if spec.kind != "fastembed_reranker":
+        raise ValueError(f"{name} is not a fastembed reranker")
+    from fastembed.rerank.cross_encoder import TextCrossEncoder
+
+    target_dir = ensure_local_model(name)
+    return TextCrossEncoder(spec.model_id, specific_model_path=str(target_dir))
+
+
+__all__ = [
+    "LocalModelFile",
+    "LocalModelSpec",
+    "MODEL_LOCK_FILENAME",
+    "MANIFEST_PATH",
+    "build_fastembed_embedding",
+    "build_fastembed_reranker",
+    "ensure_local_model",
+    "get_local_model_spec",
+    "list_local_model_specs",
+    "managed_model_dir",
+    "models_dir",
+    "verify_local_model_dir",
+]

package/src/migrate_embeddings.py

@@ -16,6 +16,7 @@ import time
 import numpy as np
 
 import paths
+from local_models import build_fastembed_embedding, get_local_model_spec
 
 NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
 _cognitive_dir = paths.cognitive_dir()
@@ -24,8 +25,8 @@ DB_PATH = str(_cognitive_dir / "cognitive.db")
 BACKUP_PATH = DB_PATH + ".bak-384dims-pre-upgrade"
 
 MODELS = {
-    "small": ("BAAI/bge-small-en-v1.5", 384),
-    "base": ("BAAI/bge-base-en-v1.5", 768),
+    "small": ("bge-small-embeddings", 384),
+    "base": ("bge-base-embeddings", 768),
 }
 
 
@@ -47,8 +48,6 @@ def verify():
 
 def upgrade():
     """Re-embed all memories from bge-small (384) to bge-base (768)."""
-    from fastembed import TextEmbedding
-
     # Verify current state
     print("Current state:")
     verify()
@@ -62,8 +61,9 @@ def upgrade():
 
     # Load new model
     model_name, expected_dim = MODELS["base"]
-    print(f"\nLoading {model_name}...")
-    model = TextEmbedding(model_name)
+    spec = get_local_model_spec(model_name)
+    print(f"\nLoading {spec.model_id}@{spec.revision}...")
+    model = build_fastembed_embedding(model_name)
 
     conn = sqlite3.connect(DB_PATH)
     try:

package/src/model_warmup.py

@@ -28,40 +28,37 @@ class WarmupTarget:
     kind: str
     model_id: str
     source: str
+    source_repo: str | None = None
     revision: str | None = None
     required: bool = True
 
 
 def warmup_targets() -> list[WarmupTarget]:
     from classifier_local import MODEL_ID, MODEL_REVISION
+    from local_models import list_local_model_specs
 
-    return [
+    targets = [
         WarmupTarget(
             name="local-zero-shot-classifier",
             kind="transformers_sequence_classifier",
             model_id=MODEL_ID,
             revision=MODEL_REVISION,
             source="src/classifier_local.py",
-        ),
-        WarmupTarget(
-            name="bge-base-embeddings",
-            kind="fastembed_embedding",
-            model_id="BAAI/bge-base-en-v1.5",
-            source="src/cognitive/_core.py",
-        ),
-        WarmupTarget(
-            name="bge-small-embeddings",
-            kind="fastembed_embedding",
-            model_id="BAAI/bge-small-en-v1.5",
-            source="src/migrate_embeddings.py",
-        ),
-        WarmupTarget(
-            name="cross-encoder-reranker",
-            kind="fastembed_reranker",
-            model_id="Xenova/ms-marco-MiniLM-L-6-v2",
-            source="src/cognitive/_core.py",
+            source_repo=MODEL_ID,
         ),
     ]
+    for spec in list_local_model_specs():
+        targets.append(
+            WarmupTarget(
+                name=spec.name,
+                kind=spec.kind,
+                model_id=spec.model_id,
+                revision=spec.revision,
+                source=spec.source,
+                source_repo=spec.source_repo,
+            )
+        )
+    return targets
 
 
 def _state_path() -> Path:
@@ -86,16 +83,16 @@ def _warm_transformers(target: WarmupTarget) -> None:
 
 
 def _warm_fastembed_embedding(target: WarmupTarget) -> None:
-    from fastembed import TextEmbedding
+    from local_models import build_fastembed_embedding
 
-    model = TextEmbedding(target.model_id)
+    model = build_fastembed_embedding(target.name)
     list(model.embed(["NEXO model warmup"]))
 
 
 def _warm_fastembed_reranker(target: WarmupTarget) -> None:
-    from fastembed.rerank.cross_encoder import TextCrossEncoder
+    from local_models import build_fastembed_reranker
 
-    TextCrossEncoder(target.model_id)
+    build_fastembed_reranker(target.name)
 
 
 def warm_target(target: WarmupTarget) -> None:

package/src/paths.py

@@ -336,6 +336,14 @@ def cognitive_dir() -> Path:
     return new
 
 
+def models_dir() -> Path:
+    new = runtime_dir() / "models"
+    legacy = home() / "models"
+    if not new.exists() and legacy.exists():
+        return legacy
+    return new
+
+
 def coordination_dir() -> Path:
     new = runtime_dir() / "coordination"
     legacy = home() / "coordination"
@@ -488,6 +496,7 @@ __all__ = [
     "backups_dir",
     "memory_dir",
     "cognitive_dir",
+    "models_dir",
     "coordination_dir",
     "exports_dir",
     "nexo_email_dir",