nexo-brain 5.7.0 → 5.8.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.7.0",
+  "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,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.7.0` is the current packaged-runtime line: `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.
+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.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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.7.0",
+  "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/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/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}."