nexo-brain 2.3.1 → 2.4.0

package/src/scripts/nexo-catchup.py

@@ -18,10 +18,32 @@ import sys
 from datetime import datetime, timedelta
 from pathlib import Path
 
-CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
-
 HOME = Path.home()
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(HOME / ".nexo")))
+
+
+def _resolve_claude_cli() -> Path:
+    """Find claude CLI: saved path > PATH > common locations."""
+    saved = NEXO_HOME / "config" / "claude-cli-path"
+    if saved.exists():
+        p = Path(saved.read_text().strip())
+        if p.exists():
+            return p
+    import shutil
+    found = shutil.which("claude")
+    if found:
+        return Path(found)
+    for candidate in [
+        HOME / ".local" / "bin" / "claude",
+        HOME / ".npm-global" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ]:
+        if candidate.exists():
+            return candidate
+    return HOME / ".local" / "bin" / "claude"  # last resort
+
+
+CLAUDE_CLI = _resolve_claude_cli()
 LOG_DIR = NEXO_HOME / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
 LOG_FILE = LOG_DIR / "catchup.log"
@@ -47,7 +69,10 @@ def _resolve_python() -> str:
 
 NEXO_PYTHON = _resolve_python()
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent.parent)))
-MANIFEST = NEXO_CODE / "crons" / "manifest.json"
+# Look for manifest in NEXO_HOME first (packaged install), then NEXO_CODE (dev/repo)
+_manifest_home = NEXO_HOME / "crons" / "manifest.json"
+_manifest_code = NEXO_CODE / "crons" / "manifest.json"
+MANIFEST = _manifest_home if _manifest_home.exists() else _manifest_code
 
 
 def _load_tasks_from_manifest() -> list[tuple]:

package/src/scripts/nexo-daily-self-audit.py

@@ -43,7 +43,27 @@ RUNTIME_PREFLIGHT_SUMMARY = LOG_DIR / "runtime-preflight-summary.json"
 WATCHDOG_SMOKE_SUMMARY = LOG_DIR / "watchdog-smoke-summary.json"
 RESTORE_LOG = LOG_DIR / "snapshot-restores.log"
 CORTEX_LOG_DIR = NEXO_HOME / "brain" / "logs"
-CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
+def _resolve_claude_cli() -> Path:
+    """Find claude CLI: saved path > PATH > common locations."""
+    import shutil as _shutil
+    saved = NEXO_HOME / "config" / "claude-cli-path"
+    if saved.exists():
+        p = Path(saved.read_text().strip())
+        if p.exists():
+            return p
+    found = _shutil.which("claude")
+    if found:
+        return Path(found)
+    for candidate in [
+        Path.home() / ".local" / "bin" / "claude",
+        Path.home() / ".npm-global" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ]:
+        if candidate.exists():
+            return candidate
+    return Path.home() / ".local" / "bin" / "claude"
+
+CLAUDE_CLI = _resolve_claude_cli()
 
 findings = []
 

package/src/scripts/nexo-evolution-run.py

@@ -64,7 +64,27 @@ IMMUTABLE_FILES = {
 }
 
 # ── Claude CLI path ──────────────────────────────────────────────────────
-CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
+def _resolve_claude_cli() -> Path:
+    """Find claude CLI: saved path > PATH > common locations."""
+    import shutil as _shutil
+    saved = NEXO_HOME / "config" / "claude-cli-path"
+    if saved.exists():
+        p = Path(saved.read_text().strip())
+        if p.exists():
+            return p
+    found = _shutil.which("claude")
+    if found:
+        return Path(found)
+    for candidate in [
+        Path.home() / ".local" / "bin" / "claude",
+        Path.home() / ".npm-global" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ]:
+        if candidate.exists():
+            return candidate
+    return Path.home() / ".local" / "bin" / "claude"
+
+CLAUDE_CLI = _resolve_claude_cli()
 
 # ── Logging ──────────────────────────────────────────────────────────────
 LOG_DIR.mkdir(parents=True, exist_ok=True)

package/src/scripts/nexo-postmortem-consolidator.py

@@ -42,7 +42,27 @@ MEMORY_DIR = NEXO_HOME / "memory"
 MEMORY_INDEX = MEMORY_DIR / "MEMORY.md"
 HISTORY_FILE = NEXO_HOME / "coordination" / "postmortem-history.json"
 CONSOLIDATION_LOG = NEXO_HOME / "logs" / "postmortem-consolidation.log"
-CLAUDE_CLI = HOME / ".local" / "bin" / "claude"
+def _resolve_claude_cli() -> Path:
+    """Find claude CLI: saved path > PATH > common locations."""
+    import shutil as _shutil
+    saved = NEXO_HOME / "config" / "claude-cli-path"
+    if saved.exists():
+        p = Path(saved.read_text().strip())
+        if p.exists():
+            return p
+    found = _shutil.which("claude")
+    if found:
+        return Path(found)
+    for candidate in [
+        HOME / ".local" / "bin" / "claude",
+        HOME / ".npm-global" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ]:
+        if candidate.exists():
+            return candidate
+    return HOME / ".local" / "bin" / "claude"
+
+CLAUDE_CLI = _resolve_claude_cli()
 SESSION_BUFFER = NEXO_HOME / "brain" / "session_buffer.jsonl"
 
 TODAY = date.today()
@@ -379,6 +399,7 @@ def main():
         return
 
     log("=== NEXO Post-Mortem Consolidator v2 starting ===")
+    had_errors = False
 
     # Stage 1: Collect data
     data = collect_data()
@@ -392,27 +413,31 @@ def main():
         if not success:
             log("Stage 2 failed (CLI unavailable or error). "
                 "Skipping intelligent consolidation. Stage 3 (sensory + force) will still run.")
+            had_errors = True
 
     # Stage 3: Sensory Register (mechanical, kept from v1)
     try:
         process_sensory_register()
     except Exception as e:
         log(f"Sensory register failed: {e}")
+        had_errors = True
 
     # Stage 3b: Force analysis (mechanical, kept from v1)
     try:
         analyze_force_events()
     except Exception as e:
         log(f"Force analysis failed: {e}")
+        had_errors = True
 
-    # Register successful run
-    try:
-        state_file = NEXO_HOME / "operations" / ".catchup-state.json"
-        state = json.loads(state_file.read_text()) if state_file.exists() else {}
-        state["postmortem"] = datetime.now().isoformat()
-        state_file.write_text(json.dumps(state, indent=2))
-    except Exception:
-        pass
+    # Register successful run only if no stages failed
+    if not had_errors:
+        try:
+            state_file = NEXO_HOME / "operations" / ".catchup-state.json"
+            state = json.loads(state_file.read_text()) if state_file.exists() else {}
+            state["postmortem"] = datetime.now().isoformat()
+            state_file.write_text(json.dumps(state, indent=2))
+        except Exception:
+            pass
 
     mark_done()
     log("=== Consolidation v2 complete ===")

package/src/scripts/nexo-sleep.py

@@ -49,7 +49,26 @@ SLEEP_LOG = COORD_DIR / "sleep-log.json"
 MEMORY_MD = NEXO_HOME / "memory" / "MEMORY.md"
 NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 CLAUDE_MEM_DB = Path.home() / ".claude-mem" / "claude-mem.db"
-CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
+def _resolve_claude_cli() -> Path:
+    """Find claude CLI: saved path > PATH > common locations."""
+    saved = NEXO_HOME / "config" / "claude-cli-path"
+    if saved.exists():
+        p = Path(saved.read_text().strip())
+        if p.exists():
+            return p
+    found = shutil.which("claude")
+    if found:
+        return Path(found)
+    for candidate in [
+        Path.home() / ".local" / "bin" / "claude",
+        Path.home() / ".npm-global" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ]:
+        if candidate.exists():
+            return candidate
+    return Path.home() / ".local" / "bin" / "claude"
+
+CLAUDE_CLI = _resolve_claude_cli()
 
 LAST_RUN_FILE = COORD_DIR / "sleep-last-run"
 LOCK_FILE = COORD_DIR / "sleep.lock"
@@ -534,6 +553,7 @@ def main():
 
         run_log = {"date": str(TODAY), "started": TIMESTAMP,
                    "stage_a": None, "stage_b": None, "completed": None}
+        sleep_had_errors = False
 
         # Stage A: Housekeeping (mechanical)
         if start_phase == "stage_a":
@@ -555,7 +575,8 @@ def main():
 
             if "error" in dream_result:
                 log(f"Stage B: Dreaming failed ({dream_result['error']}). "
-                    "Stage A cleanup completed successfully. Marking done to avoid retry loop.")
+                    "Stage A cleanup completed successfully. Not marking catchup to allow retry.")
+                sleep_had_errors = True
             else:
                 # Stage B2: Execute actions from CLI output
                 actions_file = COORD_DIR / "sleep-actions.json"
@@ -575,14 +596,15 @@ def main():
         append_sleep_log(run_log)
         log(f"NEXO Sleep v2 complete at {run_log['completed']}")
 
-        # Register for catch-up
-        try:
-            state_file = NEXO_HOME / "operations" / ".catchup-state.json"
-            st = json.loads(state_file.read_text()) if state_file.exists() else {}
-            st["sleep"] = datetime.now().isoformat()
-            state_file.write_text(json.dumps(st, indent=2))
-        except Exception:
-            pass
+        # Register for catch-up only if all stages succeeded
+        if not sleep_had_errors:
+            try:
+                state_file = NEXO_HOME / "operations" / ".catchup-state.json"
+                st = json.loads(state_file.read_text()) if state_file.exists() else {}
+                st["sleep"] = datetime.now().isoformat()
+                state_file.write_text(json.dumps(st, indent=2))
+            except Exception:
+                pass
 
     finally:
         try:

package/src/scripts/nexo-synthesis.py

@@ -26,7 +26,27 @@ NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 OUTPUT_FILE = COORD_DIR / "daily-synthesis.md"
 LAST_RUN_FILE = COORD_DIR / "synthesis-last-run"
 LOCK_FILE = COORD_DIR / "synthesis.lock"
-CLAUDE_CLI = HOME / ".local" / "bin" / "claude"
+def _resolve_claude_cli() -> Path:
+    """Find claude CLI: saved path > PATH > common locations."""
+    import shutil as _shutil
+    saved = NEXO_HOME / "config" / "claude-cli-path"
+    if saved.exists():
+        p = Path(saved.read_text().strip())
+        if p.exists():
+            return p
+    found = _shutil.which("claude")
+    if found:
+        return Path(found)
+    for candidate in [
+        HOME / ".local" / "bin" / "claude",
+        HOME / ".npm-global" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ]:
+        if candidate.exists():
+            return candidate
+    return HOME / ".local" / "bin" / "claude"
+
+CLAUDE_CLI = _resolve_claude_cli()
 
 TODAY = date.today()
 TODAY_STR = TODAY.isoformat()
@@ -109,17 +129,17 @@ def collect_data() -> dict:
         (TODAY_STR,)
     )
 
-    # Overdue reminders
+    # Overdue reminders (schema: description, date, status uppercase)
     data["overdue_reminders"] = safe_query(
-        "SELECT id, title, due_date FROM reminders "
-        "WHERE status='PENDING' AND due_date <= ? ORDER BY due_date",
+        "SELECT id, description, date FROM reminders "
+        "WHERE status='PENDING' AND date <= ? ORDER BY date",
         (TODAY_STR,)
     )
 
-    # Pending followups
+    # Pending followups (schema: description, date, status uppercase)
     data["pending_followups"] = safe_query(
-        "SELECT id, title, description, due_date FROM followups "
-        "WHERE status='pending' ORDER BY due_date"
+        "SELECT id, description, date FROM followups "
+        "WHERE status='PENDING' ORDER BY date"
     )
 
     # Guard stats
@@ -240,13 +260,13 @@ def fallback_synthesis(data: dict):
     if data.get("overdue_reminders"):
         lines.append("## Overdue Reminders")
         for r in data["overdue_reminders"][:10]:
-            lines.append(f"- #{r.get('id', '?')} {r.get('title', '')} (due {r.get('due_date', '?')})")
+            lines.append(f"- #{r.get('id', '?')} {r.get('description', '')} (due {r.get('date', '?')})")
         lines.append("")
 
     if data.get("pending_followups"):
         lines.append("## Pending Followups")
         for f in data["pending_followups"][:10]:
-            lines.append(f"- #{f.get('id', '?')} {f.get('title', '')} (due {f.get('due_date', '?')})")
+            lines.append(f"- #{f.get('id', '?')} {f.get('description', '')} (due {f.get('date', '?')})")
         lines.append("")
 
     OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)

package/src/scripts/nexo-update.sh

@@ -34,13 +34,20 @@ read_version() {
     python3 -c "import json; print(json.load(open('$PACKAGE_JSON')).get('version','unknown'))" 2>/dev/null || echo "unknown"
 }
 
-# --- Step 1: Check for uncommitted changes in src/ ---
-log "Checking for uncommitted changes in src/..."
+# --- Check if this is a git repo ---
+if [ ! -d "$REPO_DIR/.git" ] && [ ! -f "$REPO_DIR/.git" ]; then
+    err "ABORTED: Not a git repository at $REPO_DIR"
+    err "For packaged installs, use: npm update -g nexo-brain"
+    exit 1
+fi
+
+# --- Step 1: Check for uncommitted changes in entire worktree ---
+log "Checking for uncommitted changes..."
 cd "$REPO_DIR"
 
-if [ -n "$(git status --porcelain -- src/ 2>/dev/null)" ]; then
-    err "ABORTED: Uncommitted changes in src/"
-    git status --short -- src/
+if [ -n "$(git status --porcelain 2>/dev/null)" ]; then
+    err "ABORTED: Uncommitted changes in worktree"
+    git status --short
     exit 1
 fi
 log "Working tree clean."
@@ -48,6 +55,11 @@ log "Working tree clean."
 # Record current state
 OLD_VERSION="$(read_version)"
 OLD_COMMIT="$(git rev-parse HEAD)"
+REQ_FILE="$SRC_DIR/requirements.txt"
+OLD_REQ_HASH=""
+if [ -f "$REQ_FILE" ]; then
+    OLD_REQ_HASH="$(shasum -a 256 "$REQ_FILE" | cut -d' ' -f1)"
+fi
 log "Current: v${OLD_VERSION} (${OLD_COMMIT:0:8})"
 
 # --- Step 2: Backup databases ---
@@ -94,6 +106,54 @@ fi
 NEW_VERSION="$(read_version)"
 log "New version: v${NEW_VERSION}"
 
+# --- Step 4b: Reinstall Python dependencies if requirements.txt changed ---
+NEW_REQ_HASH=""
+if [ -f "$REQ_FILE" ]; then
+    NEW_REQ_HASH="$(shasum -a 256 "$REQ_FILE" | cut -d' ' -f1)"
+fi
+
+DEPS_CHANGED=false
+if [ "$OLD_REQ_HASH" != "$NEW_REQ_HASH" ]; then
+    DEPS_CHANGED=true
+fi
+
+reinstall_pip_deps() {
+    local VENV_PIP="$NEXO_HOME/.venv/bin/pip"
+    if [ -f "$REQ_FILE" ]; then
+        if [ -x "$VENV_PIP" ]; then
+            "$VENV_PIP" install --quiet -r "$REQ_FILE" || return 1
+        else
+            python3 -m pip install --quiet -r "$REQ_FILE" --break-system-packages 2>/dev/null || return 1
+        fi
+    fi
+    return 0
+}
+
+if [ "$DEPS_CHANGED" = true ] || [ "$OLD_VERSION" != "$NEW_VERSION" ]; then
+    log "Reinstalling Python dependencies..."
+    if ! reinstall_pip_deps; then
+        err "pip install failed! Rolling back..."
+        git reset --hard "$OLD_COMMIT"
+        reinstall_pip_deps || warn "pip rollback also had issues"
+        if [ -d "$BACKUP_DIR" ]; then
+            for db in "$BACKUP_DIR"/*.db; do
+                [ -f "$db" ] || continue
+                BASENAME="$(basename "$db")"
+                for candidate in "$NEXO_HOME/data/$BASENAME" "$NEXO_HOME/$BASENAME" "$SRC_DIR/$BASENAME"; do
+                    if [ -f "$candidate" ]; then
+                        cp "$db" "$candidate"
+                        warn "  Restored: $BASENAME"
+                        break
+                    fi
+                done
+            done
+        fi
+        err "Rolled back to ${OLD_COMMIT:0:8}. Databases restored."
+        exit 1
+    fi
+    log "Python dependencies updated."
+fi
+
 # --- Step 5: Run migrations if version changed ---
 if [ "$OLD_VERSION" != "$NEW_VERSION" ]; then
     log "Version changed: ${OLD_VERSION} -> ${NEW_VERSION}"
@@ -101,6 +161,8 @@ if [ "$OLD_VERSION" != "$NEW_VERSION" ]; then
     if ! (cd "$SRC_DIR" && python3 -c "import db; db.init_db()" 2>&1); then
         err "Migration failed! Rolling back..."
         git reset --hard "$OLD_COMMIT"
+        # Reinstall pip deps from restored old requirements.txt
+        reinstall_pip_deps || warn "pip rollback also had issues"
         # Restore DB backups
         if [ -d "$BACKUP_DIR" ]; then
             for db in "$BACKUP_DIR"/*.db; do
@@ -115,7 +177,7 @@ if [ "$OLD_VERSION" != "$NEW_VERSION" ]; then
                 done
             done
         fi
-        err "Rolled back to ${OLD_COMMIT:0:8}. Databases restored."
+        err "Rolled back to ${OLD_COMMIT:0:8}. Databases and deps restored."
         exit 1
     fi
     log "Migrations applied."
@@ -128,6 +190,8 @@ log "Verifying server.py import..."
 if ! (cd "$SRC_DIR" && python3 -c "import server" 2>&1); then
     err "Import verification failed! Rolling back..."
     git reset --hard "$OLD_COMMIT"
+    # Reinstall pip deps from restored old requirements.txt
+    reinstall_pip_deps || warn "pip rollback also had issues"
     if [ -d "$BACKUP_DIR" ]; then
         for db in "$BACKUP_DIR"/*.db; do
             [ -f "$db" ] || continue
@@ -141,10 +205,48 @@ if ! (cd "$SRC_DIR" && python3 -c "import server" 2>&1); then
             done
         done
     fi
-    err "Rolled back to ${OLD_COMMIT:0:8}. Databases restored."
+    err "Rolled back to ${OLD_COMMIT:0:8}. Databases and deps restored."
     exit 1
 fi
 
+# --- Step 7: Sync hooks to NEXO_HOME ---
+HOOKS_SRC="$SRC_DIR/hooks"
+HOOKS_DEST="$NEXO_HOME/hooks"
+if [ -d "$HOOKS_SRC" ]; then
+    mkdir -p "$HOOKS_DEST"
+    SYNCED=0
+    for hook in "$HOOKS_SRC"/*.sh; do
+        [ -f "$hook" ] || continue
+        cp "$hook" "$HOOKS_DEST/$(basename "$hook")"
+        chmod 755 "$HOOKS_DEST/$(basename "$hook")"
+        SYNCED=$((SYNCED + 1))
+    done
+    if [ "$SYNCED" -gt 0 ]; then
+        log "Synced $SYNCED hook(s) to $HOOKS_DEST"
+    fi
+fi
+
+# --- Step 8: Sync cron definitions with manifest ---
+CRON_SYNC="$SRC_DIR/crons/sync.py"
+CRON_SYNC_OK=false
+if [ -f "$CRON_SYNC" ]; then
+    log "Syncing cron definitions..."
+    if NEXO_HOME="$NEXO_HOME" NEXO_CODE="$SRC_DIR" python3 "$CRON_SYNC" 2>&1; then
+        log "Cron definitions synced."
+        CRON_SYNC_OK=true
+    else
+        warn "Cron sync failed (non-fatal). Installed manifest NOT refreshed to avoid divergence."
+    fi
+fi
+
+# --- Step 8b: Refresh installed manifest for catchup/watchdog (only if sync succeeded) ---
+if $CRON_SYNC_OK && [ -d "$SRC_DIR/crons" ]; then
+    mkdir -p "$NEXO_HOME/crons"
+    cp -f "$SRC_DIR/crons/"*.json "$NEXO_HOME/crons/" 2>/dev/null
+    cp -f "$SRC_DIR/crons/"*.py "$NEXO_HOME/crons/" 2>/dev/null
+    log "Refreshed installed crons manifest."
+fi
+
 # --- Done ---
 echo ""
 log "========================================="