nexo-brain 3.0.1 → 3.1.0

package/src/plugins/schedule.py

@@ -3,6 +3,7 @@
 import json
 import os
 import platform
+import re
 import subprocess
 from pathlib import Path
 
@@ -69,9 +70,20 @@ def _summary_has_warning(summary: str = "") -> bool:
     lowered = str(summary or "").strip().lower()
     if not lowered:
         return False
+    if re.search(r"\b[1-9]\d*\s+(errors?|warnings?)\b", lowered):
+        return True
     if "no warning" in lowered or "without warnings" in lowered:
         return False
-    warning_tokens = ("warning", "warnings", "warn:", "degraded", "partial failure", "issues detected")
+    warning_tokens = (
+        "warning",
+        "warnings",
+        "warn:",
+        "degraded",
+        "partial failure",
+        "issues detected",
+        "completed with findings",
+        "findings detected",
+    )
     return any(token in lowered for token in warning_tokens)
 
 

package/src/plugins/update.py

@@ -149,14 +149,21 @@ def _backup_databases() -> tuple[str, str | None]:
 
     for db_file in db_files:
         dest = backup_dir / db_file.name
+        src_conn = None
+        dst_conn = None
         try:
             src_conn = sqlite3.connect(str(db_file))
             dst_conn = sqlite3.connect(str(dest))
             src_conn.backup(dst_conn)
-            dst_conn.close()
-            src_conn.close()
         except Exception as e:
             return str(backup_dir), f"Failed to backup {db_file.name}: {e}"
+        finally:
+            for conn in (dst_conn, src_conn):
+                if conn is not None:
+                    try:
+                        conn.close()
+                    except Exception:
+                        pass
 
     return str(backup_dir), None
 
@@ -170,14 +177,21 @@ def _restore_databases(backup_dir: str):
         # Try to find original location
         for candidate in [DATA_DIR / db_backup.name, NEXO_HOME / db_backup.name, SRC_DIR / db_backup.name]:
             if candidate.is_file():
+                src_conn = None
+                dst_conn = None
                 try:
                     src_conn = sqlite3.connect(str(db_backup))
                     dst_conn = sqlite3.connect(str(candidate))
                     src_conn.backup(dst_conn)
-                    dst_conn.close()
-                    src_conn.close()
                 except Exception:
                     pass
+                finally:
+                    for conn in (dst_conn, src_conn):
+                        if conn is not None:
+                            try:
+                                conn.close()
+                            except Exception:
+                                pass
                 break
 
 

package/src/protocol_settings.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+"""Shared protocol-discipline settings loaded from calibration.json."""
+
+import json
+import os
+from pathlib import Path
+
+
+DEFAULT_PROTOCOL_STRICTNESS = "lenient"
+VALID_PROTOCOL_STRICTNESS = {"lenient", "strict", "learning"}
+
+
+def _nexo_home() -> Path:
+    return Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))).expanduser()
+
+
+def _calibration_path() -> Path:
+    return _nexo_home() / "brain" / "calibration.json"
+
+
+def normalize_protocol_strictness(value: str | None) -> str:
+    candidate = str(value or "").strip().lower()
+    aliases = {
+        "default": "lenient",
+        "normal": "lenient",
+        "off": "lenient",
+        "warn": "lenient",
+        "soft": "lenient",
+        "hard": "strict",
+        "guided": "learning",
+    }
+    candidate = aliases.get(candidate, candidate)
+    if candidate in VALID_PROTOCOL_STRICTNESS:
+        return candidate
+    return DEFAULT_PROTOCOL_STRICTNESS
+
+
+def get_protocol_strictness() -> str:
+    env_override = os.environ.get("NEXO_PROTOCOL_STRICTNESS", "").strip()
+    if env_override:
+        return normalize_protocol_strictness(env_override)
+
+    cal_path = _calibration_path()
+    if not cal_path.is_file():
+        return DEFAULT_PROTOCOL_STRICTNESS
+
+    try:
+        payload = json.loads(cal_path.read_text())
+    except Exception:
+        return DEFAULT_PROTOCOL_STRICTNESS
+
+    preferences = payload.get("preferences") if isinstance(payload, dict) else {}
+    candidate = ""
+    if isinstance(preferences, dict):
+        candidate = str(preferences.get("protocol_strictness", "") or "").strip()
+    if not candidate and isinstance(payload, dict):
+        candidate = str(payload.get("protocol_strictness", "") or "").strip()
+    return normalize_protocol_strictness(candidate)

package/src/public_contribution.py

@@ -14,7 +14,7 @@ import re
 import shutil
 import socket
 import subprocess
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timezone
 from pathlib import Path
 
 from runtime_power import load_schedule_config, save_schedule_config
@@ -33,8 +33,6 @@ STATUS_PENDING_AUTH = "pending_auth"
 STATUS_PAUSED_OPEN_PR = "paused_open_pr"
 STATUS_COOLDOWN = "cooldown"
 STATUS_OFF = "off"
-COOLDOWN_HOURS_MERGED = 168
-COOLDOWN_HOURS_CLOSED = 72
 VALID_MODES = {MODE_UNSET, MODE_OFF, MODE_DRAFT_PRS, MODE_PENDING_AUTH}
 VALID_STATUSES = {
     STATUS_UNSET,
@@ -224,10 +222,6 @@ def _parse_iso(ts: str | None) -> datetime | None:
         return None
 
 
-def _future_iso(hours: int) -> str:
-    return (_utcnow() + timedelta(hours=hours)).isoformat()
-
-
 def format_public_contribution_label(config: dict | None = None) -> str:
     cfg = normalize_public_contribution_config(config)
     if cfg["mode"] == MODE_DRAFT_PRS:
@@ -369,12 +363,13 @@ def refresh_public_contribution_state(config: dict | None = None) -> dict:
                 config["status"] = STATUS_PAUSED_OPEN_PR
                 save_public_contribution_config(config)
                 return config
+            resolution = "merged" if payload.get("mergedAt") else "closed"
             config["active_pr_url"] = ""
             config["active_pr_number"] = None
             config["active_branch"] = ""
-            cooldown_hours = COOLDOWN_HOURS_MERGED if payload.get("mergedAt") else COOLDOWN_HOURS_CLOSED
-            config["cooldown_until"] = _future_iso(cooldown_hours)
-            config["status"] = STATUS_COOLDOWN
+            config["cooldown_until"] = ""
+            config["status"] = STATUS_ACTIVE
+            config["last_result"] = f"resolved_pr:{resolution}:{payload.get('url') or ''}".rstrip(":")
             save_public_contribution_config(config)
             return config
         return _set_pending_auth(
@@ -384,7 +379,11 @@ def refresh_public_contribution_state(config: dict | None = None) -> dict:
 
     cooldown_until = _parse_iso(config.get("cooldown_until"))
     if cooldown_until and cooldown_until > _utcnow():
-        config["status"] = STATUS_COOLDOWN
+        # Legacy installs used a post-merge/close cooldown that blocked the next
+        # public contribution cycle even after maintainers resolved the Draft PR.
+        # Public contribution should pause only while the PR is still open.
+        config["cooldown_until"] = ""
+        config["status"] = STATUS_ACTIVE
         save_public_contribution_config(config)
         return config
 
@@ -430,9 +429,6 @@ def can_run_public_contribution(config: dict | None = None) -> tuple[bool, str,
         return False, "public contribution is disabled", config
     if config["status"] == STATUS_PAUSED_OPEN_PR:
         return False, "an active Draft PR is already open for this machine", config
-    cooldown_until = _parse_iso(config.get("cooldown_until"))
-    if cooldown_until and cooldown_until > _utcnow():
-        return False, f"cooldown until {cooldown_until.isoformat()}", config
     return True, "", config
 
 

package/src/public_evolution_queue.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+"""Durable queue for public-core ports discovered outside the public runner.
+
+Managed flows such as self-audit may apply a local/core fix inline. When that
+fix belongs in the public repository as well, we persist a normalized queue
+entry in ``evolution_log`` so the weekly public contribution cycle can port it
+later instead of losing the improvement inside one machine.
+"""
+
+import json
+import os
+import sqlite3
+from pathlib import Path
+
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))).expanduser()
+QUEUE_CLASSIFICATION = "public_port_queue"
+QUEUE_STATUS_PENDING = "pending_public_port"
+PUBLIC_ALLOWED_PREFIXES = (
+    "src/",
+    "bin/",
+    "tests/",
+    "templates/",
+    "hooks/",
+    "migrations/",
+    ".claude-plugin/",
+)
+
+
+def resolve_repo_root(nexo_code: str | os.PathLike[str] | None = None) -> Path | None:
+    raw = Path(
+        nexo_code
+        or os.environ.get("NEXO_CODE")
+        or str(NEXO_HOME)
+    ).expanduser()
+    candidates = []
+    if raw.name == "src":
+        candidates.append(raw.parent)
+    candidates.append(raw)
+    for candidate in candidates:
+        if (candidate / "package.json").exists():
+            return candidate.resolve()
+    return None
+
+
+def normalize_public_path(
+    filepath: str,
+    *,
+    repo_root: Path | None = None,
+) -> str:
+    text = str(filepath or "").strip()
+    if not text:
+        return ""
+
+    normalized_raw = text.replace("\\", "/").lstrip("./")
+    if any(
+        normalized_raw == prefix.rstrip("/")
+        or normalized_raw.startswith(prefix)
+        for prefix in PUBLIC_ALLOWED_PREFIXES
+    ):
+        return normalized_raw
+
+    repo_root = repo_root or resolve_repo_root()
+    if not repo_root:
+        return ""
+
+    candidate = Path(text).expanduser()
+    if not candidate.is_absolute():
+        candidate = repo_root / candidate
+    try:
+        rel = candidate.resolve().relative_to(repo_root.resolve()).as_posix()
+    except Exception:
+        for prefix in PUBLIC_ALLOWED_PREFIXES:
+            marker = normalized_raw.find(prefix)
+            if marker >= 0:
+                return normalized_raw[marker:]
+        return ""
+    if any(rel == prefix.rstrip("/") or rel.startswith(prefix) for prefix in PUBLIC_ALLOWED_PREFIXES):
+        return rel
+    return ""
+
+
+def is_public_core_path(filepath: str, *, repo_root: Path | None = None) -> bool:
+    return bool(normalize_public_path(filepath, repo_root=repo_root))
+
+
+def queue_public_port_candidate(
+    conn: sqlite3.Connection,
+    *,
+    title: str,
+    reasoning: str,
+    files_changed: list[str],
+    source: str,
+    metadata: dict | None = None,
+) -> dict:
+    row = conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='evolution_log'"
+    ).fetchone()
+    if not row:
+        return {"ok": False, "reason": "evolution_log_missing"}
+
+    repo_root = resolve_repo_root()
+    normalized_files: list[str] = []
+    seen: set[str] = set()
+    for filepath in files_changed:
+        rel = normalize_public_path(filepath, repo_root=repo_root)
+        if rel and rel not in seen:
+            normalized_files.append(rel)
+            seen.add(rel)
+    if not normalized_files:
+        return {"ok": False, "reason": "no_public_files"}
+
+    proposal = str(title or "").strip()[:300] or "Managed core autofix queued for public port"
+    clean_reasoning = str(reasoning or "").strip()[:4000] or "Queued for public-core port."
+    payload = dict(metadata or {})
+    payload.setdefault("source", source)
+    payload["files"] = normalized_files
+
+    existing = conn.execute(
+        """SELECT id, status
+           FROM evolution_log
+           WHERE classification = ?
+             AND proposal = ?
+             AND files_changed = ?
+             AND status IN (?, 'draft_pr_created', 'skipped_duplicate_existing_pr')
+           ORDER BY id DESC
+           LIMIT 1""",
+        (
+            QUEUE_CLASSIFICATION,
+            proposal,
+            json.dumps(normalized_files),
+            QUEUE_STATUS_PENDING,
+        ),
+    ).fetchone()
+    if existing:
+        return {
+            "ok": True,
+            "queued": False,
+            "log_id": int(existing["id"]),
+            "status": str(existing["status"] or ""),
+            "files_changed": normalized_files,
+        }
+
+    cur = conn.execute(
+        """INSERT INTO evolution_log (
+               cycle_number, dimension, proposal, classification, reasoning, status, files_changed, test_result
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+        (
+            0,
+            "public_core",
+            proposal,
+            QUEUE_CLASSIFICATION,
+            clean_reasoning,
+            QUEUE_STATUS_PENDING,
+            json.dumps(normalized_files),
+            json.dumps(payload, ensure_ascii=False),
+        ),
+    )
+    return {
+        "ok": True,
+        "queued": True,
+        "log_id": int(cur.lastrowid),
+        "status": QUEUE_STATUS_PENDING,
+        "files_changed": normalized_files,
+    }
+
+
+def list_pending_public_port_candidates(
+    conn: sqlite3.Connection,
+    *,
+    limit: int = 3,
+) -> list[dict]:
+    rows = conn.execute(
+        """SELECT id, created_at, proposal, reasoning, status, files_changed, test_result
+           FROM evolution_log
+           WHERE classification = ?
+             AND status = ?
+           ORDER BY created_at ASC, id ASC
+           LIMIT ?""",
+        (QUEUE_CLASSIFICATION, QUEUE_STATUS_PENDING, max(1, int(limit))),
+    ).fetchall()
+    results: list[dict] = []
+    for row in rows:
+        metadata = {}
+        raw_payload = str(row["test_result"] or "").strip()
+        if raw_payload:
+            try:
+                parsed = json.loads(raw_payload)
+                if isinstance(parsed, dict):
+                    metadata = parsed
+            except Exception:
+                metadata = {"raw": raw_payload}
+        files_changed = []
+        raw_files = str(row["files_changed"] or "").strip()
+        if raw_files:
+            try:
+                parsed_files = json.loads(raw_files)
+                if isinstance(parsed_files, list):
+                    files_changed = [str(item).strip() for item in parsed_files if str(item).strip()]
+            except Exception:
+                pass
+        results.append(
+            {
+                "id": int(row["id"]),
+                "created_at": str(row["created_at"] or ""),
+                "title": str(row["proposal"] or ""),
+                "reasoning": str(row["reasoning"] or ""),
+                "status": str(row["status"] or ""),
+                "files_changed": files_changed,
+                "metadata": metadata,
+            }
+        )
+    return results
+
+
+def update_public_port_candidate(
+    conn: sqlite3.Connection,
+    log_id: int,
+    *,
+    status: str,
+    metadata_patch: dict | None = None,
+) -> None:
+    row = conn.execute(
+        "SELECT test_result FROM evolution_log WHERE id = ? LIMIT 1",
+        (int(log_id),),
+    ).fetchone()
+    payload: dict = {}
+    if row and str(row["test_result"] or "").strip():
+        try:
+            parsed = json.loads(str(row["test_result"]))
+            if isinstance(parsed, dict):
+                payload = parsed
+        except Exception:
+            payload = {"raw": str(row["test_result"])}
+    if metadata_patch:
+        payload.update(metadata_patch)
+    conn.execute(
+        "UPDATE evolution_log SET status = ?, test_result = ? WHERE id = ?",
+        (status, json.dumps(payload, ensure_ascii=False), int(log_id)),
+    )

package/src/scripts/nexo-catchup.py

@@ -197,14 +197,14 @@ def main():
         log("Catch-Up already running; skipping overlapping invocation.")
         return
 
-    _heal_personal_schedules()
-    state = load_state()
-    tasks = catchup_candidates()
-
     ran = 0
     skipped = 0
     skipped_out_of_window = 0
     try:
+        _heal_personal_schedules()
+        state = load_state()
+        tasks = catchup_candidates()
+
         for candidate in tasks:
             name = candidate["cron_id"]
             if not candidate.get("missed"):
@@ -221,19 +221,19 @@ def main():
             log(f"  {name} — missed scheduled run due at {due_at}, catching up...")
             if run_task(candidate, state):
                 ran += 1
-    finally:
-        lock_handle.close()
 
-    if ran == 0 and skipped_out_of_window == 0:
-        log("All tasks up to date, nothing to catch up.")
-    elif ran >= 3:
-        # Many tasks caught up — ask CLI to assess system state
-        _cli_post_catchup_assessment(ran, skipped, state)
-    else:
-        suffix = f", {skipped_out_of_window} outside recovery window" if skipped_out_of_window else ""
-        log(f"Caught up {ran} tasks, {skipped} already current{suffix}.")
+        if ran == 0 and skipped_out_of_window == 0:
+            log("All tasks up to date, nothing to catch up.")
+        elif ran >= 3:
+            # Many tasks caught up — ask CLI to assess system state
+            _cli_post_catchup_assessment(ran, skipped, state)
+        else:
+            suffix = f", {skipped_out_of_window} outside recovery window" if skipped_out_of_window else ""
+            log(f"Caught up {ran} tasks, {skipped} already current{suffix}.")
 
-    log("=== Catch-Up complete ===")
+        log("=== Catch-Up complete ===")
+    finally:
+        lock_handle.close()
 
 
 def _cli_post_catchup_assessment(ran: int, skipped: int, state: dict):