nexo-brain 3.1.6 → 3.1.8

package/src/server.py

@@ -16,6 +16,13 @@ from tools_sessions import (
     handle_session_portable_context,
     handle_session_export_bundle,
 )
+from tools_hot_context import (
+    handle_recent_context_capture,
+    handle_recent_context,
+    handle_pre_action_context,
+    handle_recent_context_resolve,
+    handle_hot_context_list,
+)
 from user_context import get_context as _get_ctx
 from tools_coordination import (
     handle_track, handle_untrack, handle_files,
@@ -200,7 +207,9 @@ mcp = FastMCP(
         "When you catch something the user missed→`nexo_cognitive_trust(event='proactive_action')`. "
         "Detect intent, not keywords — works in ALL languages.\n"
         "- **Delegate:** prefer direct. If needed: `nexo_context_packet(area)` + guard + 'if unsure STOP'\n"
-        "- **Memory:** `nexo_recall` searches all. Capture: errors→`nexo_learning_add`, prefs, entities, decisions\n"
+        "- **Memory:** `nexo_recall` searches all. For fresh 24h continuity use `nexo_pre_action_context(query='...')` before acting and "
+        "`nexo_recent_context_capture(...)` / `nexo_recent_context_resolve(...)` for important ongoing threads. "
+        "Capture: errors→`nexo_learning_add`, prefs, entities, decisions\n"
         "- **Change log:** `nexo_task_close` should be the default closure path. If you bypass it, call `nexo_change_log(...)` after production edits. NOT for config dir\n"
         "- **Diary:** When user signals end of session (any language, any style — 'bye', 'done', 'cierro', etc.), "
         "write `nexo_session_diary_write(...)` with self_critique BEFORE responding. "
@@ -307,6 +316,70 @@ def nexo_context_packet(area: str, files: str = "") -> str:
     return handle_context_packet(area, files)
 
 
+@mcp.tool
+def nexo_recent_context_capture(
+    title: str,
+    summary: str = "",
+    details: str = "",
+    topic: str = "",
+    context_key: str = "",
+    state: str = "active",
+    owner: str = "",
+    source_type: str = "",
+    source_id: str = "",
+    session_id: str = "",
+    actor: str = "nexo",
+    ttl_hours: int = 24,
+    metadata: str = "",
+) -> str:
+    """Capture/update a recent 24h context item and append an event.
+
+    Use this for important ongoing threads that should stay mentally fresh across sessions/clients.
+    """
+    return handle_recent_context_capture(
+        title, summary, details, topic, context_key, state, owner,
+        source_type, source_id, session_id, actor, ttl_hours, metadata,
+    )
+
+
+@mcp.tool
+def nexo_recent_context(query: str = "", context_key: str = "", hours: int = 24, limit: int = 8) -> str:
+    """Read recent hot context and continuity events from the last N hours."""
+    return handle_recent_context(query, context_key, hours, limit)
+
+
+@mcp.tool
+def nexo_pre_action_context(query: str = "", context_key: str = "", session_id: str = "", hours: int = 24, limit: int = 8) -> str:
+    """Build the 24h recent-context bundle that should be reviewed before acting.
+
+    Especially useful for emails, orchestrators, and any work where the same topic may reappear hours later.
+    """
+    return handle_pre_action_context(query, context_key, session_id, hours, limit)
+
+
+@mcp.tool
+def nexo_recent_context_resolve(
+    context_key: str = "",
+    topic: str = "",
+    resolution: str = "",
+    actor: str = "nexo",
+    session_id: str = "",
+    source_type: str = "",
+    source_id: str = "",
+    ttl_hours: int = 24,
+) -> str:
+    """Resolve a recent hot-context item and append a resolution event."""
+    return handle_recent_context_resolve(
+        context_key, topic, resolution, actor, session_id, source_type, source_id, ttl_hours
+    )
+
+
+@mcp.tool
+def nexo_hot_context_list(hours: int = 24, limit: int = 10, state: str = "") -> str:
+    """List hot-context items currently alive in the recent continuity window."""
+    return handle_hot_context_list(hours, limit, state)
+
+
 @mcp.tool
 def nexo_smart_startup() -> str:
     """Pre-load relevant cognitive memories based on pending followups, due reminders, and last session topics.

package/src/tools_hot_context.py

@@ -0,0 +1,163 @@
+"""Tools for NEXO hot context / recent 24h memory."""
+
+from __future__ import annotations
+
+import json
+
+from db import (
+    derive_context_key,
+    capture_context_event,
+    get_hot_context,
+    build_pre_action_context,
+    format_pre_action_context_bundle,
+    resolve_hot_context,
+    search_hot_context,
+)
+
+
+def _parse_metadata(metadata: str = "") -> dict:
+    if not metadata or not metadata.strip():
+        return {}
+    try:
+        parsed = json.loads(metadata)
+    except Exception:
+        return {"raw": metadata.strip()}
+    return parsed if isinstance(parsed, dict) else {"value": parsed}
+
+
+def handle_recent_context_capture(
+    title: str,
+    summary: str = "",
+    details: str = "",
+    topic: str = "",
+    context_key: str = "",
+    state: str = "active",
+    owner: str = "",
+    source_type: str = "",
+    source_id: str = "",
+    session_id: str = "",
+    actor: str = "nexo",
+    ttl_hours: int = 24,
+    metadata: str = "",
+) -> str:
+    """Capture/update a recent context item and append an event."""
+    clean_title = (title or "").strip()
+    if not clean_title and not summary.strip():
+        return "ERROR: title or summary is required."
+    resolved_key = derive_context_key(
+        context_key=context_key,
+        topic=topic,
+        title=clean_title or summary,
+        source_type=source_type,
+        source_id=source_id,
+    )
+    result = capture_context_event(
+        event_type="context_capture",
+        title=clean_title or summary,
+        summary=(summary or clean_title)[:600],
+        body=details[:1600] if details else "",
+        context_key=resolved_key,
+        topic=topic,
+        context_title=clean_title or summary or resolved_key,
+        context_summary=summary or details or clean_title,
+        context_type="topic",
+        state=state or "active",
+        owner=owner or "",
+        actor=actor or "nexo",
+        source_type=source_type or "",
+        source_id=source_id or "",
+        session_id=session_id or "",
+        metadata=_parse_metadata(metadata),
+        ttl_hours=ttl_hours,
+    )
+    event = result.get("event") or {}
+    return (
+        f"Recent context captured: {result.get('context_key') or resolved_key}\n"
+        f"Title: {clean_title or summary}\n"
+        f"State: {(result.get('context') or {}).get('state', state or 'active')}\n"
+        f"Event: {event.get('event_type', 'context_capture')}"
+    )
+
+
+def handle_recent_context(query: str = "", context_key: str = "", hours: int = 24, limit: int = 8) -> str:
+    """Search hot context items and show their recent continuity."""
+    if context_key.strip():
+        item = get_hot_context(context_key.strip(), include_events=True, limit=max(4, int(limit or 8)))
+        if not item:
+            return f"No hot context found for {context_key.strip()}."
+        bundle = {
+            "query": query.strip(),
+            "context_key": context_key.strip(),
+            "hours": hours,
+            "contexts": [item],
+            "events": item.get("events") or [],
+            "reminders": [],
+            "followups": [],
+            "has_matches": True,
+        }
+        return format_pre_action_context_bundle(bundle)
+
+    bundle = build_pre_action_context(query=query, context_key="", session_id="", hours=hours, limit=limit)
+    return format_pre_action_context_bundle(bundle)
+
+
+def handle_pre_action_context(query: str = "", context_key: str = "", session_id: str = "", hours: int = 24, limit: int = 8) -> str:
+    """Build the recent 24h bundle that agents/scripts should consult before acting."""
+    bundle = build_pre_action_context(
+        query=query,
+        context_key=context_key,
+        session_id=session_id,
+        hours=hours,
+        limit=limit,
+    )
+    return format_pre_action_context_bundle(bundle)
+
+
+def handle_recent_context_resolve(
+    context_key: str = "",
+    topic: str = "",
+    resolution: str = "",
+    actor: str = "nexo",
+    session_id: str = "",
+    source_type: str = "",
+    source_id: str = "",
+    ttl_hours: int = 24,
+) -> str:
+    """Resolve a hot-context item and append a resolution event."""
+    resolved_key = derive_context_key(
+        context_key=context_key,
+        topic=topic,
+        title=topic,
+        source_type=source_type,
+        source_id=source_id,
+    )
+    if not resolved_key:
+        return "ERROR: context_key or topic is required."
+    result = resolve_hot_context(
+        context_key=resolved_key,
+        resolution=resolution or "Context resolved.",
+        actor=actor or "nexo",
+        session_id=session_id or "",
+        source_type=source_type or "",
+        source_id=source_id or "",
+        ttl_hours=ttl_hours,
+    )
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+    return f"Hot context resolved: {resolved_key}"
+
+
+def handle_hot_context_list(hours: int = 24, limit: int = 10, state: str = "") -> str:
+    """List active hot context items without the full event bundle."""
+    rows = search_hot_context("", hours=hours, limit=limit, state=state)
+    if not rows:
+        return "No hot context items."
+    lines = [f"HOT CONTEXT ({len(rows)}):"]
+    for item in rows:
+        summary = (item.get("summary") or "").strip()
+        suffix = f" — {summary[:120]}" if summary else ""
+        lines.append(
+            f"- {item.get('context_key')}: [{item.get('state')}] {item.get('title')} "
+            f"(last_event={item.get('last_event_at')}){suffix}"
+        )
+    return "\n".join(lines)

package/src/tools_sessions.py

@@ -14,7 +14,8 @@ from db import (
     get_inbox, get_pending_questions, now_epoch,
     SESSION_STALE_SECONDS, check_session_has_diary,
     save_checkpoint, read_checkpoint, increment_compaction_count,
-    get_db,
+    get_db, build_pre_action_context, format_pre_action_context_bundle,
+    capture_context_event,
 )
 
 # ── Session Keepalive ────────────────────────────────────────────────
@@ -131,6 +132,19 @@ def _session_portability_bundle(sid: str = "") -> dict:
             (session_id,),
         ).fetchall()
     ]
+    recent_query = " | ".join(
+        part for part in [
+            str(session_row["task"] or "").strip(),
+            str((checkpoint or {}).get("current_goal") or "").strip(),
+            str((draft or {}).get("last_context_hint") or "").strip(),
+        ] if part
+    )
+    recent_context = build_pre_action_context(
+        query=recent_query,
+        session_id=session_id,
+        hours=24,
+        limit=4,
+    ) if recent_query else {"has_matches": False}
     return {
         "ok": True,
         "generated_at": datetime.now(timezone.utc).isoformat(),
@@ -146,6 +160,7 @@ def _session_portability_bundle(sid: str = "") -> dict:
         "checkpoint": dict(checkpoint) if checkpoint else {},
         "latest_diary": dict(diary) if diary else {},
         "diary_draft": dict(draft) if draft else {},
+        "recent_context": recent_context,
         "open_protocol_tasks": protocol_tasks,
         "open_workflow_goals": workflow_goals,
         "open_workflow_runs": workflow_runs,
@@ -199,6 +214,9 @@ def handle_session_portable_context(sid: str = "") -> str:
                 f"- Context hint: {draft.get('last_context_hint') or '(none)'}",
             ]
         )
+    recent_context = bundle.get("recent_context") or {}
+    if recent_context.get("has_matches"):
+        lines.extend(["", format_pre_action_context_bundle(recent_context, compact=True)])
 
     protocol_tasks = bundle.get("open_protocol_tasks") or []
     if protocol_tasks:
@@ -382,7 +400,7 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
     Args:
         sid: Session ID
         task: Current task description
-        context_hint: Optional — stored for diary draft context, not processed.
+        context_hint: Optional — stored for diary draft context and used for recent 24h continuity lookup.
     """
     from db import get_db
     update_session(sid, task)
@@ -404,6 +422,21 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
             age = _format_age(q["created_epoch"])
             parts.append(f"  {q['qid']} de {q['from_sid']} ({age}): {q['question']}")
 
+    recent_query = (context_hint or task or "").strip()
+    if recent_query:
+        try:
+            bundle = build_pre_action_context(
+                query=recent_query,
+                session_id=sid,
+                hours=24,
+                limit=4,
+            )
+            if bundle.get("has_matches"):
+                parts.append("")
+                parts.append(format_pre_action_context_bundle(bundle, compact=True))
+        except Exception:
+            pass
+
     # Incremental diary draft — accumulate every heartbeat, full UPSERT every 5
     _hb_count = 0  # Hoisted for Layer 3 DIARY_OVERDUE signal
     try:
@@ -463,6 +496,28 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
     except Exception:
         pass  # Checkpoint update is best-effort
 
+    try:
+        capture_context_event(
+            event_type="heartbeat",
+            title=task[:160],
+            summary=(context_hint or task)[:600],
+            body=context_hint[:1600] if context_hint else "",
+            context_key=f"session:{sid}",
+            context_title=task[:160],
+            context_summary=(context_hint or task)[:600],
+            context_type="session_topic",
+            state="active",
+            owner="session",
+            actor=sid,
+            source_type="heartbeat",
+            source_id=sid,
+            session_id=sid,
+            metadata={"task": task[:160]},
+            ttl_hours=24,
+        )
+    except Exception:
+        pass
+
     # ── Layer 3: DIARY_OVERDUE signal based on heartbeat count + time ──
     conn = get_db()
     row = conn.execute("SELECT started_epoch FROM sessions WHERE sid = ?", (sid,)).fetchone()
@@ -555,7 +610,17 @@ def handle_context_packet(area: str, files: str = "") -> str:
     except Exception:
         pass
 
-    # 5. Cognitive memories for this area
+    # 5. Recent hot context in the last 24h
+    try:
+        hot_bundle = build_pre_action_context(query=area, hours=24, limit=4)
+        if hot_bundle.get("has_matches"):
+            parts.append("## RECENT HOT CONTEXT (24H)")
+            parts.append(format_pre_action_context_bundle(hot_bundle, compact=True))
+            parts.append("")
+    except Exception:
+        pass
+
+    # 6. Cognitive memories for this area
     try:
         import cognitive
         results = cognitive.search(
@@ -573,7 +638,7 @@ def handle_context_packet(area: str, files: str = "") -> str:
     except Exception:
         pass
 
-    # 6. Data flow tracing requirement (mandatory for all subagents)
+    # 7. Data flow tracing requirement (mandatory for all subagents)
     parts.append("## MANDATORY RULE: DATA FLOW TRACING")
     parts.append("BEFORE modifying any file or data, answer these 3 questions:")
     parts.append("  1. WHO PRODUCES this data? (which function/cron/endpoint generates it)")
@@ -717,6 +782,14 @@ def handle_smart_startup_query() -> str:
         lines.append("")
         lines.append(cognitive.format_results(results))
 
+        try:
+            hot_bundle = build_pre_action_context(query=composite_query, hours=24, limit=4)
+            if hot_bundle.get("has_matches"):
+                lines.append("")
+                lines.append(format_pre_action_context_bundle(hot_bundle, compact=True))
+        except Exception:
+            pass
+
         # Session tone from Deep Sleep (emotional intelligence layer)
         tone = _load_session_tone()
         if tone: