nexo-brain 2.6.12 → 2.6.13

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.12",
+  "version": "2.6.13",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -484,7 +484,7 @@ Core and personal jobs now declare explicit recovery contracts in `crons/manifes
 
 | Field | Purpose |
 |-------|---------|
-| `recovery_policy` | `catchup`, `restart`, or `skip` |
+| `recovery_policy` | `catchup`, `restart`, `restart_daemon`, or `skip` |
 | `run_on_boot` | Re-run when the machine starts |
 | `run_on_wake` | Re-run after sleep/resume |
 | `idempotent` | Safe to re-run without side effects |
@@ -492,6 +492,8 @@ Core and personal jobs now declare explicit recovery contracts in `crons/manifes
 
 If the Mac was asleep during a scheduled window, `catchup` detects the gap from `cron_runs` (not a state file) and re-executes eligible jobs once. Interval-based personal scripts get a single recovery run, not repeated ticks.
 
+For personal daemon-style helpers, `recovery_policy=restart_daemon` plus `schedule_required=true` declares an official `KeepAlive` schedule. NEXO can now reconcile and repair those daemons instead of treating them as unmanaged legacy LaunchAgents.
+
 ## Startup Preflight (v2.6.2)
 
 Before `nexo chat` or MCP server start, NEXO runs a preflight check:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.12",
+  "version": "2.6.13",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — local cognitive runtime for Claude Code. Persistent memory, overnight learning, recovery-aware crons, personal scripts, doctor diagnostics, startup preflight, and optional power helper.",
   "bin": {

package/src/plugins/schedule.py

@@ -56,21 +56,20 @@ def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
 
 def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
                         interval_seconds: int = 0, description: str = '',
-                        script_type: str = 'auto') -> str:
+                        script_type: str = 'auto', keep_alive: bool = False) -> str:
     """Add a new personal cron job. Generates and installs the LaunchAgent (macOS) or systemd timer (Linux).
 
     Args:
         cron_id: Unique ID for this cron (e.g. 'my-backup', 'report-daily'). Must be lowercase with hyphens.
         script: Path to the script to run (absolute or relative to NEXO_HOME/scripts/).
         schedule: Time-based schedule as 'HH:MM' (daily) or 'HH:MM:weekday' (e.g. '08:00:1' for Monday 8AM). Mutually exclusive with interval_seconds.
-        interval_seconds: Run every N seconds (e.g. 300 for every 5 min). Mutually exclusive with schedule.
+        interval_seconds: Run every N seconds (e.g. 300 for every 5 min). Mutually exclusive with schedule/keep_alive.
         description: What this cron does (for logs and status).
         script_type: 'auto' (default), 'python', 'shell', 'node', or 'php'.
+        keep_alive: Run as a daemon/keep-alive service instead of a timer.
     """
     if not cron_id or not script:
         return "ERROR: cron_id and script are required."
-    if not schedule and not interval_seconds:
-        return "ERROR: either schedule (e.g. '08:00') or interval_seconds (e.g. 300) is required."
 
     nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
     script_path = Path(script)
@@ -82,6 +81,11 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
     script_meta = parse_inline_metadata(script_path)
     detected_runtime = classify_runtime(script_path, script_meta)
     declared = get_declared_schedule(script_meta, script_meta.get("name", script_path.stem))
+    keep_alive = bool(keep_alive or declared.get("schedule_type") == "keep_alive")
+
+    if sum(bool(value) for value in [schedule, interval_seconds, keep_alive]) != 1:
+        return "ERROR: choose exactly one schedule mode: schedule, interval_seconds, or keep_alive."
+
     script_type = (script_type or "auto").strip().lower()
     if script_type == "auto":
         script_type = detected_runtime if detected_runtime != "unknown" else "python"
@@ -102,6 +106,7 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
             description or script_meta.get("description", ""),
             script_type,
             nexo_home,
+            keep_alive=keep_alive,
             declared=declared,
         )
     elif system == "Linux":
@@ -114,6 +119,7 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
             description or script_meta.get("description", ""),
             script_type,
             nexo_home,
+            keep_alive=keep_alive,
             declared=declared,
         )
     else:
@@ -134,7 +140,7 @@ def _runtime_command(script_type: str) -> str:
     return "python3"
 
 
-def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds, description, script_type, label="", plist_path=""):
+def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds, description, script_type, label="", plist_path="", keep_alive: bool = False):
     init_db()
     script_meta = parse_inline_metadata(Path(script_path))
     runtime = classify_runtime(Path(script_path), script_meta)
@@ -148,7 +154,11 @@ def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds
         source="filesystem",
         has_inline_metadata=bool(script_meta),
     )
-    if interval_seconds:
+    if keep_alive:
+        schedule_type = "keep_alive"
+        schedule_value = "true"
+        schedule_label = "keep alive"
+    elif interval_seconds:
         schedule_type = "interval"
         schedule_value = str(interval_seconds)
         schedule_label = f"every {interval_seconds}s"
@@ -174,7 +184,7 @@ def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds
 
 
 def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seconds,
-                     description, script_type, nexo_home, *, declared: dict | None = None):
+                     description, script_type, nexo_home, *, keep_alive: bool = False, declared: dict | None = None):
     """Create and load a macOS LaunchAgent."""
     import plistlib
 
@@ -201,7 +211,9 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
         },
     }
 
-    if interval_seconds:
+    if keep_alive:
+        plist["KeepAlive"] = True
+    elif interval_seconds:
         plist["StartInterval"] = interval_seconds
     elif schedule:
         parts = schedule.split(":")
@@ -211,7 +223,7 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
         plist["StartCalendarInterval"] = cal
 
     declared = declared or {}
-    if declared.get("run_on_boot"):
+    if declared.get("run_on_boot") or (keep_alive and "run_on_boot" not in declared):
         plist["RunAtLoad"] = True
 
     with open(plist_path, "wb") as f:
@@ -228,13 +240,20 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
         script_type,
         label=label,
         plist_path=str(plist_path),
+        keep_alive=keep_alive,
     )
 
-    return f"Cron '{cron_id}' installed at {plist_path} and loaded.{' Schedule: ' + schedule if schedule else f' Interval: {interval_seconds}s'}"
+    if keep_alive:
+        detail = " KeepAlive daemon"
+    elif schedule:
+        detail = f" Schedule: {schedule}"
+    else:
+        detail = f" Interval: {interval_seconds}s"
+    return f"Cron '{cron_id}' installed at {plist_path} and loaded.{detail}"
 
 
 def _add_systemd_timer(cron_id, script_path, wrapper_path, schedule, interval_seconds,
-                       description, script_type, nexo_home, *, declared: dict | None = None):
+                       description, script_type, nexo_home, *, keep_alive: bool = False, declared: dict | None = None):
     """Create and enable a systemd user timer (Linux)."""
     unit_dir = Path.home() / ".config" / "systemd" / "user"
     unit_dir.mkdir(parents=True, exist_ok=True)
@@ -257,9 +276,46 @@ Environment=NEXO_PERSONAL_CRON_ID={cron_id}
     service_path = unit_dir / f"nexo-{cron_id}.service"
     service_path.write_text(service_content)
 
-    # Timer unit
     declared = declared or {}
 
+    if keep_alive:
+        service_content = f"""[Unit]
+Description=NEXO daemon: {description or cron_id}
+
+[Service]
+Type=simple
+ExecStart={exec_cmd}
+Restart=always
+RestartSec=10
+Environment=NEXO_HOME={nexo_home}
+Environment=HOME={Path.home()}
+Environment={PERSONAL_SCHEDULE_MANAGED_ENV}=1
+Environment=NEXO_PERSONAL_CRON_ID={cron_id}
+
+[Install]
+WantedBy=default.target
+"""
+        service_path = unit_dir / f"nexo-{cron_id}.service"
+        service_path.write_text(service_content)
+
+        subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+        subprocess.run(["systemctl", "--user", "enable", "--now", f"nexo-{cron_id}.service"], capture_output=True)
+
+        _register_schedule_metadata(
+            cron_id,
+            script_path,
+            schedule,
+            interval_seconds,
+            description,
+            script_type,
+            label=f"nexo-{cron_id}",
+            plist_path="",
+            keep_alive=True,
+        )
+
+        return f"Cron '{cron_id}' installed as KeepAlive systemd service and enabled. Service: {service_path}"
+
+    # Timer unit
     if interval_seconds:
         timer_spec = f"OnUnitActiveSec={interval_seconds}s"
         if declared.get("run_on_boot") or not declared.get("required"):
@@ -301,6 +357,7 @@ WantedBy=timers.target
         script_type,
         label=f"nexo-{cron_id}",
         plist_path="",
+        keep_alive=False,
     )
 
     return f"Cron '{cron_id}' installed as systemd timer and enabled. Service: {service_path}, Timer: {timer_path}"

package/src/script_registry.py

@@ -32,6 +32,16 @@ _IGNORED_FILES = {
 }
 _IGNORED_DIRS = {"deep-sleep", "__pycache__"}
 
+_LEGACY_WAKE_RECOVERY_METADATA = [
+    "# nexo: name=nexo-wake-recovery",
+    "# nexo: description=Recover interval LaunchAgents after macOS sleep/wake gaps",
+    "# nexo: runtime=shell",
+    "# nexo: cron_id=wake-recovery",
+    "# nexo: schedule_required=true",
+    "# nexo: recovery_policy=restart_daemon",
+    "# nexo: run_on_boot=true",
+]
+
 # Forbidden patterns — direct DB access from personal scripts
 _FORBIDDEN_PATTERNS = [
     re.compile(r"\bsqlite3\b"),
@@ -77,6 +87,33 @@ def get_scripts_dir() -> Path:
     return NEXO_HOME / "scripts"
 
 
+def _apply_legacy_personal_script_backfills() -> None:
+    """Backfill metadata for known legacy personal scripts shipped before the registry existed."""
+    scripts_dir = get_scripts_dir()
+    wake_recovery = scripts_dir / "nexo-wake-recovery.sh"
+    if not wake_recovery.is_file():
+        return
+
+    try:
+        text = wake_recovery.read_text()
+    except Exception:
+        return
+
+    if "# nexo:" in "\n".join(text.splitlines()[:25]):
+        return
+    if "Wake Recovery" not in text:
+        return
+
+    lines = text.splitlines(keepends=True)
+    head: list[str] = []
+    start = 0
+    if lines and lines[0].startswith("#!"):
+        head.append(lines[0])
+        start = 1
+    head.extend([line + "\n" for line in _LEGACY_WAKE_RECOVERY_METADATA])
+    wake_recovery.write_text("".join(head + lines[start:]))
+
+
 def load_core_script_names() -> set[str]:
     """Load script names from crons/manifest.json (these are core, not personal)."""
     names: set[str] = set()
@@ -279,6 +316,11 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
                 "cron_id": cron_id,
             }
 
+    def _effective_run_on_boot(policy: str) -> bool:
+        if "run_on_boot" in metadata:
+            return run_on_boot
+        return policy == "restart_daemon"
+
     def _effective_run_on_wake(policy: str) -> bool:
         if "run_on_wake" in metadata:
             return run_on_wake
@@ -379,12 +421,29 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
             "schedule": schedule_raw,
             "interval_seconds": 0,
             "recovery_policy": recovery_policy_raw or "catchup",
-            "run_on_boot": run_on_boot,
+            "run_on_boot": _effective_run_on_boot(recovery_policy_raw or "catchup"),
             "run_on_wake": _effective_run_on_wake(recovery_policy_raw or "catchup"),
             "idempotent": _effective_idempotent(recovery_policy_raw or "catchup"),
             "max_catchup_age": max_catchup_age or (14 * 86400 if weekday is not None else 48 * 3600),
         }
 
+    if required and recovery_policy_raw == "restart_daemon":
+        return {
+            "required": required,
+            "valid": True,
+            "cron_id": cron_id,
+            "schedule_type": "keep_alive",
+            "schedule_value": "true",
+            "schedule_label": "keep alive",
+            "schedule": "",
+            "interval_seconds": 0,
+            "recovery_policy": "restart_daemon",
+            "run_on_boot": _effective_run_on_boot("restart_daemon"),
+            "run_on_wake": _effective_run_on_wake("restart_daemon"),
+            "idempotent": _effective_idempotent("restart_daemon"),
+            "max_catchup_age": max_catchup_age,
+        }
+
     return {
         "required": required,
         "valid": not required,
@@ -416,6 +475,7 @@ def _script_entry(path: Path, meta: dict, *, is_core: bool, classification: str,
 
 def classify_scripts_dir() -> dict:
     """Classify every file in NEXO_HOME/scripts into personal/core/ignored/non-script buckets."""
+    _apply_legacy_personal_script_backfills()
     scripts_dir = get_scripts_dir()
     if not scripts_dir.is_dir():
         return {"scripts_dir": str(scripts_dir), "entries": [], "summary": {}}
@@ -927,6 +987,7 @@ def ensure_personal_schedules(*, dry_run: bool = False) -> dict:
             interval_seconds=declared.get("interval_seconds", 0),
             description=script.get("description", ""),
             script_type=script.get("runtime", "auto"),
+            keep_alive=declared.get("schedule_type") == "keep_alive",
         )
         target = report["repaired" if existing else "created"]
         target.append({