nexo-brain 7.1.0 → 7.1.2

package/src/hooks/heartbeat-user-msg.sh

@@ -6,6 +6,8 @@ NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
 HELPER=""
 if [ -n "${NEXO_CODE:-}" ] && [ -f "${NEXO_CODE%/}/hooks/heartbeat-enforcement.py" ]; then
     HELPER="${NEXO_CODE%/}/hooks/heartbeat-enforcement.py"
+elif [ -f "$NEXO_HOME/core/hooks/heartbeat-enforcement.py" ]; then
+    HELPER="$NEXO_HOME/core/hooks/heartbeat-enforcement.py"
 elif [ -f "$NEXO_HOME/hooks/heartbeat-enforcement.py" ]; then
     HELPER="$NEXO_HOME/hooks/heartbeat-enforcement.py"
 fi

package/src/hooks/inbox-hook.sh

@@ -28,8 +28,12 @@ echo "$NOW" > "$DEBOUNCE_FILE"
 
 # 4. Find NEXO SID mapped to this Claude session_id
 NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-DB="$NEXO_HOME/data/nexo.db"
-mkdir -p "$NEXO_HOME/data"
+DATA_DIR="$NEXO_HOME/runtime/data"
+if [ ! -d "$DATA_DIR" ] && [ -d "$NEXO_HOME/data" ]; then
+    DATA_DIR="$NEXO_HOME/data"
+fi
+DB="$DATA_DIR/nexo.db"
+mkdir -p "$DATA_DIR"
 [ -f "$DB" ] || exit 0
 
 NEXO_SID=$(sqlite3 "$DB" "SELECT sid FROM sessions WHERE (external_session_id = '${CLAUDE_SID}' OR claude_session_id = '${CLAUDE_SID}') AND last_update_epoch > (strftime('%s','now') - 900) ORDER BY last_update_epoch DESC LIMIT 1;" 2>/dev/null)

package/src/hooks/post-compact.sh

@@ -5,10 +5,18 @@
 set -uo pipefail
 
 NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-NEXO_DB="$NEXO_HOME/data/nexo.db"
-mkdir -p "$NEXO_HOME/data"
+DATA_DIR="$NEXO_HOME/runtime/data"
+if [ ! -d "$DATA_DIR" ] && [ -d "$NEXO_HOME/data" ]; then
+    DATA_DIR="$NEXO_HOME/data"
+fi
+OPERATIONS_DIR="$NEXO_HOME/runtime/operations"
+if [ ! -d "$OPERATIONS_DIR" ] && [ -d "$NEXO_HOME/operations" ]; then
+    OPERATIONS_DIR="$NEXO_HOME/operations"
+fi
+NEXO_DB="$DATA_DIR/nexo.db"
+mkdir -p "$DATA_DIR" "$OPERATIONS_DIR"
 TODAY=$(date +%Y-%m-%d)
-LOG_FILE="$NEXO_HOME/operations/tool-logs/${TODAY}.jsonl"
+LOG_FILE="$OPERATIONS_DIR/tool-logs/${TODAY}.jsonl"
 LOG_LINES=0
 if [ -f "$LOG_FILE" ]; then
     LOG_LINES=$(wc -l < "$LOG_FILE" | tr -d ' ')
@@ -120,7 +128,7 @@ if [ -f "$NEXO_DB" ]; then
             BLOCK="$BLOCK\n**Session tasks so far:** $TASKS_SEEN"
         fi
 
-        BLOCK="$BLOCK\n**Tool logs:** ${NEXO_HOME}/operations/tool-logs/${TODAY}.jsonl ($LOG_LINES entries)"
+        BLOCK="$BLOCK\n**Tool logs:** ${OPERATIONS_DIR}/tool-logs/${TODAY}.jsonl ($LOG_LINES entries)"
         BLOCK="$BLOCK\n\n**POST-COMPACTION INSTRUCTIONS:**"
         BLOCK="$BLOCK\n1. Call nexo_heartbeat with the SID above to reconnect with the session"
         BLOCK="$BLOCK\n2. If you need specific lost data, query tool logs with jq"

package/src/hooks/pre-compact.sh

@@ -7,10 +7,18 @@ set -uo pipefail
 
 HOOK_DIR="$(cd "$(dirname "$0")" && pwd)"
 NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-NEXO_DB="$NEXO_HOME/data/nexo.db"
-mkdir -p "$NEXO_HOME/data"
+DATA_DIR="$NEXO_HOME/runtime/data"
+if [ ! -d "$DATA_DIR" ] && [ -d "$NEXO_HOME/data" ]; then
+    DATA_DIR="$NEXO_HOME/data"
+fi
+OPERATIONS_DIR="$NEXO_HOME/runtime/operations"
+if [ ! -d "$OPERATIONS_DIR" ] && [ -d "$NEXO_HOME/operations" ]; then
+    OPERATIONS_DIR="$NEXO_HOME/operations"
+fi
+NEXO_DB="$DATA_DIR/nexo.db"
+mkdir -p "$DATA_DIR" "$OPERATIONS_DIR"
 TODAY=$(date +%Y-%m-%d)
-LOG_FILE="$NEXO_HOME/operations/tool-logs/${TODAY}.jsonl"
+LOG_FILE="$OPERATIONS_DIR/tool-logs/${TODAY}.jsonl"
 LOG_LINES=0
 if [ -f "$LOG_FILE" ]; then
     LOG_LINES=$(wc -l < "$LOG_FILE" | tr -d ' ')
@@ -164,6 +172,6 @@ fi
 
 cat << HOOKEOF
 {
-  "systemMessage": "CONTEXT IS ABOUT TO BE COMPRESSED.\n\nOBLIGATORY ACTIONS BEFORE COMPACTION:\n1. Save critical state via MCP: nexo_checkpoint_save with current task, active files, decisions, errors, next step, and reasoning thread.\n2. If there is work in progress without a commit, save data via nexo_entity_create, nexo_preference_set, nexo_learning_add, nexo_followup_create.\n3. PERSISTENT TOOL LOGS: ${NEXO_HOME}/operations/tool-logs/${TODAY}.jsonl has ${LOG_LINES} entries.\n4. After compaction, the PostCompact hook will re-inject a Core Memory Block with the checkpoint.\n5. MCP tools (nexo_*) preserve all state — use them to recover context.\n6. EMERGENCY DIARY: An automatic diary was written by the pre-compact hook. The LLM can still write a better one via nexo_session_diary_write."
+  "systemMessage": "CONTEXT IS ABOUT TO BE COMPRESSED.\n\nOBLIGATORY ACTIONS BEFORE COMPACTION:\n1. Save critical state via MCP: nexo_checkpoint_save with current task, active files, decisions, errors, next step, and reasoning thread.\n2. If there is work in progress without a commit, save data via nexo_entity_create, nexo_preference_set, nexo_learning_add, nexo_followup_create.\n3. PERSISTENT TOOL LOGS: ${OPERATIONS_DIR}/tool-logs/${TODAY}.jsonl has ${LOG_LINES} entries.\n4. After compaction, the PostCompact hook will re-inject a Core Memory Block with the checkpoint.\n5. MCP tools (nexo_*) preserve all state — use them to recover context.\n6. EMERGENCY DIARY: An automatic diary was written by the pre-compact hook. The LLM can still write a better one via nexo_session_diary_write."
 }
 HOOKEOF

package/src/migrate_embeddings.py

@@ -15,10 +15,12 @@ import sys
 import time
 import numpy as np
 
+import paths
+
 NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
-_data_dir = os.path.join(NEXO_HOME, "data")
-os.makedirs(_data_dir, exist_ok=True)
-DB_PATH = os.path.join(_data_dir, "cognitive.db")
+_cognitive_dir = paths.cognitive_dir()
+_cognitive_dir.mkdir(parents=True, exist_ok=True)
+DB_PATH = str(_cognitive_dir / "cognitive.db")
 BACKUP_PATH = DB_PATH + ".bak-384dims-pre-upgrade"
 
 MODELS = {

package/src/nexo_migrate.py

@@ -30,6 +30,8 @@ import time
 from pathlib import Path
 from typing import Callable
 
+import paths
+
 
 def _nexo_home() -> Path:
     env = os.environ.get("NEXO_HOME")
@@ -42,7 +44,7 @@ def _db_path() -> Path:
     env = os.environ.get("NEXO_DB_PATH")
     if env:
         return Path(env)
-    return _nexo_home() / "data" / "nexo.db"
+    return paths.resolve_db_path()
 
 
 def _structure_version_path() -> Path:

package/src/plugin_loader.py

@@ -8,6 +8,7 @@ import signal
 import sys
 import time
 
+import paths
 from db import get_db
 from fastmcp.tools import Tool
 
@@ -25,9 +26,9 @@ except ModuleNotFoundError as exc:
 SERVER_DIR = os.path.dirname(os.path.abspath(__file__))
 PLUGINS_DIR = os.path.join(SERVER_DIR, "plugins")
 
-# Personal plugins directory: NEXO_HOME/plugins/ (env var, defaults to ~/.nexo/)
+# Personal plugins directory: NEXO_HOME/personal/plugins/ (env var, defaults to ~/.nexo/)
 NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
-PERSONAL_PLUGINS_DIR = os.path.join(NEXO_HOME, "plugins")
+PERSONAL_PLUGINS_DIR = str(paths.personal_plugins_dir())
 
 PLUGIN_LOAD_TIMEOUT = 10  # seconds per plugin
 
@@ -141,14 +142,22 @@ def load_all_plugins(mcp) -> int:
                     continue
                 plugin_map[f] = (PLUGINS_DIR, "repo")
 
-    # 2. Personal plugins (override if same filename)
+    # 2. Personal plugins. Never let a personal file shadow a packaged core
+    # plugin at startup: creation already rejects that collision, and keeping
+    # the repo plugin canonical avoids hybrid installs with two sources of truth.
     if os.path.isdir(PERSONAL_PLUGINS_DIR):
         for f in sorted(os.listdir(PERSONAL_PLUGINS_DIR)):
             if f.endswith(".py") and f != "__init__.py":
                 if is_duplicate_artifact_name(os.path.join(PERSONAL_PLUGINS_DIR, f)):
                     continue
-                source = "personal (override)" if f in plugin_map else "personal"
-                plugin_map[f] = (PERSONAL_PLUGINS_DIR, source)
+                if f in plugin_map:
+                    print(
+                        f"[PLUGIN SHADOW SKIP] {f}: personal plugin collides with packaged core filename; "
+                        "keeping core plugin canonical",
+                        file=sys.stderr,
+                    )
+                    continue
+                plugin_map[f] = (PERSONAL_PLUGINS_DIR, "personal")
 
     # Load all in sorted order
     for f in sorted(plugin_map):

package/src/plugins/adaptive_mode.py

@@ -28,10 +28,13 @@ import time
 import math
 import subprocess
 from datetime import datetime, timedelta
+from pathlib import Path
+
+import paths
 from db import get_db
 
 NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
-ADAPTIVE_STATE_FILE = os.path.join(NEXO_HOME, "brain", "adaptive_state.json")
+ADAPTIVE_STATE_FILE = str(paths.brain_dir() / "adaptive_state.json")
 
 # Mode definitions
 MODES = {

package/src/plugins/backup.py

@@ -14,12 +14,12 @@ import shutil
 import sqlite3
 import threading
 import time
+from pathlib import Path
 
+import paths
 from db import get_db
 
 NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
-DB_PATH = os.path.join(NEXO_HOME, "data", "nexo.db")
-BACKUP_DIR = os.path.join(NEXO_HOME, "backups")
 
 RETENTION_DAYS = 7
 
@@ -66,6 +66,14 @@ def _reset_rate_limit_state_for_tests() -> None:
             _last_call_ts[key] = 0.0
 
 
+def _db_path() -> Path:
+    return paths.db_path()
+
+
+def _backup_dir() -> Path:
+    return paths.backups_dir()
+
+
 def handle_backup_now() -> str:
     """Create an immediate backup of the NEXO database.
 
@@ -75,14 +83,15 @@ def handle_backup_now() -> str:
     if err is not None:
         return err
 
-    os.makedirs(BACKUP_DIR, exist_ok=True)
+    backup_dir = _backup_dir()
+    backup_dir.mkdir(parents=True, exist_ok=True)
     timestamp = time.strftime("%Y-%m-%d-%H%M")
-    dest = os.path.join(BACKUP_DIR, f"nexo-{timestamp}.db")
+    dest = backup_dir / f"nexo-{timestamp}.db"
 
     # Use SQLite backup API for consistency
-    src_conn = sqlite3.connect(DB_PATH)
+    src_conn = sqlite3.connect(str(_db_path()))
     try:
-        dst_conn = sqlite3.connect(dest)
+        dst_conn = sqlite3.connect(str(dest))
         try:
             src_conn.backup(dst_conn)
         finally:
@@ -90,16 +99,17 @@ def handle_backup_now() -> str:
     finally:
         src_conn.close()
 
-    size_kb = os.path.getsize(dest) / 1024
+    size_kb = dest.stat().st_size / 1024
     _cleanup_old()
-    return f"Backup created: {os.path.basename(dest)} ({size_kb:.0f} KB)"
+    return f"Backup created: {dest.name} ({size_kb:.0f} KB)"
 
 
 def handle_backup_list() -> str:
     """List available backups with dates and sizes."""
-    if not os.path.isdir(BACKUP_DIR):
+    backup_dir = _backup_dir()
+    if not backup_dir.is_dir():
         return "No backups."
-    files = sorted(glob.glob(os.path.join(BACKUP_DIR, "nexo-*.db")), reverse=True)
+    files = sorted(glob.glob(str(backup_dir / "nexo-*.db")), reverse=True)
     if not files:
         return "No backups."
     lines = [f"BACKUPS ({len(files)}):"]
@@ -127,15 +137,16 @@ def handle_backup_restore(filename: str) -> str:
     if err is not None:
         return err
 
-    src = os.path.join(BACKUP_DIR, filename)
-    if not os.path.isfile(src):
+    backup_dir = _backup_dir()
+    src = backup_dir / filename
+    if not src.is_file():
         return f"Backup not found: {filename}"
 
     # Create safety backup first
-    safety = os.path.join(BACKUP_DIR, f"nexo-pre-restore-{time.strftime('%Y%m%d%H%M%S')}.db")
-    src_conn = sqlite3.connect(DB_PATH)
+    safety = backup_dir / f"nexo-pre-restore-{time.strftime('%Y%m%d%H%M%S')}.db"
+    src_conn = sqlite3.connect(str(_db_path()))
     try:
-        dst_conn = sqlite3.connect(safety)
+        dst_conn = sqlite3.connect(str(safety))
         try:
             src_conn.backup(dst_conn)
         finally:
@@ -144,9 +155,9 @@ def handle_backup_restore(filename: str) -> str:
         src_conn.close()
 
     # Restore
-    restore_conn = sqlite3.connect(src)
+    restore_conn = sqlite3.connect(str(src))
     try:
-        target_conn = sqlite3.connect(DB_PATH)
+        target_conn = sqlite3.connect(str(_db_path()))
         try:
             restore_conn.backup(target_conn)
         finally:
@@ -163,7 +174,7 @@ def handle_backup_restore(filename: str) -> str:
             pass
         db._shared_conn = None
 
-    return f"DB restaurada desde {filename}. Safety backup: {os.path.basename(safety)}"
+    return f"DB restaurada desde {filename}. Safety backup: {safety.name}"
 
 
 def _cleanup_old():
@@ -173,12 +184,13 @@ def _cleanup_old():
     `nexo-pre-restore-*.db` safety snapshots created by handle_backup_restore.
     Failures are swallowed — housekeeping must never interrupt the caller.
     """
-    if not os.path.isdir(BACKUP_DIR):
+    backup_dir = _backup_dir()
+    if not backup_dir.is_dir():
         return
     cutoff = time.time() - (RETENTION_DAYS * 86400)
     # glob `nexo-*.db` matches both the hourly pattern and pre-restore
     # snapshots, so a single loop prunes both with a single pass.
-    for f in glob.glob(os.path.join(BACKUP_DIR, "nexo-*.db")):
+    for f in glob.glob(str(backup_dir / "nexo-*.db")):
         try:
             if os.path.getmtime(f) < cutoff:
                 os.remove(f)

package/src/plugins/evolution.py

@@ -42,6 +42,8 @@ def handle_evolution_status() -> str:
 
     from user_context import get_context
     lines = [f"{get_context().assistant_name} EVOLUTION STATUS:"]
+    if objective and objective.get("evolution_enabled") is False:
+        lines.append(f"  Disabled: {objective.get('disabled_reason', 'unknown')}")
     has_output = False
     for key, label in CANONICAL_DIMENSIONS.items():
         m = metrics.get(key)

package/src/plugins/memory_export.py

@@ -11,6 +11,7 @@ import cognitive
 import claim_graph
 import compaction_memory
 import media_memory
+import paths
 import user_state_model
 from db import get_db
 from memory_backends import get_backend, list_backends
@@ -69,7 +70,11 @@ def handle_memory_export(format: str = "markdown", output_dir: str = "") -> str:
         return "ERROR: only markdown export is supported for now."
 
     stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
-    root = Path(output_dir).expanduser() if output_dir.strip() else (_nexo_home() / "exports" / "memory" / stamp)
+    root = (
+        Path(output_dir).expanduser()
+        if output_dir.strip()
+        else (paths.exports_dir() / "memory" / stamp)
+    )
     root.mkdir(parents=True, exist_ok=True)
 
     conn = get_db()

package/src/plugins/personal_plugins.py

@@ -1,4 +1,4 @@
-"""NEXO Personal Plugins — scaffold persistent MCP tools in NEXO_HOME/plugins."""
+"""NEXO Personal Plugins — scaffold persistent MCP tools in NEXO_HOME/personal/plugins."""
 
 from __future__ import annotations
 
@@ -16,11 +16,15 @@ NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent
 
 
 def _plugins_dir() -> Path:
-    path = paths.core_plugins_dir()
+    path = paths.personal_plugins_dir()
     path.mkdir(parents=True, exist_ok=True)
     return path
 
 
+def _core_plugin_path(filename: str) -> Path:
+    return paths.core_plugins_dir() / filename
+
+
 def _safe_slug(value: str) -> str:
     chars: list[str] = []
     for ch in str(value or "").lower():
@@ -68,11 +72,11 @@ def _render_plugin_template(*, plugin_stem: str, tool_name: str, description: st
     content = content.replace("handle_example_tool", handler_name)
     content = content.replace("nexo_example_tool", tool_name)
     content = content.replace(
-        "Personal plugin scaffold created. Edit this handler in NEXO_HOME/plugins.",
+        "Personal plugin scaffold created. Edit this handler in NEXO_HOME/personal/plugins.",
         description or f"Personal plugin scaffold for {plugin_stem}.",
     )
     content = content.replace(
-        "Example personal MCP tool scaffold. Edit it in NEXO_HOME/plugins.",
+        "Example personal MCP tool scaffold. Edit it in NEXO_HOME/personal/plugins.",
         description or f"Personal MCP tool scaffold for {plugin_stem}.",
     )
     return content
@@ -86,15 +90,21 @@ def handle_personal_plugin_create(
     script_runtime: str = "python",
     force: bool = False,
 ) -> str:
-    """Create a personal MCP plugin scaffold in NEXO_HOME/plugins.
+    """Create a personal MCP plugin scaffold in NEXO_HOME/personal/plugins.
 
-    Optionally also creates a companion script in NEXO_HOME/scripts.
+    Optionally also creates a companion script in NEXO_HOME/personal/scripts.
     """
     init_db()
     plugin_stem = _safe_slug(name)
     filename = f"{plugin_stem}.py"
     tool_name = (tool_name or f"nexo_{plugin_stem.replace('-', '_')}").strip()
     plugin_path = _plugins_dir() / filename
+    core_plugin_path = _core_plugin_path(filename)
+    if core_plugin_path.exists() and not force:
+        return json.dumps({
+            "ok": False,
+            "error": f"Personal plugin name collides with a core plugin identity: {filename}",
+        }, ensure_ascii=False)
     if plugin_path.exists() and not force:
         return json.dumps({
             "ok": False,
@@ -137,6 +147,6 @@ TOOLS = [
     (
         handle_personal_plugin_create,
         "nexo_personal_plugin_create",
-        "Create a persistent personal MCP plugin scaffold in NEXO_HOME/plugins, optionally with a companion script in NEXO_HOME/scripts.",
+        "Create a persistent personal MCP plugin scaffold in NEXO_HOME/personal/plugins, optionally with a companion script in NEXO_HOME/personal/scripts.",
     ),
 ]

package/src/plugins/personal_scripts.py

@@ -8,8 +8,13 @@ from script_registry import (
     classify_scripts_dir,
     create_script,
     ensure_personal_schedules,
+    get_automation_status,
+    list_operator_automations,
     reconcile_personal_scripts,
     remove_personal_script,
+    set_automation_enabled,
+    set_automation_instructions,
+    set_automation_schedule,
     sync_personal_scripts,
     unschedule_personal_script,
 )
@@ -98,23 +103,79 @@ def handle_personal_script_remove(name: str, keep_file: bool = False) -> str:
     return json.dumps(remove_personal_script(name, keep_file=keep_file), ensure_ascii=False)
 
 
+def handle_automations_list(include_all: bool = False) -> str:
+    init_db()
+    return json.dumps({"ok": True, "automations": list_operator_automations(include_all=include_all)}, ensure_ascii=False)
+
+
+def handle_automation_status(name: str) -> str:
+    init_db()
+    return json.dumps(get_automation_status(name), ensure_ascii=False)
+
+
+def handle_automation_enable(name: str) -> str:
+    init_db()
+    return json.dumps(set_automation_enabled(name, True), ensure_ascii=False)
+
+
+def handle_automation_disable(name: str) -> str:
+    init_db()
+    return json.dumps(set_automation_enabled(name, False), ensure_ascii=False)
+
+
+def handle_automation_instructions(name: str, text: str = "", clear: bool = False) -> str:
+    init_db()
+    return json.dumps(set_automation_instructions(name, "" if clear else text), ensure_ascii=False)
+
+
+def handle_automation_schedule(
+    name: str,
+    every_seconds: int = 0,
+    daily_at: str = "",
+    clear: bool = False,
+) -> str:
+    init_db()
+    interval_seconds = int(every_seconds or 0) or None
+    return json.dumps(
+        set_automation_schedule(
+            name,
+            interval_seconds=interval_seconds,
+            daily_at=str(daily_at or "").strip() or None,
+            clear=bool(clear),
+        ),
+        ensure_ascii=False,
+    )
+
+
 TOOLS = [
     (handle_personal_scripts_sync, "nexo_personal_scripts_sync",
      "Sync personal scripts and personal cron schedules from filesystem and LaunchAgents into the registry."),
     (handle_personal_scripts_classify, "nexo_personal_scripts_classify",
-     "Classify files in NEXO_HOME/scripts into personal, core, ignored, and non-script buckets."),
+     "Classify files in NEXO_HOME/personal/scripts into personal, core, ignored, and non-script buckets."),
     (handle_personal_scripts_list, "nexo_personal_scripts_list",
      "List personal scripts known to NEXO, optionally including attached schedules."),
     (handle_personal_script_create, "nexo_personal_script_create",
-     "Create a new personal script in NEXO_HOME/scripts, register it, and optionally attach a schedule."),
+     "Create a new personal script in NEXO_HOME/personal/scripts, register it, and optionally attach a schedule."),
     (handle_personal_script_schedules, "nexo_personal_script_schedules",
      "List registered personal script schedules."),
     (handle_personal_scripts_reconcile, "nexo_personal_scripts_reconcile",
-     "Classify, sync, and ensure declared personal schedules so NEXO_HOME/scripts and personal crons stay aligned."),
+     "Classify, sync, and ensure declared personal schedules so NEXO_HOME/personal/scripts and personal crons stay aligned."),
     (handle_personal_scripts_ensure_schedules, "nexo_personal_scripts_ensure_schedules",
      "Create or repair personal script schedules declared in inline metadata."),
     (handle_personal_script_unschedule, "nexo_personal_script_unschedule",
      "Remove all personal schedules attached to a script without touching core crons."),
     (handle_personal_script_remove, "nexo_personal_script_remove",
      "Remove a personal script from the registry and optionally delete its file after unscheduling it."),
+    (handle_automations_list, "nexo_automations_list",
+     "List the operator-facing automations NEXO Desktop manages directly, with optional support/debug widening."),
+    (handle_automation_status, "nexo_automation_status",
+     "Read the composed runtime status for one automation, including availability, schedule, and operator overrides."),
+    (handle_automation_enable, "nexo_automation_enable",
+     "Enable one operator-facing automation."),
+    (handle_automation_disable, "nexo_automation_disable",
+     "Disable one operator-facing automation."),
+    (handle_automation_instructions, "nexo_automation_instructions",
+     "Set or clear operator-side extra instructions for one automation without editing the core prompt."),
+    (handle_automation_schedule, "nexo_automation_schedule",
+     "Set or clear the cadence override for one operator-facing automation."),
 ]

package/src/presets/entities_universal.json

@@ -109,8 +109,8 @@
       "aliases": [],
       "metadata": {
         "old": "~/claude/hooks",
-        "canonical": "~/.nexo/hooks",
-        "note": "Pre-v6 runtime lived under ~/claude/*; canonical runtime is ~/.nexo/*"
+        "canonical": "~/.nexo/personal/hooks",
+        "note": "Pre-v6 runtime lived under ~/claude/*; operator-owned hooks now live under ~/.nexo/personal/*."
       }
     },
     {
@@ -119,7 +119,7 @@
       "aliases": [],
       "metadata": {
         "old": "~/claude/scripts",
-        "canonical": "~/.nexo/scripts"
+        "canonical": "~/.nexo/personal/scripts"
       }
     },
     {
@@ -128,7 +128,70 @@
       "aliases": [],
       "metadata": {
         "old": "~/claude/brain",
-        "canonical": "~/.nexo/brain"
+        "canonical": "~/.nexo/personal/brain"
+      }
+    },
+    {
+      "type": "legacy_path",
+      "name": "flat_nexo_scripts_to_personal",
+      "aliases": [],
+      "metadata": {
+        "old": "~/.nexo/scripts",
+        "canonical": "~/.nexo/personal/scripts"
+      }
+    },
+    {
+      "type": "legacy_path",
+      "name": "flat_nexo_brain_to_personal",
+      "aliases": [],
+      "metadata": {
+        "old": "~/.nexo/brain",
+        "canonical": "~/.nexo/personal/brain"
+      }
+    },
+    {
+      "type": "legacy_path",
+      "name": "flat_nexo_config_to_personal",
+      "aliases": [],
+      "metadata": {
+        "old": "~/.nexo/config",
+        "canonical": "~/.nexo/personal/config"
+      }
+    },
+    {
+      "type": "legacy_path",
+      "name": "flat_nexo_data_to_runtime",
+      "aliases": [],
+      "metadata": {
+        "old": "~/.nexo/data",
+        "canonical": "~/.nexo/runtime/data"
+      }
+    },
+    {
+      "type": "legacy_path",
+      "name": "flat_nexo_logs_to_runtime",
+      "aliases": [],
+      "metadata": {
+        "old": "~/.nexo/logs",
+        "canonical": "~/.nexo/runtime/logs"
+      }
+    },
+    {
+      "type": "legacy_path",
+      "name": "flat_nexo_operations_to_runtime",
+      "aliases": [],
+      "metadata": {
+        "old": "~/.nexo/operations",
+        "canonical": "~/.nexo/runtime/operations"
+      }
+    },
+    {
+      "type": "legacy_path",
+      "name": "flat_nexo_exports_to_runtime",
+      "aliases": [],
+      "metadata": {
+        "old": "~/.nexo/exports",
+        "canonical": "~/.nexo/runtime/exports"
       }
     },
     {