nexo-brain 7.9.20 → 7.9.22

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.20",
+  "version": "7.9.22",
   "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.20` is the current packaged-runtime line. Patch release over `7.9.19`: 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.
+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.
+
+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.
 
 Previously in `7.9.19`: runtime doctor now distinguishes real install breakage from tracked in-progress work, interactive Desktop sessions no longer poison automation telemetry scoring, stale filesystem skill rows are pruned during sync, stale protocol debt draining marks rows resolved, and watchdog treats LaunchAgent SIGTERM reloads as supervisor interruptions instead of failures.
 

package/package.json

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

@@ -1267,26 +1267,15 @@ def _reload_launch_agents_after_bump() -> dict:
             if not plist.is_file():
                 result["skipped_missing"] += 1
                 continue
-            # launchctl bootout / bootstrap is the modern API but requires
-            # the GUI session id ($UID/Background or gui/$UID). The legacy
-            # unload + load -w pair still works on every macOS NEXO supports
-            # and does not need a session id, so we use it here.
-            unload_proc = subprocess.run(
-                ["launchctl", "unload", str(plist)],
-                capture_output=True, text=True, timeout=10,
-            )
-            # unload returns non-zero if the agent was not loaded — that
-            # is fine, we still try to load fresh.
-            load_proc = subprocess.run(
-                ["launchctl", "load", "-w", str(plist)],
-                capture_output=True, text=True, timeout=10,
-            )
-            if load_proc.returncode == 0:
+            from runtime_power import reload_launchagent_plist
+
+            reload_result = reload_launchagent_plist(plist)
+            if reload_result.get("ok"):
                 result["reloaded"] += 1
             else:
                 result["errors"].append({
                     "plist": plist.name,
-                    "stderr": (load_proc.stderr or load_proc.stdout or "load failed")[:300],
+                    "stderr": str(reload_result.get("error") or "reload failed")[:300],
                 })
         except subprocess.TimeoutExpired:
             result["errors"].append({"plist": plist.name, "stderr": "launchctl timeout"})

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/crons/sync.py

@@ -34,7 +34,11 @@ if str(_runtime_root) not in sys.path:
 import paths
 from cron_recovery import is_cron_enabled, resolve_declared_schedule, should_run_at_load
 try:
-    from runtime_power import resolve_launchagent_path
+    from runtime_power import (
+        reload_launchagent_plist,
+        resolve_launchagent_path,
+        unload_launchagent_plist,
+    )
 except ImportError:
     def resolve_launchagent_path() -> str:
         """Fallback when runtime_power is not importable."""
@@ -58,6 +62,17 @@ except ImportError:
                     break
         return ":".join(parts)
 
+    def reload_launchagent_plist(plist_path: Path, label: str | None = None, timeout: int = 10) -> dict:
+        subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+        proc = subprocess.run(["launchctl", "load", "-w", str(plist_path)], capture_output=True, text=True, timeout=timeout)
+        if proc.returncode == 0:
+            return {"ok": True, "label": label or Path(plist_path).stem}
+        return {"ok": False, "label": label or Path(plist_path).stem, "error": proc.stderr or proc.stdout or "load failed"}
+
+    def unload_launchagent_plist(plist_path: Path, label: str | None = None, timeout: int = 10) -> dict:
+        proc = subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True, text=True, timeout=timeout)
+        return {"ok": proc.returncode == 0, "label": label or Path(plist_path).stem}
+
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 SOURCE_ROOT = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent.parent)))
 RUNTIME_ROOT = NEXO_HOME
@@ -437,14 +452,14 @@ def install_plist(label: str, plist: dict, plist_path: Path, dry_run: bool):
         log(f"  DRY-RUN: would install {plist_path.name}")
         return
 
-    # Unload if already loaded
-    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
-
     with open(plist_path, "wb") as f:
         plistlib.dump(plist, f)
 
-    subprocess.run(["launchctl", "load", str(plist_path)], capture_output=True)
-    log(f"  Installed + loaded: {plist_path.name}")
+    result = reload_launchagent_plist(plist_path, label=label)
+    if result.get("ok"):
+        log(f"  Installed + loaded: {plist_path.name}")
+    else:
+        log(f"  Installed but launchctl reload failed: {plist_path.name}: {result.get('error') or 'unknown error'}")
 
 
 def unload_plist(plist_path: Path, dry_run: bool):
@@ -453,7 +468,7 @@ def unload_plist(plist_path: Path, dry_run: bool):
         log(f"  DRY-RUN: would remove {plist_path.name}")
         return
 
-    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+    unload_launchagent_plist(plist_path)
     plist_path.unlink(missing_ok=True)
     log(f"  Removed: {plist_path.name}")
 

package/src/doctor/providers/runtime.py

@@ -32,6 +32,7 @@ from claude_cli import (
 )
 from cron_recovery import is_cron_enabled, resolve_declared_schedule, should_run_at_load
 from doctor.models import DoctorCheck, safe_check
+from runtime_power import reload_launchagent_plist
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parents[2])))
@@ -1080,25 +1081,13 @@ def _recent_permission_denial(cron_id: str, max_age_seconds: int = 7 * 86400) ->
 
 def _repair_launchagents(items: list[tuple[str, Path]]) -> tuple[bool, list[str]]:
     evidence = []
-    uid = str(os.getuid())
     ok = True
     for cron_id, plist_path in items:
         label = f"com.nexo.{cron_id}"
-        subprocess.run(
-            ["launchctl", "bootout", f"gui/{uid}/{label}"],
-            capture_output=True,
-            text=True,
-            timeout=3,
-        )
-        result = subprocess.run(
-            ["launchctl", "bootstrap", f"gui/{uid}", str(plist_path)],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-        if result.returncode != 0:
+        result = reload_launchagent_plist(plist_path, label=label, timeout=5)
+        if not result.get("ok"):
             ok = False
-            evidence.append(f"{label}: {result.stderr.strip() or result.stdout.strip() or 'bootstrap failed'}")
+            evidence.append(f"{label}: {result.get('error') or result.get('bootstrap_error') or 'reload failed'}")
     return ok, evidence
 
 

package/src/lifecycle_events.py

@@ -260,6 +260,138 @@ 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:
+        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 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 = {}
+
+    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/plugins/update.py

@@ -1043,25 +1043,16 @@ def _reload_launch_agents_after_bump() -> dict:
             if not plist.is_file():
                 result["skipped_missing"] += 1
                 continue
-            subprocess.run(
-                ["launchctl", "unload", str(plist)],
-                capture_output=True,
-                text=True,
-                timeout=10,
-            )
-            load_proc = subprocess.run(
-                ["launchctl", "load", "-w", str(plist)],
-                capture_output=True,
-                text=True,
-                timeout=10,
-            )
-            if load_proc.returncode == 0:
+            from runtime_power import reload_launchagent_plist
+
+            reload_result = reload_launchagent_plist(plist)
+            if reload_result.get("ok"):
                 result["reloaded"] += 1
             else:
                 result["errors"].append(
                     {
                         "plist": plist.name,
-                        "stderr": (load_proc.stderr or load_proc.stdout or "load failed")[:300],
+                        "stderr": str(reload_result.get("error") or "reload failed")[:300],
                     }
                 )
         except subprocess.TimeoutExpired:

package/src/runtime_power.py

@@ -17,9 +17,11 @@ import json
 import os
 import paths
 import platform
+import plistlib
 import shutil
 import subprocess
 import sys
+import time
 from pathlib import Path
 
 
@@ -101,6 +103,163 @@ def resolve_launchagent_path() -> str:
     return ":".join(parts)
 
 
+def launchagent_label_from_plist(plist_path: Path, label: str | None = None) -> str:
+    """Resolve a launchd label from a plist, falling back to the filename."""
+    if label:
+        return label
+    try:
+        with Path(plist_path).open("rb") as fh:
+            payload = plistlib.load(fh)
+        plist_label = payload.get("Label")
+        if plist_label:
+            return str(plist_label)
+    except Exception:
+        pass
+    name = Path(plist_path).stem
+    return name
+
+
+def _launchctl_text(proc: subprocess.CompletedProcess) -> str:
+    return (proc.stderr or proc.stdout or "").strip()
+
+
+def _launchctl_print(label: str, timeout: int = 5) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        ["launchctl", "print", f"gui/{os.getuid()}/{label}"],
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+
+
+def launchagent_loaded_from_plist(plist_path: Path, label: str | None = None) -> bool:
+    """Return True when launchd has the label loaded from this exact plist."""
+    plist_path = Path(plist_path)
+    resolved_label = launchagent_label_from_plist(plist_path, label)
+    try:
+        proc = _launchctl_print(resolved_label)
+    except Exception:
+        return False
+    if proc.returncode != 0:
+        return False
+    stdout = proc.stdout or ""
+    candidates = {
+        str(plist_path),
+        str(plist_path.expanduser()),
+        str(plist_path.resolve(strict=False)),
+    }
+    return any(f"path = {candidate}" in stdout or candidate in stdout for candidate in candidates)
+
+
+def unload_launchagent_plist(
+    plist_path: Path,
+    label: str | None = None,
+    timeout: int = 10,
+    wait_seconds: float = 0.25,
+) -> dict:
+    """Best-effort unload using modern and legacy launchctl forms.
+
+    macOS can report a generic bootstrap error when a job is still loaded.
+    We therefore boot out by label, boot out by plist path, and finally call
+    the legacy unload form for older installs.
+    """
+    plist_path = Path(plist_path)
+    resolved_label = launchagent_label_from_plist(plist_path, label)
+    domain = f"gui/{os.getuid()}"
+    commands = [
+        ["launchctl", "bootout", f"{domain}/{resolved_label}"],
+        ["launchctl", "bootout", domain, str(plist_path)],
+        ["launchctl", "unload", str(plist_path)],
+    ]
+    evidence: list[str] = []
+    for command in commands:
+        try:
+            proc = subprocess.run(command, capture_output=True, text=True, timeout=timeout)
+            if proc.returncode != 0:
+                text = _launchctl_text(proc)
+                if text:
+                    evidence.append(text[:300])
+        except subprocess.TimeoutExpired:
+            evidence.append("launchctl timeout")
+        except Exception as exc:
+            evidence.append(str(exc)[:300])
+
+    deadline = time.monotonic() + max(0.0, wait_seconds)
+    while time.monotonic() < deadline:
+        if not launchagent_loaded_from_plist(plist_path, resolved_label):
+            return {"ok": True, "label": resolved_label, "errors": evidence}
+        time.sleep(0.05)
+
+    still_loaded = launchagent_loaded_from_plist(plist_path, resolved_label)
+    return {"ok": not still_loaded, "label": resolved_label, "errors": evidence}
+
+
+def reload_launchagent_plist(
+    plist_path: Path,
+    label: str | None = None,
+    timeout: int = 10,
+) -> dict:
+    """Reload one LaunchAgent and tolerate already-loaded launchd races."""
+    plist_path = Path(plist_path)
+    resolved_label = launchagent_label_from_plist(plist_path, label)
+    if not plist_path.is_file():
+        return {"ok": False, "label": resolved_label, "error": "plist missing"}
+
+    unload_launchagent_plist(plist_path, resolved_label, timeout=timeout)
+    domain = f"gui/{os.getuid()}"
+    try:
+        bootstrap = subprocess.run(
+            ["launchctl", "bootstrap", domain, str(plist_path)],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        return {"ok": False, "label": resolved_label, "error": "launchctl timeout"}
+    except Exception as exc:
+        return {"ok": False, "label": resolved_label, "error": str(exc)[:300]}
+
+    if bootstrap.returncode == 0:
+        return {"ok": True, "label": resolved_label, "action": "bootstrap"}
+
+    bootstrap_error = _launchctl_text(bootstrap) or "bootstrap failed"
+    if launchagent_loaded_from_plist(plist_path, resolved_label):
+        return {
+            "ok": True,
+            "label": resolved_label,
+            "action": "already-loaded",
+            "warning": bootstrap_error[:300],
+        }
+
+    try:
+        fallback = subprocess.run(
+            ["launchctl", "load", "-w", str(plist_path)],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        return {"ok": False, "label": resolved_label, "error": "launchctl timeout"}
+    except Exception as exc:
+        return {"ok": False, "label": resolved_label, "error": str(exc)[:300]}
+
+    if fallback.returncode == 0 or launchagent_loaded_from_plist(plist_path, resolved_label):
+        return {
+            "ok": True,
+            "label": resolved_label,
+            "action": "legacy-load",
+            "warning": bootstrap_error[:300],
+        }
+
+    fallback_error = _launchctl_text(fallback) or "load failed"
+    return {
+        "ok": False,
+        "label": resolved_label,
+        "error": fallback_error[:300],
+        "bootstrap_error": bootstrap_error[:300],
+    }
+
+
 def _schedule_defaults() -> dict:
     return {
         "timezone": "UTC",

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",