nexo-brain 7.9.5 → 7.9.7

package/src/db/_schema.py

@@ -1393,6 +1393,37 @@ def _m52_lifecycle_canonical_plan(conn):
     _migrate_add_index(conn, "idx_lifecycle_events_plan_id", "lifecycle_events", "canonical_plan_id")
 
 
+def _m53_session_conversation_identity(conn):
+    """Stable Desktop conversation identity independent from the runtime SID."""
+    _migrate_add_column(conn, "sessions", "conversation_id", "TEXT DEFAULT ''")
+    _migrate_add_index(conn, "idx_sessions_conversation_id", "sessions", "conversation_id")
+
+
+def _m54_continuity_snapshots(conn):
+    """Durable continuity snapshots for Desktop/Brain handoff and audit."""
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS continuity_snapshots (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            conversation_id TEXT NOT NULL,
+            session_id TEXT DEFAULT '',
+            external_session_id TEXT DEFAULT '',
+            client TEXT DEFAULT '',
+            event_type TEXT NOT NULL DEFAULT 'turn_end',
+            payload_json TEXT NOT NULL DEFAULT '{}',
+            trace_id TEXT DEFAULT '',
+            idempotency_key TEXT NOT NULL DEFAULT '',
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now')),
+            UNIQUE(conversation_id, idempotency_key)
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_continuity_snapshots_conv", "continuity_snapshots", "conversation_id")
+    _migrate_add_index(conn, "idx_continuity_snapshots_sid", "continuity_snapshots", "session_id")
+    _migrate_add_index(conn, "idx_continuity_snapshots_created", "continuity_snapshots", "created_at")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -1446,6 +1477,8 @@ MIGRATIONS = [
     (50, "dedupe_nexo_product_learning_pair", _m50_dedupe_nexo_product_learning_pair),
     (51, "lifecycle_events", _m51_lifecycle_events),
     (52, "lifecycle_canonical_plan", _m52_lifecycle_canonical_plan),
+    (53, "session_conversation_identity", _m53_session_conversation_identity),
+    (54, "continuity_snapshots", _m54_continuity_snapshots),
 ]
 
 

package/src/db/_sessions.py

@@ -41,6 +41,7 @@ def register_session(
     *,
     external_session_id: str = "",
     session_client: str = "",
+    conversation_id: str = "",
 ) -> dict:
     """Register or re-register a session."""
     sid = _validate_sid(sid)
@@ -48,12 +49,28 @@ def register_session(
     now = now_epoch()
     linked_session_id = (external_session_id or claude_session_id or "").strip()
     conn.execute(
-        "INSERT OR REPLACE INTO sessions (sid, task, started_epoch, last_update_epoch, local_time, claude_session_id, external_session_id, session_client) "
-        "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-        (sid, task, now, now, local_time_str(), linked_session_id, linked_session_id, (session_client or "").strip())
+        "INSERT OR REPLACE INTO sessions (sid, task, started_epoch, last_update_epoch, local_time, claude_session_id, external_session_id, session_client, conversation_id) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (
+            sid,
+            task,
+            now,
+            now,
+            local_time_str(),
+            linked_session_id,
+            linked_session_id,
+            (session_client or "").strip(),
+            (conversation_id or "").strip(),
+        )
     )
     conn.commit()
-    return {"sid": sid, "task": task, "external_session_id": linked_session_id, "session_client": (session_client or "").strip()}
+    return {
+        "sid": sid,
+        "task": task,
+        "external_session_id": linked_session_id,
+        "session_client": (session_client or "").strip(),
+        "conversation_id": (conversation_id or "").strip(),
+    }
 
 
 def update_session(sid: str, task: str | None) -> dict:
@@ -99,7 +116,7 @@ def get_active_sessions() -> list[dict]:
     conn = get_db()
     cutoff = now_epoch() - SESSION_STALE_SECONDS
     rows = conn.execute(
-        "SELECT sid, task, started_epoch, last_update_epoch, local_time "
+        "SELECT sid, task, started_epoch, last_update_epoch, local_time, conversation_id "
         "FROM sessions WHERE last_update_epoch > ?",
         (cutoff,)
     ).fetchall()
@@ -232,7 +249,7 @@ def search_sessions(keyword: str) -> list[dict]:
     conn = get_db()
     cutoff = now_epoch() - SESSION_STALE_SECONDS
     rows = conn.execute(
-        "SELECT sid, task, last_update_epoch, local_time FROM sessions "
+        "SELECT sid, task, last_update_epoch, local_time, conversation_id FROM sessions "
         "WHERE last_update_epoch > ? AND LOWER(task) LIKE ?",
         (cutoff, f"%{keyword.lower()}%")
     ).fetchall()
@@ -431,4 +448,3 @@ def _expire_old_questions(conn: sqlite3.Connection):
         "WHERE status = 'pending' AND created_epoch < ?",
         (cutoff,)
     )
-

package/src/lifecycle_events.py

@@ -75,6 +75,7 @@ TERMINAL_STATUSES = {
     "rejected",
 }
 _DIARY_TRIGGERING = lifecycle_prompts.DIARY_TRIGGERING_ACTIONS
+SESSION_NOT_LINKED_REASON = "session-not-linked-to-nexo"
 
 
 def _normalise_payload(obj: Any) -> str:
@@ -125,6 +126,34 @@ def _session_diary_session_ids(conn, session_id: str) -> List[str]:
     return deduped
 
 
+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()
+    if not raw:
+        return False
+    if raw.startswith("nexo-"):
+        return True
+    try:
+        row = conn.execute(
+            "SELECT 1 FROM session_claude_aliases WHERE claude_session_id = ? LIMIT 1",
+            (raw,),
+        ).fetchone()
+        if row is not None:
+            return True
+    except Exception:
+        pass
+    try:
+        row = conn.execute(
+            "SELECT 1 FROM sessions "
+            "WHERE external_session_id = ? OR claude_session_id = ? "
+            "LIMIT 1",
+            (raw, raw),
+        ).fetchone()
+        return row is not None
+    except Exception:
+        return False
+
+
 def _max_session_diary_id(conn, session_id: str) -> int:
     session_ids = _session_diary_session_ids(conn, session_id)
     if not session_ids:
@@ -510,10 +539,14 @@ def record_complete_canonical(
     )
     diary_evidence = _session_diary_evidence(conn, session_id, dispatched_at, actions_json)
     diary_required = action in _DIARY_TRIGGERING and bool(session_id)
+    session_registered = _session_is_linked_to_nexo(conn, session_id) if diary_required else bool(session_id)
+    session_unregistered = diary_required and not session_registered
     diary_missing = diary_required and diary_evidence is None
     effective = "retryable_error" if (any_failure or diary_missing) else "canonical_done"
     last_error = None
-    if any_failure:
+    if session_unregistered:
+        last_error = SESSION_NOT_LINKED_REASON
+    elif any_failure:
         last_error = "one-or-more-actions-failed"
     elif diary_missing:
         last_error = "canonical-diary-not-confirmed"
@@ -540,8 +573,9 @@ def record_complete_canonical(
         "failed_actions": any_failure,
         "diary_confirmed": diary_evidence is not None,
         "diary_required": diary_required,
+        "session_registered": session_registered,
         "session_diary_id": diary_evidence.get("session_diary_id") if diary_evidence else None,
-        "reason": "canonical-diary-not-confirmed" if diary_missing else None,
+        "reason": last_error if effective == "retryable_error" else None,
     }
 
 
@@ -570,6 +604,15 @@ def wait_for_canonical_diary(
         session_id = str(row[0] or "")
         if not session_id:
             return {"status": "rejected", "reason": "missing-session-id", "event_id": event_id}
+        if not _session_is_linked_to_nexo(conn, session_id):
+            return {
+                "status": "retryable_error",
+                "event_id": event_id,
+                "session_id": session_id,
+                "diary_confirmed": False,
+                "session_registered": False,
+                "reason": SESSION_NOT_LINKED_REASON,
+            }
         evidence = _session_diary_evidence(conn, session_id, row[1], row[2])
         if evidence is not None:
             return {
@@ -577,6 +620,7 @@ def wait_for_canonical_diary(
                 "event_id": event_id,
                 "session_id": session_id,
                 "diary_confirmed": True,
+                "session_registered": True,
                 **evidence,
             }
         if time.monotonic() >= deadline:
@@ -585,6 +629,7 @@ def wait_for_canonical_diary(
                 "event_id": event_id,
                 "session_id": session_id,
                 "diary_confirmed": False,
+                "session_registered": True,
                 "reason": last_error or "diary-confirm-timeout",
             }
         time.sleep(min(poll_s, max(0.0, deadline - time.monotonic())))

package/src/paths.py

@@ -70,7 +70,30 @@ def home() -> Path:
 # Core (shipped with the package, replaced on every `nexo update`)
 # ---------------------------------------------------------------------------
 def core_dir() -> Path:
-    return home() / "core"
+    container = home() / "core"
+    live_markers = (
+        "cli.py",
+        "server.py",
+        "db",
+        "hooks",
+        "plugins",
+        "rules",
+        "scripts",
+        "package.json",
+        "version.json",
+    )
+    if any((container / marker).exists() for marker in live_markers):
+        return container
+    current = container / "current"
+    if current.exists():
+        try:
+            resolved = current.resolve(strict=False)
+            if resolved.exists():
+                return resolved
+        except Exception:
+            return current
+        return current
+    return container
 
 
 def core_scripts_dir() -> Path:

package/src/plugin_loader.py

@@ -290,7 +290,13 @@ def load_plugin(mcp, filename: str, plugins_dir: str | None = None) -> int:
             mcp.local_provider.remove_tool(name)
         except Exception:
             pass
-        t = Tool.from_function(func, name=name, description=description)
+        # output_schema=None disables FastMCP's auto-generated
+        # `x-fastmcp-wrap-result` wrapper that otherwise makes str-returning
+        # plugin tools unexecutable in Claude Code. See server.py and
+        # followup NF-FASTMCP-OUTPUT-SCHEMA-1776969764.
+        t = Tool.from_function(
+            func, name=name, description=description, output_schema=None
+        )
         mcp.add_tool(t)
         tool_names.append(name)
 

package/src/plugins/update.py

@@ -12,6 +12,7 @@ import time
 from pathlib import Path
 
 from runtime_home import export_resolved_nexo_home
+from runtime_versioning import activate_versioned_runtime_snapshot, write_restart_required_marker
 
 try:
     from tree_hygiene import is_duplicate_artifact_name
@@ -1228,6 +1229,25 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
         except Exception as e:
             launchagent_reload_warning = f"launchagent reload error: {e}"
 
+    versioned_runtime_summary = None
+    restart_marker_summary = None
+    if old_version != new_version:
+        try:
+            _emit_progress(progress_fn, "Activating versioned runtime snapshot...")
+            versioned_runtime_summary = activate_versioned_runtime_snapshot(
+                source_root=_runtime_code_root(),
+                version=new_version,
+            )
+        except Exception as e:
+            errors.append(f"versioned runtime activation: {e}")
+        try:
+            restart_marker_summary = write_restart_required_marker(
+                from_version=old_version,
+                to_version=new_version,
+            )
+        except Exception as e:
+            errors.append(f"restart marker: {e}")
+
     if errors:
         # 5. Full rollback: restore code tree + DBs + pip deps + rollback npm package
         if code_backup_dir:
@@ -1289,6 +1309,10 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
             )
         else:
             lines.append(f"  WARNING: launchagent reload: {launchagent_reload_warning}")
+    if versioned_runtime_summary and versioned_runtime_summary.get("ok"):
+        lines.append(f"  Runtime activation: core/current -> versions/{new_version}")
+    if restart_marker_summary:
+        lines.append(f"  Restart marker: {restart_marker_summary.get('path')}")
     lines.append("")
     lines.append("MCP server restart needed to load new code.")
     return "\n".join(lines)
@@ -1499,6 +1523,27 @@ def handle_update(
         except Exception:
             pass  # Non-critical, configs can be re-synced later
 
+        versioned_runtime_summary = None
+        restart_marker_summary = None
+        if version_changed:
+            try:
+                _emit_progress(progress_fn, "Activating versioned runtime snapshot...")
+                versioned_runtime_summary = activate_versioned_runtime_snapshot(
+                    source_root=SRC_DIR,
+                    version=new_version,
+                )
+                steps_done.append("versioned-runtime")
+            except Exception as e:
+                raise RuntimeError(f"Versioned runtime activation failed: {e}")
+            try:
+                restart_marker_summary = write_restart_required_marker(
+                    from_version=old_version,
+                    to_version=new_version,
+                )
+                steps_done.append("restart-marker")
+            except Exception as e:
+                raise RuntimeError(f"Restart marker write failed: {e}")
+
         # Build result
         dep_summary_lines = _format_dep_results(dep_results)
         if pull_out == "Already up to date.":
@@ -1529,6 +1574,10 @@ def handle_update(
         lines.extend(external_cli_lines)
         if "client-sync" in steps_done:
             lines.append("  Clients: configured client targets synced")
+        if versioned_runtime_summary and versioned_runtime_summary.get("ok"):
+            lines.append(f"  Runtime activation: core/current -> versions/{new_version}")
+        if restart_marker_summary:
+            lines.append(f"  Restart marker: {restart_marker_summary.get('path')}")
         lines.append("")
         lines.append("MCP server restart needed to load new code.")
         return "\n".join(lines)