nexo-brain 7.9.22 → 7.9.24

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.22",
+  "version": "7.9.24",
   "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,7 +18,11 @@
 
 [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.9.22` is the current packaged-runtime line. Patch release over `7.9.21`: Desktop lifecycle shutdowns now have an emergency Brain-side fallback diary path, so close/archive/app-exit can preserve title, goal, session ids, and transcript tail even when the live agent does not answer the injected diary prompt before shutdown.
+Version `7.9.24` is the current packaged-runtime line. Patch release over `7.9.23`: Desktop lifecycle shutdown now resolves alias-only diary SIDs back to the registered NEXO session before stopping, so app-exit can preserve the diary and confirm the real session is closed.
+
+Previously in `7.9.23`: Desktop lifecycle fallback diaries now enrich sparse lifecycle events from continuity snapshots, so app-exit fallback evidence preserves recent turn context even when the live agent does not answer the injected diary prompt before shutdown.
+
+Previously in `7.9.22`: Desktop lifecycle shutdowns gained an emergency Brain-side fallback diary path, so close/archive/app-exit can preserve title, goal, session ids, and transcript tail even when the live agent does not answer the injected diary prompt before shutdown.
 
 Previously in `7.9.21`: LaunchAgent reload/repair now handles macOS already-loaded races by booting out jobs with modern launchctl forms, falling back to legacy load, and treating an already-loaded job as healthy only when it points at the expected plist.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.22",
+  "version": "7.9.24",
   "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/lifecycle_events.py

@@ -127,6 +127,109 @@ def _session_diary_session_ids(conn, session_id: str) -> List[str]:
     return deduped
 
 
+def _registered_session_ids(conn, session_id: str, candidates: Optional[List[str]] = None) -> List[str]:
+    """Return real active-session table ids linked to a lifecycle session id."""
+    raw = str(session_id or "").strip()
+    ids = [str(s or "").strip() for s in list(candidates or []) if str(s or "").strip()]
+    if raw and raw not in ids:
+        ids.append(raw)
+    rows = []
+    try:
+        if ids:
+            placeholders = ",".join("?" for _ in ids)
+            rows = conn.execute(
+                "SELECT sid FROM sessions "
+                f"WHERE sid IN ({placeholders}) OR external_session_id = ? OR claude_session_id = ? "
+                "ORDER BY last_update_epoch DESC",
+                (*ids, raw, raw),
+            ).fetchall()
+        elif raw:
+            rows = conn.execute(
+                "SELECT sid FROM sessions "
+                "WHERE external_session_id = ? OR claude_session_id = ? OR sid = ? "
+                "ORDER BY last_update_epoch DESC",
+                (raw, raw, raw),
+            ).fetchall()
+    except Exception:
+        rows = []
+
+    deduped: List[str] = []
+    seen = set()
+    for row in rows:
+        sid = str(row[0] or "").strip() if row else ""
+        if sid and sid not in seen:
+            seen.add(sid)
+            deduped.append(sid)
+    return deduped
+
+
+def _linked_external_session_ids(conn, session_id: str) -> List[str]:
+    """Return external Claude/Desktop ids linked to a NEXO SID or raw session id."""
+    raw = str(session_id or "").strip()
+    if not raw:
+        return []
+    ids: List[str] = []
+    if not raw.startswith("nexo-"):
+        ids.append(raw)
+    try:
+        rows = conn.execute(
+            "SELECT claude_session_id FROM session_claude_aliases WHERE sid = ? "
+            "ORDER BY last_seen DESC",
+            (raw,),
+        ).fetchall()
+        ids.extend(str(row[0] or "").strip() for row in rows if row and row[0])
+    except Exception:
+        pass
+    try:
+        rows = conn.execute(
+            "SELECT external_session_id, claude_session_id FROM sessions WHERE sid = ?",
+            (raw,),
+        ).fetchall()
+        for row in rows:
+            ids.extend(str(value or "").strip() for value in row if value)
+    except Exception:
+        pass
+
+    deduped: List[str] = []
+    seen = set()
+    for external_id in ids:
+        if external_id and external_id not in seen:
+            seen.add(external_id)
+            deduped.append(external_id)
+    return deduped
+
+
+def _registered_stop_session_ids(conn, session_id: str) -> List[str]:
+    """Resolve a lifecycle stop target to real registered NEXO SIDs."""
+    raw = str(session_id or "").strip()
+    if not raw:
+        return []
+    candidates = _session_diary_session_ids(conn, raw)
+    external_ids = _linked_external_session_ids(conn, raw)
+    for external_id in external_ids:
+        candidates.extend(_session_diary_session_ids(conn, external_id))
+
+    registered: List[str] = []
+    registered.extend(_registered_session_ids(conn, raw, candidates))
+    for external_id in external_ids:
+        registered.extend(_registered_session_ids(conn, external_id, candidates))
+
+    deduped: List[str] = []
+    seen = set()
+    for sid in registered:
+        if sid and sid not in seen:
+            seen.add(sid)
+            deduped.append(sid)
+    if deduped:
+        return deduped
+    return [raw] if raw.startswith("nexo-") else []
+
+
+def registered_stop_session_ids(session_id: str) -> List[str]:
+    """Public wrapper used by plugin handlers before calling nexo_stop."""
+    return _registered_stop_session_ids(get_db(), session_id)
+
+
 def _session_is_linked_to_nexo(conn, session_id: str) -> bool:
     """True when the external Claude/Desktop session is linked to a NEXO SID."""
     raw = str(session_id or "").strip()
@@ -264,6 +367,9 @@ def _preferred_diary_session_id(conn, session_id: str) -> str:
     """Return the best session id to store fallback diary evidence under."""
     raw = str(session_id or "").strip()
     candidates = _session_diary_session_ids(conn, raw)
+    for sid in _registered_session_ids(conn, raw, candidates):
+        if str(sid or "").startswith("nexo-"):
+            return str(sid)
     for sid in candidates:
         if str(sid or "").startswith("nexo-"):
             return str(sid)
@@ -278,6 +384,18 @@ def _payload_lines(payload: Dict[str, Any]) -> List[str]:
         text = str(raw or "").strip()
         if text:
             lines.append(text)
+    if not lines:
+        messages = payload.get("messages")
+        if isinstance(messages, list):
+            for item in messages[-12:]:
+                if isinstance(item, dict):
+                    role = str(item.get("role") or item.get("type") or item.get("sender") or "message").strip()
+                    text = str(item.get("content") or item.get("text") or "").strip()
+                else:
+                    role = "message"
+                    text = str(item or "").strip()
+                if text:
+                    lines.append(f"{role}: {text}")
     if not lines:
         user = str(payload.get("last_user_message") or payload.get("latest_user_text") or "").strip()
         assistant = str(payload.get("last_assistant_message") or payload.get("latest_assistant_text") or "").strip()
@@ -288,6 +406,114 @@ def _payload_lines(payload: Dict[str, Any]) -> List[str]:
     return lines[-12:]
 
 
+def _parse_payload_json(raw: Any) -> Dict[str, Any]:
+    try:
+        parsed = json.loads(raw or "{}")
+    except Exception:
+        return {}
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def _payload_has_context(payload: Dict[str, Any]) -> bool:
+    if not isinstance(payload, dict):
+        return False
+    if _payload_lines(payload):
+        return True
+    for key in ("current_goal", "last_user_message", "latest_user_text", "last_assistant_message", "latest_assistant_text"):
+        if str(payload.get(key) or "").strip():
+            return True
+    return False
+
+
+def _continuity_payloads_for_event(
+    conn,
+    conversation_id: str,
+    session_id: str,
+    limit: int = 24,
+) -> List[Dict[str, Any]]:
+    """Return recent continuity payloads for richer emergency diaries."""
+    conv = str(conversation_id or "").strip()
+    sid = str(session_id or "").strip()
+    if not conv and not sid:
+        return []
+
+    where_parts: List[str] = []
+    params: List[Any] = []
+    if conv:
+        where_parts.append("conversation_id = ?")
+        params.append(conv)
+    if sid:
+        where_parts.append("session_id = ?")
+        params.append(sid)
+    where = " OR ".join(where_parts)
+
+    try:
+        rows = conn.execute(
+            "SELECT event_type, payload_json FROM continuity_snapshots "
+            f"WHERE ({where}) "
+            "ORDER BY id DESC LIMIT ?",
+            (*params, int(limit)),
+        ).fetchall()
+    except Exception:
+        return []
+
+    payloads: List[Dict[str, Any]] = []
+    for row in reversed(rows):
+        event_type = str(row[0] or "").strip()
+        if event_type and event_type not in {"turn_end", "app_exit", "desktop_snapshot", "close", "archive"}:
+            continue
+        payload = _parse_payload_json(row[1] if len(row) > 1 else "")
+        if payload:
+            payloads.append(payload)
+    return payloads
+
+
+def _dedupe_lines(lines: List[str]) -> List[str]:
+    seen = set()
+    result: List[str] = []
+    for raw in lines:
+        line = str(raw or "").strip()
+        if not line or line in seen:
+            continue
+        seen.add(line)
+        result.append(line)
+    return result
+
+
+def _enrich_payload_from_continuity(
+    conn,
+    payload: Dict[str, Any],
+    conversation_id: str,
+    session_id: str,
+) -> Dict[str, Any]:
+    """Fill sparse lifecycle payloads from durable continuity snapshots."""
+    enriched = dict(payload or {})
+    continuity_payloads = _continuity_payloads_for_event(conn, conversation_id, session_id)
+    if not continuity_payloads:
+        return enriched
+
+    latest = continuity_payloads[-1]
+    for key in (
+        "title",
+        "current_goal",
+        "last_user_message",
+        "latest_user_text",
+        "last_assistant_message",
+        "latest_assistant_text",
+    ):
+        if not str(enriched.get(key) or "").strip() and str(latest.get(key) or "").strip():
+            enriched[key] = latest[key]
+
+    continuity_lines: List[str] = []
+    for item in continuity_payloads:
+        continuity_lines.extend(_payload_lines(item))
+    continuity_lines = _dedupe_lines(continuity_lines)
+    current_lines = _payload_lines(enriched)
+    if len(continuity_lines) > len(current_lines) or not _payload_has_context(enriched):
+        enriched["transcript_tail"] = continuity_lines[-12:]
+    return enriched
+
+
 def write_fallback_diary_for_lifecycle_event(
     event_id: str,
     reason: str = "",
@@ -341,6 +567,7 @@ def write_fallback_diary_for_lifecycle_event(
             payload = {}
     except Exception:
         payload = {}
+    payload = _enrich_payload_from_continuity(conn, payload, conversation_id, session_id)
 
     title = str(payload.get("title") or conversation_id or event_id).strip()
     transcript_lines = _payload_lines(payload)

package/src/plugins/lifecycle_events.py

@@ -217,11 +217,14 @@ def handle_nexo_lifecycle_stop_nexo_session(
     try:
         from tools_sessions import handle_stop
 
-        message = handle_stop(str(sid or ""))
+        raw_sid = str(sid or "").strip()
+        stop_sids = lifecycle_events.registered_stop_session_ids(raw_sid) or [raw_sid]
+        messages = [handle_stop(stop_sid) for stop_sid in stop_sids]
         return json.dumps({
             "status": "ok",
-            "sid": str(sid or ""),
-            "message": message,
+            "sid": raw_sid,
+            "stopped_session_ids": stop_sids,
+            "message": " ".join(messages),
         }, ensure_ascii=False)
     except Exception as exc:
         return json.dumps({