nexo-brain 7.12.14 → 7.12.15

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.12.14",
+  "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.14` is the current packaged-runtime line. Patch release — dashboard followup execution now respects the selected terminal client across macOS, Windows via WSL, and Linux instead of returning a macOS-only dead end. Result: operators can launch followups from the dashboard on every supported Brain host without hardcoding Claude-only or Mac-only assumptions.
+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/package.json

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