nexo-brain 7.31.4 → 7.31.7

package/src/provider_circuit_breaker.py

@@ -190,6 +190,9 @@ def record_session_outcome(
             "consecutive_failures": 0,
             "closed_at": _now(),
             "recovered_from": entry.get("reason") if was_open else None,
+            # The pause email promises "another notice when work resumes":
+            # arm that notice only when the OPENING was actually notified.
+            "resume_notice_pending": bool(was_open and entry.get("operator_notified_at")),
         }
         _save_state(state)
         return state[backend]
@@ -213,6 +216,21 @@ def record_session_outcome(
     return entry
 
 
+def should_notify_operator_resumed(backend: str) -> bool:
+    """True exactly once after a notified opening closes (engine resumed).
+
+    The pause notice tells the operator "you will get another notice when
+    work resumes" — this is that notice's gate. Clears the flag on read.
+    """
+    state = _load_state()
+    entry = _entry(state, backend)
+    if entry.get("state") == "closed" and entry.get("resume_notice_pending"):
+        entry["resume_notice_pending"] = False
+        _save_state(state)
+        return True
+    return False
+
+
 def should_notify_operator(backend: str) -> bool:
     """True exactly once per opening — callers use it to send ONE notice."""
     state = _load_state()

package/src/rules/core-rules.json

@@ -1,11 +1,11 @@
 {
   "_meta": {
-    "version": "1.1.0",
+    "version": "1.2.0",
     "description": "NEXO Brain Core System Rules — battle-tested behavioral rules that ship with every installation",
     "created": "2026-03-26",
     "source": "Consolidated from production use, managed bootstrap CORE files, ticket/conversation analysis and product-core review",
-    "total_rules": 70,
-    "blocking": 65,
+    "total_rules": 71,
+    "blocking": 66,
     "advisory": 5,
     "immutable": true,
     "immutable_note": "Core rules are the DNA of NEXO Brain. They CANNOT be deleted or modified by the user. Only the migration system (version updates from the creators) can add, modify, or remove rules. Users can configure behavioral intensity (autonomy, communication, proactivity) but not the rules themselves."
@@ -630,6 +630,14 @@
           "importance": 5,
           "type": "blocking",
           "added_in": "1.1.0"
+        },
+        {
+          "id": "PC33",
+          "rule": "Stateful answers need evidence before wording",
+          "why": "Before answering about releases, commits, branches, tags, tickets, servers, ports, DNS, deployments, sent messages, uploads, installs, or verified/closed status, NEXO must consult live/continuity evidence or explicitly state the gap instead of relying on recollection.",
+          "importance": 5,
+          "type": "blocking",
+          "added_in": "1.2.0"
         }
       ]
     }

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

@@ -325,6 +325,19 @@ def collect_learnings() -> list[dict]:
     return safe_query(NEXO_DB, "SELECT * FROM learnings ORDER BY updated_at DESC LIMIT 200")
 
 
+def collect_all_active_learnings(db_path: Path | str = NEXO_DB) -> list[dict]:
+    """Full active learning list for Deep Sleep file-backed analysis."""
+    status_filter = ""
+    if "status" in _table_columns(Path(db_path), "learnings"):
+        status_filter = "WHERE COALESCE(status, 'active') NOT IN ('superseded', 'deleted', 'archived')"
+    return safe_query(
+        Path(db_path),
+        "SELECT * FROM learnings "
+        f"{status_filter} "
+        "ORDER BY COALESCE(updated_at, created_at) DESC, id DESC"
+    )
+
+
 def collect_diaries(target_date: str) -> list[dict]:
     """Today's session diaries."""
     # Diaries store created_at as unix timestamp or ISO string -- handle both
@@ -959,6 +972,9 @@ def main():
     learnings = collect_learnings()
     print(f"  Learnings: {len(learnings)}")
 
+    all_active_learnings = collect_all_active_learnings()
+    print(f"  Active learnings dump: {len(all_active_learnings)}")
+
     diaries = collect_diaries(target_date)
     print(f"  Diaries today: {len(diaries)}")
 
@@ -997,6 +1013,12 @@ def main():
     ]
     shared_parts.append(format_section("ACTIVE FOLLOWUPS", followups))
     shared_parts.append(format_section("LEARNINGS (recent 200)", learnings))
+    shared_parts.append(
+        "\n## FULL ACTIVE LEARNINGS DUMP\n"
+        f"- File: learnings-dump.json\n"
+        f"- Count: {len(all_active_learnings)}\n"
+        "- Use this file for complete learning coverage; do not call nexo_learning_list from inside Deep Sleep analysis.\n"
+    )
     shared_parts.append(format_section("SESSION DIARIES TODAY", diaries))
     shared_parts.append(format_section("TRUST SCORE HISTORY (7d)", trust_history))
     shared_parts.append(format_section("DISCOVERED NON-CORE CONTENT", extras))
@@ -1012,6 +1034,22 @@ def main():
     long_horizon_file.write_text(json.dumps(long_horizon, indent=2, ensure_ascii=False), encoding="utf-8")
     print(f"  Long horizon JSON: {long_horizon_file.name}")
 
+    learnings_dump_file = date_dir / "learnings-dump.json"
+    learnings_dump_file.write_text(
+        json.dumps(
+            {
+                "generated_at": datetime.now().isoformat(),
+                "source_db": str(NEXO_DB),
+                "active_learning_count": len(all_active_learnings),
+                "learnings": all_active_learnings,
+            },
+            indent=2,
+            ensure_ascii=False,
+        ),
+        encoding="utf-8",
+    )
+    print(f"  Full learnings JSON: {learnings_dump_file.name} ({len(all_active_learnings)} active)")
+
     # Individual session files
     session_files_written = []
     session_txt_map = {}
@@ -1091,11 +1129,13 @@ def main():
         "total_tool_uses": sum(s["tool_use_count"] for s in sessions),
         "followups_active": len(followups),
         "learnings_count": len(learnings),
+        "active_learnings_count": len(all_active_learnings),
         "diaries_today": len(diaries),
         "error_log_files": len(error_logs),
         "date_dir": str(date_dir),
         "shared_context_file": str(shared_file),
         "long_horizon_file": str(long_horizon_file),
+        "learnings_dump_file": str(learnings_dump_file),
         "context_file": str(legacy_file),
         "total_size_bytes": total_size,
     }

package/src/scripts/jargon_first_response.py

@@ -9,7 +9,8 @@ Token list (case-insensitive substring match), taken verbatim from the
 followup spec:
 
     Learning #, protocol debt, cortex eval, runtime-core, guard_check,
-    heartbeat, pre-emptive guard, enforcer, task_open, task_close, NF-
+    heartbeat, pre-emptive guard, enforcer, task_open, task_close, NF-,
+    Subscription inactive, WSL, scorer, match, cortex
 
 Use as:
 
@@ -53,6 +54,11 @@ PROHIBITED_TOKENS: Sequence[str] = (
     "task_close",
     "heartbeat",
     "NF-",
+    "Subscription inactive",
+    "WSL",
+    "scorer",
+    "match",
+    "cortex",
 )
 
 # Heuristic signals from the *user* message that mean "operator asked for
@@ -103,15 +109,13 @@ def scan_text(text: str, *, tokens: Iterable[str] = PROHIBITED_TOKENS) -> List[d
     target = _first_visible_paragraph(text)
     if not target:
         return []
-    lowered = target.lower()
     found: List[dict] = []
     for token in tokens:
-        needle = token.lower()
-        start = 0
-        while True:
-            idx = lowered.find(needle, start)
-            if idx < 0:
-                break
+        pattern = re.escape(token)
+        if token.isalpha() and len(token) <= 6:
+            pattern = rf"\b{pattern}\b"
+        for match in re.finditer(pattern, target, re.IGNORECASE):
+            idx = match.start()
             snippet_start = max(0, idx - 25)
             snippet_end = min(len(target), idx + len(token) + 25)
             found.append({
@@ -119,7 +123,6 @@ def scan_text(text: str, *, tokens: Iterable[str] = PROHIBITED_TOKENS) -> List[d
                 "index": idx,
                 "snippet": target[snippet_start:snippet_end].replace("\n", " "),
             })
-            start = idx + max(1, len(needle))
     found.sort(key=lambda row: row["index"])
     return found
 

package/src/scripts/nexo-email-monitor.py

@@ -90,12 +90,83 @@ CONCURRENT_THRESHOLD_MINUTES = 15
 MAX_CONCURRENT_SESSIONS = 2
 MAX_EMAIL_ATTEMPTS = 3
 DEFAULT_OPERATOR_LANGUAGE = "en"
+SUPPORTED_NOTIFICATION_LANGUAGES = {"en", "es"}
 EMPTY_INBOX_BACKOFF_STEPS = (
     (12, 60 * 60),
     (6, 30 * 60),
     (3, 15 * 60),
 )
 DEFAULT_ASSISTANT_NAME = "Nova"
+HEADLESS_NOTIFICATION_TEMPLATES = {
+    "email_needs_interactive": {
+        "es": {
+            "subject": "[{assistant_name}] Emails que necesitan tu atención ({count})",
+            "body": (
+                "Hola {user_name},\n\n"
+                "Los siguientes emails ya se han intentado {max_attempts} veces sin poder completarse:\n\n"
+                "{details}\n\n"
+                "Los he marcado como `needs_interactive`.\n"
+                "Abre {assistant_name} Desktop y pregunta por el email afectado para resolverlo manualmente.\n\n"
+                "— {assistant_name}"
+            ),
+        },
+        "en": {
+            "subject": "[{assistant_name}] Emails requiring your attention ({count})",
+            "body": (
+                "Hello {user_name},\n\n"
+                "The following emails have already been attempted {max_attempts} times without completing:\n\n"
+                "{details}\n\n"
+                "I marked them as `needs_interactive`.\n"
+                "Open {assistant_name} Desktop and ask about the affected email so it can be resolved manually.\n\n"
+                "— {assistant_name}"
+            ),
+        },
+    },
+    "provider_breaker_open": {
+        "es": {
+            "subject": "[{assistant_name}] Motor {backend} en pausa ({reason})",
+            "body": (
+                "Hola {user_name},\n\n"
+                "He pausado las automatizaciones que usan {backend} porque no está disponible: {reason}.\n\n"
+                "El trabajo pendiente queda EN COLA; no se pierde nada.\n"
+                "Se reanudará automáticamente cuando el motor vuelva a estar disponible{retry_hint}.\n\n"
+                "No recibirás un aviso por cada tarea: solo este aviso y otro cuando el trabajo se reanude.\n\n"
+                "— {assistant_name}"
+            ),
+        },
+        "en": {
+            "subject": "[{assistant_name}] Engine {backend} paused ({reason})",
+            "body": (
+                "Hello {user_name},\n\n"
+                "I paused the automations that use {backend} because it is unavailable: {reason}.\n\n"
+                "Pending work stays QUEUED; nothing is lost.\n"
+                "It will resume automatically when the engine becomes available again{retry_hint}.\n\n"
+                "You will not get one notice per task: only this notice and another one when work resumes.\n\n"
+                "— {assistant_name}"
+            ),
+        },
+    },
+    "provider_breaker_resumed": {
+        "es": {
+            "subject": "[{assistant_name}] Motor {backend} reanudado",
+            "body": (
+                "Hola {user_name},\n\n"
+                "El motor {backend} vuelve a estar disponible y he reanudado las automatizaciones.\n\n"
+                "La cola pendiente se está procesando ya, en orden. No tienes que hacer nada.\n\n"
+                "— {assistant_name}"
+            ),
+        },
+        "en": {
+            "subject": "[{assistant_name}] Engine {backend} resumed",
+            "body": (
+                "Hello {user_name},\n\n"
+                "The {backend} engine is available again and I have resumed the automations.\n\n"
+                "The pending queue is being processed now, in order. Nothing is needed from you.\n\n"
+                "— {assistant_name}"
+            ),
+        },
+    },
+}
 EVENT_TABLE_SQL = """
 CREATE TABLE IF NOT EXISTS email_events (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -1990,6 +2061,104 @@ def _uses_spanish(language: str) -> bool:
     return normalized == "es" or normalized.startswith("es-")
 
 
+def _normalize_notification_language(value: str | None = "") -> str:
+    normalized = str(value or "").strip().lower().replace("_", "-")
+    if normalized == "es" or normalized.startswith("es-"):
+        return "es"
+    if normalized == "en" or normalized.startswith("en-"):
+        return "en"
+    return ""
+
+
+def _desktop_settings_candidates() -> list[Path]:
+    home = Path.home()
+    candidates: list[Path] = []
+    explicit_settings = os.environ.get("NEXO_DESKTOP_SETTINGS", "").strip()
+    if explicit_settings:
+        candidates.append(Path(explicit_settings))
+    explicit_user_data = os.environ.get("NEXO_DESKTOP_USER_DATA", "").strip()
+    if explicit_user_data:
+        candidates.append(Path(explicit_user_data) / "app-settings.json")
+    candidates.extend([
+        home / "Library" / "Application Support" / "nexo-desktop-mvp" / "app-settings.json",
+        home / "Library" / "Application Support" / "NEXO Desktop" / "app-settings.json",
+        home / "Library" / "Application Support" / "nexo-desktop" / "app-settings.json",
+    ])
+    return candidates
+
+
+def _read_json_file(path: Path) -> dict:
+    try:
+        if path.is_file():
+            payload = json.loads(path.read_text(encoding="utf-8"))
+            if isinstance(payload, dict):
+                return payload
+    except Exception:
+        return {}
+    return {}
+
+
+def get_desktop_ui_language(settings_payload: dict | None = None) -> str:
+    """Return the Desktop UI language for deterministic non-LLM notices."""
+    payloads: list[dict] = []
+    if isinstance(settings_payload, dict):
+        payloads.append(settings_payload)
+    else:
+        payloads.extend(_read_json_file(candidate) for candidate in _desktop_settings_candidates())
+
+    for payload in payloads:
+        app = payload.get("app") if isinstance(payload.get("app"), dict) else {}
+        for candidate in (app.get("ui_language"), payload.get("ui_language")):
+            lang = _normalize_notification_language(str(candidate or ""))
+            if lang:
+                return lang
+    return ""
+
+
+def resolve_notification_language(
+    operator_language: str | None = "",
+    *,
+    settings_payload: dict | None = None,
+) -> str:
+    """Resolve static notification language: Desktop UI first, profile fallback, EN final."""
+    return (
+        get_desktop_ui_language(settings_payload=settings_payload)
+        or _normalize_notification_language(operator_language)
+        or DEFAULT_OPERATOR_LANGUAGE
+    )
+
+
+def render_headless_notification_template(
+    template_id: str,
+    lang: str,
+    variables: dict,
+) -> tuple[str, str]:
+    normalized = _normalize_notification_language(lang) or DEFAULT_OPERATOR_LANGUAGE
+    template_group = HEADLESS_NOTIFICATION_TEMPLATES.get(template_id)
+    if not template_group:
+        raise KeyError(f"unknown headless notification template: {template_id}")
+    template = template_group.get(normalized) or template_group[DEFAULT_OPERATOR_LANGUAGE]
+    values = {key: "" if value is None else value for key, value in dict(variables or {}).items()}
+    return template["subject"].format(**values), template["body"].format(**values)
+
+
+def _provider_reason(reason: str, lang: str) -> str:
+    normalized = _normalize_notification_language(lang) or DEFAULT_OPERATOR_LANGUAGE
+    reasons = {
+        "es": {
+            "credits": "créditos agotados",
+            "rate_limit": "límite de uso alcanzado",
+            "auth": "sesión caducada (hay que volver a conectar)",
+        },
+        "en": {
+            "credits": "credits exhausted",
+            "rate_limit": "rate limit reached",
+            "auth": "session expired (needs re-login)",
+        },
+    }
+    return reasons.get(normalized, reasons["en"]).get(reason, reason)
+
+
 def _localized_operator_escalation_email(
     *,
     operator_name: str,
@@ -1998,33 +2167,18 @@ def _localized_operator_escalation_email(
     exhausted_count: int,
     details: str,
 ) -> tuple[str, str]:
-    # Phase 1.6 — subjects are signed by the AGENT (assistant_name, dynamic
-    # per install), not by the product: the operator talks to their agent.
-    if _uses_spanish(operator_language):
-        # Phase 1.6 — this branch used to contain the ENGLISH text copied
-        # verbatim (operator-reported 10-jun: escalation mails arrived in
-        # English with language=es configured). Real Spanish now.
-        subject = f"[{assistant_name}] Emails que necesitan tu atención ({exhausted_count})"
-        body = (
-            f"Hola {operator_name},\n\n"
-            f"Los siguientes emails ya se han intentado {MAX_EMAIL_ATTEMPTS} veces "
-            f"sin conseguirlo (la sesión muere antes de terminar):\n\n{details}\n\n"
-            "Los he marcado como `needs_interactive`. "
-            f"Abre {assistant_name} Desktop y pregunta por el email afectado para resolverlo manualmente.\n\n"
-            f"— {assistant_name}"
-        )
-        return subject, body
-
-    subject = f"[{assistant_name}] Emails requiring manual attention ({exhausted_count})"
-    body = (
-        f"Hello {operator_name},\n\n"
-        f"The following emails have already been attempted {MAX_EMAIL_ATTEMPTS} times "
-        f"without succeeding (the session dies before completion):\n\n{details}\n\n"
-        f"I marked them as `needs_interactive`. "
-        f"Open {assistant_name} Desktop and ask about the affected email so it can be resolved manually.\n\n"
-        f"— {assistant_name}"
+    lang = resolve_notification_language(operator_language)
+    return render_headless_notification_template(
+        "email_needs_interactive",
+        lang,
+        {
+            "assistant_name": assistant_name,
+            "user_name": operator_name,
+            "count": exhausted_count,
+            "max_attempts": MAX_EMAIL_ATTEMPTS,
+            "details": details,
+        },
     )
-    return subject, body
 
 
 def _operator_aliases(config) -> list[str]:
@@ -2443,6 +2597,45 @@ def _decrement_attempts(email_ids):
         log.warning(f"Failed to decrement attempts: {e}")
 
 
+def _notify_provider_breaker_resumed_once():
+    """Send the resume notice the pause email promises — once per recovery."""
+    try:
+        from provider_circuit_breaker import should_notify_operator_resumed
+        for backend in ("claude_code", "codex"):
+            if not should_notify_operator_resumed(backend):
+                continue
+            operator_name, assistant_name, operator_language = _get_operator_info()
+            config = load_config()
+            operator_email = config.get("operator_email", "") if config else ""
+            if not operator_email:
+                return
+            subject, body = render_headless_notification_template(
+                "provider_breaker_resumed",
+                resolve_notification_language(operator_language),
+                {
+                    "assistant_name": assistant_name,
+                    "user_name": operator_name,
+                    "backend": backend,
+                },
+            )
+            body_file = BASE_DIR / ".breaker-resume-body.txt"
+            body_file.write_text(body, encoding="utf-8")
+            send_script = get_send_reply_script_path(local_script_dir=_script_dir)
+            subprocess.run(
+                [
+                    sys.executable, str(send_script),
+                    "--to", f"{operator_name} <{operator_email}>",
+                    "--subject", subject,
+                    "--body-file", str(body_file),
+                ],
+                timeout=30,
+                capture_output=True,
+            )
+            log.info(f"Breaker resume notice sent for {backend}")
+    except Exception as e:
+        log.warning(f"Breaker resume notice failed: {e}")
+
+
 def _notify_provider_breaker_open_once(error):
     """Fase 1.6 — ONE operator notice per breaker opening, in their language.
 
@@ -2464,36 +2657,21 @@ def _notify_provider_breaker_open_once(error):
         retry_hint = ""
         if error.retry_after_ts:
             retry_hint = datetime.fromtimestamp(error.retry_after_ts).strftime("%H:%M")
-        reason_es = {
-            "credits": "créditos agotados",
-            "rate_limit": "límite de uso alcanzado",
-            "auth": "sesión caducada (hay que volver a conectar)",
-        }.get(error.reason, error.reason)
-        reason_en = {
-            "credits": "credits exhausted",
-            "rate_limit": "rate limit reached",
-            "auth": "session expired (needs re-login)",
-        }.get(error.reason, error.reason)
-        if _uses_spanish(operator_language):
-            subject = f"[{assistant_name}] Motor {error.backend} en pausa ({reason_es})"
-            body = (
-                f"Hola {operator_name},\n\n"
-                f"He pausado las automatizaciones que usan {error.backend} porque está no disponible: {reason_es}.\n\n"
-                "El trabajo pendiente queda EN COLA (no se pierde nada) y se reanudará solo en cuanto el motor vuelva"
-                + (f" (próxima comprobación ~{retry_hint})" if retry_hint else "")
-                + ".\n\nNo recibirás un aviso por cada tarea: solo este, y otro cuando se reanude.\n\n"
-                f"— {assistant_name}"
-            )
-        else:
-            subject = f"[{assistant_name}] Engine {error.backend} paused ({reason_en})"
-            body = (
-                f"Hello {operator_name},\n\n"
-                f"I paused the automations that use {error.backend} because it is unavailable: {reason_en}.\n\n"
-                "Pending work stays QUEUED (nothing is lost) and resumes automatically once the engine is back"
-                + (f" (next probe ~{retry_hint})" if retry_hint else "")
-                + ".\n\nYou will not get one notice per task — just this one, and another when work resumes.\n\n"
-                f"— {assistant_name}"
-            )
+        lang = resolve_notification_language(operator_language)
+        retry_label = ""
+        if retry_hint:
+            retry_label = f" (próxima comprobación ~{retry_hint})" if lang == "es" else f" (next probe ~{retry_hint})"
+        subject, body = render_headless_notification_template(
+            "provider_breaker_open",
+            lang,
+            {
+                "assistant_name": assistant_name,
+                "user_name": operator_name,
+                "backend": error.backend,
+                "reason": _provider_reason(error.reason, lang),
+                "retry_hint": retry_label,
+            },
+        )
         body_file = BASE_DIR / ".breaker-notice-body.txt"
         body_file.write_text(body, encoding="utf-8")
         send_script = get_send_reply_script_path(local_script_dir=_script_dir)
@@ -2675,6 +2853,7 @@ def main():
         backoff_state = load_empty_inbox_backoff_state()
         debt_block = scan_debt()
 
+        _notify_provider_breaker_resumed_once()
         reconcile_orphaned_seen(config, hours=24)
         reconcile_terminal_unseen(config, hours=48)
         # Recovery window widened from 24h to 7 days (168h): a single email can

package/templates/CLAUDE.md.template

@@ -37,6 +37,7 @@ The full protected registry lives in NEXO Brain `core_rules`. Keep this compact
 - Do not ask the user to do work that NEXO can safely do with available tools.
 - Prepare up to the safe boundary; ask only for real decisions, missing credentials, approvals, payments, destructive actions, or legally required consent.
 - Verify current reality before claiming facts about external state, product capabilities, dates, versions, servers, routes, ports, schemas, or tickets.
+- Before answering about releases, commits, branches, tags, tickets, servers, ports, DNS, deployments, sent messages, uploads, installs, or verified/closed status, consult live/continuity evidence or explicitly state that the state is not verified yet.
 - Do not invent or deny NEXO capabilities without checking the live product/source of truth first.
 - Preserve one continuous user-facing identity across supported clients and sessions.
 - Treat Brain, calibration, profile, decisions, learnings, diary, and followups as stronger authority than legacy client memory files.

package/templates/CODEX.AGENTS.md.template

@@ -32,6 +32,7 @@ The full protected registry lives in NEXO Brain `core_rules`. Keep this compact
 - Do not ask the user to do work that NEXO can safely do with available tools.
 - Prepare up to the safe boundary; ask only for real decisions, missing credentials, approvals, payments, destructive actions, or legally required consent.
 - Verify current reality before claiming facts about external state, product capabilities, dates, versions, servers, routes, ports, schemas, or tickets.
+- Before answering about releases, commits, branches, tags, tickets, servers, ports, DNS, deployments, sent messages, uploads, installs, or verified/closed status, consult live/continuity evidence or explicitly state that the state is not verified yet.
 - Do not invent or deny NEXO capabilities without checking the live product/source of truth first.
 - Preserve one continuous user-facing identity across supported clients and sessions.
 - Treat Brain, calibration, profile, decisions, learnings, diary, and followups as stronger authority than legacy client memory files.

package/templates/core-prompts/r26-jargon-rewrite.md

@@ -0,0 +1 @@
+Reescribe antes de responder: la primera respuesta o el resumen de cierre usa terminos internos sin traducir. Empieza por la conclusion en lenguaje normal y, si necesitas mencionar un termino tecnico, explicalo en la misma frase.

package/templates/core-prompts/r34-capability-reality-check.md

@@ -0,0 +1 @@
+Antes de negar una capacidad o declarar un bloqueo, verifica la realidad viva: catálogo/sistema, recetas o skills previos, scripts existentes, producto activo, BD o fuente oficial. Si no has hecho esa comprobación en este turno, no afirmes que no se puede/no existe; ejecuta la comprobación primero o formula el estado como no verificado.

package/templates/core-prompts/r35-execute-before-ask.md

@@ -0,0 +1 @@
+La ultima orden del operador fue imperativa y la accion parece reversible. Ejecuta el siguiente paso seguro con las herramientas disponibles y deja alternativas o dudas no bloqueantes para el final. Pregunta solo si falta una credencial, hay pago, accion destructiva o ambiguedad real.

package/templates/core-prompts/r36-production-change-log-required.md

@@ -0,0 +1 @@
+Has ejecutado una mutacion de produccion. Antes de cerrar la tarea, registra el cambio con `nexo_change_log(...)` o cierra con `nexo_task_close(...)` incluyendo archivos/artefacto, motivo, riesgo y verificacion real.

package/templates/core-prompts/server-mcp-instructions.md

@@ -29,7 +29,7 @@
 - **Dissonance:** user contradicts memory→`nexo_cognitive_dissonance`. Frustrated→force=True
 - **Trust:** <40=paranoid verify twice, >80=fluid. Check: `nexo_cognitive_trust`
 
-## Guardian Rules (Phase 2 Layer 3 — R26–R33)
+## Guardian Rules (Phase 2 Layer 3 — R26–R37)
 - **R26 no jargon:** Never use NEXO internal jargon (protocol debt, cortex evaluation, guard_check, heartbeat, runtime check, shadow/soft/hard) when talking to the user. Translate to plain operational language. First answer to the operator on any thread leads with the recommendation or status, not the diagnostic.
 - **R26b silent enforcement:** Never tell the user that Guardian / Protocol Enforcer / a system reminder forced you to do something. Apply the required action silently. When a reminder says "Do not produce visible text", that silence applies to the entire reminder turn: no prose before the tool call, no prose after it, and if there is no fresh operator message then the visible output must stay empty.
 - **R27 2–3 sentences:** Keep each decision point to 2–3 short sentences. Details only if asked. Prefer conclusion + next action over option dumps or raw diagnostics.
@@ -40,3 +40,4 @@
 - **R32 Nora/María read-only:** Their infrastructure is observed, never written. Only act on Nora/María resources with explicit permission in the current user message. See learnings #283, #336, #358; the Layer 2 engine enforces this with R25.
 - **R33 procedure lookup:** To discover available tools, reusable skills, or the canonical location of an artifact, use `nexo_system_catalog` / `nexo_tool_explain` / `nexo_skill_match` — do not assume tool names from memory. If a skill already covers the flow, use it instead of improvising.
 - **R34 identity coherence:** NEXO is a single identity shared across terminals. When there are 2+ active sessions, THEY ARE ALL YOU. Before denying an action ("I haven't done that" / "I didn't do that" / "I didn't"), first consult `nexo_recent_context` / `nexo_session_diary_read` / `nexo_change_log`. Another terminal may have acted. Anti-example: saying "I did not send that email" without checking `nexo_change_log` when a sibling session already sent it.
+- **R37 pre-answer evidence:** Before answering about releases, commits, branches, tags, tickets, servers, ports, DNS, deployments, sent messages, uploads, installs, verified/closed status, or prior external actions, consult live/continuity evidence first. If evidence is unavailable in the turn, say the state is not verified yet and keep checking instead of guessing from memory.

package/tool-enforcement-map.json

@@ -2244,7 +2244,7 @@
       "triggers_after": []
     },
     "nexo_guardian_rule_override": {
-      "description": "Temporarily override a Guardian rule's mode (off/shadow/soft/hard) with TTL (1h/24h/session). Core rules (R13/R14/R16/R25/R30) cannot be set to off. Writes to ~/.nexo/config/guardian-runtime-overrides.json.",
+      "description": "Temporarily override a Guardian rule's mode (off/shadow/soft/hard) with TTL (1h/24h/session). Core rules (R13/R14/R16/R25/R30/R34/R37) cannot be set to off. Writes to ~/.nexo/config/guardian-runtime-overrides.json.",
       "category": "guardian",
       "source": "server",
       "requires": [],
@@ -5192,7 +5192,9 @@
       "R14_correction_learning",
       "R16_declared_done",
       "R25_nora_maria_read_only",
-      "R30_pre_done_evidence_system_prompt"
+      "R30_pre_done_evidence_system_prompt",
+      "R34_identity_coherence",
+      "R37_pre_answer_evidence_gate"
     ],
     "core_rules_disallow_off": true,
     "server_side_rules_schema": {