nexo-brain 6.5.0 → 7.0.0

package/src/doctor/providers/boot.py

@@ -13,7 +13,8 @@ NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 
 def check_db_exists() -> DoctorCheck:
     """Check that the main database file exists and is readable."""
-    db_path = NEXO_HOME / "data" / "nexo.db"
+    import paths
+    db_path = paths.db_path()
     if db_path.is_file():
         size_kb = db_path.stat().st_size / 1024
         return DoctorCheck(
@@ -37,9 +38,21 @@ def check_db_exists() -> DoctorCheck:
 
 
 def check_required_dirs() -> DoctorCheck:
-    """Check that required NEXO_HOME directories exist."""
-    required = ["data", "scripts", "plugins", "crons", "hooks", "coordination", "operations", "logs"]
-    missing = [d for d in required if not (NEXO_HOME / d).is_dir()]
+    """Check that required NEXO_HOME directories exist (post-F0.6 layout
+    or pre-F0.6 fallback)."""
+    import paths
+    # Each required dir maps to one of the new locations OR the legacy fallback.
+    required_helpers = [
+        ("data", paths.data_dir()),
+        ("scripts", paths.core_scripts_dir()),
+        ("plugins", paths.core_plugins_dir()),
+        ("crons", paths.crons_dir()),
+        ("hooks", paths.core_hooks_dir()),
+        ("coordination", paths.coordination_dir()),
+        ("operations", paths.operations_dir()),
+        ("logs", paths.logs_dir()),
+    ]
+    missing = [name for (name, path) in required_helpers if not path.is_dir()]
 
     if not missing:
         return DoctorCheck(
@@ -47,7 +60,7 @@ def check_required_dirs() -> DoctorCheck:
             tier="boot",
             status="healthy",
             severity="info",
-            summary=f"All {len(required)} required directories present",
+            summary=f"All {len(required_helpers)} required directories present",
         )
 
     return DoctorCheck(
@@ -57,7 +70,7 @@ def check_required_dirs() -> DoctorCheck:
         severity="warn" if len(missing) < 3 else "error",
         summary=f"{len(missing)} required director{'y' if len(missing) == 1 else 'ies'} missing",
         evidence=[f"Missing: {d}" for d in missing],
-        repair_plan=[f"mkdir -p {NEXO_HOME / d}" for d in missing],
+        repair_plan=[f"mkdir -p {dict(required_helpers)[d]}" for d in missing],
     )
 
 
@@ -107,7 +120,8 @@ def check_disk_space() -> DoctorCheck:
 
 def check_wrapper_scripts() -> DoctorCheck:
     """Check that cron wrapper script exists."""
-    wrapper = NEXO_HOME / "scripts" / "nexo-cron-wrapper.sh"
+    import paths
+    wrapper = paths.core_scripts_dir() / "nexo-cron-wrapper.sh"
     if wrapper.is_file():
         return DoctorCheck(
             id="boot.wrapper_scripts",

package/src/doctor/providers/deep.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import datetime as dt
 import json
 import os
+import paths
 import time
 from pathlib import Path
 
@@ -67,7 +68,7 @@ def _self_audit_enabled() -> bool | 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"
+    summary_file = paths.logs_dir() / "self-audit-summary.json"
     age = _file_age_seconds(summary_file)
 
     if age is None:
@@ -154,7 +155,7 @@ def check_schema_version() -> DoctorCheck:
     """Check DB schema version is present and reasonable."""
     try:
         import sqlite3
-        db_path = NEXO_HOME / "data" / "nexo.db"
+        db_path = paths.db_path()
         if not db_path.is_file():
             return DoctorCheck(
                 id="deep.schema_version",
@@ -187,7 +188,7 @@ def check_schema_version() -> DoctorCheck:
 
 def check_preflight_summary() -> DoctorCheck:
     """Check runtime preflight summary."""
-    summary_file = NEXO_HOME / "logs" / "runtime-preflight-summary.json"
+    summary_file = paths.logs_dir() / "runtime-preflight-summary.json"
     age = _file_age_seconds(summary_file)
 
     if age is None:
@@ -242,7 +243,7 @@ def check_preflight_summary() -> DoctorCheck:
 
 def check_watchdog_smoke() -> DoctorCheck:
     """Check watchdog smoke summary."""
-    summary_file = NEXO_HOME / "logs" / "watchdog-smoke-summary.json"
+    summary_file = paths.logs_dir() / "watchdog-smoke-summary.json"
     age = _file_age_seconds(summary_file)
 
     if age is None:
@@ -300,7 +301,7 @@ def check_learning_count() -> DoctorCheck:
     """Check learning count as a health proxy."""
     try:
         import sqlite3
-        db_path = NEXO_HOME / "data" / "nexo.db"
+        db_path = paths.db_path()
         if not db_path.is_file():
             return DoctorCheck(
                 id="deep.learning_count",

package/src/doctor/providers/runtime.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import datetime as dt
 import json
 import os
+import paths
 import platform
 import plistlib
 import re
@@ -423,7 +424,7 @@ def _extract_declared_file_targets(args: dict, cwd: str) -> set[str]:
 
 
 def _load_active_conditioned_learnings() -> list[dict]:
-    db_path = NEXO_HOME / "data" / "nexo.db"
+    db_path = paths.db_path()
     if not db_path.is_file():
         return []
     try:
@@ -622,7 +623,7 @@ def _recent_codex_conditioned_file_discipline_status(*, days: int = 7, max_files
 
 
 def _open_protocol_debt_summary(*debt_types: str) -> dict:
-    db_path = NEXO_HOME / "data" / "nexo.db"
+    db_path = paths.db_path()
     summary = {"available": False, "open_total": 0, "counts": {}}
     if not db_path.is_file() or not debt_types:
         return summary
@@ -661,7 +662,7 @@ def _client_assumption_regressions() -> list[str]:
     if not src_root.is_dir():
         return []
     src_root = src_root.resolve()
-    backup_root = (NEXO_HOME / "backups").resolve()
+    backup_root = (paths.backups_dir()).resolve()
     contrib_root = (NEXO_HOME / "contrib").resolve()
     allowed_relative_paths = {
         Path("scripts") / "deep-sleep" / "collect.py",
@@ -715,7 +716,7 @@ def _load_json(path: Path) -> dict:
 
 
 def _latest_cron_run_age_seconds(cron_id: str) -> float | None:
-    db_path = NEXO_HOME / "data" / "nexo.db"
+    db_path = paths.db_path()
     if not db_path.is_file():
         return None
     try:
@@ -748,7 +749,7 @@ def _latest_cron_run_age_seconds(cron_id: str) -> float | None:
 def _latest_periodic_summary(kind: str) -> dict | None:
     pattern = f"*-{kind}-summary.json"
     candidates: list[tuple[str, Path]] = []
-    for path in (NEXO_HOME / "operations" / "deep-sleep").glob(pattern):
+    for path in (paths.operations_dir() / "deep-sleep").glob(pattern):
         try:
             payload = json.loads(path.read_text())
         except Exception:
@@ -830,7 +831,7 @@ def _enabled_optionals() -> dict[str, bool]:
 
 def _enabled_manifest_crons() -> list[dict]:
     manifest_candidates = [
-        NEXO_HOME / "crons" / "manifest.json",
+        paths.crons_dir() / "manifest.json",
         NEXO_CODE / "crons" / "manifest.json",
     ]
     optionals = _enabled_optionals()
@@ -1049,7 +1050,7 @@ def _plist_runtime_paths(plist_data: dict) -> list[str]:
 
 
 def _recent_permission_denial(cron_id: str, max_age_seconds: int = 7 * 86400) -> bool:
-    stderr_path = NEXO_HOME / "logs" / f"{cron_id}-stderr.log"
+    stderr_path = paths.logs_dir() / f"{cron_id}-stderr.log"
     age = _file_age_seconds(stderr_path)
     if age is None or age > max_age_seconds:
         return False
@@ -1135,7 +1136,7 @@ def _sync_launchagents_from_manifest() -> tuple[bool, list[str]]:
 
 def check_immune_status() -> DoctorCheck:
     """Check immune system status freshness."""
-    status_file = NEXO_HOME / "coordination" / "immune-status.json"
+    status_file = paths.coordination_dir() / "immune-status.json"
     age = _file_age_seconds(status_file)
 
     if age is None:
@@ -1230,7 +1231,7 @@ def check_immune_status() -> DoctorCheck:
 
 def check_watchdog_status() -> DoctorCheck:
     """Check watchdog status freshness."""
-    status_file = NEXO_HOME / "operations" / "watchdog-status.json"
+    status_file = paths.operations_dir() / "watchdog-status.json"
     age = _file_age_seconds(status_file)
 
     if age is None:
@@ -1307,7 +1308,7 @@ def check_stale_sessions() -> DoctorCheck:
     """Check for stale sessions from DB."""
     try:
         import sqlite3
-        db_path = NEXO_HOME / "data" / "nexo.db"
+        db_path = paths.db_path()
         if not db_path.is_file():
             return DoctorCheck(
                 id="runtime.stale_sessions",
@@ -1358,7 +1359,7 @@ def check_cron_freshness() -> DoctorCheck:
     """Check cron_runs table for recent executions."""
     try:
         import sqlite3
-        db_path = NEXO_HOME / "data" / "nexo.db"
+        db_path = paths.db_path()
         if not db_path.is_file():
             return DoctorCheck(
                 id="runtime.cron_freshness",
@@ -2404,7 +2405,7 @@ def check_protocol_compliance() -> DoctorCheck:
     try:
         import sqlite3
 
-        db_path = NEXO_HOME / "data" / "nexo.db"
+        db_path = paths.db_path()
         if db_path.is_file():
             conn = sqlite3.connect(str(db_path), timeout=2)
             try:
@@ -2775,7 +2776,7 @@ def check_release_artifact_sync() -> DoctorCheck:
 
 
 def check_release_trace_hygiene() -> DoctorCheck:
-    db_path = NEXO_HOME / "data" / "nexo.db"
+    db_path = paths.db_path()
     if not db_path.is_file():
         return DoctorCheck(
             id="runtime.release_trace_hygiene",
@@ -2906,8 +2907,8 @@ def check_release_trace_hygiene() -> DoctorCheck:
 
 
 def check_state_watchers() -> DoctorCheck:
-    db_path = NEXO_HOME / "data" / "nexo.db"
-    summary_path = NEXO_HOME / "operations" / "state-watchers-status.json"
+    db_path = paths.db_path()
+    summary_path = paths.operations_dir() / "state-watchers-status.json"
     active_watchers = 0
     if db_path.is_file():
         try:
@@ -3007,7 +3008,7 @@ def check_state_watchers() -> DoctorCheck:
 
 
 def check_automation_telemetry(days: int = 7) -> DoctorCheck:
-    db_path = NEXO_HOME / "data" / "nexo.db"
+    db_path = paths.db_path()
     if not db_path.is_file():
         return DoctorCheck(
             id="runtime.automation_telemetry",

package/src/evolution_cycle.py

@@ -7,6 +7,7 @@ v1.1 (future): sandbox execution of auto-approved changes.
 
 import json
 import os
+import paths
 import shutil
 import subprocess
 import sqlite3
@@ -16,17 +17,17 @@ from pathlib import Path
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(NEXO_HOME)))
-NEXO_DB = NEXO_HOME / "data" / "nexo.db"
+NEXO_DB = paths.db_path()
 SANDBOX_DIR = NEXO_HOME / "sandbox" / "workspace"
-SNAPSHOTS_DIR = NEXO_HOME / "snapshots"
-RESTORE_LOG = NEXO_HOME / "logs" / "snapshot-restores.log"
+SNAPSHOTS_DIR = paths.snapshots_dir()
+RESTORE_LOG = paths.logs_dir() / "snapshot-restores.log"
 
 # Evolution config: brain/ (canonical) > cortex/ (legacy) > NEXO_CODE (dev)
 def _resolve_evolution_file(name: str) -> Path:
-    for candidate in [NEXO_HOME / "brain" / name, NEXO_HOME / "cortex" / name, NEXO_CODE / name]:
+    for candidate in [paths.brain_dir() / name, NEXO_HOME / "cortex" / name, NEXO_CODE / name]:
         if candidate.exists():
             return candidate
-    return NEXO_HOME / "brain" / name  # default canonical path
+    return paths.brain_dir() / name  # default canonical path
 
 OBJECTIVE_FILE = _resolve_evolution_file("evolution-objective.json")
 PROMPT_FILE = _resolve_evolution_file("evolution-prompt.md")
@@ -233,7 +234,7 @@ def dry_run_restore_test() -> bool:
     _nexo_code = Path(os.environ.get("NEXO_CODE", ""))
     restore_script = None
     for candidate in [_nexo_code / "scripts" / "nexo-snapshot-restore.sh",
-                      NEXO_HOME / "scripts" / "nexo-snapshot-restore.sh"]:
+                      paths.core_scripts_dir() / "nexo-snapshot-restore.sh"]:
         if candidate.exists():
             restore_script = candidate
             break

package/src/health_check.py

@@ -47,7 +47,8 @@ def _check_runtime() -> dict:
 
 
 def _check_database() -> dict:
-    db_path = _nexo_home() / "data" / "nexo.db"
+    import paths
+    db_path = paths.db_path()
     out: dict[str, Any] = {"path": str(db_path), "exists": db_path.is_file()}
     if not out["exists"]:
         out["status"] = "error"
@@ -108,7 +109,8 @@ def _check_mcp() -> dict:
 
 
 def _check_errors(hours: int = 24) -> dict:
-    ops_dir = _nexo_home() / "operations"
+    import paths
+    ops_dir = paths.operations_dir()
     out: dict[str, Any] = {"dir": str(ops_dir)}
     if not ops_dir.is_dir():
         out["recent_errors"] = 0