nexo-brain 5.7.0 → 5.8.1

package/.claude-plugin/plugin.json

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

@@ -875,6 +875,135 @@ def _purge_zero_byte_db_files() -> list[Path]:
     return removed
 
 
+def _heal_deep_sleep_runtime(dest: Path = NEXO_HOME) -> list[str]:
+    """Repair deep-sleep state that older runtimes left in a bad shape.
+
+    Runs on every ``auto_update`` post-sync. The bug it fixes: between
+    Brain 5.6.1 and 5.8.0 the cron wrapper only wrote to ``cron_runs`` at
+    end, so any wrapper killed by signal produced no row. The watchdog then
+    saw the cron as "missing cron_runs entry" and kickstart-‍k'd the live
+    worker — an infinite loop that wedged deep-sleep Phase 2 on the first
+    session of every batch. 5.8.1 fixes the loop at the source (wrapper
+    start-row + watchdog in-flight detection) but older runtimes that have
+    already been running the buggy loop need their residue cleaned up.
+
+    Returns the list of actions performed, for logging. Failures are
+    swallowed: this is best-effort healing, it must never block an update.
+    """
+    import sqlite3
+    import time as _time
+
+    actions: list[str] = []
+
+    deep_sleep_dir = dest / "operations" / "deep-sleep"
+    coord_dir = dest / "coordination"
+    data_db = dest / "data" / "nexo.db"
+    now = _time.time()
+
+    # (1) Drop poisoned checkpoints: the first retry that hit Anthropic's
+    #     overloaded_error got cached as a permanent failure. Older
+    #     extract.py re-used that checkpoint forever. New extract.py treats
+    #     transient errors as retryable, but old poisoned checkpoints still
+    #     claim 0 findings — purge them so the next deep-sleep retries cleanly.
+    if deep_sleep_dir.is_dir():
+        poisoned = 0
+        for checkpoint_dir in deep_sleep_dir.glob("*/checkpoints"):
+            if not checkpoint_dir.is_dir():
+                continue
+            for entry in checkpoint_dir.glob("*.json"):
+                try:
+                    content = entry.read_text()
+                except OSError:
+                    continue
+                if "overloaded_error" in content or '"error":{"type":"' in content:
+                    try:
+                        entry.unlink()
+                        poisoned += 1
+                    except OSError:
+                        pass
+        if poisoned:
+            actions.append(f"checkpoints-purged:{poisoned}")
+
+        # Drop debug-extract-*.txt scratch files older than 7 days.
+        stale_debug = 0
+        for entry in deep_sleep_dir.glob("debug-extract-*.txt"):
+            try:
+                if now - entry.stat().st_mtime > 7 * 86400:
+                    entry.unlink()
+                    stale_debug += 1
+            except OSError:
+                continue
+        if stale_debug:
+            actions.append(f"debug-scratch-purged:{stale_debug}")
+
+    # (2) Release stale deep-sleep locks so the next 04:30 run can acquire
+    #     them. Locks older than 6h are always stale — a real run finishes
+    #     in well under an hour.
+    lock_names = ("sleep.lock", "sleep-process.lock", "synthesis.lock")
+    released = 0
+    if coord_dir.is_dir():
+        for name in lock_names:
+            lock_path = coord_dir / name
+            if not lock_path.exists():
+                continue
+            try:
+                age = now - lock_path.stat().st_mtime
+            except OSError:
+                continue
+            if age > 6 * 3600:
+                try:
+                    lock_path.unlink()
+                    released += 1
+                except OSError:
+                    pass
+    if released:
+        actions.append(f"stale-locks-released:{released}")
+
+    # (3) Close dangling cron_runs rows. Any row with ended_at IS NULL older
+    #     than 6h is either a process killed by the old watchdog loop or a
+    #     zombie left behind by a previous bad install. Close them with
+    #     exit_code=143 + summary so the NEW watchdog treats the cron as
+    #     "finished with error" rather than "in-flight forever".
+    if data_db.is_file():
+        try:
+            conn = sqlite3.connect(str(data_db), timeout=5)
+            try:
+                cur = conn.execute(
+                    """
+                    UPDATE cron_runs
+                       SET ended_at = datetime('now'),
+                           exit_code = 143,
+                           error = 'healed by auto_update (pre-5.8.1 wrapper left row open)',
+                           duration_secs = CAST(
+                               strftime('%s','now') - strftime('%s', started_at) AS REAL
+                           )
+                     WHERE ended_at IS NULL
+                       AND strftime('%s','now') - strftime('%s', started_at) > 6 * 3600
+                    """
+                )
+                closed = cur.rowcount or 0
+                conn.commit()
+                if closed:
+                    actions.append(f"cron_runs-closed-dangling:{closed}")
+            finally:
+                conn.close()
+        except Exception as exc:
+            actions.append(f"cron_runs-heal-warning:{exc.__class__.__name__}")
+
+    # (4) Remove .watchdog-fails registry entries older than 24h — the new
+    #     in-flight detection makes stale counters obsolete.
+    fails_file = dest / "scripts" / ".watchdog-fails"
+    if fails_file.exists():
+        try:
+            if now - fails_file.stat().st_mtime > 24 * 3600:
+                fails_file.unlink()
+                actions.append("watchdog-fails-reset")
+        except OSError:
+            pass
+
+    return actions
+
+
 def _backup_dbs() -> str | None:
     """Snapshot all .db files before migration. Returns backup dir or None."""
     import sqlite3
@@ -2558,6 +2687,16 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
     except Exception as e:
         actions.append(f"client-sync-warning:{e}")
 
+    # Heal deep-sleep residue from older buggy runtimes. Idempotent + safe:
+    # no-op if the runtime is already clean.
+    try:
+        _emit_progress(progress_fn, "Healing deep-sleep runtime state...")
+        heal_actions = _heal_deep_sleep_runtime(dest)
+        for action in heal_actions:
+            actions.append(f"deep-sleep-heal:{action}")
+    except Exception as exc:
+        actions.append(f"deep-sleep-heal-warning:{exc.__class__.__name__}")
+
     _emit_progress(progress_fn, "Verifying runtime imports...")
     verify = subprocess.run(
         [sys.executable, "-c", "import server"],

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),
 ]