nexo-brain 3.1.2 → 3.1.4

package/src/db/_schema.py

@@ -674,6 +674,35 @@ def _m28_automation_runs(conn):
     _migrate_add_index(conn, "idx_automation_runs_status", "automation_runs", "status")
 
 
+def _m29_item_history_and_soft_delete(conn):
+    """Persist reminder/followup history and read-before-mutate tokens."""
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS item_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            item_type TEXT NOT NULL,
+            item_id TEXT NOT NULL,
+            event_type TEXT NOT NULL,
+            note TEXT DEFAULT '',
+            actor TEXT DEFAULT '',
+            metadata TEXT DEFAULT '{}',
+            created_at REAL NOT NULL
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS item_read_tokens (
+            token TEXT PRIMARY KEY,
+            item_type TEXT NOT NULL,
+            item_id TEXT NOT NULL,
+            history_seq INTEGER DEFAULT 0,
+            issued_at REAL NOT NULL,
+            expires_at REAL NOT NULL
+        )
+    """)
+    _migrate_add_index(conn, "idx_item_history_lookup", "item_history", "item_type, item_id, created_at")
+    _migrate_add_index(conn, "idx_item_history_item", "item_history", "item_id")
+    _migrate_add_index(conn, "idx_item_read_tokens_lookup", "item_read_tokens", "item_type, item_id, expires_at")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -703,6 +732,7 @@ MIGRATIONS = [
     (26, "protocol_answer_confidence", _m26_protocol_answer_confidence),
     (27, "state_watchers", _m27_state_watchers),
     (28, "automation_runs", _m28_automation_runs),
+    (29, "item_history_and_soft_delete", _m29_item_history_and_soft_delete),
 ]
 
 

package/src/scripts/deep-sleep/apply_findings.py

@@ -30,6 +30,8 @@ NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent
 if str(NEXO_CODE) not in sys.path:
     sys.path.insert(0, str(NEXO_CODE))
 
+import db as nexo_db
+
 DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
 NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 COGNITIVE_DB = NEXO_HOME / "data" / "cognitive.db"
@@ -294,25 +296,31 @@ def _touch_existing_followup(existing: dict, *, description: str, date: str = ""
     preferred_date = _prefer_due_date(existing.get("date", ""), date)
     if preferred_date and preferred_date != str(existing.get("date", "") or "") and "date" in cols:
         updates["date"] = preferred_date
-    if "reasoning" in cols and reasoning_note:
-        updates["reasoning"] = _append_note(existing.get("reasoning", ""), reasoning_note)
-    if "updated_at" in cols:
-        updates["updated_at"] = datetime.now().timestamp()
-
+    note = reasoning_note or "Deep Sleep matched this followup semantically."
+    changed = False
     if updates:
-        conn = sqlite3.connect(str(NEXO_DB))
-        set_clause = ", ".join(f"{column} = ?" for column in updates)
-        params = list(updates.values()) + [existing["id"]]
-        conn.execute(f"UPDATE followups SET {set_clause} WHERE id = ?", params)
-        conn.commit()
-        conn.close()
+        result = nexo_db.update_followup(
+            str(existing["id"]),
+            history_actor="deep-sleep",
+            history_event="updated",
+            history_note=note,
+            **updates,
+        )
+        if result.get("error"):
+            return {"success": False, "error": result["error"]}
+        changed = True
+    elif note:
+        note_result = nexo_db.add_followup_note(str(existing["id"]), note, actor="deep-sleep")
+        if note_result.get("error"):
+            return {"success": False, "error": note_result["error"]}
+        changed = True
 
     return {
         "success": True,
         "id": existing["id"],
         "outcome": "matched_existing_followup",
         "similarity": existing.get("_similarity", 1.0),
-        "updated_existing": bool(updates),
+        "updated_existing": changed,
     }
 
 
@@ -509,32 +517,27 @@ def create_followup(description: str, date: str = "", reasoning_note: str = "")
                 reasoning_note=reasoning_note or "Deep Sleep matched this followup semantically.",
             )
 
-        now = datetime.now().timestamp()
         # Generate a deterministic ID
         fid = "NF-DS-" + hashlib.md5(description.encode()).hexdigest()[:8].upper()
-        columns = _table_columns(NEXO_DB, "followups")
-        payload = {
-            "id": fid,
-            "description": description,
-            "date": date,
-            "status": "PENDING",
-            "created_at": now,
-            "updated_at": now,
-        }
-        if "reasoning" in columns:
-            payload["reasoning"] = reasoning_note or "Deep Sleep v2 overnight analysis"
-        if "verification" in columns:
-            payload["verification"] = ""
-        insert_columns = [column for column in payload if column in columns]
-        values = [payload[column] for column in insert_columns]
+        existing = nexo_db.get_followup(fid)
+        if existing:
+            return _touch_existing_followup(
+                existing,
+                description=description,
+                date=date,
+                reasoning_note=reasoning_note or "Deep Sleep revisited this deterministic followup.",
+            )
 
-        conn = sqlite3.connect(str(NEXO_DB))
-        conn.execute(
-            f"INSERT OR IGNORE INTO followups ({', '.join(insert_columns)}) VALUES ({', '.join('?' for _ in insert_columns)})",
-            values,
+        followup_result = nexo_db.create_followup(
+            id=fid,
+            description=description,
+            date=date or None,
+            verification="",
+            reasoning=reasoning_note or "Deep Sleep v2 overnight analysis",
+            recurrence=None,
         )
-        conn.commit()
-        conn.close()
+        if followup_result.get("error"):
+            return {"success": False, "error": followup_result["error"]}
         return {"success": True, "id": fid, "outcome": "new_followup"}
     except Exception as e:
         return {"success": False, "error": str(e)}

package/src/scripts/nexo-daily-self-audit.py

@@ -37,6 +37,7 @@ if str(NEXO_CODE) not in sys.path:
     sys.path.insert(0, str(NEXO_CODE))
 
 from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
+import db as nexo_db
 from public_evolution_queue import queue_public_port_candidate
 
 LOG_DIR = NEXO_HOME / "logs"
@@ -251,42 +252,36 @@ def _ensure_followup(conn: sqlite3.Connection, *, prefix: str, description: str,
             "description": description,
             "verification": verification,
             "reasoning": reasoning,
-            "updated_at": now_epoch,
         }
         if "priority" in columns:
             update_fields["priority"] = priority
         closed_status = str(existing_id_row["status"] or "").upper()
         if closed_status.startswith("COMPLETED") or closed_status in {"DELETED", "ARCHIVED", "BLOCKED", "WAITING"}:
             update_fields["status"] = "PENDING"
-        ordered_updates = [name for name in update_fields.keys() if name in columns]
-        if ordered_updates:
-            assignments = ", ".join(f"{name} = ?" for name in ordered_updates)
-            conn.execute(
-                f"UPDATE followups SET {assignments} WHERE id = ?",
-                [update_fields[name] for name in ordered_updates] + [followup_id],
-            )
+        conn.commit()
+        result = nexo_db.update_followup(
+            followup_id,
+            history_actor="self-audit",
+            history_event="updated",
+            history_note="Daily self-audit refreshed canonical followup coverage.",
+            **update_fields,
+        )
+        if result.get("error"):
+            return ""
         return followup_id
 
-    values = {
-        "id": followup_id,
-        "date": "",
-        "description": description,
-        "verification": verification,
-        "status": "PENDING",
-        "reasoning": reasoning,
-        "recurrence": None,
-        "created_at": now_epoch,
-        "updated_at": now_epoch,
-    }
-    if "priority" in columns:
-        values["priority"] = priority
-
-    ordered_columns = [name for name in values.keys() if name in columns]
-    placeholders = ", ".join("?" for _ in ordered_columns)
-    conn.execute(
-        f"INSERT INTO followups ({', '.join(ordered_columns)}) VALUES ({placeholders})",
-        [values[name] for name in ordered_columns],
+    conn.commit()
+    result = nexo_db.create_followup(
+        id=followup_id,
+        description=description,
+        date=None,
+        verification=verification,
+        reasoning=reasoning,
+        recurrence=None,
+        priority=priority,
     )
+    if result.get("error"):
+        return ""
     return followup_id
 
 
@@ -319,7 +314,6 @@ def _append_note(existing: str, note: str) -> str:
 def _complete_matching_followup(conn: sqlite3.Connection, description: str, note: str) -> int:
     if not _table_exists(conn, "followups"):
         return 0
-    columns = _table_columns(conn, "followups")
     rows = conn.execute(
         """SELECT id, verification, reasoning
            FROM followups
@@ -329,21 +323,11 @@ def _complete_matching_followup(conn: sqlite3.Connection, description: str, note
         (description,),
     ).fetchall()
     completed = 0
-    now_epoch = datetime.now().timestamp()
+    conn.commit()
     for row in rows:
-        updates = {"status": "COMPLETED"}
-        if "updated_at" in columns:
-            updates["updated_at"] = now_epoch
-        if "verification" in columns:
-            updates["verification"] = _append_note(row["verification"], note)
-        if "reasoning" in columns:
-            updates["reasoning"] = _append_note(row["reasoning"], note)
-        assignments = ", ".join(f"{column} = ?" for column in updates)
-        conn.execute(
-            f"UPDATE followups SET {assignments} WHERE id = ?",
-            [updates[column] for column in updates] + [row["id"]],
-        )
-        completed += 1
+        result = nexo_db.complete_followup(str(row["id"]), note)
+        if not result.get("error"):
+            completed += 1
     return completed
 
 

package/src/scripts/nexo-followup-hygiene.py

@@ -18,6 +18,13 @@ from datetime import datetime, date, timedelta
 from pathlib import Path
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+import db as nexo_db
 
 NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 COORD_DIR = NEXO_HOME / "coordination"
@@ -50,11 +57,31 @@ def main():
     dirty_r = conn.execute("SELECT COUNT(*) FROM reminders WHERE status LIKE 'COMPLETED %'").fetchone()[0]
 
     if dirty_f > 0:
-        conn.execute("UPDATE followups SET status='COMPLETED' WHERE status LIKE 'COMPLETED %'")
+        dirty_followups = conn.execute(
+            "SELECT id, status FROM followups WHERE status LIKE 'COMPLETED %'"
+        ).fetchall()
+        for row in dirty_followups:
+            nexo_db.update_followup(
+                str(row["id"]),
+                status="COMPLETED",
+                history_actor="followup-hygiene",
+                history_event="normalized",
+                history_note=f"Weekly hygiene normalized dirty status from {row['status']} to COMPLETED.",
+            )
         log(f"Normalized {dirty_f} dirty followup statuses")
 
     if dirty_r > 0:
-        conn.execute("UPDATE reminders SET status='COMPLETED' WHERE status LIKE 'COMPLETED %'")
+        dirty_reminders = conn.execute(
+            "SELECT id, status FROM reminders WHERE status LIKE 'COMPLETED %'"
+        ).fetchall()
+        for row in dirty_reminders:
+            nexo_db.update_reminder(
+                str(row["id"]),
+                status="COMPLETED",
+                history_actor="followup-hygiene",
+                history_event="normalized",
+                history_note=f"Weekly hygiene normalized dirty status from {row['status']} to COMPLETED.",
+            )
         log(f"Normalized {dirty_r} dirty reminder statuses")
 
     # 2. Flag stale followups (PENDING >14 days, no updates)

package/src/server.py

@@ -24,10 +24,10 @@ from tools_coordination import (
 from tools_reminders import handle_reminders
 from tools_menu import handle_menu
 from tools_reminders_crud import (
-    handle_reminder_create, handle_reminder_update,
-    handle_reminder_complete, handle_reminder_delete,
-    handle_followup_create, handle_followup_update,
-    handle_followup_complete, handle_followup_delete,
+    handle_reminder_create, handle_reminder_get, handle_reminder_update,
+    handle_reminder_complete, handle_reminder_note, handle_reminder_restore, handle_reminder_delete,
+    handle_followup_create, handle_followup_get, handle_followup_update,
+    handle_followup_complete, handle_followup_note, handle_followup_restore, handle_followup_delete,
 )
 from tools_learnings import (
     handle_learning_add, handle_learning_search,
@@ -191,6 +191,8 @@ mcp = FastMCP(
         "React: DIARY REMINDER→write diary, VIBE:NEGATIVE→ultra-concise, AUTO-PRIME→read learnings\n"
         "- **Followups:** NEXO tasks, execute silently. 'done'/'all set'→`nexo_followup_complete` NOW. "
         "Reminders=user's, alert when due\n"
+        "- **Reminder/followup history:** before update/delete/restore/note, call the corresponding "
+        "`nexo_reminder_get` / `nexo_followup_get` first and use its `READ_TOKEN`.\n"
         "- **Observe:** correction→learning. 'tomorrow'→followup. person→entity. open topic→followup 3d\n"
         "- **Trust events:** When user expresses satisfaction/thanks (any language)→`nexo_cognitive_trust(event='explicit_thanks')`. "
         "When user corrects you→`nexo_cognitive_trust(event='correction')`. "
@@ -488,7 +490,7 @@ def nexo_reminders(filter: str = "due") -> str:
     """Check reminders and followups.
 
     Args:
-        filter: 'due' (vencidos/hoy), 'all' (todos activos), 'followups' (solo NEXO followups)
+        filter: 'due', 'all', 'followups', 'completed', 'deleted', 'history', or 'any'
     """
     return handle_reminders(filter)
 
@@ -503,7 +505,7 @@ def nexo_menu() -> str:
     return handle_menu()
 
 
-# ── Reminders CRUD (4 tools) ──────────────────────────────────────
+# ── Reminders CRUD (7 tools) ──────────────────────────────────────
 
 @mcp.tool
 def nexo_reminder_create(id: str, description: str, date: str = "", category: str = "general") -> str:
@@ -519,17 +521,36 @@ def nexo_reminder_create(id: str, description: str, date: str = "", category: st
 
 
 @mcp.tool
-def nexo_reminder_update(id: str, description: str = "", date: str = "", status: str = "", category: str = "") -> str:
+def nexo_reminder_get(id: str) -> str:
+    """Read a reminder with its history and usage rules.
+
+    IMPORTANT: before update/delete/restore/note, call this tool first and use the returned READ_TOKEN.
+    """
+    return handle_reminder_get(id)
+
+
+@mcp.tool
+def nexo_reminder_update(
+    id: str,
+    description: str = "",
+    date: str = "",
+    status: str = "",
+    category: str = "",
+    read_token: str = "",
+) -> str:
     """Update fields of an existing reminder. Only non-empty fields are changed.
 
+    IMPORTANT: call `nexo_reminder_get` first and pass its READ_TOKEN.
+
     Args:
         id: Reminder ID (e.g., R87).
         description: New description (optional).
         date: New date YYYY-MM-DD (optional).
         status: New status (optional).
         category: New category (optional).
+        read_token: Token returned by `nexo_reminder_get`.
     """
-    return handle_reminder_update(id, description, date, status, category)
+    return handle_reminder_update(id, description, date, status, category, read_token)
 
 
 @mcp.tool
@@ -543,16 +564,47 @@ def nexo_reminder_complete(id: str) -> str:
 
 
 @mcp.tool
-def nexo_reminder_delete(id: str) -> str:
-    """Delete a reminder permanently.
+def nexo_reminder_note(id: str, note: str, read_token: str = "", actor: str = "nexo") -> str:
+    """Append a note to reminder history.
+
+    IMPORTANT: call `nexo_reminder_get` first and pass its READ_TOKEN.
+
+    Args:
+        id: Reminder ID (e.g., R87).
+        note: Operational note to append to history.
+        read_token: Token returned by `nexo_reminder_get`.
+        actor: Actor label for the history note.
+    """
+    return handle_reminder_note(id, note, read_token, actor)
+
+
+@mcp.tool
+def nexo_reminder_restore(id: str, read_token: str = "") -> str:
+    """Restore a soft-deleted reminder back to PENDING.
+
+    IMPORTANT: call `nexo_reminder_get` first and pass its READ_TOKEN.
+
+    Args:
+        id: Reminder ID (e.g., R87).
+        read_token: Token returned by `nexo_reminder_get`.
+    """
+    return handle_reminder_restore(id, read_token)
+
+
+@mcp.tool
+def nexo_reminder_delete(id: str, read_token: str = "") -> str:
+    """Soft-delete a reminder.
+
+    IMPORTANT: call `nexo_reminder_get` first and pass its READ_TOKEN.
 
     Args:
         id: Reminder ID (e.g., R87).
+        read_token: Token returned by `nexo_reminder_get`.
     """
-    return handle_reminder_delete(id)
+    return handle_reminder_delete(id, read_token)
 
 
-# ── Followups CRUD (4 tools) ──────────────────────────────────────
+# ── 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:
@@ -568,18 +620,32 @@ def nexo_followup_create(id: str, description: str, date: str = "", verification
                     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).
     """
-    result = handle_followup_create(id, description, date, verification, reasoning, recurrence)
-    if priority in ('critical', 'high', 'low') and 'created' in result:
-        from db import get_db
-        get_db().execute("UPDATE followups SET priority = ? WHERE id = ?", (priority, id))
-        get_db().commit()
-    return result
+    return handle_followup_create(id, description, date, verification, reasoning, recurrence, priority)
 
 
 @mcp.tool
-def nexo_followup_update(id: str, description: str = "", date: str = "", verification: str = "", status: str = "", priority: str = "") -> str:
+def nexo_followup_get(id: str) -> str:
+    """Read a followup with its history and usage rules.
+
+    IMPORTANT: before update/delete/restore/note, call this tool first and use the returned READ_TOKEN.
+    """
+    return handle_followup_get(id)
+
+
+@mcp.tool
+def nexo_followup_update(
+    id: str,
+    description: str = "",
+    date: str = "",
+    verification: str = "",
+    status: str = "",
+    priority: str = "",
+    read_token: str = "",
+) -> str:
     """Update fields of an existing followup. Only non-empty fields are changed.
 
+    IMPORTANT: call `nexo_followup_get` first and pass its READ_TOKEN.
+
     Args:
         id: Followup ID (e.g., NF45).
         description: New description (optional).
@@ -587,13 +653,9 @@ def nexo_followup_update(id: str, description: str = "", date: str = "", verific
         verification: New verification text (optional).
         status: New status (optional).
         priority: critical, high, medium, low (optional).
+        read_token: Token returned by `nexo_followup_get`.
     """
-    result = handle_followup_update(id, description, date, verification, status)
-    if priority in ('critical', 'high', 'medium', 'low'):
-        from db import get_db
-        get_db().execute("UPDATE followups SET priority = ? WHERE id = ?", (priority, id))
-        get_db().commit()
-    return result
+    return handle_followup_update(id, description, date, verification, status, priority, read_token)
 
 
 @mcp.tool
@@ -608,13 +670,44 @@ def nexo_followup_complete(id: str, result: str = "") -> str:
 
 
 @mcp.tool
-def nexo_followup_delete(id: str) -> str:
-    """Delete a followup permanently.
+def nexo_followup_note(id: str, note: str, read_token: str = "", actor: str = "nexo") -> str:
+    """Append a note to followup history.
+
+    IMPORTANT: call `nexo_followup_get` first and pass its READ_TOKEN.
+
+    Args:
+        id: Followup ID (e.g., NF45).
+        note: Operational note to append to history.
+        read_token: Token returned by `nexo_followup_get`.
+        actor: Actor label for the history note.
+    """
+    return handle_followup_note(id, note, read_token, actor)
+
+
+@mcp.tool
+def nexo_followup_restore(id: str, read_token: str = "") -> str:
+    """Restore a soft-deleted followup back to PENDING.
+
+    IMPORTANT: call `nexo_followup_get` first and pass its READ_TOKEN.
+
+    Args:
+        id: Followup ID (e.g., NF45).
+        read_token: Token returned by `nexo_followup_get`.
+    """
+    return handle_followup_restore(id, read_token)
+
+
+@mcp.tool
+def nexo_followup_delete(id: str, read_token: str = "") -> str:
+    """Soft-delete a followup.
+
+    IMPORTANT: call `nexo_followup_get` first and pass its READ_TOKEN.
 
     Args:
         id: Followup ID (e.g., NF45).
+        read_token: Token returned by `nexo_followup_get`.
     """
-    return handle_followup_delete(id)
+    return handle_followup_delete(id, read_token)
 
 
 # ── Learnings CRUD (5 tools) ──────────────────────────────────────

package/src/tools_learnings.py

@@ -307,16 +307,26 @@ def handle_learning_add(category: str, title: str, content: str, reasoning: str
         return f"ERROR: {result['error']}"
     if prevention or applies_to or review_days > 0 or priority != 'medium':
         initial_weight = {'critical': 0.9, 'high': 0.7, 'medium': 0.5, 'low': 0.3}[priority]
+        updated_at = now_epoch()
+        review_due_at = now_epoch() + (max(1, int(review_days)) * 86400)
         conn = get_db()
         conn.execute(
             "UPDATE learnings SET prevention = ?, applies_to = ?, status = COALESCE(status, 'active'), "
             "review_due_at = ?, updated_at = ?, priority = ?, weight = ? WHERE id = ?",
-            (prevention, applies_to, now_epoch() + (max(1, int(review_days)) * 86400), now_epoch(),
+            (prevention, applies_to, review_due_at, updated_at,
              priority, initial_weight, result["id"])
         )
         conn.commit()
-        result = conn.execute("SELECT * FROM learnings WHERE id = ?", (result["id"],)).fetchone()
         result = dict(result)
+        result.update({
+            "prevention": prevention,
+            "applies_to": applies_to,
+            "status": result.get("status") or "active",
+            "review_due_at": review_due_at,
+            "updated_at": updated_at,
+            "priority": priority,
+            "weight": initial_weight,
+        })
 
     # Cognitive ingest — embed learning for semantic search
     new_id = result["id"]

package/src/tools_reminders.py

@@ -19,16 +19,16 @@ def handle_reminders(filter_type: str = "due") -> str:
     """Read reminders and followups from SQLite, return relevant ones.
 
     Args:
-        filter_type: 'due' (vencidos/hoy), 'all' (todos activos), 'followups' (solo followups)
+        filter_type: 'due', 'all', 'followups', 'completed', 'deleted', 'history', 'any'
     """
     parts = []
 
-    if filter_type in ("due", "all"):
+    if filter_type in ("due", "all", "completed", "deleted", "history", "any"):
         r = _format_reminders(filter_type)
         if r:
             parts.append(r)
 
-    if filter_type in ("due", "all", "followups"):
+    if filter_type in ("due", "all", "followups", "completed", "deleted", "history", "any"):
         f = _format_followups(filter_type)
         if f:
             parts.append(f)
@@ -52,7 +52,8 @@ def _format_reminders(filter_type: str) -> str:
         desc = desc.replace("**", "")
         due_marker = " [DUE]" if _is_due(fecha) else ""
         fecha_display = f"({fecha})" if fecha else "(—)"
-        lines.append(f"  {rid} {fecha_display}{due_marker} — {desc[:120]}")
+        status_tag = f" [{status}]" if status and status != "PENDING" else ""
+        lines.append(f"  {rid} {fecha_display}{due_marker}{status_tag} — {desc[:120]}")
         if "RECURRENTE" in status.upper():
             lines.append(f"    Status: {status}")
 
@@ -81,6 +82,8 @@ def _format_followups(filter_type: str) -> str:
         pri = r.get("priority") or "medium"
         pri_icon = {"critical": "🔴", "high": "🟠", "medium": "", "low": "⚪"}.get(pri, "")
         pri_tag = f" {pri_icon}" if pri_icon else ""
-        lines.append(f"  {nfid} {fecha_display}{due_marker}{pri_tag}{rec_tag} — {desc[:120]}")
+        status = r.get("status") or ""
+        status_tag = f" [{status}]" if status and status != "PENDING" else ""
+        lines.append(f"  {nfid} {fecha_display}{due_marker}{pri_tag}{rec_tag}{status_tag} — {desc[:120]}")
 
     return "\n".join(lines)