nexo-brain 7.25.6 → 7.26.0

package/src/scripts/nexo-cron-wrapper.sh

@@ -45,21 +45,71 @@ from datetime import datetime, timezone
 print(datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"))
 PY
 )
+RUNTIME_META=$(python3 - "$NEXO_HOME" <<'PY' 2>/dev/null || true
+from __future__ import annotations
+import json
+import sys
+from pathlib import Path
+
+nexo_home = Path(sys.argv[1]).expanduser()
+schedule = {}
+for candidate in (
+    nexo_home / "personal" / "config" / "schedule.json",
+    nexo_home / "config" / "schedule.json",
+):
+    try:
+        schedule = json.loads(candidate.read_text(encoding="utf-8"))
+        break
+    except Exception:
+        continue
+
+provider_runtime = schedule.get("provider_runtime") if isinstance(schedule.get("provider_runtime"), dict) else {}
+backend = str(provider_runtime.get("automation_backend") or schedule.get("automation_backend") or "claude_code").strip().lower()
+provider = str(provider_runtime.get("automation_provider") or "").strip().lower()
+if provider not in {"anthropic", "openai", "none"}:
+    provider = {"claude_code": "anthropic", "codex": "openai", "none": "none"}.get(backend, "")
+snapshot = {
+    "selected_chat_provider": provider_runtime.get("selected_chat_provider") or "",
+    "automation_provider": provider,
+    "automation_backend": backend,
+    "fallback_policy": provider_runtime.get("fallback_policy") or {"automation": "fail_closed"},
+}
+print(provider + "\t" + backend + "\t" + json.dumps(snapshot, ensure_ascii=False, separators=(",", ":")))
+PY
+)
+if [ -n "$RUNTIME_META" ]; then
+    IFS=$'\t' read -r CRON_PROVIDER CRON_BACKEND RUNTIME_SNAPSHOT <<< "$RUNTIME_META"
+else
+    CRON_PROVIDER=""
+    CRON_BACKEND=""
+    RUNTIME_SNAPSHOT="{}"
+fi
 
 # Phase 1: INSERT row at start (ended_at NULL = "running").
 # ROW_ID empty on DB failure; spool-fallback at the end handles that.
 ROW_ID=""
-ROW_ID=$(python3 - "$DB" "$CRON_ID" "$STARTED_AT" <<'PY' 2>/dev/null
+ROW_ID=$(python3 - "$DB" "$CRON_ID" "$STARTED_AT" "$CRON_PROVIDER" "$CRON_BACKEND" "$RUNTIME_SNAPSHOT" <<'PY' 2>/dev/null
 from __future__ import annotations
 import sqlite3
 import sys
-db_path, cron_id, started_at = sys.argv[1:]
+db_path, cron_id, started_at, provider, backend, runtime_snapshot = sys.argv[1:]
 conn = sqlite3.connect(db_path)
 try:
-    cur = conn.execute(
-        "INSERT INTO cron_runs (cron_id, started_at, ended_at) VALUES (?, ?, NULL)",
-        (cron_id, started_at),
-    )
+    try:
+        cur = conn.execute(
+            """
+            INSERT INTO cron_runs (cron_id, started_at, ended_at, provider, backend, runtime_snapshot)
+            VALUES (?, ?, NULL, ?, ?, ?)
+            """,
+            (cron_id, started_at, provider, backend, runtime_snapshot or "{}"),
+        )
+    except sqlite3.OperationalError as exc:
+        if "provider" not in str(exc) and "backend" not in str(exc) and "runtime_snapshot" not in str(exc):
+            raise
+        cur = conn.execute(
+            "INSERT INTO cron_runs (cron_id, started_at, ended_at) VALUES (?, ?, NULL)",
+            (cron_id, started_at),
+        )
     conn.commit()
     print(cur.lastrowid)
 finally:
@@ -97,30 +147,60 @@ PY
     fi
 
     # Update the row we inserted at start — or INSERT fresh if the start write failed.
-    if ! python3 - "$DB" "$ROW_ID" "$CRON_ID" "$STARTED_AT" "$ended_at" "$EXIT_CODE" "$summary" "$error" "$duration" <<'PY' 2>/dev/null
+    if ! python3 - "$DB" "$ROW_ID" "$CRON_ID" "$STARTED_AT" "$ended_at" "$EXIT_CODE" "$summary" "$error" "$duration" "$CRON_PROVIDER" "$CRON_BACKEND" "$RUNTIME_SNAPSHOT" <<'PY' 2>/dev/null
 from __future__ import annotations
 import sqlite3
 import sys
-db_path, row_id, cron_id, started_at, ended_at, exit_code, summary, error, duration_secs = sys.argv[1:]
+db_path, row_id, cron_id, started_at, ended_at, exit_code, summary, error, duration_secs, provider, backend, runtime_snapshot = sys.argv[1:]
 conn = sqlite3.connect(db_path)
 try:
     if row_id:
-        conn.execute(
-            """
-            UPDATE cron_runs
-               SET ended_at=?, exit_code=?, summary=?, error=?, duration_secs=?
-             WHERE id=?
-            """,
-            (ended_at, int(exit_code), summary, error, float(duration_secs), int(row_id)),
-        )
+        try:
+            conn.execute(
+                """
+                UPDATE cron_runs
+                   SET ended_at=?, exit_code=?, summary=?, error=?, duration_secs=?,
+                       provider=COALESCE(NULLIF(provider, ''), ?),
+                       backend=COALESCE(NULLIF(backend, ''), ?),
+                       runtime_snapshot=CASE
+                           WHEN runtime_snapshot IS NULL OR runtime_snapshot = '' OR runtime_snapshot = '{}'
+                           THEN ?
+                           ELSE runtime_snapshot
+                       END
+                 WHERE id=?
+                """,
+                (ended_at, int(exit_code), summary, error, float(duration_secs), provider, backend, runtime_snapshot or "{}", int(row_id)),
+            )
+        except sqlite3.OperationalError as exc:
+            if "provider" not in str(exc) and "backend" not in str(exc) and "runtime_snapshot" not in str(exc):
+                raise
+            conn.execute(
+                """
+                UPDATE cron_runs
+                   SET ended_at=?, exit_code=?, summary=?, error=?, duration_secs=?
+                 WHERE id=?
+                """,
+                (ended_at, int(exit_code), summary, error, float(duration_secs), int(row_id)),
+            )
     else:
-        conn.execute(
-            """
-            INSERT INTO cron_runs (cron_id, started_at, ended_at, exit_code, summary, error, duration_secs)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-            """,
-            (cron_id, started_at, ended_at, int(exit_code), summary, error, float(duration_secs)),
-        )
+        try:
+            conn.execute(
+                """
+                INSERT INTO cron_runs (cron_id, started_at, ended_at, exit_code, summary, error, duration_secs, provider, backend, runtime_snapshot)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (cron_id, started_at, ended_at, int(exit_code), summary, error, float(duration_secs), provider, backend, runtime_snapshot or "{}"),
+            )
+        except sqlite3.OperationalError as exc:
+            if "provider" not in str(exc) and "backend" not in str(exc) and "runtime_snapshot" not in str(exc):
+                raise
+            conn.execute(
+                """
+                INSERT INTO cron_runs (cron_id, started_at, ended_at, exit_code, summary, error, duration_secs)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                """,
+                (cron_id, started_at, ended_at, int(exit_code), summary, error, float(duration_secs)),
+            )
     conn.commit()
 finally:
     conn.close()
@@ -128,12 +208,12 @@ PY
     then
         mkdir -p "$SPOOL_DIR"
         local spool_file="$SPOOL_DIR/${CRON_ID}-$(date +%Y%m%d-%H%M%S)-$$.json"
-        python3 - "$spool_file" "$CRON_ID" "$STARTED_AT" "$ended_at" "$EXIT_CODE" "$summary" "$error" "$duration" <<'PY'
+        python3 - "$spool_file" "$CRON_ID" "$STARTED_AT" "$ended_at" "$EXIT_CODE" "$summary" "$error" "$duration" "$CRON_PROVIDER" "$CRON_BACKEND" "$RUNTIME_SNAPSHOT" <<'PY'
 from __future__ import annotations
 import json
 import sys
 from pathlib import Path
-spool_file, cron_id, started_at, ended_at, exit_code, summary, error, duration_secs = sys.argv[1:]
+spool_file, cron_id, started_at, ended_at, exit_code, summary, error, duration_secs, provider, backend, runtime_snapshot = sys.argv[1:]
 Path(spool_file).write_text(
     json.dumps({
         "cron_id": cron_id,
@@ -143,6 +223,9 @@ Path(spool_file).write_text(
         "summary": summary,
         "error": error,
         "duration_secs": float(duration_secs),
+        "provider": provider,
+        "backend": backend,
+        "runtime_snapshot": runtime_snapshot or "{}",
     }, indent=2, ensure_ascii=False) + "\n",
     encoding="utf-8",
 )

package/src/scripts/nexo-morning-agent.py

@@ -569,7 +569,7 @@ def generate_briefing(prompt: str) -> tuple[str, str]:
         output_format="json",
         append_system_prompt=render_core_prompt("morning-agent-json-output"),
         allowed_tools="Read,Glob,Grep",
-        bare_mode=True,
+        bare_mode=False,
     )
     if result.returncode != 0:
         detail = (result.stderr or result.stdout or "").strip()

package/src/server.py

@@ -440,7 +440,7 @@ def _run_kwargs_from_env() -> dict:
 # ── Session management (3 tools) ──────────────────────────────────
 
 @mcp.tool
-def nexo_startup(task: str = "Startup", claude_session_id: str = "", session_token: str = "", session_client: str = "", conversation_id: str = "") -> str:
+def nexo_startup(task: str = "Startup", claude_session_id: str = "", session_token: str = "", session_client: str = "", session_provider: str = "", conversation_id: str = "") -> str:
     """Register new session, clean stale ones, return active sessions + alerts.
 
     Call this ONCE at the start of every conversation.
@@ -453,6 +453,7 @@ def nexo_startup(task: str = "Startup", claude_session_id: str = "", session_tok
                       other clients may pass a synthetic durable token when useful.
                       Pass this to enable automatic inter-terminal inbox detection when available.
         session_client: Optional client label such as `claude_code` or `codex`.
+        session_provider: Optional provider label such as `anthropic` or `openai`.
         conversation_id: Stable client-side conversation identifier when available.
     """
     return handle_startup(
@@ -460,6 +461,7 @@ def nexo_startup(task: str = "Startup", claude_session_id: str = "", session_tok
         claude_session_id=claude_session_id,
         session_token=session_token,
         session_client=session_client,
+        session_provider=session_provider,
         conversation_id=conversation_id,
     )
 

package/src/tools_automation_sessions.py

@@ -84,11 +84,12 @@ def handle_session_log_create(payload: dict | None = None, **kwargs) -> dict:
         except Exception:
             resonance_tier = ""
 
-    from agent_runner import _record_automation_start
+    from agent_runner import _automation_provider_for_backend, _record_automation_start
 
     row_id, err = _record_automation_start(
         caller=caller,
         backend=backend,
+        provider=_automation_provider_for_backend(backend),
         session_type=session_type,
         task_profile="",
         model=model,

package/src/tools_sessions.py

@@ -12,6 +12,7 @@ import threading
 from datetime import datetime, timezone
 from pathlib import Path
 from core_prompts import render_core_prompt
+from client_preferences import client_to_provider, normalize_provider_key
 from db import (
     register_session, update_session, complete_session,
     get_active_sessions, clean_stale_sessions, search_sessions,
@@ -582,6 +583,7 @@ def handle_startup(
     claude_session_id: str = "",
     session_token: str = "",
     session_client: str = "",
+    session_provider: str = "",
     conversation_id: str = "",
 ) -> str:
     """Full startup sequence: register, clean, report.
@@ -593,12 +595,16 @@ def handle_startup(
                       other clients may pass a synthetic durable ID when useful.
                       Enables automatic inbox detection when hook-backed clients provide one.
         session_client: Optional client label such as `claude_code` or `codex`.
+        session_provider: Optional provider label such as `anthropic` or `openai`.
     """
     _set_interactive_db_timeout()
     sid = _generate_sid()
     startup_warnings: list[str] = []
     cleaned = _safe_interactive("stale-session cleanup", clean_stale_sessions, 0, startup_warnings)
     linked_session_id = (session_token or claude_session_id or "").strip()
+    inferred_client = (session_client or "").strip()
+    if not inferred_client and claude_session_id and not session_token:
+        inferred_client = "claude_code"
     # v6.0.7 hotfix: when the caller did not pass an explicit UUID, fall back to
     # the Claude Code SessionStart UUID written by the SessionStart hook to
     # <NEXO_HOME>/coordination/.claude-session-id. This fixes the "unknown
@@ -606,15 +612,13 @@ def handle_startup(
     # nexo_startup() without propagating the hook payload (bug revisited
     # after PR #208 — PR #208 covered the hook side; this covers the
     # startup side so every session row is born correlated).
-    if not linked_session_id:
+    if not linked_session_id and (not inferred_client or inferred_client == "claude_code"):
         linked_session_id = _autodetect_claude_session_id()
-    inferred_client = (session_client or "").strip()
-    if not inferred_client and claude_session_id and not session_token:
-        inferred_client = "claude_code"
     if not inferred_client and linked_session_id:
         # If we recovered the UUID from the coordination file, the only
         # client that writes there is Claude Code.
         inferred_client = "claude_code"
+    inferred_provider = normalize_provider_key(session_provider) or client_to_provider(inferred_client)
     conversation = str(conversation_id or "").strip()
     conflicts = []
     if conversation:
@@ -623,7 +627,7 @@ def handle_startup(
             conn = get_db()
             rows = conn.execute(
                 """
-                SELECT sid, task, last_update_epoch, external_session_id, session_client
+                SELECT sid, task, last_update_epoch, external_session_id, session_client, session_provider
                 FROM sessions
                 WHERE conversation_id = ? AND last_update_epoch > ?
                 ORDER BY last_update_epoch DESC
@@ -638,9 +642,10 @@ def handle_startup(
         lambda: register_session(
             sid,
             task,
-            claude_session_id=linked_session_id,
+            claude_session_id=linked_session_id if inferred_client == "claude_code" else "",
             external_session_id=linked_session_id,
             session_client=inferred_client,
+            session_provider=inferred_provider,
             conversation_id=conversation,
         ),
         None,
@@ -668,7 +673,7 @@ def handle_startup(
     # Backward-compatible: if the alias table does not yet exist (older
     # DB), register_claude_session_alias returns False silently and
     # the legacy sessions.claude_session_id column stays authoritative.
-    if linked_session_id:
+    if linked_session_id and inferred_client == "claude_code":
         try:
             from hook_guardrails import register_claude_session_alias
             from db import get_db as _get_db
@@ -712,7 +717,7 @@ def handle_startup(
             age = _format_age(row["last_update_epoch"])
             lines.append(
                 f"  {row['sid']} ({age}) — {row['task']} "
-                f"[client={row.get('session_client') or '?'} external={row.get('external_session_id') or '?'}]"
+                f"[provider={row.get('session_provider') or '?'} client={row.get('session_client') or '?'} external={row.get('external_session_id') or '?'}]"
             )
 
     if memory_maintenance and not memory_maintenance.get("ok"):