nexo-brain 6.4.0 → 7.0.0

package/src/cli.py

@@ -37,6 +37,7 @@ import contextlib
 import io
 import json
 import os
+import paths
 import shutil
 import subprocess
 import sys
@@ -303,7 +304,7 @@ def _scripts_list(args):
         print(json.dumps(scripts, indent=2))
     else:
         if not scripts:
-            print("No personal scripts found in", NEXO_HOME / "scripts")
+            print("No personal scripts found in", paths.core_scripts_dir())
             return 0
         # Table output
         name_w = max(len(s["name"]) for s in scripts)
@@ -347,7 +348,7 @@ def _scripts_classify(args):
 
     entries = report.get("entries", [])
     if not entries:
-        print("No scripts directory found:", report.get("scripts_dir", NEXO_HOME / "scripts"))
+        print("No scripts directory found:", report.get("scripts_dir", paths.core_scripts_dir()))
         return 0
 
     path_w = max(len(Path(entry["path"]).name) for entry in entries)
@@ -452,6 +453,49 @@ def _scripts_unschedule(args):
     return 0 if result.get("ok") else 1
 
 
+def _scripts_set_enabled(args, enabled):
+    from script_registry import set_personal_script_enabled
+
+    result = set_personal_script_enabled(args.name, enabled)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok") else 1
+    if not result.get("ok"):
+        print(result.get("error", "Failed to toggle script"), file=sys.stderr)
+        return 1
+    verb = "enabled" if enabled else "disabled"
+    if result.get("changed"):
+        print(f"Script {result['name']} {verb}.")
+    else:
+        print(f"Script {result['name']} already {verb}.")
+    return 0
+
+
+def _scripts_status(args):
+    from script_registry import get_personal_script_status
+
+    result = get_personal_script_status(args.name)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok") else 1
+    if not result.get("ok"):
+        print(result.get("error", "Failed to read status"), file=sys.stderr)
+        return 1
+    state = "enabled" if result.get("enabled") else "DISABLED"
+    print(f"{result.get('name')} [{result.get('classification')}] -> {state}")
+    last = result.get("last_run") or {}
+    if last:
+        exit_code = last.get("exit_code")
+        started = last.get("started_at") or "?"
+        print(f"  last run: {started} (exit={exit_code})")
+        summary = (last.get("summary") or "").strip()
+        if summary:
+            print(f"  summary: {summary[:120]}")
+    else:
+        print("  last run: (none)")
+    return 0
+
+
 def _scripts_remove(args):
     from script_registry import remove_personal_script
 
@@ -495,8 +539,8 @@ def _scripts_run(args):
 
     # Only inject DB paths for core scripts
     if is_core:
-        env["NEXO_DB"] = str(NEXO_HOME / "data" / "nexo.db")
-        env["NEXO_COGNITIVE_DB"] = str(NEXO_HOME / "data" / "cognitive.db")
+        env["NEXO_DB"] = str(paths.db_path())
+        env["NEXO_COGNITIVE_DB"] = str(paths.data_dir() / "cognitive.db")
 
     # Timeout
     timeout = None
@@ -988,7 +1032,7 @@ def _update(args):
     # the sensory-register buffer. Keeps a .pre-v5.4.1.bak backup the first
     # time it runs on a given host.
     try:
-        buf = NEXO_HOME / "brain" / "session_buffer.jsonl"
+        buf = paths.brain_dir() / "session_buffer.jsonl"
         marker = buf.with_suffix(".jsonl.pre-v5.4.1.bak")
         if buf.is_file() and not marker.is_file():
             raw = buf.read_text(errors="ignore").splitlines()
@@ -1120,7 +1164,7 @@ def _write_calibration_default_resonance(tier: str) -> None:
     …). This helper keeps the CLI path writing to both calibration.json
     AND schedule.json so the two surfaces never disagree.
     """
-    cal_path = NEXO_HOME / "brain" / "calibration.json"
+    cal_path = paths.brain_dir() / "calibration.json"
     try:
         cal_path.parent.mkdir(parents=True, exist_ok=True)
         if cal_path.exists():
@@ -2116,6 +2160,19 @@ def main():
     unschedule_p.add_argument("name", help="Script name or path")
     unschedule_p.add_argument("--json", action="store_true", help="JSON output")
 
+    # scripts enable / disable / status (Plan F0.2.2)
+    enable_p = scripts_sub.add_parser("enable", help="Enable a personal script (cron wrapper will run it again)")
+    enable_p.add_argument("name", help="Script name or path")
+    enable_p.add_argument("--json", action="store_true", help="JSON output")
+
+    disable_p = scripts_sub.add_parser("disable", help="Disable a personal script (cron wrapper will skip it)")
+    disable_p.add_argument("name", help="Script name or path")
+    disable_p.add_argument("--json", action="store_true", help="JSON output")
+
+    status_p = scripts_sub.add_parser("status", help="Show enabled flag + last cron_runs row for a script")
+    status_p.add_argument("name", help="Script name or path")
+    status_p.add_argument("--json", action="store_true", help="JSON output")
+
     # scripts remove
     remove_p = scripts_sub.add_parser("remove", help="Remove a personal script and any attached schedules")
     remove_p.add_argument("name", help="Script name or path")
@@ -2394,6 +2451,12 @@ def main():
             return _scripts_doctor(args)
         elif args.scripts_command == "call":
             return _scripts_call(args)
+        elif args.scripts_command == "enable":
+            return _scripts_set_enabled(args, True)
+        elif args.scripts_command == "disable":
+            return _scripts_set_enabled(args, False)
+        elif args.scripts_command == "status":
+            return _scripts_status(args)
         else:
             scripts_parser.print_help()
             return 0

package/src/cron_recovery.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import json
 import os
+import paths
 import plistlib
 import sqlite3
 import contextlib
@@ -16,8 +17,8 @@ NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent
 LAUNCH_AGENTS_DIR = Path.home() / "Library" / "LaunchAgents"
 OPTIONALS_FILE = NEXO_HOME / "config" / "optionals.json"
 SCHEDULE_FILE = NEXO_HOME / "config" / "schedule.json"
-DB_PATH = NEXO_HOME / "data" / "nexo.db"
-STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
+DB_PATH = paths.db_path()
+STATE_FILE = paths.operations_dir() / ".catchup-state.json"
 
 
 def _local_timezone():
@@ -84,7 +85,7 @@ def resolve_declared_schedule(cron: dict) -> dict:
 
 def load_enabled_crons() -> list[dict]:
     manifest_candidates = [
-        NEXO_HOME / "crons" / "manifest.json",
+        paths.crons_dir() / "manifest.json",
         NEXO_CODE / "crons" / "manifest.json",
     ]
     optionals = _load_json(OPTIONALS_FILE, {})

package/src/db/_personal_scripts.py

@@ -122,7 +122,9 @@ def upsert_personal_script(
             metadata_json = excluded.metadata_json,
             created_by = COALESCE(NULLIF(personal_scripts.created_by, ''), excluded.created_by),
             source = excluded.source,
-            enabled = excluded.enabled,
+            -- Plan F0.2.2: preserve operator-set `enabled` flag across sync runs.
+            -- Sync defaults to enabled=True for INSERTs; on UPDATE we keep
+            -- whatever the operator (or `nexo scripts disable`) set.
             has_inline_metadata = excluded.has_inline_metadata,
             last_synced_at = excluded.last_synced_at,
             updated_at = excluded.updated_at

package/src/db/_skills.py

@@ -11,6 +11,7 @@ Executable skills are indexed in SQLite but sourced from filesystem definitions.
 import datetime
 import json
 import os
+import paths
 import re
 import shutil
 from pathlib import Path
@@ -25,7 +26,7 @@ NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parents[1])))
 
 NEXO_ROOT = NEXO_CODE.parent
-PERSONAL_SKILLS_DIR = NEXO_HOME / "skills"
+PERSONAL_SKILLS_DIR = paths.personal_skills_dir()
 
 
 def _resolve_core_skills_dir() -> Path:

package/src/desktop_bridge.py

@@ -27,11 +27,13 @@ def _nexo_home() -> Path:
 
 
 def _calibration_path() -> Path:
-    return _nexo_home() / "brain" / "calibration.json"
+    import paths
+    return paths.brain_dir() / "calibration.json"
 
 
 def _profile_path() -> Path:
-    return _nexo_home() / "brain" / "profile.json"
+    import paths
+    return paths.brain_dir() / "profile.json"
 
 
 def _read_json(path: Path) -> dict:

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