nexo-brain 7.27.3 → 7.28.0

package/src/db/_memory_v2.py

@@ -129,6 +129,55 @@ def _redact_value(value: Any) -> tuple[Any, bool]:
     return value, False
 
 
+def _memory_executive_shadow_decision(
+    *,
+    event_uid: str,
+    source_type: str,
+    source_id: str,
+    event_type: str,
+    actor: str,
+    session_id: str,
+    project_key: str,
+    text: str,
+    metadata: dict[str, Any],
+    privacy_level: str,
+    idempotency_key: str,
+    created_at: float,
+) -> dict[str, Any]:
+    try:
+        from memory_executive import audit_record, decide
+    except Exception as exc:
+        return {"error": f"memory_executive_unavailable:{_truncate(str(exc), 160)}"}
+
+    raw_refs = metadata.get("evidence_refs") or metadata.get("evidence_ref") or []
+    if isinstance(raw_refs, str):
+        evidence_refs = [raw_refs]
+    elif isinstance(raw_refs, (list, tuple, set)):
+        evidence_refs = [str(item) for item in raw_refs if str(item).strip()]
+    else:
+        evidence_refs = []
+    event = {
+        "event_uid": event_uid,
+        "source_type": source_type,
+        "source_id": source_id,
+        "event_type": event_type,
+        "actor": actor,
+        "session_id": session_id,
+        "project_key": project_key,
+        "text": _truncate(text, 1200),
+        "metadata": metadata,
+        "evidence_refs": evidence_refs,
+        "privacy_level": privacy_level,
+        "idempotency_key": idempotency_key,
+        "created_at": str(created_at),
+    }
+    try:
+        decision = decide(event, shadow_mode=True)
+        return audit_record(event, decision)
+    except Exception as exc:
+        return {"error": f"memory_executive_error:{_truncate(str(exc), 160)}"}
+
+
 def _stable_hash(value: Any) -> str:
     if value in (None, ""):
         return ""
@@ -282,6 +331,35 @@ def record_memory_event(
         idempotency_key=idempotency_key,
         created_at=now,
     )
+    executive_text = " ".join(
+        str(part or "").strip()
+        for part in (
+            clean_meta.get("summary") if isinstance(clean_meta, dict) else "",
+            clean_meta.get("statement") if isinstance(clean_meta, dict) else "",
+            clean_meta.get("goal") if isinstance(clean_meta, dict) else "",
+            clean_meta.get("outcome") if isinstance(clean_meta, dict) else "",
+            clean_command,
+            clean_raw_ref,
+        )
+        if str(part or "").strip()
+    )
+    if isinstance(clean_meta, dict) and "memory_executive" not in clean_meta:
+        clean_meta["memory_executive"] = _memory_executive_shadow_decision(
+            event_uid=uid,
+            source_type=clean_source_type,
+            source_id=_truncate(source_id, 200),
+            event_type=clean_event_type,
+            actor=_truncate(actor, 120),
+            session_id=_truncate(session_id, 160),
+            project_key=_truncate(project_key, 120),
+            text=executive_text,
+            metadata=clean_meta,
+            privacy_level="secret" if redaction_applied else (privacy_level or "normal"),
+            idempotency_key=idempotency_key or uid,
+            created_at=now,
+        )
+        if clean_meta["memory_executive"].get("decision_kind") == "quarantine":
+            enqueue_observation = False
 
     try:
         cursor = conn.execute(
@@ -1028,7 +1106,7 @@ def backfill_memory_observations(
     return {"ok": True, "sources": sorted(requested), "seen": seen, "created_or_updated": created}
 
 
-def memory_observation_health() -> dict:
+def memory_observation_health(*, pending_sla_seconds: int = 3600, now: float | None = None) -> dict:
     conn = _core().get_db()
     tables = {
         "memory_events": _table_exists(conn, "memory_events"),
@@ -1044,11 +1122,40 @@ def memory_observation_health() -> dict:
     if tables["memory_observations"]:
         counts["observations"] = int(conn.execute("SELECT COUNT(*) FROM memory_observations").fetchone()[0])
         latest["observation_created_at"] = conn.execute("SELECT MAX(created_at) FROM memory_observations").fetchone()[0]
+    pending_sla = max(1, int(pending_sla_seconds or 3600))
+    pending_older_than_sla = 0
+    oldest_pending = None
+    max_pending_age_seconds = 0.0
     if tables["memory_observation_queue"]:
         rows = conn.execute(
             "SELECT status, COUNT(*) AS cnt FROM memory_observation_queue GROUP BY status"
         ).fetchall()
         counts["queue"] = {row["status"]: int(row["cnt"]) for row in rows}
+        stamp = float(now if now is not None else _core().now_epoch())
+        stale_cutoff = stamp - pending_sla
+        pending_older_than_sla = int(
+            conn.execute(
+                """
+                SELECT COUNT(*)
+                  FROM memory_observation_queue
+                 WHERE status IN ('pending', 'failed')
+                   AND created_at <= ?
+                """,
+                (stale_cutoff,),
+            ).fetchone()[0]
+        )
+        oldest = conn.execute(
+            """
+            SELECT event_uid, status, created_at, updated_at, last_error
+              FROM memory_observation_queue
+             WHERE status IN ('pending', 'failed')
+             ORDER BY created_at ASC, id ASC
+             LIMIT 1
+            """
+        ).fetchone()
+        if oldest:
+            oldest_pending = dict(oldest)
+            max_pending_age_seconds = max(0.0, stamp - float(oldest["created_at"] or stamp))
 
     fts_enabled = _is_virtual_fts_table(conn, "memory_observations_fts")
     fts_queryable = False
@@ -1061,12 +1168,33 @@ def memory_observation_health() -> dict:
 
     missing_required = [name for name in ("memory_events", "memory_observations", "memory_observation_queue") if not tables[name]]
     failed_queue = int(counts["queue"].get("failed", 0))
+    warnings = []
+    if pending_older_than_sla:
+        warnings.append(
+            {
+                "code": "pending_sla_breached",
+                "pending_older_than_sla": pending_older_than_sla,
+                "pending_sla_seconds": pending_sla,
+                "max_pending_age_seconds": max_pending_age_seconds,
+                "oldest_pending": oldest_pending,
+            }
+        )
+    if failed_queue:
+        warnings.append({"code": "queue_failed", "failed": failed_queue})
     return {
-        "ok": not missing_required and failed_queue == 0,
+        "ok": not missing_required and failed_queue == 0 and pending_older_than_sla == 0,
         "tables": tables,
         "missing_required": missing_required,
         "counts": counts,
         "latest": latest,
+        "queue_sla": {
+            "pending_sla_seconds": pending_sla,
+            "pending_sla_ok": pending_older_than_sla == 0,
+            "pending_older_than_sla": pending_older_than_sla,
+            "oldest_pending": oldest_pending,
+            "max_pending_age_seconds": max_pending_age_seconds,
+        },
+        "warnings": warnings,
         "fts_enabled": fts_enabled,
         "fts_degraded": tables["memory_observations_fts"] and not fts_enabled,
         "fts_queryable": fts_queryable,