nexo-brain 7.23.13 → 7.24.0

package/src/db/_memory_v2.py

@@ -9,6 +9,7 @@ stable substrate without changing hook behaviour again.
 import hashlib
 import importlib
 import json
+import os
 import re
 import sqlite3
 import sys
@@ -429,6 +430,101 @@ def _derive_observation(event: dict) -> dict:
     }
 
 
+def _intraday_facts_enabled() -> bool:
+    value = os.environ.get("NEXO_INTRADAY_FACTS_ENABLED", "1").strip().lower()
+    return value not in {"0", "false", "no", "off", "disabled"}
+
+
+def _intraday_fact_candidate(observation: dict) -> bool:
+    if str(observation.get("status") or "active").lower() != "active":
+        return False
+    if float(observation.get("salience") or 0.0) < 0.62:
+        return False
+    if str(observation.get("observation_type") or "") not in {
+        "code_change",
+        "correction",
+        "decision",
+        "task_result",
+    }:
+        return False
+    if not str(observation.get("summary") or "").strip():
+        return False
+
+    facts = observation.get("facts") if isinstance(observation.get("facts"), dict) else {}
+    metadata = facts.get("metadata") if isinstance(facts.get("metadata"), dict) else {}
+    event_type = str(facts.get("event_type") or "")
+    source_type = str(facts.get("source_type") or "")
+    refs = [str(ref) for ref in observation.get("evidence_refs") or []]
+    observation_type = str(observation.get("observation_type") or "")
+
+    if observation_type == "task_result":
+        outcome = str(metadata.get("outcome") or event_type.removeprefix("protocol_task_") or "").lower()
+        return outcome in {"done", "closed", "completed", "success", "partial"}
+    if observation_type == "code_change":
+        verification_keys = {
+            "verified",
+            "verification",
+            "change_verify",
+            "test_output",
+            "tests_passed",
+            "evidence",
+        }
+        if source_type in {"change_log", "evidence_ledger", "protocol_task"}:
+            return True
+        if any(key in metadata and str(metadata.get(key) or "").strip() for key in verification_keys):
+            return True
+        return any(ref.startswith(("change_log:", "evidence:", "protocol_task:")) for ref in refs)
+    return observation_type in {"correction", "decision"}
+
+
+def publish_intraday_fact(observation: dict, *, ttl_hours: int = 36) -> dict:
+    """Expose high-salience observations as temporary hot context.
+
+    This is deliberately not long-term promotion. Deep Sleep can later promote,
+    merge, or discard the observation; the intraday fact only keeps today's
+    important work visible while the operator keeps working.
+    """
+    if not _intraday_facts_enabled():
+        return {"ok": True, "skipped": True, "reason": "intraday facts disabled"}
+    if not _intraday_fact_candidate(observation):
+        return {"ok": True, "skipped": True, "reason": "not an intraday fact candidate"}
+
+    uid = str(observation.get("observation_uid") or "").strip()
+    if not uid:
+        return {"ok": False, "error": "observation_uid is required"}
+
+    try:
+        from db._hot_context import capture_context_event
+
+        result = capture_context_event(
+            event_type="intraday_fact",
+            title=_truncate(observation.get("subject") or uid, 160),
+            summary=_truncate(observation.get("summary") or "", 600),
+            body=_truncate(observation.get("summary") or "", 1600),
+            context_key=f"intraday_fact:{uid}",
+            context_title=_truncate(observation.get("subject") or uid, 160),
+            context_summary=_truncate(observation.get("summary") or "", 600),
+            context_type="intraday_fact",
+            state="active",
+            owner="nexo",
+            actor="memory-observation-processor",
+            source_type="memory_observation",
+            source_id=uid,
+            session_id=str(observation.get("session_id") or ""),
+            metadata={
+                "observation_type": observation.get("observation_type") or "",
+                "project_key": observation.get("project_key") or "",
+                "promotion_state": observation.get("promotion_state") or "observation",
+                "evidence_refs": observation.get("evidence_refs") or [],
+            },
+            ttl_hours=ttl_hours,
+            created_at=float(observation.get("updated_at") or _core().now_epoch()),
+        )
+        return {"ok": True, "context_key": result.get("context_key"), "result": result}
+    except Exception as exc:
+        return {"ok": False, "error": _truncate(str(exc), 500)}
+
+
 def upsert_memory_observation(observation: dict) -> dict:
     conn = _core().get_db()
     if not _table_exists(conn, "memory_observations"):
@@ -520,6 +616,7 @@ def process_memory_observation_queue(limit: int = 25) -> dict:
     ).fetchall()
     processed = 0
     failed = 0
+    intraday_facts = 0
     now = _core().now_epoch()
     for row in rows:
         event = _row_to_event(row)
@@ -527,6 +624,9 @@ def process_memory_observation_queue(limit: int = 25) -> dict:
         try:
             observation = _derive_observation(event)
             upsert_memory_observation(observation)
+            intraday_result = publish_intraday_fact(observation)
+            if intraday_result.get("ok") and not intraday_result.get("skipped"):
+                intraday_facts += 1
             conn.execute(
                 """
                 UPDATE memory_observation_queue
@@ -554,7 +654,13 @@ def process_memory_observation_queue(limit: int = 25) -> dict:
             )
             failed += 1
     conn.commit()
-    return {"ok": failed == 0, "processed": processed, "failed": failed, "total_seen": len(rows)}
+    return {
+        "ok": failed == 0,
+        "processed": processed,
+        "failed": failed,
+        "intraday_facts": intraday_facts,
+        "total_seen": len(rows),
+    }
 
 
 def list_memory_events(

package/src/db/_protocol.py

@@ -365,9 +365,9 @@ def cortex_evaluation_summary(days: int = 30) -> dict:
 
     gaps: list[str] = []
     if total < 3:
-        gaps.append("Muy pocas evaluaciones del cortex para inferir mejora estable.")
+        gaps.append("Too few Cortex evaluations to infer stable improvement.")
     if len(linked) < 2:
-        gaps.append("Muy pocas decisiones enlazadas a outcomes para medir calidad real de recomendación.")
+        gaps.append("Too few decisions linked to outcomes to measure real recommendation quality.")
 
     return {
         "days": max(1, int(days)),

package/src/db/_reminders.py

@@ -14,7 +14,53 @@ from db._hot_context import capture_context_event
 from db._learnings import extract_keywords
 from db._semantic_similarity import hybrid_similarity_score
 
-ACTIVE_EXCLUDED_STATUSES = {"DELETED", "archived", "blocked", "waiting"}
+ACTIVE_EXCLUDED_STATUSES = {
+    "ARCHIVED",
+    "BLOCKED",
+    "DELETED",
+    "DONE",
+    "EXPIRED",
+    "NEEDS_DECISION",
+    "PARKED",
+    "STALE_REVIEW",
+    "WAITING",
+    "WAITING_EXTERNAL",
+    "WAITING_USER",
+}
+FOLLOWUP_TERMINAL_STATUSES = {"COMPLETED", "DELETED", "DONE", "EXPIRED", "ARCHIVED"}
+FOLLOWUP_WAITING_USER_STATUSES = {"NEEDS_DECISION", "WAITING_USER"}
+FOLLOWUP_WAITING_EXTERNAL_STATUSES = {"WAITING", "WAITING_EXTERNAL"}
+FOLLOWUP_BLOCKED_STATUSES = {"BLOCKED"}
+FOLLOWUP_STATUS_ALIASES = {
+    "": "PENDING",
+    "PENDIENTE": "PENDING",
+    "PENDING": "PENDING",
+    "ACTIVE": "PENDING",
+    "ACTIVO": "PENDING",
+    "COMPLETADO": "COMPLETED",
+    "COMPLETED": "COMPLETED",
+    "DONE": "DONE",
+    "HECHO": "DONE",
+    "ELIMINADO": "DELETED",
+    "DELETED": "DELETED",
+    "ARCHIVED": "ARCHIVED",
+    "ARCHIVADO": "ARCHIVED",
+    "BLOCKED": "BLOCKED",
+    "BLOQUEADO": "BLOCKED",
+    "WAITING": "WAITING",
+    "WAITING_EXTERNAL": "WAITING_EXTERNAL",
+    "ESPERANDO": "WAITING_EXTERNAL",
+    "WAITING_USER": "WAITING_USER",
+    "NEEDS_DECISION": "NEEDS_DECISION",
+    "NEEDS-DECISION": "NEEDS_DECISION",
+    "NEEDS DECISION": "NEEDS_DECISION",
+    "DECISION": "NEEDS_DECISION",
+    "NECESITA_DECISION": "NEEDS_DECISION",
+    "PARKED": "PARKED",
+    "APARCADO": "PARKED",
+    "STALE_REVIEW": "STALE_REVIEW",
+    "EXPIRED": "EXPIRED",
+}
 READ_TOKEN_TTL_SECONDS = 30 * 60
 
 # Opportunistic cleanup of expired item_read_tokens: runs at most once every
@@ -71,6 +117,49 @@ def _truncate(text: str | None, limit: int = 240) -> str:
     return text if len(text) <= limit else text[: limit - 3] + "..."
 
 
+def normalize_followup_status(status: str | None) -> str:
+    """Return the canonical followup status used by lifecycle tools."""
+    clean = str(status or "").strip()
+    if not clean:
+        return "PENDING"
+    upper = clean.upper().replace("-", "_")
+    if upper.startswith("COMPLETED"):
+        return "COMPLETED"
+    return FOLLOWUP_STATUS_ALIASES.get(upper, upper)
+
+
+def followup_lifecycle_lane(followup: dict) -> str:
+    """Classify one followup into an operational lane without mutating it."""
+    status = normalize_followup_status(followup.get("status"))
+    owner = str(followup.get("owner") or "").strip().lower()
+    if status in FOLLOWUP_TERMINAL_STATUSES:
+        return "completed" if status in {"COMPLETED", "DONE"} else status.lower()
+    if status in FOLLOWUP_BLOCKED_STATUSES:
+        return "blocked"
+    if status in FOLLOWUP_WAITING_USER_STATUSES or owner == "user":
+        return "waiting_user"
+    if status in FOLLOWUP_WAITING_EXTERNAL_STATUSES or owner == "waiting":
+        return "waiting_external"
+    if status == "PARKED":
+        return "parked"
+    if status == "STALE_REVIEW":
+        return "stale_review"
+    return "active"
+
+
+def followup_due_state(followup: dict) -> str:
+    """Return due/backlog/future/completed without changing the lifecycle lane."""
+    lane = followup_lifecycle_lane(followup)
+    if lane != "active":
+        return lane
+    due = _parse_date(followup.get("date"))
+    if due is None:
+        return "backlog"
+    if due > datetime.date.today():
+        return "future"
+    return "due"
+
+
 def _format_changes(before: sqlite3.Row | dict | None, after: sqlite3.Row | dict | None, fields: list[str]) -> str:
     if before is None or after is None:
         return ""
@@ -226,18 +315,20 @@ def _active_status_where(column_name: str = "status") -> str:
     excluded = ", ".join(f"'{value}'" for value in sorted(ACTIVE_EXCLUDED_STATUSES))
     return (
         f"{column_name} NOT LIKE 'COMPLETED%' "
-        f"AND {column_name} NOT IN ({excluded})"
+        f"AND UPPER(COALESCE({column_name}, '')) NOT IN ({excluded})"
     )
 
 
 def _context_state_from_status(status: str | None) -> str:
-    normalized = str(status or "PENDING").strip().upper()
+    normalized = normalize_followup_status(status)
     if normalized.startswith("COMPLETED"):
         return "resolved"
     if normalized == "DELETED":
         return "abandoned"
-    if normalized == "WAITING":
+    if normalized in {"WAITING_USER", "NEEDS_DECISION"}:
         return "waiting_user"
+    if normalized in {"WAITING", "WAITING_EXTERNAL"}:
+        return "waiting_third_party"
     if normalized == "BLOCKED":
         return "blocked"
     return "active"
@@ -632,6 +723,7 @@ def create_followup(
     """
     conn = get_db()
     now = now_epoch()
+    status = normalize_followup_status(status)
     similar = find_similar_followups(description)
     warning = ""
     if similar:
@@ -742,6 +834,8 @@ def update_followup(
             updates.pop("owner")
         else:
             updates["owner"] = coerced
+    if "status" in updates:
+        updates["status"] = normalize_followup_status(updates["status"])
     if not updates:
         return {"error": "No valid fields to update"}
 
@@ -1102,6 +1196,40 @@ def get_followup_history(id: str, limit: int = 20) -> list[dict]:
     return get_item_history("followup", id, limit=limit)
 
 
+def followup_lifecycle_snapshot(limit: int = 500) -> dict:
+    """Return followups grouped by lifecycle lane for dashboards and runners."""
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT * FROM followups ORDER BY updated_at DESC LIMIT ?",
+        (max(1, min(int(limit or 500), 5000)),),
+    ).fetchall()
+    lanes = {
+        "active": [],
+        "waiting_user": [],
+        "waiting_external": [],
+        "blocked": [],
+        "parked": [],
+        "stale_review": [],
+        "expired": [],
+        "completed": [],
+        "deleted": [],
+        "archived": [],
+    }
+    for row in rows:
+        item = dict(row)
+        item["status"] = normalize_followup_status(item.get("status"))
+        lane = followup_lifecycle_lane(item)
+        item["lifecycle_lane"] = lane
+        item["due_state"] = followup_due_state(item)
+        lanes.setdefault(lane, []).append(item)
+    return {
+        "ok": True,
+        "total": len(rows),
+        "lanes": lanes,
+        "counts": {lane: len(items) for lane, items in lanes.items()},
+    }
+
+
 def _parse_date(date_str: str | None) -> datetime.date | None:
     text = str(date_str or "").strip()
     if not text:

package/src/db/_schema.py

@@ -1341,7 +1341,7 @@ def _m49_protocol_guard_ack_backfill(conn):
 
 def _m50_dedupe_nexo_product_learning_pair(conn):
     """Block D.2 / G7-adjacent: dedupe the two learnings that encode the
-    "NEXO Brain producto público vs instancia personal de Francisco"
+    "NEXO Brain public product vs Francisco's personal instance"
     invariant as a physically separate pair.
 
     Francisco's runtime has this concept stored twice (historical IDs 212
@@ -1368,7 +1368,7 @@ def _m50_dedupe_nexo_product_learning_pair(conn):
 
     def _norm(text: str) -> str:
         # Collapse whitespace and strip punctuation/case so "NEXO Brain
-        # producto público vs instancia personal" matches its twin no
+        # public product vs personal instance" matches its twin no
         # matter how the operator rephrased it.
         import re as _re
         stripped = _re.sub(r"[\W_]+", " ", str(text or "")).strip().lower()

package/src/events_bus.py

@@ -101,11 +101,10 @@ def emit(
     path.parent.mkdir(parents=True, exist_ok=True)
     _rotate_if_needed(path)
 
-    # v0.32.5 — antes `_next_id(path)` se calculaba ANTES de adquirir el
-    # flock → dos emitters concurrentes leían el mismo tail, computaban
-    # el mismo id, y escribían dos eventos con el mismo id. El renderer
-    # dedup descartaba el segundo silently → eventos perdidos. Ahora
-    # `_next_id` se llama DENTRO del lock, garantizando monotonía.
+    # v0.32.5 — `_next_id(path)` used to run BEFORE taking the flock. Two
+    # concurrent emitters could read the same tail, compute the same id, and
+    # write two events with that id. Renderer dedup then dropped the second
+    # event silently. Calling `_next_id` INSIDE the lock guarantees monotonicity.
     line = None
     event = None
     with path.open("a", encoding="utf-8") as fh: