nexo-brain 7.11.6 → 7.11.7

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.11.6",
+  "version": "7.11.7",
   "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,9 @@
 
 [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.11.6` is the current packaged-runtime line. Patch release — Guardian G4 now filters more false-positive slash fragments before they become debt, `strict_protocol_write_without_task` downgrades to `warn` when the session has a fresh heartbeat, and Deep Sleep extraction validates the real prompt contract instead of accepting any syntactically valid JSON. Validation so far: `50` targeted tests across hook guardrails and Deep Sleep extraction.
+Version `7.11.7` is the current packaged-runtime line. Patch release — runtime doctor now stops treating resolved protocol drift, disabled evolution, successful zero-usage headless runs, and recent in-flight crons as live runtime failures, while `runner-health-check` treats supervisor `SIGTERM 143` reloads as benign and supports both tuple and row-shaped SQLite reads. Result: the runtime doctor/runtime tier goes back to green on the live install. Validation so far: `104` targeted tests across doctor and runner-health.
+
+Previously in `7.11.6`: patch release — Guardian G4 now filters more false-positive slash fragments before they become debt, `strict_protocol_write_without_task` downgrades to `warn` when the session has a fresh heartbeat, and Deep Sleep extraction validates the real prompt contract instead of accepting any syntactically valid JSON. Validation so far: `50` targeted tests across hook guardrails and Deep Sleep extraction.
 
 Previously in `7.11.5`: patch release — Desktop-managed installs now block the standalone dashboard at the same product-mode layer as evolution, so `installation_live`, cron sync, and watchdog no longer disagree about whether `com.nexo.dashboard` should exist. Validation: `125` targeted tests across product-mode, cron sync, and doctor, plus a full pre-release wrapper (`2321 passed, 2 skipped, 1 xfailed, 4 xpassed`).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.11.6",
+  "version": "7.11.7",
   "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/runtime.py

@@ -57,6 +57,28 @@ PACKAGE_JSON = NEXO_CODE / "package.json"
 CHANGELOG_FILE = NEXO_CODE / "CHANGELOG.md"
 
 
+def _evolution_objective_payload() -> dict:
+    candidates = [
+        NEXO_HOME / "brain" / "evolution-objective.json",
+        NEXO_HOME / "cortex" / "evolution-objective.json",
+    ]
+    for path in candidates:
+        if not path.is_file():
+            continue
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        if isinstance(payload, dict):
+            return payload
+    return {}
+
+
+def _is_evolution_disabled() -> bool:
+    payload = _evolution_objective_payload()
+    return payload.get("evolution_enabled") is False
+
+
 def _expected_runtime_code_dir() -> Path:
     packaged = NEXO_HOME / "core"
     if packaged.exists() or not (NEXO_HOME / "server.py").is_file():
@@ -887,6 +909,8 @@ def _cron_expectations() -> dict[str, dict]:
         cron_id = cron.get("id")
         if not cron_id or cron.get("keep_alive"):
             continue
+        if cron_id == "evolution" and _is_evolution_disabled():
+            continue
         if cron.get("run_at_load") and not cron.get("interval_seconds") and not cron.get("schedule"):
             continue
 
@@ -1485,7 +1509,17 @@ def check_cron_freshness() -> DoctorCheck:
                 )
             # Latest run per cron
             rows = conn.execute(
-                "SELECT cron_id, MAX(started_at) as last_run FROM cron_runs GROUP BY cron_id"
+                """
+                SELECT cr.cron_id, cr.started_at, cr.ended_at, cr.exit_code
+                FROM cron_runs cr
+                INNER JOIN (
+                    SELECT cron_id, MAX(started_at) AS last_run
+                    FROM cron_runs
+                    GROUP BY cron_id
+                ) latest
+                  ON latest.cron_id = cr.cron_id
+                 AND latest.last_run = cr.started_at
+                """
             ).fetchall()
         finally:
             conn.close()
@@ -1510,8 +1544,16 @@ def check_cron_freshness() -> DoctorCheck:
 
             age = now - parsed.timestamp()
             expected = expectations.get(cron_id, {"threshold": DEFAULT_CRON_THRESHOLD, "label": "runtime default"})
+            in_flight = row[2] is None and row[3] is None
+            if in_flight and age <= max(expected["threshold"] * 4, 3600):
+                continue
             if age > expected["threshold"]:
-                stale.append(f"{cron_id}: {int(age / 3600)}h ago (expected {expected['label']})")
+                if in_flight:
+                    stale.append(
+                        f"{cron_id}: in-flight for {int(age / 60)}m (expected {expected['label']})"
+                    )
+                else:
+                    stale.append(f"{cron_id}: {int(age / 3600)}h ago (expected {expected['label']})")
 
         if stale:
             return DoctorCheck(
@@ -2318,6 +2360,11 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
         repair_plan.append("Keep using managed Codex bootstrap so conditioned-file discipline remains visible in transcripts")
 
     no_open_conditioned_debt = debt_summary["available"] and debt_summary["open_total"] == 0
+    historical_no_open_debt_drift = (
+        no_open_conditioned_debt
+        and audit.get("latest_violation_age_seconds") is not None
+        and float(audit["latest_violation_age_seconds"]) >= LIVE_PROTOCOL_SESSION_FRESHNESS
+    )
     historical_read_only = (
         no_open_conditioned_debt
         and audit["read_without_protocol"] > 0
@@ -2334,13 +2381,16 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
     )
 
     if audit["write_without_protocol"] or audit["write_without_guard_ack"]:
-        if tracked_mutation_without_open_debt:
+        if historical_no_open_debt_drift:
+            status = "healthy"
+            severity = "info"
+        elif tracked_mutation_without_open_debt:
             status = "healthy"
             severity = "info"
         else:
             status = "critical"
             severity = "error"
-    elif historical_read_only:
+    elif historical_no_open_debt_drift or historical_read_only:
         status = "healthy"
         severity = "info"
     elif audit["read_without_protocol"]:
@@ -2357,7 +2407,7 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
         severity=severity,
         summary=(
             "Historical Codex conditioned-file drift has no open protocol debt"
-            if historical_read_only
+            if historical_no_open_debt_drift or historical_read_only
             else "Tracked Codex conditioned-file mutation drift has no open protocol debt"
             if tracked_mutation_without_open_debt
             else "Recent Codex sessions respect conditioned-file discipline"
@@ -2685,7 +2735,10 @@ def check_protocol_compliance() -> DoctorCheck:
                     closed_tasks = [row for row in tasks if row["status"] != "open"]
                     verify_required = [row for row in closed_tasks if row["must_verify"] and row["status"] == "done"]
                     verify_ok = [row for row in verify_required if (row["close_evidence"] or "").strip()]
-                    change_required = [row for row in closed_tasks if row["must_change_log"]]
+                    change_required = [
+                        row for row in closed_tasks
+                        if row["must_change_log"] and row["status"] in {"done", "partial", "failed"}
+                    ]
                     change_ok = [row for row in change_required if row["change_log_id"]]
                     learning_required = [row for row in closed_tasks if row["correction_happened"]]
                     learning_ok = [row for row in learning_required if row["learning_id"]]
@@ -3216,16 +3269,23 @@ def check_automation_telemetry(days: int = 7) -> DoctorCheck:
                 interactive_expr = "0"
                 if "session_type" in columns:
                     interactive_expr = "COALESCE(session_type, '') LIKE 'interactive%'"
+                headless_unmetered_expr = (
+                    f"status = 'ok' AND NOT ({interactive_expr}) "
+                    "AND (input_tokens + cached_input_tokens + output_tokens) = 0 "
+                    "AND COALESCE(total_cost_usd, 0) <= 0 "
+                    "AND COALESCE(cost_source, '') IN ('', 'backend', 'missing')"
+                )
                 row = conn.execute(
                     f"""
                     SELECT
                         COUNT(*) AS runs,
                         SUM(CASE WHEN status = 'ok' THEN 1 ELSE 0 END) AS successful_runs,
                         SUM(CASE WHEN status != 'ok' THEN 1 ELSE 0 END) AS failed_runs,
-                        SUM(CASE WHEN status = 'ok' AND NOT ({interactive_expr}) THEN 1 ELSE 0 END) AS scored_successful_runs,
+                        SUM(CASE WHEN status = 'ok' AND NOT ({interactive_expr}) AND NOT ({headless_unmetered_expr}) THEN 1 ELSE 0 END) AS scored_successful_runs,
                         SUM(CASE WHEN status = 'ok' AND NOT ({interactive_expr}) AND (input_tokens + cached_input_tokens + output_tokens) > 0 THEN 1 ELSE 0 END) AS usage_runs,
                         SUM(CASE WHEN status = 'ok' AND NOT ({interactive_expr}) AND total_cost_usd IS NOT NULL THEN 1 ELSE 0 END) AS cost_runs,
                         SUM(CASE WHEN status = 'ok' AND NOT ({interactive_expr}) AND cost_source = 'pricing_unavailable' THEN 1 ELSE 0 END) AS pricing_gaps,
+                        SUM(CASE WHEN {headless_unmetered_expr} THEN 1 ELSE 0 END) AS headless_unmetered_runs,
                         SUM(CASE WHEN status = 'ok' AND ({interactive_expr}) AND ((input_tokens + cached_input_tokens + output_tokens) = 0 OR total_cost_usd IS NULL) THEN 1 ELSE 0 END) AS interactive_unmetered_runs,
                         GROUP_CONCAT(DISTINCT backend) AS backends
                     FROM automation_runs
@@ -3284,9 +3344,10 @@ def check_automation_telemetry(days: int = 7) -> DoctorCheck:
     usage_runs = int((row["usage_runs"] if row else 0) or 0)
     cost_runs = int((row["cost_runs"] if row else 0) or 0)
     pricing_gaps = int((row["pricing_gaps"] if row else 0) or 0)
+    headless_unmetered_runs = int((row["headless_unmetered_runs"] if row and "headless_unmetered_runs" in row.keys() else 0) or 0)
     interactive_unmetered_runs = int((row["interactive_unmetered_runs"] if row and "interactive_unmetered_runs" in row.keys() else 0) or 0)
-    usage_denominator = scored_successful_runs or (successful_runs if not interactive_unmetered_runs else 0)
-    cost_denominator = scored_successful_runs or (successful_runs if not interactive_unmetered_runs else 0)
+    usage_denominator = scored_successful_runs or (successful_runs if not interactive_unmetered_runs and not headless_unmetered_runs else 0)
+    cost_denominator = scored_successful_runs or (successful_runs if not interactive_unmetered_runs and not headless_unmetered_runs else 0)
     missing_usage_runs = max(0, usage_denominator - usage_runs) if usage_denominator else 0
     usage_coverage = round((usage_runs / usage_denominator) * 100, 1) if usage_denominator else 100.0
     cost_coverage = round((cost_runs / cost_denominator) * 100, 1) if cost_denominator else 100.0
@@ -3302,6 +3363,8 @@ def check_automation_telemetry(days: int = 7) -> DoctorCheck:
     ]
     if missing_usage_runs:
         evidence.append(f"missing_usage_runs={missing_usage_runs}")
+    if headless_unmetered_runs:
+        evidence.append(f"headless_unmetered_runs_excluded={headless_unmetered_runs}")
     if interactive_unmetered_runs:
         evidence.append(f"interactive_unmetered_runs_excluded={interactive_unmetered_runs}")
     backends = str((row["backends"] if row else "") or "").strip()

package/src/scripts/runner-health-check.py

@@ -71,6 +71,25 @@ RUNNERS = [
 ]
 
 
+def _row_value(row: sqlite3.Row | tuple, key: str):
+    if isinstance(row, sqlite3.Row):
+        return row[key]
+    column_index = {
+        "exit_code": 0,
+        "error": 1,
+        "started_at": 2,
+    }
+    return row[column_index[key]]
+
+
+def _is_benign_supervisor_interrupt(row: sqlite3.Row | tuple) -> bool:
+    exit_code = _row_value(row, "exit_code")
+    error = _row_value(row, "error")
+    if int(exit_code or 0) != 143:
+        return False
+    return "Killed by SIGTERM" in str(error or "")
+
+
 def _recent_summary_evidence(conn: sqlite3.Connection, cron_id: str, cutoff: str) -> Optional[dict]:
     row = conn.execute(
         "SELECT summary, started_at FROM cron_runs WHERE cron_id=? AND started_at > ? AND summary != '' ORDER BY started_at DESC LIMIT 1",
@@ -113,27 +132,33 @@ def _recent_log_evidence(now: datetime, max_age_hours: int, *sources: tuple[str,
 
 
 def _last_error_state(conn: sqlite3.Connection, cron_id: str) -> Optional[dict]:
-    row = conn.execute(
-        "SELECT error, started_at FROM cron_runs WHERE cron_id=? AND error != '' AND error IS NOT NULL ORDER BY started_at DESC LIMIT 1",
+    rows = conn.execute(
+        "SELECT exit_code, error, started_at FROM cron_runs WHERE cron_id=? AND error != '' AND error IS NOT NULL ORDER BY started_at DESC",
         (cron_id,),
-    ).fetchone()
-    if not row:
+    ).fetchall()
+    row = next((candidate for candidate in rows if not _is_benign_supervisor_interrupt(candidate)), None)
+    if row is None:
         return None
 
     successful_since = conn.execute(
-        "SELECT COUNT(*) FROM cron_runs WHERE cron_id=? AND started_at > ? AND (exit_code=0 OR exit_code IS NULL)",
-        (cron_id, row[1]),
-    ).fetchone()
+        "SELECT exit_code, error, started_at FROM cron_runs WHERE cron_id=? AND started_at > ?",
+        (cron_id, _row_value(row, "started_at")),
+    ).fetchall()
+    successful_count = sum(
+        1
+        for candidate in successful_since
+        if int(_row_value(candidate, "exit_code") or 0) == 0 or _is_benign_supervisor_interrupt(candidate)
+    )
     age_row = conn.execute(
         "SELECT ROUND((julianday('now') - julianday(?)) * 24, 1)",
-        (row[1],),
+        (_row_value(row, "started_at"),),
     ).fetchone()
 
     return {
-        "last_error": row[0][:200],
-        "last_error_at": row[1],
+        "last_error": str(_row_value(row, "error") or "")[:200],
+        "last_error_at": _row_value(row, "started_at"),
         "last_error_age_hours": age_row[0] if age_row else None,
-        "successful_runs_since_last_error": successful_since[0] if successful_since else 0,
+        "successful_runs_since_last_error": successful_count,
     }
 
 
@@ -167,11 +192,15 @@ def check_runner(conn: sqlite3.Connection, runner: dict) -> dict:
         result["issues"].append(f"No runs in the last {MAX_HOURS_NO_RUN}h (last: {last_run})")
 
     # Check 2: Successful runs in the last week
-    row = conn.execute(
-        "SELECT COUNT(*) FROM cron_runs WHERE cron_id=? AND started_at > ? AND (exit_code=0 OR exit_code IS NULL)",
+    run_rows_7d = conn.execute(
+        "SELECT exit_code, error, started_at FROM cron_runs WHERE cron_id=? AND started_at > ?",
         (cron_id, cutoff_7d),
-    ).fetchone()
-    success_7d = row[0] or 0
+    ).fetchall()
+    success_7d = sum(
+        1
+        for row in run_rows_7d
+        if int(_row_value(row, "exit_code") or 0) == 0 or _is_benign_supervisor_interrupt(row)
+    )
     result["successful_runs_last_7d"] = success_7d
 
     if success_7d < runner["min_weekly"]:
@@ -183,11 +212,11 @@ def check_runner(conn: sqlite3.Connection, runner: dict) -> dict:
         )
 
     # Check 3: Error rate in last week
-    row = conn.execute(
-        "SELECT COUNT(*) FROM cron_runs WHERE cron_id=? AND started_at > ? AND exit_code IS NOT NULL AND exit_code != 0",
-        (cron_id, cutoff_7d),
-    ).fetchone()
-    errors_7d = row[0] or 0
+    errors_7d = sum(
+        1
+        for row in run_rows_7d
+        if int(_row_value(row, "exit_code") or 0) != 0 and not _is_benign_supervisor_interrupt(row)
+    )
     total_7d = success_7d + errors_7d
     result["errors_last_7d"] = errors_7d
     result["total_runs_last_7d"] = total_7d
@@ -266,6 +295,7 @@ def main() -> int:
         return 1
 
     conn = sqlite3.connect(str(DB_PATH), timeout=10)
+    conn.row_factory = sqlite3.Row
     now = datetime.now(timezone.utc)
 
     report = {