nexo-brain 2.3.1 → 2.3.2

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 "========================================="

package/src/scripts/nexo-watchdog.sh

@@ -45,7 +45,12 @@ log() { echo "[$TS] $1" >> "$LOG"; }
 # The NEXO_CODE env var must point to the repo src/ directory.
 # Add personal (non-manifest) monitors to PERSONAL_MONITORS below.
 NEXO_CODE="${NEXO_CODE:-$(cd "$(dirname "$0")/.." 2>/dev/null && pwd)}"
-MANIFEST_FILE="$NEXO_CODE/crons/manifest.json"
+# Look for manifest in NEXO_HOME first (packaged install), then NEXO_CODE (dev/repo)
+if [ -f "$NEXO_HOME/crons/manifest.json" ]; then
+  MANIFEST_FILE="$NEXO_HOME/crons/manifest.json"
+else
+  MANIFEST_FILE="$NEXO_CODE/crons/manifest.json"
+fi
 
 _build_monitors_from_manifest() {
   if [ ! -f "$MANIFEST_FILE" ]; then
@@ -53,18 +58,22 @@ _build_monitors_from_manifest() {
     return
   fi
   python3 -c "
-import json, sys
+import json, sys, platform
 
 nexo_home = '$NEXO_HOME'
+is_mac = platform.system() == 'Darwin'
 
 with open('$MANIFEST_FILE') as f:
     data = json.load(f)
 
 for c in data.get('crons', []):
     cid = c['id']
-    # Derive human-readable name from id
     name = cid.replace('-', ' ').title()
-    plist_id = 'com.nexo.' + cid
+    # Use the right service identifier per platform
+    if is_mac:
+        svc_id = 'com.nexo.' + cid
+    else:
+        svc_id = 'nexo-' + cid + '.timer'
     stdout_log = nexo_home + '/logs/' + cid + '-stdout.log'
     stderr_log = nexo_home + '/logs/' + cid + '-stderr.log'
 
@@ -98,7 +107,7 @@ for c in data.get('crons', []):
     mon_type = 'core' if c.get('core') else 'personal'
     proc_grep = ''  # manifest crons are one-shot, no persistent process
 
-    print(f'{name}|{plist_id}|{stdout_log}|{stderr_log}|{max_stale}|{proc_grep}|{schedule_desc}|{mon_type}')
+    print(f'{name}|{svc_id}|{stdout_log}|{stderr_log}|{max_stale}|{proc_grep}|{schedule_desc}|{mon_type}')
 " 2>/dev/null
 }
 
@@ -140,7 +149,12 @@ IS_MACOS=false
 log_repair() { echo "[$TS] REPAIR: $1" >> "$REPAIR_LOG"; log "REPAIR: $1"; }
 
 is_loaded() {
-  $IS_MACOS && launchctl list "$1" &>/dev/null
+  if $IS_MACOS; then
+    launchctl list "$1" &>/dev/null
+  else
+    # On Linux, check if the systemd timer is enabled
+    systemctl --user is-enabled "$1" &>/dev/null
+  fi
 }
 
 # ============================================================================
@@ -179,6 +193,36 @@ try_repair_launchagent() {
   return 1
 }
 
+try_repair_systemd() {
+  $IS_MACOS && return 1
+  local timer_unit="$1"
+  local service_unit="${timer_unit%.timer}.service"
+
+  # Repair 1: Timer not enabled — try to enable and start
+  if ! systemctl --user is-enabled "$timer_unit" &>/dev/null; then
+    systemctl --user daemon-reload 2>/dev/null
+    systemctl --user enable --now "$timer_unit" 2>/dev/null
+    sleep 1
+    if systemctl --user is-enabled "$timer_unit" &>/dev/null; then
+      log_repair "$timer_unit: enabled and started"
+      return 0
+    fi
+    return 1
+  fi
+
+  # Repair 2: Timer enabled but not active — start it
+  if ! systemctl --user is-active "$timer_unit" &>/dev/null; then
+    systemctl --user start "$timer_unit" 2>/dev/null
+    sleep 1
+    if systemctl --user is-active "$timer_unit" &>/dev/null; then
+      log_repair "$timer_unit: restarted"
+      return 0
+    fi
+  fi
+
+  return 1
+}
+
 try_repair_cron() {
   local script="$1"
 
@@ -195,29 +239,26 @@ try_repair_cron() {
 }
 
 try_reexecute_missed_cron() {
-  $IS_MACOS || return 1
-  # Re-execute a cron that missed its scheduled run
-  # Extracts ProgramArguments from the plist and runs them
-  local plist_id="$1"
-  local plist_file="$HOME_DIR/Library/LaunchAgents/${plist_id}.plist"
+  local svc_id="$1"
 
-  if [ ! -f "$plist_file" ]; then
-    log "Re-execute skipped: no plist for $plist_id"
-    return 1
-  fi
+  if $IS_MACOS; then
+    # macOS: extract command from plist and run it
+    local plist_file="$HOME_DIR/Library/LaunchAgents/${svc_id}.plist"
 
-  # Extract the full command from plist
-  local cmd
-  cmd=$(python3 -c "
+    if [ ! -f "$plist_file" ]; then
+      log "Re-execute skipped: no plist for $svc_id"
+      return 1
+    fi
+
+    local cmd
+    cmd=$(python3 -c "
 import plistlib, sys
 try:
     with open('$plist_file', 'rb') as f:
         d = plistlib.load(f)
     args = d.get('ProgramArguments', [])
-    # Skip KeepAlive services (they should be running, not re-executed)
     if d.get('KeepAlive'):
         sys.exit(1)
-    # Skip services without a schedule (RunAtLoad only)
     if not d.get('StartCalendarInterval') and not d.get('StartInterval'):
         sys.exit(1)
     print(' '.join(args))
@@ -225,28 +266,36 @@ except:
     sys.exit(1)
 " 2>/dev/null)
 
-  if [ -z "$cmd" ] || [ $? -ne 0 ]; then
-    return 1
-  fi
-
-  log "Re-executing missed cron: $plist_id → $cmd"
-  # Run in background with timeout (5 min max)
-  timeout 300 bash -c "$cmd" >> "$LOG_DIR/watchdog-reexec.log" 2>&1 &
-  local pid=$!
+    if [ -z "$cmd" ] || [ $? -ne 0 ]; then
+      return 1
+    fi
 
-  # Wait briefly and check if it started ok
-  sleep 2
-  if kill -0 "$pid" 2>/dev/null || wait "$pid" 2>/dev/null; then
-    log_repair "$plist_id: re-executed missed cron (PID $pid)"
-    return 0
+    log "Re-executing missed cron: $svc_id → $cmd"
+    timeout 300 bash -c "$cmd" >> "$LOG_DIR/watchdog-reexec.log" 2>&1 &
+    local pid=$!
+    sleep 2
+    if kill -0 "$pid" 2>/dev/null || wait "$pid" 2>/dev/null; then
+      log_repair "$svc_id: re-executed missed cron (PID $pid)"
+      return 0
+    else
+      log "Re-execute failed for $svc_id"
+      return 1
+    fi
   else
-    log "Re-execute failed for $plist_id"
-    return 1
+    # Linux: start the corresponding service unit directly
+    local service_unit="${svc_id%.timer}.service"
+    log "Re-executing missed cron: $svc_id → systemctl start $service_unit"
+    if systemctl --user start "$service_unit" 2>/dev/null; then
+      log_repair "$svc_id: re-executed via systemctl start $service_unit"
+      return 0
+    else
+      log "Re-execute failed for $svc_id"
+      return 1
+    fi
   fi
 }
 
 try_verify_repair() {
-  $IS_MACOS || return 1
   # After Level 2 repair, wait and verify the service is healthy
   local plist_id="$1"
   local log_stdout="$2"
@@ -388,20 +437,26 @@ for monitor in "${MONITORS[@]}"; do
   error_count=0
   proc_alive="n/a"
 
-  # Check 1: LaunchAgent loaded?
+  # Check 1: Service loaded? (launchd on macOS, systemd on Linux)
   if is_loaded "$plist_id"; then
     loaded="yes"
   else
     loaded="no"
-    # AUTO-REPAIR: try to bootstrap
-    if try_repair_launchagent "$plist_id" "$proc_grep"; then
+    # AUTO-REPAIR: try platform-appropriate repair
+    repair_ok=false
+    if $IS_MACOS; then
+      try_repair_launchagent "$plist_id" "$proc_grep" && repair_ok=true
+    else
+      try_repair_systemd "$plist_id" && repair_ok=true
+    fi
+    if $repair_ok; then
       loaded="yes"
       status="HEALED"
-      details="${details}Self-healed: bootstrapped. "
+      details="${details}Self-healed: service re-registered. "
       TOTAL_HEALED=$((TOTAL_HEALED + 1))
     else
       status="FAIL"
-      details="${details}Not loaded in launchctl (repair failed). "
+      details="${details}Service not loaded (repair failed). "
     fi
   fi
 
@@ -411,9 +466,10 @@ for monitor in "${MONITORS[@]}"; do
       proc_alive="yes"
     else
       proc_alive="no"
-      # AUTO-REPAIR: try to kickstart
+      # AUTO-REPAIR: try to kickstart (platform-appropriate)
       if [ "$status" != "FAIL" ] && [ "$status" != "HEALED" ]; then
-        if try_repair_launchagent "$plist_id" "$proc_grep"; then
+        if ($IS_MACOS && try_repair_launchagent "$plist_id" "$proc_grep") || \
+           (! $IS_MACOS && try_repair_systemd "$plist_id"); then
           proc_alive="yes"
           status="HEALED"
           details="${details}Self-healed: kickstarted. "
@@ -820,7 +876,7 @@ if [ "$TOTAL_FAIL" -gt 0 ]; then
 Schedule: ${m_sched}
 Type: ${m_type}
 Failure reason: ${m_details}
-Plist: ~/Library/LaunchAgents/${m_plist}.plist
+Service config: $($IS_MACOS && echo "~/Library/LaunchAgents/${m_plist}.plist" || echo "~/.config/systemd/user/${m_plist}")
 Process grep: ${m_proc}
 Stderr (last 20 lines):
 ${STDERR_TAIL}
@@ -857,7 +913,7 @@ Do NOT propagate fixes for [personal] services — those stay local only."
       cat > "$REPAIR_PROMPT_FILE" <<NEXOPROMPT
 WATCHDOG LEVEL 2 REPAIR — Automated diagnostic session.
 
-The watchdog detected services that failed mechanical repair (launchctl bootstrap/kickstart).
+The watchdog detected services that failed mechanical repair (launchctl/systemctl re-registration).
 Your job: diagnose the root cause and fix it. Do NOT ask the user anything — resolve autonomously.
 
 Each failure is tagged [core] or [personal]:
@@ -868,10 +924,10 @@ FAILURES:
 ${FAIL_DETAILS}
 
 STEPS:
-1. Read the plist file to understand the service configuration
+1. Read the service config (plist on macOS, systemd unit on Linux) to understand the service
 2. Check stderr/stdout logs for the actual error
 3. Fix the root cause (missing file, bad config, dependency issue, etc.)
-4. Reload the service and verify it is running
+4. Reload the service and verify it is running (launchctl on macOS, systemctl on Linux)
 5. Log what you did to $NEXO_HOME/logs/watchdog-repair-result.log
 ${PROPAGATE_BLOCK}