nexo-brain 7.12.1 → 7.12.3

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.12.1",
+  "version": "7.12.3",
   "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.12.1` is the current packaged-runtime line. Patch release — Guardian G3 now sees SSH remote-write intent even when the shell payload arrives through pipe, heredoc, or stdin redirect, recent same-task Cortex decisions unlock the next matching G3 retry for a short TTL, and personal text automations now run as bare one-shots with short timeouts and overlap locks instead of spawning full agent sessions. Result: remote deploy/recovery flows stop dead-ending after `nexo_cortex_decide`, and short cron-owned text jobs stop hanging for hours or stacking parallel subprocesses.
+Version `7.12.2` is the current packaged-runtime line. Patch release — legacy headless automation paths now stay on the resonance engine: `task_profile` no longer pre-fills model/effort, `email-monitor` stops carrying a private routing override, personal automation helpers stop injecting a default model, and runtime updates scrub the last stale email-profile field automatically. Result: email daemon, personal scripts, and updated installs all converge on the same `caller`/`tier` → backend → `(model, effort)` resolution path already used by Deep Sleep and morning-agent.
 
 Previously in `7.12.0`: minor release — adds `nexo support-snapshot` for generic local runtime diagnostics and completes the silent-reminder hardening on the live Protocol Enforcer path. The support collector emits one JSON bundle with version/platform metadata, runtime path presence, health-check output, and recent event/operation tails, while map-driven reminders (`nexo_startup`, `nexo_smart_startup`, `nexo_heartbeat`, `nexo_reminders`, `nexo_session_diary_*`, `nexo_stop`, `nexo_task_close`, compaction checkpoint prompts) now say explicitly that silence owns the entire reminder turn.
 

package/bin/nexo-brain.js

@@ -17,8 +17,21 @@
 const { execSync, spawnSync } = require("child_process");
 const crypto = require("crypto");
 const fs = require("fs");
+const { createRequire } = require("module");
 const path = require("path");
 const readline = require("readline");
+// Force relative launcher helpers to resolve from bin/ even under test harnesses.
+require = createRequire(path.join(__dirname, "nexo-brain.js"));
+const { runViaWsl } = require("./windows-wsl-bridge");
+
+if (process.platform === "win32") {
+  const bridged = runViaWsl({
+    scriptPath: __filename,
+    args: process.argv.slice(2),
+    label: "NEXO Brain",
+  });
+  process.exit(bridged?.status ?? 1);
+}
 
 let NEXO_HOME = process.env.NEXO_HOME || path.join(require("os").homedir(), ".nexo");
 const DEFAULT_ASSISTANT_NAME = "Nova";
@@ -98,6 +111,10 @@ const DEFAULT_CLAUDE_CODE_REASONING_EFFORT = _MODEL_DEFAULTS.claude_code.reasoni
 const DEFAULT_CODEX_MODEL = _MODEL_DEFAULTS.codex.model;
 const DEFAULT_CODEX_REASONING_EFFORT = _MODEL_DEFAULTS.codex.reasoning_effort || "";
 
+function isDesktopManagedInstall() {
+  return String(process.env.NEXO_DESKTOP_MANAGED || "").trim() === "1";
+}
+
 // v6.0.0 — Hook manifest is the single source of truth for which hook
 // handlers get registered. Both plugin mode (hooks/hooks.json) and npm
 // mode (this installer's registerAllCoreHooks) read from the same file.
@@ -210,6 +227,62 @@ function run(cmd, opts = {}) {
 
 function log(msg) {
   console.log(`  ${msg}`);
+  try {
+    const logPath = path.join(
+      NEXO_HOME,
+      "runtime",
+      "bootstrap",
+      "logs",
+      "brain-install.log"
+    );
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.appendFileSync(logPath, `[${new Date().toISOString()}] ${msg}\n`);
+  } catch {}
+}
+
+let _stagedRuntimeBundleRoot = null;
+let _stagedRuntimeCleanup = null;
+
+function getRuntimeBundleRoot() {
+  if (_stagedRuntimeBundleRoot) {
+    return _stagedRuntimeBundleRoot;
+  }
+  const bundleRoot = path.resolve(__dirname, "..");
+  if (process.platform !== "linux") {
+    return bundleRoot;
+  }
+  const normalizedRoot = bundleRoot.replace(/\\/g, "/");
+  if (!normalizedRoot.startsWith("/mnt/")) {
+    return bundleRoot;
+  }
+
+  const tmpRoot = fs.mkdtempSync(path.join(require("os").tmpdir(), "nexo-brain-stage-"));
+  const stagedRoot = path.join(tmpRoot, path.basename(bundleRoot));
+  fs.mkdirSync(stagedRoot, { recursive: true });
+
+  log("Staging bundled runtime into local Linux storage...");
+  const tarCmd =
+    `tar --exclude=__pycache__ --exclude=node_modules --exclude='*.pyc' ` +
+    `--exclude='*.db' --exclude=.git ` +
+    `-C ${JSON.stringify(bundleRoot)} -cf - . | ` +
+    `tar -C ${JSON.stringify(stagedRoot)} -xf -`;
+  const stageResult = spawnSync("/bin/sh", ["-c", tarCmd], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 10 * 60 * 1000,
+  });
+  if (stageResult.status !== 0) {
+    const detail = (stageResult.stderr || stageResult.stdout || "").trim() || `exit ${stageResult.status}`;
+    throw new Error(`Failed to stage bundled runtime from Windows storage: ${detail}`);
+  }
+  log(`  Runtime bundle staged at ${stagedRoot}`);
+  _stagedRuntimeBundleRoot = stagedRoot;
+  _stagedRuntimeCleanup = () => {
+    try {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    } catch {}
+  };
+  return _stagedRuntimeBundleRoot;
 }
 
 function readPackageJson() {
@@ -487,6 +560,15 @@ function runMandatoryModelWarmup(pythonPath, nexoHome = NEXO_HOME, { reason = "i
   log("Local model warmup complete.");
 }
 
+function runDesktopAwareModelWarmup(pythonPath, nexoHome = NEXO_HOME, options = {}) {
+  const reason = String((options && options.reason) || "install");
+  if (isDesktopManagedInstall()) {
+    log(`Desktop-managed runtime detected — local model warmup deferred during ${reason}.`);
+    return;
+  }
+  runMandatoryModelWarmup(pythonPath, nexoHome, options);
+}
+
 async function runWarmupModelsCommand(args) {
   const dryRun = args.includes("--dry-run");
   const json = args.includes("--json");
@@ -716,6 +798,10 @@ function resolveRuntimeSchedulePath(nexoHome) {
 
 function finalizeF06Layout(python, nexoHome = NEXO_HOME) {
   try {
+    // auto_update lives in NEXO_CODE (e.g. ~/.nexo/core or ~/.nexo/core/current),
+    // not directly in NEXO_HOME, so PYTHONPATH must point at the runtime code
+    // directory or `import auto_update` fails with ModuleNotFoundError.
+    const codeDir = runtimeCodeDir(nexoHome);
     const result = spawnSync(
       python,
       [
@@ -731,8 +817,8 @@ function finalizeF06Layout(python, nexoHome = NEXO_HOME) {
         env: {
           ...process.env,
           NEXO_HOME: nexoHome,
-          NEXO_CODE: runtimeCodeDir(nexoHome),
-          PYTHONPATH: nexoHome,
+          NEXO_CODE: codeDir,
+          PYTHONPATH: codeDir,
         },
         encoding: "utf8",
       },
@@ -1438,7 +1524,7 @@ function getDefaultSchedule(timezone) {
 }
 
 function writeDesktopProductMode(nexoHome) {
-  if (String(process.env.NEXO_DESKTOP_MANAGED || "").trim() !== "1") return;
+  if (!isDesktopManagedInstall()) return;
   const configDir = resolveRuntimeConfigDir(nexoHome);
   fs.mkdirSync(configDir, { recursive: true });
   const target = path.join(configDir, "product-mode.json");
@@ -1465,7 +1551,7 @@ function ensureEvolutionObjectiveForCurrentProductMode(nexoHome) {
   const brainDir = resolveRuntimeBrainDir(nexoHome);
   fs.mkdirSync(brainDir, { recursive: true });
   const evoObjectivePath = path.join(brainDir, "evolution-objective.json");
-  const desktopManaged = String(process.env.NEXO_DESKTOP_MANAGED || "").trim() === "1";
+  const desktopManaged = isDesktopManagedInstall();
   let payload = null;
   if (fs.existsSync(evoObjectivePath)) {
     try {
@@ -1788,6 +1874,29 @@ function installClaudeCodeCli(platform) {
   const desktopNode = String(process.env.NEXO_DESKTOP_NODE || "").trim();
   const bundledNpmCli = String(process.env.NEXO_DESKTOP_NPM_CLI || "").trim();
   const managedPrefix = managedClaudePrefix();
+  const desktopManaged = isDesktopManagedInstall();
+
+  // OFFLINE-FIRST: detect bundled claude-code .tgz and install from it.
+  // Path: resources/brain-bundle/claude-code/claude-code-X.Y.Z.tgz (relative
+  // to bin/, so __dirname/../claude-code/). Falls back to PyPI/npm if absent.
+  const bundledClaudeDir = path.join(__dirname, "..", "claude-code");
+  if (fs.existsSync(bundledClaudeDir)) {
+    const tgzFiles = fs.readdirSync(bundledClaudeDir).filter((f) => f.endsWith(".tgz"));
+    if (tgzFiles.length > 0) {
+      const tgzPath = path.join(bundledClaudeDir, tgzFiles[0]);
+      log("  Installing claude-code from bundled tarball (offline)...");
+      spawnSync(
+        "npm",
+        ["install", "-g", "--prefix", managedPrefix, tgzPath],
+        { stdio: "inherit", env: installEnv },
+      );
+      claudeInstalled = detectInstalledClients().claude_code.path || "";
+      if (claudeInstalled) {
+        persistClaudeCliPath(claudeInstalled);
+        return { installed: true, path: claudeInstalled };
+      }
+    }
+  }
 
   if (desktopNode && bundledNpmCli) {
     spawnSync(
@@ -1805,6 +1914,23 @@ function installClaudeCodeCli(platform) {
     }
   }
 
+  if (desktopManaged) {
+    spawnSync(
+      "npm",
+      ["install", "-g", "--prefix", managedPrefix, "@anthropic-ai/claude-code"],
+      {
+        stdio: "inherit",
+        env: installEnv,
+      },
+    );
+    claudeInstalled = detectInstalledClients().claude_code.path || "";
+    if (claudeInstalled) {
+      persistClaudeCliPath(claudeInstalled);
+      return { installed: true, path: claudeInstalled };
+    }
+    return { installed: false, path: "" };
+  }
+
   spawnSync("npx", ["-y", "@anthropic-ai/claude-code", "--version"], {
     stdio: "pipe",
     timeout: 60000,
@@ -1834,6 +1960,7 @@ function installCodexCli() {
 async function configureClientSetup({ lang, useDefaults, autoInstall, detected }) {
   const strings = clientSetupStrings(lang);
   const setup = defaultClientSetup(detected);
+  const desktopManaged = String(process.env.NEXO_DESKTOP_MANAGED || "").trim() === "1";
   setup.client_install_preferences = {
     claude_code: autoInstall === "auto" ? "auto" : "ask",
     codex: autoInstall === "auto" ? "auto" : "ask",
@@ -1885,6 +2012,10 @@ async function configureClientSetup({ lang, useDefaults, autoInstall, detected }
   const required = requiredCliClients(setup);
   for (const client of required) {
     if (detected[client] && detected[client].installed) continue;
+    if (desktopManaged && client === "claude_code") {
+      log("Claude Code install deferred to Desktop final sync.");
+      continue;
+    }
     let shouldInstall = useDefaults || autoInstall === "auto";
     if (!shouldInstall && process.stdin.isTTY && process.stdout.isTTY) {
       const question = client === "claude_code" ? strings.installClaudeQ : strings.installCodexQ;
@@ -1913,6 +2044,10 @@ async function configureClientSetup({ lang, useDefaults, autoInstall, detected }
   }
 
   if (setup.automation_enabled && setup.automation_backend !== "none" && !detected[setup.automation_backend]?.installed) {
+    if (desktopManaged && setup.automation_backend === "claude_code") {
+      log("Claude Code will be provisioned by Desktop after the core runtime is ready.");
+      return { setup, detected };
+    }
     const label = setup.automation_backend === "claude_code" ? "Claude Code" : "Codex";
     log(strings.automationDisabled(label));
     setup.automation_enabled = false;
@@ -2425,9 +2560,9 @@ async function runSetup() {
   // Check prerequisites
   const platform = process.platform;
   if (platform === "win32") {
-    log("Windows detected. NEXO Brain requires WSL (Windows Subsystem for Linux).");
+    log("Windows detected, but the automatic WSL bridge was not available.");
     log("Install WSL: https://learn.microsoft.com/en-us/windows/wsl/install");
-    log("Then run this command inside WSL (Ubuntu terminal), not PowerShell/CMD.");
+    log("Then run this command again, or launch it directly inside WSL (Ubuntu terminal).");
     process.exit(1);
   }
   if (platform !== "darwin" && platform !== "linux") {
@@ -2435,6 +2570,15 @@ async function runSetup() {
     process.exit(1);
   }
 
+  const bundleRoot = getRuntimeBundleRoot();
+  const bundleSrcDir = path.join(bundleRoot, "src");
+  const bundleTemplatesDir = path.join(bundleRoot, "templates");
+  process.on("exit", () => {
+    if (_stagedRuntimeCleanup) {
+      _stagedRuntimeCleanup();
+    }
+  });
+
   const onboardingMigration = ensureOnboardingCompletionMarker(NEXO_HOME);
   if (onboardingMigration.changed) {
     log("Migrated legacy calibration completion marker.");
@@ -2466,7 +2610,7 @@ async function runSetup() {
         }
 
         // Recursive copy helper (skips __pycache__, .pyc, .db files)
-        const srcDir = path.join(__dirname, "..", "src");
+        const srcDir = bundleSrcDir;
         const copyDirRec = (src, dest) => {
           fs.mkdirSync(dest, { recursive: true });
           fs.readdirSync(src).forEach(item => {
@@ -2539,7 +2683,7 @@ async function runSetup() {
         }
 
         const migPythonForWarmup = findVenvPython(NEXO_HOME) || "python3";
-        runMandatoryModelWarmup(migPythonForWarmup, NEXO_HOME, { reason: "update", installRuntimeDeps: false });
+        runDesktopAwareModelWarmup(migPythonForWarmup, NEXO_HOME, { reason: "update", installRuntimeDeps: false });
 
         // Update plugins (all .py files in plugins/)
         const pluginsSrc = path.join(srcDir, "plugins");
@@ -2594,7 +2738,7 @@ async function runSetup() {
         // hand-edited template under ~/.nexo/templates/ is replaced on
         // upgrade. Keep local forks under personal/ or outside the runtime
         // home to avoid silent loss.
-        const migTemplatesSrc = path.join(__dirname, "..", "templates");
+        const migTemplatesSrc = bundleTemplatesDir;
         const migTemplatesDest = path.join(NEXO_HOME, "templates");
         if (fs.existsSync(migTemplatesSrc)) {
           copyDirRec(migTemplatesSrc, migTemplatesDest);
@@ -2643,7 +2787,7 @@ async function runSetup() {
             ? { runtime_repaired_from: activeRuntimeVersion }
             : {}),
         }, null, 2));
-        syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
+        syncRuntimePackageMetadata(bundleRoot, NEXO_HOME);
         log("Finalizing F0.6 runtime layout...");
         const migLayoutFinalize = finalizeF06Layout(migPython, NEXO_HOME);
         if (!migLayoutFinalize.ok) {
@@ -2657,7 +2801,7 @@ async function runSetup() {
 
         // Keep the rendered template in-memory for version tracking, but do
         // not drop a loose reference file in NEXO_HOME root.
-        const templateSrc = path.join(__dirname, "..", "templates", "CLAUDE.md.template");
+        const templateSrc = path.join(bundleTemplatesDir, "CLAUDE.md.template");
         if (fs.existsSync(templateSrc)) {
           const operatorName = installed.operator_name || DEFAULT_ASSISTANT_NAME;
           let claudeMd = fs.readFileSync(templateSrc, "utf8")
@@ -2729,7 +2873,7 @@ async function runSetup() {
       // Same version — backfill crons/ if missing (for installs before crons was shipped)
       const syncPython = findVenvPython(NEXO_HOME) || run("which python3") || "python3";
       const cronsDest = resolveRuntimeCronsDir(NEXO_HOME);
-      const cronsSrc = path.join(__dirname, "..", "src", "crons");
+      const cronsSrc = path.join(bundleSrcDir, "crons");
       if (fs.existsSync(cronsSrc)) {
         const copyDirRec2 = (src, dest) => {
           fs.mkdirSync(dest, { recursive: true });
@@ -2754,7 +2898,7 @@ async function runSetup() {
 
       // Same version — refresh packaged core skills/templates/runtime helpers too.
       const skillsCoreDest = path.join(NEXO_HOME, "core", "skills");
-      const skillsCoreSrc = path.join(__dirname, "..", "src", "skills");
+      const skillsCoreSrc = path.join(bundleSrcDir, "skills");
       if (fs.existsSync(skillsCoreSrc)) {
         const copyDirRec3 = (src, dest) => {
           fs.mkdirSync(dest, { recursive: true });
@@ -2771,16 +2915,16 @@ async function runSetup() {
       }
 
       ["skills_runtime.py"].forEach((fname) => {
-        const srcFile = path.join(__dirname, "..", "src", fname);
+        const srcFile = path.join(bundleSrcDir, fname);
         const destFile = path.join(NEXO_HOME, "core", fname);
         if (fs.existsSync(srcFile)) {
           fs.mkdirSync(path.dirname(destFile), { recursive: true });
           fs.copyFileSync(srcFile, destFile);
         }
       });
-      syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
+      syncRuntimePackageMetadata(bundleRoot, NEXO_HOME);
 
-      const templatesSrc = path.join(__dirname, "..", "templates");
+      const templatesSrc = bundleTemplatesDir;
       const templatesDest = path.join(NEXO_HOME, "templates");
       if (fs.existsSync(templatesSrc)) {
         fs.mkdirSync(templatesDest, { recursive: true });
@@ -2808,7 +2952,7 @@ async function runSetup() {
         throw new Error(`F0.6 layout finalization failed: ${syncLayoutFinalize.error}`);
       }
 
-      runMandatoryModelWarmup(syncPython, NEXO_HOME, { reason: "repair" });
+      runDesktopAwareModelWarmup(syncPython, NEXO_HOME, { reason: "repair" });
       logMacPermissionsNotice(NEXO_HOME, syncPython);
 
       log(`Already at v${currentVersion}. No migration needed.`);
@@ -3303,11 +3447,22 @@ async function runSetup() {
   // Use venv python if available, otherwise fall back to system python with --break-system-packages
   const pipPython = fs.existsSync(venvPython) ? venvPython : python;
   const requirementsFile = path.join(__dirname, "..", "src", "requirements.txt");
-  const pipArgs = ["-m", "pip", "install", "--quiet", "-r", requirementsFile];
+  // Detect bundled wheels in resources/python-wheels (offline-first). If
+  // present, pip uses --no-index --find-links to install without internet.
+  // Falls back to PyPI if bundle not found.
+  const bundledWheelsDir = path.join(__dirname, "..", "python-wheels");
+  const useBundle = fs.existsSync(bundledWheelsDir);
+  const pipArgs = useBundle
+    ? ["-m", "pip", "install", "--no-index", "--find-links", bundledWheelsDir, "--progress-bar", "off", "-r", requirementsFile]
+    : ["-m", "pip", "install", "-v", "--progress-bar", "off", "--default-timeout=60", "-r", requirementsFile];
   if (!fs.existsSync(venvPython)) {
-    pipArgs.push("--break-system-packages");  // Fallback for systems without venv
+    pipArgs.push("--break-system-packages");
+  }
+  if (useBundle) {
+    log("  Installing Python deps from bundled wheels (offline)...");
+  } else {
+    log("  Installing Python deps from PyPI (online)...");
   }
-
   const pipInstall = spawnSync(pipPython, pipArgs, { stdio: "inherit" });
   if (pipInstall.status !== 0) {
     log("Failed to install Python dependencies.");
@@ -3319,7 +3474,54 @@ async function runSetup() {
     python = venvPython;
   }
   log("Dependencies installed.");
-  runMandatoryModelWarmup(python, NEXO_HOME, { reason: "install", installRuntimeDeps: false });
+
+  // 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 });
+        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) && !fs.existsSync(dst)) {
+            fs.copyFileSync(src, dst);
+          }
+        }
+        // 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}`);
+    }
+  }
+
+  runDesktopAwareModelWarmup(python, NEXO_HOME, { reason: "install", installRuntimeDeps: false });
 
   // Step 4: Create ~/.nexo/
   log("Setting up NEXO home...");
@@ -3368,15 +3570,15 @@ async function runSetup() {
       files_updated: 0,
     }, null, 2)
   );
-  syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
+  syncRuntimePackageMetadata(bundleRoot, NEXO_HOME);
 
   // Copy source files
   log("Copying core runtime files...");
-  const srcDir = path.join(__dirname, "..", "src");
+  const srcDir = bundleSrcDir;
   const pluginsSrcDir = path.join(srcDir, "plugins");
   const scriptsSrcDir = path.join(srcDir, "scripts");
   const skillsSrcDir = path.join(srcDir, "skills");
-  const templateDir = path.join(__dirname, "..", "templates");
+  const templateDir = bundleTemplatesDir;
 
   // Recursive copy helper (skips __pycache__, .pyc, .db files)
   const copyDirRecursive = (src, dest) => {
@@ -3394,7 +3596,7 @@ async function runSetup() {
   };
 
   // Core flat files (single .py files in src/)
-  const coreFiles = getCoreRuntimeFlatFiles();
+  const coreFiles = getCoreRuntimeFlatFiles(srcDir);
   coreFiles.forEach((f) => {
     const src = path.join(srcDir, f);
     if (fs.existsSync(src)) {
@@ -4416,6 +4618,10 @@ See ~/.nexo/ for configuration.
   console.log(`  \u255A${"═".repeat(bw - 2)}\u255D`);
   console.log("");
 
+  if (_stagedRuntimeCleanup) {
+    _stagedRuntimeCleanup();
+    _stagedRuntimeCleanup = null;
+  }
   closeReadline();
 }
 

package/bin/nexo.js

@@ -11,6 +11,16 @@ const { spawnSync } = require("child_process");
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
+const { runViaWsl } = require("./windows-wsl-bridge");
+
+if (process.platform === "win32") {
+  const bridged = runViaWsl({
+    scriptPath: __filename,
+    args: process.argv.slice(2),
+    label: "NEXO CLI",
+  });
+  process.exit(bridged?.status ?? 1);
+}
 
 function resolveNexoHome(rawValue) {
   const homeDir = os.homedir();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.12.1",
+  "version": "7.12.3",
   "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",
@@ -73,6 +73,7 @@
   "files": [
     "bin/nexo-brain.js",
     "bin/nexo.js",
+    "bin/windows-wsl-bridge.js",
     "bin/postinstall.js",
     "scripts/sync_release_artifacts.py",
     "src/",

package/src/agent_runner.py

@@ -27,7 +27,6 @@ from client_preferences import (
     load_client_preferences,
     normalize_client_key,
     resolve_automation_backend,
-    resolve_automation_task_profile,
     resolve_client_runtime_profile,
     resolve_terminal_client,
 )
@@ -936,14 +935,6 @@ def run_automation_prompt(
     selected_backend = backend or resolve_automation_backend(preferences=prefs)
     if selected_backend == BACKEND_NONE:
         raise AutomationBackendUnavailableError("Automation backend is disabled in config.")
-
-    if task_profile:
-        profile = resolve_automation_task_profile(task_profile, preferences=prefs)
-        selected_backend = profile["backend"] or selected_backend
-        if not model:
-            model = profile["model"]
-        if not reasoning_effort:
-            reasoning_effort = profile["reasoning_effort"]
     selected_backend = _resolve_available_backend(selected_backend, preferences=prefs)
 
     # Resonance map decides (model, effort) for every call. ``caller`` is

package/src/auto_update.py

@@ -1630,6 +1630,47 @@ def _migrate_effort_to_resonance(dest: Path = NEXO_HOME) -> list[str]:
     return actions
 
 
+def _cleanup_legacy_email_routing_config(dest: Path = NEXO_HOME) -> list[str]:
+    """Remove retired email routing overrides from persisted runtime config.
+
+    Older runtimes stored ``automation_task_profile`` inside
+    ``runtime/nexo-email/config.json`` (and earlier under ``nexo-email/``).
+    The email monitor now resolves model/effort exclusively from its caller in
+    ``resonance_map.py``, so keeping that key around only preserves a stale,
+    misleading second source of truth.
+    """
+    import json as _json
+
+    actions: list[str] = []
+    candidates = [
+        dest / "runtime" / "nexo-email" / "config.json",
+        dest / "nexo-email" / "config.json",
+    ]
+    for path in candidates:
+        if not path.is_file():
+            continue
+        try:
+            payload = _json.loads(path.read_text())
+        except Exception as exc:
+            actions.append(
+                f"email-routing-cleanup-warning:{path.name}:{exc.__class__.__name__}"
+            )
+            continue
+        if not isinstance(payload, dict):
+            continue
+        if "automation_task_profile" not in payload:
+            continue
+        payload.pop("automation_task_profile", None)
+        try:
+            path.write_text(_json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+            actions.append(f"email-routing-cleanup:{path}")
+        except Exception as exc:
+            actions.append(
+                f"email-routing-cleanup-warning:{path.name}:{exc.__class__.__name__}"
+            )
+    return actions
+
+
 def _relocate_resonance_tiers_contract(dest: Path = NEXO_HOME) -> list[str]:
     """Ensure ``resonance_tiers.json`` lives at the public contract path
     ``NEXO_HOME/personal/brain/resonance_tiers.json`` and purge the legacy
@@ -4688,6 +4729,14 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
     except Exception as exc:
         actions.append(f"v6-purge-warning:{exc.__class__.__name__}")
 
+    try:
+        _emit_progress(progress_fn, "Cleaning legacy email routing overrides...")
+        email_actions = _cleanup_legacy_email_routing_config(dest)
+        for action in email_actions:
+            actions.append(action)
+    except Exception as exc:
+        actions.append(f"email-routing-cleanup-warning:{exc.__class__.__name__}")
+
     try:
         _emit_progress(progress_fn, "Ensuring local classifier baseline...")
         if _is_ephemeral_runtime_install(dest):

package/src/cli.py

@@ -2518,6 +2518,7 @@ def _skills_compose(args):
 def _uninstall(args):
     """Stop all crons, remove MCP config and hooks, preserve user data."""
     from pathlib import Path
+    from windows_runtime import cleanup_windows_host_artifacts, running_inside_wsl, running_from_windows_host
 
     nexo_home = Path(os.environ.get("NEXO_HOME", Path.home() / ".nexo"))
     dry_run = args.dry_run
@@ -2566,6 +2567,20 @@ def _uninstall(args):
             if not dry_run:
                 subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
 
+        if running_inside_wsl() or running_from_windows_host():
+            host_cleanup = cleanup_windows_host_artifacts(
+                delete_data=delete_data,
+                dry_run=dry_run,
+            )
+            for action in host_cleanup.get("actions", []):
+                log_action(
+                    action.get("category", "remove-win-host-artifact"),
+                    action.get("detail", ""),
+                    action.get("path", ""),
+                )
+            for error in host_cleanup.get("errors", []):
+                errors.append(f"Windows host cleanup: {error}")
+
     # ── 2. Remove MCP server and hooks from Claude Code settings ──
     claude_settings = Path.home() / ".claude" / "settings.json"
     if claude_settings.exists():