nexo-brain 7.30.4 → 7.30.6

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.4",
+  "version": "7.30.6",
   "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,9 @@
 
 [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.30.4` is the current packaged-runtime line. Patch release over v7.30.3 - local runtime update post-sync now gives bounded Memory Fabric repair enough time to finish, and headless automations now treat `nexo_stop` as a terminal close so followup/deep-sleep runners do not reopen no-op protocol loops.
+Version `7.30.6` is the current packaged-runtime line. Patch release over v7.30.5 - Deep Sleep now rotates its operational artifacts and logs automatically, keeping historical installs bounded without touching local-context memory.
+
+Previously in `7.30.4`: patch release over v7.30.3 - local runtime update post-sync now gives bounded Memory Fabric repair enough time to finish, and headless automations now treat `nexo_stop` as a terminal close so followup/deep-sleep runners do not reopen no-op protocol loops.
 
 Previously in `7.30.3`: patch release over v7.30.2 - release closeout now protects the freshly written runtime backup from technical pruning and validates protocol evidence against the canonical `runtime/data/nexo.db` layout.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.4",
+  "version": "7.30.6",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/auto_update.py

@@ -2275,6 +2275,21 @@ def _heal_deep_sleep_runtime(dest: Path = NEXO_HOME) -> list[str]:
         except OSError:
             pass
 
+    # (5) Bound Deep Sleep operational artifacts for existing installs. Older
+    # versions accumulated DB backups and large context dumps indefinitely; this
+    # apply path runs on update so users do not have to wait for the next night.
+    try:
+        from deep_sleep_retention import prune_deep_sleep_runtime
+
+        report = prune_deep_sleep_runtime(nexo_home=dest, apply=True)
+        deleted = int(report.get("deleted_count") or 0)
+        rotated = int(report.get("logs_rotated") or 0)
+        freed = int(report.get("deleted_bytes") or 0) + int(report.get("log_bytes_trimmed") or 0)
+        if deleted or rotated:
+            actions.append(f"retention:{deleted}-deleted:{rotated}-logs:{freed}-bytes")
+    except Exception as exc:
+        actions.append(f"retention-warning:{exc.__class__.__name__}")
+
     return actions
 
 

package/src/automation_preferences.py

@@ -14,20 +14,34 @@ SUPPORTED_AUTOMATIONS = {"morning-agent"}
 
 
 MORNING_AGENT_SCHEMA: dict[str, Any] = {
-    "schema_version": 1,
+    "schema_version": 2,
     "automation": "morning-agent",
-    "title": "Morning briefing content",
+    "title": "Morning preparation",
     "groups": [
         {
             "id": "content",
-            "label": "Content",
+            "label": "What NEXO watches",
             "items": [
+                {
+                    "id": "auto_relevance",
+                    "type": "boolean",
+                    "label": "Automatic relevance",
+                    "default": True,
+                    "help": "NEXO decides what matters by urgency, change, impact, confidence and whether there is a useful next action.",
+                },
                 {
                     "id": "priorities",
                     "type": "boolean",
                     "label": "Priorities",
                     "default": True,
-                    "help": "The most important things NEXO thinks you should look at first.",
+                    "help": "The most important things to look at first today.",
+                },
+                {
+                    "id": "changes_since_yesterday",
+                    "type": "boolean",
+                    "label": "What changed",
+                    "default": True,
+                    "help": "Recent changes, new information and moved work that may affect the day.",
                 },
                 {
                     "id": "agenda",
@@ -72,19 +86,25 @@ MORNING_AGENT_SCHEMA: dict[str, Any] = {
                     "help": "Things that may stop progress, need your decision or could become a problem.",
                 },
                 {
-                    "id": "internal_refs",
+                    "id": "next_actions",
                     "type": "boolean",
-                    "label": "Internal references",
-                    "default": False,
-                    "help": "Technical file names, IDs or internal references. Keep this off for a cleaner human summary.",
+                    "label": "Next actions",
+                    "default": True,
+                    "help": "A practical closing list of what to do first, what can wait and what needs a decision.",
                 },
                 {
-                    "id": "news",
+                    "id": "internal_refs",
                     "type": "boolean",
-                    "label": "News",
+                    "label": "Internal references",
                     "default": False,
-                    "help": "A short set of current public headlines from the configured news feed, included only when the source can be verified.",
+                    "help": "Technical file names, IDs or internal references. Keep this off for a cleaner human summary.",
                 },
+            ],
+        },
+        {
+            "id": "external",
+            "label": "Day context",
+            "items": [
                 {
                     "id": "weather",
                     "type": "boolean",
@@ -92,6 +112,50 @@ MORNING_AGENT_SCHEMA: dict[str, Any] = {
                     "default": True,
                     "help": "Today's weather from the location saved in Desktop or your residence in the profile, included only when the forecast can be verified.",
                 },
+                {
+                    "id": "news",
+                    "type": "boolean",
+                    "label": "Relevant public context",
+                    "default": True,
+                    "help": "Public headlines only when they are current, verifiable and useful for the operator's day, work, location or interests.",
+                },
+                {
+                    "id": "news_interests",
+                    "type": "multi_choice",
+                    "label": "Public context interests",
+                    "default": ["automatic"],
+                    "options": [
+                        "automatic",
+                        "business",
+                        "technology",
+                        "finance",
+                        "local",
+                        "health",
+                        "legal",
+                        "education",
+                        "real_estate",
+                        "science",
+                        "culture",
+                        "sports",
+                    ],
+                    "exclusive_options": ["automatic"],
+                    "help": "Use Automatic so NEXO infers useful topics, or choose areas you want watched in the morning.",
+                },
+                {
+                    "id": "excluded_topics",
+                    "type": "multi_choice",
+                    "label": "Topics to avoid",
+                    "default": [],
+                    "options": ["politics", "sports", "celebrity", "crime", "crypto", "market_noise"],
+                    "help": "Topics NEXO should avoid unless they are directly relevant to your work or safety.",
+                },
+                {
+                    "id": "why_shown",
+                    "type": "boolean",
+                    "label": "Explain why",
+                    "default": False,
+                    "help": "Adds a short reason when NEXO includes external context, useful while tuning the briefing.",
+                },
             ],
         },
         {
@@ -176,6 +240,36 @@ def _iter_schema_items(schema: dict[str, Any]):
                 yield item
 
 
+def _normalize_multi_choice(raw_value: Any, item: dict[str, Any]) -> tuple[list[str], list[str]]:
+    options = [str(v) for v in list(item.get("options") or [])]
+    allowed = set(options)
+    warnings: list[str] = []
+    if isinstance(raw_value, (list, tuple, set)):
+        raw_items = list(raw_value)
+    else:
+        text = str(raw_value or "").strip()
+        if not text:
+            raw_items = []
+        else:
+            raw_items = [part.strip() for part in text.replace(";", ",").split(",")]
+    selected: list[str] = []
+    for raw_item in raw_items:
+        clean = str(raw_item or "").strip()
+        if not clean:
+            continue
+        if clean not in allowed:
+            warnings.append(f"{item.get('id')}: invalid option {clean}")
+            continue
+        if clean not in selected:
+            selected.append(clean)
+    exclusive = [str(v) for v in list(item.get("exclusive_options") or [])]
+    for exclusive_value in exclusive:
+        if exclusive_value in selected and len(selected) > 1:
+            selected = [exclusive_value]
+            break
+    return selected, warnings
+
+
 def default_automation_preferences(name: str) -> dict[str, Any]:
     schema = get_automation_preference_schema(name)
     values: dict[str, Any] = {}
@@ -218,6 +312,10 @@ def validate_automation_preferences(name: str, payload: dict[str, Any] | None) -
                 values[key] = clean
             else:
                 warnings.append(f"{key}: invalid choice")
+        elif kind in {"multi_choice", "multi-select", "multiselect"}:
+            selected, item_warnings = _normalize_multi_choice(raw_value, item)
+            values[key] = selected
+            warnings.extend(item_warnings)
         elif kind == "number":
             try:
                 values[key] = int(raw_value)
@@ -349,11 +447,16 @@ def format_automation_preferences_prompt_block(name_or_path: str) -> str:
         "\n== STRUCTURED CONTENT PREFERENCES FOR THIS AUTOMATION ==\n"
         f"{compact}\n"
         "Morning briefing intent: act like a professional personal assistant preparing the operator for the day. "
-        "Do not merely list available records; filter, rank, and explain what deserves attention first.\n"
+        "The result is a start-of-day preparation, not a settings checklist or a report dump.\n"
+        "Do not merely list available records; filter, rank, and explain what deserves attention first. "
+        "Score relevance by urgency, change since yesterday, impact, actionability, confidence, and user preference.\n"
         "Adapt the emphasis from the operator profile, role, recent activity, and context. "
         "Do not ask the user to choose a user type manually and do not assume a profession unless the context supports it.\n"
+        "If automatic relevance is enabled, omit low-value items even when their source is enabled. "
+        "Prefer a short Top 3, important changes, commitments, risks, and practical next actions.\n"
         "Use these preferences to decide what to include, omit, and emphasize. "
-        "Disabled/unavailable data sources must not be invented; news and weather require verified collected data.\n"
+        "Disabled/unavailable data sources must not be invented; news and weather require verified collected data. "
+        "Relevant public context should be included only when it helps the operator understand the day, their work, their location, or a declared interest.\n"
     )
 
 

package/src/deep_sleep_retention.py

@@ -0,0 +1,320 @@
+"""Deep Sleep runtime retention.
+
+Keeps Deep Sleep operational artifacts bounded without touching the live memory
+databases or the local-context index. The policy is intentionally conservative:
+old context dumps are only deleted after their run produced a synthesis or agent
+start packet, so failed or incomplete nights remain debuggable.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import time
+from pathlib import Path
+from typing import Iterable
+
+DEFAULT_KEEP_DB_BACKUPS = int(os.environ.get("NEXO_DEEP_SLEEP_KEEP_DB_BACKUPS", "3") or "3")
+DEFAULT_KEEP_CONTEXTS = int(os.environ.get("NEXO_DEEP_SLEEP_KEEP_CONTEXTS", "7") or "7")
+DEFAULT_MAX_LOG_BYTES = int(os.environ.get("NEXO_DEEP_SLEEP_MAX_LOG_BYTES", str(1024 * 1024)) or str(1024 * 1024))
+DEFAULT_RETAINED_LOG_BYTES = int(
+    os.environ.get("NEXO_DEEP_SLEEP_RETAINED_LOG_BYTES", str(768 * 1024)) or str(768 * 1024)
+)
+DEBUG_TTL_SECONDS = int(os.environ.get("NEXO_DEEP_SLEEP_DEBUG_TTL_SECONDS", str(7 * 86400)) or str(7 * 86400))
+
+_DATE_PREFIX_RE = re.compile(r"^(\d{4}-\d{2}-\d{2})(?:[-T]?(\d{6}))?")
+_DATE_CONTEXT_RE = re.compile(r"^(\d{4}-\d{2}-\d{2}(?:[-T]?\d{6})?)-context\.txt$")
+
+
+def _default_home() -> Path:
+    return Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))).expanduser()
+
+
+def _dedupe_existing(paths: Iterable[Path]) -> list[Path]:
+    seen: set[Path] = set()
+    result: list[Path] = []
+    for path in paths:
+        try:
+            key = path.resolve()
+        except OSError:
+            key = path
+        if key in seen or not path.exists():
+            continue
+        seen.add(key)
+        result.append(path)
+    return result
+
+
+def _deep_sleep_dirs(nexo_home: Path) -> list[Path]:
+    return _dedupe_existing(
+        [
+            nexo_home / "runtime" / "operations" / "deep-sleep",
+            nexo_home / "operations" / "deep-sleep",
+        ]
+    )
+
+
+def _log_dirs(nexo_home: Path) -> list[Path]:
+    return _dedupe_existing(
+        [
+            nexo_home / "runtime" / "logs",
+            nexo_home / "logs",
+        ]
+    )
+
+
+def _artifact_sort_key(path: Path) -> tuple[float, str]:
+    match = _DATE_PREFIX_RE.match(path.name)
+    if match:
+        date_part, time_part = match.groups()
+        compact = date_part.replace("-", "") + (time_part or "000000")
+        try:
+            return (float(compact), path.name)
+        except ValueError:
+            pass
+    try:
+        return (path.stat().st_mtime, path.name)
+    except OSError:
+        return (0.0, path.name)
+
+
+def _analyzed_marker_exists(deep_sleep_dir: Path, run_id: str) -> bool:
+    markers = [
+        deep_sleep_dir / f"{run_id}-agent-start-packet.json",
+        deep_sleep_dir / f"{run_id}-synthesis.json",
+        deep_sleep_dir / f"{run_id}-applied.json",
+        deep_sleep_dir / run_id / "synthesis.json",
+    ]
+    return any(path.exists() and path.stat().st_size > 0 for path in markers)
+
+
+def _path_size(path: Path) -> int:
+    try:
+        if path.is_dir():
+            total = 0
+            for child in path.rglob("*"):
+                try:
+                    if child.is_file() or child.is_symlink():
+                        total += child.stat().st_size
+                except OSError:
+                    continue
+            return total
+        return path.stat().st_size
+    except OSError:
+        return 0
+
+
+def _delete_path(path: Path, *, apply: bool) -> tuple[bool, int]:
+    size = _path_size(path)
+    if not apply:
+        return True, size
+    try:
+        if path.is_dir():
+            shutil.rmtree(path)
+        else:
+            path.unlink()
+        return True, size
+    except FileNotFoundError:
+        return False, 0
+    except OSError:
+        return False, 0
+
+
+def _sidecars(path: Path) -> list[Path]:
+    candidates = [Path(str(path) + "-wal"), Path(str(path) + "-shm")]
+    return [candidate for candidate in candidates if candidate.exists()]
+
+
+def _record_delete(report: dict, path: Path, *, reason: str, apply: bool) -> None:
+    ok, size = _delete_path(path, apply=apply)
+    if not ok:
+        report["warnings"].append(f"delete-failed:{path}")
+        return
+    report["deleted_count"] += 1
+    report["deleted_bytes"] += size
+    report["deleted"].append({"path": str(path), "bytes": size, "reason": reason})
+
+
+def _prune_db_backups(deep_sleep_dir: Path, report: dict, *, keep: int, apply: bool) -> None:
+    for family in ("*-backup-nexo.db", "*-backup-cognitive.db"):
+        backups = sorted(deep_sleep_dir.glob(family), key=_artifact_sort_key, reverse=True)
+        kept = backups[:keep]
+        report["kept"].append({"kind": family, "count": len(kept), "root": str(deep_sleep_dir)})
+        for backup in backups[keep:]:
+            _record_delete(report, backup, reason=f"old-db-backup:{family}", apply=apply)
+            for sidecar in _sidecars(backup):
+                _record_delete(report, sidecar, reason=f"old-db-backup-sidecar:{family}", apply=apply)
+
+
+def _prune_contexts(deep_sleep_dir: Path, report: dict, *, keep: int, apply: bool) -> None:
+    contexts: list[tuple[str, Path]] = []
+    for path in deep_sleep_dir.glob("*-context.txt"):
+        match = _DATE_CONTEXT_RE.match(path.name)
+        if not match:
+            continue
+        contexts.append((match.group(1), path))
+
+    contexts.sort(key=lambda item: _artifact_sort_key(item[1]), reverse=True)
+    keep_run_ids = {run_id for run_id, _ in contexts[:keep]}
+    report["kept"].append({"kind": "context.txt", "count": min(len(contexts), keep), "root": str(deep_sleep_dir)})
+
+    for run_id, context_file in contexts[keep:]:
+        if run_id in keep_run_ids:
+            continue
+        if not _analyzed_marker_exists(deep_sleep_dir, run_id):
+            report["kept"].append({"kind": "unanalyzed-context", "path": str(context_file)})
+            continue
+        _record_delete(report, context_file, reason="old-analyzed-context", apply=apply)
+        date_dir = deep_sleep_dir / run_id
+        if date_dir.is_dir():
+            _record_delete(report, date_dir, reason="old-analyzed-context-dir", apply=apply)
+
+
+def _prune_debug_scratch(deep_sleep_dir: Path, report: dict, *, now: float, apply: bool) -> None:
+    for pattern in ("debug-extract-*.txt", "debug-synthesize-*.txt"):
+        for path in deep_sleep_dir.glob(pattern):
+            try:
+                if now - path.stat().st_mtime <= DEBUG_TTL_SECONDS:
+                    continue
+            except OSError:
+                continue
+            _record_delete(report, path, reason="old-debug-scratch", apply=apply)
+
+
+def _rotate_log(path: Path, report: dict, *, max_bytes: int, retained_bytes: int, apply: bool) -> None:
+    try:
+        original_size = path.stat().st_size
+    except OSError:
+        return
+    if original_size <= max_bytes:
+        return
+    retained_bytes = max(1, min(retained_bytes, max_bytes))
+    if not apply:
+        report["logs_rotated"] += 1
+        report["log_bytes_trimmed"] += max(0, original_size - retained_bytes)
+        report["rotated_logs"].append({"path": str(path), "original_bytes": original_size, "dry_run": True})
+        return
+
+    try:
+        with path.open("rb") as fh:
+            if original_size > retained_bytes:
+                fh.seek(-retained_bytes, os.SEEK_END)
+            tail = fh.read()
+        newline = tail.find(b"\n")
+        if newline > 0:
+            tail = tail[newline + 1 :]
+        header = (
+            f"[rotated by NEXO Deep Sleep retention; original_bytes={original_size}; "
+            f"retained_bytes={len(tail)}]\n"
+        ).encode("utf-8")
+        path.write_bytes(header + tail)
+        new_size = path.stat().st_size
+    except OSError as exc:
+        report["warnings"].append(f"log-rotate-failed:{path}:{exc.__class__.__name__}")
+        return
+
+    report["logs_rotated"] += 1
+    report["log_bytes_trimmed"] += max(0, original_size - new_size)
+    report["rotated_logs"].append({"path": str(path), "original_bytes": original_size, "new_bytes": new_size})
+
+
+def _rotate_logs(nexo_home: Path, report: dict, *, max_bytes: int, retained_bytes: int, apply: bool) -> None:
+    names = {
+        "deep-sleep.log",
+        "deep-sleep-stdout.log",
+        "deep-sleep-stderr.log",
+        "sleep-stdout.log",
+        "sleep-stderr.log",
+        "prevent-sleep-stdout.log",
+        "prevent-sleep-stderr.log",
+    }
+    for log_dir in _log_dirs(nexo_home):
+        for name in names:
+            path = log_dir / name
+            if path.is_file():
+                _rotate_log(path, report, max_bytes=max_bytes, retained_bytes=retained_bytes, apply=apply)
+
+
+def prune_deep_sleep_runtime(
+    *,
+    nexo_home: str | Path | None = None,
+    apply: bool = False,
+    keep_db_backups: int = DEFAULT_KEEP_DB_BACKUPS,
+    keep_contexts: int = DEFAULT_KEEP_CONTEXTS,
+    max_log_bytes: int = DEFAULT_MAX_LOG_BYTES,
+    retained_log_bytes: int = DEFAULT_RETAINED_LOG_BYTES,
+) -> dict:
+    """Apply or plan Deep Sleep retention for a runtime home."""
+    home = Path(nexo_home).expanduser() if nexo_home is not None else _default_home()
+    keep_db_backups = max(1, int(keep_db_backups))
+    keep_contexts = max(1, int(keep_contexts))
+    report: dict = {
+        "ok": True,
+        "apply": bool(apply),
+        "nexo_home": str(home),
+        "roots": [],
+        "deleted_count": 0,
+        "deleted_bytes": 0,
+        "deleted": [],
+        "kept": [],
+        "logs_rotated": 0,
+        "log_bytes_trimmed": 0,
+        "rotated_logs": [],
+        "warnings": [],
+    }
+
+    now = time.time()
+    for deep_sleep_dir in _deep_sleep_dirs(home):
+        report["roots"].append(str(deep_sleep_dir))
+        _prune_db_backups(deep_sleep_dir, report, keep=keep_db_backups, apply=apply)
+        _prune_contexts(deep_sleep_dir, report, keep=keep_contexts, apply=apply)
+        _prune_debug_scratch(deep_sleep_dir, report, now=now, apply=apply)
+    _rotate_logs(home, report, max_bytes=max_log_bytes, retained_bytes=retained_log_bytes, apply=apply)
+    return report
+
+
+def _print_human(report: dict) -> None:
+    mode = "apply" if report.get("apply") else "dry-run"
+    print(f"NEXO Deep Sleep retention ({mode})")
+    print(f"  roots: {len(report.get('roots') or [])}")
+    print(f"  deleted: {report.get('deleted_count', 0)}")
+    print(f"  freed/planned: {report.get('deleted_bytes', 0)} bytes")
+    print(f"  logs_rotated: {report.get('logs_rotated', 0)}")
+    print(f"  log_bytes_trimmed: {report.get('log_bytes_trimmed', 0)}")
+    if report.get("warnings"):
+        print("  warnings:")
+        for warning in report["warnings"]:
+            print(f"    - {warning}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="NEXO Deep Sleep retention")
+    parser.add_argument("--nexo-home", default=None)
+    parser.add_argument("--apply", action="store_true", help="delete/rotate instead of dry-run")
+    parser.add_argument("--json", action="store_true", help="print machine-readable JSON")
+    parser.add_argument("--quiet", action="store_true", help="suppress human output")
+    parser.add_argument("--keep-db-backups", type=int, default=DEFAULT_KEEP_DB_BACKUPS)
+    parser.add_argument("--keep-contexts", type=int, default=DEFAULT_KEEP_CONTEXTS)
+    parser.add_argument("--max-log-bytes", type=int, default=DEFAULT_MAX_LOG_BYTES)
+    parser.add_argument("--retained-log-bytes", type=int, default=DEFAULT_RETAINED_LOG_BYTES)
+    args = parser.parse_args(argv)
+
+    report = prune_deep_sleep_runtime(
+        nexo_home=args.nexo_home,
+        apply=args.apply,
+        keep_db_backups=args.keep_db_backups,
+        keep_contexts=args.keep_contexts,
+        max_log_bytes=args.max_log_bytes,
+        retained_log_bytes=args.retained_log_bytes,
+    )
+    if args.json:
+        print(json.dumps(report, indent=2, ensure_ascii=False))
+    elif not args.quiet:
+        _print_human(report)
+    return 0 if report.get("ok") else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/preference_catalog.py

@@ -10,10 +10,18 @@ from typing import Any
 
 
 AUTOMATION_ITEM_ES = {
+    "auto_relevance": (
+        "Relevancia automática",
+        "NEXO decide qué merece aparecer usando urgencia, cambios, impacto, confianza y si hay una acción útil.",
+    ),
     "priorities": (
         "Prioridades",
         "Incluye las cosas más importantes del día: lo urgente, lo atrasado y lo que conviene resolver primero.",
     ),
+    "changes_since_yesterday": (
+        "Cambios importantes",
+        "Incluye novedades recientes, cambios desde ayer y asuntos que se han movido mientras no estabas.",
+    ),
     "agenda": (
         "Agenda",
         "Añade citas, eventos o bloques de calendario que NEXO conozca para que sepas qué viene hoy.",
@@ -38,13 +46,29 @@ AUTOMATION_ITEM_ES = {
         "Bloqueos y riesgos",
         "Señala bloqueos, riesgos o asuntos que pueden frenarte si no los atiendes.",
     ),
+    "next_actions": (
+        "Siguientes acciones",
+        "Cierra el resumen con pasos prácticos: qué mirar primero, qué puede esperar y qué decisión falta.",
+    ),
     "internal_refs": (
         "Referencias internas",
         "Incluye referencias internas útiles. Déjalo desactivado si prefieres un resumen más limpio.",
     ),
     "news": (
-        "Noticias",
-        "Añade titulares públicos. Si internet o la fuente de noticias falla, NEXO seguirá preparando el resumen.",
+        "Actualidad relevante",
+        "Añade contexto público solo si es actual, verificable y útil para tu día, trabajo, ubicación o intereses.",
+    ),
+    "news_interests": (
+        "Temas de actualidad",
+        "Temas que NEXO debe vigilar. Usa automático para que los infiera por tu contexto y hábitos.",
+    ),
+    "excluded_topics": (
+        "Temas a evitar",
+        "Temas que NEXO debe evitar salvo que sean directamente relevantes para tu trabajo o seguridad.",
+    ),
+    "why_shown": (
+        "Explicar por qué",
+        "Añade una frase breve explicando por qué una noticia o dato externo entra en el resumen.",
     ),
     "weather": (
         "Tiempo",
@@ -69,6 +93,48 @@ AUTOMATION_ITEM_ES = {
 }
 
 
+AUTOMATION_OPTION_ALIASES_ES = {
+    "news_interests": {
+        "automatic": ["automatico", "automático", "auto", "nexo decide", "por defecto"],
+        "business": ["empresa", "negocio", "negocios", "empresas", "economia", "economía"],
+        "technology": ["tecnologia", "tecnología", "ia", "inteligencia artificial", "software"],
+        "finance": ["finanzas", "financiero", "mercados", "bolsa"],
+        "local": ["local", "zona", "ciudad", "mallorca", "ubicacion", "ubicación"],
+        "health": ["salud", "sanidad", "medicina", "medico", "médico"],
+        "legal": ["legal", "leyes", "normativa", "justicia"],
+        "education": ["educacion", "educación", "formacion", "formación", "estudios"],
+        "real_estate": ["inmobiliario", "vivienda", "arquitectura", "urbanismo"],
+        "science": ["ciencia", "investigacion", "investigación", "innovacion", "innovación"],
+        "culture": ["cultura", "sociedad"],
+        "sports": ["deportes", "deporte"],
+    },
+    "excluded_topics": {
+        "politics": ["politica", "política", "partidos", "elecciones"],
+        "sports": ["deportes", "deporte", "futbol", "fútbol"],
+        "celebrity": ["famosos", "celebridades", "prensa rosa", "television", "televisión"],
+        "crime": ["sucesos", "crimen", "delitos"],
+        "crypto": ["cripto", "crypto", "bitcoin", "ethereum"],
+        "market_noise": ["ruido de mercado", "bolsa diaria", "mercados diarios"],
+    },
+    "length": {
+        "short": ["corto", "breve"],
+        "normal": ["normal", "medio"],
+        "detailed": ["detallado", "detalle", "mas detalle", "más detalle"],
+    },
+    "tone": {
+        "direct": ["directo"],
+        "warm": ["cercano", "calido", "cálido"],
+        "executive": ["ejecutivo", "directivo"],
+        "personal": ["personal"],
+    },
+    "format": {
+        "sections": ["secciones"],
+        "bullets": ["puntos", "lista", "bullets"],
+        "narrative": ["narrativo", "texto"],
+    },
+}
+
+
 def _fold(value: str) -> str:
     return re.sub(r"\s+", " ", str(value or "").strip().lower())
 
@@ -124,11 +190,43 @@ def _coerce_value(value: Any, entry: dict[str, Any]) -> Any:
         raw = str(value).strip().lower()
         return raw in {"1", "true", "yes", "on", "si", "sí", "activar", "enabled"}
     options = [str(option.get("value") if isinstance(option, dict) else option) for option in entry.get("options") or []]
+    aliases = entry.get("option_aliases") if isinstance(entry.get("option_aliases"), dict) else {}
+    alias_map: dict[str, str] = {}
+    for option in options:
+        alias_map[_fold(option)] = option
+        for alias in list((aliases.get(option) if isinstance(aliases.get(option), list) else []) or []):
+            alias_map[_fold(alias)] = option
+    if kind in {"multi_choice", "multi-select", "multiselect"}:
+        if isinstance(value, (list, tuple, set)):
+            raw_items = list(value)
+        else:
+            raw_items = [part.strip() for part in str(value or "").replace(";", ",").split(",")]
+        selected: list[str] = []
+        invalid: list[str] = []
+        for raw_item in raw_items:
+            text = str(raw_item or "").strip()
+            if not text:
+                continue
+            mapped = alias_map.get(_fold(text), text if text in options else "")
+            if not mapped:
+                invalid.append(text)
+                continue
+            if mapped not in selected:
+                selected.append(mapped)
+        if invalid:
+            raise ValueError(f"Invalid value '{invalid[0]}'. Valid values: {', '.join(options)}")
+        exclusive = [str(v) for v in list(entry.get("exclusive_options") or [])]
+        for exclusive_value in exclusive:
+            if exclusive_value in selected and len(selected) > 1:
+                selected = [exclusive_value]
+                break
+        return selected
     if options:
         raw = str(value).strip()
-        if raw not in options:
+        mapped = alias_map.get(_fold(raw), raw if raw in options else "")
+        if mapped not in options:
             raise ValueError(f"Invalid value '{raw}'. Valid values: {', '.join(options)}")
-        return raw
+        return mapped
     return value
 
 
@@ -192,6 +290,7 @@ def _automation_entries(*, include_values: bool, locale: str) -> list[dict[str,
                 "aliases": [
                     f"morning-agent.{item_id}",
                     f"resumen.{item_id}",
+                    f"morning.{item_id}",
                     str(item.get("label") or ""),
                     item_id.replace("_", " "),
                     label,
@@ -202,6 +301,8 @@ def _automation_entries(*, include_values: bool, locale: str) -> list[dict[str,
                 "help": help_text,
                 "type": str(item.get("type") or "text"),
                 "options": list(item.get("options") or []),
+                "exclusive_options": list(item.get("exclusive_options") or []),
+                "option_aliases": AUTOMATION_OPTION_ALIASES_ES.get(item_id, {}) if locale == "es" else {},
                 "writable": not bool(item.get("disabled")),
                 "storage": "personal_scripts.metadata.automation_preferences",
                 "path": item_id,

package/src/scripts/deep-sleep/retention.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+SRC_DIR = Path(__file__).resolve().parents[2]
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+from deep_sleep_retention import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/scripts/nexo-deep-sleep.sh

@@ -23,6 +23,14 @@ mkdir -p "$LOG_DIR" "$DEEP_SLEEP_DIR"
 
 log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_DIR/deep-sleep.log"; }
 
+run_retention() {
+    if ! python3 "$SCRIPT_DIR/deep-sleep/retention.py" --apply --quiet >> "$LOG_DIR/deep-sleep.log" 2>&1; then
+        log "Retention warning: Deep Sleep cleanup failed"
+    fi
+}
+
+run_retention
+
 # Read watermark (last processed timestamp)
 SINCE=""
 if [ -f "$WATERMARK_FILE" ]; then
@@ -46,6 +54,7 @@ if [ ! -f "$DEEP_SLEEP_DIR/$RUN_ID-context.txt" ]; then
     log "No context file generated. Skipping."
     echo "$UNTIL" > "$WATERMARK_FILE"
     log "Watermark updated to $UNTIL (no sessions to process)"
+    run_retention
     exit 0
 fi
 
@@ -58,6 +67,7 @@ if [ "$SESSIONS" -eq 0 ]; then
     log "No sessions found. Skipping."
     echo "$UNTIL" > "$WATERMARK_FILE"
     log "Watermark updated to $UNTIL (no sessions)"
+    run_retention
     exit 0
 fi
 
@@ -96,3 +106,4 @@ fi
 echo "$UNTIL" > "$WATERMARK_FILE"
 log "Watermark updated to $UNTIL"
 log "=== Deep Sleep v2 complete (run_id=$RUN_ID) ==="
+run_retention

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

@@ -38,6 +38,7 @@ import signal
 import subprocess
 import sys
 import tempfile
+import unicodedata
 import urllib.parse
 import urllib.request
 import xml.etree.ElementTree as ET
@@ -87,7 +88,42 @@ MAX_DIARY_ITEMS = 6
 MORNING_BRIEFING_STALE_HOURS = 12
 _ACTIVE_CLAIM: dict[str, str] = {}
 HTTP_TIMEOUT = 7
-DEFAULT_NEWS_RSS_URL = "https://news.google.com/rss?hl=es&gl=ES&ceid=ES:es"
+NEWS_MAX_HEADLINES = 8
+NEWS_MAX_FEEDS = 5
+NEWS_INTEREST_QUERY_ES = {
+    "business": "empresa economia negocios",
+    "technology": "tecnologia inteligencia artificial software",
+    "finance": "finanzas economia mercados",
+    "local": "actualidad local",
+    "health": "salud sanidad medicina",
+    "legal": "legal justicia normativa",
+    "education": "educacion universidad formacion",
+    "real_estate": "vivienda inmobiliario urbanismo",
+    "science": "ciencia investigacion innovacion",
+    "culture": "cultura sociedad",
+    "sports": "deportes",
+}
+NEWS_INTEREST_QUERY_EN = {
+    "business": "business economy companies",
+    "technology": "technology artificial intelligence software",
+    "finance": "finance economy markets",
+    "local": "local news",
+    "health": "health medicine healthcare",
+    "legal": "law regulation justice",
+    "education": "education university training",
+    "real_estate": "housing real estate urban planning",
+    "science": "science research innovation",
+    "culture": "culture society",
+    "sports": "sports",
+}
+NEWS_EXCLUDED_KEYWORDS = {
+    "politics": ["politica", "politics", "eleccion", "election", "partido", "congreso", "senado", "parliament"],
+    "sports": ["deporte", "sports", "futbol", "football", "liga", "tenis", "basket", "baloncesto"],
+    "celebrity": ["famos", "celebrity", "celebrit", "television", "tv", "influencer"],
+    "crime": ["crimen", "crime", "asesin", "homicid", "robo", "suceso", "detenido", "arrest"],
+    "crypto": ["crypto", "cripto", "bitcoin", "ethereum", "blockchain", "nft"],
+    "market_noise": ["bolsa", "stock", "stocks", "market", "mercado", "wall street", "ibex", "nasdaq"],
+}
 
 
 def log(message: str) -> None:
@@ -654,31 +690,177 @@ def _collect_weather(profile: dict) -> dict:
         return {"available": False, "error": str(exc)[:240]}
 
 
-def _collect_news(profile: dict) -> dict:
+def _fold_match(value: object) -> str:
+    normalized = unicodedata.normalize("NFKD", str(value or ""))
+    asciiish = "".join(ch for ch in normalized if not unicodedata.combining(ch))
+    return asciiish.casefold()
+
+
+def _preference_list(preferences: dict | None, key: str, default: list[str] | None = None) -> list[str]:
+    values = preferences if isinstance(preferences, dict) else {}
+    raw = values.get(key)
+    if isinstance(raw, (list, tuple, set)):
+        items = [str(item or "").strip() for item in raw]
+    elif raw:
+        items = [part.strip() for part in str(raw).replace(";", ",").split(",")]
+    else:
+        items = list(default or [])
+    result: list[str] = []
+    for item in items:
+        if item and item not in result:
+            result.append(item)
+    return result
+
+
+def _news_locale(profile: dict) -> tuple[str, str]:
+    language = str(profile.get("language") or "").strip().lower()
+    residence = _fold_match(profile.get("current_residence") or profile.get("location") or "")
+    if language.startswith("en"):
+        return "en", "US"
+    if any(token in residence for token in ["united states", "usa", "eeuu", "estados unidos"]):
+        return "en", "US"
+    return "es", "ES"
+
+
+def _news_feed_url(query: str, *, language: str, country: str) -> str:
+    lang = "en" if language.startswith("en") else "es"
+    params = {
+        "hl": lang,
+        "gl": country,
+        "ceid": f"{country}:{lang}",
+    }
+    clean_query = str(query or "").strip()
+    if clean_query:
+        params["q"] = clean_query
+        return f"https://news.google.com/rss/search?{urllib.parse.urlencode(params)}"
+    return f"https://news.google.com/rss?{urllib.parse.urlencode(params)}"
+
+
+def _profile_news_terms(profile: dict) -> list[str]:
+    role = _fold_match(profile.get("role") or profile.get("profession") or profile.get("job_title") or "")
+    residence = str(profile.get("current_residence") or profile.get("location") or "").strip()
+    terms: list[str] = []
+    role_queries = [
+        (["fundador", "founder", "ceo", "directivo", "manager", "business"], "empresa economia tecnologia"),
+        (["developer", "programador", "software", "technical", "tecnico", "engineer"], "tecnologia software inteligencia artificial"),
+        (["medic", "doctor", "clinica", "health", "sanidad"], "salud sanidad medicina"),
+        (["arquitect", "architecture", "inmobili", "real estate"], "vivienda urbanismo arquitectura"),
+        (["abog", "law", "legal"], "legal normativa justicia"),
+        (["educ", "profesor", "student", "estudiante"], "educacion formacion universidad"),
+        (["ventas", "sales", "commercial", "comercial"], "ventas clientes empresa"),
+        (["administr", "admin", "office"], "empresa laboral administracion"),
+    ]
+    for needles, query in role_queries:
+        if any(needle in role for needle in needles):
+            terms.append(query)
+            break
+    if residence:
+        terms.append(f"{residence} actualidad")
+    return terms
+
+
+def _news_queries(profile: dict, preferences: dict | None) -> tuple[list[dict[str, str]], list[str], list[str]]:
+    language, country = _news_locale(profile)
+    interests = _preference_list(preferences, "news_interests", ["automatic"])
+    excluded = _preference_list(preferences, "excluded_topics", [])
+    automatic = not interests or "automatic" in interests
+    query_map = NEWS_INTEREST_QUERY_EN if language.startswith("en") else NEWS_INTEREST_QUERY_ES
+    queries: list[dict[str, str]] = []
+
+    if automatic:
+        for term in _profile_news_terms(profile):
+            queries.append({"interest": "automatic", "query": term})
+        fallback = "business technology economy" if language.startswith("en") else "empresa tecnologia economia"
+        queries.append({"interest": "automatic", "query": fallback})
+
+    for interest in interests:
+        if interest == "automatic":
+            continue
+        query = query_map.get(interest)
+        if not query:
+            continue
+        if interest == "local":
+            residence = str(profile.get("current_residence") or profile.get("location") or "").strip()
+            if residence:
+                query = f"{residence} actualidad"
+        queries.append({"interest": interest, "query": query})
+
+    if not queries:
+        queries.append({"interest": "automatic", "query": ""})
+
+    deduped: list[dict[str, str]] = []
+    seen: set[str] = set()
+    for query in queries:
+        key = _fold_match(query.get("query") or "") or "top"
+        if key in seen:
+            continue
+        seen.add(key)
+        deduped.append(query)
+        if len(deduped) >= NEWS_MAX_FEEDS:
+            break
+    return deduped, interests or ["automatic"], excluded
+
+
+def _headline_is_excluded(title: str, excluded_topics: list[str]) -> bool:
+    folded = _fold_match(title)
+    for topic in excluded_topics:
+        for keyword in NEWS_EXCLUDED_KEYWORDS.get(topic, []):
+            if _fold_match(keyword) in folded:
+                return True
+    return False
+
+
+def _parse_news_feed(xml_text: str, *, interest: str, excluded_topics: list[str]) -> list[dict]:
+    root = ET.fromstring(xml_text)
+    items: list[dict] = []
+    for item in root.findall(".//item"):
+        title = _clean_text(item.findtext("title"), limit=220)
+        if not title or _headline_is_excluded(title, excluded_topics):
+            continue
+        link = str(item.findtext("link") or "").strip()
+        source = _clean_text(item.findtext("source"), limit=80)
+        published = _clean_text(item.findtext("pubDate"), limit=120)
+        items.append({
+            "title": title,
+            "source": source,
+            "published": published,
+            "url": link[:500],
+            "interest": interest,
+        })
+    return items
+
+
+def _collect_news(profile: dict, preferences: dict | None = None) -> dict:
     try:
-        rss_url = str(profile.get("news_rss_url") or os.environ.get("NEXO_NEWS_RSS_URL") or DEFAULT_NEWS_RSS_URL).strip()
-        if not rss_url:
-            return {"available": False, "error": "no_news_source"}
-        xml_text = _fetch_text_url(rss_url)
-        root = ET.fromstring(xml_text)
+        language, country = _news_locale(profile)
+        queries, interests, excluded = _news_queries(profile, preferences)
         items: list[dict] = []
-        for item in root.findall(".//item"):
-            title = _clean_text(item.findtext("title"), limit=220)
-            link = str(item.findtext("link") or "").strip()
-            source = _clean_text(item.findtext("source"), limit=80)
-            published = _clean_text(item.findtext("pubDate"), limit=120)
-            if title:
-                items.append({
-                    "title": title,
-                    "source": source,
-                    "published": published,
-                    "url": link[:500],
-                })
-            if len(items) >= 6:
+        seen_titles: set[str] = set()
+        used_queries: list[str] = []
+        for query in queries:
+            feed_url = _news_feed_url(query.get("query") or "", language=language, country=country)
+            xml_text = _fetch_text_url(feed_url)
+            used_queries.append(query.get("query") or "top headlines")
+            for headline in _parse_news_feed(xml_text, interest=query.get("interest") or "automatic", excluded_topics=excluded):
+                key = _fold_match(headline.get("title") or "")
+                if not key or key in seen_titles:
+                    continue
+                seen_titles.add(key)
+                items.append(headline)
+                if len(items) >= NEWS_MAX_HEADLINES:
+                    break
+            if len(items) >= NEWS_MAX_HEADLINES:
                 break
         return {
             "available": bool(items),
-            "source": rss_url,
+            "source": "google-news-rss",
+            "mode": "relevant_public_context",
+            "language": language,
+            "country": country,
+            "interests": interests,
+            "excluded_topics": excluded,
+            "queries": used_queries,
+            "selection_rule": "Headlines are only useful if they relate to the operator's work, location, explicit interests or broad high-impact context.",
             "headlines": items,
             "error": "" if items else "empty_feed",
         }
@@ -692,7 +874,7 @@ def _collect_external_context(profile: dict, preferences: dict | None) -> dict:
     if values.get("weather"):
         external["weather"] = _collect_weather(profile)
     if values.get("news"):
-        external["news"] = _collect_news(profile)
+        external["news"] = _collect_news(profile, values)
     return external
 
 

package/src/scripts/nexo-sleep.py

@@ -41,6 +41,7 @@ if str(NEXO_CODE) not in sys.path:
 from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 from constants import AUTOMATION_SUBPROCESS_TIMEOUT
 from core_prompts import render_core_prompt
+from deep_sleep_retention import prune_deep_sleep_runtime
 import paths
 try:
     from client_preferences import resolve_user_model as _resolve_user_model
@@ -261,6 +262,9 @@ def stage_a_cleanup() -> dict:
         "a5_heartbeat_trimmed": False,
         "a6_reflection_trimmed": False,
         "a7_daemon_logs_deleted": 0,
+        "a9_deep_sleep_deleted": 0,
+        "a9_deep_sleep_freed_bytes": 0,
+        "a9_deep_sleep_logs_rotated": 0,
     }
 
     # A1: Delete daily_summaries/*.md >90 days
@@ -366,6 +370,16 @@ def stage_a_cleanup() -> dict:
                 except Exception:
                     pass
 
+    # A9: Bound Deep Sleep operational artifacts and logs. This is safe to run
+    # daily: incomplete/unanalysed contexts are preserved for retry/debugging.
+    try:
+        deep_sleep_retention = prune_deep_sleep_runtime(nexo_home=NEXO_HOME, apply=True)
+        stats["a9_deep_sleep_deleted"] = int(deep_sleep_retention.get("deleted_count") or 0)
+        stats["a9_deep_sleep_freed_bytes"] = int(deep_sleep_retention.get("deleted_bytes") or 0)
+        stats["a9_deep_sleep_logs_rotated"] = int(deep_sleep_retention.get("logs_rotated") or 0)
+    except Exception as exc:
+        stats["a9_deep_sleep_warning"] = exc.__class__.__name__
+
     return stats
 
 

package/templates/core-prompts/morning-agent.md

@@ -9,7 +9,9 @@ Product intent:
 - Think like a professional personal assistant or chief of staff: filter noise, rank priorities, connect related items, and make the day feel prepared.
 - Adapt the emphasis to the operator's real context: administrative work needs tasks, deadlines, email movement and missing inputs; executives need decisions, risks, money, people and blocked outcomes; technical users need incidents, deployments, regressions and dependencies; commercial users need leads, customers and follow-ups; regulated or clinical users need careful wording, pending actions and factual status only.
 - Do not ask the operator to choose a user type. Infer the useful angle from the structured context, profile fields, recent activity and explicit preferences. If the context is thin, stay general and practical.
-- Include news and weather only when verified collected data exists in the context. Never fabricate public news, forecasts, calendar events, emails or professional advice.
+- Include news and weather only when verified collected data exists in the context. Public headlines are not a generic news block: include them only when they relate to the operator's work, location, declared interests, or broad high-impact context worth knowing before starting the day.
+- When external context is included, make it useful in one sentence. Do not mention RSS feeds, internal URLs, settings schemas, or source plumbing.
+- If the structured preferences include automatic relevance, actively omit low-value items even when a source is enabled.
 
 Hard rules:
 - Do not invent achievements, blockers, meetings, messages, or external events.
@@ -20,6 +22,14 @@ Hard rules:
 - Mention operator decisions only when the context actually supports them.
 - Keep the email concise unless structured preferences ask for more detail: roughly 180-350 words.
 - Use short sections and bullets when useful.
+
+Recommended structure:
+- Opening: one short sentence with the state of the day.
+- Top priorities: the 1-3 things most worth attention.
+- Changes and commitments: only what moved, is due, or affects today's choices.
+- Risks or blockers: only if there is something to prevent, unblock, or decide.
+- Day context: weather and relevant public context only when verified and useful.
+- Next actions: practical first steps when the context supports them.
 [[extra_section]]Return ONLY a valid JSON object with this exact shape:
 {
   "subject": "string",