nexo-brain 7.9.8 → 7.9.10

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.8",
+  "version": "7.9.10",
   "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,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.8` is the current packaged-runtime line. Hotfix release over `7.9.7`: packaged installs that already run from `~/.nexo/core/current -> versions/<version>` no longer mistake that managed snapshot for a mutable source checkout during `nexo update`. The updater now stays on the packaged path unless `version.json` points to a real external repo, so installed users stop “updating” from the old runtime back into itself. Coordinated Desktop v0.28.10 bundles the same fix.
+Version `7.9.10` is the current packaged-runtime line. Hotfix release over `7.9.9`: `nexo_doctor` now defaults blank calls to `runtime_personal` instead of failing on missing `plane`, and non-interactive installer/update paths preserve existing identity defaults from runtime profile/calibration metadata instead of blindly rewriting operators to generic onboarding defaults. Desktop remains at v0.28.11 because the extra fixes are Brain-only.
 
 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/bin/nexo-brain.js

@@ -252,6 +252,24 @@ function readRuntimeCalibration(nexoHome = NEXO_HOME) {
   return { path: null, payload: null };
 }
 
+function profilePathCandidates(nexoHome = NEXO_HOME) {
+  return [
+    path.join(nexoHome, "personal", "brain", "profile.json"),
+    path.join(nexoHome, "brain", "profile.json"),
+  ];
+}
+
+function readRuntimeProfile(nexoHome = NEXO_HOME) {
+  for (const filePath of profilePathCandidates(nexoHome)) {
+    if (!fs.existsSync(filePath)) continue;
+    const payload = readJsonFile(filePath);
+    if (payload && typeof payload === "object") {
+      return { path: filePath, payload };
+    }
+  }
+  return { path: null, payload: null };
+}
+
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
@@ -288,6 +306,55 @@ function hasPartialPlaceholderCalibration(calibration) {
   return isPlaceholderUserName(name) || !nonEmptyString(language);
 }
 
+function firstMeaningfulString(...values) {
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    const clean = value.trim();
+    if (clean) return clean;
+  }
+  return "";
+}
+
+function normalizeLanguageCode(value) {
+  const clean = String(value || "").trim().toLowerCase().replace("_", "-");
+  if (!clean) return "";
+  return clean.split("-")[0];
+}
+
+function resolveExistingIdentityDefaults(nexoHome = NEXO_HOME) {
+  const calibration = readRuntimeCalibration(nexoHome).payload || {};
+  const user = calibration.user && typeof calibration.user === "object" ? calibration.user : {};
+  const profile = readRuntimeProfile(nexoHome).payload || {};
+  const version = readJsonFile(path.join(nexoHome, "version.json")) || {};
+
+  const userName = firstMeaningfulString(
+    user.name,
+    calibration.user_name,
+    profile.user_name,
+    version.user_name,
+  );
+  const language = normalizeLanguageCode(firstMeaningfulString(
+    user.language,
+    calibration.language,
+    profile.language,
+    version.language,
+  ));
+  const operatorName = firstMeaningfulString(
+    user.assistant_name,
+    calibration.assistant_name,
+    calibration.operator_name,
+    profile.assistant_name,
+    profile.operator_name,
+    version.operator_name,
+  );
+
+  return {
+    userName: !isPlaceholderUserName(userName) ? userName : "",
+    language,
+    operatorName: !isReservedAssistantName(operatorName) ? operatorName : "",
+  };
+}
+
 function ensureOnboardingCompletionMarker(nexoHome = NEXO_HOME) {
   const record = readRuntimeCalibration(nexoHome);
   if (!record.path || !isOnboardingComplete(record.payload)) {
@@ -684,6 +751,59 @@ function finalizeF06Layout(python, nexoHome = NEXO_HOME) {
   }
 }
 
+function readRuntimeVersionFrom(basePath) {
+  if (!basePath) return "";
+  for (const candidate of [
+    path.join(basePath, "version.json"),
+    path.join(basePath, "package.json"),
+  ]) {
+    try {
+      if (!fs.existsSync(candidate)) continue;
+      const payload = JSON.parse(fs.readFileSync(candidate, "utf8"));
+      const version = String(payload.version || "").trim();
+      if (version) return version;
+    } catch (_) {}
+  }
+  return "";
+}
+
+function readActiveRuntimeSnapshotVersion(nexoHome = NEXO_HOME) {
+  return readRuntimeVersionFrom(path.join(nexoHome, "core", "current"));
+}
+
+function activateVersionedRuntimeSnapshot(python, nexoHome = NEXO_HOME, version = "") {
+  try {
+    const srcDir = path.join(__dirname, "..", "src");
+    const inline = [
+      "import json, os, pathlib, sys",
+      `sys.path.insert(0, ${JSON.stringify(srcDir)})`,
+      "from runtime_versioning import activate_versioned_runtime_snapshot",
+      "home = pathlib.Path(os.environ['NEXO_HOME'])",
+      `result = activate_versioned_runtime_snapshot(source_root=home / 'core', version=${JSON.stringify(version)})`,
+      "print(json.dumps(result))",
+    ].join("; ");
+    const result = spawnSync(python, ["-c", inline], {
+      cwd: nexoHome,
+      env: {
+        ...process.env,
+        NEXO_HOME: nexoHome,
+      },
+      encoding: "utf8",
+    });
+    if (result.status !== 0) {
+      const detail = (result.stderr || result.stdout || "").trim();
+      throw new Error(detail || "activation command failed");
+    }
+    const payload = JSON.parse(String(result.stdout || "{}").trim() || "{}");
+    if (!payload || payload.ok !== true) {
+      throw new Error(payload && payload.error ? payload.error : "activation returned not-ok");
+    }
+    return payload;
+  } catch (err) {
+    return { ok: false, error: String((err && err.message) || err) };
+  }
+}
+
 function getCoreRuntimeFlatFiles(srcDir = path.join(__dirname, "..", "src")) {
   const staticFiles = [
     "server.py",
@@ -2296,10 +2416,17 @@ async function runSetup() {
       const currentPkg = readPackageJson();
       const installedVersion = installed.version || "0.0.0";
       const currentVersion = currentPkg.version;
-
-      if (installedVersion !== currentVersion) {
-        log(`Existing installation detected: v${installedVersion} → v${currentVersion}`);
-        log("Running auto-migration...");
+      const activeRuntimeVersion = readActiveRuntimeSnapshotVersion(NEXO_HOME);
+      const needsRuntimeRepair = activeRuntimeVersion !== currentVersion;
+
+      if (installedVersion !== currentVersion || needsRuntimeRepair) {
+        if (installedVersion !== currentVersion) {
+          log(`Existing installation detected: v${installedVersion} → v${currentVersion}`);
+          log("Running auto-migration...");
+        } else {
+          log(`Existing installation detected: metadata v${installedVersion}, runtime core/current v${activeRuntimeVersion || "missing"}`);
+          log("Repairing active runtime snapshot...");
+        }
 
         // Recursive copy helper (skips __pycache__, .pyc, .db files)
         const srcDir = path.join(__dirname, "..", "src");
@@ -2469,6 +2596,9 @@ async function runSetup() {
           installed_at: installed.installed_at,
           updated_at: new Date().toISOString(),
           migrated_from: installedVersion,
+          ...(installedVersion === currentVersion && activeRuntimeVersion && activeRuntimeVersion !== currentVersion
+            ? { runtime_repaired_from: activeRuntimeVersion }
+            : {}),
         }, null, 2));
         syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
         log("Finalizing F0.6 runtime layout...");
@@ -2476,6 +2606,11 @@ async function runSetup() {
         if (!migLayoutFinalize.ok) {
           throw new Error(`F0.6 layout finalization failed: ${migLayoutFinalize.error}`);
         }
+        const migActivation = activateVersionedRuntimeSnapshot(migPython, NEXO_HOME, currentVersion);
+        if (!migActivation.ok) {
+          throw new Error(`Runtime activation failed: ${migActivation.error}`);
+        }
+        log(`  Runtime activation: core/current -> versions/${currentVersion}`);
 
         // Keep the rendered template in-memory for version tracking, but do
         // not drop a loose reference file in NEXO_HOME root.
@@ -2898,9 +3033,11 @@ async function runSetup() {
     },
   };
 
+  const existingIdentity = resolveExistingIdentityDefaults(NEXO_HOME);
+
   // Detect language from input or use default
-  let lang = "en";
-  let t = i18n.en;
+  let lang = existingIdentity.language || "en";
+  let t = i18n[lang] || i18n.en;
   if (!useDefaults) {
     const langInput = await ask("  What's your preferred language? / ¿En qué idioma prefieres hablar?\n  > ");
     const langLower = langInput.trim().toLowerCase();
@@ -2941,7 +3078,7 @@ async function runSetup() {
   // Step 2: User's name (P2) — v6.0.0 empty input falls through to "Usuario"
   // instead of keeping an empty string. The calibration file always ships
   // with a concrete user.name so downstream tooling does not need guards.
-  let userName = "Usuario";
+  let userName = existingIdentity.userName || "Usuario";
   if (!useDefaults) {
     const nameInput = await ask(t.askUserName);
     const trimmedName = nameInput.trim();
@@ -2953,7 +3090,7 @@ async function runSetup() {
   }
 
   // Step 3: Agent name (P3)
-  let operatorName = DEFAULT_ASSISTANT_NAME;
+  let operatorName = existingIdentity.operatorName || DEFAULT_ASSISTANT_NAME;
   if (!useDefaults) {
     while (true) {
       const name = await ask(t.askAgentName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.8",
+  "version": "7.9.10",
   "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/doctor/planes.py

@@ -28,6 +28,7 @@ VALID_DIAGNOSTIC_PLANES = {
 }
 
 DOCTOR_COMPATIBLE_PLANES = {"runtime_personal", "installation_live", "database_real"}
+DEFAULT_DOCTOR_PLANE = "runtime_personal"
 
 
 def normalize_diagnostic_plane(plane: str = "") -> str:
@@ -40,15 +41,19 @@ def diagnostic_plane_choices() -> list[str]:
 
 
 def diagnostic_plane_preflight(plane: str = "") -> tuple[str, DoctorCheck | None]:
-    clean_plane = normalize_diagnostic_plane(plane)
+    raw_plane = str(plane or "").strip()
+    if not raw_plane:
+        return DEFAULT_DOCTOR_PLANE, None
+
+    clean_plane = normalize_diagnostic_plane(raw_plane)
     if not clean_plane:
         options = ", ".join(diagnostic_plane_choices())
         return "", DoctorCheck(
-            id="orchestrator.diagnostic_plane_required",
+            id="orchestrator.diagnostic_plane_invalid",
             tier="orchestrator",
             status="critical",
             severity="error",
-            summary="El diagnóstico está bloqueado hasta fijar explícitamente el plano",
+            summary=f"Plano diagnóstico desconocido: {raw_plane}",
             evidence=[
                 f"planes válidos: {options}",
                 "Usa `runtime_personal` para ~/.nexo y hábitos del runtime; `installation_live` para hooks/clientes/instalación; `database_real` para filas y schema reales.",
@@ -58,8 +63,7 @@ def diagnostic_plane_preflight(plane: str = "") -> tuple[str, DoctorCheck | None
                 "Si el problema pertenece a producto público o al co-operador, usa el surface correcto en vez de NEXO Doctor.",
             ],
             escalation_prompt=(
-                "NEXO mezcló planos en diagnósticos anteriores. El doctor no debe correr hasta que se elija "
-                "explícitamente si el problema está en producto público, runtime personal, instalación viva, BD real o co-operador."
+                "El plano elegido no existe. Repite el diagnóstico con un plano válido para evitar mezclar runtime, instalación, BD real o surfaces ajenas al doctor."
             ),
         )
 

package/src/plugins/doctor.py

@@ -22,26 +22,11 @@ def handle_doctor(tier: str = "boot", fix: bool = False, output: str = "text", p
     """
     from doctor.orchestrator import run_doctor
     from doctor.formatters import format_report
-    from doctor.planes import diagnostic_plane_choices
 
     if tier not in ("boot", "runtime", "deep", "all"):
         return f"Invalid tier '{tier}'. Use: boot, runtime, deep, all"
     if output not in ("text", "json"):
         return f"Invalid output '{output}'. Use: text, json"
-    if not (plane or "").strip():
-        valid_planes = diagnostic_plane_choices()
-        if output == "json":
-            return (
-                "{"
-                f"\"ok\": false, \"error\": \"Missing required argument: plane\", "
-                "\"missing_argument\": \"plane\", "
-                f"\"valid_planes\": {valid_planes!r}"
-                "}"
-            ).replace("'", '"')
-        return (
-            "Missing required argument: plane. "
-            f"Use one of: {', '.join(valid_planes)}."
-        )
 
     report = run_doctor(tier=tier, fix=fix, plane=plane)
     return format_report(report, fmt=output)