nexo-brain 7.30.4 → 7.30.5

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.4",
+  "version": "7.30.5",
   "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.5` is the current packaged-runtime line. Patch release over v7.30.4 - the morning briefing is now Morning preparation, with automatic relevance, changes since yesterday, next actions, relevant public context, and chat-addressable preference settings for non-technical users.
+
+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.5",
   "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/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/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/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/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",