nexo-brain 4.0.1 → 5.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "4.0.1",
+  "version": "5.0.0",
   "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

@@ -87,15 +87,14 @@ Versions `3.1.7` through `3.2.0` close the recent-memory gap:
 - when even that misses, NEXO now exposes raw transcript fallback tools for Claude Code and Codex session stores
 - NEXO can now inspect itself through a live system catalog derived from canonical sources instead of relying only on stale docs or operator memory
 
-Version `4.0.1` keeps the 4.0 release aligned across channels while preserving the next memory-surface gap closure:
+Version `5.0.0` closes the loop between memory, decisions, outcomes, and reusable behavior:
 
-- non-text artifacts now have a first-class multimodal reference layer instead of living outside the memory model
-- pre-compaction auto-flush now persists actionable session state before context compression can erase it
-- the claim graph now behaves like a public knowledge wiki with evidence, freshness, verification state, and linting
-- operators can export a readable markdown memory bundle instead of trusting only opaque database state
-- user adaptation now uses a richer inspectable user-state model instead of leaning only on shallow sentiment heuristics
-- retrieval exposes more public knobs for hybrid weighting, decomposition, dreams, and dormant-memory handling
-- newer memory layers now declare an explicit backend contract rather than silently hardcoding storage assumptions forever
+- goal profiles are now explicit and auditable instead of living as hidden heuristics
+- the Cortex can rank alternatives with goals, outcomes, overrides, and structured penalties
+- repeated outcome patterns can become durable learnings that influence later decisions
+- outcome-backed evidence can seed, promote, demote, or retire reusable skills
+- the runtime benchmark pack now shows the operator/runtime advantage with checked-in artifacts instead of relying only on prose
+- personal-script/core runtime paths, protocol debt maintenance, and release doctoring are now strong enough that the live install path can be audited honestly before release
 
 ### Client Capability Matrix
 
@@ -625,6 +624,8 @@ Scripts in `NEXO_HOME/scripts/` are first-class managed entities:
 
 Personal scripts are completely separate from core NEXO processes. The `crons/manifest.json` defines core; everything in `NEXO_HOME/scripts/` is personal.
 
+If you need to decide between a personal script, skill, plugin, or schedule, use [docs/personal-artifacts-manual.md](docs/personal-artifacts-manual.md). That is the canonical operational guide.
+
 ## Recovery-Aware Background Jobs (v2.6.2)
 
 Core and personal jobs now declare explicit recovery contracts in `crons/manifest.json`:
@@ -835,9 +836,9 @@ nexo doctor --tier runtime --json  # Machine-readable health report
 nexo doctor --fix              # Apply deterministic repairs
 ```
 
-Personal scripts live in `NEXO_HOME/scripts/` with inline metadata. Their Python templates now include `run_automation_text(...)`, which routes work through the configured NEXO automation backend instead of hardcoding `claude -p` or provider-specific model names. `nexo-agent-run.py` now also supports task profiles (`fast`, `balanced`, `deep`) plus safe backend fallback, so automations can prefer cheaper/faster Codex paths or deeper Claude paths without hardcoding one provider forever. See `docs/writing-scripts.md` for details.
+Personal scripts live in `NEXO_HOME/scripts/` with inline metadata. Their Python templates now include `run_automation_text(...)`, which routes work through the configured NEXO automation backend instead of hardcoding `claude -p` or provider-specific model names. `nexo-agent-run.py` now also supports task profiles (`fast`, `balanced`, `deep`) plus safe backend fallback, so automations can prefer cheaper/faster Codex paths or deeper Claude paths without hardcoding one provider forever. See `docs/writing-scripts.md` for details and `docs/personal-artifacts-manual.md` for the canonical artifact decision guide.
 
-Skills v2 combine procedural guides with optional executable scripts. Personal skills live in `NEXO_HOME/skills/`, packaged core skills live in `NEXO_CODE/skills/` during development and `NEXO_HOME/skills-core/` in installed environments, and staged runtime copies live in `NEXO_HOME/skills-runtime/`. Execution is fully autonomous: Deep Sleep can evolve mature guide skills into executable drafts automatically, and runtime execution no longer waits for manual approval. See `docs/skills-v2.md` for the full model.
+Skills v2 combine procedural guides with optional executable scripts. Personal skills live in `NEXO_HOME/skills/`, packaged core skills live in `NEXO_CODE/skills/` during development and `NEXO_HOME/skills-core/` in installed environments, and staged runtime copies live in `NEXO_HOME/skills-runtime/`. Execution is fully autonomous: Deep Sleep can evolve mature guide skills into executable drafts automatically, and runtime execution no longer waits for manual approval. See `docs/skills-v2.md` for the full model and `docs/personal-artifacts-manual.md` for the boundary between skills, scripts, plugins, and schedules.
 
 The Doctor system reads existing health artifacts (immune, watchdog, self-audit) without triggering repairs in default mode.
 
@@ -914,6 +915,8 @@ TOOLS = [
 
 Reload without restarting: `nexo_plugin_load("my_plugin.py")`
 
+Use a personal plugin only when you need a new MCP tool in the runtime surface. If the real need is autonomous execution or scheduling, use a personal script plus managed schedule instead. The canonical decision guide is [docs/personal-artifacts-manual.md](docs/personal-artifacts-manual.md).
+
 ### Data Privacy
 
 - **Everything stays local.** All data in `~/.nexo/`, never uploaded anywhere.

package/bin/nexo-brain.js

@@ -2211,16 +2211,41 @@ async function main() {
     "set -euo pipefail",
     "",
     `NEXO_HOME="${NEXO_HOME}"`,
-    'PYTHON="$NEXO_HOME/.venv/bin/python3"',
-    'if [ ! -x "$PYTHON" ]; then',
-    '  if command -v python3 >/dev/null 2>&1; then',
-    '    PYTHON="python3"',
-    "  else",
-    '    PYTHON="python"',
-    "  fi",
-    "fi",
     'export NEXO_HOME',
-    'export NEXO_CODE="$NEXO_HOME"',
+    'export NEXO_CODE="${NEXO_CODE:-$NEXO_HOME}"',
+    'resolve_python() {',
+    '  local candidates=()',
+    '  local candidate=""',
+    '  if [ -n "${NEXO_RUNTIME_PYTHON:-}" ]; then candidates+=("$NEXO_RUNTIME_PYTHON"); fi',
+    '  if [ -n "${NEXO_PYTHON:-}" ]; then candidates+=("$NEXO_PYTHON"); fi',
+    '  candidates+=("$NEXO_HOME/.venv/bin/python3" "$NEXO_HOME/.venv/bin/python")',
+    '  case "$(uname -s)" in',
+    '    Darwin) candidates+=("/opt/homebrew/bin/python3" "/usr/local/bin/python3") ;;',
+    '    *) candidates+=("/usr/local/bin/python3" "/usr/bin/python3") ;;',
+    '  esac',
+    '  if command -v python3 >/dev/null 2>&1; then candidates+=("$(command -v python3)"); fi',
+    '  if command -v python >/dev/null 2>&1; then candidates+=("$(command -v python)"); fi',
+    '  for candidate in "${candidates[@]}"; do',
+    '    [ -n "$candidate" ] || continue',
+    '    [ -x "$candidate" ] || continue',
+    '    if NEXO_HOME="$NEXO_HOME" NEXO_CODE="$NEXO_CODE" "$candidate" -c "import fastmcp" >/dev/null 2>&1; then',
+    '      printf \'%s\\n\' "$candidate"',
+    '      return 0',
+    '    fi',
+    '  done',
+    '  for candidate in "${candidates[@]}"; do',
+    '    [ -n "$candidate" ] || continue',
+    '    [ -x "$candidate" ] || continue',
+    '    printf \'%s\\n\' "$candidate"',
+    '    return 0',
+    '  done',
+    '  return 1',
+    '}',
+    'PYTHON="$(resolve_python || true)"',
+    'if [ -z "$PYTHON" ]; then',
+    '  echo "NEXO runtime Python not found. Run nexo-brain or nexo update to repair the installation." >&2',
+    '  exit 1',
+    'fi',
     'exec "$PYTHON" "$NEXO_HOME/cli.py" "$@"',
     "",
   ].join("\n");

package/bin/nexo.js

@@ -14,17 +14,44 @@ const path = require("path");
 
 const NEXO_HOME = process.env.NEXO_HOME || path.join(os.homedir(), ".nexo");
 
+function pythonSupportsModule(candidate, moduleName) {
+  if (!candidate) return false;
+  if (candidate.includes("/") && !fs.existsSync(candidate)) return false;
+  try {
+    const result = spawnSync(candidate, ["-c", `import ${moduleName}`], {
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        NEXO_HOME,
+        NEXO_CODE: path.join(__dirname, "..", "src"),
+      },
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
 function findPython() {
   const candidates = [
+    process.env.NEXO_RUNTIME_PYTHON,
+    process.env.NEXO_PYTHON,
     path.join(NEXO_HOME, ".venv", "bin", "python3"),
     path.join(NEXO_HOME, ".venv", "bin", "python"),
+    process.platform === "darwin" ? "/opt/homebrew/bin/python3" : "",
+    "/usr/local/bin/python3",
+    "/usr/bin/python3",
     "python3",
     "python",
   ];
+  let fallback = "";
   for (const c of candidates) {
-    if (c.includes("/") ? fs.existsSync(c) : true) return c;
+    if (!c) continue;
+    if (!(c.includes("/") ? fs.existsSync(c) : true)) continue;
+    if (!fallback) fallback = c;
+    if (pythonSupportsModule(c, "fastmcp")) return c;
   }
-  return "python3";
+  return fallback || "python3";
 }
 
 function findCliPy() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "4.0.1",
+  "version": "5.0.0",
   "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

@@ -11,6 +11,7 @@ import json
 import hashlib
 import os
 import re
+import shutil
 import subprocess
 import sys
 import time
@@ -148,16 +149,41 @@ def _runtime_cli_wrapper_text() -> str:
         "#!/usr/bin/env bash\n"
         "set -euo pipefail\n\n"
         f'NEXO_HOME="{NEXO_HOME}"\n'
-        'PYTHON="$NEXO_HOME/.venv/bin/python3"\n'
-        'if [ ! -x "$PYTHON" ]; then\n'
-        '  if command -v python3 >/dev/null 2>&1; then\n'
-        '    PYTHON="python3"\n'
-        "  else\n"
-        '    PYTHON="python"\n'
-        "  fi\n"
-        "fi\n"
         'export NEXO_HOME\n'
-        'export NEXO_CODE="$NEXO_HOME"\n'
+        'export NEXO_CODE="${NEXO_CODE:-$NEXO_HOME}"\n'
+        'resolve_python() {\n'
+        '  local candidates=()\n'
+        '  local candidate=""\n'
+        '  if [ -n "${NEXO_RUNTIME_PYTHON:-}" ]; then candidates+=("$NEXO_RUNTIME_PYTHON"); fi\n'
+        '  if [ -n "${NEXO_PYTHON:-}" ]; then candidates+=("$NEXO_PYTHON"); fi\n'
+        '  candidates+=("$NEXO_HOME/.venv/bin/python3" "$NEXO_HOME/.venv/bin/python")\n'
+        '  case "$(uname -s)" in\n'
+        '    Darwin) candidates+=("/opt/homebrew/bin/python3" "/usr/local/bin/python3") ;;\n'
+        '    *) candidates+=("/usr/local/bin/python3" "/usr/bin/python3") ;;\n'
+        '  esac\n'
+        '  if command -v python3 >/dev/null 2>&1; then candidates+=("$(command -v python3)"); fi\n'
+        '  if command -v python >/dev/null 2>&1; then candidates+=("$(command -v python)"); fi\n'
+        '  for candidate in "${candidates[@]}"; do\n'
+        '    [ -n "$candidate" ] || continue\n'
+        '    [ -x "$candidate" ] || continue\n'
+        '    if NEXO_HOME="$NEXO_HOME" NEXO_CODE="$NEXO_CODE" "$candidate" -c "import fastmcp" >/dev/null 2>&1; then\n'
+        '      printf \'%s\\n\' "$candidate"\n'
+        '      return 0\n'
+        '    fi\n'
+        '  done\n'
+        '  for candidate in "${candidates[@]}"; do\n'
+        '    [ -n "$candidate" ] || continue\n'
+        '    [ -x "$candidate" ] || continue\n'
+        '    printf \'%s\\n\' "$candidate"\n'
+        '    return 0\n'
+        '  done\n'
+        '  return 1\n'
+        '}\n'
+        'PYTHON="$(resolve_python || true)"\n'
+        'if [ -z "$PYTHON" ]; then\n'
+        '  echo "NEXO runtime Python not found. Run nexo-brain or nexo update to repair the installation." >&2\n'
+        '  exit 1\n'
+        'fi\n'
         'exec "$PYTHON" "$NEXO_HOME/cli.py" "$@"\n'
     )
 
@@ -209,14 +235,50 @@ def _requirements_hash() -> str:
     return ""
 
 
+def _venv_python_path(runtime_root: Path = NEXO_HOME) -> Path:
+    if sys.platform == "win32":
+        return runtime_root / ".venv" / "Scripts" / "python.exe"
+    return runtime_root / ".venv" / "bin" / "python3"
+
+
+def _venv_pip_path(runtime_root: Path = NEXO_HOME) -> Path:
+    if sys.platform == "win32":
+        return runtime_root / ".venv" / "Scripts" / "pip.exe"
+    return runtime_root / ".venv" / "bin" / "pip"
+
+
+def _ensure_runtime_venv(runtime_root: Path = NEXO_HOME) -> Path | None:
+    venv_python = _venv_python_path(runtime_root)
+    if venv_python.exists():
+        return venv_python
+    try:
+        runtime_root.mkdir(parents=True, exist_ok=True)
+        result = subprocess.run(
+            [sys.executable, "-m", "venv", str(runtime_root / ".venv")],
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+        if result.returncode == 0 and venv_python.exists():
+            _log(f"Created managed venv at {runtime_root / '.venv'}")
+            return venv_python
+        _log(f"venv creation failed (exit {result.returncode}): {result.stderr or result.stdout}")
+    except Exception as e:
+        _log(f"venv creation failed: {e}")
+    return None
+
+
 def _reinstall_pip_deps() -> bool:
     """Reinstall Python deps from requirements.txt. Returns True on success."""
     req_file = SRC_DIR / "requirements.txt"
     if not req_file.exists():
         return True
-    venv_pip = NEXO_HOME / ".venv" / "bin" / "pip"
-    if not venv_pip.exists():
-        venv_pip = NEXO_HOME / ".venv" / "bin" / "pip3"
+    _ensure_runtime_venv(NEXO_HOME)
+    venv_pip = _venv_pip_path(NEXO_HOME)
+    if not venv_pip.exists() and sys.platform != "win32":
+        alt_pip = NEXO_HOME / ".venv" / "bin" / "pip3"
+        if alt_pip.exists():
+            venv_pip = alt_pip
     try:
         if venv_pip.exists():
             result = subprocess.run(
@@ -1399,9 +1461,12 @@ def _reinstall_runtime_pip_deps(runtime_root: Path = NEXO_HOME) -> bool:
     req_file = runtime_root / "requirements.txt"
     if not req_file.exists():
         return True
-    venv_pip = runtime_root / ".venv" / "bin" / "pip"
-    if not venv_pip.exists():
-        venv_pip = runtime_root / ".venv" / "bin" / "pip3"
+    _ensure_runtime_venv(runtime_root)
+    venv_pip = _venv_pip_path(runtime_root)
+    if not venv_pip.exists() and sys.platform != "win32":
+        alt_pip = runtime_root / ".venv" / "bin" / "pip3"
+        if alt_pip.exists():
+            venv_pip = alt_pip
     try:
         if venv_pip.exists():
             result = subprocess.run(

package/src/cli.py

@@ -471,6 +471,94 @@ def _scripts_doctor(args):
     return 0
 
 
+def _runtime_python_candidates() -> list[str]:
+    candidates: list[str] = []
+    seen: set[str] = set()
+
+    def _add(value: str | None) -> None:
+        if not value:
+            return
+        text = str(value).strip()
+        if not text or text in seen:
+            return
+        seen.add(text)
+        candidates.append(text)
+
+    _add(os.environ.get("NEXO_RUNTIME_PYTHON"))
+    _add(os.environ.get("NEXO_PYTHON"))
+    _add(sys.executable)
+
+    for root in {NEXO_HOME, NEXO_CODE, NEXO_CODE.parent}:
+        _add(str(root / ".venv" / "bin" / "python3"))
+        _add(str(root / ".venv" / "bin" / "python"))
+
+    if sys.platform == "darwin":
+        _add("/opt/homebrew/bin/python3")
+        _add("/usr/local/bin/python3")
+    else:
+        _add("/usr/local/bin/python3")
+        _add("/usr/bin/python3")
+
+    _add(shutil.which("python3"))
+    _add(shutil.which("python"))
+    return candidates
+
+
+def _python_supports_module(python_bin: str, module_name: str) -> bool:
+    path = Path(python_bin)
+    if "/" in python_bin and not path.exists():
+        return False
+    try:
+        result = subprocess.run(
+            [python_bin, "-c", f"import {module_name}"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            env={**os.environ, "NEXO_HOME": str(NEXO_HOME), "NEXO_CODE": str(NEXO_CODE)},
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+def _recover_scripts_call_runtime(tool_name: str, exc: ModuleNotFoundError) -> int | None:
+    missing = getattr(exc, "name", "") or ""
+    if missing != "fastmcp":
+        return None
+    if os.environ.get("NEXO_CLI_REEXECED") == "1":
+        return None
+
+    current = str(Path(sys.executable).resolve())
+    for candidate in _runtime_python_candidates():
+        try:
+            resolved = str(Path(candidate).resolve()) if "/" in candidate else candidate
+        except Exception:
+            resolved = candidate
+        if resolved == current:
+            continue
+        if not _python_supports_module(candidate, "fastmcp"):
+            continue
+        env = {
+            **os.environ,
+            "NEXO_HOME": str(NEXO_HOME),
+            "NEXO_CODE": str(NEXO_CODE),
+            "NEXO_CLI_REEXECED": "1",
+        }
+        result = subprocess.run(
+            [candidate, str(Path(__file__).resolve()), *sys.argv[1:]],
+            capture_output=True,
+            text=True,
+            timeout=60,
+            env=env,
+        )
+        if result.stdout:
+            print(result.stdout, end="")
+        if result.stderr:
+            print(result.stderr, file=sys.stderr, end="")
+        return result.returncode
+    return None
+
+
 def _scripts_call(args):
     """Call a NEXO MCP tool via in-process fastmcp client."""
     tool_name = args.tool
@@ -562,6 +650,10 @@ def _scripts_call(args):
         print(str(e), file=sys.stderr)
         return 1
     except Exception as e:
+        if isinstance(e, ModuleNotFoundError):
+            recovered = _recover_scripts_call_runtime(tool_name, e)
+            if recovered is not None:
+                return recovered
         print(f"Error calling tool {tool_name}: {e}", file=sys.stderr)
         return 1
 
@@ -1120,6 +1212,17 @@ def _skills_evolution(args):
     return 0
 
 
+def _skills_outcome_review(args):
+    from skills_runtime import review_skill_outcomes
+
+    result = review_skill_outcomes(args.id, auto_apply=args.auto_apply)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if result.get("ok") else 1
+
+
 def _skills_promote(args):
     from skills_runtime import promote_skill
 
@@ -1344,6 +1447,11 @@ def main():
     skills_evolution_p = skills_sub.add_parser("evolution", help="Evolution candidates")
     skills_evolution_p.add_argument("--json", action="store_true", help="JSON output")
 
+    skills_outcome_review_p = skills_sub.add_parser("outcome-review", help="Review skill lifecycle against sustained outcomes")
+    skills_outcome_review_p.add_argument("id", help="Skill ID")
+    skills_outcome_review_p.add_argument("--auto-apply", action="store_true", help="Apply the recommended promotion/retirement when it is strong enough")
+    skills_outcome_review_p.add_argument("--json", action="store_true", help="JSON output")
+
     skills_promote_p = skills_sub.add_parser("promote", help="Promote a skill lifecycle level")
     skills_promote_p.add_argument("id", help="Skill ID")
     skills_promote_p.add_argument("--target-level", default="published", choices=["draft", "published", "stable"])
@@ -1445,6 +1553,8 @@ def main():
             return _skills_featured(args)
         elif args.skills_command == "evolution":
             return _skills_evolution(args)
+        elif args.skills_command == "outcome-review":
+            return _skills_outcome_review(args)
         elif args.skills_command == "promote":
             return _skills_promote(args)
         elif args.skills_command == "retire":

package/src/crons/manifest.json

@@ -143,6 +143,30 @@
       "run_on_boot": true,
       "run_on_wake": true
     },
+    {
+      "id": "impact-scorer",
+      "script": "scripts/nexo-impact-scorer.py",
+      "schedule": {"hour": 5, "minute": 45},
+      "description": "Daily impact scoring for active followups so real queues can prioritize by expected impact",
+      "core": true,
+      "recovery_policy": "catchup",
+      "idempotent": true,
+      "max_catchup_age": 172800,
+      "run_on_boot": true,
+      "run_on_wake": true
+    },
+    {
+      "id": "outcome-checker",
+      "script": "scripts/nexo-outcome-checker.py",
+      "schedule": {"hour": 8, "minute": 0},
+      "description": "Daily outcome verification — marks tracked outcomes as met or missed",
+      "core": true,
+      "recovery_policy": "catchup",
+      "idempotent": true,
+      "max_catchup_age": 172800,
+      "run_on_boot": true,
+      "run_on_wake": true
+    },
     {
       "id": "auto-close-sessions",
       "script": "auto_close_sessions.py",

package/src/crons/sync.py

@@ -42,6 +42,9 @@ LABEL_PREFIX = "com.nexo."
 LOG_DIR = NEXO_HOME / "logs"
 OPTIONALS_FILE = NEXO_HOME / "config" / "optionals.json"
 SCHEDULE_FILE = NEXO_HOME / "config" / "schedule.json"
+CORE_CRON_MANAGED_ENV = "NEXO_MANAGED_CORE_CRON"
+PERSONAL_CRON_MANAGED_ENV = "NEXO_MANAGED_PERSONAL_CRON"
+PERSONAL_CRON_ID_ENV = "NEXO_PERSONAL_CRON_ID"
 RETIRED_CORE_FILES = (
     Path("scripts") / "nexo-day-orchestrator.sh",
 )
@@ -316,6 +319,29 @@ def unload_plist(plist_path: Path, dry_run: bool):
     log(f"  Removed: {plist_path.name}")
 
 
+def _plist_is_personal(existing: dict) -> bool:
+    """Return True when a LaunchAgent is explicitly managed as a personal cron."""
+    env = existing.get("EnvironmentVariables", {}) or {}
+    return env.get(PERSONAL_CRON_MANAGED_ENV) == "1" or bool(env.get(PERSONAL_CRON_ID_ENV))
+
+
+def _plist_is_core(existing: dict) -> bool:
+    """Return True when a LaunchAgent should be treated as a core cron."""
+    env = existing.get("EnvironmentVariables", {}) or {}
+    if _plist_is_personal(existing):
+        return False
+
+    if env.get(CORE_CRON_MANAGED_ENV) == "1":
+        return True
+
+    args = existing.get("ProgramArguments", [])
+    arg_blob = " ".join(str(a) for a in args)
+    return (
+        "nexo-cron-wrapper.sh" in arg_blob
+        and (str(SOURCE_ROOT) in arg_blob or str(NEXO_HOME) in arg_blob)
+    )
+
+
 def sync(dry_run: bool = False):
     system = platform.system()
     if system == "Linux":
@@ -355,20 +381,10 @@ def sync(dry_run: bool = False):
     #    (personal crons like shopify-backup, email-monitor are left alone)
     for cron_id, plist_path in installed.items():
         if cron_id not in manifest_ids:
-            # Check if this was previously a core cron by reading the plist
-            # If it points to NEXO_CODE scripts → it's core, safe to remove
             try:
                 with open(plist_path, "rb") as f:
                     existing = plistlib.load(f)
-                env = existing.get("EnvironmentVariables", {}) or {}
-                args = existing.get("ProgramArguments", [])
-                is_core = env.get("NEXO_MANAGED_CORE_CRON") == "1"
-                if not is_core:
-                    arg_blob = " ".join(str(a) for a in args)
-                    is_core = (
-                        "nexo-cron-wrapper.sh" in arg_blob
-                        and (str(SOURCE_ROOT) in arg_blob or str(NEXO_HOME) in arg_blob)
-                    )
+                is_core = _plist_is_core(existing)
             except Exception:
                 is_core = False
 

package/src/dashboard/app.py

@@ -1566,9 +1566,54 @@ async def api_guard(limit: int = Query(100, ge=1, le=500)):
 async def api_cortex(limit: int = Query(50, ge=1, le=200)):
     db = _db()
     conn = db.get_db()
-    logs = [dict(r) for r in conn.execute("SELECT * FROM cortex_log ORDER BY created_at DESC LIMIT ?", (limit,)).fetchall()]
-    decisions = [dict(r) for r in conn.execute("SELECT * FROM decisions ORDER BY created_at DESC LIMIT ?", (limit,)).fetchall()]
-    return {"cortex_logs": logs, "decisions": decisions}
+    summary = db.cortex_evaluation_summary(days=30) if hasattr(db, "cortex_evaluation_summary") else {}
+    logs = []
+    decisions = []
+    if conn.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name='cortex_log'").fetchone():
+        logs = [dict(r) for r in conn.execute("SELECT * FROM cortex_log ORDER BY created_at DESC LIMIT ?", (limit,)).fetchall()]
+    if conn.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name='decisions'").fetchone():
+        decisions = [dict(r) for r in conn.execute("SELECT * FROM decisions ORDER BY created_at DESC LIMIT ?", (limit,)).fetchall()]
+    evaluations = []
+    if conn.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name='cortex_evaluations'").fetchone():
+        evaluations = [
+            dict(r) for r in conn.execute(
+                "SELECT * FROM cortex_evaluations ORDER BY created_at DESC, id DESC LIMIT ?",
+                (limit,),
+            ).fetchall()
+        ]
+        for item in evaluations:
+            for key, default in (("goal_profile_labels", []), ("goal_profile_weights", {})):
+                raw = item.get(key)
+                if raw in (None, ""):
+                    item[key] = default
+                    continue
+                if isinstance(raw, (list, dict)):
+                    continue
+                try:
+                    item[key] = json.loads(raw)
+                except Exception:
+                    item[key] = default
+        linked_outcome_ids = sorted(
+            {
+                int(item.get("linked_outcome_id"))
+                for item in evaluations
+                if item.get("linked_outcome_id")
+            }
+        )
+        if linked_outcome_ids and conn.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name='outcomes'").fetchone():
+            placeholders = ",".join("?" for _ in linked_outcome_ids)
+            outcome_rows = {
+                int(row["id"]): dict(row)
+                for row in conn.execute(
+                    f"SELECT id, status, deadline FROM outcomes WHERE id IN ({placeholders})",
+                    linked_outcome_ids,
+                ).fetchall()
+            }
+            for item in evaluations:
+                outcome_id = item.get("linked_outcome_id")
+                if outcome_id:
+                    item["linked_outcome"] = outcome_rows.get(int(outcome_id))
+    return {"cortex_logs": logs, "decisions": decisions, "evaluations": evaluations, "summary": summary}
 
 
 # ---------------------------------------------------------------------------