nexo-brain 7.9.21 → 7.9.23

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.21",
+  "version": "7.9.23",
   "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.21` is the current packaged-runtime line. Patch release over `7.9.20`: 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.
+Version `7.9.23` is the current packaged-runtime line. Patch release over `7.9.22`: 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.
 
 Previously in `7.9.20`: packaged update/doctor repair now finds `runtime/crons/sync.py`, LaunchAgent PATH includes the managed Claude runtime installed under `~/.nexo/runtime/bootstrap/npm-global/bin`, root runtime backfill includes `claude_cli.py`, and Immune no longer treats the legacy optional `~/.claude-mem/claude-mem.db` as a required database.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.21",
+  "version": "7.9.23",
   "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/cli.py

@@ -3232,6 +3232,14 @@ def main():
     lwait_p.add_argument("--timeout-ms", type=int, default=45_000)
     lwait_p.add_argument("--poll-ms", type=int, default=500)
 
+    lfallback_diary_p = lifecycle_sub.add_parser(
+        "write-fallback-diary",
+        help="v7.9.22: write emergency diary evidence for a lifecycle event",
+    )
+    lfallback_diary_p.add_argument("--event-id", required=True)
+    lfallback_diary_p.add_argument("--reason", default="")
+    lfallback_diary_p.add_argument("--source", default="desktop-lifecycle-fallback")
+
     lwait_stop_p = lifecycle_sub.add_parser(
         "wait-for-stop",
         help="v7.9.10: wait until the linked NEXO session is no longer active",
@@ -3547,6 +3555,23 @@ def main():
             if status == "retryable_error":
                 return 2
             return 3
+        if args.lifecycle_command == "write-fallback-diary":
+            out = _lifecycle_plugin.handle_nexo_lifecycle_write_fallback_diary(
+                event_id=args.event_id,
+                reason=args.reason or "",
+                source=args.source or "desktop-lifecycle-fallback",
+            )
+            print(out)
+            try:
+                parsed = _json.loads(out)
+                status = str(parsed.get("status", ""))
+            except Exception:
+                status = ""
+            if status in ("ok", "processed", "already_processed"):
+                return 0
+            if status == "retryable_error":
+                return 2
+            return 3
         if args.lifecycle_command == "wait-for-stop":
             out = _lifecycle_plugin.handle_nexo_lifecycle_wait_for_stop(
                 event_id=args.event_id,

package/src/lifecycle_events.py

@@ -260,6 +260,259 @@ def _session_diary_since(conn, session_id: str, dispatched_at: Optional[str], ac
     return _session_diary_evidence(conn, session_id, dispatched_at, actions_json) is not None
 
 
+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 candidates:
+        if str(sid or "").startswith("nexo-"):
+            return str(sid)
+    return candidates[0] if candidates else raw
+
+
+def _payload_lines(payload: Dict[str, Any]) -> List[str]:
+    lines: List[str] = []
+    if not isinstance(payload, dict):
+        return lines
+    for raw in payload.get("transcript_tail") or []:
+        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()
+        if user:
+            lines.append(f"user: {user}")
+        if assistant:
+            lines.append(f"assistant: {assistant}")
+    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 = "",
+    source: str = "desktop-lifecycle-fallback",
+) -> Dict[str, Any]:
+    """Write minimum durable diary evidence when live-agent injection fails.
+
+    This is the safety net for Desktop close/archive/app-exit. The preferred
+    path remains an agent-authored ``nexo_session_diary_write``. If the agent is
+    busy or stdin never produces a response, Desktop can call this command so
+    session continuity still has a concrete ``session_diary`` row instead of
+    silently losing the last context.
+    """
+    if not event_id:
+        return {"status": "rejected", "reason": "missing-event-id"}
+
+    conn = get_db()
+    row = conn.execute(
+        "SELECT action, conversation_id, session_id, reason, payload_snapshot, "
+        "canonical_dispatched_at, canonical_actions_json "
+        "FROM lifecycle_events WHERE event_id = ?",
+        (str(event_id),),
+    ).fetchone()
+    if row is None:
+        return {"status": "rejected", "reason": "unknown-event-id", "event_id": event_id}
+
+    action = str(row[0] or "")
+    conversation_id = str(row[1] or "")
+    session_id = str(row[2] or "")
+    lifecycle_reason = str(row[3] or "")
+    dispatched_at = row[5]
+    actions_json = row[6]
+    if action not in _DIARY_TRIGGERING:
+        return {"status": "processed", "event_id": event_id, "diary_required": False}
+    if not session_id:
+        return {"status": "rejected", "reason": "missing-session-id", "event_id": event_id}
+
+    existing = _session_diary_evidence(conn, session_id, dispatched_at, actions_json)
+    if existing is not None:
+        return {
+            "status": "ok",
+            "event_id": event_id,
+            "fallback_written": False,
+            "diary_confirmed": True,
+            **existing,
+        }
+
+    try:
+        payload = json.loads(row[4] or "{}")
+        if not isinstance(payload, dict):
+            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)
+    technical_reason = str(reason or lifecycle_reason or "fallback-diary").strip()
+    diary_session_id = _preferred_diary_session_id(conn, session_id)
+    summary = (
+        "Diario automatico de emergencia generado por NEXO Desktop al cerrar "
+        f"'{title}'. No se confirmo un diario escrito por el agente vivo, asi "
+        "que se preserva el snapshot disponible para continuidad."
+    )
+    decisions = (
+        f"Accion de ciclo de vida: {action}. Evento: {event_id}. "
+        f"Motivo tecnico: {technical_reason}."
+    )
+    pending = str(payload.get("current_goal") or payload.get("last_user_message") or "").strip()
+    if not pending:
+        pending = "Revisar la conversacion al reabrir y continuar desde el snapshot preservado."
+    context_next_parts = [
+        f"conversation_id={conversation_id}",
+        f"session_id={session_id}",
+    ]
+    if transcript_lines:
+        context_next_parts.append("Transcript tail:\n" + "\n".join(transcript_lines))
+    context_next = "\n".join(context_next_parts)[:8000]
+
+    from db import write_session_diary
+
+    diary = write_session_diary(
+        diary_session_id,
+        decisions=decisions,
+        summary=summary,
+        discarded="",
+        pending=pending,
+        context_next=context_next,
+        mental_state="Fallback automatico: el agente vivo no confirmo el cierre dentro del timeout.",
+        domain="nexo-desktop",
+        user_signals="Cierre/archivo de conversacion; preservar informacion antes de salir.",
+        self_critique="El cierre no debe depender exclusivamente de que el agente responda a tiempo.",
+        source=source or "desktop-lifecycle-fallback",
+    )
+    return {
+        "status": "ok",
+        "event_id": event_id,
+        "fallback_written": True,
+        "diary_confirmed": True,
+        "session_diary_id": diary.get("id"),
+        "diary_session_id": diary_session_id,
+        "source": source or "desktop-lifecycle-fallback",
+    }
+
+
 def _session_stop_state(conn, session_id: str) -> Dict[str, Any]:
     """Return whether the lifecycle session can be verified as fully stopped."""
     raw = str(session_id or "").strip()

package/src/plugins/lifecycle_events.py

@@ -168,6 +168,27 @@ def handle_nexo_lifecycle_wait_for_diary(
     return json.dumps(ack, ensure_ascii=False)
 
 
+def handle_nexo_lifecycle_write_fallback_diary(
+    event_id: str,
+    reason: str = "",
+    source: str = "desktop-lifecycle-fallback",
+) -> str:
+    """Write emergency diary evidence for a lifecycle event."""
+    try:
+        ack = lifecycle_events.write_fallback_diary_for_lifecycle_event(
+            event_id=str(event_id or ""),
+            reason=str(reason or ""),
+            source=str(source or "desktop-lifecycle-fallback"),
+        )
+    except Exception as exc:
+        return json.dumps({
+            "status": "retryable_error",
+            "reason": f"{type(exc).__name__}: {exc}",
+            "handler_threw": True,
+        }, ensure_ascii=False)
+    return json.dumps(ack, ensure_ascii=False)
+
+
 def handle_nexo_lifecycle_wait_for_stop(
     event_id: str,
     timeout_ms: int = 10_000,
@@ -231,6 +252,11 @@ TOOLS = [
         "nexo_lifecycle_wait_for_diary",
         "Wait for concrete session_diary evidence for a canonical lifecycle event before Desktop stops the session.",
     ),
+    (
+        handle_nexo_lifecycle_write_fallback_diary,
+        "nexo_lifecycle_write_fallback_diary",
+        "Write emergency session_diary evidence when Desktop cannot get a live agent-authored close diary.",
+    ),
     (
         handle_nexo_lifecycle_wait_for_stop,
         "nexo_lifecycle_wait_for_stop",

package/src/runtime_versioning.py

@@ -34,6 +34,7 @@ RESTART_ALLOWLIST = {
     "nexo_lifecycle_status",
     "nexo_lifecycle_complete_canonical",
     "nexo_lifecycle_wait_for_diary",
+    "nexo_lifecycle_write_fallback_diary",
     "nexo_continuity_snapshot_read",
     "nexo_continuity_resume_bundle",
     "nexo_continuity_audit",

package/tool-enforcement-map.json

@@ -1983,6 +1983,19 @@
       },
       "triggers_after": []
     },
+    "nexo_lifecycle_write_fallback_diary": {
+      "description": "Write a Brain-side fallback session_diary for a Desktop lifecycle event when live diary injection cannot complete.",
+      "category": "lifecycle",
+      "source": "plugin:lifecycle_events",
+      "requires": [],
+      "provides": [],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
     "nexo_lifecycle_stop_nexo_session": {
       "description": "Best-effort explicit stop of a NEXO SID for Desktop lifecycle cleanup.",
       "category": "lifecycle",