nexo-brain 2.2.0 → 2.3.0

package/README.md

@@ -283,13 +283,13 @@ NEXO Brain doesn't just respond — it runs 15 autonomous processes in the backg
 | **prevent-sleep** | Always (daemon) | Keeps machine awake for nocturnal processes (caffeinate/systemd-inhibit) |
 | **evolution** | Weekly (Sun) | Self-improvement proposals — NEXO suggests and applies enhancements |
 | **followup-hygiene** | Weekly (Sun) | Normalizes statuses, flags stale followups, cleans orphans |
+| **learning-housekeep** | 03:15 daily | Dedup learnings, adjust weights by usage, process overdue reviews, reconcile decision outcomes |
 | **immune** | Every 30 min | Quarantine processing, memory promotion/rejection, synaptic pruning |
-| **synthesis** | Every 2 hours | Memory synthesis — discovers cross-memory patterns |
-| **backup** | Every hour | SQLite database backups |
-| **watchdog** | Every 5 min | Monitors services, LaunchAgents, and infrastructure health |
+| **synthesis** | 06:00 daily | Memory synthesis — discovers cross-memory patterns |
+| **watchdog** | Every 30 min | Monitors services, LaunchAgents, and infrastructure health |
 | **auto-close-sessions** | Every 5 min | Cleans stale sessions |
 
-All processes are defined in `src/crons/manifest.json` and auto-synced to your system by `nexo_update`. On macOS they run via LaunchAgents; on Linux via systemd user timers (or crontab fallback). Personal crons (your own scripts) are never touched by the sync. If your Mac was asleep during a scheduled process, the catch-up script re-runs everything in order when it wakes.
+Core processes are defined in `src/crons/manifest.json` and auto-synced to your system by `nexo_update`. On macOS they run via LaunchAgents; on Linux via systemd user timers. `tcc-approve`, `prevent-sleep`, and `backup` are platform/personal helpers — not in the manifest but listed above for completeness. Personal crons (your own scripts) are never touched by the sync. If your Mac was asleep during a scheduled process, the catch-up script re-runs everything in order when it wakes.
 
 ## Deep Sleep v2 — Overnight Learning (v2.1.0)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — Cognitive co-operator for Claude Code. Memory, emotional intelligence, overnight learning (Deep Sleep), cron management, trust scoring, and adaptive calibration.",
   "bin": {

package/scripts/migrate-v1.7-to-v1.8.py

@@ -39,7 +39,7 @@ MCP_OWNED_SECTIONS = [
     "Dissonance",
     "Disonancia",
     "Observe the User",
-    "Observar a Francisco",  # legacy personal CLAUDE.md files
+    "Observar a {{user}}",  # legacy personal CLAUDE.md files
     "Observar al Usuario",
     "Change Log",
     "Session Diary",
@@ -51,7 +51,7 @@ MCP_OWNED_SECTIONS = [
 BOOTSTRAP_SECTIONS = [
     "Startup",
     "User Profile",
-    "Francisco",  # legacy personal CLAUDE.md files
+    "{{user_name}}",  # legacy personal CLAUDE.md files
     "Formato",
     "Format",
     "Autonomy",

package/scripts/nexo-preflight.sh

@@ -0,0 +1,236 @@
+#!/bin/bash
+# ============================================================================
+# NEXO Preflight — CI / manual verification script
+# Checks: Python syntax, shell syntax, manifest<->file consistency,
+#         manifest<->watchdog consistency
+# Exit code: 0 if all PASS, 1 if any FAIL
+# Usage: bash scripts/nexo-preflight.sh
+# ============================================================================
+set -uo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+SRC="$REPO_ROOT/src"
+MANIFEST="$SRC/crons/manifest.json"
+WATCHDOG="$SRC/scripts/nexo-watchdog.sh"
+
+PASS=0
+FAIL=0
+WARN=0
+
+pass() { echo "  PASS  $1"; ((PASS++)); }
+fail() { echo "  FAIL  $1"; ((FAIL++)); }
+warn() { echo "  WARN  $1"; ((WARN++)); }
+
+echo "============================================================"
+echo "NEXO Preflight — $(date '+%Y-%m-%d %H:%M:%S')"
+echo "============================================================"
+
+# ── 1. py_compile for all Python scripts in src/scripts/ ──────────────────
+echo ""
+# Non-core scripts to exclude from compilation checks
+NON_CORE="check-context.py"
+
+echo "--- Check 1: Python syntax (src/scripts/*.py) ---"
+for pyfile in "$SRC"/scripts/*.py; do
+    # Skip " 2" duplicate files (backup copies)
+    [[ "$pyfile" == *" 2"* ]] && continue
+    [ -f "$pyfile" ] || continue
+    name=$(basename "$pyfile")
+    # Skip non-core scripts
+    for skip in $NON_CORE; do
+        [[ "$name" == "$skip" ]] && continue 2
+    done
+    if python3 -m py_compile "$pyfile" 2>/dev/null; then
+        pass "$name"
+    else
+        fail "$name — py_compile error"
+    fi
+done
+
+# ── 2. py_compile for auto_close_sessions.py ──────────────────────────────
+echo ""
+echo "--- Check 2: Python syntax (auto_close_sessions.py) ---"
+ACS="$SRC/auto_close_sessions.py"
+if [ -f "$ACS" ]; then
+    if python3 -m py_compile "$ACS" 2>/dev/null; then
+        pass "auto_close_sessions.py"
+    else
+        fail "auto_close_sessions.py — py_compile error"
+    fi
+else
+    fail "auto_close_sessions.py — file not found"
+fi
+
+# ── 3. bash -n for all shell scripts in src/scripts/ ─────────────────────
+echo ""
+echo "--- Check 3: Shell syntax (src/scripts/*.sh) ---"
+for shfile in "$SRC"/scripts/*.sh; do
+    # Skip " 2" duplicate files (backup copies)
+    [[ "$shfile" == *" 2"* ]] && continue
+    [ -f "$shfile" ] || continue
+    name=$(basename "$shfile")
+    if bash -n "$shfile" 2>/dev/null; then
+        pass "$name"
+    else
+        fail "$name — bash -n syntax error"
+    fi
+done
+
+# ── 4. Manifest<->file consistency ────────────────────────────────────────
+echo ""
+echo "--- Check 4: Manifest crons have existing script files ---"
+if [ ! -f "$MANIFEST" ]; then
+    fail "manifest.json not found at $MANIFEST"
+else
+    # Extract script paths from manifest crons
+    cron_scripts=$(python3 -c "
+import json, sys
+try:
+    m = json.load(open('$MANIFEST'))
+    for c in m.get('crons', []):
+        print(c.get('id', '?') + '|' + c.get('script', ''))
+except Exception as e:
+    print(f'ERROR|{e}', file=sys.stderr)
+    sys.exit(1)
+" 2>/dev/null)
+
+    if [ $? -ne 0 ]; then
+        fail "manifest.json — cannot parse JSON"
+    else
+        while IFS='|' read -r cron_id script_path; do
+            [ -z "$script_path" ] && continue
+            full_path="$SRC/$script_path"
+            if [ -f "$full_path" ]; then
+                pass "cron '$cron_id' -> $script_path exists"
+            else
+                fail "cron '$cron_id' -> $script_path NOT FOUND"
+            fi
+        done <<< "$cron_scripts"
+    fi
+fi
+
+# ── 5. Manifest<->watchdog MONITORS consistency ──────────────────────────
+echo ""
+echo "--- Check 5: Manifest crons present in watchdog MONITORS ---"
+if [ ! -f "$WATCHDOG" ]; then
+    fail "nexo-watchdog.sh not found at $WATCHDOG"
+else
+    # The watchdog dynamically builds MONITORS from manifest.json via
+    # _build_monitors_from_manifest(). Verify that function exists and
+    # references the manifest, plus check that any hardcoded PERSONAL_MONITORS
+    # use valid com.nexo.* plist IDs.
+
+    if grep -q "_build_monitors_from_manifest" "$WATCHDOG"; then
+        pass "watchdog dynamically loads MONITORS from manifest.json"
+    else
+        fail "watchdog does NOT reference _build_monitors_from_manifest"
+    fi
+
+    if grep -q 'MANIFEST_FILE' "$WATCHDOG"; then
+        pass "watchdog references MANIFEST_FILE"
+    else
+        fail "watchdog does NOT reference MANIFEST_FILE for dynamic loading"
+    fi
+
+    # Check that any hardcoded personal monitors have valid format
+    personal_count=$(grep -c '|com\.nexo\.' "$WATCHDOG" 2>/dev/null || echo 0)
+    if [ "$personal_count" -gt 0 ]; then
+        pass "watchdog has $personal_count personal monitor entries"
+    else
+        pass "watchdog has no hardcoded personal monitors (all from manifest)"
+    fi
+fi
+
+# ── 6. Manifest<->README consistency ─────────────────────────────────────
+echo ""
+echo "--- Check 6: Manifest crons mentioned in README ---"
+README="$REPO_ROOT/README.md"
+if [ -f "$README" ] && [ -f "$MANIFEST" ]; then
+    manifest_ids=$(python3 -c "
+import json
+m = json.load(open('$MANIFEST'))
+for c in m.get('crons', []):
+    print(c['id'])
+" 2>/dev/null)
+
+    for cid in $manifest_ids; do
+        if grep -qE "\*\*${cid}\*\*|${cid}" "$README" 2>/dev/null; then
+            pass "cron '$cid' documented in README"
+        else
+            fail "cron '$cid' NOT in README"
+        fi
+    done
+else
+    warn "README.md or manifest.json not found, skipping"
+fi
+
+# ── 7. Smoke tests ──────────────────────────────────────────────────────
+echo ""
+echo "--- Check 7: Smoke tests ---"
+
+# 7a: catchup weekday conversion (manifest 0=Sunday -> python 6)
+WEEKDAY_TEST=$(python3 -c "
+# Simulate the conversion from catchup.py
+manifest_weekday = 0  # Sunday in cron/launchd
+py_weekday = (manifest_weekday - 1) % 7  # Should be 6 (Sunday in Python)
+assert py_weekday == 6, f'Expected 6 (Sunday), got {py_weekday}'
+# Also test Monday
+assert (1 - 1) % 7 == 0, 'Monday should be 0'
+# Saturday
+assert (6 - 1) % 7 == 5, 'Saturday should be 5'
+print('OK')
+" 2>&1)
+if [ "$WEEKDAY_TEST" = "OK" ]; then
+    pass "catchup weekday conversion (manifest 0=Sun -> python 6)"
+else
+    fail "catchup weekday conversion: $WEEKDAY_TEST"
+fi
+
+# 7b: change_log schema uses what_changed (not description)
+SCHEMA_TEST=$(python3 -c "
+import sys
+sys.path.insert(0, '$SRC')
+# Verify change_log columns match what learning-housekeep uses
+with open('$SRC/db/_core.py') as f:
+    core = f.read()
+if 'what_changed' in core:
+    print('OK')
+else:
+    print('FAIL: what_changed not found in _core.py')
+" 2>&1)
+if [ "$SCHEMA_TEST" = "OK" ]; then
+    pass "change_log schema uses what_changed (matches reconciler)"
+else
+    fail "change_log schema: $SCHEMA_TEST"
+fi
+
+# 7c: reconciler queries use correct columns for change_log
+RECONCILER_TEST=$(python3 -c "
+with open('$SRC/scripts/nexo-learning-housekeep.py') as f:
+    code = f.read()
+# Find the change_log section of _reconcile_decision_outcome
+cl_section = code[code.index('# Check change_log'):code.index('return None', code.index('# Check change_log'))]
+if 'what_changed LIKE' in cl_section:
+    print('OK')
+else:
+    print('FAIL: change_log section does not use what_changed')
+" 2>&1)
+if [ "$RECONCILER_TEST" = "OK" ]; then
+    pass "reconciler uses correct change_log columns"
+else
+    fail "reconciler columns: $RECONCILER_TEST"
+fi
+
+# ── Summary ───────────────────────────────────────────────────────────────
+echo ""
+echo "============================================================"
+echo "Results: $PASS PASS, $FAIL FAIL, $WARN WARN"
+echo "============================================================"
+
+if [ "$FAIL" -gt 0 ]; then
+    echo "PREFLIGHT FAILED"
+    exit 1
+else
+    echo "PREFLIGHT OK"
+    exit 0
+fi

package/src/auto_update.py

@@ -93,6 +93,27 @@ def _read_package_version() -> str:
     return "unknown"
 
 
+# ── Hook sync ────────────────────────────────────────────────────────
+
+def _sync_hooks():
+    """Copy hook scripts from src/hooks/ to NEXO_HOME/hooks/ after a git pull."""
+    import shutil
+    hooks_src = SRC_DIR / "hooks"
+    hooks_dest = NEXO_HOME / "hooks"
+    if not hooks_src.is_dir():
+        return
+    hooks_dest.mkdir(parents=True, exist_ok=True)
+    synced = 0
+    for f in hooks_src.iterdir():
+        if f.is_file() and f.suffix == ".sh":
+            dest = hooks_dest / f.name
+            shutil.copy2(str(f), str(dest))
+            os.chmod(str(dest), 0o755)
+            synced += 1
+    if synced:
+        _log(f"Synced {synced} hook(s) to {hooks_dest}")
+
+
 # ── Git-based auto-update ────────────────────────────────────────────
 
 def _check_git_updates() -> str | None:
@@ -140,6 +161,10 @@ def _check_git_updates() -> str | None:
     # Run DB migrations after pull
     _run_db_migrations()
 
+    # Sync hooks to NEXO_HOME (nexo-brain.js copies them on install,
+    # but auto-update via git pull bypasses nexo-brain.js)
+    _sync_hooks()
+
     msg = f"Auto-updated: {old_version} -> {new_version}" if old_version != new_version else f"Auto-updated (v{new_version}, new commits)"
     _log(msg)
     return msg

package/src/crons/manifest.json

@@ -70,35 +70,28 @@
     {
       "id": "followup-hygiene",
       "script": "scripts/nexo-followup-hygiene.py",
-      "schedule": {"hour": 5, "minute": 0},
+      "schedule": {"hour": 5, "minute": 0, "weekday": 0},
       "description": "Clean stale followups, archive completed, validate dates",
       "core": true
     },
     {
       "id": "synthesis",
       "script": "scripts/nexo-synthesis.py",
-      "interval_seconds": 7200,
-      "description": "Periodic synthesis — cross-reference learnings, decisions, changes",
+      "schedule": {"hour": 6, "minute": 0},
+      "description": "Daily synthesis — cross-reference learnings, decisions, changes",
       "core": true
     },
     {
       "id": "auto-close-sessions",
-      "script": "scripts/nexo-auto-close-sessions.py",
+      "script": "auto_close_sessions.py",
       "interval_seconds": 300,
       "description": "Close stale sessions that lost their parent process",
       "core": true
     },
-    {
-      "id": "github-monitor",
-      "script": "scripts/nexo-github-monitor.py",
-      "schedule": {"hour": 8, "minute": 0},
-      "description": "Monitor GitHub repo — issues, PRs, stars, auto-respond",
-      "core": true
-    },
-    {
+{
       "id": "catchup",
       "script": "scripts/nexo-catchup.py",
-      "schedule": {"hour": 8, "minute": 30},
+      "run_at_load": true,
       "description": "Morning catchup briefing for the user",
       "core": true
     }

package/src/crons/sync.py

@@ -42,15 +42,56 @@ def load_manifest() -> list[dict]:
     return data.get("crons", [])
 
 
+def _copy_script_to_nexo_home(src: Path) -> Path:
+    """Copy a script from NEXO_CODE to NEXO_HOME/scripts/ for Sandbox compatibility.
+
+    macOS Sandbox blocks LaunchAgents from executing scripts in ~/Documents/.
+    We copy scripts to NEXO_HOME/scripts/ which is typically ~/claude/scripts/
+    or ~/.nexo/scripts/ — both outside the Sandbox restricted paths.
+    """
+    dest_dir = NEXO_HOME / "scripts"
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    if src.is_dir():
+        import shutil
+        dest = dest_dir / src.name
+        if dest.exists():
+            shutil.rmtree(dest)
+        shutil.copytree(src, dest)
+        return dest
+    else:
+        dest = dest_dir / src.name
+        import shutil
+        shutil.copy2(src, dest)
+        dest.chmod(0o755)
+        return dest
+
+
 def build_plist(cron: dict) -> dict:
     """Build a macOS LaunchAgent plist dict from a manifest entry."""
     cron_id = cron["id"]
     label = f"{LABEL_PREFIX}{cron_id}"
-    script_path = str(NEXO_CODE / cron["script"])
+    script_src = NEXO_CODE / cron["script"]
     script_type = cron.get("type", "python")
 
+    # Copy scripts to NEXO_HOME/scripts/ to avoid macOS Sandbox restrictions
+    script_dest = _copy_script_to_nexo_home(script_src)
+    script_path = str(script_dest)
+
+    # Also copy the wrapper and any subdirectories (e.g., deep-sleep/)
+    wrapper_src = NEXO_CODE / "scripts" / "nexo-cron-wrapper.sh"
+    wrapper_dest = _copy_script_to_nexo_home(wrapper_src)
+    wrapper_path = str(wrapper_dest)
+
+    # Copy script subdirectories if they exist (e.g., deep-sleep/ for nexo-deep-sleep.sh)
+    script_name = script_src.stem  # e.g., "nexo-deep-sleep"
+    subdir_name = script_name.replace("nexo-", "")  # e.g., "deep-sleep"
+    subdir_src = NEXO_CODE / "scripts" / subdir_name
+    if subdir_src.is_dir():
+        _copy_script_to_nexo_home(subdir_src)
+
     if script_type == "shell":
-        program_args = ["/bin/bash", script_path]
+        program_args = ["/bin/bash", wrapper_path, cron_id, "/bin/bash", script_path]
     else:
         # Find python3
         python_candidates = [
@@ -64,7 +105,7 @@ def build_plist(cron: dict) -> dict:
             if Path(p).exists():
                 python_bin = p
                 break
-        program_args = [python_bin, script_path]
+        program_args = ["/bin/bash", wrapper_path, cron_id, python_bin, script_path]
 
     plist = {
         "Label": label,
@@ -84,7 +125,9 @@ def build_plist(cron: dict) -> dict:
     }
 
     # Schedule
-    if "interval_seconds" in cron:
+    if cron.get("run_at_load"):
+        plist["RunAtLoad"] = True
+    elif "interval_seconds" in cron:
         plist["StartInterval"] = cron["interval_seconds"]
     elif "schedule" in cron:
         cal = {}
@@ -126,6 +169,8 @@ def plist_needs_update(existing_path: Path, new_plist: dict) -> bool:
         return True
     if existing.get("StartCalendarInterval") != new_plist.get("StartCalendarInterval"):
         return True
+    if existing.get("RunAtLoad") != new_plist.get("RunAtLoad"):
+        return True
     return False
 
 
@@ -157,8 +202,12 @@ def unload_plist(plist_path: Path, dry_run: bool):
 
 
 def sync(dry_run: bool = False):
-    if platform.system() != "Darwin":
-        log("Not macOS — cron sync only supports LaunchAgents. Skipping.")
+    system = platform.system()
+    if system == "Linux":
+        sync_linux(dry_run)
+        return
+    if system != "Darwin":
+        log(f"Unsupported platform: {system}. Skipping.")
         return
 
     LOG_DIR.mkdir(parents=True, exist_ok=True)
@@ -210,6 +259,102 @@ def sync(dry_run: bool = False):
     log("Sync complete.")
 
 
+def sync_linux(dry_run: bool = False):
+    """Sync manifest to systemd user timers (Linux)."""
+    unit_dir = Path.home() / ".config" / "systemd" / "user"
+    unit_dir.mkdir(parents=True, exist_ok=True)
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+    manifest_crons = load_manifest()
+    wrapper_src = NEXO_CODE / "scripts" / "nexo-cron-wrapper.sh"
+    wrapper_dest = _copy_script_to_nexo_home(wrapper_src)
+
+    log(f"Manifest: {len(manifest_crons)} core crons")
+
+    python_bin = "/usr/bin/python3"
+    for p in ["/usr/bin/python3", "/usr/local/bin/python3"]:
+        if Path(p).exists():
+            python_bin = p
+            break
+
+    for cron in manifest_crons:
+        cron_id = cron["id"]
+        script_src = NEXO_CODE / cron["script"]
+        script_dest = _copy_script_to_nexo_home(script_src)
+        script_type = cron.get("type", "python")
+
+        # Copy subdirectories
+        subdir_name = script_src.stem.replace("nexo-", "")
+        subdir_src = NEXO_CODE / "scripts" / subdir_name
+        if subdir_src.is_dir():
+            _copy_script_to_nexo_home(subdir_src)
+
+        if script_type == "shell":
+            exec_cmd = f"/bin/bash {wrapper_dest} {cron_id} /bin/bash {script_dest}"
+        else:
+            exec_cmd = f"/bin/bash {wrapper_dest} {cron_id} {python_bin} {script_dest}"
+
+        service_path = unit_dir / f"nexo-{cron_id}.service"
+        timer_path = unit_dir / f"nexo-{cron_id}.timer"
+
+        service_content = f"""[Unit]
+Description=NEXO: {cron.get('description', cron_id)}
+
+[Service]
+Type=oneshot
+ExecStart={exec_cmd}
+Environment=NEXO_HOME={NEXO_HOME}
+Environment=NEXO_CODE={NEXO_CODE}
+Environment=HOME={Path.home()}
+"""
+
+        if cron.get("run_at_load"):
+            timer_spec = "OnBootSec=0"
+        elif "interval_seconds" in cron:
+            timer_spec = f"OnUnitActiveSec={cron['interval_seconds']}s\nOnBootSec=60s"
+        elif "schedule" in cron:
+            s = cron["schedule"]
+            h, m = s.get("hour", 0), s.get("minute", 0)
+            if "weekday" in s:
+                days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+                timer_spec = f"OnCalendar={days[s['weekday']]} *-*-* {h:02d}:{m:02d}:00"
+            else:
+                timer_spec = f"OnCalendar=*-*-* {h:02d}:{m:02d}:00"
+        else:
+            log(f"  SKIP {cron_id}: no schedule or interval")
+            continue
+
+        timer_content = f"""[Unit]
+Description=NEXO timer: {cron.get('description', cron_id)}
+
+[Timer]
+{timer_spec}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+"""
+
+        if dry_run:
+            log(f"  DRY-RUN: would install {cron_id}")
+            continue
+
+        service_path.write_text(service_content)
+        timer_path.write_text(timer_content)
+        log(f"  Installed: {cron_id}")
+
+    if not dry_run:
+        subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+        for cron in manifest_crons:
+            subprocess.run(
+                ["systemctl", "--user", "enable", "--now", f"nexo-{cron['id']}.timer"],
+                capture_output=True
+            )
+        log("systemd timers enabled.")
+
+    log("Sync complete.")
+
+
 if __name__ == "__main__":
     dry_run = "--dry-run" in sys.argv
     if dry_run:

package/src/db/__init__.py

@@ -87,3 +87,16 @@ from db._evolution import (
     insert_evolution_metric, get_latest_metrics,
     insert_evolution_log, get_evolution_history, update_evolution_log_status,
 )
+
+# Cron execution history
+from db._cron_runs import (
+    cron_run_start, cron_run_end, cron_runs_recent, cron_runs_summary,
+)
+
+# Skills
+from db._skills import (
+    create_skill, get_skill, list_skills, search_skills,
+    update_skill, delete_skill,
+    record_usage as record_skill_usage,
+    match_skills, merge_skills, get_skill_stats, decay_unused_skills,
+)