nexo-brain 6.5.0 → 7.1.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "6.5.0",
+  "version": "7.1.0",
   "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",
@@ -26,7 +26,7 @@
   "hooks": "./hooks/hooks.json",
   "userConfig": {
     "operator_name": {
-      "description": "What should your AI co-operator call itself? (default: NEXO)",
+      "description": "What should your AI co-operator call itself? (default: Nova)",
       "sensitive": false
     }
   }

package/README.md

@@ -18,7 +18,11 @@
 
 [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 `6.5.0` is the current packaged-runtime line — Plan Consolidado fase F0.2: operators can now `nexo scripts enable|disable|status <name>` any personal automation. The cron wrapper honours the flag at every tick (`exit 0` with `summary='[disabled]'` while the LaunchAgent stays loaded). The companion NEXO Desktop client (a closed-source product, distributed separately) wires the same toggle into its Automatizaciones panel. See [CHANGELOG](CHANGELOG.md) for the full diff.
+Version `7.1.0` is the current packaged-runtime line. It closes the post-F0.6 runtime contract: `~/.nexo/core` is now the canonical shipped code root, layout healers re-run automatically after sync/update, Desktop consumes a Brain-generated Guardian runtime snapshot instead of stale manual lists, the core automation surface now officially includes `email-monitor`, `followup-runner`, and `morning-agent`, and the local classifier baseline auto-installs on fresh installs / `nexo update` unless the operator explicitly opts out with `NEXO_LOCAL_CLASSIFIER=off`. The companion NEXO Desktop client (v0.22.0, closed-source distributed separately) turns that same contract into a closed bootstrap/login/product flow.
+
+Previously in `7.0.1`: hotfix over v7.0.0 (db._core.DB_PATH was only caller still hardcoded to legacy ~/.nexo/data/nexo.db; every shared-DB command silently returned empty results post-migration). Previously in `7.0.0`: **BREAKING — Plan Consolidado fase F0.6**: physical separation of the runtime tree into `~/.nexo/{core,personal,runtime}/`. The flat layout (`~/.nexo/scripts/`, `brain/`, `data/`, `operations/`, ...) is gone. Operators on v6.x are auto-migrated on first `nexo update`; fresh installs land directly in the new tree. New `paths.py` helpers are transition-aware.
+
+Previously in `6.5.0`: Plan Consolidado fase F0.2: operators can now `nexo scripts enable|disable|status <name>` any personal automation. The cron wrapper honours the flag at every tick (`exit 0` with `summary='[disabled]'` while the LaunchAgent stays loaded). The companion NEXO Desktop client (a closed-source product, distributed separately) wires the same toggle into its Automatizaciones panel. See [CHANGELOG](CHANGELOG.md) for the full diff.
 
 > **About NEXO Desktop.** NEXO Desktop is a separate closed-source companion app distributed at [systeam.es/nexo-desktop](https://systeam.es/nexo-desktop) — its source does not live in this repo. When release notes mention Desktop they describe a coordinated client release that consumes the Brain's CLI / MCP contract; the Brain itself is fully usable on its own (terminal, Codex, Claude Code, or any MCP client).
 
@@ -792,7 +796,7 @@ npx nexo-brain
 The installer handles everything and syncs the same `nexo` MCP brain into Claude Code, Claude Desktop, and Codex when those clients are present:
 
 ```
-  How should I call myself? (default: NEXO) > Atlas
+  How should I call myself? (default: Nova) > Atlas
 
   Can I explore your workspace to learn about your projects? (y/n) > y
 

package/bin/nexo-brain.js

@@ -21,6 +21,23 @@ const path = require("path");
 const readline = require("readline");
 
 let NEXO_HOME = process.env.NEXO_HOME || path.join(require("os").homedir(), ".nexo");
+const DEFAULT_ASSISTANT_NAME = "Nova";
+const RESERVED_ASSISTANT_NAME_KEYS = new Set(["nexo", "nexobrain", "nexodesktop"]);
+
+function normalizeAssistantNameCandidate(value) {
+  return String(value || "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+
+function isReservedAssistantName(value) {
+  const normalized = normalizeAssistantNameCandidate(value);
+  if (!normalized) return false;
+  for (const reserved of RESERVED_ASSISTANT_NAME_KEYS) {
+    if (normalized === reserved || normalized.includes(reserved)) {
+      return true;
+    }
+  }
+  return false;
+}
 
 function shouldSkipShellProfileBackfill() {
   // Mirror of _should_skip_shell_profile_backfill() in src/auto_update.py.
@@ -197,10 +214,11 @@ function isDuplicateArtifactName(name, dirPath = "") {
 
 function syncWatchdogHashRegistry(nexoHome) {
   try {
-    const watchdogPath = path.join(nexoHome, "scripts", "nexo-watchdog.sh");
+    const scriptsDir = runtimeScriptsDir(nexoHome);
+    const watchdogPath = path.join(scriptsDir, "nexo-watchdog.sh");
     if (!fs.existsSync(watchdogPath)) return;
 
-    const registryPath = path.join(nexoHome, "scripts", ".watchdog-hashes");
+    const registryPath = path.join(scriptsDir, ".watchdog-hashes");
     const entries = new Map();
     if (fs.existsSync(registryPath)) {
       for (const line of fs.readFileSync(registryPath, "utf8").split(/\r?\n/)) {
@@ -222,6 +240,40 @@ function syncWatchdogHashRegistry(nexoHome) {
   }
 }
 
+function runtimeCodeDir(nexoHome) {
+  const coreDir = path.join(nexoHome, "core");
+  for (const candidate of [coreDir, nexoHome]) {
+    if (
+      fs.existsSync(path.join(candidate, "cli.py")) ||
+      fs.existsSync(path.join(candidate, "server.py")) ||
+      fs.existsSync(path.join(candidate, "db"))
+    ) {
+      return candidate;
+    }
+  }
+  return fs.existsSync(coreDir) ? coreDir : nexoHome;
+}
+
+function runtimeServerPath(nexoHome) {
+  const codeDir = runtimeCodeDir(nexoHome);
+  if (fs.existsSync(path.join(codeDir, "server.py"))) {
+    return path.join(codeDir, "server.py");
+  }
+  return path.join(nexoHome, "server.py");
+}
+
+function runtimeHooksDir(nexoHome) {
+  const codeDir = runtimeCodeDir(nexoHome);
+  const hooksDir = path.join(codeDir, "hooks");
+  return fs.existsSync(hooksDir) ? hooksDir : path.join(nexoHome, "hooks");
+}
+
+function runtimeScriptsDir(nexoHome) {
+  const codeDir = runtimeCodeDir(nexoHome);
+  const scriptsDir = path.join(codeDir, "scripts");
+  return fs.existsSync(scriptsDir) ? scriptsDir : path.join(nexoHome, "scripts");
+}
+
 function writeRuntimeCoreArtifactsManifest(nexoHome, srcDir) {
   try {
     const listTopLevelFiles = (dirPath) => {
@@ -233,17 +285,23 @@ function writeRuntimeCoreArtifactsManifest(nexoHome, srcDir) {
         })
         .sort();
     };
-    const configDir = path.join(nexoHome, "config");
-    fs.mkdirSync(configDir, { recursive: true });
     const payload = {
       generated_at: new Date().toISOString(),
       script_names: listTopLevelFiles(path.join(srcDir, "scripts")),
       hook_names: listTopLevelFiles(path.join(srcDir, "hooks")),
     };
-    fs.writeFileSync(
-      path.join(configDir, "runtime-core-artifacts.json"),
-      `${JSON.stringify(payload, null, 2)}\n`
-    );
+    const manifestBody = `${JSON.stringify(payload, null, 2)}\n`;
+    const configDirs = [
+      path.join(nexoHome, "config"),
+      path.join(nexoHome, "personal", "config"),
+    ];
+    const seen = new Set();
+    for (const configDir of configDirs) {
+      if (seen.has(configDir)) continue;
+      seen.add(configDir);
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(path.join(configDir, "runtime-core-artifacts.json"), manifestBody);
+    }
   } catch (err) {
     log(`WARN: could not write runtime core-artifacts manifest: ${err.message}`);
   }
@@ -260,6 +318,44 @@ function syncRuntimePackageMetadata(repoRoot = path.join(__dirname, ".."), runti
   }
 }
 
+function finalizeF06Layout(python, nexoHome = NEXO_HOME) {
+  try {
+    const result = spawnSync(
+      python,
+      [
+        "-c",
+        [
+          "import auto_update",
+          "auto_update._maybe_migrate_to_f06_layout()",
+          "auto_update._ensure_f06_legacy_shims()",
+          "auto_update._rewrite_f06_launch_agents()",
+        ].join("; "),
+      ],
+      {
+        cwd: nexoHome,
+        env: {
+          ...process.env,
+          NEXO_HOME: nexoHome,
+          NEXO_CODE: runtimeCodeDir(nexoHome),
+          PYTHONPATH: nexoHome,
+        },
+        encoding: "utf8",
+      },
+    );
+    if (result.status !== 0) {
+      const detail = (result.stderr || result.stdout || "").trim();
+      throw new Error(detail || "unknown error");
+    }
+    const marker = path.join(nexoHome, ".structure-version");
+    if (!fs.existsSync(marker) || fs.readFileSync(marker, "utf8").trim() !== "F0.6") {
+      throw new Error("F0.6 structure marker missing after layout finalization");
+    }
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: String((err && err.message) || err) };
+  }
+}
+
 function getCoreRuntimeFlatFiles(srcDir = path.join(__dirname, "..", "src")) {
   const staticFiles = [
     "server.py",
@@ -648,8 +744,9 @@ function _hookCommand(hook, hooksDir, nexoHome) {
 }
 
 function _writeHooksStatus(nexoHome, manifestEntries, registrations) {
-  // Publish ~/.nexo/hooks_status.json so NEXO Desktop can render the
-  // "Hooks activos X/Y" widget without peeking into settings.json.
+  // Publish the canonical hook-health contract under runtime/operations/.
+  // Keep ~/.nexo/hooks_status.json only as a legacy alias so the root tree
+  // does not remain the live source of truth.
   try {
     const now = new Date();
     const pkgJson = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
@@ -664,19 +761,34 @@ function _writeHooksStatus(nexoHome, manifestEntries, registrations) {
       healthy,
       hooks: registrations,
     };
-    fs.mkdirSync(nexoHome, { recursive: true });
-    fs.writeFileSync(
-      path.join(nexoHome, "hooks_status.json"),
-      JSON.stringify(payload, null, 2) + "\n",
-    );
+    const body = JSON.stringify(payload, null, 2) + "\n";
+    const canonicalDir = path.join(nexoHome, "runtime", "operations");
+    const canonicalPath = path.join(canonicalDir, "hooks_status.json");
+    const legacyPath = path.join(nexoHome, "hooks_status.json");
+
+    fs.mkdirSync(canonicalDir, { recursive: true });
+    fs.writeFileSync(canonicalPath, body);
+
+    try {
+      if (fs.existsSync(legacyPath) || fs.lstatSync(legacyPath).isSymbolicLink()) {
+        fs.rmSync(legacyPath, { force: true });
+      }
+    } catch (_) {}
+
+    try {
+      const relTarget = path.relative(path.dirname(legacyPath), canonicalPath) || path.basename(canonicalPath);
+      fs.symlinkSync(relTarget, legacyPath);
+    } catch (_) {
+      fs.writeFileSync(legacyPath, body);
+    }
   } catch (_) {}
 }
 
 /**
  * Register every hook declared by src/hooks/manifest.json into the
  * Claude Code settings file. Idempotent, never removes user-owned hooks.
- * Writes ~/.nexo/hooks_status.json after each run so NEXO Desktop can
- * display hook health without parsing settings.json.
+ * Writes the canonical hook-status contract after each run so NEXO Desktop
+ * can display hook health without parsing settings.json.
  */
 function registerAllCoreHooks(settings, hooksDir, nexoHome) {
   if (!settings.hooks) settings.hooks = {};
@@ -904,7 +1016,9 @@ function detectInstalledClients() {
     ? [path.join(homeDir, "Applications", "Claude.app"), "/Applications/Claude.app"]
     : [];
   const desktopAppPath = desktopApps.find((candidate) => fs.existsSync(candidate)) || "";
-  const claudeBin = run("which claude") || "";
+  const managedClaudeBin = resolveManagedClaudeBinary();
+  const persistedClaudeBin = readPersistedClaudeCliPath();
+  const claudeBin = managedClaudeBin || persistedClaudeBin || run("which claude", { env: buildManagedCliEnv() }) || run("which claude") || "";
   const codexBin = run("which codex") || "";
   return {
     claude_code: {
@@ -925,6 +1039,64 @@ function detectInstalledClients() {
   };
 }
 
+function managedClaudePrefix() {
+  const explicit = String(process.env.NEXO_CLAUDE_PREFIX || "").trim();
+  if (explicit) return explicit;
+  return path.join(NEXO_HOME, "runtime", "bootstrap", "npm-global");
+}
+
+function buildManagedCliEnv(extraEnv = {}) {
+  const prefix = managedClaudePrefix();
+  const parts = [
+    path.join(prefix, "bin"),
+    process.env.PATH || "",
+  ].filter(Boolean);
+  return {
+    ...process.env,
+    npm_config_prefix: prefix,
+    PATH: parts.join(path.delimiter),
+    ...extraEnv,
+  };
+}
+
+function resolveManagedClaudeBinary() {
+  const prefix = managedClaudePrefix();
+  const candidates = process.platform === "win32"
+    ? [path.join(prefix, "claude.cmd"), path.join(prefix, "bin", "claude.cmd")]
+    : [path.join(prefix, "bin", "claude"), path.join(prefix, "claude")];
+  return candidates.find((candidate) => candidate && fs.existsSync(candidate)) || "";
+}
+
+function readPersistedClaudeCliPath() {
+  const candidates = [
+    path.join(NEXO_HOME, "config", "claude-cli-path"),
+    path.join(NEXO_HOME, "personal", "config", "claude-cli-path"),
+  ];
+  for (const file of candidates) {
+    try {
+      if (!fs.existsSync(file)) continue;
+      const value = String(fs.readFileSync(file, "utf8") || "").trim();
+      if (value && fs.existsSync(value)) return value;
+    } catch {}
+  }
+  return "";
+}
+
+function persistClaudeCliPath(claudePath) {
+  const value = String(claudePath || "").trim();
+  if (!value) return;
+  const targets = [
+    path.join(NEXO_HOME, "config", "claude-cli-path"),
+    path.join(NEXO_HOME, "personal", "config", "claude-cli-path"),
+  ];
+  for (const file of targets) {
+    try {
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, value);
+    } catch {}
+  }
+}
+
 function clientSetupStrings(lang) {
   if (lang === "es") {
     return {
@@ -1092,17 +1264,48 @@ function requiredCliClients(setup) {
 }
 
 function installClaudeCodeCli(platform) {
-  let claudeInstalled = run("which claude");
-  if (claudeInstalled) return { installed: true, path: claudeInstalled };
+  let claudeInstalled = detectInstalledClients().claude_code.path || "";
+  if (claudeInstalled) {
+    persistClaudeCliPath(claudeInstalled);
+    return { installed: true, path: claudeInstalled };
+  }
+
+  const installEnv = buildManagedCliEnv();
+  const desktopNode = String(process.env.NEXO_DESKTOP_NODE || "").trim();
+  const bundledNpmCli = String(process.env.NEXO_DESKTOP_NPM_CLI || "").trim();
+  const managedPrefix = managedClaudePrefix();
+
+  if (desktopNode && bundledNpmCli) {
+    spawnSync(
+      desktopNode,
+      [bundledNpmCli, "install", "-g", "--prefix", managedPrefix, "@anthropic-ai/claude-code"],
+      {
+        stdio: "inherit",
+        env: { ...installEnv, ELECTRON_RUN_AS_NODE: "1" },
+      },
+    );
+    claudeInstalled = detectInstalledClients().claude_code.path || "";
+    if (claudeInstalled) {
+      persistClaudeCliPath(claudeInstalled);
+      return { installed: true, path: claudeInstalled };
+    }
+  }
 
-  spawnSync("npx", ["-y", "@anthropic-ai/claude-code", "--version"], { stdio: "pipe", timeout: 60000 });
-  claudeInstalled = run("which claude");
+  spawnSync("npx", ["-y", "@anthropic-ai/claude-code", "--version"], {
+    stdio: "pipe",
+    timeout: 60000,
+    env: installEnv,
+  });
+  claudeInstalled = detectInstalledClients().claude_code.path || "";
   if (!claudeInstalled) {
     const npmCmd = platform === "linux" ? "sudo" : "npm";
-    const npmArgs = platform === "linux" ? ["npm", "install", "-g", "@anthropic-ai/claude-code"] : ["install", "-g", "@anthropic-ai/claude-code"];
-    spawnSync(npmCmd, npmArgs, { stdio: "inherit" });
-    claudeInstalled = run("which claude");
+    const npmArgs = platform === "linux"
+      ? ["npm", "install", "-g", "@anthropic-ai/claude-code"]
+      : ["install", "-g", "--prefix", managedPrefix, "@anthropic-ai/claude-code"];
+    spawnSync(npmCmd, npmArgs, { stdio: "inherit", env: installEnv });
+    claudeInstalled = detectInstalledClients().claude_code.path || "";
   }
+  if (claudeInstalled) persistClaudeCliPath(claudeInstalled);
   return { installed: Boolean(claudeInstalled), path: claudeInstalled || "" };
 }
 
@@ -1642,6 +1845,7 @@ async function main() {
     || process.argv.includes("--yes")
     || process.argv.includes("--skip")
     || process.argv.includes("-y");
+  const smokeTestMode = process.env.NEXO_TESTING_SMOKE === "1";
 
   console.log("");
   console.log(
@@ -1847,11 +2051,16 @@ async function main() {
           migrated_from: installedVersion,
         }, null, 2));
         syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
+        log("Finalizing F0.6 runtime layout...");
+        const migLayoutFinalize = finalizeF06Layout(migPython, NEXO_HOME);
+        if (!migLayoutFinalize.ok) {
+          throw new Error(`F0.6 layout finalization failed: ${migLayoutFinalize.error}`);
+        }
 
         // Save updated CLAUDE.md template as reference (don't overwrite user's)
         const templateSrc = path.join(__dirname, "..", "templates", "CLAUDE.md.template");
         if (fs.existsSync(templateSrc)) {
-          const operatorName = installed.operator_name || "NEXO";
+          const operatorName = installed.operator_name || DEFAULT_ASSISTANT_NAME;
           let claudeMd = fs.readFileSync(templateSrc, "utf8")
             .replace(/\{\{NAME\}\}/g, operatorName)
             .replace(/\{\{NEXO_HOME\}\}/g, NEXO_HOME);
@@ -1874,7 +2083,7 @@ async function main() {
         }
 
         // Restore operator shell alias + PATH if lost during previous updates
-        const migOperatorName = installed.operator_name || "NEXO";
+        const migOperatorName = installed.operator_name || DEFAULT_ASSISTANT_NAME;
         const migAliasName = migOperatorName.toLowerCase();
         if (migAliasName !== "nexo") {
           const migSkip = shouldSkipShellProfileBackfill();
@@ -2003,6 +2212,11 @@ async function main() {
           }
         }
       }
+      log("Finalizing F0.6 runtime layout...");
+      const syncLayoutFinalize = finalizeF06Layout(syncPython, NEXO_HOME);
+      if (!syncLayoutFinalize.ok) {
+        throw new Error(`F0.6 layout finalization failed: ${syncLayoutFinalize.error}`);
+      }
 
       logMacPermissionsNotice(NEXO_HOME, syncPython);
 
@@ -2069,8 +2283,9 @@ async function main() {
       dataDirConfirm: (p) => `Data directory: ${p}`,
       askUserName: "  What's your name? > ",
       userGreet: (n) => `Nice to meet you, ${n}.`,
-      askAgentName: "  What should I call myself? (default: NEXO) > ",
+      askAgentName: `  What should I call myself? (default: ${DEFAULT_ASSISTANT_NAME}) > `,
       agentConfirm: (n) => `Got it. I'm ${n}.`,
+      agentNameReserved: "That name is reserved for the product. Pick a different assistant name.",
       calibTitle: "Let's calibrate my personality to work best with you.",
       calibNote: "(You can change these anytime via nexo_preference_set)",
       autonomyQ: "  How autonomous should I be?\n    1. Conservative — ask before most actions\n    2. Balanced — act on routine, ask on important\n    3. Full — act first, inform after, only ask when truly uncertain\n  > ",
@@ -2101,8 +2316,9 @@ async function main() {
       dataDirConfirm: (p) => `Directorio de datos: ${p}`,
       askUserName: "  ¿Cómo te llamas? > ",
       userGreet: (n) => `Encantado, ${n}.`,
-      askAgentName: "  ¿Cómo quieres que me llame? (default: NEXO) > ",
+      askAgentName: `  ¿Cómo quieres que me llame? (default: ${DEFAULT_ASSISTANT_NAME}) > `,
       agentConfirm: (n) => `Perfecto, soy ${n}.`,
+      agentNameReserved: "Ese nombre está reservado para el producto. Elige otro nombre para el asistente.",
       calibTitle: "Vamos a calibrar mi personalidad para trabajar mejor contigo.",
       calibNote: "(Puedes cambiar esto en cualquier momento con nexo_preference_set)",
       autonomyQ: "  ¿Cuánta autonomía me das?\n    1. Conservador — pregunto antes de casi todo\n    2. Equilibrado — actúo en lo rutinario, pregunto en lo importante\n    3. Total — actúo primero, informo después, solo pregunto si hay duda real\n  > ",
@@ -2133,8 +2349,9 @@ async function main() {
       dataDirConfirm: (p) => `Répertoire de données : ${p}`,
       askUserName: "  Comment tu t'appelles ? > ",
       userGreet: (n) => `Enchanté, ${n}.`,
-      askAgentName: "  Comment veux-tu m'appeler ? (défaut: NEXO) > ",
+      askAgentName: `  Comment veux-tu m'appeler ? (défaut : ${DEFAULT_ASSISTANT_NAME}) > `,
       agentConfirm: (n) => `C'est noté. Je suis ${n}.`,
+      agentNameReserved: "Ce nom est réservé au produit. Choisis un autre nom pour l'assistant.",
       calibTitle: "Calibrons ma personnalité pour mieux travailler ensemble.",
       calibNote: "(Tu peux changer ça à tout moment avec nexo_preference_set)",
       autonomyQ: "  Quel niveau d'autonomie me donnes-tu ?\n    1. Conservateur — je demande avant presque tout\n    2. Équilibré — j'agis en routine, je demande pour l'important\n    3. Total — j'agis d'abord, j'informe après\n  > ",
@@ -2165,8 +2382,9 @@ async function main() {
       dataDirConfirm: (p) => `Datenverzeichnis: ${p}`,
       askUserName: "  Wie heißt du? > ",
       userGreet: (n) => `Freut mich, ${n}.`,
-      askAgentName: "  Wie soll ich heißen? (Standard: NEXO) > ",
+      askAgentName: `  Wie soll ich heißen? (Standard: ${DEFAULT_ASSISTANT_NAME}) > `,
       agentConfirm: (n) => `Alles klar. Ich bin ${n}.`,
+      agentNameReserved: "Dieser Name ist für das Produkt reserviert. Bitte wähle einen anderen Assistentennamen.",
       calibTitle: "Kalibrieren wir meine Persönlichkeit für die Zusammenarbeit.",
       calibNote: "(Jederzeit änderbar mit nexo_preference_set)",
       autonomyQ: "  Wie viel Autonomie gibst du mir?\n    1. Konservativ — frage vor fast allem\n    2. Ausgewogen — handle bei Routine, frage bei Wichtigem\n    3. Voll — handle zuerst, informiere danach\n  > ",
@@ -2197,8 +2415,9 @@ async function main() {
       dataDirConfirm: (p) => `Directory dati: ${p}`,
       askUserName: "  Come ti chiami? > ",
       userGreet: (n) => `Piacere, ${n}.`,
-      askAgentName: "  Come vuoi chiamarmi? (default: NEXO) > ",
+      askAgentName: `  Come vuoi chiamarmi? (default: ${DEFAULT_ASSISTANT_NAME}) > `,
       agentConfirm: (n) => `Perfetto, sono ${n}.`,
+      agentNameReserved: "Quel nome è riservato al prodotto. Scegli un altro nome per l'assistente.",
       calibTitle: "Calibriamo la mia personalità per lavorare meglio insieme.",
       calibNote: "(Puoi cambiare in qualsiasi momento con nexo_preference_set)",
       autonomyQ: "  Quanta autonomia mi dai?\n    1. Conservatore — chiedo prima di quasi tutto\n    2. Equilibrato — agisco nella routine, chiedo per le cose importanti\n    3. Totale — agisco prima, informo dopo\n  > ",
@@ -2229,8 +2448,9 @@ async function main() {
       dataDirConfirm: (p) => `Diretório de dados: ${p}`,
       askUserName: "  Como te chamas? > ",
       userGreet: (n) => `Prazer, ${n}.`,
-      askAgentName: "  Como queres que eu me chame? (padrão: NEXO) > ",
+      askAgentName: `  Como queres que eu me chame? (padrão: ${DEFAULT_ASSISTANT_NAME}) > `,
       agentConfirm: (n) => `Perfeito, sou ${n}.`,
+      agentNameReserved: "Esse nome está reservado para o produto. Escolhe outro nome para o assistente.",
       calibTitle: "Vamos calibrar a minha personalidade para trabalhar melhor contigo.",
       calibNote: "(Podes mudar a qualquer momento com nexo_preference_set)",
       autonomyQ: "  Quanta autonomia me dás?\n    1. Conservador — pergunto antes de quase tudo\n    2. Equilibrado — ajo na rotina, pergunto no importante\n    3. Total — ajo primeiro, informo depois\n  > ",
@@ -2312,8 +2532,19 @@ async function main() {
   }
 
   // Step 3: Agent name (P3)
-  const name = useDefaults ? "" : await ask(t.askAgentName);
-  const operatorName = name.trim() || "NEXO";
+  let operatorName = DEFAULT_ASSISTANT_NAME;
+  if (!useDefaults) {
+    while (true) {
+      const name = await ask(t.askAgentName);
+      const candidate = name.trim() || DEFAULT_ASSISTANT_NAME;
+      if (!isReservedAssistantName(candidate)) {
+        operatorName = candidate;
+        break;
+      }
+      log(t.agentNameReserved);
+      console.log("");
+    }
+  }
   log(t.agentConfirm(operatorName));
   console.log("");
 
@@ -2446,6 +2677,24 @@ async function main() {
     );
   } catch (_) {}
 
+  if (smokeTestMode) {
+    // Pytest fresh-install smoke only needs to prove that the non-interactive
+    // onboarding path writes the current calibration shape. Skip the rest of
+    // the heavy bootstrap (client installs, pip, scan, LaunchAgents) so the
+    // smoke does not sit on long dependency timeouts inside sandboxes.
+    try {
+      const canonicalBrainDir = path.join(NEXO_HOME, "personal", "brain");
+      fs.mkdirSync(canonicalBrainDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(canonicalBrainDir, "calibration.json"),
+        JSON.stringify(calibration, null, 2)
+      );
+    } catch (_) {}
+    log("Smoke test mode detected — wrote calibration and skipped heavy bootstrap.");
+    rl.close();
+    return;
+  }
+
   const clientConfig = await configureClientSetup({
     lang,
     useDefaults,
@@ -2596,10 +2845,18 @@ async function main() {
     '    printf \'%s\\n\' "${NEXO_CODE%/}"',
     '    return 0',
     '  fi',
+    '  if [ -f "$NEXO_HOME/core/cli.py" ]; then',
+    '    printf \'%s\\n\' "$NEXO_HOME/core"',
+    '    return 0',
+    '  fi',
     '  if [ -f "$NEXO_HOME/cli.py" ]; then',
     '    printf \'%s\\n\' "$NEXO_HOME"',
     '    return 0',
     '  fi',
+    '  if [ -d "$NEXO_HOME/core" ]; then',
+    '    printf \'%s\\n\' "$NEXO_HOME/core"',
+    '    return 0',
+    '  fi',
     '  printf \'%s\\n\' "$NEXO_HOME"',
     '}',
     'NEXO_CODE="$(resolve_code_dir)"',
@@ -2641,6 +2898,11 @@ async function main() {
     '  exit 1',
     'fi',
     'CLI_PY="$NEXO_CODE/cli.py"',
+    'if [ ! -f "$CLI_PY" ] && [ -f "$NEXO_HOME/core/cli.py" ]; then',
+    '  NEXO_CODE="$NEXO_HOME/core"',
+    '  export NEXO_CODE',
+    '  CLI_PY="$NEXO_HOME/core/cli.py"',
+    'fi',
     'if [ ! -f "$CLI_PY" ] && [ -f "$NEXO_HOME/cli.py" ]; then',
     '  NEXO_CODE="$NEXO_HOME"',
     '  export NEXO_CODE',
@@ -3308,9 +3570,10 @@ ${doScan ? `- Stack: ${Object.keys(profileData.code.languages || {}).slice(0, 5)
   if (!settings.mcpServers) settings.mcpServers = {};
   settings.mcpServers.nexo = {
     command: python,
-    args: [path.join(NEXO_HOME, "server.py")],
+    args: [runtimeServerPath(NEXO_HOME)],
     env: {
       NEXO_HOME: NEXO_HOME,
+      NEXO_CODE: runtimeCodeDir(NEXO_HOME),
       NEXO_NAME: operatorName,
     },
   };
@@ -3319,7 +3582,7 @@ ${doScan ? `- Stack: ${Object.keys(profileData.code.languages || {}).slice(0, 5)
   if (!settings.hooks) settings.hooks = {};
 
   // Hook scripts already copied above — just reference the dest dir
-  const hooksDestDir = path.join(NEXO_HOME, "hooks");
+  const hooksDestDir = runtimeHooksDir(NEXO_HOME);
 
   registerAllCoreHooks(settings, hooksDestDir, NEXO_HOME);
 
@@ -3328,12 +3591,12 @@ ${doScan ? `- Stack: ${Object.keys(profileData.code.languages || {}).slice(0, 5)
   fs.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
   log("MCP server + 8 core hooks configured in Claude Code settings.");
 
-  const syncClientsScript = path.join(NEXO_HOME, "scripts", "nexo-sync-clients.py");
+  const syncClientsScript = path.join(runtimeScriptsDir(NEXO_HOME), "nexo-sync-clients.py");
   if (fs.existsSync(syncClientsScript)) {
     const syncArgs = [
       syncClientsScript,
       "--nexo-home", NEXO_HOME,
-      "--runtime-root", NEXO_HOME,
+      "--runtime-root", runtimeCodeDir(NEXO_HOME),
       "--python", python,
       "--operator-name", operatorName,
     ];
@@ -3374,11 +3637,9 @@ ${doScan ? `- Stack: ${Object.keys(profileData.code.languages || {}).slice(0, 5)
     }
   }
 
-  const claudeCliPath = run("which claude") || "";
+  const claudeCliPath = detectInstalledClients().claude_code.path || run("which claude", { env: buildManagedCliEnv() }) || run("which claude") || "";
   if (claudeCliPath) {
-    const cliPathFile = path.join(NEXO_HOME, "config", "claude-cli-path");
-    fs.mkdirSync(path.dirname(cliPathFile), { recursive: true });
-    fs.writeFileSync(cliPathFile, claudeCliPath.trim());
+    persistClaudeCliPath(claudeCliPath.trim());
     log(`Claude CLI path saved: ${claudeCliPath.trim()}`);
   }
 
@@ -3391,7 +3652,6 @@ ${doScan ? `- Stack: ${Object.keys(profileData.code.languages || {}).slice(0, 5)
   schedule = await maybeConfigurePublicContribution(schedule, useDefaults);
   schedule = await maybeConfigureFullDiskAccess(schedule, useDefaults, python);
   const enabledOptionals = { dashboard: doDashboard, automation: schedule.automation_enabled !== false };
-  const smokeTestMode = process.env.NEXO_TESTING_SMOKE === "1";
   if (smokeTestMode) {
     log("Smoke test mode detected — skipping LaunchAgents installation.");
   } else if (isEphemeralInstall(NEXO_HOME)) {
@@ -3515,6 +3775,12 @@ See ~/.nexo/ for configuration.
     log(`CLAUDE.md version tracker initialized: v${claudeMdVersionMatch[1]}`);
   }
 
+  log("Finalizing F0.6 runtime layout...");
+  const layoutFinalize = finalizeF06Layout(python, NEXO_HOME);
+  if (!layoutFinalize.ok) {
+    throw new Error(`F0.6 layout finalization failed: ${layoutFinalize.error}`);
+  }
+
   console.log("");
   const readyMsg = t.ready(operatorName, aliasName);
   const readySub = t.readySubtext;

package/bin/nexo.js

@@ -42,12 +42,18 @@ function resolveCodeDir() {
   if (fs.existsSync(repoCandidate)) {
     return path.join(__dirname, "..", "src");
   }
+  if (fs.existsSync(path.join(NEXO_HOME, "core", "cli.py"))) {
+    return path.join(NEXO_HOME, "core");
+  }
   if (fs.existsSync(path.join(NEXO_HOME, "cli.py"))) {
     return NEXO_HOME;
   }
   if (fs.existsSync(path.join(NEXO_HOME, "claude", "cli.py"))) {
     return path.join(NEXO_HOME, "claude");
   }
+  if (fs.existsSync(path.join(NEXO_HOME, "core"))) {
+    return path.join(NEXO_HOME, "core");
+  }
   return NEXO_HOME;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "6.5.0",
+  "version": "7.1.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain \u2014 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",