nexo-brain 5.3.9 → 5.3.10

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.3.9",
+  "version": "5.3.10",
   "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,7 @@
 
 [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 `5.3.9` is the current packaged-runtime line: packaged updates now rebuild the core artifact manifest from the canonical npm package source instead of the live `~/.nexo/scripts` directory, so personal scripts stop being reclassified as core, portable user-data export keeps including them, and runtime doctor can recover personal LaunchAgent ownership cleanly after a bad `5.3.8` update.
+Version `5.3.10` is the current packaged-runtime line: packaged installs and updates now refresh `~/.nexo/package.json` from the published npm package so runtime metadata stops drifting after successful updates, `nexo doctor --tier deep` no longer flags a healthy runtime as degraded just because the first daily `self-audit-summary.json` has not been produced yet, weekly Evolution once again emits explicit dimension telemetry instead of leaving `nexo_evolution_status` blank, and daily synthesis only pulls startup/update summaries into the briefing when they are operationally actionable.
 
 Start here:
 - [5-minute quickstart](docs/quickstart-5-minutes.md)
@@ -89,7 +89,7 @@ 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 `5.3.9` is the packaged core-artifact manifest heal for `5.3.8`: packaged updates now rebuild `runtime-core-artifacts.json` from the canonical npm package `src/` tree instead of scanning the live `~/.nexo/scripts` directory, script classification prefers that canonical packaged source when available, and runtime doctor syncs personal scripts before LaunchAgent inventory so personal automations recover cleanly instead of being mistaken for unknown core drift. Version `5.3.8` was the immediate packaged-migration hotfix for `5.3.7`: the installer/runtime migrator now discovers all top-level runtime Python modules from `src/` dynamically instead of relying on a manual allowlist, so new product surfaces like `nexo export` / `nexo import` actually arrive in `~/.nexo` after update instead of being present only in the published npm tarball. Version `5.3.7` closed the remaining packaged-runtime happy-path gap and finally exposed portable user-data migration commands: packaged `nexo update` now self-heals cron definitions and LaunchAgents after a successful npm bump, new `nexo export` / `nexo import` commands move operator data as a safe bundle instead of leaving that flow implicit, and runtime doctor now distinguishes tracked historical Codex drift from an actually broken runtime so cleaned installs stop staying red for stale transcript debt alone. Version `5.3.6` hardened the Claude Code bootstrap path and related runtime hygiene: managed client sync now writes the NEXO MCP server where current Claude Code actually reads it (`~/.claude.json`), script classification is stricter about core-vs-personal runtime artifacts, schedule status distinguishes genuinely running jobs from broken ones, and retroactive learnings stop opening keyword-only false positives outside their declared `applies_to` scope. Version `5.3.5` already keeps CLI version visibility honest right after `nexo update`: if the cached npm version lags behind the runtime you just installed, `nexo` / `nexo chat` now clamp `Latest` to the installed version and refresh the cache instead of showing a stale older release. Version `5.3.4` already cleaned up legacy core alias leakage and added the version-status banner. Version `5.3.3` closed the remaining packaged-runtime doctor mismatch: the built-in hourly backup helper is now inventoried as a core LaunchAgent, so clean installs no longer get a false unknown-LaunchAgent warning. Version `5.3.2` already hardened the runtime boundary by persisting which runtime scripts/hooks are core product artifacts, keeping `nexo scripts` from mixing those into the personal bucket, and migrating the legacy Claude Code heartbeat wrappers into managed core hooks.
+Version `5.3.10` tightens the packaged-runtime truth layer again: installs and updates now keep `~/.nexo/package.json` aligned with the published npm package so runtime metadata and doctor evidence no longer drift to an old version, `nexo doctor --tier deep` treats a missing `self-audit-summary.json` as a pending bootstrap artifact when the runtime was just installed or updated instead of reporting a false degradation, weekly Evolution now asks for explicit `dimension_scores` / `score_evidence` so telemetry can persist instead of staying blank, and daily synthesis only ingests `update-last-summary.json` when it carries actionable runtime signals. Version `5.3.9` is the packaged core-artifact manifest heal for `5.3.8`: packaged updates now rebuild `runtime-core-artifacts.json` from the canonical npm package `src/` tree instead of scanning the live `~/.nexo/scripts` directory, script classification prefers that canonical packaged source when available, and runtime doctor syncs personal scripts before LaunchAgent inventory so personal automations recover cleanly instead of being mistaken for unknown core drift. Version `5.3.8` was the immediate packaged-migration hotfix for `5.3.7`: the installer/runtime migrator now discovers all top-level runtime Python modules from `src/` dynamically instead of relying on a manual allowlist, so new product surfaces like `nexo export` / `nexo import` actually arrive in `~/.nexo` after update instead of being present only in the published npm tarball. Version `5.3.7` closed the remaining packaged-runtime happy-path gap and finally exposed portable user-data migration commands: packaged `nexo update` now self-heals cron definitions and LaunchAgents after a successful npm bump, new `nexo export` / `nexo import` commands move operator data as a safe bundle instead of leaving that flow implicit, and runtime doctor now distinguishes tracked historical Codex drift from an actually broken runtime so cleaned installs stop staying red for stale transcript debt alone. Version `5.3.6` hardened the Claude Code bootstrap path and related runtime hygiene: managed client sync now writes the NEXO MCP server where current Claude Code actually reads it (`~/.claude.json`), script classification is stricter about core-vs-personal runtime artifacts, schedule status distinguishes genuinely running jobs from broken ones, and retroactive learnings stop opening keyword-only false positives outside their declared `applies_to` scope. Version `5.3.5` already keeps CLI version visibility honest right after `nexo update`: if the cached npm version lags behind the runtime you just installed, `nexo` / `nexo chat` now clamp `Latest` to the installed version and refresh the cache instead of showing a stale older release. Version `5.3.4` already cleaned up legacy core alias leakage and added the version-status banner. Version `5.3.3` closed the remaining packaged-runtime doctor mismatch: the built-in hourly backup helper is now inventoried as a core LaunchAgent, so clean installs no longer get a false unknown-LaunchAgent warning. Version `5.3.2` already hardened the runtime boundary by persisting which runtime scripts/hooks are core product artifacts, keeping `nexo scripts` from mixing those into the personal bucket, and migrating the legacy Claude Code heartbeat wrappers into managed core hooks.
 
 Version `5.3.1` normalizes packaged npm installs so they behave like packaged npm installs: `nexo update` now keeps the runtime anchored to `~/.nexo`, refreshes packaged bootstrap/client artifacts after upgrade, avoids repo-only release-artifact drift in installed runtimes, and keeps personal scripts on the canonical packaged path.
 

package/bin/nexo-brain.js

@@ -120,6 +120,17 @@ function writeRuntimeCoreArtifactsManifest(nexoHome, srcDir) {
   }
 }
 
+function syncRuntimePackageMetadata(repoRoot = path.join(__dirname, ".."), runtimeHome = NEXO_HOME) {
+  try {
+    const pkgSrc = path.join(repoRoot, "package.json");
+    if (fs.existsSync(pkgSrc)) {
+      fs.copyFileSync(pkgSrc, path.join(runtimeHome, "package.json"));
+    }
+  } catch (err) {
+    log(`WARN: could not sync runtime package metadata: ${err.message}`);
+  }
+}
+
 function getCoreRuntimeFlatFiles(srcDir = path.join(__dirname, "..", "src")) {
   const staticFiles = [
     "server.py",
@@ -1606,6 +1617,7 @@ async function main() {
           updated_at: new Date().toISOString(),
           migrated_from: installedVersion,
         }, null, 2));
+        syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
 
         // Save updated CLAUDE.md template as reference (don't overwrite user's)
         const templateSrc = path.join(__dirname, "..", "templates", "CLAUDE.md.template");
@@ -1699,6 +1711,7 @@ async function main() {
           fs.copyFileSync(srcFile, destFile);
         }
       });
+      syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
 
       const templatesSrc = path.join(__dirname, "..", "templates");
       const templatesDest = path.join(NEXO_HOME, "templates");
@@ -2205,6 +2218,7 @@ async function main() {
       files_updated: 0,
     }, null, 2)
   );
+  syncRuntimePackageMetadata(path.join(__dirname, ".."), NEXO_HOME);
 
   // Copy source files
   log("Copying core runtime files...");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.3.9",
+  "version": "5.3.10",
   "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/doctor/providers/deep.py

@@ -1,17 +1,20 @@
 """Deep tier checks — read existing artifacts for richer validation. Target <60s."""
 from __future__ import annotations
 
+import datetime as dt
 import json
 import os
 import time
 from pathlib import Path
 
+from cron_recovery import load_enabled_crons
 from doctor.models import DoctorCheck, safe_check
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 
 # Freshness thresholds
 SELF_AUDIT_FRESHNESS = 86400 * 2  # 2 days (runs daily)
+SELF_AUDIT_BOOTSTRAP_GRACE = 86400  # 1 day grace after install/update before the first summary exists
 PREFLIGHT_FRESHNESS = 86400  # 1 day
 WATCHDOG_SMOKE_FRESHNESS = 86400  # 1 day
 
@@ -29,12 +32,70 @@ def _load_json(path: Path) -> dict:
     return json.loads(path.read_text())
 
 
+def _timestamp_age_seconds(value: str) -> float | None:
+    raw = str(value or "").strip()
+    if not raw:
+        return None
+    try:
+        parsed = dt.datetime.fromisoformat(raw.replace("Z", "+00:00"))
+    except Exception:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=dt.timezone.utc)
+    return max(0.0, time.time() - parsed.timestamp())
+
+
+def _runtime_bootstrap_age_seconds() -> float | None:
+    version_file = NEXO_HOME / "version.json"
+    try:
+        payload = _load_json(version_file)
+    except Exception:
+        payload = {}
+    for key in ("updated_at", "installed_at"):
+        age = _timestamp_age_seconds(str(payload.get(key, "") or ""))
+        if age is not None:
+            return age
+    return _file_age_seconds(version_file)
+
+
+def _self_audit_enabled() -> bool | None:
+    try:
+        return any(str(cron.get("id") or "").strip() == "self-audit" for cron in load_enabled_crons())
+    except Exception:
+        return None
+
+
 def check_self_audit_summary() -> DoctorCheck:
     """Check latest self-audit summary exists and is recent."""
     summary_file = NEXO_HOME / "logs" / "self-audit-summary.json"
     age = _file_age_seconds(summary_file)
 
     if age is None:
+        enabled = _self_audit_enabled()
+        if enabled is False:
+            return DoctorCheck(
+                id="deep.self_audit",
+                tier="deep",
+                status="healthy",
+                severity="info",
+                summary="Self-audit automation disabled or not installed",
+            )
+
+        bootstrap_age = _runtime_bootstrap_age_seconds()
+        if enabled and bootstrap_age is not None and bootstrap_age <= SELF_AUDIT_BOOTSTRAP_GRACE:
+            bootstrap_hours = bootstrap_age / 3600
+            return DoctorCheck(
+                id="deep.self_audit",
+                tier="deep",
+                status="healthy",
+                severity="info",
+                summary="Self-audit scheduled but no summary yet",
+                evidence=[
+                    f"Runtime install/update {bootstrap_hours:.0f} hours ago",
+                    f"Expected later at: {summary_file}",
+                ],
+            )
+
         return DoctorCheck(
             id="deep.self_audit",
             tier="deep",

package/src/evolution_cycle.py

@@ -261,6 +261,19 @@ def dry_run_restore_test() -> bool:
 def build_evolution_prompt(week_data: dict, objective: dict) -> str:
     """Build a SHORT prompt — CLI investigates on its own using tools."""
 
+    objective_dims = normalize_objective(objective).get("dimensions", {})
+    current_scores = {
+        dim: int(m["score"])
+        for dim, m in week_data.get("current_metrics", {}).items()
+        if isinstance(m, dict) and isinstance(m.get("score"), (int, float))
+    }
+    if not current_scores:
+        current_scores = {
+            dim: int((payload or {}).get("current", 0) or 0)
+            for dim, payload in objective_dims.items()
+            if isinstance(payload, dict)
+        }
+
     # Summary stats only — CLI will dig deeper with tools
     stats = {
         "learnings_this_week": len(week_data.get("learnings", [])),
@@ -268,7 +281,7 @@ def build_evolution_prompt(week_data: dict, objective: dict) -> str:
         "changes_this_week": len(week_data.get("changes", [])),
         "diaries_this_week": len(week_data.get("diaries", [])),
         "evolution_history": len(week_data.get("evolution_history", [])),
-        "current_scores": {dim: m["score"] for dim, m in week_data.get("current_metrics", {}).items()},
+        "current_scores": current_scores,
     }
 
     mode = normalize_objective(objective).get("evolution_mode", "auto")
@@ -332,6 +345,20 @@ SAFETY:
 OUTPUT FORMAT (JSON):
 {{
   "analysis": "one paragraph summary of what you found",
+  "dimension_scores": {{
+    "episodic_memory": 0,
+    "autonomy": 0,
+    "proactivity": 0,
+    "self_improvement": 0,
+    "agi": 0
+  }},
+  "score_evidence": {{
+    "episodic_memory": "why this score changed or stayed flat",
+    "autonomy": "why this score changed or stayed flat",
+    "proactivity": "why this score changed or stayed flat",
+    "self_improvement": "why this score changed or stayed flat",
+    "agi": "why this score changed or stayed flat"
+  }},
   "patterns": [{{"type": "...", "description": "...", "frequency": "..."}}],
   "proposals": [
     {{
@@ -345,6 +372,8 @@ OUTPUT FORMAT (JSON):
   ]
 }}
 
+Always include all five canonical keys in `dimension_scores` and `score_evidence`.
+Scores must be integers in the 0-100 range and reflect the current week, not targets.
 Max 3 proposals. Quality over quantity. If nothing needs improving, say so."""
 
     return prompt

package/src/plugins/evolution.py

@@ -1,33 +1,77 @@
 """Evolution plugin — NEXO self-improvement tools for interactive sessions."""
 
+import json
 import os
+from pathlib import Path
 from db import get_latest_metrics, get_evolution_history, update_evolution_log_status, get_db
 
 
+CANONICAL_DIMENSIONS = {
+    "episodic_memory": "Episodic Memory",
+    "autonomy": "Autonomy",
+    "proactivity": "Proactivity",
+    "self_improvement": "Self-improvement",
+    "agi": "AGI",
+}
+
+
+def _resolve_objective_file() -> Path:
+    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+    for candidate in (
+        nexo_home / "brain" / "evolution-objective.json",
+        nexo_home / "cortex" / "evolution-objective.json",
+    ):
+        if candidate.exists():
+            return candidate
+    return nexo_home / "brain" / "evolution-objective.json"
+
+
+def _load_objective() -> dict:
+    try:
+        raw = json.loads(_resolve_objective_file().read_text())
+    except Exception:
+        return {}
+    return raw if isinstance(raw, dict) else {}
+
+
 def handle_evolution_status() -> str:
     """Show current NEXO dimension scores and recent trend."""
     metrics = get_latest_metrics()
-    if not metrics:
-        return "No evolution metrics recorded."
-
-    BARS = {
-        "episodic_memory": "Episodic Memory",
-        "autonomy": "Autonomy",
-        "proactivity": "Proactivity",
-        "self_improvement": "Self-improvement",
-        "agi": "AGI",
-    }
+    objective = _load_objective()
+    objective_dims = objective.get("dimensions", {}) if isinstance(objective.get("dimensions"), dict) else {}
 
     from user_context import get_context
     lines = [f"{get_context().assistant_name} EVOLUTION STATUS:"]
-    for key, label in BARS.items():
+    has_output = False
+    for key, label in CANONICAL_DIMENSIONS.items():
         m = metrics.get(key)
         if m:
             score = m["score"]
             delta = m["delta"]
             bar = "█" * (score // 5) + "░" * (20 - score // 5)
             delta_str = f" (+{delta})" if delta > 0 else f" ({delta})" if delta < 0 else " (=)"
-            lines.append(f"  {label:<20} {bar} {score}%{delta_str}")
+            target = ""
+            if isinstance(objective_dims.get(key), dict) and objective_dims[key].get("target") is not None:
+                target = f" / target {int(objective_dims[key].get('target', 0) or 0)}%"
+            lines.append(f"  {label:<20} {bar} {score}%{delta_str}{target}")
+            has_output = True
+            continue
+
+        objective_entry = objective_dims.get(key)
+        if isinstance(objective_entry, dict):
+            score = int(objective_entry.get("current", 0) or 0)
+            target = int(objective_entry.get("target", 0) or 0)
+            bar = "█" * (score // 5) + "░" * (20 - score // 5)
+            lines.append(f"  {label:<20} {bar} {score}% (objective fallback, target {target}%)")
+            has_output = True
+
+    if not has_output:
+        return "No evolution metrics recorded."
+
+    if not metrics:
+        lines.append("  Note: no persisted evolution_metrics rows yet; showing objective fallback.")
+    if objective.get("last_evolution"):
+        lines.append(f"  Last evolution: {objective['last_evolution']}")
     return "\n".join(lines)
 
 

package/src/scripts/nexo-synthesis.py

@@ -135,6 +135,36 @@ def _impact_reasoning(row: dict) -> str:
     return str(factors.get("reasoning") or "").strip()
 
 
+def _load_json_summary(path: Path, *, actionable) -> tuple[dict | None, str | None]:
+    if not path.exists():
+        return None, None
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        return None, str(exc)
+    if not isinstance(payload, dict):
+        return None, "summary payload is not a JSON object"
+    if not actionable(payload):
+        return None, None
+    return payload, None
+
+
+def _load_coordination_summary(filename: str, *, actionable) -> tuple[dict | None, str | None]:
+    return _load_json_summary(COORD_DIR / filename, actionable=actionable)
+
+
+def _update_summary_actionable(payload: dict) -> bool:
+    if any(payload.get(key) for key in ("error", "updated", "deferred_reason", "git_update", "npm_notice")):
+        return True
+    for action in payload.get("actions") or []:
+        if str(action).startswith("personal-schedules-"):
+            return True
+    for message in payload.get("client_bootstrap_updates") or []:
+        if "already current" not in str(message).lower():
+            return True
+    return False
+
+
 def collect_data() -> dict:
     """Collect all raw data for synthesis."""
     data = {"date": TODAY_STR}
@@ -207,6 +237,43 @@ def collect_data() -> dict:
         except Exception as exc:
             data["impact_queue_summary_error"] = str(exc)
 
+    followup_hygiene_summary, followup_hygiene_error = _load_coordination_summary(
+        "followup-hygiene-summary.json",
+        actionable=lambda payload: any(
+            int(payload.get(key, 0) or 0) > 0
+            for key in ("dirty_normalized", "stale_count", "orphan_count")
+        ),
+    )
+    if followup_hygiene_summary is not None:
+        data["followup_hygiene_summary"] = followup_hygiene_summary
+    elif followup_hygiene_error:
+        data["followup_hygiene_summary_error"] = followup_hygiene_error
+
+    outcome_checker_summary, outcome_checker_error = _load_coordination_summary(
+        "outcome-checker-summary.json",
+        actionable=lambda payload: (
+            any(
+                int(payload.get(key, 0) or 0) > 0
+                for key in ("checked", "met", "missed", "pending", "errors")
+            )
+            or bool(payload.get("ids"))
+            or bool(((payload.get("auto_promoted_patterns") or {}).get("promoted") or []))
+        ),
+    )
+    if outcome_checker_summary is not None:
+        data["outcome_checker_summary"] = outcome_checker_summary
+    elif outcome_checker_error:
+        data["outcome_checker_summary_error"] = outcome_checker_error
+
+    update_summary, update_summary_error = _load_json_summary(
+        NEXO_HOME / "logs" / "update-last-summary.json",
+        actionable=_update_summary_actionable,
+    )
+    if update_summary is not None:
+        data["update_summary"] = update_summary
+    elif update_summary_error:
+        data["update_summary_error"] = update_summary_error
+
     # Guard stats
     data["guard_stats"] = safe_query(
         "SELECT category, COUNT(*) as cnt FROM learnings WHERE status='active' "