nexo-brain 7.30.15 → 7.30.17

package/.claude-plugin/plugin.json

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

@@ -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.30.15` is the current packaged-runtime line. Patch release over v7.30.14 - Email NEXO reply lifecycle closure now handles affirmative actionable replies and prevents already-closed processed threads from reopening.
+Version `7.30.17` is the current packaged-runtime line. Patch release over v7.30.16 - F0.6 repairs promoted helper imports for personal scripts by adding a core-backed compatibility shim without duplicating the script catalog.
+
+Previously in `7.30.16`: patch release over v7.30.14 - Desktop diagnostics can read embedding migration status without warming models, and the coordinated Desktop update path is covered for bundled model verification and obsolete managed model cleanup.
 
 Previously in `7.30.14`: patch release over v7.30.13 - support tickets, provider capability discovery, task-close rearming, internal audit followups, and the memory-observation watchdog are aligned for Desktop-managed agents.
 

package/bin/nexo-brain.js

@@ -666,6 +666,11 @@ function shouldSkipModelWarmup() {
   return ["1", "true", "yes", "on"].includes(flag);
 }
 
+function shouldInstallLocalClassifierWarmupDeps() {
+  const flag = String(process.env.NEXO_LOCAL_CLASSIFIER || "").trim().toLowerCase();
+  return ["1", "true", "on", "auto"].includes(flag);
+}
+
 function resolveSystemPython() {
   return run("which python3") || run("which python") || "python3";
 }
@@ -705,13 +710,15 @@ function installWarmupPythonDependencies(pythonPath, { quiet = false, installRun
     }
   }
 
-  const classifierResult = spawnSync(
-    pythonPath,
-    [...pipCommon, ...WARMUP_PIP_PACKAGES],
-    { stdio, timeout: WARMUP_TIMEOUT_MS }
-  );
-  if (classifierResult.status !== 0) {
-    throw new Error("failed to install local classifier dependencies for model warmup");
+  if (shouldInstallLocalClassifierWarmupDeps()) {
+    const classifierResult = spawnSync(
+      pythonPath,
+      [...pipCommon, ...WARMUP_PIP_PACKAGES],
+      { stdio, timeout: WARMUP_TIMEOUT_MS }
+    );
+    if (classifierResult.status !== 0) {
+      throw new Error("failed to install local classifier dependencies for model warmup");
+    }
   }
 }
 
@@ -766,6 +773,157 @@ function runDesktopAwareModelWarmup(pythonPath, nexoHome = NEXO_HOME, options =
   runMandatoryModelWarmup(pythonPath, nexoHome, options);
 }
 
+function slugifyLocalModelName(value) {
+  return String(value || "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+function readManagedModelLock(dir) {
+  try {
+    const lockPath = path.join(dir, ".nexo-model-lock.json");
+    if (!fs.existsSync(lockPath)) return null;
+    const payload = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+    return payload && typeof payload === "object" ? payload : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function isManagedModelRevisionDir(dir, { slug = "", revision = "" } = {}) {
+  const lock = readManagedModelLock(dir);
+  if (!lock) return false;
+  if (!lock.name || !lock.revision || (!lock.model_id && !lock.source_repo)) return false;
+  if (slug && slugifyLocalModelName(lock.name) !== slug) return false;
+  if (revision && String(lock.revision || "") !== String(revision || "")) return false;
+  return true;
+}
+
+function sha256File(filePath) {
+  return crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+}
+
+function cleanupObsoleteRuntimeLlmModels(runtimeModelsDir, manifest, { reason = "install" } = {}) {
+  if (String(process.env.NEXO_KEEP_OBSOLETE_LLM_MODELS || "").trim() === "1") {
+    log(`  Keeping obsolete LLM models by NEXO_KEEP_OBSOLETE_LLM_MODELS=1 (${reason}).`);
+    return [];
+  }
+  if (!fs.existsSync(runtimeModelsDir)) return [];
+
+  const allowed = new Map();
+  for (const spec of manifest.models || []) {
+    const slug = slugifyLocalModelName(spec.name || "");
+    const revision = String(spec.revision || "").trim();
+    if (!slug || !revision) continue;
+    if (!allowed.has(slug)) allowed.set(slug, new Set());
+    allowed.get(slug).add(revision);
+  }
+
+  const removed = [];
+  for (const slugEntry of fs.readdirSync(runtimeModelsDir, { withFileTypes: true })) {
+    if (!slugEntry.isDirectory()) continue;
+    const slug = slugEntry.name;
+    if (slug.startsWith(".")) continue;
+    if (slug === "_hf-cache") continue;
+    const slugDir = path.join(runtimeModelsDir, slug);
+    const allowedRevisions = allowed.get(slug) || new Set();
+    for (const revisionEntry of fs.readdirSync(slugDir, { withFileTypes: true })) {
+      if (!revisionEntry.isDirectory()) continue;
+      const revision = revisionEntry.name;
+      const revisionDir = path.join(slugDir, revision);
+      if (allowedRevisions.has(revision)) continue;
+      if (!isManagedModelRevisionDir(revisionDir, { slug, revision })) continue;
+      fs.rmSync(revisionDir, { recursive: true, force: true });
+      removed.push(path.relative(runtimeModelsDir, revisionDir));
+    }
+    try {
+      if (fs.readdirSync(slugDir).length === 0) fs.rmdirSync(slugDir);
+    } catch (_) {}
+  }
+
+  if (removed.length > 0) {
+    log(`  Removed ${removed.length} obsolete managed LLM model revision(s) (${reason}).`);
+  }
+  return removed;
+}
+
+function copyBundledLlmModelsToRuntime(nexoHome = NEXO_HOME, {
+  reason = "install",
+  bundledModelsDir = path.join(__dirname, "..", "models"),
+  manifestPath = path.join(__dirname, "..", "src", "local_model_manifest.json"),
+} = {}) {
+  // OFFLINE-FIRST: copy bundled LLM models to runtime/models BEFORE warmup,
+  // so fastembed finds them locally and skips HuggingFace downloads.
+  // Bundle layout: resources/brain-bundle/models/<source-repo-name>/<all files>.
+  // Target layout: <NEXO_HOME>/runtime/models/<spec.name slugified>/<revision>/<files>.
+  // We map by source_repo basename to match local_model_manifest.json.
+  if (!fs.existsSync(bundledModelsDir)) return 0;
+  try {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    const runtimeModelsDir = path.join(nexoHome, "runtime", "models");
+    let modelsCopied = 0;
+    for (const spec of manifest.models || []) {
+      // Bundle layout supports either model_id basename (e.g.
+      // "bge-base-en-v1.5" from "BAAI/bge-base-en-v1.5") or source_repo
+      // basename (e.g. "bge-base-en-v1.5-onnx-q" from "qdrant/...").
+      const modelIdName = (spec.model_id || "").split("/").pop();
+      const sourceRepoName = (spec.source_repo || "").split("/").pop();
+      let sourceDir = path.join(bundledModelsDir, sourceRepoName);
+      if (!fs.existsSync(sourceDir)) {
+        sourceDir = path.join(bundledModelsDir, modelIdName);
+      }
+      if (!fs.existsSync(sourceDir)) continue;
+      const slug = slugifyLocalModelName(spec.name || "");
+      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)) {
+          missingFiles.push(f.path);
+          continue;
+        }
+        fs.mkdirSync(path.dirname(dst), { recursive: true });
+        let shouldCopy = !fs.existsSync(dst) || (f.size && fs.statSync(dst).size !== f.size);
+        if (!shouldCopy && f.sha256 && sha256File(dst) !== f.sha256) {
+          shouldCopy = true;
+        }
+        if (shouldCopy) {
+          fs.copyFileSync(src, dst);
+        }
+        if (f.size && fs.statSync(dst).size !== f.size) {
+          missingFiles.push(`${f.path}:size`);
+          continue;
+        }
+        if (f.sha256) {
+          const actual = sha256File(dst);
+          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({
+        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: spec.required_files,
+      }, null, 2));
+      modelsCopied++;
+    }
+    if (modelsCopied > 0) log(`  Copied ${modelsCopied} pre-bundled LLM model(s) (offline, ${reason}).`);
+    if (modelsCopied > 0 && modelsCopied === (manifest.models || []).length) {
+      cleanupObsoleteRuntimeLlmModels(runtimeModelsDir, manifest, { reason });
+    }
+    return modelsCopied;
+  } catch (err) {
+    log(`  WARN: bundled models copy failed during ${reason}: ${err.message}`);
+    return 0;
+  }
+}
+
 async function runWarmupModelsCommand(args) {
   const dryRun = args.includes("--dry-run");
   const json = args.includes("--json");
@@ -3216,6 +3374,7 @@ async function runSetup() {
           log("  Python dependencies reconciled.");
         }
 
+        copyBundledLlmModelsToRuntime(NEXO_HOME, { reason: "update" });
         const migPythonForWarmup = findVenvPython(NEXO_HOME) || "python3";
         runDesktopAwareModelWarmup(migPythonForWarmup, NEXO_HOME, { reason: "update", installRuntimeDeps: false });
 
@@ -3492,6 +3651,7 @@ async function runSetup() {
         stampRuntimeRepairBaseline(NEXO_HOME, "bin.nexo-brain.same-version-repair")
       );
 
+      copyBundledLlmModelsToRuntime(NEXO_HOME, { reason: "repair" });
       runDesktopAwareModelWarmup(syncPython, NEXO_HOME, { reason: "repair" });
       logMacPermissionsNotice(NEXO_HOME, syncPython);
 
@@ -3935,71 +4095,7 @@ async function runSetup() {
   }
   log("Dependencies installed.");
 
-  // OFFLINE-FIRST: copy bundled LLM models to runtime/models BEFORE warmup,
-  // so fastembed finds them locally and skips the ~217MB HuggingFace download.
-  // Bundle layout: resources/brain-bundle/models/<source-repo-name>/<all files>.
-  // Target layout: <NEXO_HOME>/runtime/models/<spec.name slugified>/<revision>/<files>.
-  // We map by source_repo basename to match local_model_manifest.json.
-  const bundledModelsDir = path.join(__dirname, "..", "models");
-  if (fs.existsSync(bundledModelsDir)) {
-    try {
-      const manifest = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "src", "local_model_manifest.json"), "utf8"));
-      const runtimeModelsDir = path.join(NEXO_HOME, "runtime", "models");
-      let modelsCopied = 0;
-      for (const spec of manifest.models || []) {
-        // Bundle layout supports either model_id basename (e.g.
-        // "bge-base-en-v1.5" from "BAAI/bge-base-en-v1.5") or source_repo
-        // basename (e.g. "bge-base-en-v1.5-onnx-q" from "qdrant/...").
-        const modelIdName = (spec.model_id || "").split("/").pop();
-        const sourceRepoName = (spec.source_repo || "").split("/").pop();
-        let sourceDir = path.join(bundledModelsDir, modelIdName);
-        if (!fs.existsSync(sourceDir)) {
-          sourceDir = path.join(bundledModelsDir, sourceRepoName);
-        }
-        if (!fs.existsSync(sourceDir)) continue;
-        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)) {
-            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({
-          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: spec.required_files,
-        }, null, 2));
-        modelsCopied++;
-      }
-      if (modelsCopied > 0) log(`  Copied ${modelsCopied} pre-bundled LLM model(s) (offline).`);
-    } catch (err) {
-      log(`  WARN: bundled models copy failed: ${err.message}`);
-    }
-  }
+  copyBundledLlmModelsToRuntime(NEXO_HOME, { reason: "install" });
 
   runDesktopAwareModelWarmup(python, NEXO_HOME, { reason: "install", installRuntimeDeps: false });
 
@@ -5121,4 +5217,13 @@ if (isCliEntrypoint()) {
     console.error("Setup failed:", err.message);
     process.exit(1);
   });
+} else {
+  module.exports = {
+    cleanupObsoleteRuntimeLlmModels,
+    copyBundledLlmModelsToRuntime,
+    isManagedModelRevisionDir,
+    readManagedModelLock,
+    sha256File,
+    slugifyLocalModelName,
+  };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.15",
+  "version": "7.30.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/auto_update.py

@@ -1211,6 +1211,15 @@ def _local_classifier_install_command() -> list[str]:
     return cmd
 
 
+def _local_classifier_auto_install_enabled() -> bool:
+    return str(os.environ.get("NEXO_LOCAL_CLASSIFIER", "")).strip().lower() in {
+        "1",
+        "true",
+        "on",
+        "auto",
+    }
+
+
 def _install_local_classifier_worker() -> None:
     from classifier_local import MODEL_REVISION
 
@@ -1311,6 +1320,18 @@ def _maybe_install_local_classifier() -> None:
             "opt_out": True,
         })
         return
+    if not _local_classifier_auto_install_enabled():
+        from classifier_local import MODEL_REVISION
+
+        _write_classifier_install_log("[classifier-install] deferred: model is not bundled; set NEXO_LOCAL_CLASSIFIER=auto to install")
+        _write_classifier_install_state({
+            "installed_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "model_revision": MODEL_REVISION,
+            "deps_ok": False,
+            "deferred": True,
+            "reason": "not_bundled",
+        })
+        return
     try:
         deps_ok, versions, _missing = _probe_local_classifier_dependencies()
         if deps_ok:
@@ -3133,6 +3154,103 @@ def _ensure_f06_legacy_shims() -> None:
         paths.finalize_backup_snapshot(conflict_root)
 
 
+def _ensure_f06_personal_script_import_shims() -> None:
+    """Expose promoted core helpers to legacy personal scripts.
+
+    Some operator-owned scripts are executed directly from
+    ``NEXO_HOME/personal/scripts`` and therefore only get that directory on
+    ``sys.path``. When Block E.6 promoted ``nexo_personal_automation.py`` into
+    ``core/scripts``, those direct scripts lost the bare import
+    ``from nexo_personal_automation import ...``. Keep the source of truth in
+    core, but add a tiny compatibility entry in personal/scripts.
+    """
+
+    helper_names = ("nexo_personal_automation.py",)
+    core_scripts = NEXO_HOME / "core" / "scripts"
+    personal_scripts = NEXO_HOME / "personal" / "scripts"
+    stub_marker = "# Auto-generated by NEXO F0.6 personal import shim."
+
+    def _same_file(a: Path, b: Path) -> bool:
+        try:
+            return a.is_file() and b.is_file() and a.read_bytes() == b.read_bytes()
+        except Exception:
+            return False
+
+    def _managed_stub(path: Path) -> bool:
+        try:
+            return path.is_file() and path.read_text(encoding="utf-8", errors="ignore").startswith(stub_marker)
+        except Exception:
+            return False
+
+    def _write_stub(shim: Path, target: Path) -> None:
+        relative = os.path.relpath(str(target), str(shim.parent))
+        shim.write_text(
+            f"""{stub_marker}
+from __future__ import annotations
+
+import importlib.util as _importlib_util
+from pathlib import Path as _Path
+
+_TARGET = (_Path(__file__).resolve().parent / {relative!r}).resolve()
+_SPEC = _importlib_util.spec_from_file_location("_nexo_core_personal_automation", _TARGET)
+if _SPEC is None or _SPEC.loader is None:
+    raise ImportError(f"Cannot load NEXO core helper at {{_TARGET}}")
+_MODULE = _importlib_util.module_from_spec(_SPEC)
+_SPEC.loader.exec_module(_MODULE)
+__all__ = getattr(_MODULE, "__all__", [name for name in vars(_MODULE) if not name.startswith("_")])
+globals().update({{name: getattr(_MODULE, name) for name in __all__}})
+""",
+            encoding="utf-8",
+        )
+
+    try:
+        personal_scripts.mkdir(parents=True, exist_ok=True)
+    except Exception as exc:
+        _log(f"[F0.6 shim] could not create personal/scripts for import shims: {exc}")
+        return
+
+    for name in helper_names:
+        target = core_scripts / name
+        if not target.is_file():
+            continue
+        shim = personal_scripts / name
+
+        if shim.is_symlink():
+            try:
+                if shim.resolve(strict=False) == target.resolve(strict=False):
+                    continue
+            except Exception:
+                pass
+            try:
+                shim.unlink()
+            except Exception as exc:
+                _log(f"[F0.6 shim] could not replace personal import symlink {name}: {exc}")
+                continue
+
+        if shim.exists():
+            if shim.is_file() and (_same_file(shim, target) or _managed_stub(shim)):
+                try:
+                    shim.unlink()
+                except Exception as exc:
+                    _log(f"[F0.6 shim] could not replace personal import copy {name}: {exc}")
+                    continue
+            else:
+                _log(f"[F0.6 shim] preserving distinct personal import helper {shim}")
+                continue
+
+        try:
+            relative = os.path.relpath(str(target), str(shim.parent))
+            shim.symlink_to(relative)
+            continue
+        except Exception as exc:
+            _log(f"[F0.6 shim] symlink create failed for personal import helper {name}: {exc}")
+
+        try:
+            _write_stub(shim, target)
+        except Exception as exc:
+            _log(f"[F0.6 shim] stub create failed for personal import helper {name}: {exc}")
+
+
 def _rewrite_f06_launch_agents() -> int:
     """Rewrite lingering LaunchAgent paths to canonical F0.6 locations."""
     import re as _re
@@ -3258,6 +3376,7 @@ def _maybe_migrate_to_f06_layout() -> None:
             _promote_packaged_runtime_code_to_core()
             if _f06_live_legacy_paths():
                 _ensure_f06_legacy_shims()
+            _ensure_f06_personal_script_import_shims()
             _cleanup_f06_root_residue()
             try:
                 _rewrite_f06_launch_agents()
@@ -3477,6 +3596,7 @@ def _maybe_migrate_to_f06_layout() -> None:
         except Exception as e:
             _log(f"[F0.6] marker write failed: {e}")
         _ensure_f06_legacy_shims()
+        _ensure_f06_personal_script_import_shims()
         _cleanup_f06_root_residue()
         try:
             rewritten = _rewrite_f06_launch_agents()

package/src/cognitive/__init__.py

@@ -17,6 +17,8 @@ from cognitive._core import (
     _get_db, _init_tables, _migrate_lifecycle, _migrate_co_activation,
     _migrate_memory_personalization,
     _auto_migrate_embeddings,
+    embedding_migration_status,
+    _active_embedding_context, _row_embedding_array, _embedding_migration_uses_shadow,
     _get_model, _get_reranker, rerank_results,
     embed, cosine_similarity, _array_to_blob, _blob_to_array,
     extract_temporal_date, redact_secrets,