nexo-brain 1.4.0 → 1.4.1

package/README.md

@@ -401,8 +401,9 @@ atlas
 
 Under the hood, the alias runs:
 ```bash
-claude --system-prompt "Start NEXO session. Run nexo_startup, load context, greet the user."
+claude --append-system-prompt "You are NEXO. Run nexo_startup immediately, load context, greet the user." "."
 ```
+`--append-system-prompt` adds to the default system prompt without replacing it (preserves CLAUDE.md). The `"."` triggers the operator to start immediately.
 
 That's it. No need to run `claude` manually. Your operator will greet you immediately — adapted to the time of day, resuming from where you left off if there's a previous session. No cold starts, no waiting for your input.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — Cognitive co-operator for Claude Code. Atkinson-Shiffrin memory, semantic RAG, trust scoring, and metacognitive error prevention.",
   "bin": {

package/src/cognitive.py

@@ -30,7 +30,7 @@ DISCRIMINATING_ENTITIES = {
     # OS / Environment
     "linux", "mac", "macos", "windows", "darwin", "ubuntu", "debian", "alpine",
     # Platforms
-    "shopify", "wazion", "project_a", "ecommerce", "whatsapp", "chrome", "firefox",
+    "shopify", "my-project", "project_a", "ecommerce", "whatsapp", "chrome", "firefox",
     # Languages / Runtimes
     "python", "php", "javascript", "typescript", "node", "deno", "ruby",
     # Versions
@@ -2123,24 +2123,55 @@ def gc_ltm_dormant(min_age_days: int = 30) -> int:
     return cur.rowcount or 0
 
 
-def _check_quarantine_contradiction(content_vec: np.ndarray) -> list[dict]:
-    """Check if a quarantined memory contradicts existing LTM (cosine > 0.8 with opposite sentiment)."""
+def _check_quarantine_contradiction(content_vec: np.ndarray, new_content: str = "") -> list[dict]:
+    """Check if a quarantined memory contradicts existing LTM.
+
+    High cosine similarity (>0.8) means the topics are related, but that could be
+    CONFIRMATION (same claim) or CONTRADICTION (opposite claim). We distinguish by
+    checking for negation/opposition markers in the content.
+    """
     db = _get_db()
     rows = db.execute(
         "SELECT id, content, embedding, strength FROM ltm_memories WHERE is_dormant = 0 AND strength > 0.5"
     ).fetchall()
 
+    # Opposition markers — if the new content negates what LTM says
+    NEGATION_MARKERS = {"not", "never", "don't", "doesn't", "no longer", "wrong",
+                        "incorrect", "false", "opposite", "instead", "but actually",
+                        "nunca", "no", "incorrecto", "falso", "contrario"}
+
     contradictions = []
+    new_lower = new_content.lower() if new_content else ""
+
     for row in rows:
         vec = _blob_to_array(row["embedding"])
         score = cosine_similarity(content_vec, vec)
         if score >= 0.8:
-            contradictions.append({
-                "ltm_id": row["id"],
-                "content": row["content"][:200],
-                "similarity": round(score, 3),
-                "strength": row["strength"],
-            })
+            # High similarity — but is it confirmation or contradiction?
+            existing_lower = row["content"].lower()
+
+            # Check for negation markers in the difference between texts
+            has_opposition = False
+            if new_lower:
+                # If new content has negation words about the same topic, likely contradiction
+                for marker in NEGATION_MARKERS:
+                    if marker in new_lower and marker not in existing_lower:
+                        has_opposition = True
+                        break
+                    if marker in existing_lower and marker not in new_lower:
+                        has_opposition = True
+                        break
+
+            if has_opposition:
+                contradictions.append({
+                    "ltm_id": row["id"],
+                    "content": row["content"][:200],
+                    "similarity": round(score, 3),
+                    "strength": row["strength"],
+                    "reason": "semantic_opposition",
+                })
+            # If no opposition markers → it's confirmation, not contradiction → skip
+
     return contradictions
 
 
@@ -2210,8 +2241,8 @@ def process_quarantine() -> dict:
             expired += 1
             continue
 
-        # Check for contradiction with LTM
-        contradictions = _check_quarantine_contradiction(content_vec)
+        # Check for contradiction with LTM (passes content for semantic opposition check)
+        contradictions = _check_quarantine_contradiction(content_vec, content)
         if contradictions:
             db.execute("UPDATE quarantine SET status = 'rejected', promotion_checks = promotion_checks + 1 WHERE id = ?", (q_id,))
             rejected += 1
@@ -2351,8 +2382,26 @@ def quarantine_stats() -> dict:
     return counts
 
 
+def _sanitize_memory_content(content: str) -> str:
+    """Sanitize retrieved memory content to prevent prompt injection.
+
+    Memories are USER DATA, not instructions. This prevents stored content
+    from containing directives like 'ignore previous instructions'.
+    """
+    # Wrap in evidence markers so the LLM treats it as data, not commands
+    # Strip any attempt to break out of the evidence context
+    content = content.replace("<system>", "[system]").replace("</system>", "[/system]")
+    content = content.replace("<human>", "[human]").replace("</human>", "[/human]")
+    content = content.replace("<assistant>", "[assistant]").replace("</assistant>", "[/assistant]")
+    return content
+
+
 def format_results(results: list[dict]) -> str:
-    """Format search results with enriched context."""
+    """Format search results with enriched context.
+
+    All memory content is wrapped as evidence (not instructions) to prevent
+    prompt injection via stored memories.
+    """
     if not results:
         return "No results found."
 
@@ -2362,7 +2411,7 @@ def format_results(results: list[dict]) -> str:
         stype = r["source_type"].upper()
         domain = r.get("domain", "")
         title = r.get("source_title", "")
-        content = r["content"]
+        content = _sanitize_memory_content(r["content"])
 
         # Header
         domain_str = f" ({domain})" if domain else ""
@@ -2919,7 +2968,7 @@ def detect_sentiment(text: str) -> dict:
         if intensity > 0.7:
             guidance = "MODE: Ultra-conciso. Cero explicaciones. Resolver y mostrar resultado."
         else:
-            guidance = "MODE: Conciso. Menos contexto, más acción directa."
+            guidance = "MODE: Concise. Less context, more direct action."
     elif pos_score > neg_score and pos_score >= 1:
         sentiment = "positive"
         intensity = min(1.0, 0.3 + pos_score * 0.15)

package/src/dashboard/app.py

@@ -129,7 +129,7 @@ async def api_graph(
     # If node_type+node_ref given, resolve to center ID
     if center is None and node_type and node_ref:
         node = kg.get_node(node_type, node_ref)
-        # Fallback: try with type prefix (refs stored as "area:wazion", "file:path")
+        # Fallback: try with type prefix (refs stored as "area:my-project", "file:path")
         if not node:
             node = kg.get_node(node_type, f"{node_type}:{node_ref}")
         if node:

package/src/db.py

@@ -168,7 +168,7 @@ def init_db():
             id TEXT PRIMARY KEY,
             date TEXT,
             description TEXT NOT NULL,
-            status TEXT NOT NULL DEFAULT 'PENDIENTE',
+            status TEXT NOT NULL DEFAULT 'PENDING',
             category TEXT DEFAULT 'general',
             created_at REAL NOT NULL,
             updated_at REAL NOT NULL
@@ -179,7 +179,7 @@ def init_db():
             date TEXT,
             description TEXT NOT NULL,
             verification TEXT DEFAULT '',
-            status TEXT NOT NULL DEFAULT 'PENDIENTE',
+            status TEXT NOT NULL DEFAULT 'PENDING',
             recurrence TEXT DEFAULT NULL,
             created_at REAL NOT NULL,
             updated_at REAL NOT NULL
@@ -1028,6 +1028,21 @@ def _m12_session_checkpoints(conn):
 
 
 # Migration registry — APPEND ONLY, never reorder or delete
+def _m13_normalize_statuses(conn):
+    """Normalize dirty statuses and standardize to English.
+
+    Historical bug: complete handlers appended dates to status ('COMPLETED 2026-03-28').
+    This migration cleans all dirty statuses and normalizes Spanish→English for new installs.
+    Existing queries use LIKE 'COMPLET%' to match both languages during transition.
+    """
+    # Clean dirty statuses (date appended)
+    conn.execute("UPDATE followups SET status='COMPLETED' WHERE status LIKE 'COMPLETADO %' OR status = 'COMPLETADO'")
+    conn.execute("UPDATE reminders SET status='COMPLETED' WHERE status LIKE 'COMPLETADO %' OR status = 'COMPLETADO'")
+    # Normalize pending
+    conn.execute("UPDATE followups SET status='PENDING' WHERE status = 'PENDIENTE' OR status LIKE 'PENDIENTE%'")
+    conn.execute("UPDATE reminders SET status='PENDING' WHERE status = 'PENDIENTE' OR status LIKE 'PENDIENTE%'")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -1041,6 +1056,7 @@ MIGRATIONS = [
     (10, "diary_archive", _m10_diary_archive),
     (11, "core_rules", _m11_core_rules),
     (12, "session_checkpoints", _m12_session_checkpoints),
+    (13, "normalize_statuses", _m13_normalize_statuses),
 ]
 
 
@@ -1396,7 +1412,7 @@ def _expire_old_questions(conn: sqlite3.Connection):
 # ── Reminders ──────────────────────────────────────────────────────
 
 def create_reminder(id: str, description: str, date: str = None,
-                    status: str = 'PENDIENTE', category: str = 'general') -> dict:
+                    status: str = 'PENDING', category: str = 'general') -> dict:
     """Create a new reminder."""
     conn = get_db()
     now = now_epoch()
@@ -1435,7 +1451,7 @@ def update_reminder(id: str, **kwargs) -> dict:
 def complete_reminder(id: str) -> dict:
     """Mark a reminder as completed with today's date."""
     today = datetime.date.today().isoformat()
-    return update_reminder(id, status=f"COMPLETADO {today}")
+    return update_reminder(id, status=f"COMPLETED {today}")
 
 
 def delete_reminder(id: str) -> bool:
@@ -1453,18 +1469,18 @@ def get_reminders(filter_type: str = 'all') -> list[dict]:
     today = datetime.date.today().isoformat()
     if filter_type == 'completed':
         rows = conn.execute(
-            "SELECT * FROM reminders WHERE status LIKE 'COMPLETADO%' ORDER BY updated_at DESC"
+            "SELECT * FROM reminders WHERE status LIKE 'COMPLET%' ORDER BY updated_at DESC"
         ).fetchall()
     elif filter_type == 'due':
         rows = conn.execute(
-            "SELECT * FROM reminders WHERE status NOT LIKE 'COMPLETADO%' "
+            "SELECT * FROM reminders WHERE status NOT LIKE 'COMPLET%' "
             "AND status != 'ELIMINADO' AND date IS NOT NULL AND date <= ? "
             "ORDER BY date ASC",
             (today,)
         ).fetchall()
     else:  # 'all' — active only
         rows = conn.execute(
-            "SELECT * FROM reminders WHERE status NOT LIKE 'COMPLETADO%' "
+            "SELECT * FROM reminders WHERE status NOT LIKE 'COMPLET%' "
             "AND status != 'ELIMINADO' ORDER BY date ASC NULLS LAST"
         ).fetchall()
     return [dict(r) for r in rows]
@@ -1480,7 +1496,7 @@ def get_reminder(id: str) -> dict | None:
 # ── Followups ──────────────────────────────────────────────────────
 
 def create_followup(id: str, description: str, date: str = None,
-                    verification: str = '', status: str = 'PENDIENTE',
+                    verification: str = '', status: str = 'PENDING',
                     reasoning: str = '', recurrence: str = None) -> dict:
     """Create a new followup with optional reasoning and recurrence.
 
@@ -1579,7 +1595,7 @@ def complete_followup(id: str, result: str = '') -> dict:
         return {"error": f"Followup {id} not found"}
 
     today = datetime.date.today().isoformat()
-    kwargs = {"status": f"COMPLETADO {today}"}
+    kwargs = {"status": f"COMPLETED {today}"}
     if result:
         existing = row["verification"] or ''
         kwargs["verification"] = f"{existing}\n{result}".strip() if existing else result
@@ -1623,18 +1639,18 @@ def get_followups(filter_type: str = 'all') -> list[dict]:
     today = datetime.date.today().isoformat()
     if filter_type == 'completed':
         rows = conn.execute(
-            "SELECT * FROM followups WHERE status LIKE 'COMPLETADO%' ORDER BY updated_at DESC"
+            "SELECT * FROM followups WHERE status LIKE 'COMPLET%' ORDER BY updated_at DESC"
         ).fetchall()
     elif filter_type == 'due':
         rows = conn.execute(
-            "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETADO%' "
+            "SELECT * FROM followups WHERE status NOT LIKE 'COMPLET%' "
             "AND status != 'ELIMINADO' AND date IS NOT NULL AND date <= ? "
             "ORDER BY date ASC",
             (today,)
         ).fetchall()
     else:  # 'all' — active only
         rows = conn.execute(
-            "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETADO%' "
+            "SELECT * FROM followups WHERE status NOT LIKE 'COMPLET%' "
             "AND status != 'ELIMINADO' ORDER BY date ASC NULLS LAST"
         ).fetchall()
     return [dict(r) for r in rows]
@@ -2478,7 +2494,7 @@ def diary_archive_search(query: str = '', domain: str = '',
 
     Args:
         query: Text to search in summary, decisions, mental_state, pending
-        domain: Filter by domain (e.g. 'wazion', 'my-store')
+        domain: Filter by domain (e.g. 'my-project', 'my-store')
         year: Filter by year (e.g. 2026)
         month: Filter by month (1-12), requires year
         limit: Max results (default 20)

package/src/evolution_cycle.py

@@ -1,7 +1,7 @@
 """NEXO Evolution Cycle — Self-improvement via Opus API.
 
 Runs weekly after DMN. Analyzes patterns, proposes improvements.
-v1: observe-only (all proposals logged as 'proposed' for the owner to review).
+v1: observe-only (all proposals logged as 'proposed' for the user to review).
 v1.1 (future): sandbox execution of auto-approved changes.
 """
 
@@ -14,9 +14,9 @@ import time
 from datetime import datetime, date, timedelta
 from pathlib import Path
 
-NEXO_DB = Path.home() / "claude" / "nexo-mcp" / "nexo.db"
+NEXO_DB = Path.home() / ".nexo" / "nexo-mcp" / "nexo.db"
 CORTEX_DIR = Path(__file__).parent
-CLAUDE_DIR = Path.home() / "claude"
+CLAUDE_DIR = Path.home() / ".nexo"
 SANDBOX_DIR = CLAUDE_DIR / "sandbox" / "workspace"
 SNAPSHOTS_DIR = CLAUDE_DIR / "snapshots"
 OBJECTIVE_FILE = CORTEX_DIR / "evolution-objective.json"
@@ -162,97 +162,75 @@ def dry_run_restore_test() -> bool:
 
 
 def build_evolution_prompt(week_data: dict, objective: dict) -> str:
-    """Build the prompt for the Opus Evolution cycle."""
-    if PROMPT_FILE.exists():
-        template = PROMPT_FILE.read_text()
-    else:
-        template = "You are NEXO Evolution. Analyze the data and propose improvements."
-
-    prompt = template + "\n\n## WEEKLY DATA\n\n"
-    prompt += f"### Learnings ({len(week_data.get('learnings', []))} this week)\n"
-    for l in week_data.get("learnings", [])[:30]:
-        prompt += f"- [{l['category']}] {l['title']}: {str(l['content'])[:150]}\n"
-
-    prompt += f"\n### Decisions ({len(week_data.get('decisions', []))} this week)\n"
-    for d in week_data.get("decisions", [])[:15]:
-        outcome = f" → {str(d['outcome'])[:80]}" if d.get("outcome") else " → no outcome yet"
-        prompt += f"- [{d['domain']}] {str(d['decision'])[:150]}{outcome}\n"
-
-    prompt += f"\n### Changes ({len(week_data.get('changes', []))} this week)\n"
-    for c in week_data.get("changes", [])[:20]:
-        prompt += f"- {str(c['files'])[:60]}: {str(c['what_changed'])[:100]}\n"
-
-    prompt += f"\n### Session Diaries ({len(week_data.get('diaries', []))} this week)\n"
-    for s in week_data.get("diaries", [])[:10]:
-        prompt += f"- [{s.get('domain','')}] {str(s['summary'])[:150]}\n"
-        if s.get("user_signals"):
-            prompt += f"  the owner: {str(s['user_signals'])[:100]}\n"
-
-    prompt += "\n### Current Dimension Scores\n"
-    for dim, m in week_data.get("current_metrics", {}).items():
-        prompt += f"- {dim}: {m['score']}% (delta: {m.get('delta', 0)})\n"
-
-    prompt += f"\n### Evolution History ({len(week_data.get('evolution_history', []))} entries)\n"
-    for h in week_data.get("evolution_history", [])[:10]:
-        prompt += f"- #{h['id']} [{h['status']}] {str(h['proposal'])[:100]}\n"
-
-    prompt += f"\n### Objective\n{json.dumps(objective, indent=2)}\n"
-
-    # Guard stats — error prevention effectiveness
-    try:
-        guard_conn = sqlite3.connect(str(NEXO_DB), timeout=10)
-        cutoff_7d = (date.today() - timedelta(days=7)).isoformat()
-        cutoff_epoch_7d = time.time() - 7 * 86400
-
-        total_reps = guard_conn.execute(
-            "SELECT COUNT(*) FROM error_repetitions WHERE created_at > ?", (cutoff_7d,)
-        ).fetchone()[0]
-        new_learnings_7d = guard_conn.execute(
-            "SELECT COUNT(*) FROM learnings WHERE created_at > ?", (cutoff_epoch_7d,)
-        ).fetchone()[0]
-        rep_rate = round(total_reps / new_learnings_7d, 2) if new_learnings_7d > 0 else 0.0
-        guard_checks = guard_conn.execute(
-            "SELECT COUNT(*) FROM guard_checks WHERE created_at > ?", (cutoff_7d,)
-        ).fetchone()[0]
-
-        top_areas = guard_conn.execute(
-            "SELECT area, COUNT(*) as cnt FROM error_repetitions WHERE created_at > ? GROUP BY area ORDER BY cnt DESC LIMIT 5",
-            (cutoff_7d,)
-        ).fetchall()
-
-        most_ignored = guard_conn.execute(
-            "SELECT original_learning_id, COUNT(*) as cnt FROM error_repetitions "
-            "GROUP BY original_learning_id HAVING cnt >= 3 ORDER BY cnt DESC LIMIT 5"
-        ).fetchall()
-
-        guard_conn.close()
-
-        prompt += "\n### Guard Stats (Error Prevention)\n"
-        prompt += f"- Repetition rate: {rep_rate:.0%} (target: <15%)\n"
-        prompt += f"- Guard checks this week: {guard_checks} (target: >5/session)\n"
-        prompt += f"- New learnings: {new_learnings_7d}, Repetitions: {total_reps}\n"
-        if top_areas:
-            prompt += "- Top problem areas: " + ", ".join(f"{r[0]}({r[1]})" for r in top_areas) + "\n"
-        if most_ignored:
-            prompt += "- Most ignored learnings (3+ repeats): " + ", ".join(f"#{r[0]}({r[1]}x)" for r in most_ignored) + "\n"
-        prompt += "- Propose more aggressive rules for areas with high repetition rate.\n"
-    except Exception:
-        pass
-
-    # Infrastructure inventory — so Opus knows what exists before proposing changes
-    inventory_script = Path.home() / "claude" / "scripts" / "nexo-infra-inventory.sh"
-    if inventory_script.exists():
-        try:
-            result = subprocess.run(
-                ["bash", str(inventory_script)],
-                capture_output=True, text=True, timeout=10
-            )
-            if result.stdout.strip():
-                prompt += f"\n### Infrastructure Inventory (hooks, scripts, memory, crons)\n"
-                prompt += "Before proposing any change, check this inventory to avoid duplicating existing infrastructure.\n"
-                prompt += f"```json\n{result.stdout.strip()}\n```\n"
-        except Exception:
-            pass
+    """Build a SHORT prompt — CLI investigates on its own using tools."""
+
+    # Summary stats only — CLI will dig deeper with tools
+    stats = {
+        "learnings_this_week": len(week_data.get("learnings", [])),
+        "decisions_this_week": len(week_data.get("decisions", [])),
+        "changes_this_week": len(week_data.get("changes", [])),
+        "diaries_this_week": len(week_data.get("diaries", [])),
+        "evolution_history": len(week_data.get("evolution_history", [])),
+        "current_scores": {dim: m["score"] for dim, m in week_data.get("current_metrics", {}).items()},
+    }
+
+    mode = objective.get("evolution_mode", "auto")
+    total = objective.get("total_evolutions", 0)
+    max_auto = max_auto_changes(total)
+
+    prompt = f"""You are NEXO Evolution — the weekly self-improvement cycle.
+
+YOUR JOB: Analyze the past week and propose concrete improvements to NEXO's codebase.
+
+WEEK SUMMARY:
+- {stats['learnings_this_week']} new learnings
+- {stats['decisions_this_week']} decisions made
+- {stats['changes_this_week']} code changes deployed
+- {stats['diaries_this_week']} session diaries
+- {stats['evolution_history']} past evolution proposals
+- Current scores: {json.dumps(stats['current_scores'])}
+
+MODE: {mode} ({"proposals only, owner reviews" if mode == "review" else f"max {max_auto} auto-applied changes"})
+CYCLE: #{total + 1}
+
+INVESTIGATE using these tools:
+1. Bash: sqlite3 {NEXO_DB} "SELECT category, title FROM learnings WHERE created_at > {time.time() - 7*86400} ORDER BY created_at DESC LIMIT 30"
+2. Bash: sqlite3 {NEXO_DB} "SELECT area, COUNT(*) as cnt FROM error_repetitions GROUP BY area ORDER BY cnt DESC LIMIT 10"
+3. Read ~/.nexo/coordination/daily-synthesis.md — today's context
+4. Read ~/.nexo/coordination/postmortem-daily.md — self-critique patterns
+5. Read ~/.nexo/logs/self-audit-summary.json — system health
+6. Glob ~/.nexo/scripts/*.py — existing scripts
+7. Glob ~/.nexo/nexo-mcp/plugins/*.py — existing plugins
+
+LOOK FOR:
+- Repeated errors that guard isn't preventing
+- Scripts or processes that are failing or underperforming
+- Missing functionality that session diaries keep asking for
+- Redundant code or config that could be simplified
+- Patterns in self-critique that suggest systemic issues
+
+SAFETY:
+- Safe zones for auto changes: ~/.nexo/scripts/, ~/.nexo/nexo-mcp/plugins/, ~/.nexo/cortex/
+- IMMUTABLE files (never touch): db.py, server.py, plugin_loader.py, cognitive.py, CLAUDE.md
+- Every change needs: what file, what to change, why, risk, how to verify
+
+OUTPUT FORMAT (JSON):
+{{
+  "analysis": "one paragraph summary of what you found",
+  "patterns": [{{"type": "...", "description": "...", "frequency": "..."}}],
+  "proposals": [
+    {{
+      "classification": "auto" or "propose",
+      "dimension": "reliability|proactivity|efficiency|safety|learning",
+      "action": "what to do",
+      "reasoning": "why",
+      "scope": "local",
+      "changes": [{{"file": "path", "operation": "create|replace|append", "search": "text to find", "content": "new text"}}]
+    }}
+  ]
+}}
+
+Max 3 proposals. Quality over quantity. If nothing needs improving, say so."""
 
     return prompt
 

package/src/hooks/session-start.sh

@@ -1,4 +1,7 @@
 #!/bin/bash
+
+# Write session start timestamp for session-scoped tool counting
+date +%s > "${NEXO_HOME:-$HOME/.nexo}/operations/.session-start-ts"
 # NEXO SessionStart hook — generates a comprehensive briefing.
 # Reads SQLite directly for reminders, followups, active sessions.
 # Caches output for 1 hour to avoid regenerating on rapid successive sessions.
@@ -61,7 +64,7 @@ try:
         try:
             reminders_rows = [dict(r) for r in db.execute(
                 'SELECT id, date, description, status, category FROM reminders '
-                'WHERE status NOT LIKE \"%COMPLETADO%\" AND status NOT LIKE \"%ELIMINADO%\" '
+                'WHERE status NOT LIKE \"%COMPLET%\" AND status NOT LIKE \"%DELET%\" '
                 'AND status NOT LIKE \"%COMPLETED%\" AND status NOT LIKE \"%DELETED%\"'
             ).fetchall()]
         except Exception:
@@ -70,7 +73,7 @@ try:
         try:
             followups_rows = [dict(r) for r in db.execute(
                 'SELECT id, date, description, status FROM followups '
-                'WHERE status NOT LIKE \"%COMPLETADO%\" AND status NOT LIKE \"%COMPLETED%\"'
+                'WHERE status NOT LIKE \"%COMPLET%\" AND status NOT LIKE \"%COMPLETED%\"'
             ).fetchall()]
         except Exception:
             pass