nexo-brain 7.12.10 → 7.12.15

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.12.10",
+  "version": "7.12.15",
   "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.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.
+Version `7.12.15` is the current packaged-runtime line. Patch release — same-version packaged updates now still run the safe maintenance path, Deep Sleep clears process locks on shutdown, sent replies are recorded in durable continuity, and personal script schedule-marker drift is surfaced during reconcile. Result: coordinated Desktop bundles can refresh Brain safely without breaking install/update parity on macOS, Windows via WSL, or Linux.
 
 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

@@ -225,6 +225,50 @@ function run(cmd, opts = {}) {
   }
 }
 
+function findBundledWheel(wheelsDir, prefix) {
+  try {
+    const normalizedPrefix = String(prefix || "").toLowerCase() + "-";
+    const matches = fs.readdirSync(wheelsDir)
+      .filter((name) => name.toLowerCase().startsWith(normalizedPrefix) && name.endsWith(".whl"))
+      .sort();
+    if (!matches.length) return "";
+    return path.join(wheelsDir, matches[matches.length - 1]);
+  } catch {
+    return "";
+  }
+}
+
+function pythonHasPip(pythonBin) {
+  try {
+    const result = spawnSync(pythonBin, ["-m", "pip", "--version"], {
+      stdio: "ignore",
+      timeout: 15000,
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+function seedPipFromBundledWheels(venvPython, bundledWheelsDir) {
+  if (!fs.existsSync(venvPython) || !fs.existsSync(bundledWheelsDir)) return false;
+  if (pythonHasPip(venvPython)) return true;
+  const pipWheel = findBundledWheel(bundledWheelsDir, "pip");
+  if (!pipWheel) return false;
+  log("  Seeding pip into venv from bundled wheels...");
+  const result = spawnSync(venvPython, [
+    path.join(pipWheel, "pip"),
+    "install",
+    "--no-index",
+    "--find-links",
+    bundledWheelsDir,
+    "pip",
+    "setuptools",
+    "wheel",
+  ], { stdio: "inherit", timeout: 120000 });
+  return result.status === 0 && pythonHasPip(venvPython);
+}
+
 function log(msg) {
   console.log(`  ${msg}`);
   try {
@@ -360,7 +404,14 @@ function isOnboardingComplete(calibration) {
   const meta = calibration.meta && typeof calibration.meta === "object" ? calibration.meta : {};
 
   if (meta.onboarding_completed === true) {
-    return nonEmptyString(name) && nonEmptyString(language);
+    // v7.12.11 — bug surfaced on Inma's smoke install 2026-05-03: Desktop
+    // bootstrap runs nexo-brain in --yes/--skip mode, which used to write
+    // `onboarding_completed: true` alongside the placeholder "Usuario"/"en"
+    // defaults. The Desktop wizard then never fired because this returned
+    // true on the very first launch. Treat a placeholder name as "marker is
+    // a lie, real onboarding never happened" so the renderer can still
+    // surface the wizard. Same guard applied to the legacy fallback below.
+    return nonEmptyString(name) && !isPlaceholderUserName(name) && nonEmptyString(language);
   }
 
   // Legacy fallback: v7.8/v7.9-era calibration files may not carry the
@@ -3440,8 +3491,16 @@ async function runSetup() {
       execution_first: true,
     },
     meta: {
-      onboarding_completed: true,
-      onboarding_completed_at: new Date().toISOString(),
+      // v7.12.11 — only mark onboarding_completed when the user actually
+      // answered the prompts (interactive run, !useDefaults). The
+      // Desktop bootstrap calls nexo-brain with `--yes/--skip` to set up
+      // the runtime non-interactively; in that path the values are
+      // placeholders ("Usuario" / "en" / "Nova") and the real wizard
+      // lives in the renderer. Marking it complete here used to short-
+      // circuit that wizard and leave new users staring at an empty chat
+      // (Inma 2026-05-03 smoke install).
+      onboarding_completed: !useDefaults,
+      onboarding_completed_at: !useDefaults ? new Date().toISOString() : null,
     },
     auto_install: "ask", // updated later if user answers P11
     calibrated_at: new Date().toISOString(),
@@ -3526,15 +3585,28 @@ async function runSetup() {
   const venvPython = platform === "win32"
     ? path.join(venvPath, "Scripts", "python.exe")
     : path.join(venvPath, "bin", "python3");
+  const bundledWheelsDir = path.join(__dirname, "..", "python-wheels");
 
   // Create venv if it doesn't exist
   if (!fs.existsSync(venvPython)) {
     log("  Creating Python virtual environment...");
     const venvResult = spawnSync(python, ["-m", "venv", venvPath], { stdio: "inherit" });
     if (venvResult.status !== 0) {
-      log("Failed to create venv. Trying pip install directly...");
+      if (platform === "linux" && fs.existsSync(bundledWheelsDir)) {
+        log("  Python venv could not seed pip; retrying offline without pip...");
+        try { fs.rmSync(venvPath, { recursive: true, force: true }); } catch {}
+        const bareVenv = spawnSync(python, ["-m", "venv", "--without-pip", venvPath], { stdio: "inherit" });
+        if (bareVenv.status !== 0) {
+          log("Failed to create venv. Trying pip install directly...");
+        }
+      } else {
+        log("Failed to create venv. Trying pip install directly...");
+      }
     }
   }
+  if (fs.existsSync(venvPython) && !pythonHasPip(venvPython)) {
+    seedPipFromBundledWheels(venvPython, bundledWheelsDir);
+  }
 
   // Use venv python if available, otherwise fall back to system python with --break-system-packages
   const pipPython = fs.existsSync(venvPython) ? venvPython : python;
@@ -3542,7 +3614,6 @@ async function runSetup() {
   // 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");
   // v0.32.5 — el bundle empaca wheels manylinux (cp312 x86_64) porque
   // en Win Brain corre dentro de WSL Ubuntu noble. En Mac, Brain corre
   // nativo macOS y NO acepta esos wheels (ABI distinto). Si gateamos

package/package.json

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

package/src/auto_update.py

@@ -1233,11 +1233,9 @@ def _reload_launch_agents_after_bump() -> dict:
           "errors": [{plist, stderr}],
         }
 
-    Linux equivalent: systemctl --user daemon-reload + restart of timer
-    units. Implemented as a no-op stub on Linux for now (the macOS
-    LaunchAgent path is the production target — Linux users running
-    `nexo update` get the cron sync but not the per-timer restart yet).
-    Captured as a TODO for the next round.
+    Linux/WSL remains a no-op by default. Systemd user-unit reload can be
+    enabled explicitly for development/runtime experiments, but public update
+    paths must not restart host services unexpectedly.
     """
     result: dict = {
         "scanned": 0,
@@ -1247,8 +1245,58 @@ def _reload_launch_agents_after_bump() -> dict:
         "platform": sys.platform,
     }
 
+    if sys.platform == "linux":
+        if os.environ.get("NEXO_ENABLE_SYSTEMD_RELOAD_AFTER_BUMP") != "1":
+            result["skipped_reason"] = "systemd-reload-disabled"
+            return result
+
+        # Experimental Linux path: reload systemd user units so nexo-* timers
+        # updated by auto-update pick up new ExecStart paths. Best-effort: a
+        # missing systemd (Docker/CI/most WSL installs) just returns no-op.
+        try:
+            unit_dir = Path.home() / ".config" / "systemd" / "user"
+            scanned_units = []
+            if unit_dir.is_dir():
+                scanned_units = sorted(
+                    [p for p in unit_dir.iterdir() if p.suffix in {".service", ".timer"} and p.name.startswith("nexo")]
+                )
+            result["scanned"] = len(scanned_units)
+            if scanned_units:
+                reload_proc = subprocess.run(
+                    ["systemctl", "--user", "daemon-reload"],
+                    capture_output=True,
+                    text=True,
+                    timeout=15,
+                )
+                if reload_proc.returncode != 0:
+                    result["errors"].append({
+                        "unit": "daemon-reload",
+                        "stderr": (reload_proc.stderr or reload_proc.stdout or "").strip(),
+                    })
+                else:
+                    for unit in scanned_units:
+                        restart = subprocess.run(
+                            ["systemctl", "--user", "restart", unit.name],
+                            capture_output=True,
+                            text=True,
+                            timeout=15,
+                        )
+                        if restart.returncode == 0:
+                            result["reloaded"] += 1
+                        else:
+                            result["errors"].append({
+                                "unit": unit.name,
+                                "stderr": (restart.stderr or restart.stdout or "").strip(),
+                            })
+        except FileNotFoundError:
+            result["skipped_reason"] = "systemctl-not-available"
+        except Exception as e:
+            result["errors"].append({"unit": "*", "stderr": f"systemd reload failed: {e}"})
+        return result
+
     if sys.platform != "darwin":
-        # macOS-only for now. systemd path tracked separately.
+        # Other platforms (win32 native — never reached because Brain runs
+        # inside WSL Linux on Windows): nothing to reload.
         return result
     if _is_ephemeral_runtime_install():
         result["skipped_reason"] = "ephemeral-runtime"

package/src/cli.py

@@ -1966,8 +1966,42 @@ def _service_control(service_name: str, action: str) -> int:
 
     label = f"com.nexo.{service_name}"
 
+    # v7.12.12 — Linux/WSL path uses systemd user units (`<service>.service`
+    # in ~/.config/systemd/user/). Until 7.12.11 this stub printed
+    # "supported only on macOS" and returned 1, leaving Linux operators
+    # with no CLI to start/stop the brain — they had to learn systemctl
+    # syntax themselves. Symmetric semantics: on=start, off=stop,
+    # status=is-active. Names match the macOS labels with "nexo-" prefix.
+    if plat.system() == "Linux":
+        unit = f"nexo-{service_name}.service"
+        if action == "status":
+            result = subprocess.run(
+                ["systemctl", "--user", "is-active", unit],
+                capture_output=True,
+                text=True,
+            )
+            state = (result.stdout or "").strip() or "unknown"
+            print(f"{service_name}: {'running' if state == 'active' else state}")
+            return 0
+        if action in ("on", "off"):
+            verb = "start" if action == "on" else "stop"
+            result = subprocess.run(
+                ["systemctl", "--user", verb, unit],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                print(f"{service_name}: {'started' if action == 'on' else 'stopped'}")
+                return 0
+            err = (result.stderr or result.stdout or "").strip()
+            print(f"Failed to {verb} {service_name}: {err}", file=sys.stderr)
+            print(f"Hint: install the unit at ~/.config/systemd/user/{unit}", file=sys.stderr)
+            return 1
+        print(f"Unknown action: {action}. Use on, off, or status.", file=sys.stderr)
+        return 1
+
     if plat.system() != "Darwin":
-        print(f"Service control only supported on macOS for now.", file=sys.stderr)
+        print(f"Service control not supported on this platform: {plat.system()}", file=sys.stderr)
         return 1
 
     plist_path = Path.home() / "Library" / "LaunchAgents" / f"{label}.plist"

package/src/client_sync.py

@@ -396,15 +396,20 @@ def ensure_claude_code_installed(*, user_home: str | os.PathLike[str] | None = N
             "attempts": attempts,
         }
 
-    install_cmd = (
-        ["sudo", "npm", "install", "-g", CLAUDE_CODE_NPM_PACKAGE]
-        if sys.platform == "linux"
-        else ["npm", "install", "-g", CLAUDE_CODE_NPM_PACKAGE]
-    )
+    # v7.12.12 — try npm without sudo first on Linux. Hardcoding `sudo`
+    # used to make sense on stock Ubuntu where /usr/lib/node_modules is
+    # root-owned, but inside the WSL distro NEXO Desktop ships, the
+    # default global prefix is already `/home/<user>/.nexo/runtime/
+    # bootstrap/npm-global` (writable). A blind `sudo` there triggers a
+    # password prompt on a TTY the user cannot see, so the bootstrap
+    # appears stuck. Try unprivileged first; if it fails with EACCES
+    # (insufficient permissions), retry with sudo.
     install_error = ""
+    install = None
+    base_cmd = ["npm", "install", "-g", CLAUDE_CODE_NPM_PACKAGE]
     try:
         install = subprocess.run(
-            install_cmd,
+            base_cmd,
             capture_output=True,
             text=True,
             timeout=180,
@@ -413,6 +418,29 @@ def ensure_claude_code_installed(*, user_home: str | os.PathLike[str] | None = N
         if install.returncode != 0:
             install_error = (install.stderr or install.stdout or "npm install failed").strip()
             attempts.append(install_error)
+            permission_failure = (
+                "EACCES" in install_error
+                or "permission denied" in install_error.lower()
+                or "operation not permitted" in install_error.lower()
+            )
+            if permission_failure and sys.platform == "linux":
+                attempts.append("retrying with sudo (Linux EACCES fallback)")
+                try:
+                    install = subprocess.run(
+                        ["sudo", "-n", "npm", "install", "-g", CLAUDE_CODE_NPM_PACKAGE],
+                        capture_output=True,
+                        text=True,
+                        timeout=180,
+                        env=env,
+                    )
+                    if install.returncode != 0:
+                        install_error = (install.stderr or install.stdout or "sudo npm install failed").strip()
+                        attempts.append(install_error)
+                    else:
+                        install_error = ""
+                except Exception as exc:
+                    install_error = f"sudo npm install failed: {exc}"
+                    attempts.append(install_error)
     except Exception as exc:
         install_error = f"npm install failed: {exc}"
         attempts.append(install_error)

package/src/dashboard/app.py

@@ -1101,26 +1101,82 @@ async def api_ops_execute(fid: str):
     if not row:
         return JSONResponse({"error": f"Followup {fid} not found"}, status_code=404)
     item = dict(row)
-    if platform.system() != "Darwin":
-        return JSONResponse(
-            {"error": "This operation requires macOS (uses osascript to open Terminal)"},
-            status_code=501,
-        )
     # Security: avoid interpolating user-controlled data into shell commands.
-    # Write the followup ID to a temp file and pass a safe, fixed command to osascript.
+    # Write the followup ID to a temp file and pass a safe, fixed command.
     import tempfile
     tmp = tempfile.NamedTemporaryFile(mode="w", suffix=".txt", prefix="nexo-followup-", delete=False)
     tmp.write(fid)
     tmp.close()
-    # The selected terminal client reads the followup ID from the temp file — no shell interpolation of description
     try:
+        # Use the selected terminal client from NEXO preferences (Claude Code or
+        # Codex) instead of hardcoding a launcher in the dashboard.
         _, shell_cmd = build_followup_terminal_shell_command(tmp.name)
     except AgentRunnerError as exc:
         return JSONResponse({"error": str(exc)}, status_code=503)
-    escaped = shell_cmd.replace("\\", "\\\\").replace('"', '\\"')
-    script = f'tell application "Terminal" to do script "{escaped}"'
-    subprocess.Popen(["osascript", "-e", script])
-    return {"success": True, "followup_id": fid}
+
+    system = platform.system()
+    if system == "Darwin":
+        # macOS: open Terminal.app via osascript (legacy path).
+        escaped = shell_cmd.replace("\\", "\\\\").replace('"', '\\"')
+        script = f'tell application "Terminal" to do script "{escaped}"'
+        subprocess.Popen(["osascript", "-e", script])
+        return {"success": True, "followup_id": fid, "platform": "darwin"}
+
+    # 7.12.14 — Windows / WSL parity. Until now this endpoint returned 501
+    # on any non-Darwin host, leaving Win11 users without a way to launch
+    # followups from the dashboard. We detect WSL via WSL_DISTRO_NAME /
+    # /proc/sys/fs/binfmt_misc/WSLInterop and shell out through Win
+    # interop (cmd.exe /c start ... wt.exe) so the user gets a real
+    # Windows Terminal tab running `wsl.exe -d <distro> -- bash -lc "<cmd>"`
+    # — matching the Mac UX of "click → terminal opens with claude waiting".
+    is_wsl = bool(os.environ.get("WSL_DISTRO_NAME")) or os.path.exists(
+        "/proc/sys/fs/binfmt_misc/WSLInterop"
+    )
+    if is_wsl:
+        distro = os.environ.get("WSL_DISTRO_NAME") or "Ubuntu-24.04"
+        # Quote the bash command for cmd.exe; cmd's start unwraps one level
+        # so we double-escape inner double quotes.
+        bash_cmd = shell_cmd.replace('"', '\\"')
+        wsl_invoke = f'wsl.exe -d {distro} -- bash -lc "{bash_cmd}"'
+        try:
+            subprocess.Popen(
+                ["cmd.exe", "/c", "start", "", "wt.exe", "new-tab", "--", "cmd.exe", "/k", wsl_invoke],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        except FileNotFoundError:
+            return JSONResponse(
+                {
+                    "error": "Could not launch Windows Terminal automatically.",
+                    "manual_command": wsl_invoke,
+                    "followup_id": fid,
+                },
+                status_code=503,
+            )
+        return {"success": True, "followup_id": fid, "platform": "wsl", "distro": distro}
+
+    # Pure Linux (no WSL): try common terminal emulators in order, then
+    # fall back to returning the manual command. Best-effort because the
+    # dashboard is primarily Mac + WSL.
+    from shutil import which
+    for emulator in ("x-terminal-emulator", "gnome-terminal", "konsole", "xterm"):
+        if which(emulator):
+            try:
+                if emulator == "gnome-terminal":
+                    subprocess.Popen([emulator, "--", "bash", "-lc", shell_cmd])
+                else:
+                    subprocess.Popen([emulator, "-e", shell_cmd])
+                return {"success": True, "followup_id": fid, "platform": "linux", "emulator": emulator}
+            except OSError:
+                continue
+    return JSONResponse(
+        {
+            "error": "No terminal emulator available to launch the followup automatically.",
+            "manual_command": shell_cmd,
+            "followup_id": fid,
+        },
+        status_code=503,
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -1959,8 +2015,21 @@ def main():
             webbrowser.open(f"http://localhost:{args.port}")
         threading.Thread(target=_open, daemon=True).start()
 
+    # v7.12.12 — bind 0.0.0.0 when running inside WSL so the Windows host
+    # can reach the dashboard. WSL2 does auto port forwarding for 127.0.0.1
+    # in most setups, but corporate networks and certain WSL versions break
+    # the loopback bridge; binding all interfaces inside the guest closes
+    # that gap with no security cost (the WSL guest is private to the
+    # logged-in Windows user). On Mac/Linux native, keep 127.0.0.1.
+    bind_host = "127.0.0.1"
+    try:
+        from src.windows_runtime import running_inside_wsl  # type: ignore
+        if running_inside_wsl():
+            bind_host = "0.0.0.0"
+    except Exception:
+        pass
     import uvicorn
-    uvicorn.run(app, host="127.0.0.1", port=args.port, log_level="info")
+    uvicorn.run(app, host=bind_host, port=args.port, log_level="info")
 
 
 if __name__ == "__main__":

package/src/desktop_bridge.py

@@ -405,14 +405,20 @@ def _onboard_steps() -> list[dict]:
             "id": "residence",
             "prompt": {"es": "¿Dónde vives o trabajas habitualmente?", "en": "Where do you live or work most days?"},
             "hint": {
-                "es": "Una ciudad o zona; me ayuda con horarios, clima, ofertas locales y mil cosas más.",
-                "en": "A city or area; helps me with schedules, weather, local options, and a thousand small things.",
+                "es": "Empieza a escribir y elige tu ciudad. Guardo coordenadas para clima, horarios, etc.",
+                "en": "Start typing and pick your city. We save coordinates for weather, schedules, and so on.",
             },
-            "type": "text",
+            # v7.12.13 — `city` triggers the geocoding autocomplete in the
+            # renderer (CityStep talks to Nominatim and writes a JSON
+            # payload with display, name, lat, lon, country). The weather
+            # widget and any future location-aware feature can then read
+            # real coordinates from profile.current_residence instead of
+            # a free-text label.
+            "type": "city",
             "writes": "profile.current_residence",
             "file": "profile.json",
             "optional": True,
-            "validate": r"^.{0,120}$",
+            "validate": r"^.{0,2000}$",
         },
         {
             "id": "role",

package/src/email_sent_events.py

@@ -0,0 +1,222 @@
+"""Durable sent-email continuity for NEXO automations.
+
+The email monitor tracks inbound lifecycle rows. This module tracks outbound
+messages so startup, duplicate checks, and briefings can see what NEXO already
+sent even when the send path did not originate from an inbound email row.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+import paths
+
+
+EMAIL_SENT_TABLE_SQL = """
+CREATE TABLE IF NOT EXISTS sent_email_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    message_id TEXT,
+    sender TEXT,
+    to_addrs TEXT NOT NULL DEFAULT '',
+    cc_addrs TEXT NOT NULL DEFAULT '',
+    subject TEXT NOT NULL DEFAULT '',
+    in_reply_to TEXT NOT NULL DEFAULT '',
+    references_header TEXT NOT NULL DEFAULT '',
+    source TEXT NOT NULL DEFAULT '',
+    status TEXT NOT NULL DEFAULT 'sent',
+    sent_at TEXT NOT NULL DEFAULT (datetime('now','localtime')),
+    meta TEXT NOT NULL DEFAULT '{}'
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_sent_email_message_id
+ON sent_email_events(message_id)
+WHERE message_id IS NOT NULL AND message_id != '';
+CREATE INDEX IF NOT EXISTS idx_sent_email_sent_at ON sent_email_events(sent_at);
+CREATE INDEX IF NOT EXISTS idx_sent_email_subject ON sent_email_events(subject);
+"""
+
+RECENT_SENT_EMAILS_TITLE = "EMAILS ENVIADOS ULTIMAS 24H POR LA OPERATIVA"
+
+
+def sent_email_db_path() -> Path:
+    return paths.nexo_email_dir() / "nexo-email.db"
+
+
+def ensure_sent_email_table(conn: sqlite3.Connection) -> None:
+    conn.executescript(EMAIL_SENT_TABLE_SQL)
+
+
+def _connect(db_path: str | Path | None = None) -> sqlite3.Connection:
+    path = Path(db_path) if db_path else sent_email_db_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(path)
+    conn.row_factory = sqlite3.Row
+    ensure_sent_email_table(conn)
+    return conn
+
+
+def _clean(value: object, limit: int = 500) -> str:
+    text = " ".join(str(value or "").split())
+    if len(text) <= limit:
+        return text
+    return text[: limit - 3].rstrip() + "..."
+
+
+def _safe_meta(meta: dict[str, Any] | None) -> str:
+    try:
+        return json.dumps(meta or {}, ensure_ascii=True, sort_keys=True)
+    except Exception:
+        return "{}"
+
+
+def _record_cognitive_memory(event: dict[str, str]) -> None:
+    try:
+        import cognitive
+
+        to_value = event.get("to_addrs", "")
+        subject = event.get("subject", "")
+        message_id = event.get("message_id", "")
+        content = (
+            "Sent email recorded by NEXO. "
+            f"To: {to_value}. Subject: {subject}. Message-ID: {message_id}."
+        )
+        cognitive.ingest_to_ltm(
+            content,
+            source_type="email_sent",
+            source_id=message_id or f"{to_value}:{subject}",
+            source_title=subject,
+            domain="email",
+            tags="email,sent,continuity",
+            bypass_gate=True,
+        )
+    except Exception:
+        pass
+
+
+def record_sent_email(
+    *,
+    message_id: str = "",
+    sender: str = "",
+    to_addrs: str = "",
+    cc_addrs: str = "",
+    subject: str = "",
+    in_reply_to: str = "",
+    references_header: str = "",
+    source: str = "",
+    status: str = "sent",
+    meta: dict[str, Any] | None = None,
+    db_path: str | Path | None = None,
+    record_memory: bool = True,
+) -> dict[str, str]:
+    event = {
+        "message_id": _clean(message_id, 300),
+        "sender": _clean(sender, 300),
+        "to_addrs": _clean(to_addrs, 800),
+        "cc_addrs": _clean(cc_addrs, 800),
+        "subject": _clean(subject, 500),
+        "in_reply_to": _clean(in_reply_to, 300),
+        "references_header": _clean(references_header, 1000),
+        "source": _clean(source or "unknown", 120),
+        "status": _clean(status or "sent", 80),
+        "meta": _safe_meta(meta),
+    }
+    conn = _connect(db_path)
+    try:
+        conn.execute(
+            """
+            INSERT OR REPLACE INTO sent_email_events (
+                message_id, sender, to_addrs, cc_addrs, subject, in_reply_to,
+                references_header, source, status, meta
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                event["message_id"],
+                event["sender"],
+                event["to_addrs"],
+                event["cc_addrs"],
+                event["subject"],
+                event["in_reply_to"],
+                event["references_header"],
+                event["source"],
+                event["status"],
+                event["meta"],
+            ),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+    if record_memory:
+        _record_cognitive_memory(event)
+    return event
+
+
+def recent_sent_emails(
+    *,
+    hours: int = 24,
+    limit: int = 10,
+    db_path: str | Path | None = None,
+) -> list[dict[str, str]]:
+    cutoff = (datetime.now() - timedelta(hours=max(1, int(hours)))).strftime("%Y-%m-%d %H:%M:%S")
+    conn = _connect(db_path)
+    try:
+        rows = conn.execute(
+            """
+            SELECT message_id, sender, to_addrs, cc_addrs, subject, in_reply_to,
+                   references_header, source, status, sent_at, meta
+            FROM sent_email_events
+            WHERE sent_at >= ?
+            ORDER BY sent_at DESC
+            LIMIT ?
+            """,
+            (cutoff, max(1, int(limit))),
+        ).fetchall()
+        return [dict(row) for row in rows]
+    finally:
+        conn.close()
+
+
+def find_sent_email(
+    *,
+    to_addr: str = "",
+    subject: str = "",
+    since_hours: int = 72,
+    db_path: str | Path | None = None,
+) -> dict[str, str] | None:
+    target_to = _clean(to_addr).lower()
+    target_subject = _clean(subject).lower()
+    if not target_to or not target_subject:
+        return None
+    for event in recent_sent_emails(hours=since_hours, limit=100, db_path=db_path):
+        if target_to in str(event.get("to_addrs") or "").lower() and target_subject in str(event.get("subject") or "").lower():
+            return event
+    return None
+
+
+def format_recent_sent_email_block(*, hours: int = 24, limit: int = 8) -> str:
+    rows = recent_sent_emails(hours=hours, limit=limit)
+    if not rows:
+        return ""
+    lines = [f"== {RECENT_SENT_EMAILS_TITLE} =="]
+    for row in rows:
+        sent_at = str(row.get("sent_at") or "")
+        to_value = _clean(row.get("to_addrs"), 120)
+        subject = _clean(row.get("subject"), 160)
+        source = _clean(row.get("source"), 80)
+        lines.append(f"- {sent_at} | to: {to_value} | subject: {subject} | source: {source}")
+    return "\n".join(lines)
+
+
+__all__ = [
+    "RECENT_SENT_EMAILS_TITLE",
+    "ensure_sent_email_table",
+    "find_sent_email",
+    "format_recent_sent_email_block",
+    "recent_sent_emails",
+    "record_sent_email",
+    "sent_email_db_path",
+]

package/src/hooks/pre-compact.sh

@@ -230,24 +230,55 @@ conn.execute('''
 ''', (sid, decisions, pending, context_next, summary))
 conn.commit()
 
-# Layer 3: structured auto-flush for continuity and inspectability
+conn.close()
+" 2>/dev/null || true
+
+    # Layer 3: structured auto-flush is useful but non-critical. Keep it
+    # best-effort in the background so pre-compaction never blocks on heavy
+    # imports, vector backends, or ingestion latency after the emergency diary
+    # has already been committed.
+    (
+        NEXO_PRECOMPACT_SID="$TARGET_SID" \
+        NEXO_PRECOMPACT_LOG_FILE="$LOG_FILE" \
+        HOOK_DIR="$HOOK_DIR" \
+        python3 - <<'PY'
+import os
+import sqlite3
+import sys
+
+sid = os.environ.get("NEXO_PRECOMPACT_SID", "")
+log_file = os.environ.get("NEXO_PRECOMPACT_LOG_FILE", "")
+hook_dir = os.environ.get("HOOK_DIR", "")
+if not sid or not hook_dir:
+    sys.exit(0)
+
+sys.path.insert(0, os.path.abspath(os.path.join(hook_dir, "..")))
 try:
-    import os
-    sys.path.insert(0, os.path.abspath(os.path.join('$HOOK_DIR', '..')))
+    import paths
+
+    task = ""
+    try:
+        conn = sqlite3.connect(str(paths.db_path()), timeout=3)
+        row = conn.execute("SELECT task FROM sessions WHERE sid = ? LIMIT 1", (sid,)).fetchone()
+        task = (row[0] if row else "") or ""
+        conn.close()
+    except Exception:
+        task = ""
+
     import compaction_memory
+
     compaction_memory.record_auto_flush(
         session_id=sid,
         task=task,
-        current_goal='',
+        current_goal="",
         log_file=log_file,
-        last_diary_ts=last_diary_ts,
-        source='pre-compact-hook',
+        last_diary_ts="",
+        source="pre-compact-hook",
     )
 except Exception:
     pass
-
-conn.close()
-" 2>/dev/null || true
+PY
+    ) >/dev/null 2>&1 &
 fi
 
 cat << HOOKEOF

package/src/plugins/update.py

@@ -1137,19 +1137,23 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
         return msg
 
     new_version = _read_version()
-    if old_version == new_version:
-        return f"Already up to date (v{old_version}). No changes."
+    version_changed = old_version != new_version
+    if not version_changed:
+        _emit_progress(progress_fn, "Package version unchanged; running idempotent maintenance...")
 
     # 4. Post-npm verification steps
     errors = []
 
     # Reinstall pip deps for new version
-    _emit_progress(progress_fn, "Reconciling Python dependencies...")
-    pip_err = _reinstall_pip_deps()
-    if pip_err:
-        errors.append(f"pip deps: {pip_err}")
-
-    # Run migrations
+    if version_changed:
+        _emit_progress(progress_fn, "Reconciling Python dependencies...")
+        pip_err = _reinstall_pip_deps()
+        if pip_err:
+            errors.append(f"pip deps: {pip_err}")
+
+    # Run migrations even when npm reports the same package version. Several
+    # cleanup hooks are idempotent and may need to repair an install after a
+    # previous interrupted update without waiting for the next version bump.
     _emit_progress(progress_fn, "Running runtime migrations...")
     mig_err = _run_migrations()
     if mig_err:
@@ -1217,7 +1221,7 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
     if not clients_ok:
         client_sync_warning = client_sync_error or "unknown client sync error"
 
-    if old_version != new_version:
+    if version_changed:
         _emit_progress(progress_fn, "Reloading LaunchAgents after version bump...")
         try:
             launchagent_reload_summary = _reload_launch_agents_after_bump()
@@ -1235,7 +1239,7 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
     mcp_code_changed = False
     force_restart = False
     new_fingerprint = ""
-    if old_version != new_version:
+    if version_changed:
         try:
             _emit_progress(progress_fn, "Activating versioned runtime snapshot...")
             versioned_runtime_summary = activate_versioned_runtime_snapshot(
@@ -1308,8 +1312,13 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
         return "\n".join(lines)
 
     lines = ["UPDATE SUCCESSFUL (packaged install)"]
-    lines.append(f"  Version: {old_version} -> {new_version}")
+    if version_changed:
+        lines.append(f"  Version: {old_version} -> {new_version}")
+    else:
+        lines.append(f"  Version: {old_version} (unchanged; idempotent maintenance)")
     lines.append(f"  Backup: {backup_dir}")
+    if not version_changed:
+        lines.append("  Python deps: unchanged")
     if not cron_sync_warning:
         lines.append("  Crons: synced with manifest")
     else:
@@ -1340,7 +1349,11 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
     if restart_marker_summary:
         lines.append(f"  Restart marker: {restart_marker_summary.get('path')}")
     lines.append("")
-    if old_version != new_version and not mcp_code_changed and not force_restart:
+    if not version_changed:
+        lines.append(
+            "Package version unchanged; maintenance completed without an MCP restart."
+        )
+    elif not mcp_code_changed and not force_restart:
         # Doc-only / blog-only / changelog-only release. The bytes the running
         # MCP imports are byte-identical to what's now on disk, so existing
         # MCP clients keep working without a forced restart.
@@ -1432,16 +1445,20 @@ def handle_update(
         new_req_hash = _requirements_hash()
         deps_changed = old_req_hash != new_req_hash
 
+        no_changes_pulled = pull_out == "Already up to date."
+
         # Step 5: Reinstall pip dependencies if requirements.txt changed
-        if deps_changed or version_changed:
+        if deps_changed:
             _emit_progress(progress_fn, "Reconciling Python dependencies...")
             pip_err = _reinstall_pip_deps()
             if pip_err:
                 raise RuntimeError(f"Pip install failed: {pip_err}")
             steps_done.append("pip-deps")
 
-        # Step 6: Run migrations if version changed
-        if version_changed:
+        # Step 6: Run idempotent migrations/cleanup even on same-version
+        # updates. This repairs interrupted installs and pending cleanup
+        # without waiting for a future version bump.
+        if version_changed or no_changes_pulled:
             _emit_progress(progress_fn, "Running runtime migrations...")
             mig_err = _run_migrations()
             if mig_err:
@@ -1607,9 +1624,17 @@ def handle_update(
 
         # Build result
         dep_summary_lines = _format_dep_results(dep_results)
-        if pull_out == "Already up to date.":
-            msg = f"Already up to date (v{old_version}). No changes pulled."
+        if no_changes_pulled:
+            msg = f"Already up to date (v{old_version}). Idempotent maintenance completed."
             trailing = [*dep_summary_lines, *external_cli_lines]
+            if "migrations" in steps_done:
+                trailing.insert(0, "  Migrations: checked/applied")
+            if "hook-sync" in steps_done:
+                trailing.insert(1 if trailing else 0, "  Hooks: synced to NEXO_HOME")
+            if "cron-sync" in steps_done:
+                trailing.insert(2 if len(trailing) >= 2 else len(trailing), "  Crons: synced with manifest")
+            if "client-sync" in steps_done:
+                trailing.append("  Clients: configured client targets synced")
             if trailing:
                 msg += "\n" + "\n".join(trailing)
             return msg
@@ -1623,7 +1648,7 @@ def handle_update(
         lines.append(f"  Backup: {backup_dir}")
         if "pip-deps" in steps_done:
             lines.append("  Python deps: reinstalled")
-        if version_changed:
+        if "migrations" in steps_done:
             lines.append("  Migrations: applied")
         if "cron-sync" in steps_done:
             lines.append("  Crons: synced with manifest")

package/src/script_registry.py

@@ -1424,9 +1424,38 @@ def sync_personal_scripts(prune_missing: bool = True) -> dict:
         })
     result["schedule_audit"] = schedule_audit
     result["missing_declared_schedules"] = missing_declared
+    result["marker_warnings"] = _schedule_marker_warnings(schedule_audit)
     return result
 
 
+def _schedule_marker_warnings(schedule_audit: dict) -> list[dict]:
+    """Report LaunchAgent marker drift without silently blessing it.
+
+    Managed personal schedules must be both declared in inline metadata and
+    carry the managed marker written by the official schedule flow.
+    """
+    warnings: list[dict] = []
+    for record in (schedule_audit or {}).get("schedules", []) or []:
+        marker = bool(record.get("managed_marker"))
+        declared = bool(record.get("schedule_declared"))
+        matches = bool(record.get("schedule_matches_declared"))
+        if marker and not declared:
+            reason = "managed marker present but no valid declared schedule"
+        elif marker and declared and not matches:
+            reason = "managed marker present but schedule drifts from declaration"
+        elif not marker and declared:
+            reason = "declared schedule discovered without managed marker"
+        else:
+            continue
+        warnings.append({
+            "cron_id": str(record.get("cron_id") or ""),
+            "script_path": str(record.get("script_path") or ""),
+            "plist_path": str(record.get("plist_path") or ""),
+            "reason": reason,
+        })
+    return warnings
+
+
 def _schedule_matches(existing: dict, declared: dict) -> bool:
     if not existing or not declared.get("valid"):
         return False
@@ -1583,6 +1612,7 @@ def reconcile_personal_scripts(*, dry_run: bool = False) -> dict:
         "dry_run": dry_run,
         "renamed_legacy_filenames": renamed_result,
         "sync": sync_result,
+        "marker_warnings": sync_result.get("marker_warnings", []),
         "ensure_schedules": ensure_result,
         "classification": ensure_result.get("classification", sync_result.get("classification", {})),
     }

package/src/scripts/check-context.py

@@ -21,6 +21,7 @@ if str(NEXO_CODE) not in sys.path:
     sys.path.insert(0, str(NEXO_CODE))
 
 import paths
+from email_sent_events import find_sent_email
 from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 from core_prompts import render_core_prompt
 try:
@@ -38,6 +39,9 @@ class ContextChecker:
 
     def check_email_sent(self, to_addr, subject, since_hours=72):
         """Check if email was already sent to address with subject."""
+        if find_sent_email(to_addr=to_addr, subject=subject, since_hours=since_hours):
+            return True
+
         sent_path = Path.home() / "mail" / ".nexo-sent" / ".Sent"
         if not sent_path.exists():
             return False

package/src/scripts/nexo-morning-agent.py

@@ -55,6 +55,7 @@ from automation_controls import (
 )
 from client_preferences import resolve_automation_backend, resolve_client_runtime_profile
 from core_prompts import render_core_prompt
+from email_sent_events import format_recent_sent_email_block, recent_sent_emails
 import db as nexo_db
 from paths import data_dir, logs_dir, operations_dir
 from runtime_home import export_resolved_nexo_home
@@ -188,6 +189,23 @@ def _serialize_diaries(*, limit: int) -> list[dict]:
     return result
 
 
+def _serialize_recent_sent_emails(*, limit: int = 8) -> list[dict]:
+    result: list[dict] = []
+    try:
+        rows = recent_sent_emails(hours=24, limit=limit)
+    except Exception:
+        return result
+    for row in rows:
+        result.append({
+            "sent_at": str(row.get("sent_at") or ""),
+            "to": _clean_text(row.get("to_addrs"), limit=180),
+            "subject": _clean_text(row.get("subject"), limit=220),
+            "source": str(row.get("source") or ""),
+            "message_id": str(row.get("message_id") or ""),
+        })
+    return result
+
+
 def collect_context(profile: dict) -> dict:
     nexo_db.init_db()
     due_followups = _serialize_followups("due", limit=MAX_DUE_ITEMS)
@@ -204,6 +222,7 @@ def collect_context(profile: dict) -> dict:
         for row in _serialize_reminders("active", limit=MAX_ACTIVE_ITEMS + MAX_DUE_ITEMS)
         if row["id"] not in due_reminder_ids
     ][:MAX_ACTIVE_ITEMS]
+    recent_sent = _serialize_recent_sent_emails()
     return {
         "generated_at": datetime.now().astimezone().isoformat(),
         "today": date.today().isoformat(),
@@ -220,15 +239,27 @@ def collect_context(profile: dict) -> dict:
         "due_followups": due_followups,
         "active_followups": active_followups,
         "recent_diaries": _serialize_diaries(limit=MAX_DIARY_ITEMS),
+        "recent_sent_emails_24h": recent_sent,
         "counts": {
             "due_reminders": len(due_reminders),
             "active_reminders": len(active_reminders),
             "due_followups": len(due_followups),
             "active_followups": len(active_followups),
+            "recent_sent_emails_24h": len(recent_sent),
         },
     }
 
 
+def append_recent_sent_email_block(body: str) -> str:
+    try:
+        block = format_recent_sent_email_block(hours=24, limit=8)
+    except Exception:
+        block = ""
+    if not block or "EMAILS ENVIADOS ULTIMAS 24H" in body:
+        return body
+    return body.rstrip() + "\n\n" + block + "\n"
+
+
 def build_prompt(context: dict, *, extra_instructions_block: str = "") -> str:
     operator = context.get("operator") if isinstance(context.get("operator"), dict) else {}
     assistant = context.get("assistant") if isinstance(context.get("assistant"), dict) else {}
@@ -390,6 +421,7 @@ def main(argv: list[str] | None = None) -> int:
             extra_instructions_block=format_operator_extra_instructions_block("morning-agent"),
         )
         subject, body = generate_briefing(prompt)
+        body = append_recent_sent_email_block(body)
         write_latest_briefing(recipient=recipient or "[dry-run]", subject=subject, body=body)
 
         if args.dry_run:

package/src/scripts/nexo-send-reply.py

@@ -46,6 +46,7 @@ if str(_repo_src) not in sys.path:
 
 from paths import nexo_email_dir
 from runtime_home import export_resolved_nexo_home
+from email_sent_events import record_sent_email
 
 NEXO_HOME = export_resolved_nexo_home()
 EMAIL_BASE_DIR = nexo_email_dir()
@@ -501,11 +502,12 @@ def main(argv=None):
             args.in_reply_to, args.references,
             attachments=args.attach
         )
+        sent_copy_saved = False
         try:
-            save_to_sent(config, raw_message)
+            sent_copy_saved = bool(save_to_sent(config, raw_message))
         except Exception as sent_exc:
             print(f"WARN: sent copy not saved to IMAP Sent: {sent_exc}", file=sys.stderr)
-        record_reply_lifecycle(
+        lifecycle_event = record_reply_lifecycle(
             args.in_reply_to,
             args.references,
             reply_body,
@@ -514,6 +516,24 @@ def main(argv=None):
             cc=args.cc,
             message_id=msg_id,
         )
+        try:
+            record_sent_email(
+                message_id=msg_id,
+                sender=str(config.get("email") or ""),
+                to_addrs=args.to,
+                cc_addrs=args.cc,
+                subject=args.subject,
+                in_reply_to=args.in_reply_to,
+                references_header=args.references,
+                source="nexo-send-reply",
+                meta={
+                    "sent_copy_saved": sent_copy_saved,
+                    "lifecycle_event": lifecycle_event,
+                    "account_label": (args.account_label or "").strip(),
+                },
+            )
+        except Exception as sent_event_exc:
+            print(f"WARN: sent email continuity tracking failed: {sent_event_exc}", file=sys.stderr)
         print(f"OK:{msg_id}")
     except Exception as e:
         print(f"FAIL:{e}", file=sys.stderr)

package/src/scripts/nexo-sleep.py

@@ -19,10 +19,12 @@ Stage B — Dreaming (automation backend):
 """
 
 import fcntl
+import atexit
 import json
 import os
 import re
 import shutil
+import signal
 import sqlite3
 import subprocess
 import sys
@@ -73,6 +75,8 @@ PROCESS_LOCK = COORD_DIR / "sleep-process.lock"
 TODAY = date.today()
 NOW = datetime.now()
 TIMESTAMP = NOW.strftime("%Y-%m-%d %H:%M")
+_PROCESS_LOCK_FD = None
+_PROCESS_LOCK_CLEANED = False
 
 
 # ─── Run-once & resume logic (unchanged from v1) ──────────────────────────────
@@ -128,6 +132,42 @@ def mark_complete():
     LOCK_FILE.unlink(missing_ok=True)
 
 
+def _cleanup_process_lock():
+    global _PROCESS_LOCK_FD, _PROCESS_LOCK_CLEANED
+
+    if _PROCESS_LOCK_CLEANED:
+        return
+    _PROCESS_LOCK_CLEANED = True
+    try:
+        if _PROCESS_LOCK_FD is not None:
+            fcntl.flock(_PROCESS_LOCK_FD, fcntl.LOCK_UN)
+            _PROCESS_LOCK_FD.close()
+    except Exception:
+        pass
+    finally:
+        _PROCESS_LOCK_FD = None
+        try:
+            PROCESS_LOCK.unlink(missing_ok=True)
+        except Exception:
+            pass
+
+
+def _handle_shutdown_signal(signum, _frame):
+    log(f"Received shutdown signal {signum}; cleaning sleep process lock.")
+    _cleanup_process_lock()
+    raise SystemExit(128 + signum)
+
+
+def _register_process_lock_cleanup(lock_fd):
+    global _PROCESS_LOCK_FD, _PROCESS_LOCK_CLEANED
+
+    _PROCESS_LOCK_FD = lock_fd
+    _PROCESS_LOCK_CLEANED = False
+    atexit.register(_cleanup_process_lock)
+    signal.signal(signal.SIGINT, _handle_shutdown_signal)
+    signal.signal(signal.SIGTERM, _handle_shutdown_signal)
+
+
 # ─── Helpers ──────────────────────────────────────────────────────────────────
 
 def log(msg: str):
@@ -518,6 +558,7 @@ def main():
         fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
         lock_fd.write(str(os.getpid()))
         lock_fd.flush()
+        _register_process_lock_cleanup(lock_fd)
     except (IOError, OSError):
         log("Another sleep instance running. Exiting.")
         sys.exit(0)
@@ -587,12 +628,7 @@ def main():
                 pass
 
     finally:
-        try:
-            fcntl.flock(lock_fd, fcntl.LOCK_UN)
-            lock_fd.close()
-            PROCESS_LOCK.unlink(missing_ok=True)
-        except Exception:
-            pass
+        _cleanup_process_lock()
 
 
 if __name__ == "__main__":

package/src/tools_sessions.py

@@ -1073,6 +1073,13 @@ def handle_smart_startup_query() -> str:
     from db import get_db
     conn = get_db()
     query_parts = []
+    sent_email_block = ""
+    try:
+        from email_sent_events import format_recent_sent_email_block
+
+        sent_email_block = format_recent_sent_email_block(hours=24, limit=8)
+    except Exception:
+        sent_email_block = ""
 
     # 1. Pending followups (what NEXO needs to do)
     followups = conn.execute(
@@ -1099,6 +1106,8 @@ def handle_smart_startup_query() -> str:
         pass
 
     if not query_parts:
+        if sent_email_block:
+            return sent_email_block
         return "No pending context to pre-load."
 
     # Search per-part to avoid diffuse centroid that matches everything
@@ -1123,6 +1132,8 @@ def handle_smart_startup_query() -> str:
         results = sorted(all_results, key=lambda x: x["score"], reverse=True)[:10]
         composite_query = " | ".join(query_parts[:6])
         if not results:
+            if sent_email_block:
+                return "Smart startup query: no relevant memories found.\n\n" + sent_email_block
             return "Smart startup query: no relevant memories found."
 
         lines = [f"SMART STARTUP — {len(results)} memories pre-loaded from composite query:"]
@@ -1138,6 +1149,10 @@ def handle_smart_startup_query() -> str:
         except Exception:
             pass
 
+        if sent_email_block:
+            lines.append("")
+            lines.append(sent_email_block)
+
         # Session tone from Deep Sleep (emotional intelligence layer)
         tone = _load_session_tone()
         if tone: