nexo-brain 2.6.0 → 2.6.2

package/src/cli.py

@@ -450,62 +450,14 @@ def _update(args):
     - Explicit dev env: sync from NEXO_CODE/src
     - Packaged/runtime-only install: delegate to plugins.update handle_update()
     """
-    import shutil
+    from auto_update import manual_sync_update, _resolve_sync_source
+    from runtime_power import ensure_power_policy_choice, apply_power_policy
 
-    dest = NEXO_HOME
-
-    def _runtime_version_source() -> Path | None:
-        version_file = NEXO_HOME / "version.json"
-        if not version_file.is_file():
-            return None
-        try:
-            data = json.loads(version_file.read_text())
-        except Exception:
-            return None
-        source = str(data.get("source", "")).strip()
-        if not source:
-            return None
-        candidate = Path(source).expanduser()
-        if (candidate / "src").is_dir() and (candidate / "package.json").is_file():
-            return candidate
-        return None
-
-    def _resolve_sync_source() -> tuple[Path | None, Path | None]:
-        try:
-            same_as_runtime = NEXO_CODE.resolve() == dest.resolve()
-        except Exception:
-            same_as_runtime = NEXO_CODE == dest
-
-        # Explicit dev mode: NEXO_CODE points at repo/src, never the installed runtime itself.
-        if (
-            not same_as_runtime
-            and (NEXO_CODE / "db").is_dir()
-            and (NEXO_CODE.parent / "package.json").is_file()
-        ):
-            return NEXO_CODE, NEXO_CODE.parent
-
-        # Installed runtime linked back to a source checkout
-        version_source = _runtime_version_source()
-        if version_source:
-            return version_source / "src", version_source
-
-        return None, None
+    interactive = sys.stdin.isatty() and sys.stdout.isatty()
 
+    dest = NEXO_HOME
     src_dir, repo_dir = _resolve_sync_source()
 
-    if src_dir is not None:
-        try:
-            if src_dir.resolve() == dest.resolve():
-                version_source = _runtime_version_source()
-                if version_source:
-                    src_dir = version_source / "src"
-                    repo_dir = version_source
-                else:
-                    src_dir = None
-                    repo_dir = None
-        except Exception:
-            pass
-
     if src_dir is None or repo_dir is None:
         try:
             from plugins.update import handle_update
@@ -518,151 +470,42 @@ def _update(args):
             return 1
 
         result = handle_update()
+        choice = ensure_power_policy_choice(interactive=interactive, reason="update")
+        power_result = apply_power_policy(choice.get("policy"))
         if args.json:
             print(json.dumps({
                 "mode": "packaged",
                 "message": result,
+                "power_policy": choice.get("policy"),
+                "power_action": power_result.get("action"),
             }, indent=2, ensure_ascii=False))
         else:
             print(result)
+            if choice.get("prompted"):
+                print(f"Power policy: {choice.get('policy')}")
         return 0 if "UPDATE SUCCESSFUL" in result or "Already up to date" in result else 1
 
-    # Packages (directories with __init__.py or known structure)
-    packages = ["db", "cognitive", "doctor", "dashboard", "rules", "crons", "hooks"]
-    copied_packages = 0
-    for pkg in packages:
-        pkg_src = src_dir / pkg
-        pkg_dest = dest / pkg
-        if pkg_src.is_dir():
-            if pkg_dest.exists():
-                shutil.rmtree(str(pkg_dest), ignore_errors=True)
-            shutil.copytree(
-                str(pkg_src), str(pkg_dest),
-                ignore=shutil.ignore_patterns("__pycache__", "*.pyc", "*.pyo", "*.db"),
-            )
-            copied_packages += 1
-
-    # Flat Python files
-    flat_files = [
-        "server.py", "plugin_loader.py", "knowledge_graph.py", "kg_populate.py",
-        "maintenance.py", "storage_router.py", "claim_graph.py", "hnsw_index.py",
-        "evolution_cycle.py", "migrate_embeddings.py", "auto_close_sessions.py",
-        "auto_update.py", "tools_sessions.py", "tools_coordination.py",
-        "tools_reminders.py", "tools_reminders_crud.py", "tools_learnings.py",
-        "tools_credentials.py", "tools_task_history.py", "tools_menu.py",
-        "cli.py", "script_registry.py", "skills_runtime.py", "user_context.py",
-        "cron_recovery.py",
-        "requirements.txt",
-    ]
-    copied_files = 0
-    for f in flat_files:
-        src_f = src_dir / f
-        if src_f.is_file():
-            shutil.copy2(str(src_f), str(dest / f))
-            copied_files += 1
-
-    # Plugins
-    plugins_src = src_dir / "plugins"
-    plugins_dest = dest / "plugins"
-    if plugins_src.is_dir():
-        plugins_dest.mkdir(parents=True, exist_ok=True)
-        for f in plugins_src.iterdir():
-            if f.is_file() and f.suffix == ".py":
-                shutil.copy2(str(f), str(plugins_dest / f.name))
-
-    # Scripts
-    scripts_src = src_dir / "scripts"
-    scripts_dest = dest / "scripts"
-    if scripts_src.is_dir():
-        scripts_dest.mkdir(parents=True, exist_ok=True)
-        for f in scripts_src.iterdir():
-            if f.name == "__pycache__" or f.name.startswith("."):
-                continue
-            dst = scripts_dest / f.name
-            if f.is_dir():
-                if dst.exists():
-                    shutil.rmtree(str(dst), ignore_errors=True)
-                shutil.copytree(str(f), str(dst), ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
-            elif f.is_file():
-                shutil.copy2(str(f), str(dst))
-                if f.suffix == ".sh":
-                    dst.chmod(0o755)
-
-    # Templates
-    templates_src = repo_dir / "templates"
-    templates_dest = dest / "templates"
-    if templates_src.is_dir():
-        templates_dest.mkdir(parents=True, exist_ok=True)
-        for f in templates_src.iterdir():
-            if f.is_file():
-                shutil.copy2(str(f), str(templates_dest / f.name))
-
-    # Runtime version metadata
-    package_json = repo_dir / "package.json"
-    if package_json.is_file():
-        shutil.copy2(str(package_json), str(dest / "package.json"))
-        try:
-            pkg = json.loads(package_json.read_text())
-            version_payload = {
-                "version": pkg.get("version", "?"),
-                "source": str(repo_dir),
-            }
-            (dest / "version.json").write_text(json.dumps(version_payload, indent=2))
-        except Exception:
-            pass
-
-    # Core skills
-    skills_src = src_dir / "skills"
-    skills_dest = dest / "skills-core"
-    if skills_src.is_dir():
-        if skills_dest.exists():
-            shutil.rmtree(str(skills_dest), ignore_errors=True)
-        shutil.copytree(
-            str(skills_src), str(skills_dest),
-            ignore=shutil.ignore_patterns("__pycache__", "*.pyc"),
-        )
-
-    # Runtime CLI wrapper
-    bin_dir = dest / "bin"
-    bin_dir.mkdir(parents=True, exist_ok=True)
-    wrapper = bin_dir / "nexo"
-    wrapper_content = (
-        "#!/usr/bin/env bash\n"
-        "set -euo pipefail\n\n"
-        f'NEXO_HOME="{dest}"\n'
-        'PYTHON="$NEXO_HOME/.venv/bin/python3"\n'
-        'if [ ! -x "$PYTHON" ]; then\n'
-        '  if command -v python3 >/dev/null 2>&1; then PYTHON="python3"; else PYTHON="python"; fi\n'
-        'fi\n'
-        'export NEXO_HOME\n'
-        'export NEXO_CODE="$NEXO_HOME"\n'
-        'exec "$PYTHON" "$NEXO_HOME/cli.py" "$@"\n'
-    )
-    wrapper.write_text(wrapper_content)
-    wrapper.chmod(0o755)
-
-    try:
-        from db import init_db
-        from script_registry import sync_personal_scripts
-
-        init_db()
-        sync_personal_scripts()
-    except Exception:
-        pass
-
-    result = {
-        "mode": "sync",
-        "packages": copied_packages,
-        "files": copied_files,
-        "nexo_home": str(dest),
-        "source": str(src_dir),
-    }
+    choice = ensure_power_policy_choice(interactive=interactive, reason="update")
+    power_result = apply_power_policy(choice.get("policy"))
+    result = manual_sync_update(interactive=interactive, allow_source_pull=True)
+    result["power_policy"] = choice.get("policy")
+    result["power_action"] = power_result.get("action")
     if args.json:
-        print(json.dumps(result, indent=2))
+        print(json.dumps(result, indent=2, ensure_ascii=False))
     else:
-        print(f"Updated NEXO_HOME ({dest})")
-        print(f"  {copied_packages} packages, {copied_files} files synced from {src_dir}")
-    return 0
+        if result.get("ok"):
+            print(f"Updated NEXO_HOME ({dest})")
+            print(
+                f"  {result.get('packages', 0)} packages, {result.get('files', 0)} files synced from "
+                f"{result.get('source', src_dir)}"
+            )
+            if result.get("pulled_source"):
+                print("  Source repo: pulled latest fast-forward before sync")
+            if choice.get("prompted"):
+                print(f"  Power policy: {choice.get('policy')}")
+        else:
+            print(f"UPDATE FAILED: {result.get('error', 'sync failed')}", file=sys.stderr)
+    return 0 if result.get("ok") else 1
 
 
 def _service_control(service_name: str, action: str) -> int:
@@ -733,6 +576,23 @@ def _chat(args):
         print("Claude Code launcher not found in PATH. Install `claude` first.", file=sys.stderr)
         return 1
 
+    try:
+        from auto_update import startup_preflight
+
+        preflight = startup_preflight(entrypoint="chat", interactive=False)
+        if preflight.get("updated"):
+            print("[NEXO] Startup update applied before chat.", file=sys.stderr)
+        elif preflight.get("deferred_reason"):
+            print(f"[NEXO] Update deferred: {preflight['deferred_reason']}", file=sys.stderr)
+        elif preflight.get("git_update"):
+            print(f"[NEXO] {preflight['git_update']}", file=sys.stderr)
+        elif preflight.get("npm_notice"):
+            print(f"[NEXO] {preflight['npm_notice']}", file=sys.stderr)
+        if preflight.get("error"):
+            print(f"[NEXO] Startup preflight warning: {preflight['error']}", file=sys.stderr)
+    except Exception:
+        pass
+
     result = subprocess.run(
         [claude_bin, "--dangerously-skip-permissions", target],
         env=os.environ.copy(),

package/src/cron_recovery.py

@@ -57,6 +57,60 @@ def load_enabled_crons() -> list[dict]:
     return []
 
 
+def _calendar_payload_from_declared(value: str) -> dict | None:
+    parts = str(value or "").split(":")
+    if len(parts) not in {2, 3}:
+        return None
+    try:
+        hour = int(parts[0])
+        minute = int(parts[1])
+        weekday = int(parts[2]) if len(parts) == 3 else None
+    except ValueError:
+        return None
+    payload = {"hour": hour, "minute": minute}
+    if weekday is not None:
+        payload["weekday"] = weekday
+    return payload
+
+
+def load_managed_personal_crons() -> list[dict]:
+    try:
+        from script_registry import classify_scripts_dir, discover_personal_schedules
+    except Exception:
+        return []
+
+    scripts_by_path: dict[str, dict] = {}
+    for entry in classify_scripts_dir().get("entries", []):
+        if entry.get("classification") != "personal":
+            continue
+        scripts_by_path[str(entry.get("path", ""))] = entry
+
+    personal: list[dict] = []
+    for schedule in discover_personal_schedules():
+        script = scripts_by_path.get(str(schedule.get("script_path", "")))
+        declared = (script or {}).get("declared_schedule", {})
+        if not script or not declared.get("valid"):
+            continue
+        schedule_type = declared.get("schedule_type")
+        if schedule_type not in {"calendar", "interval"}:
+            continue
+        personal.append({
+            "id": schedule["cron_id"],
+            "script": schedule["script_path"],
+            "type": script.get("runtime", "python"),
+            "schedule": declared.get("schedule", ""),
+            "interval_seconds": int(declared.get("interval_seconds", 0) or 0),
+            "schedule_type": schedule_type,
+            "recovery_policy": declared.get("recovery_policy", "none"),
+            "idempotent": bool(declared.get("idempotent", False)),
+            "max_catchup_age": int(declared.get("max_catchup_age", 0) or 0),
+            "run_on_boot": bool(declared.get("run_on_boot", False)),
+            "run_on_wake": bool(declared.get("run_on_wake", False)),
+            "personal_managed": True,
+        })
+    return personal
+
+
 def default_recovery_policy(cron: dict) -> str:
     if cron.get("keep_alive") or cron.get("interval_seconds"):
         return "restart"
@@ -122,6 +176,23 @@ def launchagent_schedule(cron_id: str) -> dict:
 
 
 def effective_schedule(cron: dict) -> dict:
+    if cron.get("personal_managed"):
+        if cron.get("schedule_type") == "interval":
+            return {
+                "source": "personal",
+                "schedule_type": "interval",
+                "interval_seconds": int(cron.get("interval_seconds", 0) or 0),
+                "run_at_load": bool(cron.get("run_on_boot")),
+            }
+        if cron.get("schedule_type") == "calendar":
+            calendar = _calendar_payload_from_declared(str(cron.get("schedule", ""))) or {}
+            return {
+                "source": "personal",
+                "schedule_type": "calendar",
+                "calendar": calendar,
+                "run_at_load": bool(cron.get("run_on_boot")),
+            }
+
     actual = launchagent_schedule(cron["id"])
     if actual.get("schedule_type"):
         return actual
@@ -241,7 +312,7 @@ def catchup_candidates(now: datetime | None = None) -> list[dict]:
     if now.tzinfo is None:
         now = now.replace(tzinfo=_local_timezone())
 
-    crons = load_enabled_crons()
+    crons = load_enabled_crons() + load_managed_personal_crons()
     contracts = {cron["id"]: recovery_contract(cron) for cron in crons if cron.get("id")}
     successes = latest_successful_runs(list(contracts), db_path=DB_PATH)
     legacy = legacy_state_runs(state_file=STATE_FILE)
@@ -253,14 +324,22 @@ def catchup_candidates(now: datetime | None = None) -> list[dict]:
             continue
         contract = contracts[cron_id]
         schedule = effective_schedule(cron)
-        if contract["recovery_policy"] != "catchup":
-            continue
-        if schedule.get("schedule_type") != "calendar":
+        schedule_type = schedule.get("schedule_type")
+        if schedule_type not in {"calendar", "interval"}:
             continue
         if not contract["idempotent"]:
             continue
-
-        due_at = last_scheduled_time(schedule["calendar"], now)
+        if schedule_type == "calendar":
+            if contract["recovery_policy"] != "catchup":
+                continue
+            due_at = last_scheduled_time(schedule["calendar"], now)
+        else:
+            if contract["recovery_policy"] not in {"catchup", "run_once_on_wake"}:
+                continue
+            interval_seconds = int(schedule.get("interval_seconds", 0) or 0)
+            if interval_seconds <= 0:
+                continue
+            due_at = now - timedelta(seconds=interval_seconds)
         last_success = successes.get(cron_id) or legacy.get(cron_id)
         age_seconds = max(int((now - due_at).total_seconds()), 0)
         missed = last_success is None or last_success < due_at
@@ -270,6 +349,7 @@ def catchup_candidates(now: datetime | None = None) -> list[dict]:
             "cron_id": cron_id,
             "script": cron.get("script", ""),
             "type": cron.get("type", "python"),
+            "personal_managed": bool(cron.get("personal_managed")),
             "contract": contract,
             "schedule": schedule,
             "last_due_at": due_at,

package/src/crons/sync.py

@@ -370,7 +370,7 @@ def sync_linux(dry_run: bool = False):
     LOG_DIR.mkdir(parents=True, exist_ok=True)
 
     manifest_crons = load_manifest()
-    wrapper_src = NEXO_CODE / "scripts" / "nexo-cron-wrapper.sh"
+    wrapper_src = SOURCE_ROOT / "scripts" / "nexo-cron-wrapper.sh"
     wrapper_dest = _copy_script_to_nexo_home(wrapper_src)
 
     log(f"Manifest: {len(manifest_crons)} core crons")
@@ -383,13 +383,13 @@ def sync_linux(dry_run: bool = False):
 
     for cron in manifest_crons:
         cron_id = cron["id"]
-        script_src = NEXO_CODE / cron["script"]
+        script_src = SOURCE_ROOT / 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
+        subdir_src = SOURCE_ROOT / "scripts" / subdir_name
         if subdir_src.is_dir():
             _copy_script_to_nexo_home(subdir_src)
 
@@ -411,7 +411,7 @@ Description=NEXO: {cron.get('description', cron_id)}
 Type=oneshot
 ExecStart={exec_cmd}
 Environment=NEXO_HOME={NEXO_HOME}
-Environment=NEXO_CODE={NEXO_CODE}
+Environment=NEXO_CODE={SOURCE_ROOT}
 Environment=HOME={Path.home()}
 StandardOutput=append:{stdout_log}
 StandardError=append:{stderr_log}

package/src/plugins/schedule.py

@@ -10,7 +10,12 @@ from db import (
     init_db, cron_runs_recent, cron_runs_summary,
     upsert_personal_script, register_personal_script_schedule,
 )
-from script_registry import PERSONAL_SCHEDULE_MANAGED_ENV, parse_inline_metadata, classify_runtime
+from script_registry import (
+    PERSONAL_SCHEDULE_MANAGED_ENV,
+    parse_inline_metadata,
+    classify_runtime,
+    get_declared_schedule,
+)
 
 
 def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
@@ -76,6 +81,7 @@ 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))
     script_type = (script_type or "auto").strip().lower()
     if script_type == "auto":
         script_type = detected_runtime if detected_runtime != "unknown" else "python"
@@ -96,6 +102,7 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
             description or script_meta.get("description", ""),
             script_type,
             nexo_home,
+            declared=declared,
         )
     elif system == "Linux":
         return _add_systemd_timer(
@@ -107,6 +114,7 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
             description or script_meta.get("description", ""),
             script_type,
             nexo_home,
+            declared=declared,
         )
     else:
         return f"ERROR: unsupported platform: {system}"
@@ -166,7 +174,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):
+                     description, script_type, nexo_home, *, declared: dict | None = None):
     """Create and load a macOS LaunchAgent."""
     import plistlib
 
@@ -202,6 +210,10 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
             cal["Weekday"] = int(parts[2])
         plist["StartCalendarInterval"] = cal
 
+    declared = declared or {}
+    if declared.get("run_on_boot"):
+        plist["RunAtLoad"] = True
+
     with open(plist_path, "wb") as f:
         plistlib.dump(plist, f)
 
@@ -222,7 +234,7 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
 
 
 def _add_systemd_timer(cron_id, script_path, wrapper_path, schedule, interval_seconds,
-                       description, script_type, nexo_home):
+                       description, script_type, nexo_home, *, 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)
@@ -246,8 +258,12 @@ Environment=NEXO_PERSONAL_CRON_ID={cron_id}
     service_path.write_text(service_content)
 
     # Timer unit
+    declared = declared or {}
+
     if interval_seconds:
-        timer_spec = f"OnUnitActiveSec={interval_seconds}s\nOnBootSec=60s"
+        timer_spec = f"OnUnitActiveSec={interval_seconds}s"
+        if declared.get("run_on_boot") or not declared.get("required"):
+            timer_spec += "\nOnBootSec=60s"
     elif schedule:
         parts = schedule.split(":")
         hour, minute = int(parts[0]), int(parts[1])

package/src/plugins/update.py

@@ -9,24 +9,22 @@ import sys
 import time
 from pathlib import Path
 
-# Repo root: go up from src/plugins/ -> src/ -> repo/
+# Code root is the parent of plugins/:
+# - source checkout: <repo>/src
+# - packaged runtime: <NEXO_HOME>
 _THIS_DIR = Path(__file__).resolve().parent
-REPO_DIR = _THIS_DIR.parent.parent
-PACKAGE_JSON = REPO_DIR / "package.json"
+CODE_ROOT = _THIS_DIR.parent
+_REPO_CANDIDATE = CODE_ROOT.parent
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 DATA_DIR = NEXO_HOME / "data"
 BACKUP_BASE = NEXO_HOME / "backups"
 
-# In packaged installs, update.py lives at ~/.nexo/plugins/update.py
-# so REPO_DIR would be ~/ (wrong). Detect this and fix paths.
-_PACKAGED_INSTALL = not (REPO_DIR / ".git").exists() and not (REPO_DIR / ".git").is_file()
-
-if _PACKAGED_INSTALL:
-    # In packaged mode, core .py files live directly in NEXO_HOME
-    SRC_DIR = NEXO_HOME
-else:
-    SRC_DIR = REPO_DIR / "src"
+# In packaged installs, update.py lives at <NEXO_HOME>/plugins/update.py.
+_PACKAGED_INSTALL = not (_REPO_CANDIDATE / ".git").exists() and not (_REPO_CANDIDATE / ".git").is_file()
+REPO_DIR = CODE_ROOT if _PACKAGED_INSTALL else _REPO_CANDIDATE
+SRC_DIR = CODE_ROOT
+PACKAGE_JSON = REPO_DIR / "package.json"
 
 
 def _find_npm_pkg_src() -> Path | None:
@@ -64,13 +62,27 @@ def _refresh_installed_manifest():
 
 
 def _read_version() -> str:
-    """Read version from package.json or NEXO_HOME/version.json (packaged installs)."""
+    """Read the installed/runtime version."""
+    if _PACKAGED_INSTALL:
+        # version.json is the runtime truth for packaged installs.
+        try:
+            version_file = NEXO_HOME / "version.json"
+            if version_file.exists():
+                return json.loads(version_file.read_text()).get("version", "unknown")
+        except Exception:
+            pass
+        try:
+            package_file = NEXO_HOME / "package.json"
+            if package_file.exists():
+                return json.loads(package_file.read_text()).get("version", "unknown")
+        except Exception:
+            pass
+
     try:
         if PACKAGE_JSON.exists():
             return json.loads(PACKAGE_JSON.read_text()).get("version", "unknown")
     except Exception:
         pass
-    # Packaged installs don't ship package.json — check version.json in NEXO_HOME
     try:
         version_file = NEXO_HOME / "version.json"
         if version_file.exists():