nexo-brain 2.6.10 → 2.6.11

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.10",
+  "version": "2.6.11",
   "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/bin/nexo-brain.js

@@ -89,6 +89,44 @@ function syncWatchdogHashRegistry(nexoHome) {
   }
 }
 
+function getCoreRuntimeFlatFiles() {
+  return [
+    "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",
+    "client_sync.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",
+    "public_contribution.py",
+    "cron_recovery.py",
+    "runtime_power.py",
+    "requirements.txt",
+  ];
+}
+
+function getCoreRuntimePackages() {
+  return ["db", "cognitive", "doctor"];
+}
+
 function isProtectedMacPath(candidate) {
   if (process.platform !== "darwin" || !candidate) return false;
   const homeDir = require("os").homedir();
@@ -981,16 +1019,7 @@ async function main() {
         log("  Hooks updated.");
 
         // Update core Python files (flat .py files in src/)
-        const coreFlatFiles = [
-          "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",
-          "requirements.txt",
-        ];
+        const coreFlatFiles = getCoreRuntimeFlatFiles();
         coreFlatFiles.forEach((f) => {
           const src = path.join(srcDir, f);
           if (fs.existsSync(src)) {
@@ -998,7 +1027,7 @@ async function main() {
           }
         });
         // Update core packages (db/, cognitive/) — full directory copy
-        ["db", "cognitive"].forEach(pkg => {
+        getCoreRuntimePackages().forEach(pkg => {
           const pkgSrc = path.join(srcDir, pkg);
           if (fs.existsSync(pkgSrc)) {
             copyDirRec(pkgSrc, path.join(NEXO_HOME, pkg));
@@ -1752,33 +1781,7 @@ async function main() {
   };
 
   // Core flat files (single .py files in src/)
-  const coreFiles = [
-    "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",
-    "client_sync.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",
-    "requirements.txt",
-    "cli.py",
-    "script_registry.py",
-    "skills_runtime.py",
-  ];
+  const coreFiles = getCoreRuntimeFlatFiles();
   coreFiles.forEach((f) => {
     const src = path.join(srcDir, f);
     if (fs.existsSync(src)) {
@@ -1811,7 +1814,7 @@ async function main() {
 
   log("Copying core packages...");
   // Core packages (directories with __init__.py)
-  ["db", "cognitive", "doctor"].forEach(pkg => {
+  getCoreRuntimePackages().forEach(pkg => {
     const pkgSrc = path.join(srcDir, pkg);
     if (fs.existsSync(pkgSrc)) {
       copyDirRecursive(pkgSrc, path.join(NEXO_HOME, pkg));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.10",
+  "version": "2.6.11",
   "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/auto_update.py

@@ -1202,6 +1202,7 @@ def _backup_runtime_tree(dest: Path = NEXO_HOME) -> str:
         "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",
+        "public_contribution.py",
         "cron_recovery.py", "runtime_power.py", "requirements.txt", "package.json", "version.json",
     ]
     for name in code_dirs:
@@ -1250,6 +1251,7 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
         "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",
+        "public_contribution.py",
         "cron_recovery.py", "runtime_power.py", "requirements.txt",
     ]
     copied_packages = 0
@@ -1383,12 +1385,14 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
                 sys.executable,
                 "-c",
                 (
+                    "import json; "
                     "import db; "
                     "init_db = getattr(db, 'init_db', None); "
                     "init_db() if callable(init_db) else None; "
                     "import script_registry; "
                     "reconcile_scripts = getattr(script_registry, 'reconcile_personal_scripts', None); "
-                    "reconcile_scripts(dry_run=False) if callable(reconcile_scripts) else None"
+                    "result = reconcile_scripts(dry_run=False) if callable(reconcile_scripts) else {}; "
+                    "print(json.dumps(result))"
                 ),
             ],
             cwd=str(dest),
@@ -1400,6 +1404,11 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
         if init_result.returncode != 0:
             return False, [init_result.stderr.strip() or init_result.stdout.strip() or "runtime init failed"]
         actions.append("db+personal-sync")
+        reconcile_payload = _parse_runtime_init_payload(init_result.stdout or "")
+        extra_actions, reconcile_message = _personal_schedule_reconcile_summary(reconcile_payload)
+        actions.extend(extra_actions)
+        if reconcile_message:
+            _emit_progress(progress_fn, reconcile_message)
     except Exception as e:
         return False, [f"runtime init error: {e}"]
 
@@ -1493,6 +1502,46 @@ def _emit_progress(progress_fn, message: str) -> None:
             pass
 
 
+def _parse_runtime_init_payload(stdout: str) -> dict:
+    """Extract the JSON payload emitted by the runtime init helper."""
+    lines = [line.strip() for line in stdout.splitlines() if line.strip()]
+    for line in reversed(lines):
+        try:
+            payload = json.loads(line)
+        except Exception:
+            continue
+        if isinstance(payload, dict):
+            return payload
+    return {}
+
+
+def _personal_schedule_reconcile_summary(reconcile_result: dict) -> tuple[list[str], str | None]:
+    """Turn reconcile_personal_scripts() output into stable update actions."""
+    if not isinstance(reconcile_result, dict):
+        return [], None
+
+    ensured = reconcile_result.get("ensure_schedules", {})
+    if not isinstance(ensured, dict):
+        return [], None
+
+    created = len(ensured.get("created", []) or [])
+    repaired = len(ensured.get("repaired", []) or [])
+    invalid = len(ensured.get("invalid", []) or [])
+
+    actions: list[str] = []
+    parts: list[str] = []
+    if created or repaired:
+        actions.append(f"personal-schedules-healed:{created + repaired}")
+        parts.append(f"{created} created")
+        parts.append(f"{repaired} repaired")
+    if invalid:
+        actions.append(f"personal-schedules-invalid:{invalid}")
+        parts.append(f"{invalid} invalid")
+    if not parts:
+        return [], None
+    return actions, "Personal schedules: " + ", ".join(parts) + "."
+
+
 def manual_sync_update(*, interactive: bool = False, allow_source_pull: bool = True, progress_fn=None) -> dict:
     src_dir, repo_dir = _resolve_sync_source()
     if src_dir is None or repo_dir is None:
@@ -1599,8 +1648,12 @@ def startup_preflight(*, entrypoint: str, interactive: bool = False) -> dict:
             _ensure_runtime_cli_wrapper()
             _ensure_runtime_cli_in_shell()
             init_db()
-            reconcile_personal_scripts(dry_run=False)
+            reconcile_result = reconcile_personal_scripts(dry_run=False)
             result["actions"].append("db+personal-sync")
+            extra_actions, reconcile_message = _personal_schedule_reconcile_summary(reconcile_result)
+            result["actions"].extend(extra_actions)
+            if reconcile_message:
+                _log(reconcile_message)
         except Exception as e:
             result["error"] = str(e)
             _write_update_summary(result)

package/src/cli.py

@@ -64,6 +64,123 @@ if str(NEXO_CODE) not in sys.path:
     sys.path.insert(0, str(NEXO_CODE))
 
 
+def _missing_runtime_module_message(module_name: str, exc: Exception) -> str:
+    missing = getattr(exc, "name", None) or module_name
+    return (
+        f"{module_name} is unavailable in the current runtime ({missing}). "
+        "Continuing with safe defaults so `nexo update` can repair the installation."
+    )
+
+
+def _load_runtime_power_support() -> dict:
+    try:
+        from runtime_power import (
+            ensure_power_policy_choice,
+            apply_power_policy,
+            format_power_policy_label,
+            ensure_full_disk_access_choice,
+            format_full_disk_access_label,
+        )
+        return {
+            "available": True,
+            "message": "",
+            "ensure_power_policy_choice": ensure_power_policy_choice,
+            "apply_power_policy": apply_power_policy,
+            "format_power_policy_label": format_power_policy_label,
+            "ensure_full_disk_access_choice": ensure_full_disk_access_choice,
+            "format_full_disk_access_label": format_full_disk_access_label,
+        }
+    except ImportError as exc:
+        message = _missing_runtime_module_message("runtime_power", exc)
+
+        def ensure_power_policy_choice(**kwargs):
+            return {"policy": "disabled", "prompted": False, "message": message}
+
+        def apply_power_policy(policy=None):
+            return {"ok": True, "action": "skipped", "details": [], "message": message}
+
+        def format_power_policy_label(policy):
+            return policy or "disabled"
+
+        def ensure_full_disk_access_choice(**kwargs):
+            return {"status": "unset", "prompted": False, "reasons": [], "message": message}
+
+        def format_full_disk_access_label(status):
+            return status or "unset"
+
+        return {
+            "available": False,
+            "message": message,
+            "ensure_power_policy_choice": ensure_power_policy_choice,
+            "apply_power_policy": apply_power_policy,
+            "format_power_policy_label": format_power_policy_label,
+            "ensure_full_disk_access_choice": ensure_full_disk_access_choice,
+            "format_full_disk_access_label": format_full_disk_access_label,
+        }
+
+
+def _load_public_contribution_support() -> dict:
+    try:
+        from public_contribution import (
+            ensure_public_contribution_choice,
+            format_public_contribution_label,
+            load_public_contribution_config,
+            refresh_public_contribution_state,
+            disable_public_contribution,
+        )
+        return {
+            "available": True,
+            "message": "",
+            "ensure_public_contribution_choice": ensure_public_contribution_choice,
+            "format_public_contribution_label": format_public_contribution_label,
+            "load_public_contribution_config": load_public_contribution_config,
+            "refresh_public_contribution_state": refresh_public_contribution_state,
+            "disable_public_contribution": disable_public_contribution,
+        }
+    except ImportError as exc:
+        message = _missing_runtime_module_message("public_contribution", exc)
+
+        def _default_config(config=None):
+            payload = {
+                "enabled": False,
+                "mode": "disabled",
+                "status": "unavailable",
+                "prompted": False,
+                "message": message,
+            }
+            if isinstance(config, dict):
+                payload.update(config)
+            return payload
+
+        def ensure_public_contribution_choice(**kwargs):
+            return _default_config()
+
+        def format_public_contribution_label(config=None):
+            cfg = _default_config(config)
+            if cfg.get("status") == "unavailable":
+                return "disabled (runtime repair needed)"
+            return cfg.get("mode") or "disabled"
+
+        def load_public_contribution_config():
+            return _default_config()
+
+        def refresh_public_contribution_state(config=None):
+            return _default_config(config)
+
+        def disable_public_contribution():
+            return _default_config()
+
+        return {
+            "available": False,
+            "message": message,
+            "ensure_public_contribution_choice": ensure_public_contribution_choice,
+            "format_public_contribution_label": format_public_contribution_label,
+            "load_public_contribution_config": load_public_contribution_config,
+            "refresh_public_contribution_state": refresh_public_contribution_state,
+            "disable_public_contribution": disable_public_contribution,
+        }
+
+
 def _scripts_list(args):
     from db import init_db, list_personal_scripts
     from script_registry import list_scripts, sync_personal_scripts
@@ -453,17 +570,6 @@ def _update(args):
     - Packaged/runtime-only install: delegate to plugins.update handle_update()
     """
     from auto_update import manual_sync_update, _resolve_sync_source
-    from runtime_power import (
-        ensure_power_policy_choice,
-        apply_power_policy,
-        format_power_policy_label,
-        ensure_full_disk_access_choice,
-        format_full_disk_access_label,
-    )
-    from public_contribution import (
-        ensure_public_contribution_choice,
-        format_public_contribution_label,
-    )
 
     interactive = sys.stdin.isatty() and sys.stdout.isatty()
     progress_messages: list[str] = []
@@ -488,10 +594,12 @@ def _update(args):
             return 1
 
         result = handle_update(progress_fn=progress)
-        choice = ensure_power_policy_choice(interactive=interactive, reason="update")
-        power_result = apply_power_policy(choice.get("policy"))
-        fda_choice = ensure_full_disk_access_choice(interactive=interactive, reason="update")
-        contrib_choice = ensure_public_contribution_choice(interactive=interactive, reason="update")
+        runtime_power = _load_runtime_power_support()
+        public_contribution = _load_public_contribution_support()
+        choice = runtime_power["ensure_power_policy_choice"](interactive=interactive, reason="update")
+        power_result = runtime_power["apply_power_policy"](choice.get("policy"))
+        fda_choice = runtime_power["ensure_full_disk_access_choice"](interactive=interactive, reason="update")
+        contrib_choice = public_contribution["ensure_public_contribution_choice"](interactive=interactive, reason="update")
         if args.json:
             print(json.dumps({
                 "mode": "packaged",
@@ -510,24 +618,26 @@ def _update(args):
         else:
             print(result)
             if choice.get("prompted"):
-                print(f"Power policy: {format_power_policy_label(choice.get('policy'))}")
+                print(f"Power policy: {runtime_power['format_power_policy_label'](choice.get('policy'))}")
             if power_result.get("message"):
                 print(f"Power helper: {power_result.get('message')}")
             if fda_choice.get("prompted"):
-                print(f"Full Disk Access: {format_full_disk_access_label(fda_choice.get('status'))}")
+                print(f"Full Disk Access: {runtime_power['format_full_disk_access_label'](fda_choice.get('status'))}")
             if fda_choice.get("message"):
                 print(f"Full Disk Access: {fda_choice.get('message')}")
             if contrib_choice.get("prompted"):
-                print(f"Contributor mode: {format_public_contribution_label(contrib_choice)}")
+                print(f"Contributor mode: {public_contribution['format_public_contribution_label'](contrib_choice)}")
             if contrib_choice.get("message"):
                 print(f"Contributor mode: {contrib_choice.get('message')}")
         return 0 if "UPDATE SUCCESSFUL" in result or "Already up to date" in result else 1
 
-    choice = ensure_power_policy_choice(interactive=interactive, reason="update")
-    power_result = apply_power_policy(choice.get("policy"))
-    fda_choice = ensure_full_disk_access_choice(interactive=interactive, reason="update")
-    contrib_choice = ensure_public_contribution_choice(interactive=interactive, reason="update")
     result = manual_sync_update(interactive=interactive, allow_source_pull=True, progress_fn=progress)
+    runtime_power = _load_runtime_power_support()
+    public_contribution = _load_public_contribution_support()
+    choice = runtime_power["ensure_power_policy_choice"](interactive=interactive, reason="update")
+    power_result = runtime_power["apply_power_policy"](choice.get("policy"))
+    fda_choice = runtime_power["ensure_full_disk_access_choice"](interactive=interactive, reason="update")
+    contrib_choice = public_contribution["ensure_public_contribution_choice"](interactive=interactive, reason="update")
     result["power_policy"] = choice.get("policy")
     result["power_action"] = power_result.get("action")
     result["power_details"] = power_result.get("details")
@@ -551,18 +661,35 @@ def _update(args):
                 f"  {result.get('packages', 0)} packages, {result.get('files', 0)} files synced from "
                 f"{result.get('source', src_dir)}"
             )
+            healed = 0
+            invalid = 0
+            for action in result.get("actions", []):
+                if action.startswith("personal-schedules-healed:"):
+                    try:
+                        healed += int(action.split(":", 1)[1])
+                    except ValueError:
+                        pass
+                elif action.startswith("personal-schedules-invalid:"):
+                    try:
+                        invalid += int(action.split(":", 1)[1])
+                    except ValueError:
+                        pass
+            if healed:
+                print(f"  Personal schedules: self-healed {healed}")
+            if invalid:
+                print(f"  Personal schedules: {invalid} declarations need review")
             if result.get("pulled_source"):
                 print("  Source repo: pulled latest fast-forward before sync")
             if choice.get("prompted"):
-                print(f"  Power policy: {format_power_policy_label(choice.get('policy'))}")
+                print(f"  Power policy: {runtime_power['format_power_policy_label'](choice.get('policy'))}")
             if power_result.get("message"):
                 print(f"  Power helper: {power_result.get('message')}")
             if fda_choice.get("prompted"):
-                print(f"  Full Disk Access: {format_full_disk_access_label(fda_choice.get('status'))}")
+                print(f"  Full Disk Access: {runtime_power['format_full_disk_access_label'](fda_choice.get('status'))}")
             if fda_choice.get("message"):
                 print(f"  Full Disk Access: {fda_choice.get('message')}")
             if contrib_choice.get("prompted"):
-                print(f"  Contributor mode: {format_public_contribution_label(contrib_choice)}")
+                print(f"  Contributor mode: {public_contribution['format_public_contribution_label'](contrib_choice)}")
             if contrib_choice.get("message"):
                 print(f"  Contributor mode: {contrib_choice.get('message')}")
         else:
@@ -582,29 +709,29 @@ def _clients_sync(args):
 
 
 def _contributor_status(args):
-    from public_contribution import (
-        format_public_contribution_label,
-        load_public_contribution_config,
-        refresh_public_contribution_state,
+    public_contribution = _load_public_contribution_support()
+    config = public_contribution["refresh_public_contribution_state"](
+        public_contribution["load_public_contribution_config"]()
     )
-
-    config = refresh_public_contribution_state(load_public_contribution_config())
     payload = {
         "enabled": bool(config.get("enabled")),
         "mode": config.get("mode"),
         "status": config.get("status"),
-        "label": format_public_contribution_label(config),
+        "label": public_contribution["format_public_contribution_label"](config),
         "github_user": config.get("github_user"),
         "fork_repo": config.get("fork_repo"),
         "active_pr_url": config.get("active_pr_url"),
         "active_branch": config.get("active_branch"),
         "cooldown_until": config.get("cooldown_until"),
         "last_result": config.get("last_result"),
+        "message": config.get("message") or public_contribution.get("message"),
     }
     if args.json:
         print(json.dumps(payload, indent=2, ensure_ascii=False))
     else:
         print(f"Contributor mode: {payload['label']}")
+        if payload["message"]:
+            print(f"  {payload['message']}")
         if payload["github_user"]:
             print(f"  GitHub user: {payload['github_user']}")
         if payload["fork_repo"]:
@@ -619,30 +746,40 @@ def _contributor_status(args):
 
 
 def _contributor_on(args):
-    from public_contribution import ensure_public_contribution_choice, format_public_contribution_label
+    public_contribution = _load_public_contribution_support()
 
     interactive = sys.stdin.isatty() and sys.stdout.isatty()
     if not interactive:
         print("Contributor mode requires an interactive terminal to confirm GitHub Draft PR consent.", file=sys.stderr)
         return 1
-    config = ensure_public_contribution_choice(interactive=True, reason="contributor", force_prompt=True)
+    if not public_contribution["available"]:
+        print(public_contribution["message"], file=sys.stderr)
+        return 1
+    config = public_contribution["ensure_public_contribution_choice"](
+        interactive=True,
+        reason="contributor",
+        force_prompt=True,
+    )
     if args.json:
         print(json.dumps(config, indent=2, ensure_ascii=False))
     else:
-        print(f"Contributor mode: {format_public_contribution_label(config)}")
+        print(f"Contributor mode: {public_contribution['format_public_contribution_label'](config)}")
         if config.get("message"):
             print(config.get("message"))
     return 0 if config.get("mode") == "draft_prs" else 1
 
 
 def _contributor_off(args):
-    from public_contribution import disable_public_contribution, format_public_contribution_label
+    public_contribution = _load_public_contribution_support()
 
-    config = disable_public_contribution()
+    if not public_contribution["available"]:
+        print(public_contribution["message"], file=sys.stderr)
+        return 1
+    config = public_contribution["disable_public_contribution"]()
     if args.json:
         print(json.dumps(config, indent=2, ensure_ascii=False))
     else:
-        print(f"Contributor mode: {format_public_contribution_label(config)}")
+        print(f"Contributor mode: {public_contribution['format_public_contribution_label'](config)}")
     return 0
 
 

package/src/scripts/nexo-catchup.py

@@ -120,6 +120,30 @@ def _acquire_lock():
     return handle
 
 
+def _heal_personal_schedules() -> dict:
+    """Recreate declared personal schedules before catch-up checks missed windows."""
+    summary = {"created": 0, "repaired": 0, "invalid": 0, "error": ""}
+    try:
+        from script_registry import reconcile_personal_scripts
+
+        result = reconcile_personal_scripts(dry_run=False)
+        ensured = result.get("ensure_schedules", {})
+        summary["created"] = len(ensured.get("created", []))
+        summary["repaired"] = len(ensured.get("repaired", []))
+        summary["invalid"] = len(ensured.get("invalid", []))
+        if summary["created"] or summary["repaired"]:
+            log(
+                "Repaired declared personal schedules before catch-up: "
+                f"{summary['created']} created, {summary['repaired']} repaired."
+            )
+        if summary["invalid"]:
+            log(f"WARNING: {summary['invalid']} declared personal schedules are invalid.")
+    except Exception as e:
+        summary["error"] = str(e)
+        log(f"Personal schedule self-heal skipped: {e}")
+    return summary
+
+
 def run_task(candidate: dict, state: dict) -> bool:
     """Execute a task and update state."""
     name = candidate["cron_id"]
@@ -172,6 +196,7 @@ def main():
         log("Catch-Up already running; skipping overlapping invocation.")
         return
 
+    _heal_personal_schedules()
     state = load_state()
     tasks = catchup_candidates()