nexo-brain 5.8.1 → 5.8.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.8.1",
+  "version": "5.8.2",
   "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,7 +18,9 @@
 
 [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.8.1` is the current packaged-runtime line: closes a self-reinforcing `launchctl kickstart -k` loop in the watchdog that wedged deep-sleep Phase 2 between 2026-04-14 and 2026-04-17. The cron wrapper now INSERTs an in-flight row (`ended_at=NULL`) at start and traps SIGTERM/INT/HUP to close it with `exit_code=143` instead of vanishing from `cron_runs`. The watchdog interprets in-flight rows as "currently running" and only re-executes after verifying the worker process is dead. `extract.py` classifies CLI failures into transient (`overloaded_error`, rate-limit, timeout, signal — retried next run) and deterministic (skipped after `MAX_POISON_ATTEMPTS`), and passes a slim shared-context (200 head lines + metadata) instead of the full 400+ KB dump. A new `auto_update._heal_deep_sleep_runtime()` repairs existing installs silently on the next `nexo update`: poisoned checkpoints, stale locks, dangling `cron_runs` rows, and bloated `.watchdog-fails` counters.
+Version `5.8.2` is the current packaged-runtime line: the Brain core no longer auto-classifies `followups` and `reminders` on behalf of agents. v5.8.0's `classify_task()` heuristic (NEXO-specific ID prefixes `NF-PROTOCOL-*` / `NF-DS-*` / `NF-AUDIT-*`, Spanish user-verbs `debes` / `revisar` / `firmar`, agent keywords `monitor` / `auditoría diaria` / `checkpoint`) was fine for NEXO's own DB but bled convention into every third-party agent plugged into the shared Brain. The core now persists `internal=0` and `owner=NULL` when the caller omits them, and clients that want automatic classification (NEXO Desktop does, via its `_legacyClassifyOwner` helpers) compute it themselves and pass the result. Migration #40 keeps the columns + indexes; rows already backfilled by v5.8.0 keep their values. `normalise_owner` still explicitly rejects the string `"nexo"` so legacy hardcoding cannot sneak back in.
+
+Previously in `5.8.1`: closes a self-reinforcing `launchctl kickstart -k` loop in the watchdog that wedged deep-sleep Phase 2 between 2026-04-14 and 2026-04-17. The cron wrapper now INSERTs an in-flight row (`ended_at=NULL`) at start and traps SIGTERM/INT/HUP to close it with `exit_code=143` instead of vanishing from `cron_runs`. The watchdog interprets in-flight rows as "currently running" and only re-executes after verifying the worker process is dead. `extract.py` classifies CLI failures into transient (`overloaded_error`, rate-limit, timeout, signal — retried next run) and deterministic (skipped after `MAX_POISON_ATTEMPTS`), and passes a slim shared-context (200 head lines + metadata) instead of the full 400+ KB dump. A new `auto_update._heal_deep_sleep_runtime()` repairs existing installs silently on the next `nexo update`: poisoned checkpoints, stale locks, dangling `cron_runs` rows, and bloated `.watchdog-fails` counters.
 
 Previously in `5.8.0`: 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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.8.1",
+  "version": "5.8.2",
   "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/db/_classification.py

@@ -1,132 +1,54 @@
-"""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').
+"""NEXO DB — Task classification storage (internal + owner).
+
+Migration #40 added ``internal`` and ``owner`` columns to ``followups`` and
+``reminders``. Agents creating or updating tasks pass these two fields
+explicitly via the MCP tools (``nexo_followup_create``, ``nexo_reminder_create``
+and their ``_update`` counterparts).
+
+The Brain core does **not** classify tasks on behalf of agents. Up to and
+including v5.8.1 the core shipped a Spanish-first regex heuristic
+(``NF-PROTOCOL-*`` / ``NF-DS-*`` prefixes, user verbs like ``debes``,
+``revisar``, etc.) as a fallback for callers that left the fields blank.
+That fallback bled NEXO-specific naming conventions into every deployment
+of the shared Brain — third-party agents plugged into the same DB would
+inherit classifications they never asked for. v5.8.2 removes it.
+
+The module now exposes only:
+
+    VALID_OWNERS      — the canonical set {user, waiting, agent, shared}.
+    normalise_owner   — clamps an agent-supplied string to VALID_OWNERS
+                        (or ``None`` for empty / invalid input so the
+                        caller can decide whether to persist ``NULL``).
+    normalise_internal — coerces truthy / boolean / numeric agent input
+                        into ``0`` / ``1`` (or ``None`` for empty input).
+
+    owner values:
+        'user'    — the user has to act.
+        'waiting' — blocked on an external response.
         '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.
+                    named ``agent`` (not ``nexo``) so deployments render
+                    whatever assistant label fits client-side.
+        'shared'  — collaborative follow-up.
+        NULL      — unclassified; clients are free to apply whatever
+                    fallback they want at render time.
+
+Clients that want automatic classification (NEXO Desktop does, via its
+``_legacyClassifyOwner`` / ``_legacyIsInternalTaskId`` helpers) compute
+``owner``/``internal`` themselves and pass them to the create/update call.
 """
 
 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().
+    garbage.
     """
     if value is None:
         return None

package/src/db/_reminders.py

@@ -8,7 +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._classification import normalise_internal, normalise_owner
 from db._fts import fts_upsert
 from db._hot_context import capture_context_event
 
@@ -256,18 +256,18 @@ def create_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.
+    ('user'|'waiting'|'agent'|'shared'). When omitted, the Brain persists
+    ``internal=0`` and ``owner=NULL`` — the Brain core does not classify
+    tasks on behalf of agents. Clients that want automatic classification
+    compute it themselves and pass the result.
     """
     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
+        internal_value = 0
+    owner_value = normalise_owner(owner)
 
     columns = {str(row["name"]) for row in conn.execute("PRAGMA table_info(reminders)").fetchall()}
     payload: dict[str, object] = {
@@ -615,9 +615,10 @@ def create_followup(
 ) -> dict:
     """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.
+    Agents may set `internal` and `owner` explicitly. Omitted values
+    persist as ``internal=0`` and ``owner=NULL`` — the Brain core does not
+    classify tasks on behalf of agents. Clients that want automatic
+    classification compute it themselves and pass the result.
     """
     conn = get_db()
     now = now_epoch()
@@ -630,11 +631,10 @@ 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
+        internal_value = 0
+    owner_value = normalise_owner(owner)
 
     columns = {str(row["name"]) for row in conn.execute("PRAGMA table_info(followups)").fetchall()}
     payload: dict[str, object] = {

package/src/db/_schema.py

@@ -939,18 +939,11 @@ def _m39_hook_runs(conn):
 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.
+    Agents creating tasks via nexo_followup_create / nexo_reminder_create
+    can set both fields explicitly. The Brain core does not classify tasks
+    on behalf of agents — clients that want automatic classification
+    compute it themselves (NEXO Desktop does, via its legacy client-side
+    helpers) and pass the result.
 
     Values:
         internal: 0 (external, visible) or 1 (agent bookkeeping, hidden).
@@ -960,8 +953,10 @@ def _m40_classification_columns(conn):
             '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_index likewise. Pre-v5.8.2 versions of this migration
+    also ran a one-shot backfill using a Spanish-first regex heuristic;
+    v5.8.2 removed that heuristic so the core stays neutral across
+    deployments. Rows that were already backfilled keep their values.
     """
     _migrate_add_column(conn, "followups", "internal", "INTEGER DEFAULT 0")
     _migrate_add_column(conn, "followups", "owner", "TEXT DEFAULT NULL")
@@ -972,32 +967,6 @@ def _m40_classification_columns(conn):
     _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),