nexo-brain 7.31.3 → 7.31.5

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.31.3",
+  "version": "7.31.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,9 +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.31.3` is the current packaged-runtime line. Patch release over v7.31.2 - the recommended Claude Code model returns to Opus 4.8 with max reasoning (installs riding NEXO defaults migrate back automatically; customized models untouched), and the dead heartbeat-enforcement hook trio is removed from the source tree.
+Version `7.31.5` is the current packaged-runtime line. Patch release over v7.31.4 - the breaker resume notice exists: when a notified engine pause recovers, the operator gets exactly one resume email in their language, signed by their agent.
 
-Previously in `7.31.2`: patch release over v7.31.1 - the session ID becomes a durable identity (sessions survive quiet work periods; physical cleanup at 24h), runtime residents are isolated per generation so two installs can never kill each other's resident, and obsolete residents retire themselves once clients disconnect.
+Previously in `7.31.4`: patch release over v7.31.3 - memory recall honours absolute time ranges (ISO dates, start..end ranges, datetimes, epochs) and enforces the window in SQL, so asking about a specific past day returns that day.
 
 Previously in `7.30.33`: patch release over v7.30.32 - personal agent/script status now keeps the newest real run between manual executions and cron history, so a successful manual agent run cannot be hidden behind an older scheduled failure.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.31.3",
+  "version": "7.31.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/db/_memory_v2.py

@@ -750,12 +750,23 @@ def list_memory_events(
     session_id: str = "",
     project_key: str = "",
     limit: int = 20,
+    start_ts: float | None = None,
+    end_ts: float | None = None,
 ) -> list[dict]:
     conn = _core().get_db()
     if not _table_exists(conn, "memory_events"):
         return []
     clauses = ["1=1"]
     params: list[Any] = []
+    # time_range push-down (ff78ff94): bounds must constrain the SQL fetch
+    # itself — Python-side filtering after a recency-truncated fetch made old
+    # windows return nothing.
+    if start_ts is not None:
+        clauses.append("created_at >= ?")
+        params.append(float(start_ts))
+    if end_ts is not None:
+        clauses.append("created_at < ?")
+        params.append(float(end_ts))
     if event_type.strip():
         clauses.append("event_type = ?")
         params.append(event_type.strip().lower())
@@ -798,12 +809,20 @@ def list_memory_observations(
     project_key: str = "",
     status: str = "",
     limit: int = 20,
+    start_ts: float | None = None,
+    end_ts: float | None = None,
 ) -> list[dict]:
     conn = _core().get_db()
     if not _table_exists(conn, "memory_observations"):
         return []
     clauses = ["1=1"]
     params: list[Any] = []
+    if start_ts is not None:
+        clauses.append("created_at >= ?")
+        params.append(float(start_ts))
+    if end_ts is not None:
+        clauses.append("created_at < ?")
+        params.append(float(end_ts))
     if observation_type.strip():
         clauses.append("observation_type = ?")
         params.append(observation_type.strip().lower())
@@ -845,6 +864,8 @@ def search_memory_observations_fts(
     *,
     project_key: str = "",
     limit: int = 20,
+    start_ts: float | None = None,
+    end_ts: float | None = None,
 ) -> list[dict]:
     conn = _core().get_db()
     if not _table_exists(conn, "memory_observations_fts"):
@@ -859,6 +880,12 @@ def search_memory_observations_fts(
          WHERE memory_observations_fts MATCH ?
     """
     params: list[Any] = [fts]
+    if start_ts is not None:
+        sql += " AND o.created_at >= ?"
+        params.append(float(start_ts))
+    if end_ts is not None:
+        sql += " AND o.created_at < ?"
+        params.append(float(end_ts))
     if project_key.strip():
         sql += " AND o.project_key = ?"
         params.append(project_key.strip())

package/src/managed_mcp/lock.json

@@ -39,9 +39,9 @@
     "open-computer-use": {
       "source_type": "npm",
       "package": "open-computer-use",
-      "version": "0.1.52",
-      "integrity": "sha512-KlOHmFvXHe2IEMGE/O+zMN5ASo+FQ42copj4j1xEOnyeLq4oxUxhtHqEdPUACCUcMZaHzKXfZboL1dk5a2GjLA==",
-      "tarball": "https://registry.npmjs.org/open-computer-use/-/open-computer-use-0.1.52.tgz",
+      "version": "0.1.53",
+      "integrity": "sha512-5qwCPl7Gm4Wk2i/wFkq2dVLN2SzNRQSJTd95zXdGF+u5ZsUXkFx1IFVdNbYelWOpc4fgy8Z8/gYrbacj/2chig==",
+      "tarball": "https://registry.npmjs.org/open-computer-use/-/open-computer-use-0.1.53.tgz",
       "bin": "open-computer-use-mcp",
       "engines": {}
     },

package/src/memory_retrieval.py

@@ -82,6 +82,40 @@ def _parse_time_range(value: str = "") -> tuple[float | None, float | None, str]
         unit = match.group(2)
         delta = timedelta(hours=amount) if unit.startswith("h") else timedelta(days=amount)
         return (now - delta).timestamp(), now.timestamp(), clean
+
+    # Operator bug (session ff78ff94, 11-jun): absolute values silently fell
+    # through to (None, None, "") which DISABLED the filter — asking for a
+    # specific past day returned the most recent events instead. Support ISO
+    # dates, ISO ranges (date end is inclusive: bound = next midnight), ISO
+    # datetimes, and epoch seconds / epoch ranges.
+    def _point(text, *, end_of_day=False):
+        text = text.strip()
+        if re.fullmatch(r"\d{9,}(\.\d+)?", text):
+            return float(text), False
+        try:
+            if re.fullmatch(r"\d{4}-\d{2}-\d{2}", text):
+                day = datetime.fromisoformat(text)
+                if end_of_day:
+                    return (day + timedelta(days=1)).timestamp(), True
+                return day.timestamp(), True
+            return datetime.fromisoformat(text).timestamp(), False
+        except ValueError:
+            return None, False
+
+    if ".." in clean:
+        left, _, right = clean.partition("..")
+        start_ts, _ = _point(left)
+        end_ts, _ = _point(right, end_of_day=True)
+        if start_ts is not None and end_ts is not None and end_ts > start_ts:
+            return start_ts, end_ts, f"range:{clean}"
+        return None, None, ""
+
+    point_ts, is_date = _point(clean)
+    if point_ts is not None:
+        if is_date:
+            return point_ts, point_ts + 86400, f"day:{clean}"
+        # Single datetime/epoch: a one-hour window centred forward.
+        return point_ts, point_ts + 3600, f"at:{clean}"
     return None, None, ""
 
 
@@ -177,6 +211,8 @@ def memory_search(
         clean_query,
         project_key="",
         limit=max_items * 3,
+        start_ts=start,
+        end_ts=end,
     ):
         uid = item.get("observation_uid") or f"id:{item.get('id')}"
         observations_by_uid[uid] = item
@@ -184,6 +220,8 @@ def memory_search(
         query=clean_query,
         project_key="",
         limit=max_items * 3,
+        start_ts=start,
+        end_ts=end,
     ):
         uid = item.get("observation_uid") or f"id:{item.get('id')}"
         observations_by_uid.setdefault(uid, item)
@@ -192,6 +230,8 @@ def memory_search(
         query=clean_query,
         project_key="",
         limit=max_items * 3,
+        start_ts=start,
+        end_ts=end,
     )
 
     candidates = [

package/src/provider_circuit_breaker.py

@@ -51,7 +51,8 @@ DEFAULT_RETRY_AFTER_S = {
 _FAILURE_PATTERNS = (
     ("credits", re.compile(
         r"credit balance is too low|insufficient[_ ]quota|exceeded your current quota"
-        r"|billing hard limit|out of credits|usage limit reached|plan limits",
+        r"|billing hard limit|out of credits|usage limit reached|hit your usage limit"
+        r"|purchase more credits|plan limits",
         re.I)),
     ("rate_limit", re.compile(
         r"rate[_ -]?limit|too many requests|\b429\b|overloaded[_ ]error|\b529\b"
@@ -189,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]
@@ -212,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/scripts/nexo-email-monitor.py

@@ -2443,6 +2443,52 @@ 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
+            if _uses_spanish(operator_language):
+                subject = f"[{assistant_name}] Motor {backend} reanudado"
+                body = (
+                    f"Hola {operator_name},\n\n"
+                    f"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"
+                    f"— {assistant_name}"
+                )
+            else:
+                subject = f"[{assistant_name}] Engine {backend} resumed"
+                body = (
+                    f"Hello {operator_name},\n\n"
+                    f"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"
+                    f"— {assistant_name}"
+                )
+            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.
 
@@ -2675,6 +2721,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