nexo-brain 7.1.1 → 7.1.2

package/src/crons/manifest.json

@@ -90,6 +90,19 @@
       "run_on_boot": true,
       "run_on_wake": true
     },
+    {
+      "id": "backup",
+      "script": "scripts/nexo-backup.sh",
+      "type": "shell",
+      "interval_seconds": 3600,
+      "description": "Hourly validated runtime backups",
+      "core": true,
+      "recovery_policy": "restart",
+      "idempotent": true,
+      "max_catchup_age": 14400,
+      "run_on_boot": true,
+      "run_on_wake": false
+    },
     {
       "id": "self-audit",
       "script": "scripts/nexo-daily-self-audit.py",
@@ -204,6 +217,50 @@
       "run_on_boot": true,
       "run_on_wake": true
     },
+    {
+      "id": "tcc-approve",
+      "script": "scripts/nexo-tcc-approve.sh",
+      "type": "shell",
+      "run_at_load": true,
+      "watch_paths": ["~/.local/share/claude/versions"],
+      "platforms": ["darwin"],
+      "description": "Grant macOS TCC permissions to newly installed Claude binaries",
+      "core": true,
+      "recovery_policy": "none",
+      "idempotent": true,
+      "max_catchup_age": 0,
+      "run_on_boot": true,
+      "run_on_wake": false
+    },
+    {
+      "id": "prevent-sleep",
+      "script": "scripts/nexo-prevent-sleep.sh",
+      "type": "shell",
+      "keep_alive": true,
+      "proc_grep": "caffeinate",
+      "requires_power_policy": "always_on",
+      "description": "Keep the machine awake while the always-on power policy is enabled",
+      "core": true,
+      "recovery_policy": "restart",
+      "idempotent": true,
+      "max_catchup_age": 0,
+      "run_on_boot": true,
+      "run_on_wake": true
+    },
+    {
+      "id": "dashboard",
+      "script": "scripts/nexo-dashboard.sh",
+      "type": "shell",
+      "keep_alive": true,
+      "optional": "dashboard",
+      "description": "Keep the NEXO dashboard web UI available on localhost:6174",
+      "core": true,
+      "recovery_policy": "restart",
+      "idempotent": true,
+      "max_catchup_age": 0,
+      "run_on_boot": true,
+      "run_on_wake": true
+    },
     {
       "id": "auto-update",
       "script": "scripts/nexo-auto-update.py",

package/src/crons/sync.py

@@ -32,7 +32,7 @@ if str(_runtime_root) not in sys.path:
     sys.path.insert(0, str(_runtime_root))
 
 import paths
-from cron_recovery import resolve_declared_schedule, should_run_at_load
+from cron_recovery import is_cron_enabled, resolve_declared_schedule, should_run_at_load
 try:
     from runtime_power import resolve_launchagent_path
 except ImportError:
@@ -77,6 +77,13 @@ def _runtime_scripts_dir() -> Path:
     return new
 
 
+def _runtime_code_dir() -> Path:
+    packaged = RUNTIME_ROOT / "core"
+    if packaged.exists() or not (RUNTIME_ROOT / "server.py").exists():
+        return packaged
+    return RUNTIME_ROOT
+
+
 def _runtime_crons_dir() -> Path:
     new = RUNTIME_ROOT / "runtime" / "crons"
     legacy = RUNTIME_ROOT / "crons"
@@ -104,6 +111,12 @@ def _sync_watchdog_hash_registry():
                     continue
                 file_path, expected_hash = line.split("|", 1)
                 if file_path:
+                    candidate = Path(file_path)
+                    try:
+                        if candidate.resolve(strict=False) == watchdog_path.resolve(strict=False):
+                            continue
+                    except Exception:
+                        pass
                     entries[file_path] = expected_hash
         import hashlib
         entries[str(watchdog_path)] = hashlib.sha256(watchdog_path.read_bytes()).hexdigest()
@@ -144,6 +157,10 @@ def load_manifest() -> list[dict]:
         from automation_controls import apply_core_automation_overrides
     except Exception:
         apply_core_automation_overrides = None
+    try:
+        from product_mode import filter_blocked_crons
+    except Exception:
+        filter_blocked_crons = None
 
     with open(MANIFEST) as f:
         data = json.load(f)
@@ -156,24 +173,30 @@ def load_manifest() -> list[dict]:
         except Exception as e:
             log(f"WARNING: could not read optionals.json: {e}")
 
-    automation_default = True
+    schedule_data: dict = {}
     if SCHEDULE_FILE.is_file():
         try:
-            schedule_data = json.loads(SCHEDULE_FILE.read_text())
-            automation_default = bool(schedule_data.get("automation_enabled", True))
+            loaded = json.loads(SCHEDULE_FILE.read_text())
+            if isinstance(loaded, dict):
+                schedule_data = loaded
         except Exception:
             pass
 
     filtered = []
     for cron in crons:
-        optional_key = cron.get("optional")
-        if optional_key == "automation":
-            enabled = enabled_optionals.get(optional_key, automation_default)
-        else:
-            enabled = enabled_optionals.get(optional_key, False)
-        if optional_key and not enabled:
+        if not is_cron_enabled(
+            cron,
+            optionals=enabled_optionals,
+            schedule_data=schedule_data,
+            system=platform.system(),
+        ):
             continue
         filtered.append(cron)
+    if callable(filter_blocked_crons):
+        try:
+            filtered = filter_blocked_crons(filtered)
+        except Exception as e:
+            log(f"WARNING: could not filter product-blocked crons: {e}")
     if callable(apply_core_automation_overrides):
         try:
             return apply_core_automation_overrides(filtered)
@@ -320,7 +343,7 @@ def build_plist(cron: dict) -> dict:
             "PATH": resolve_launchagent_path(),
             "HOME": str(Path.home()),
             "NEXO_HOME": str(NEXO_HOME),
-            "NEXO_CODE": str(RUNTIME_ROOT),
+            "NEXO_CODE": str(_runtime_code_dir()),
             "NEXO_SOURCE_CODE": str(SOURCE_ROOT),
             "NEXO_MANAGED_CORE_CRON": "1",
             "PYTHONUNBUFFERED": "1",
@@ -334,6 +357,11 @@ def build_plist(cron: dict) -> dict:
     else:
         if should_run_at_load(cron):
             plist["RunAtLoad"] = True
+    if cron.get("watch_paths"):
+        plist["WatchPaths"] = [
+            str(Path(str(path)).expanduser()) if str(path).startswith("~") else str(path)
+            for path in cron.get("watch_paths", [])
+        ]
     if "interval_seconds" in cron and not cron.get("keep_alive"):
         plist["StartInterval"] = cron["interval_seconds"]
     elif "schedule" in cron and not cron.get("keep_alive"):
@@ -380,6 +408,8 @@ def plist_needs_update(existing_path: Path, new_plist: dict) -> bool:
         return True
     if existing.get("KeepAlive") != new_plist.get("KeepAlive"):
         return True
+    if existing.get("WatchPaths") != new_plist.get("WatchPaths"):
+        return True
     if existing.get("EnvironmentVariables") != new_plist.get("EnvironmentVariables"):
         return True
     return False
@@ -418,6 +448,36 @@ def _plist_is_personal(existing: dict) -> bool:
     return env.get(PERSONAL_CRON_MANAGED_ENV) == "1" or bool(env.get(PERSONAL_CRON_ID_ENV))
 
 
+def _core_launchagent_roots() -> tuple[Path, ...]:
+    roots: list[Path] = []
+    for root in (
+        SOURCE_ROOT / "scripts",
+        RUNTIME_ROOT / "core" / "scripts",
+        RUNTIME_ROOT / "scripts",
+        paths.core_scripts_dir(),
+    ):
+        normalized = root.expanduser()
+        if normalized not in roots:
+            roots.append(normalized)
+    return tuple(roots)
+
+
+def _program_arguments_point_to_core(existing: dict) -> bool:
+    args = existing.get("ProgramArguments", []) or []
+    for arg in args:
+        try:
+            candidate = Path(str(arg)).expanduser()
+        except Exception:
+            continue
+        for root in _core_launchagent_roots():
+            try:
+                candidate.relative_to(root)
+                return True
+            except ValueError:
+                continue
+    return False
+
+
 def _plist_is_core(existing: dict) -> bool:
     """Return True when a LaunchAgent should be treated as a core cron."""
     env = existing.get("EnvironmentVariables", {}) or {}
@@ -427,6 +487,9 @@ def _plist_is_core(existing: dict) -> bool:
     if env.get(CORE_CRON_MANAGED_ENV) == "1":
         return True
 
+    if _program_arguments_point_to_core(existing):
+        return True
+
     args = existing.get("ProgramArguments", [])
     arg_blob = " ".join(str(a) for a in args)
     return (
@@ -536,20 +599,25 @@ def sync_linux(dry_run: bool = False):
         stdout_log = LOG_DIR / f"{cron_id}-stdout.log"
         stderr_log = LOG_DIR / f"{cron_id}-stderr.log"
 
+        service_type = "simple" if cron.get("keep_alive") else "oneshot"
+        restart_block = "Restart=always\nRestartSec=5\n" if cron.get("keep_alive") else ""
+        install_block = "\n[Install]\nWantedBy=default.target\n" if cron.get("keep_alive") else ""
         service_content = f"""[Unit]
 Description=NEXO: {cron.get('description', cron_id)}
 
 [Service]
-Type=oneshot
+Type={service_type}
 ExecStart={exec_cmd}
 Environment=NEXO_HOME={NEXO_HOME}
-Environment=NEXO_CODE={SOURCE_ROOT}
+Environment=NEXO_CODE={_runtime_code_dir()}
 Environment=HOME={Path.home()}
 StandardOutput=append:{stdout_log}
 StandardError=append:{stderr_log}
-"""
+{restart_block}{install_block}"""
 
-        if cron.get("run_at_load"):
+        if cron.get("keep_alive"):
+            timer_spec = ""
+        elif cron.get("run_at_load"):
             timer_spec = "OnBootSec=0"
         elif "interval_seconds" in cron:
             timer_spec = f"OnUnitActiveSec={cron['interval_seconds']}s\nOnBootSec=60s"
@@ -566,6 +634,15 @@ StandardError=append:{stderr_log}
             log(f"  SKIP {cron_id}: no schedule or interval")
             continue
 
+        if dry_run:
+            log(f"  DRY-RUN: would install {cron_id}")
+            continue
+
+        service_path.write_text(service_content)
+        if cron.get("keep_alive"):
+            log(f"  Installed keep_alive service: {cron_id}")
+            continue
+
         timer_content = f"""[Unit]
 Description=NEXO timer: {cron.get('description', cron_id)}
 
@@ -576,23 +653,15 @@ Persistent=true
 [Install]
 WantedBy=timers.target
 """
-
-        if dry_run:
-            log(f"  DRY-RUN: would install {cron_id}")
-            continue
-
-        service_path.write_text(service_content)
         timer_path.write_text(timer_content)
         log(f"  Installed: {cron_id}")
 
     if not dry_run:
         subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
         for cron in manifest_crons:
-            subprocess.run(
-                ["systemctl", "--user", "enable", "--now", f"nexo-{cron['id']}.timer"],
-                capture_output=True
-            )
-        log("systemd timers enabled.")
+            unit = f"nexo-{cron['id']}.service" if cron.get("keep_alive") else f"nexo-{cron['id']}.timer"
+            subprocess.run(["systemctl", "--user", "enable", "--now", unit], capture_output=True)
+        log("systemd units enabled.")
 
     log("Sync complete.")
 

package/src/dashboard/app.py

@@ -96,6 +96,60 @@ def _adaptive():
     return adaptive_mode
 
 
+def _dashboard_runtime_flags() -> dict:
+    flags = {
+        "desktop_managed": False,
+        "disabled_features": [],
+        "evolution_available": True,
+    }
+    try:
+        from product_mode import desktop_product_requested, load_product_mode
+
+        mode = load_product_mode()
+        disabled = []
+        raw_disabled = mode.get("disabled_features") if isinstance(mode, dict) else []
+        if isinstance(raw_disabled, (list, tuple, set)):
+            disabled = [
+                str(item).strip().lower()
+                for item in raw_disabled
+                if str(item).strip()
+            ]
+        desktop_managed = bool(desktop_product_requested())
+        if desktop_managed and "evolution" not in disabled:
+            disabled.append("evolution")
+        flags["desktop_managed"] = desktop_managed
+        flags["disabled_features"] = disabled
+        flags["evolution_available"] = "evolution" not in disabled
+    except Exception:
+        pass
+    return flags
+
+
+def _feature_disabled_response(feature: str, *, api: bool = False):
+    feature_name = str(feature or "").strip().lower()
+    if api:
+        return JSONResponse(
+            {
+                "ok": False,
+                "feature": feature_name,
+                "disabled": True,
+                "reason": "Disabled by NEXO Desktop product contract",
+            },
+            status_code=403,
+        )
+    title = f"{feature_name.title()} disabled"
+    detail = (
+        f"{feature_name.title()} is disabled on Desktop-managed installs. "
+        "Use the standalone Brain product if you need that subsystem."
+    )
+    return _render(
+        "feature-disabled.html",
+        disabled_feature=feature_name,
+        disabled_title=title,
+        disabled_detail=detail,
+    )
+
+
 # ---------------------------------------------------------------------------
 # Pydantic models for request bodies
 # ---------------------------------------------------------------------------
@@ -431,6 +485,7 @@ def _render(name: str, **ctx) -> HTMLResponse:
     """Render a Jinja2 template with context."""
     try:
         tmpl = jinja_env.get_template(name)
+        ctx.setdefault("runtime_flags", _dashboard_runtime_flags())
         return HTMLResponse(tmpl.render(**ctx))
     except Exception as exc:
         import logging
@@ -507,6 +562,8 @@ async def page_plugins():
 # Advanced
 @app.get("/evolution", response_class=HTMLResponse)
 async def page_evolution():
+    if not _dashboard_runtime_flags().get("evolution_available", True):
+        return _feature_disabled_response("evolution")
     return _render("evolution.html")
 
 @app.get("/claims", response_class=HTMLResponse)
@@ -1646,6 +1703,8 @@ async def api_plugins():
 
 @app.get("/api/evolution")
 async def api_evolution():
+    if not _dashboard_runtime_flags().get("evolution_available", True):
+        return _feature_disabled_response("evolution", api=True)
     db = _db()
     conn = db.get_db()
     logs = [dict(r) for r in conn.execute("SELECT * FROM evolution_log ORDER BY created_at DESC LIMIT 50").fetchall()]

package/src/dashboard/templates/base.html

@@ -188,10 +188,12 @@
           Advanced
         </button>
         <div class="nav-group-items">
+          {% if runtime_flags.evolution_available %}
           <a href="/evolution" class="nav-item flex items-center gap-2.5 px-3 py-1.5 rounded-md text-xs text-slate-400 transition-colors" data-page="evolution">
             <svg class="w-4 h-4 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M13 7h8m0 0v8m0-8l-8 8-4-4-6 6"/></svg>
             Evolution
           </a>
+          {% endif %}
           <a href="/claims" class="nav-item flex items-center gap-2.5 px-3 py-1.5 rounded-md text-xs text-slate-400 transition-colors" data-page="claims">
             <svg class="w-4 h-4 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M13.828 10.172a4 4 0 00-5.656 0l-4 4a4 4 0 105.656 5.656l1.102-1.101m-.758-4.899a4 4 0 005.656 0l4-4a4 4 0 00-5.656-5.656l-1.1 1.1"/></svg>
             Claims Network

package/src/dashboard/templates/feature-disabled.html

@@ -0,0 +1,27 @@
+{% extends "base.html" %}
+
+{% block title %}{{ disabled_title or "Feature disabled" }}{% endblock %}
+
+{% block content %}
+<div class="max-w-3xl mx-auto space-y-6 animate-fade-in">
+  <section class="card border border-amber-500/20 bg-amber-500/5 rounded-2xl p-6">
+    <div class="flex items-start gap-4">
+      <div class="w-11 h-11 rounded-2xl bg-amber-500/15 text-amber-300 flex items-center justify-center text-xl">!</div>
+      <div class="space-y-2">
+        <p class="text-[11px] font-mono uppercase tracking-[0.28em] text-amber-300/80">
+          Product contract
+        </p>
+        <h1 class="text-2xl font-semibold text-slate-100">
+          {{ disabled_title or "Feature disabled" }}
+        </h1>
+        <p class="text-sm leading-6 text-slate-300">
+          {{ disabled_detail or "This feature is currently disabled on this installation." }}
+        </p>
+        <p class="text-xs text-slate-500">
+          Disabled feature: <code>{{ disabled_feature or "unknown" }}</code>
+        </p>
+      </div>
+    </div>
+  </section>
+</div>
+{% endblock %}

package/src/db/_email_accounts.py

@@ -13,15 +13,20 @@ import json
 import time
 from typing import Any
 
-from db._core import get_db
-
-
 DEFAULT_IMAP_PORT = 993
 DEFAULT_SMTP_PORT = 465
 VALID_ROLES = ("inbox", "outbox", "both")
 VALID_ACCOUNT_TYPES = ("agent", "operator")
 
 
+def _get_db():
+    # Resolve the DB connector lazily so test suites that reload db._core with a
+    # temporary NEXO_HOME do not keep talking to a stale shared connection.
+    from db._core import get_db
+
+    return get_db()
+
+
 def _row_to_dict(row) -> dict:
     if row is None:
         return {}
@@ -95,7 +100,7 @@ def add_email_account(
     resolved_is_default = bool(existing.get("is_default")) if is_default is None else bool(is_default)
     if clean_account_type != "operator":
         resolved_is_default = False
-    conn = get_db()
+    conn = _get_db()
     now = time.strftime("%Y-%m-%d %H:%M:%S")
     # Audit H2: when the caller does not pass `metadata` explicitly,
     # an upsert would otherwise wipe whatever the operator (or another
@@ -173,7 +178,7 @@ def list_email_accounts(
         raise ValueError(
             f"account_type must be one of {VALID_ACCOUNT_TYPES}, got {account_type!r}"
         )
-    conn = get_db()
+    conn = _get_db()
     clauses: list[str] = []
     params: list[Any] = []
     if not include_disabled:
@@ -192,7 +197,7 @@ def list_email_accounts(
 
 
 def get_email_account(label: str) -> dict | None:
-    conn = get_db()
+    conn = _get_db()
     row = conn.execute(
         "SELECT * FROM email_accounts WHERE label = ?",
         (label,),
@@ -200,9 +205,24 @@ def get_email_account(label: str) -> dict | None:
     return _row_to_dict(row) if row else None
 
 
+def get_email_account_by_id(account_id: int | str | None) -> dict | None:
+    try:
+        clean_id = int(account_id or 0)
+    except Exception:
+        return None
+    if clean_id <= 0:
+        return None
+    conn = _get_db()
+    row = conn.execute(
+        "SELECT * FROM email_accounts WHERE id = ?",
+        (clean_id,),
+    ).fetchone()
+    return _row_to_dict(row) if row else None
+
+
 def get_primary_email_account() -> dict | None:
     """Most-recently-updated enabled agent account. Returns None if table empty."""
-    conn = get_db()
+    conn = _get_db()
     row = conn.execute(
         "SELECT * FROM email_accounts WHERE enabled = 1 "
         "AND COALESCE(account_type, 'agent') = 'agent' "
@@ -213,7 +233,7 @@ def get_primary_email_account() -> dict | None:
 
 def get_default_operator_email_account() -> dict | None:
     """Return the explicit default operator mailbox, if any."""
-    conn = get_db()
+    conn = _get_db()
     row = conn.execute(
         "SELECT * FROM email_accounts "
         "WHERE enabled = 1 AND COALESCE(account_type, 'agent') = 'operator' "
@@ -223,20 +243,48 @@ def get_default_operator_email_account() -> dict | None:
     return _row_to_dict(row) if row else None
 
 
-def set_email_account_enabled(label: str, enabled: bool) -> bool:
-    conn = get_db()
-    cur = conn.execute(
-        "UPDATE email_accounts SET enabled = ?, updated_at = datetime('now') "
-        "WHERE label = ?",
-        (1 if enabled else 0, label),
-    )
+def set_email_account_enabled(
+    label: str | None = None,
+    enabled: bool = True,
+    account_id: int | str | None = None,
+) -> bool:
+    conn = _get_db()
+    if account_id is not None:
+        try:
+            clean_id = int(account_id)
+        except Exception:
+            clean_id = 0
+        if clean_id > 0:
+            cur = conn.execute(
+                "UPDATE email_accounts SET enabled = ?, updated_at = datetime('now') "
+                "WHERE id = ?",
+                (1 if enabled else 0, clean_id),
+            )
+        else:
+            cur = conn.execute("SELECT 0 WHERE 1=0")
+    else:
+        cur = conn.execute(
+            "UPDATE email_accounts SET enabled = ?, updated_at = datetime('now') "
+            "WHERE label = ?",
+            (1 if enabled else 0, label),
+        )
     conn.commit()
     return cur.rowcount > 0
 
 
-def remove_email_account(label: str) -> bool:
-    conn = get_db()
-    cur = conn.execute("DELETE FROM email_accounts WHERE label = ?", (label,))
+def remove_email_account(label: str | None = None, account_id: int | str | None = None) -> bool:
+    conn = _get_db()
+    if account_id is not None:
+        try:
+            clean_id = int(account_id)
+        except Exception:
+            clean_id = 0
+        if clean_id > 0:
+            cur = conn.execute("DELETE FROM email_accounts WHERE id = ?", (clean_id,))
+        else:
+            cur = conn.execute("SELECT 0 WHERE 1=0")
+    else:
+        cur = conn.execute("DELETE FROM email_accounts WHERE label = ?", (label,))
     conn.commit()
     return cur.rowcount > 0
 
@@ -245,6 +293,7 @@ __all__ = [
     "add_email_account",
     "list_email_accounts",
     "get_email_account",
+    "get_email_account_by_id",
     "get_primary_email_account",
     "get_default_operator_email_account",
     "set_email_account_enabled",

package/src/db/_fts.py

@@ -1,5 +1,6 @@
 """NEXO DB — Fts module."""
 import os, pathlib, sqlite3, threading, datetime
+import paths
 from db._core import get_db, now_epoch, DB_PATH
 
 NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
@@ -10,12 +11,12 @@ NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
 _FTS_MD_DIRS = [
     os.path.join(NEXO_HOME, "docs"),
     os.path.join(NEXO_HOME, "projects"),
-    os.path.join(NEXO_HOME, "memory"),
-    os.path.join(NEXO_HOME, "operations"),
+    str(paths.memory_dir()),
+    str(paths.operations_dir()),
     os.path.join(NEXO_HOME, "learnings"),
-    os.path.join(NEXO_HOME, "brain"),
+    str(paths.brain_dir()),
     os.path.join(NEXO_HOME, "agents"),
-    os.path.join(NEXO_HOME, "skills"),
+    str(paths.personal_skills_dir()),
 ]
 # Code repos: index source files (skip vendor, node_modules, etc.)
 _FTS_CODE_DIRS = []  # Users can add project dirs via nexo_index_add_dir
@@ -403,4 +404,3 @@ def _migrate_add_index(conn, index_name: str, table: str, column: str):
     conn.execute(f"CREATE INDEX IF NOT EXISTS {index_name} ON {table}({column})")
     conn.commit()
 
-

package/src/db/_personal_scripts.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 """NEXO DB — Personal scripts registry.
 
-Filesystem remains the source of truth for personal scripts in NEXO_HOME/scripts/.
+Filesystem remains the source of truth for personal scripts in NEXO_HOME/personal/scripts/.
 SQLite stores operational metadata so NEXO can reason about what scripts exist,
 what they do, and which schedules/plists are attached to them.
 """

package/src/db/_skills.py

@@ -34,8 +34,8 @@ def _resolve_core_skills_dir() -> Path:
 
     In development NEXO_CODE points at repo/src, so core skills live in src/skills.
     In packaged installs the runtime wrapper points NEXO_CODE at NEXO_HOME, so core
-    skills must live in a dedicated skills-core/ directory to avoid colliding with
-    personal skills in NEXO_HOME/skills.
+    skills must live in a dedicated core/skills directory to avoid colliding with
+    personal skills in NEXO_HOME/personal/skills.
     """
     try:
         if NEXO_CODE.resolve() == NEXO_HOME.resolve():
@@ -1472,7 +1472,7 @@ def collect_skill_improvement_candidates() -> list[dict]:
 
 
 def materialize_personal_skill_definition(skill_data: dict) -> dict:
-    """Write a personal skill definition to NEXO_HOME/skills and sync it into DB."""
+    """Write a personal skill definition to NEXO_HOME/personal/skills and sync it into DB."""
     _ensure_skill_dirs()
     skill_id = str(skill_data.get("id", "")).strip()
     name = str(skill_data.get("name", "")).strip()