nexo-brain 5.6.1 → 5.8.0

package/.claude-plugin/plugin.json

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

package/README.md

@@ -18,9 +18,11 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `5.6.1` is the current packaged-runtime line: two small-but-sharp fixes in the `nexo update` path. 0-byte `.db` orphans from interrupted installs are now purged from `~/.nexo/` and `~/.nexo/data/` before the pre-update backup runs, so backup validation no longer trips over empty shells. And when `heal_runtime_profiles()` migrates the `claude_code` default (e.g. Opus 4.6 → 4.7), the new `sync_claude_code_model()` helper also updates the `model` field in `~/.claude/settings.json` — the file Claude Code actually reads — so the boot model matches NEXO's recommendation on the next launch.
+Version `5.8.0` is the current packaged-runtime line: first-class `internal` and `owner` columns on `followups` and `reminders`. Migration #40 adds both fields with an idempotent one-shot backfill, so the "who does this task belong to?" classification moves from client-side regex (Desktop) to persistent storage every MCP client shares. Taxonomy is intentionally generic — `owner in {user, waiting, agent, shared}` — so third-party agents plugging into the shared Brain can render whatever assistant label they carry without inheriting NEXO branding. `nexo_reminder_create`, `nexo_reminder_update`, `nexo_followup_create`, and `nexo_followup_update` gain optional `internal` and `owner` parameters that win over the default heuristic.
 
-Previously in `5.6.0`: default model upgrade from Opus 4.6 to **Opus 4.7** with `reasoning_effort: "max"` (the new highest tier). Auto-migration on `nexo update` silently upgrades existing users from `claude-opus-4-6*` to `claude-opus-4-7` preserving the 1M context suffix. Codex profiles are untouched.
+Previously in `5.7.0`: `nexo update` now keeps Claude Code and Codex CLIs in lockstep with NEXO Brain itself. When the global `@anthropic-ai/claude-code` or `@openai/codex` packages are installed, the updater checks the npm registry and runs `npm install -g <pkg>@latest` in-line — so the terminal boot model stays aligned with the settings NEXO already wrote to `~/.claude/settings.json`. Packages the operator never installed are skipped silently. Pass `nexo update --no-clis` to keep the terminal CLIs pinned.
+
+Previously in `5.6.1`: update-path hardening — 0-byte `.db` orphans from interrupted installs are now purged from `~/.nexo/` and `~/.nexo/data/` before the pre-update backup, and `sync_claude_code_model()` propagates the NEXO-recommended model into `~/.claude/settings.json` whenever `heal_runtime_profiles()` migrates the `claude_code` default.
 
 Previously in `5.5.5`: data-loss guardrails + automatic self-heal. The updater now refuses to capture an already-wiped `nexo.db` into a `pre-update-*` snapshot (validated `sqlite3.backup` + pre-flight wipe guard + post-migration row-count gate), and an auto-heal restores `data/nexo.db` from the newest hourly backup on the next server boot when a wipe is detected. New `nexo recover` CLI + `nexo_recover` MCP tool.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.6.1",
+  "version": "5.8.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain \u2014 Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/auto_update.py

@@ -1168,6 +1168,202 @@ def _check_npm_version() -> str | None:
     return None
 
 
+# ── External CLI auto-update (Claude Code, Codex) ────────────────────
+# Keep this list aligned with the third-party CLIs that NEXO drives end-to-end.
+# Adding a new CLI here makes `nexo update` auto-install/bump it unless the
+# caller passes include_clis=False. Learning #323: use canonical npm names.
+_EXTERNAL_CLIS: tuple[str, ...] = (
+    "@anthropic-ai/claude-code",
+    "@openai/codex",
+)
+
+
+def _update_external_clis(progress_fn=None) -> dict:
+    """Detect and update NEXO's external terminal CLIs.
+
+    For each package in :data:`_EXTERNAL_CLIS`:
+      1. Read the installed global version via ``npm list -g --json --depth=0``.
+      2. Fetch the latest version from the npm registry via ``npm view <pkg> version``.
+      3. When newer, run ``npm install -g <pkg>@latest``.
+
+    Silently skips packages that are not installed globally — NEXO does not
+    push unsolicited installs of third-party CLIs onto operators.
+
+    Returns a dict keyed by package name. Each entry shape::
+
+        {
+            "old": "2.1.109" | None,
+            "new": "2.1.115" | None,
+            "updated": True | False,
+            "status": "updated" | "already_latest" | "not_installed"
+                      | "skipped" | "failed",
+            "error": "<message>"           # only when status == "failed"/"skipped"
+        }
+    """
+    # Reuse the npm helpers already hardened in plugins/update.py (version
+    # parsing, TimeoutExpired handling, invalid-name validation). Falling back
+    # to "skipped" keeps a partially-copied runtime from crashing the update.
+    try:
+        from plugins.update import (
+            _get_npm_global_version,
+            _get_npm_registry_version,
+            _validate_npm_name,
+        )
+    except Exception as e:  # pragma: no cover — only mid-upgrade installs hit this
+        return {
+            cli: {
+                "old": None,
+                "new": None,
+                "updated": False,
+                "status": "skipped",
+                "error": f"plugins.update helpers unavailable: {e}",
+            }
+            for cli in _EXTERNAL_CLIS
+        }
+
+    results: dict[str, dict] = {}
+
+    for pkg in _EXTERNAL_CLIS:
+        entry: dict = {"old": None, "new": None, "updated": False, "status": "unknown"}
+
+        if not _validate_npm_name(pkg):
+            entry.update({"status": "failed", "error": f"invalid npm name: {pkg!r}"})
+            results[pkg] = entry
+            continue
+
+        old_version = _get_npm_global_version(pkg)
+        if old_version is None:
+            # Not installed globally — don't auto-install third-party CLIs the
+            # operator didn't opt into. Silent skip in the final summary.
+            entry["status"] = "not_installed"
+            results[pkg] = entry
+            continue
+
+        entry["old"] = old_version
+
+        latest = _get_npm_registry_version(pkg)
+        if latest is None:
+            entry.update({
+                "new": old_version,
+                "status": "failed",
+                "error": "npm registry lookup failed",
+            })
+            results[pkg] = entry
+            continue
+
+        if old_version == latest:
+            entry.update({"new": old_version, "status": "already_latest"})
+            results[pkg] = entry
+            continue
+
+        if progress_fn is not None:
+            try:
+                progress_fn(f"Updating {pkg}: {old_version} -> {latest}...")
+            except Exception:
+                pass
+
+        try:
+            r = subprocess.run(
+                ["npm", "install", "-g", f"{pkg}@latest"],
+                capture_output=True,
+                text=True,
+                timeout=180,
+            )
+        except subprocess.TimeoutExpired:
+            # Learning #294: always capture TimeoutExpired explicitly.
+            entry.update({
+                "new": old_version,
+                "status": "failed",
+                "error": "npm install timed out after 180s",
+            })
+            results[pkg] = entry
+            continue
+        except FileNotFoundError:
+            # npm itself missing — no Node.js on PATH. Mark the rest as skipped
+            # and bail: no point retrying subsequent packages.
+            entry.update({
+                "new": old_version,
+                "status": "skipped",
+                "error": "npm not found on PATH",
+            })
+            results[pkg] = entry
+            for remaining in _EXTERNAL_CLIS:
+                results.setdefault(remaining, {
+                    "old": None,
+                    "new": None,
+                    "updated": False,
+                    "status": "skipped",
+                    "error": "npm not found on PATH",
+                })
+            return results
+        except Exception as e:  # pragma: no cover — defensive
+            entry.update({
+                "new": old_version,
+                "status": "failed",
+                "error": str(e)[:500],
+            })
+            results[pkg] = entry
+            continue
+
+        if r.returncode != 0:
+            entry.update({
+                "new": old_version,
+                "status": "failed",
+                "error": (r.stderr or r.stdout or "npm install failed").strip()[:500],
+            })
+            results[pkg] = entry
+            continue
+
+        new_version = _get_npm_global_version(pkg) or latest
+        entry.update({
+            "new": new_version,
+            "updated": new_version != old_version,
+            "status": "updated" if new_version != old_version else "already_latest",
+        })
+        results[pkg] = entry
+
+    return results
+
+
+def _format_external_clis_results(results: dict) -> list[str]:
+    """Render CLI update results as lines for the ``nexo update`` summary.
+
+    Emits a visible warning per bumped CLI (operator must restart the terminal
+    for the new version to take effect), a warning per failure, and a single
+    informational line when nothing changed but something was checked.
+    """
+    if not results:
+        return []
+
+    lines: list[str] = []
+    any_updated = False
+    any_failed = False
+    any_checked_latest = False
+
+    for pkg, entry in results.items():
+        status = entry.get("status")
+        if status == "updated":
+            any_updated = True
+            lines.append(
+                f"  CLI updated: {pkg} {entry.get('old')} -> {entry.get('new')} "
+                f"— reinicia terminal para activar"
+            )
+        elif status == "already_latest":
+            any_checked_latest = True
+        elif status == "failed":
+            any_failed = True
+            lines.append(
+                f"  WARNING: CLI {pkg} update failed: {entry.get('error', 'unknown')}"
+            )
+        # "not_installed" and "skipped" are intentionally silent — third-party
+        # CLIs that the operator never installed shouldn't spam the summary.
+
+    if not any_updated and not any_failed and any_checked_latest:
+        lines.append("  CLIs externos: ya en última versión")
+
+    return lines
+
+
 # ── File-based migrations (migrations/ directory) ────────────────────
 
 def _get_applied_migration_version() -> int:
@@ -2449,7 +2645,13 @@ def _personal_schedule_reconcile_summary(reconcile_result: dict) -> tuple[list[s
     return actions, "Personal schedules: " + ", ".join(parts) + "."
 
 
-def manual_sync_update(*, interactive: bool = False, allow_source_pull: bool = True, progress_fn=None) -> dict:
+def manual_sync_update(
+    *,
+    interactive: bool = False,
+    allow_source_pull: bool = True,
+    progress_fn=None,
+    include_clis: bool = True,
+) -> dict:
     src_dir, repo_dir = _resolve_sync_source()
     if src_dir is None or repo_dir is None:
         return {"ok": False, "mode": "sync", "error": "No source repo recorded for this runtime."}
@@ -2513,6 +2715,18 @@ def manual_sync_update(*, interactive: bool = False, allow_source_pull: bool = T
         except Exception:
             pass  # Non-critical
 
+        # Auto-update external terminal CLIs (Claude Code, Codex). Best-effort:
+        # a failed third-party install never aborts the NEXO sync itself.
+        if include_clis:
+            try:
+                _emit_progress(progress_fn, "Checking external CLI updates...")
+                cli_results = _update_external_clis(progress_fn=progress_fn)
+                sync_result["external_clis"] = cli_results
+            except Exception as e:
+                sync_result.setdefault("warnings", []).append(
+                    f"external CLI update skipped: {e}"
+                )
+
         _emit_progress(progress_fn, "Runtime update completed.")
     except Exception as e:
         _emit_progress(progress_fn, "Update failed; restoring previous runtime state...")

package/src/cli.py

@@ -823,6 +823,7 @@ def _update(args):
 
     dest = NEXO_HOME
     src_dir, repo_dir = _resolve_sync_source()
+    include_clis = not getattr(args, "no_clis", False)
 
     if src_dir is None or repo_dir is None:
         try:
@@ -835,7 +836,7 @@ def _update(args):
             )
             return 1
 
-        result = handle_update(progress_fn=progress)
+        result = handle_update(progress_fn=progress, include_clis=include_clis)
         runtime_power = _load_runtime_power_support()
         public_contribution = _load_public_contribution_support()
         choice = runtime_power["ensure_power_policy_choice"](interactive=interactive, reason="update")
@@ -873,7 +874,12 @@ def _update(args):
                 print(f"Contributor mode: {contrib_choice.get('message')}")
         return 0 if "UPDATE SUCCESSFUL" in result or "Already up to date" in result else 1
 
-    result = manual_sync_update(interactive=interactive, allow_source_pull=True, progress_fn=progress)
+    result = manual_sync_update(
+        interactive=interactive,
+        allow_source_pull=True,
+        progress_fn=progress,
+        include_clis=include_clis,
+    )
     runtime_power = _load_runtime_power_support()
     public_contribution = _load_public_contribution_support()
     choice = runtime_power["ensure_power_policy_choice"](interactive=interactive, reason="update")
@@ -2015,6 +2021,12 @@ def main():
     # -- update --
     update_parser = sub.add_parser("update", help="Update installed runtime")
     update_parser.add_argument("--json", action="store_true", help="JSON output")
+    update_parser.add_argument(
+        "--no-clis",
+        dest="no_clis",
+        action="store_true",
+        help="Skip auto-updating external terminal CLIs (Claude Code, Codex)",
+    )
 
     # -- recover --
     recover_parser = sub.add_parser(

package/src/db/_classification.py

@@ -0,0 +1,154 @@
+"""NEXO DB — Task classification helpers (internal + owner).
+
+Introduced in migration #40. Every followup and reminder carries two
+classification attributes so clients (Desktop Home, dashboard, future
+agents) do not need to compute them with client-side regex:
+
+    internal (INTEGER 0/1):
+        1 if the task is bookkeeping the agent keeps for itself
+        (protocol enforcer, deep-sleep housekeeping, audit trail,
+        release gates, retroactive learnings). These are hidden from
+        normal user views by default.
+
+    owner (TEXT):
+        'user'    — the user has to act (was 'Para ti' in Desktop).
+        'waiting' — blocked on an external response (was 'Esperando').
+        'agent'   — the AI agent handles it autonomously. Intentionally
+                    named 'agent' and NOT 'nexo' so non-NEXO deployments
+                    render whatever label fits (e.g. 'Claude', 'Codex',
+                    hotel-assistant name). The user-facing label is
+                    resolved client-side.
+        'shared'  — collaborative follow-up (was 'Seguimiento').
+        NULL      — unclassified; clients fall back to the legacy
+                    client-side heuristic for backward compat.
+
+Agents creating tasks via nexo_followup_create / nexo_reminder_create
+can override both fields explicitly. If they leave them blank, the
+Brain applies the heuristic below so a vanilla agent keeps sensible
+behaviour out of the box.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Task-ID prefixes historically owned by NEXO's own automation. They are
+# kept as a default heuristic because they match the existing corpus of
+# 468+ followups and 40+ reminders. Any agent not following this naming
+# convention will simply not match these patterns and its tasks will
+# stay visible (internal=0) unless the agent sets internal=1 explicitly
+# on create — which is exactly what we want for a pluralistic ecosystem.
+_INTERNAL_ID_PATTERNS = [
+    re.compile(r"^NF-PROTOCOL[-_]", re.IGNORECASE),
+    re.compile(r"^NF-DS[-_]", re.IGNORECASE),
+    re.compile(r"^NF-AUDIT[-_]", re.IGNORECASE),
+    re.compile(r"^NF-OPPORTUNITY[-_]", re.IGNORECASE),
+    re.compile(r"^NF-RETRO[-_]", re.IGNORECASE),
+    re.compile(r"^R-RELEASE[-_]", re.IGNORECASE),
+    re.compile(r"^R-FU-NF-PROTOCOL[-_]", re.IGNORECASE),
+    re.compile(r"^R-FU-NF-DS[-_]", re.IGNORECASE),
+    re.compile(r"^R-FU-NF-AUDIT[-_]", re.IGNORECASE),
+]
+
+# Spanish user-action verbs. The heuristic is Spanish-first because the
+# existing corpus is Spanish, but since every agent can override `owner`
+# explicitly on create, deployments in other languages are not blocked.
+_USER_VERB_RX = re.compile(
+    r"\b(francisco debe|debes|llamar|responder|revisar|validar|confirmar|"
+    r"decidir|aprobar|firmar|enviar email|mandar email|contestar|"
+    r"reuni[óo]n|reservar|comprar)\b",
+    re.IGNORECASE,
+)
+
+_WAITING_RX = re.compile(
+    r"\b(esperando|esperar|bloqueo|bloqueado|pendiente respuesta|"
+    r"pendiente de|en espera)\b",
+    re.IGNORECASE,
+)
+
+_AGENT_RX = re.compile(
+    r"\b(monitoreo|monitorizar|monitor|auditor[íi]a diaria|"
+    r"promoci[óo]n diaria|seguir|seguimiento 24|72h|checkpoint|runner|cron)\b",
+    re.IGNORECASE,
+)
+
+VALID_OWNERS = {"user", "waiting", "agent", "shared"}
+
+
+def is_internal_id(task_id: str | None) -> bool:
+    """Return True when the ID matches a known agent-internal prefix."""
+    tid = (task_id or "").strip()
+    if not tid:
+        return False
+    return any(pat.search(tid) for pat in _INTERNAL_ID_PATTERNS)
+
+
+def classify_owner(
+    task_id: str | None,
+    description: str | None,
+    category: str | None = None,
+    recurrence: str | None = None,
+) -> str:
+    """Classify ownership into one of VALID_OWNERS using the legacy rules."""
+    tid = (task_id or "").strip()
+    desc = (description or "").strip()
+    cat = (category or "").strip().lower()
+    rec = (recurrence or "").strip()
+
+    if cat == "waiting" or _WAITING_RX.search(desc):
+        return "waiting"
+    if _USER_VERB_RX.search(desc) or tid.lower().startswith("nf-protocol-"):
+        return "user"
+    if rec or _AGENT_RX.search(desc):
+        return "agent"
+    return "shared"
+
+
+def classify_task(
+    task_id: str | None,
+    description: str | None,
+    category: str | None = None,
+    recurrence: str | None = None,
+) -> tuple[int, str]:
+    """Compute (internal, owner) pair for a task.
+
+    Returns integers for internal so the SQLite column (INTEGER DEFAULT 0)
+    and the JSON round-trip stay consistent. Clients can truthy-check either
+    int or bool safely.
+    """
+    internal = 1 if is_internal_id(task_id) else 0
+    owner = classify_owner(task_id, description, category, recurrence)
+    return internal, owner
+
+
+def normalise_owner(value: str | None) -> str | None:
+    """Accept owner overrides from agents and clamp to VALID_OWNERS.
+
+    Returns None for empty input (so the DB keeps NULL / pre-existing value)
+    and coerces invalid strings to None rather than silently persisting
+    garbage. Callers decide whether to fall back to classify_owner().
+    """
+    if value is None:
+        return None
+    normalised = str(value).strip().lower()
+    if not normalised:
+        return None
+    return normalised if normalised in VALID_OWNERS else None
+
+
+def normalise_internal(value) -> int | None:
+    """Coerce agent-supplied internal flag into {0, 1} or None."""
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return 1 if value else 0
+    if isinstance(value, (int, float)):
+        return 1 if int(value) != 0 else 0
+    text = str(value).strip().lower()
+    if not text:
+        return None
+    if text in {"1", "true", "yes", "y", "on", "internal"}:
+        return 1
+    if text in {"0", "false", "no", "n", "off", "external", "public"}:
+        return 0
+    return None

package/src/db/_reminders.py

@@ -8,6 +8,7 @@ import sqlite3
 from typing import Any
 
 from db._core import get_db, now_epoch
+from db._classification import classify_task, normalise_internal, normalise_owner
 from db._fts import fts_upsert
 from db._hot_context import capture_context_event
 
@@ -249,15 +250,47 @@ def create_reminder(
     date: str = None,
     status: str = "PENDING",
     category: str = "general",
+    internal: object = None,
+    owner: str | None = None,
 ) -> dict:
-    """Create a new reminder."""
+    """Create a new reminder.
+
+    Agents may pass `internal` (0/1, bool, or string) and `owner`
+    ('user'|'waiting'|'agent'|'shared') to override the default
+    classification. When omitted, classify_task() applies the legacy
+    heuristic so behaviour matches pre-migration #40.
+    """
     conn = get_db()
     now = now_epoch()
+
+    auto_internal, auto_owner = classify_task(id, description, category, None)
+    internal_value = normalise_internal(internal)
+    if internal_value is None:
+        internal_value = auto_internal
+    owner_value = normalise_owner(owner) or auto_owner
+
+    columns = {str(row["name"]) for row in conn.execute("PRAGMA table_info(reminders)").fetchall()}
+    payload: dict[str, object] = {
+        "id": id,
+        "date": date,
+        "description": description,
+        "status": status,
+        "category": category,
+        "created_at": now,
+        "updated_at": now,
+    }
+    if "internal" in columns:
+        payload["internal"] = internal_value
+    if "owner" in columns:
+        payload["owner"] = owner_value
+
+    insert_columns = [c for c in payload if c in columns]
+    placeholders = ", ".join("?" for _ in insert_columns)
+
     try:
         conn.execute(
-            "INSERT INTO reminders (id, date, description, status, category, created_at, updated_at) "
-            "VALUES (?, ?, ?, ?, ?, ?, ?)",
-            (id, date, description, status, category, now, now),
+            f"INSERT INTO reminders ({', '.join(insert_columns)}) VALUES ({placeholders})",
+            [payload[c] for c in insert_columns],
         )
         conn.commit()
     except sqlite3.IntegrityError:
@@ -268,7 +301,7 @@ def create_reminder(
         "reminder",
         id,
         "created",
-        note=f"Reminder created. Category={category}. Date={date or '—'}.",
+        note=f"Reminder created. Category={category}. Date={date or '—'}. Owner={owner_value}.",
         actor="db",
     )
     capture_context_event(
@@ -285,7 +318,13 @@ def create_reminder(
         actor="db",
         source_type="reminder",
         source_id=id,
-        metadata={"category": category, "status": status, "date": date or ""},
+        metadata={
+            "category": category,
+            "status": status,
+            "date": date or "",
+            "internal": internal_value,
+            "owner": owner_value,
+        },
         ttl_hours=24,
     )
     return dict(row)
@@ -306,11 +345,28 @@ def update_reminder(
     if not row:
         return {"error": f"Reminder {id} not found"}
 
-    allowed = {"description", "date", "status", "category"}
+    allowed = {"description", "date", "status", "category", "internal", "owner"}
     updates = {k: v for k, v in kwargs.items() if k in allowed}
+    if "internal" in updates:
+        coerced = normalise_internal(updates["internal"])
+        if coerced is None:
+            updates.pop("internal")
+        else:
+            updates["internal"] = coerced
+    if "owner" in updates:
+        coerced = normalise_owner(updates["owner"])
+        if coerced is None:
+            updates.pop("owner")
+        else:
+            updates["owner"] = coerced
     if not updates:
         return {"error": "No valid fields to update"}
 
+    table_columns = {
+        str(r["name"]) for r in conn.execute("PRAGMA table_info(reminders)").fetchall()
+    }
+    updates = {k: v for k, v in updates.items() if k in table_columns or k == "updated_at"}
+
     updates["updated_at"] = now_epoch()
     set_clause = ", ".join(f"{k} = ?" for k in updates)
     values = list(updates.values()) + [id]
@@ -554,8 +610,15 @@ def create_followup(
     reasoning: str = "",
     recurrence: str = None,
     priority: str = "medium",
+    internal: object = None,
+    owner: str | None = None,
 ) -> dict:
-    """Create a new followup with optional reasoning and recurrence."""
+    """Create a new followup with optional reasoning and recurrence.
+
+    Agents may override the default classification via `internal` and
+    `owner`. Omitted values are filled by classify_task() using the
+    legacy heuristics so pre-migration callers keep working identically.
+    """
     conn = get_db()
     now = now_epoch()
     similar = find_similar_followups(description)
@@ -567,6 +630,12 @@ def create_followup(
             f"(scores: {', '.join(str(s['_similarity']) for s in similar[:3])}). Consider updating instead."
         )
 
+    auto_internal, auto_owner = classify_task(id, description, None, recurrence)
+    internal_value = normalise_internal(internal)
+    if internal_value is None:
+        internal_value = auto_internal
+    owner_value = normalise_owner(owner) or auto_owner
+
     columns = {str(row["name"]) for row in conn.execute("PRAGMA table_info(followups)").fetchall()}
     payload: dict[str, object] = {
         "id": id,
@@ -581,6 +650,10 @@ def create_followup(
     }
     if "priority" in columns:
         payload["priority"] = priority or "medium"
+    if "internal" in columns:
+        payload["internal"] = internal_value
+    if "owner" in columns:
+        payload["owner"] = owner_value
 
     insert_columns = [column for column in payload if column in columns]
     placeholders = ", ".join("?" for _ in insert_columns)
@@ -642,11 +715,31 @@ def update_followup(
     if not row:
         return {"error": f"Followup {id} not found"}
 
-    allowed = {"description", "date", "verification", "status", "reasoning", "recurrence", "priority"}
+    allowed = {
+        "description", "date", "verification", "status",
+        "reasoning", "recurrence", "priority", "internal", "owner",
+    }
     updates = {k: v for k, v in kwargs.items() if k in allowed}
+    if "internal" in updates:
+        coerced = normalise_internal(updates["internal"])
+        if coerced is None:
+            updates.pop("internal")
+        else:
+            updates["internal"] = coerced
+    if "owner" in updates:
+        coerced = normalise_owner(updates["owner"])
+        if coerced is None:
+            updates.pop("owner")
+        else:
+            updates["owner"] = coerced
     if not updates:
         return {"error": "No valid fields to update"}
 
+    table_columns = {
+        str(r["name"]) for r in conn.execute("PRAGMA table_info(followups)").fetchall()
+    }
+    updates = {k: v for k, v in updates.items() if k in table_columns or k == "updated_at"}
+
     updates["updated_at"] = now_epoch()
     set_clause = ", ".join(f"{k} = ?" for k in updates)
     values = list(updates.values()) + [id]

package/src/db/_schema.py

@@ -936,6 +936,69 @@ def _m39_hook_runs(conn):
     conn.execute("CREATE INDEX IF NOT EXISTS idx_hook_runs_status ON hook_runs(status)")
 
 
+def _m40_classification_columns(conn):
+    """Add internal (INTEGER 0/1) and owner (TEXT) to followups and reminders.
+
+    Background: before this migration, Desktop clients had to compute the
+    "who does this belong to" classification client-side using Spanish regex
+    on description and ID-prefix pattern matching (NF-PROTOCOL-*, NF-DS-*, …).
+    That logic was hardcoded to NEXO's own ID convention and Spanish-speaking
+    users. Any third-party agent plugging into the shared Brain would either
+    see every task as "Seguimiento" (owner=shared fallback) or, worse, have
+    its real user-facing tasks hidden by the Desktop 'internal' filter.
+
+    Fix: make both attributes first-class columns agents can set on create.
+    Vanilla agents that omit them get the legacy heuristic (classify_task)
+    applied on insert and during this one-shot backfill, so existing rows
+    preserve their current Desktop rendering.
+
+    Values:
+        internal: 0 (external, visible) or 1 (agent bookkeeping, hidden).
+        owner: 'user' | 'waiting' | 'agent' | 'shared' | NULL.
+            'agent' is deliberately generic — Desktop renders the
+            label using the configured assistant name, not a hardcoded
+            'NEXO'.
+
+    Idempotent: _migrate_add_column is a no-op when the column exists,
+    _migrate_add_index likewise. The backfill only touches rows where
+    owner IS NULL, so re-running never overwrites agent-set values.
+    """
+    _migrate_add_column(conn, "followups", "internal", "INTEGER DEFAULT 0")
+    _migrate_add_column(conn, "followups", "owner", "TEXT DEFAULT NULL")
+    _migrate_add_column(conn, "reminders", "internal", "INTEGER DEFAULT 0")
+    _migrate_add_column(conn, "reminders", "owner", "TEXT DEFAULT NULL")
+    _migrate_add_index(conn, "idx_followups_internal", "followups", "internal")
+    _migrate_add_index(conn, "idx_followups_owner", "followups", "owner")
+    _migrate_add_index(conn, "idx_reminders_internal", "reminders", "internal")
+    _migrate_add_index(conn, "idx_reminders_owner", "reminders", "owner")
+
+    from db._classification import classify_task
+
+    rows = conn.execute(
+        "SELECT id, description, recurrence FROM followups WHERE owner IS NULL"
+    ).fetchall()
+    for row in rows:
+        internal, owner = classify_task(
+            row["id"], row["description"], None, row["recurrence"]
+        )
+        conn.execute(
+            "UPDATE followups SET internal = ?, owner = ? WHERE id = ?",
+            (internal, owner, row["id"]),
+        )
+
+    rows = conn.execute(
+        "SELECT id, description, category FROM reminders WHERE owner IS NULL"
+    ).fetchall()
+    for row in rows:
+        internal, owner = classify_task(
+            row["id"], row["description"], row["category"], None
+        )
+        conn.execute(
+            "UPDATE reminders SET internal = ?, owner = ? WHERE id = ?",
+            (internal, owner, row["id"]),
+        )
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -976,6 +1039,7 @@ MIGRATIONS = [
     (37, "cortex_goal_profile_trace", _m37_cortex_goal_profile_trace),
     (38, "evolution_log_proposal_payload", _m38_evolution_log_proposal_payload),
     (39, "hook_runs", _m39_hook_runs),
+    (40, "classification_columns", _m40_classification_columns),
 ]
 
 

package/src/plugins/update.py

@@ -961,7 +961,7 @@ def _reload_launch_agents_after_bump() -> dict:
     return result
 
 
-def _handle_packaged_update(progress_fn=None) -> str:
+def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> str:
     """Update a packaged (npm) install — no git repo available."""
     old_version = _read_version()
 
@@ -1078,6 +1078,19 @@ def _handle_packaged_update(progress_fn=None) -> str:
     except Exception:
         pass  # Non-critical
 
+    # Auto-update external terminal CLIs (Claude Code, Codex). Best-effort;
+    # a third-party install failure here never rolls the update back.
+    external_cli_lines: list[str] = []
+    if include_clis:
+        try:
+            from auto_update import _update_external_clis, _format_external_clis_results
+            _emit_progress(progress_fn, "Checking external CLI updates...")
+            external_cli_lines = _format_external_clis_results(
+                _update_external_clis(progress_fn=progress_fn)
+            )
+        except Exception:
+            pass  # Non-critical
+
     client_sync_warning = None
     _emit_progress(progress_fn, "Refreshing shared client configs...")
     clients_ok, client_sync_error = _sync_packaged_clients()
@@ -1144,6 +1157,7 @@ def _handle_packaged_update(progress_fn=None) -> str:
     if retired_runtime_files:
         lines.append(f"  Cleanup: removed {len(retired_runtime_files)} retired runtime file(s)")
     lines.extend(_format_dep_results(dep_results))
+    lines.extend(external_cli_lines)
     if not client_sync_warning:
         lines.append("  Clients: configured client targets synced")
     else:
@@ -1162,7 +1176,13 @@ def _handle_packaged_update(progress_fn=None) -> str:
     return "\n".join(lines)
 
 
-def handle_update(remote: str = "origin", branch: str = "main", progress_fn=None) -> str:
+def handle_update(
+    remote: str = "origin",
+    branch: str = "main",
+    progress_fn=None,
+    *,
+    include_clis: bool = True,
+) -> str:
     """Pull latest NEXO code, backup databases, run migrations, and verify.
 
     Supports both git checkouts and packaged (npm) installs.
@@ -1179,10 +1199,13 @@ def handle_update(remote: str = "origin", branch: str = "main", progress_fn=None
     Args:
         remote: Git remote name (default: origin)
         branch: Git branch to pull (default: main)
+        include_clis: When True (default), auto-update external terminal CLIs
+            (Claude Code, Codex). Pass False (``nexo update --no-clis``) to
+            keep the third-party CLIs at their current version.
     """
     # Packaged install — no git repo
     if not _is_git_repo():
-        return _handle_packaged_update(progress_fn=progress_fn)
+        return _handle_packaged_update(progress_fn=progress_fn, include_clis=include_clis)
 
     steps_done = []
     old_commit = None
@@ -1302,6 +1325,23 @@ def handle_update(remote: str = "origin", branch: str = "main", progress_fn=None
         except Exception:
             pass  # Non-critical
 
+        # Step 10b: Update external terminal CLIs (Claude Code, Codex). Runs
+        # after migrations and before the verify-style post-steps so a stale
+        # CLI never hides bug fixes shipped with the new NEXO release. Failures
+        # here never abort the git update — the rollback only covers NEXO itself.
+        external_cli_lines: list[str] = []
+        if include_clis:
+            try:
+                from auto_update import _update_external_clis, _format_external_clis_results
+                _emit_progress(progress_fn, "Checking external CLI updates...")
+                external_cli_lines = _format_external_clis_results(
+                    _update_external_clis(progress_fn=progress_fn)
+                )
+                if external_cli_lines:
+                    steps_done.append("external-clis")
+            except Exception:
+                pass  # Non-critical
+
         # Step 11: Sync shared client configs
         try:
             _emit_progress(progress_fn, "Refreshing shared client configs...")
@@ -1345,8 +1385,9 @@ def handle_update(remote: str = "origin", branch: str = "main", progress_fn=None
         dep_summary_lines = _format_dep_results(dep_results)
         if pull_out == "Already up to date.":
             msg = f"Already up to date (v{old_version}). No changes pulled."
-            if dep_summary_lines:
-                msg += "\n" + "\n".join(dep_summary_lines)
+            trailing = [*dep_summary_lines, *external_cli_lines]
+            if trailing:
+                msg += "\n" + "\n".join(trailing)
             return msg
 
         lines = ["UPDATE SUCCESSFUL"]
@@ -1367,6 +1408,7 @@ def handle_update(remote: str = "origin", branch: str = "main", progress_fn=None
         if retired_runtime_files:
             lines.append(f"  Cleanup: removed {len(retired_runtime_files)} retired runtime file(s)")
         lines.extend(dep_summary_lines)
+        lines.extend(external_cli_lines)
         if "client-sync" in steps_done:
             lines.append("  Clients: configured client targets synced")
         lines.append("")

package/src/server.py

@@ -680,7 +680,14 @@ def nexo_menu() -> str:
 # ── Reminders CRUD (7 tools) ──────────────────────────────────────
 
 @mcp.tool
-def nexo_reminder_create(id: str, description: str, date: str = "", category: str = "general") -> str:
+def nexo_reminder_create(
+    id: str,
+    description: str,
+    date: str = "",
+    category: str = "general",
+    internal: str = "",
+    owner: str = "",
+) -> str:
     """Create a new reminder for the user.
 
     Args:
@@ -688,8 +695,12 @@ def nexo_reminder_create(id: str, description: str, date: str = "", category: st
         description: What needs to be done.
         date: Target date YYYY-MM-DD (optional).
         category: One of: decisions, tasks, waiting, ideas, general.
+        internal: '1'/'true' to mark as agent bookkeeping (hidden from
+                  default user views). Leave empty to auto-classify.
+        owner: 'user' | 'waiting' | 'agent' | 'shared'. Leave empty to
+               auto-classify by description heuristic.
     """
-    return handle_reminder_create(id, description, date, category)
+    return handle_reminder_create(id, description, date, category, internal, owner)
 
 
 @mcp.tool
@@ -708,6 +719,8 @@ def nexo_reminder_update(
     date: str = "",
     status: str = "",
     category: str = "",
+    internal: str = "",
+    owner: str = "",
     read_token: str = "",
 ) -> str:
     """Update fields of an existing reminder. Only non-empty fields are changed.
@@ -720,9 +733,11 @@ def nexo_reminder_update(
         date: New date YYYY-MM-DD (optional).
         status: New status (optional).
         category: New category (optional).
+        internal: '1'/'0' to re-classify visibility (optional).
+        owner: New 'user'|'waiting'|'agent'|'shared' (optional).
         read_token: Token returned by `nexo_reminder_get`.
     """
-    return handle_reminder_update(id, description, date, status, category, read_token)
+    return handle_reminder_update(id, description, date, status, category, internal, owner, read_token)
 
 
 @mcp.tool
@@ -779,8 +794,18 @@ def nexo_reminder_delete(id: str, read_token: str = "") -> str:
 # ── Followups CRUD (7 tools) ──────────────────────────────────────
 
 @mcp.tool
-def nexo_followup_create(id: str, description: str, date: str = "", verification: str = "", reasoning: str = "", recurrence: str = "", priority: str = "medium") -> str:
-    """Create a new NEXO followup (autonomous task).
+def nexo_followup_create(
+    id: str,
+    description: str,
+    date: str = "",
+    verification: str = "",
+    reasoning: str = "",
+    recurrence: str = "",
+    priority: str = "medium",
+    internal: str = "",
+    owner: str = "",
+) -> str:
+    """Create a new agent followup (autonomous task).
 
     Args:
         id: Unique ID starting with 'NF' (e.g., NF-MCP2).
@@ -791,8 +816,16 @@ def nexo_followup_create(id: str, description: str, date: str = "", verification
         recurrence: Auto-regenerate pattern (optional). Formats: 'weekly:monday', 'monthly:1', 'monthly:15', 'quarterly'.
                     When completed, a new followup is auto-created with the next date. The completed one is archived with date suffix.
         priority: critical, high, medium, low (default: medium).
+        internal: '1'/'true' hides from default user views (agent
+                  bookkeeping, protocol, audit). Leave empty to
+                  auto-classify by ID prefix.
+        owner: 'user' | 'waiting' | 'agent' | 'shared'. Leave empty
+               for auto-classification.
     """
-    return handle_followup_create(id, description, date, verification, reasoning, recurrence, priority)
+    return handle_followup_create(
+        id, description, date, verification, reasoning, recurrence, priority,
+        internal, owner,
+    )
 
 
 @mcp.tool
@@ -812,6 +845,8 @@ def nexo_followup_update(
     verification: str = "",
     status: str = "",
     priority: str = "",
+    internal: str = "",
+    owner: str = "",
     read_token: str = "",
 ) -> str:
     """Update fields of an existing followup. Only non-empty fields are changed.
@@ -825,9 +860,14 @@ def nexo_followup_update(
         verification: New verification text (optional).
         status: New status (optional).
         priority: critical, high, medium, low (optional).
+        internal: '1'/'0' to re-classify visibility (optional).
+        owner: New 'user'|'waiting'|'agent'|'shared' (optional).
         read_token: Token returned by `nexo_followup_get`.
     """
-    return handle_followup_update(id, description, date, verification, status, priority, read_token)
+    return handle_followup_update(
+        id, description, date, verification, status, priority,
+        internal, owner, read_token,
+    )
 
 
 @mcp.tool

package/src/tools_reminders_crud.py

@@ -40,6 +40,8 @@ def _format_reminder_payload(reminder: dict) -> str:
         f"Date: {reminder.get('date') or '—'}",
         f"Status: {reminder.get('status') or '—'}",
         f"Category: {reminder.get('category') or 'general'}",
+        f"Owner: {reminder.get('owner') or '—'}",
+        f"Internal: {1 if reminder.get('internal') else 0}",
     ]
     history_rules = reminder.get("history_rules") or []
     if history_rules:
@@ -62,6 +64,8 @@ def _format_followup_payload(followup: dict) -> str:
         f"Reasoning: {followup.get('reasoning') or '—'}",
         f"Recurrence: {followup.get('recurrence') or '—'}",
         f"Priority: {followup.get('priority') or 'medium'}",
+        f"Owner: {followup.get('owner') or '—'}",
+        f"Internal: {1 if followup.get('internal') else 0}",
     ]
     history_rules = followup.get("history_rules") or []
     if history_rules:
@@ -76,18 +80,37 @@ def _format_followup_payload(followup: dict) -> str:
 
 # ── Reminders ──────────────────────────────────────────────────────────────────
 
-def handle_reminder_create(id: str, description: str, date: str = '', category: str = 'general') -> str:
+def handle_reminder_create(
+    id: str,
+    description: str,
+    date: str = '',
+    category: str = 'general',
+    internal: str = '',
+    owner: str = '',
+) -> str:
     """Create a new reminder. id must start with 'R'."""
     if not id.startswith('R'):
         return f"ERROR: Reminder ID must start with 'R' (received: '{id}')."
 
-    result = create_reminder(id=id, description=description, date=date or None, category=category)
+    result = create_reminder(
+        id=id,
+        description=description,
+        date=date or None,
+        category=category,
+        internal=internal if internal != '' else None,
+        owner=owner if owner != '' else None,
+    )
     if not result or "error" in result:
         error_msg = result.get("error", "unknown") if isinstance(result, dict) else "unknown"
         return f"ERROR: {error_msg}"
 
     date_str = date if date else 'no date'
-    return f"Reminder created. Date: {date_str}. Category: {category}."
+    owner_final = result.get('owner') or '—'
+    internal_final = 1 if result.get('internal') else 0
+    return (
+        f"Reminder created. Date: {date_str}. Category: {category}. "
+        f"Owner: {owner_final}. Internal: {internal_final}."
+    )
 
 
 def handle_reminder_get(id: str) -> str:
@@ -104,6 +127,8 @@ def handle_reminder_update(
     date: str = '',
     status: str = '',
     category: str = '',
+    internal: str = '',
+    owner: str = '',
     read_token: str = '',
 ) -> str:
     """Update one or more fields of an existing reminder."""
@@ -120,6 +145,10 @@ def handle_reminder_update(
         fields['status'] = status
     if category:
         fields['category'] = category
+    if internal != '':
+        fields['internal'] = internal
+    if owner != '':
+        fields['owner'] = owner
 
     if not fields:
         return f"ERROR: No fields specified to update for {id}."
@@ -190,6 +219,8 @@ def handle_followup_create(
     reasoning: str = '',
     recurrence: str = '',
     priority: str = 'medium',
+    internal: str = '',
+    owner: str = '',
 ) -> str:
     """Create a new NEXO followup. id must start with 'NF'.
 
@@ -201,6 +232,11 @@ def handle_followup_create(
         reasoning: WHY this followup exists — what decision/context led to it
         recurrence: Recurrence pattern (optional). Formats: 'weekly:monday', 'monthly:1', 'quarterly'.
                     When completed, auto-creates the next occurrence.
+        internal: '1' / 'true' hides this task from default user views
+                  (agent bookkeeping, protocol enforcement, audits).
+                  Omit to let Brain classify by ID prefix heuristic.
+        owner: 'user' | 'waiting' | 'agent' | 'shared'. Omit to let
+               Brain classify by description verbs.
     """
     if not id.startswith('NF'):
         return f"ERROR: Followup ID must start with 'NF' (received: '{id}')."
@@ -213,6 +249,8 @@ def handle_followup_create(
         reasoning=reasoning,
         recurrence=recurrence or None,
         priority=priority or "medium",
+        internal=internal if internal != '' else None,
+        owner=owner if owner != '' else None,
     )
     if not result or "error" in result:
         error_msg = result.get("error", "unknown") if isinstance(result, dict) else "unknown"
@@ -221,9 +259,12 @@ def handle_followup_create(
     date_str = date if date else 'no date'
     rec_str = f" Recurrence: {recurrence}." if recurrence else ""
     priority_str = f" Priority: {priority or 'medium'}."
+    owner_final = result.get('owner') or '—'
+    internal_final = 1 if result.get('internal') else 0
+    class_str = f" Owner: {owner_final}. Internal: {internal_final}."
     warning = result.get("warning", "")
     warn_str = f"\n{warning}" if warning else ""
-    return f"Followup created. Date: {date_str}.{priority_str}{rec_str}{warn_str}"
+    return f"Followup created. Date: {date_str}.{priority_str}{rec_str}{class_str}{warn_str}"
 
 
 def handle_followup_get(id: str) -> str:
@@ -241,6 +282,8 @@ def handle_followup_update(
     verification: str = '',
     status: str = '',
     priority: str = '',
+    internal: str = '',
+    owner: str = '',
     read_token: str = '',
 ) -> str:
     """Update one or more fields of an existing followup."""
@@ -259,6 +302,10 @@ def handle_followup_update(
         fields['status'] = status
     if priority:
         fields['priority'] = priority
+    if internal != '':
+        fields['internal'] = internal
+    if owner != '':
+        fields['owner'] = owner
 
     if not fields:
         return f"ERROR: No fields specified to update for {id}."