nexo-brain 0.8.8 → 0.8.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "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,13 +30,13 @@ DISCRIMINATING_ENTITIES = {
     # OS / Environment
     "linux", "mac", "macos", "windows", "darwin", "ubuntu", "debian", "alpine",
     # Platforms
-    "shopify", "whatsapp", "chrome", "firefox",
+    "shopify", "wazion", "canarirural", "recambios", "whatsapp", "chrome", "firefox",
     # Languages / Runtimes
     "python", "php", "javascript", "typescript", "node", "deno", "ruby",
     # Versions
     "v1", "v2", "v3", "v4", "v5", "5.6", "7.4", "8.0", "8.1", "8.2",
     # Infrastructure
-    "cloudrun", "gcloud", "vps", "local", "production", "staging",
+    "mundiserver", "cloudrun", "gcloud", "vps", "local", "production", "staging",
     # DB
     "mysql", "sqlite", "postgresql", "postgres", "redis",
 }
@@ -65,12 +65,12 @@ URGENCY_SIGNALS = {
 _DEFAULT_TRUST_EVENTS = {
     # Positive
     "explicit_thanks": +3,
-    "delegation": +2,        # User delegates new task without micromanaging
-    "paradigm_shift": +2,    # User teaches, NEXO learns
+    "delegation": +2,        # Francisco delegates new task without micromanaging
+    "paradigm_shift": +2,    # Francisco teaches, NEXO learns
     "sibling_detected": +3,  # NEXO avoided context error on its own
     "proactive_action": +2,  # NEXO did something useful without being asked
     # Negative
-    "correction": -3,        # User corrects NEXO
+    "correction": -3,        # Francisco corrects NEXO
     "repeated_error": -7,    # Error on something NEXO already had a learning for
     "override": -5,          # NEXO's memory was wrong
     "correction_fatigue": -10, # Same memory corrected 3+ times
@@ -395,7 +395,7 @@ def _init_tables(conn: sqlite3.Connection):
             created_at TEXT DEFAULT (datetime('now'))
         );
 
-        -- Sentiment readings: User's detected mood per interaction
+        -- Sentiment readings: Francisco's detected mood per interaction
         CREATE TABLE IF NOT EXISTS sentiment_log (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             sentiment TEXT NOT NULL,       -- 'positive', 'negative', 'neutral', 'urgent'
@@ -421,13 +421,13 @@ def _init_tables(conn: sqlite3.Connection):
             status TEXT DEFAULT 'pending'
         );
 
-        -- Correction tracking: when User overrides a memory's guidance
+        -- Correction tracking: when Francisco overrides a memory's guidance
         CREATE TABLE IF NOT EXISTS memory_corrections (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             memory_id INTEGER NOT NULL,
             store TEXT NOT NULL,           -- 'stm' or 'ltm'
             correction_type TEXT NOT NULL, -- 'override', 'exception', 'paradigm_shift'
-            context TEXT DEFAULT '',       -- what User said
+            context TEXT DEFAULT '',       -- what Francisco said
             created_at TEXT DEFAULT (datetime('now'))
         );
     """)
@@ -2544,12 +2544,12 @@ def get_siblings(memory_id: int) -> list[dict]:
 def detect_dissonance(new_instruction: str, min_score: float = 0.65) -> list[dict]:
     """Detect cognitive dissonance: find LTM memories that contradict a new instruction.
 
-    When User gives a new instruction that conflicts with established LTM memories
+    When Francisco gives a new instruction that conflicts with established LTM memories
     (strength > 0.8), this function surfaces the conflict so NEXO can verbalize it
     rather than silently obeying or silently resisting.
 
     Args:
-        new_instruction: The new instruction or preference from User
+        new_instruction: The new instruction or preference from Francisco
         min_score: Minimum cosine similarity to consider as potential conflict
 
     Returns:
@@ -2584,12 +2584,12 @@ def detect_dissonance(new_instruction: str, min_score: float = 0.65) -> list[dic
 
 
 def resolve_dissonance(memory_id: int, resolution: str, context: str = "") -> str:
-    """Resolve a cognitive dissonance by applying User's decision.
+    """Resolve a cognitive dissonance by applying Francisco's decision.
 
     Args:
         memory_id: The LTM memory that conflicts with the new instruction
         resolution: One of:
-            - 'paradigm_shift': User changed his mind permanently. Decay old memory,
+            - 'paradigm_shift': Francisco changed his mind permanently. Decay old memory,
               new instruction becomes the standard.
             - 'exception': This is a one-time override. Keep old memory as standard.
             - 'override': Old memory was wrong. Mark as corrupted and decay to dormant.
@@ -2640,7 +2640,7 @@ def resolve_dissonance(memory_id: int, resolution: str, context: str = "") -> st
 def check_correction_fatigue() -> list[dict]:
     """Find memories corrected 3+ times in the last 7 days — mark as 'under review'.
 
-    These memories are unreliable: User keeps overriding them, suggesting
+    These memories are unreliable: Francisco keeps overriding them, suggesting
     the memory itself may be wrong or outdated.
 
     Returns:
@@ -2688,7 +2688,7 @@ def check_correction_fatigue() -> list[dict]:
 
 
 def detect_sentiment(text: str) -> dict:
-    """Analyze User's text for sentiment signals.
+    """Analyze Francisco's text for sentiment signals.
 
     Returns detected sentiment, intensity, and action guidance for NEXO.
     Not a model — keyword + heuristic based. Fast and deterministic.
@@ -2727,13 +2727,13 @@ def detect_sentiment(text: str) -> dict:
         sentiment = "negative"
         intensity = min(1.0, 0.3 + neg_score * 0.15)
         if intensity > 0.7:
-            guidance = "MODE: Ultra-conciso. Cero explicaciones. Resolver y mostrar resultado."
+            guidance = "MODE: Ultra-concise. Zero explanations. Resolve and show result."
         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)
-        guidance = "MODE: Normal. Buen momento para proponer ideas de backlog o mejoras."
+        guidance = "MODE: Normal. Good moment to propose backlog ideas or improvements."
     elif urgency_hits:
         sentiment = "urgent"
         intensity = 0.8
@@ -2752,7 +2752,7 @@ def detect_sentiment(text: str) -> dict:
 
 
 def log_sentiment(text: str) -> dict:
-    """Detect and log User's sentiment. Returns the detection result."""
+    """Detect and log Francisco's sentiment. Returns the detection result."""
     result = detect_sentiment(text)
     if result["sentiment"] != "neutral":
         db = _get_db()

package/src/db.py

@@ -437,7 +437,7 @@ _SYNONYMS = {
     "plantilla": ["template"],
     "template": ["plantilla"],
     "webhook": ["gancho"],
-    "cron": ["scheduled task", "scheduled"],
+    "cron": ["tarea programada", "scheduled"],
     "extension": ["extensión", "plugin", "addon"],
     "plugin": ["extension", "extensión"],
 }
@@ -1012,24 +1012,31 @@ def register_session(sid: str, task: str) -> dict:
     return {"sid": sid, "task": task}
 
 
-def update_session(sid: str, task: str) -> dict:
-    """Update session task and timestamp. Preserves started_epoch."""
+def update_session(sid: str, task: str | None) -> dict:
+    """Update session timestamp (and task if provided). Preserves started_epoch.
+
+    Args:
+        sid: Session ID.
+        task: New task description, or None to keep current task (keepalive touch).
+    """
     conn = get_db()
     now = now_epoch()
-    row = conn.execute("SELECT started_epoch FROM sessions WHERE sid = ?", (sid,)).fetchone()
+    row = conn.execute("SELECT started_epoch, task FROM sessions WHERE sid = ?", (sid,)).fetchone()
     if row:
+        effective_task = task if task is not None else row["task"]
         conn.execute(
             "UPDATE sessions SET task = ?, last_update_epoch = ?, local_time = ? WHERE sid = ?",
-            (task, now, local_time_str(), sid)
+            (effective_task, now, local_time_str(), sid)
         )
     else:
+        effective_task = task or "Unknown"
         conn.execute(
             "INSERT INTO sessions (sid, task, started_epoch, last_update_epoch, local_time) "
             "VALUES (?, ?, ?, ?, ?)",
-            (sid, task, now, now, local_time_str())
+            (sid, effective_task, now, now, local_time_str())
         )
     conn.commit()
-    return {"sid": sid, "task": task}
+    return {"sid": sid, "task": effective_task}
 
 
 def complete_session(sid: str):

package/src/plugins/agents.py

@@ -5,10 +5,10 @@ def handle_agent_get(id: str) -> str:
     """Get an agent's full profile by ID."""
     a = get_agent(id)
     if not a: return f"Agent '{id}' not found."
-    lines = [f"AGENTE: {a['name']} ({a['id']})", f"  Especialización: {a['specialization']}", f"  Modelo: {a['model']}"]
+    lines = [f"AGENT: {a['name']} ({a['id']})", f"  Specialization: {a['specialization']}", f"  Model: {a['model']}"]
     if a["tools"]: lines.append(f"  Tools: {a['tools']}")
-    if a["context_files"]: lines.append(f"  Contexto: {a['context_files']}")
-    if a["rules"]: lines.append(f"  Reglas: {a['rules']}")
+    if a["context_files"]: lines.append(f"  Context: {a['context_files']}")
+    if a["rules"]: lines.append(f"  Rules: {a['rules']}")
     return "\n".join(lines)
 
 def handle_agent_create(id: str, name: str, specialization: str, model: str = "sonnet",
@@ -31,8 +31,8 @@ def handle_agent_update(id: str, name: str = "", specialization: str = "", model
 def handle_agent_list() -> str:
     """List all registered agents."""
     agents = list_agents()
-    if not agents: return "No agents registered."
-    lines = ["AGENTES REGISTRADOS:"]
+    if not agents: return "No registered agents."
+    lines = ["REGISTERED AGENTS:"]
     for a in agents:
         lines.append(f"  {a['id']} — {a['name']} ({a['model']}) — {a['specialization'][:60]}")
     return "\n".join(lines)

package/src/plugins/backup.py

@@ -33,10 +33,10 @@ def handle_backup_now() -> str:
 def handle_backup_list() -> str:
     """List available backups with dates and sizes."""
     if not os.path.isdir(BACKUP_DIR):
-        return "No backups found."
+        return "No backups."
     files = sorted(glob.glob(os.path.join(BACKUP_DIR, "nexo-*.db")), reverse=True)
     if not files:
-        return "No backups found."
+        return "No backups."
     lines = [f"BACKUPS ({len(files)}):"]
     total_size = 0
     for f in files:

package/src/plugins/cognitive_memory.py

@@ -222,13 +222,13 @@ def handle_cognitive_metrics(days: int = 7) -> str:
 
 
 def handle_cognitive_sentiment(text: str) -> str:
-    """Detect the user's sentiment from his text. Returns mood, intensity, and guidance.
+    """Detect Francisco's sentiment from his text. Returns mood, intensity, and guidance.
 
-    Call this with the user's recent message to adapt NEXO's tone and behavior.
+    Call this with Francisco's recent message to adapt NEXO's tone and behavior.
     Also logs the sentiment for historical tracking.
 
     Args:
-        text: the user's recent message or instruction
+        text: Francisco's recent message or instruction
     """
     result = cognitive.log_sentiment(text)
     trust = cognitive.get_trust_score()
@@ -294,8 +294,8 @@ def handle_cognitive_trust(event: str = '', context: str = '', delta: float = No
 def handle_cognitive_dissonance(instruction: str, force: bool = False) -> str:
     """Detect cognitive dissonance: find established memories that conflict with a new instruction.
 
-    Use BEFORE applying a new preference or rule from the user that might contradict
-    existing knowledge. If conflicts found, verbalize them and ask the user to resolve.
+    Use BEFORE applying a new preference or rule from Francisco that might contradict
+    existing knowledge. If conflicts found, verbalize them and ask Francisco to resolve.
 
     Args:
         instruction: The new instruction or preference to check against LTM
@@ -328,7 +328,7 @@ def handle_cognitive_dissonance(instruction: str, force: bool = False) -> str:
         lines.append("")
 
     lines.append("RESOLVE with nexo_cognitive_resolve, or use force=True to skip:")
-    lines.append("  - 'paradigm_shift': the user changed his mind permanently.")
+    lines.append("  - 'paradigm_shift': Francisco changed his mind permanently.")
     lines.append("  - 'exception': One-time override. Old memory stays.")
     lines.append("  - 'override': Old memory was wrong.")
 
@@ -336,7 +336,7 @@ def handle_cognitive_dissonance(instruction: str, force: bool = False) -> str:
 
 
 def handle_cognitive_resolve(memory_id: int, resolution: str, context: str = '') -> str:
-    """Resolve a cognitive dissonance by applying the user's decision.
+    """Resolve a cognitive dissonance by applying Francisco's decision.
 
     Args:
         memory_id: The LTM memory ID from the dissonance detection
@@ -546,7 +546,7 @@ TOOLS = [
     (handle_cognitive_metrics, "nexo_cognitive_metrics", "Performance metrics: retrieval relevance %, repeat error rate, multilingual recommendation (spec section 9)"),
     (handle_cognitive_dissonance, "nexo_cognitive_dissonance", "Detect conflicts between a new instruction and established LTM memories. force=True to skip discussion."),
     (handle_cognitive_resolve, "nexo_cognitive_resolve", "Resolve a cognitive dissonance: paradigm_shift, exception, or override."),
-    (handle_cognitive_sentiment, "nexo_cognitive_sentiment", "Detect the user's sentiment and get tone guidance. Also logs for tracking."),
+    (handle_cognitive_sentiment, "nexo_cognitive_sentiment", "Detect Francisco's sentiment and get tone guidance. Also logs for tracking."),
     (handle_cognitive_trust, "nexo_cognitive_trust", "View or adjust trust score (0-100). Without args: view. With event: adjust."),
     (handle_cognitive_pin, "nexo_cognitive_pin", "Pin a memory — never decays, boosted +0.2 in search results."),
     (handle_cognitive_snooze, "nexo_cognitive_snooze", "Snooze a memory — hidden from searches until a date, then auto-restores."),

package/src/plugins/entities.py

@@ -21,7 +21,7 @@ def handle_entity_create(name: str, type: str, value: str, notes: str = "") -> s
         on_entity_create(eid, name, type)
     except Exception:
         pass
-    return f"Entidad creada: [{eid}] {name} ({type})"
+    return f"Entity created: [{eid}] {name} ({type})"
 
 def handle_entity_update(id: int, name: str = "", type: str = "", value: str = "", notes: str = "") -> str:
     """Update an entity. Only non-empty fields are changed."""
@@ -30,21 +30,21 @@ def handle_entity_update(id: int, name: str = "", type: str = "", value: str = "
     if type: kwargs["type"] = type
     if value: kwargs["value"] = value
     if notes: kwargs["notes"] = notes
-    if not kwargs: return "Nada que actualizar."
+    if not kwargs: return "Nothing to update."
     update_entity(id, **kwargs)
-    return f"Entidad [{id}] actualizada."
+    return f"Entity [{id}] updated."
 
 def handle_entity_delete(id: int) -> str:
     """Delete an entity."""
     if not delete_entity(id):
         return f"ERROR: Entity [{id}] not found."
-    return f"Entidad [{id}] eliminada."
+    return f"Entity [{id}] deleted."
 
 def handle_entity_list(type: str = "") -> str:
     """List all entities, optionally filtered by type."""
     results = list_entities(type)
     if not results:
-        return "No entities found."
+        return "No entities."
     grouped = {}
     for e in results:
         t = e["type"]

package/src/plugins/episodic_memory.py

@@ -27,7 +27,7 @@ def handle_decision_log(domain: str, decision: str, alternatives: str = '',
     """Log a non-trivial decision with reasoning context.
 
     Args:
-        domain: Area (ads, shopify, server, nexo, other)
+        domain: Area (ads, shopify, server, wazion, nexo, canarirural, other)
         decision: What was decided
         alternatives: JSON array or text of options considered and why discarded
         based_on: Data, metrics, or observations that informed this decision
@@ -35,7 +35,7 @@ def handle_decision_log(domain: str, decision: str, alternatives: str = '',
         context_ref: Related followup/reminder ID (e.g., NF-ADS1, R71)
         session_id: Current session ID (auto-filled if empty)
     """
-    valid_domains = {'ads', 'shopify', 'server', 'nexo', 'other'}
+    valid_domains = {'ads', 'shopify', 'server', 'wazion', 'nexo', 'canarirural', 'other'}
     if domain not in valid_domains:
         return f"ERROR: domain debe ser uno de: {', '.join(sorted(valid_domains))}"
     if confidence not in ('high', 'medium', 'low'):
@@ -65,7 +65,7 @@ def handle_decision_log(domain: str, decision: str, alternatives: str = '',
     result = dict(conn.execute("SELECT * FROM decisions WHERE id = ?", (result["id"],)).fetchone())
     due = result.get("review_due_at", "")
     due_str = f" review_due={due}" if due else ""
-    return f"Decision #{result['id']} registrada [{domain}] ({confidence}): {decision[:80]}{due_str}"
+    return f"Decision #{result['id']} logged [{domain}] ({confidence}): {decision[:80]}{due_str}"
 
 
 def handle_decision_outcome(id: int, outcome: str) -> str:
@@ -84,7 +84,7 @@ def handle_decision_outcome(id: int, outcome: str) -> str:
         (id,)
     )
     conn.commit()
-    return f"Decision #{id} outcome registrado: {outcome[:100]}"
+    return f"Decision #{id} outcome recorded: {outcome[:100]}"
 
 
 def handle_decision_search(query: str = '', domain: str = '', days: int = 30) -> str:
@@ -92,16 +92,16 @@ def handle_decision_search(query: str = '', domain: str = '', days: int = 30) ->
 
     Args:
         query: Text to search in decision, alternatives, based_on, outcome
-        domain: Filter by area (ads, shopify, server, nexo, other)
+        domain: Filter by area (ads, shopify, server, wazion, nexo, canarirural, other)
         days: Look back N days (default 30)
     """
-    valid_domains = {'ads', 'shopify', 'server', 'nexo', 'other'}
+    valid_domains = {'ads', 'shopify', 'server', 'wazion', 'nexo', 'canarirural', 'other'}
     if domain and domain not in valid_domains:
         return f"ERROR: domain debe ser uno de: {', '.join(sorted(valid_domains))}"
     results = search_decisions(query, domain, days)
     if not results:
         scope = f"'{query}'" if query else domain or 'todas'
-        return f"Sin decisiones encontradas para {scope} in {days} days."
+        return f"No decisions found for {scope} in {days} days."
 
     lines = [f"DECISIONES ({len(results)}):"]
     for d in results:
@@ -113,9 +113,9 @@ def handle_decision_search(query: str = '', domain: str = '', days: int = 30) ->
         lines.append(f"  #{d['id']} ({d['created_at']}) [{d['domain']}] {conf} [{status}]{ref}{review_due}")
         lines.append(f"    {d['decision'][:120]}")
         if d.get('based_on'):
-            lines.append(f"    Basado en: {d['based_on'][:100]}")
+            lines.append(f"    Based on: {d['based_on'][:100]}")
         if d.get('alternatives'):
-            lines.append(f"    Alternativas: {d['alternatives'][:100]}")
+            lines.append(f"    Alternatives: {d['alternatives'][:100]}")
         if outcome_str:
             lines.append(f"    Outcome:{outcome_str}")
     return "\n".join(lines)
@@ -163,7 +163,7 @@ def handle_memory_review_queue(days: int = 0) -> str:
 def handle_session_diary_write(decisions: str, summary: str,
                                 discarded: str = '', pending: str = '',
                                 context_next: str = '', mental_state: str = '',
-                                user_signals: str = '',
+                                francisco_signals: str = '',
                                 domain: str = '',
                                 session_id: str = '',
                                 self_critique: str = '') -> str:
@@ -176,16 +176,16 @@ def handle_session_diary_write(decisions: str, summary: str,
         pending: Items left unresolved, with doubt level
         context_next: What the next session should know to continue effectively
         mental_state: Internal state to transfer — thread of thought, tone, observations not yet shared, momentum. Written in first person as NEXO.
-        user_signals: Observable signals from User during session — response speed (fast='s' vs detailed explanations), tone (direct, frustrated, exploratory, excited), corrections given, topics he initiated vs topics NEXO initiated. Factual observations only, not interpretations.
-        domain: Project context: project-a, project-b, nexo, server, other
+        francisco_signals: Observable signals from Francisco during session — response speed (fast='s' vs detailed explanations), tone (direct, frustrated, exploratory, excited), corrections given, topics he initiated vs topics NEXO initiated. Factual observations only, not interpretations.
+        domain: Project context: recambios, wazion, nexo, canarirural, server, other
         session_id: Current session ID
-        self_critique: OBLIGATORIO. Post-mortem honesto: ¿Qué debí hacer proactivamente? ¿User tuvo que pedirme algo que yo debería haber detectado? ¿Repetí errores conocidos? ¿Qué regla concreta evitaría la repetición? Si sesión limpia: 'Sin autocrítica — sesión limpia.'
+        self_critique: MANDATORY. Honest post-mortem: What should I have done proactively? Did Francisco ask for something I should have detected? Did I repeat known errors? What concrete rule would prevent the recurrence? If clean session: 'No self-critique — clean session.'
     """
     sid = session_id or 'unknown'
     # Clean up draft — manual diary supersedes it
     from db import delete_diary_draft
     delete_diary_draft(sid)
-    result = write_session_diary(sid, decisions, summary, discarded, pending, context_next, mental_state, domain=domain, user_signals=user_signals, self_critique=self_critique)
+    result = write_session_diary(sid, decisions, summary, discarded, pending, context_next, mental_state, domain=domain, user_signals=francisco_signals, self_critique=self_critique)
     if "error" in result:
         return f"ERROR: {result['error']}"
     _cognitive_ingest_safe(summary, "diary", f"diary#{result.get('id','')}", f"Session {sid} summary", domain)
@@ -194,7 +194,7 @@ def handle_session_diary_write(decisions: str, summary: str,
     if mental_state and mental_state.strip():
         _cognitive_ingest_safe(mental_state, "mental_state", f"diary#{result.get('id','')}", f"Session {sid} state", domain)
     domain_str = f" [{domain}]" if domain else ""
-    msg = f"Diario sesión #{result['id']}{domain_str} guardado: {summary[:80]}"
+    msg = f"Session diary #{result['id']}{domain_str} saved: {summary[:80]}"
 
     # Trust score & sentiment summary for session diary
     try:
@@ -215,14 +215,14 @@ def handle_session_diary_write(decisions: str, summary: str,
         "SELECT COUNT(*) FROM change_log WHERE (commit_ref IS NULL OR commit_ref = '')"
     ).fetchone()[0]
     if orphan_changes > 0:
-        warnings.append(f"{orphan_changes} changes sin commit_ref")
+        warnings.append(f"{orphan_changes} changes without commit_ref")
     orphan_decisions = conn.execute(
         "SELECT COUNT(*) FROM decisions WHERE (outcome IS NULL OR outcome = '') AND created_at < datetime('now', '-7 days')"
     ).fetchone()[0]
     if orphan_decisions > 0:
-        warnings.append(f"{orphan_decisions} decisions >7d sin outcome")
+        warnings.append(f"{orphan_decisions} decisions >7d without outcome")
     if warnings:
-        msg += "\n⚠ EPISODIC GAPS: " + " | ".join(warnings) + " — resolver antes de cerrar sesión."
+        msg += "\n⚠ EPISODIC GAPS: " + " | ".join(warnings) + " — resolve before closing session."
 
     return msg
 
@@ -235,29 +235,29 @@ def handle_session_diary_read(session_id: str = '', last_n: int = 3, last_day: b
         session_id: Specific session ID to read (optional)
         last_n: Number of recent entries to return (default 3)
         last_day: If true, returns ALL entries from the most recent day (multi-terminal aware). Use this at startup.
-        domain: Filter by project context: project-a, project-b, nexo, server, other
+        domain: Filter by project context: recambios, wazion, nexo, canarirural, server, other
     """
     results = read_session_diary(session_id, last_n, last_day, domain)
     if not results:
-        return "Sin entradas en el diario de sesiones."
+        return "No entries in the session diary."
 
-    lines = [f"DIARIO DE SESIONES ({len(results)}):"]
+    lines = [f"SESSION DIARY ({len(results)}):"]
     for d in results:
         domain_label = f" [{d['domain']}]" if d.get('domain') else ""
-        lines.append(f"\n  --- Sesión {d['session_id']}{domain_label} ({d['created_at']}) ---")
-        lines.append(f"  Resumen: {d['summary']}")
+        lines.append(f"\n  --- Session {d['session_id']}{domain_label} ({d['created_at']}) ---")
+        lines.append(f"  Summary: {d['summary']}")
         if d.get('decisions'):
-            lines.append(f"  Decisiones: {d['decisions'][:200]}")
+            lines.append(f"  Decisions: {d['decisions'][:200]}")
         if d.get('discarded'):
-            lines.append(f"  Descartado: {d['discarded'][:150]}")
+            lines.append(f"  Discarded: {d['discarded'][:150]}")
         if d.get('pending'):
-            lines.append(f"  Pendiente: {d['pending'][:150]}")
+            lines.append(f"  Pending: {d['pending'][:150]}")
         if d.get('context_next'):
-            lines.append(f"  Para siguiente sesión: {d['context_next'][:200]}")
+            lines.append(f"  For next session: {d['context_next'][:200]}")
         if d.get('mental_state'):
-            lines.append(f"  Estado mental: {d['mental_state'][:300]}")
-        if d.get('user_signals'):
-            lines.append(f"  Señales User: {d['user_signals'][:300]}")
+            lines.append(f"  Mental state: {d['mental_state'][:300]}")
+        if d.get('francisco_signals'):
+            lines.append(f"  Francisco signals: {d['francisco_signals'][:300]}")
     return "\n".join(lines)
 
 
@@ -271,7 +271,7 @@ def handle_change_log(files: str, what_changed: str, why: str,
         files: File path(s) modified (comma-separated if multiple)
         what_changed: What was modified — functions, lines, behavior change
         why: WHY this change was needed — the root cause, not just "fix bug"
-        triggered_by: What triggered this — bug report, metric, User's request, followup ID
+        triggered_by: What triggered this — bug report, metric, Francisco's request, followup ID
         affects: What systems/users/flows this change impacts
         risks: What could go wrong — regressions, edge cases, dependencies
         verify: How to verify this works — what to check, followup ID if created
@@ -295,9 +295,9 @@ def handle_change_log(files: str, what_changed: str, why: str,
         on_change_log(change_id, files, "")
     except Exception:
         pass
-    msg = f"Change #{change_id} registrado: {files[:60]} — {what_changed[:60]}"
+    msg = f"Change #{change_id} logged: {files[:60]} — {what_changed[:60]}"
     if not commit_ref:
-        msg += f"\n⚠ SIN COMMIT. Usa nexo_change_commit({change_id}, 'hash') después del push, o 'server-direct' si fue edición directa en servidor."
+        msg += f"\n⚠ NO COMMIT. Use nexo_change_commit({change_id}, 'hash') after push, or 'server-direct' if it was a direct server edit."
     return msg
 
 
@@ -319,8 +319,8 @@ def handle_change_search(query: str = '', files: str = '', days: int = 30) -> st
         commit = f" [{c['commit_ref'][:8]}]" if c.get('commit_ref') else ""
         lines.append(f"  #{c['id']} ({c['created_at']}){commit}")
         lines.append(f"    Archivos: {c['files'][:100]}")
-        lines.append(f"    Qué: {c['what_changed'][:120]}")
-        lines.append(f"    Por qué: {c['why'][:120]}")
+        lines.append(f"    What: {c['what_changed'][:120]}")
+        lines.append(f"    Why: {c['why'][:120]}")
         if c.get('triggered_by'):
             lines.append(f"    Trigger: {c['triggered_by'][:80]}")
         if c.get('affects'):
@@ -352,7 +352,7 @@ def handle_recall(query: str, days: int = 30) -> str:
     """
     results = recall(query, days)
     if not results:
-        return f"Sin resultados para '{query}' en los últimos {days} días."
+        return f"No results for '{query}' in the last {days} days."
 
     # v1.2: Passive rehearsal — strengthen matching cognitive memories
     try:
@@ -367,13 +367,13 @@ def handle_recall(query: str, days: int = 30) -> str:
     SOURCE_LABELS = {
         'change_log': '[CAMBIO]',
         'change':     '[CAMBIO]',
-        'decision':   '[DECISIÓN]',
+        'decision':   '[DECISION]',
         'learning':   '[LEARNING]',
         'followup':   '[FOLLOWUP]',
         'diary':      '[DIARIO]',
         'entity':     '[ENTIDAD]',
         'file':       '[ARCHIVO]',
-        'code':       '[CÓDIGO]',
+        'code':       '[CODE]',
     }
 
     lines = [f"RECALL '{query}' — {len(results)} resultado(s):"]
@@ -390,7 +390,7 @@ def handle_recall(query: str, days: int = 30) -> str:
         if snippet:
             lines.append(f"    {snippet}")
     if len(results) < 5:
-        lines.append(f"\n  💡 Solo {len(results)} resultados en NEXO. Para historial más profundo, busca también en claude-mem: mcp__plugin_claude-mem_mcp-search__search")
+        lines.append(f"\n  💡 Only {len(results)} results in NEXO. For deeper history, also search claude-mem: mcp__plugin_claude-mem_mcp-search__search")
     return "\n".join(lines)
 
 

package/src/plugins/evolution.py

@@ -1,11 +1,7 @@
 """Evolution plugin — NEXO self-improvement tools for interactive sessions."""
 
-import os
-from pathlib import Path
 from db import get_latest_metrics, get_evolution_history, update_evolution_log_status, get_db
 
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-
 
 def handle_evolution_status() -> str:
     """Show current NEXO dimension scores and recent trend."""
@@ -61,7 +57,8 @@ def handle_evolution_propose() -> str:
     This sets a flag that the Cortex wrapper reads on the next cycle.
     """
     import json
-    obj_file = NEXO_HOME / "cortex" / "evolution-objective.json"
+    from pathlib import Path
+    obj_file = Path.home() / "claude" / "cortex" / "evolution-objective.json"
     if not obj_file.exists():
         return "ERROR: evolution-objective.json not found"
     try:
@@ -80,10 +77,10 @@ def handle_evolution_approve(log_id: int, notes: str = '') -> str:
 
     Args:
         log_id: Evolution log entry ID to approve
-        notes: Optional notes
+        notes: Optional notes from Francisco
     """
     update_evolution_log_status(log_id, "accepted",
-                                test_result=f"Approved. {notes}".strip())
+                                test_result=f"Approved by Francisco. {notes}".strip())
     return f"Proposal #{log_id} APPROVED. Will be applied in next Evolution cycle."
 
 
@@ -95,7 +92,7 @@ def handle_evolution_reject(log_id: int, reason: str = '') -> str:
         reason: Why this proposal was rejected
     """
     update_evolution_log_status(log_id, "rejected",
-                                test_result=f"Rejected: {reason}" if reason else "Rejected by user")
+                                test_result=f"Rejected: {reason}" if reason else "Rejected by Francisco")
     return f"Proposal #{log_id} REJECTED. Reason: {reason or 'no reason given'}"
 
 
@@ -107,7 +104,7 @@ TOOLS = [
     (handle_evolution_propose, "nexo_evolution_propose",
      "Manually trigger an evolution analysis outside weekly schedule"),
     (handle_evolution_approve, "nexo_evolution_approve",
-     "Approve a pending Evolution proposal"),
+     "Approve a pending Evolution proposal (Francisco only)"),
     (handle_evolution_reject, "nexo_evolution_reject",
      "Reject a pending Evolution proposal with reason"),
 ]

package/src/plugins/preferences.py

@@ -4,7 +4,7 @@ from db import set_preference, get_preference, list_preferences, delete_preferen
 def handle_preference_get(key: str) -> str:
     """Get a specific preference by key."""
     p = get_preference(key)
-    if not p: return f"Preferencia '{key}' no encontrada."
+    if not p: return f"Preference '{key}' not found."
     return f"{p['key']} = {p['value']} (cat: {p['category']})"
 
 def handle_preference_set(key: str, value: str, category: str = "general") -> str:
@@ -15,18 +15,18 @@ def handle_preference_set(key: str, value: str, category: str = "general") -> st
         cognitive.ingest_to_ltm(f"{key}: {value}", "preference", key, key, "")
     except Exception:
         pass
-    return f"Preferencia '{key}' = '{value}' ({category})"
+    return f"Preference '{key}' = '{value}' ({category})"
 
 def handle_preference_list(category: str = "") -> str:
     """List all preferences, optionally filtered by category."""
     prefs = list_preferences(category)
-    if not prefs: return "Sin preferencias."
+    if not prefs: return "No preferences."
     grouped = {}
     for p in prefs:
         c = p["category"]
         if c not in grouped: grouped[c] = []
         grouped[c].append(p)
-    lines = ["PREFERENCIAS:"]
+    lines = ["PREFERENCES:"]
     for c, items in grouped.items():
         lines.append(f"\n  [{c.upper()}]")
         for p in items:
@@ -36,8 +36,8 @@ def handle_preference_list(category: str = "") -> str:
 def handle_preference_delete(key: str) -> str:
     """Delete a preference."""
     if not delete_preference(key):
-        return f"ERROR: Preferencia '{key}' no encontrada."
-    return f"Preferencia '{key}' eliminada."
+        return f"ERROR: Preference '{key}' not found."
+    return f"Preference '{key}' deleted."
 
 TOOLS = [
     (handle_preference_get, "nexo_preference_get", "Get a specific preference value"),

package/src/server.py

@@ -52,7 +52,7 @@ mcp = FastMCP(
     name="nexo",
     instructions=(
         "NEXO operational server. Provides session coordination, "
-        "reminders, followups, and menu for the user's operations.\n\n"
+        "reminders, followups, and menu for Francisco's operations.\n\n"
         "When working with tool results, write down any important information "
         "you might need later in your response, as the original tool result "
         "may be cleared later."
@@ -208,13 +208,13 @@ def nexo_menu() -> str:
 
 @mcp.tool
 def nexo_reminder_create(id: str, description: str, date: str = "", category: str = "general") -> str:
-    """Create a new reminder for the user.
+    """Create a new reminder for Francisco.
 
     Args:
         id: Unique ID starting with 'R' (e.g., R90).
         description: What needs to be done.
         date: Target date YYYY-MM-DD (optional).
-        category: One of: decisions, tasks, waiting, ideas, general.
+        category: One of: decisiones, tareas, esperando, ideas, general.
     """
     return handle_reminder_create(id, description, date, category)
 
@@ -313,7 +313,7 @@ def nexo_learning_add(category: str, title: str, content: str, reasoning: str =
     """Add a new learning (resolved error, pattern, gotcha).
 
     Args:
-        category: One of: nexo-ops, infrastructure, security, brain-engine (or custom categories).
+        category: One of: nexo-ops, google-ads, meta-ads, google-analytics, shopify, wazion, cloud-sql, infrastructure, security, brain-engine.
         title: Short title for the learning.
         content: Full description with context and solution.
         reasoning: WHY this matters — what led to discovering this (optional).
@@ -417,7 +417,7 @@ def nexo_index_dirs() -> str:
     dirs = fts_list_dirs()
     if not dirs:
         return "No directories configured."
-    lines = ["DIRECTORIOS INDEXADOS:"]
+    lines = ["INDEXED DIRECTORIES:"]
     for d in dirs:
         source_tag = "⚙️" if d["source"] == "builtin" else "➕"
         notes = f" — {d['notes']}" if d.get("notes") else ""
@@ -544,7 +544,7 @@ def nexo_plugin_list() -> str:
     plugins = list_plugins()
     if not plugins:
         return "No plugins loaded."
-    lines = ["PLUGINS CARGADOS:"]
+    lines = ["LOADED PLUGINS:"]
     for p in plugins:
         names = p["tool_names"] or "(no tools)"
         lines.append(f"  {p['filename']} — {p['tools_count']} tools: {names}")

package/src/tools_coordination.py

@@ -19,13 +19,13 @@ def handle_track(sid: str, paths: list[str]) -> str:
 
     if result["conflicts"]:
         lines.append("")
-        lines.append("FILE CONFLICT DETECTED:")
+        lines.append("CONFLICTO DE ARCHIVOS:")
         for c in result["conflicts"]:
             lines.append(f"  {c['sid']} ({c['task']}):")
             for f in c["files"]:
                 lines.append(f"    {f}")
         lines.append("")
-        lines.append("STOP — file conflict detected. Do not edit until resolved.")
+        lines.append("PARAR e informar a Francisco antes de editar.")
 
     return "\n".join(lines)
 
@@ -35,7 +35,7 @@ def handle_untrack(sid: str, paths: list[str] | None = None) -> str:
     untrack_files(sid, paths)
     if paths:
         return f"Untracked: {', '.join(paths)}"
-    return "All files released."
+    return "Todos los archivos liberados."
 
 
 def handle_files() -> str:
@@ -56,7 +56,7 @@ def handle_files() -> str:
     conflicts = {p: sids for p, sids in all_paths.items() if len(sids) > 1}
     if conflicts:
         lines.append("")
-        lines.append("CONFLICTS:")
+        lines.append("CONFLICTOS:")
         for path, sids in conflicts.items():
             lines.append(f"  {path} -> {', '.join(sids)}")
 
@@ -66,19 +66,19 @@ def handle_files() -> str:
 def handle_send(from_sid: str, to_sid: str, text: str) -> str:
     """Send a message. to_sid='all' for broadcast."""
     msg_id = send_message(from_sid, to_sid, text)
-    target = "all sessions" if to_sid == "all" else to_sid
-    return f"Message {msg_id} sent to {target}."
+    target = "todas las sesiones" if to_sid == "all" else to_sid
+    return f"Mensaje {msg_id} enviado a {target}."
 
 
 def handle_ask(from_sid: str, to_sid: str, question: str) -> str:
     """Create a question to another session (non-blocking)."""
     qid = ask_question(from_sid, to_sid, question)
     return (
-        f"Question sent: {qid}\n"
-        f"To: {to_sid}\n"
-        f"Question: {question}\n\n"
-        f"The other session will see the question on their next nexo_heartbeat.\n"
-        f"Use nexo_check_answer(qid='{qid}') to check if answered."
+        f"Pregunta enviada: {qid}\n"
+        f"Para: {to_sid}\n"
+        f"Pregunta: {question}\n\n"
+        f"La otra sesion vera la pregunta en su proximo nexo_heartbeat.\n"
+        f"Usa nexo_check_answer(qid='{qid}') para ver si respondieron."
     )
 
 
@@ -87,7 +87,7 @@ def handle_answer(qid: str, answer_text: str) -> str:
     result = answer_question(qid, answer_text)
     if "error" in result:
         return f"ERROR: {result['error']}"
-    return f"Answered {qid}: {answer_text}"
+    return f"Respondido {qid}: {answer_text}"
 
 
 def handle_check_answer(qid: str) -> str:
@@ -96,7 +96,7 @@ def handle_check_answer(qid: str) -> str:
     if not result:
         return f"Question {qid} not found."
     if result["status"] == "answered":
-        return f"ANSWER for {qid}: {result['answer']}"
+        return f"RESPUESTA de {qid}: {result['answer']}"
     elif result["status"] == "expired":
-        return f"Question {qid} expired without answer."
-    return f"Question {qid} still pending. Retry in a few seconds."
+        return f"Pregunta {qid} expirada sin respuesta."
+    return f"Pregunta {qid} sigue pendiente. Reintentar en unos segundos."

package/src/tools_credentials.py

@@ -11,10 +11,10 @@ def handle_credential_get(service: str, key: str = '') -> str:
         return f"ERROR: No credentials found for '{target}'."
     lines = []
     for r in results:
-        lines.append(f"CREDENCIAL {r['service']}/{r['key']}:")
-        lines.append(f"  Valor: {r['value']}")
+        lines.append(f"CREDENTIAL {r['service']}/{r['key']}:")
+        lines.append(f"  Value: {r['value']}")
         notes = r.get("notes") or ""
-        lines.append(f"  Notas: {notes if notes else '—'}")
+        lines.append(f"  Notes: {notes if notes else '—'}")
     return "\n".join(lines)
 
 
@@ -53,7 +53,7 @@ def handle_credential_delete(service: str, key: str = '') -> str:
 def handle_credential_list(service: str = '') -> str:
     """List credential service/key names and notes — values are never shown."""
     results = list_credentials(service if service else None)
-    label = service if service else "TODAS"
+    label = service if service else "ALL"
     if not results:
         return f"CREDENTIALS {label.upper()}: No entries."
     lines = [f"CREDENTIALS {label.upper()} ({len(results)}):"]

package/src/tools_learnings.py

@@ -100,7 +100,7 @@ def handle_learning_add(category: str, title: str, content: str, reasoning: str
     if applies_to:
         meta.append(f"applies_to={applies_to}")
     meta_str = f" ({', '.join(meta)})" if meta else ""
-    return f"Learning #{result['id']} añadido en {category}: {title}{meta_str}{repetition_msg}"
+    return f"Learning #{result['id']} added to {category}: {title}{meta_str}{repetition_msg}"
 
 
 def handle_learning_search(query: str, category: str = '') -> str:
@@ -117,7 +117,7 @@ def handle_learning_search(query: str, category: str = '') -> str:
         lines.append(f"  #{r['id']} [{r['category']}] [{status}] {r['title']}{review_note}")
         lines.append(f"    {snippet}")
         if r.get("prevention"):
-            lines.append(f"    Prevención: {r['prevention'][:100]}")
+            lines.append(f"    Prevention: {r['prevention'][:100]}")
 
     # v1.2: Passive rehearsal — strengthen matching cognitive memories
     try:
@@ -176,7 +176,7 @@ def handle_learning_update(id: int, title: str = '', content: str = '', category
         conn = get_db()
         conn.execute(f"UPDATE learnings SET {set_clause} WHERE id = ?", values)
         conn.commit()
-    return f"Learning #{id} actualizado."
+    return f"Learning #{id} updated."
 
 
 def handle_learning_delete(id: int) -> str:
@@ -184,7 +184,7 @@ def handle_learning_delete(id: int) -> str:
     deleted = delete_learning(id)
     if not deleted:
         return f"ERROR: Learning #{id} not found."
-    return f"Learning #{id} eliminado."
+    return f"Learning #{id} deleted."
 
 
 def handle_learning_list(category: str = '') -> str:

package/src/tools_menu.py

@@ -2,7 +2,6 @@
 
 from datetime import datetime, timedelta
 import json
-import os
 import subprocess
 import sys
 from pathlib import Path
@@ -10,16 +9,14 @@ from tools_sessions import handle_status
 from tools_reminders import handle_reminders
 from db import get_db
 
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-
 
 def _get_date_str() -> str:
-    """Get formatted current date and time."""
+    """Get formatted date in Madrid timezone."""
     try:
         result = subprocess.run(
-            ["date", "+%A %d %B %Y, %H:%M"],
+            ["date", "+%A %d de %B de %Y, %H:%M"],
             capture_output=True, text=True,
-            env={"PATH": "/usr/bin:/bin"}
+            env={"TZ": "Europe/Madrid", "PATH": "/usr/bin:/bin", "LANG": "es_ES.UTF-8"}
         )
         return result.stdout.strip()
     except Exception:
@@ -27,21 +24,39 @@ def _get_date_str() -> str:
 
 
 MENU_ITEMS = [
-    ("Projects", [
-        ("1", "Project Status - Review active projects"),
-        ("2", "Infrastructure - Server health check"),
+    ("Proyectos", [
+        ("1", "WAzion - Revisar estado del proyecto"),
+        ("9", "Claude Agent VPS - Revisar cambios autonomos"),
+    ]),
+    ("Publicidad", [
+        ("7", "Google Ads - Administrar campanas (Recambios + WAzion)"),
+        ("7b", "Meta Ads - Administrar campanas Facebook/Instagram"),
+        ("7c", "Ads Tracking - Revision combinada Google+Meta"),
+    ]),
+    ("Shopify", [
+        ("4", "Shopify Theme Sync - Sincronizar tema"),
+        ("5", "Shopify Scripts - Ejecutar scripts periodicos"),
+        ("6", "Cambiar Promocion Shopify"),
     ]),
-    ("Advertising", [
-        ("3", "Google Ads - Manage campaigns"),
-        ("4", "Meta Ads - Manage Facebook/Instagram"),
+    ("Servidor e Infraestructura", [
+        ("2", "Servidor - Chequeo cl105e.mundiserver.com"),
+        ("3", "WhatsApp Logs - Revisar logs vicshopsysteam"),
+        ("11", "File Tracker - Reporte archivos PHP"),
+        ("12", "Google Cloud - Gasto, consumo y estado GCP"),
     ]),
-    ("Analytics & Monitoring", [
-        ("5", "Google Analytics - Review web analytics"),
-        ("6", "Email Review - Review inboxes"),
+    ("Comunicacion y Monitorizacion", [
+        ("8", "Recovery Optimizer - Analisis IA semanal (LUNES)"),
+        ("10", "Recovery Monitor - Estado emails/WA recovery (24h)"),
+        ("13", "Review Monitor - Estado emails/WA resenas"),
+        ("14", "WhatsApp Analisis Completo - Estadisticas globales"),
+        ("15", "Google Analytics - Revisar analiticas web"),
+        ("16", "Email Review - Revisar bandejas y spam"),
     ]),
-    ("Maintenance", [
-        ("7", "Backup - Check backup status"),
-        ("8", "Memory Review - Review pending learnings/decisions"),
+    ("Informes y SEO", [
+        ("17", "Auditoria Search Console (cada 2 semanas)"),
+        ("18", "Re-envio sitemaps (cada 30 dias)"),
+        ("19", "Verificacion SEO metas"),
+        ("20", "Informe Email Semanal (domingos)"),
     ]),
 ]
 
@@ -49,7 +64,7 @@ MENU_ITEMS = [
 def _get_dashboard_alerts() -> list[dict]:
     """Run proactive dashboard and return alerts."""
     try:
-        script = NEXO_HOME / "scripts" / "nexo-proactive-dashboard.py"
+        script = Path.home() / "claude" / "scripts" / "nexo-proactive-dashboard.py"
         if not script.exists():
             return []
         result = subprocess.run(
@@ -93,7 +108,7 @@ def handle_menu() -> str:
 
     lines = []
     lines.append("╔" + "═" * W + "╗")
-    lines.append("║" + "NEXO — OPERATIONS CENTER".center(W) + "║")
+    lines.append("║" + "NEXO — CENTRO DE OPERACIONES".center(W) + "║")
     lines.append("║" + date_str.center(W) + "║")
     lines.append("╠" + "═" * W + "╣")
 
@@ -101,30 +116,30 @@ def handle_menu() -> str:
     dashboard_alerts = _get_dashboard_alerts()
     memory_reviews = _get_memory_review_summary()
     due = handle_reminders("due")
-    has_alerts = dashboard_alerts or memory_reviews["total"] > 0 or (due and "No reminders" not in due)
+    has_alerts = dashboard_alerts or memory_reviews["total"] > 0 or (due and "No pending reminders" not in due)
 
     if has_alerts:
         lines.append("║" + "  PROACTIVE ALERTS".ljust(W) + "║")
         lines.append("╠" + "═" * W + "╣")
 
         if dashboard_alerts:
-            for alert in dashboard_alerts[:10]:
+            for alert in dashboard_alerts[:10]:  # Top 10
                 sev = alert.get("severity", "low")
                 icon = {"high": "!!!", "medium": " ! ", "low": " . "}.get(sev, " . ")
                 text = alert.get("title", "")[:W - 8]
                 lines.append("║" + f"  {icon} {text}".ljust(W) + "║")
             if len(dashboard_alerts) > 10:
                 more = len(dashboard_alerts) - 10
-                lines.append("║" + f"  ... and {more} more alerts".ljust(W) + "║")
+                lines.append("║" + f"  ... y {more} alertas mas".ljust(W) + "║")
 
         if memory_reviews["total"] > 0:
             text = (
-                f"MEMORY: {memory_reviews['total']} reviews pending "
-                f"({memory_reviews['decisions']} decisions, {memory_reviews['learnings']} learnings)"
+                f"MEMORIA: {memory_reviews['total']} revisiones pendientes "
+                f"({memory_reviews['decisions']} decisiones, {memory_reviews['learnings']} learnings)"
             )[:W - 4]
             lines.append("║" + f"  !  {text}".ljust(W) + "║")
 
-        if due and "No reminders" not in due:
+        if due and "No pending reminders" not in due:
             for reminder_line in due.split("\n"):
                 if reminder_line.strip():
                     truncated = reminder_line[:W - 2]
@@ -141,23 +156,26 @@ def handle_menu() -> str:
             lines.append("║" + entry.ljust(W) + "║")
         lines.append("╠" + "═" * W + "╣")
 
-    # Backlog: ideas, future projects, undated tasks
+    # Backlog: ideas, proyectos futuros, tareas sin fecha o lejanas
     try:
         conn = get_db()
         cutoff = (datetime.now() + timedelta(days=7)).strftime("%Y-%m-%d")
+        # Reminders sin fecha (backlog/ideas)
         no_date = conn.execute(
             "SELECT id, description, category FROM reminders WHERE status LIKE 'PENDIENTE%' AND (date IS NULL OR date='') ORDER BY category, id"
         ).fetchall()
+        # Reminders con fecha > 7 días (futuro)
         future = conn.execute(
             "SELECT id, description, date, category FROM reminders WHERE status LIKE 'PENDIENTE%' AND date > ? ORDER BY date",
             (cutoff,)
         ).fetchall()
+        # Followups sin fecha
         nf_no_date = conn.execute(
             "SELECT id, description FROM followups WHERE status NOT LIKE 'COMPLETADO%' AND (date IS NULL OR date='') ORDER BY id"
         ).fetchall()
 
         if no_date or future or nf_no_date:
-            lines.append("║" + "  BACKLOG / IDEAS / FUTURE".ljust(W) + "║")
+            lines.append("║" + "  BACKLOG / IDEAS / FUTURO".ljust(W) + "║")
             lines.append("║" + "─" * W + "║")
 
             if no_date:
@@ -172,29 +190,29 @@ def handle_menu() -> str:
                         lines.append("║" + f"    {r['id']}: {short}".ljust(W) + "║")
 
             if future:
-                lines.append("║" + f"  [Scheduled]".ljust(W) + "║")
+                lines.append("║" + f"  [Programado]".ljust(W) + "║")
                 for r in future:
                     short = r["description"][:W - 18]
                     lines.append("║" + f"    {r['id']} ({r['date']}): {short}".ljust(W) + "║")
 
             if nf_no_date:
-                lines.append("║" + f"  [Pending followups]".ljust(W) + "║")
+                lines.append("║" + f"  [Followups pendientes]".ljust(W) + "║")
                 for r in nf_no_date:
                     short = r["description"][:W - 12]
                     lines.append("║" + f"    {r['id']}: {short}".ljust(W) + "║")
 
             lines.append("╠" + "═" * W + "╣")
     except Exception as e:
-        lines.append("║" + f"  ! Backlog error: {e}".ljust(W) + "║")
+        lines.append("║" + f"  ⚠ Error backlog: {e}".ljust(W) + "║")
         lines.append("╠" + "═" * W + "╣")
 
     # Active sessions
     sessions = handle_status()
-    if "No sessions" not in sessions:
+    if "No active sessions" not in sessions:
         lines.append("║" + "  ACTIVE SESSIONS".ljust(W) + "║")
         lines.append("║" + "─" * W + "║")
         for s_line in sessions.split("\n"):
-            if s_line.strip() and "SESIONES ACTIVAS" not in s_line:
+            if s_line.strip() and "ACTIVE SESSIONS" not in s_line:
                 truncated = s_line[:W - 2]
                 lines.append("║" + f"  {truncated}".ljust(W) + "║")
         lines.append("╠" + "═" * W + "╣")

package/src/tools_reminders_crud.py

@@ -14,15 +14,15 @@ from db import (
 def handle_reminder_create(id: str, description: str, date: str = '', category: str = 'general') -> 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}')."
+        return f"ERROR: El ID del recordatorio debe empezar por 'R' (recibido: '{id}')."
 
     result = create_reminder(id=id, description=description, date=date or None, category=category)
     if not result or "error" in result:
-        error_msg = result.get("error", "unknown") if isinstance(result, dict) else "unknown"
+        error_msg = result.get("error", "desconocido") if isinstance(result, dict) else "desconocido"
         return f"ERROR: {error_msg}"
 
-    date_str = date if date else 'no date'
-    return f"Reminder {id} created. Date: {date_str}. Category: {category}."
+    fecha_str = date if date else 'no date'
+    return f"Reminder {id} created. Date: {fecha_str}. Category: {category}."
 
 
 def handle_reminder_update(id: str, description: str = '', date: str = '', status: str = '', category: str = '') -> str:
@@ -85,12 +85,12 @@ def handle_followup_create(id: str, description: str, date: str = '', verificati
 
     result = create_followup(id=id, description=description, date=date or None, verification=verification, reasoning=reasoning, recurrence=recurrence or None)
     if not result or "error" in result:
-        error_msg = result.get("error", "unknown") if isinstance(result, dict) else "unknown"
+        error_msg = result.get("error", "desconocido") if isinstance(result, dict) else "desconocido"
         return f"ERROR: {error_msg}"
 
-    date_str = date if date else 'no date'
+    fecha_str = date if date else 'no date'
     rec_str = f" Recurrence: {recurrence}." if recurrence else ""
-    return f"Followup {id} created. Date: {date_str}.{rec_str}"
+    return f"Followup {id} created. Date: {fecha_str}.{rec_str}"
 
 
 def handle_followup_update(id: str, description: str = '', date: str = '', verification: str = '', status: str = '') -> str:
@@ -136,10 +136,10 @@ def handle_followup_complete(id: str, result: str = '') -> str:
         # The new one was auto-created by complete_followup
         new_row = conn.execute("SELECT date FROM followups WHERE id = ?", (id,)).fetchone()
         if new_row:
-            msg += f" Next auto-created for {new_row['date']}."
+            msg += f" ♻️ Siguiente auto-creado para {new_row['date']}."
     linked_decisions = find_decisions_by_context_ref(id)
     if linked_decisions:
-        outcome_text = result if result else f"Followup {id} completed"
+        outcome_text = result if result else f"Followup {id} completado"
         for dec in linked_decisions:
             update_decision_outcome(dec['id'], outcome_text)
         dec_ids = ', '.join(f"#{d['id']}" for d in linked_decisions)

package/src/tools_sessions.py

@@ -79,16 +79,16 @@ def handle_startup(task: str = "Startup") -> str:
 
     if other_sessions:
         lines.append("")
-        lines.append("SESIONES ACTIVAS:")
+        lines.append("ACTIVE SESSIONS:")
         for s in other_sessions:
             age = _format_age(s["last_update_epoch"])
             lines.append(f"  {s['sid']} ({age}) — {s['task']}")
     else:
-        lines.append("Sin otras sesiones activas.")
+        lines.append("No other active sessions.")
 
     if inbox:
         lines.append("")
-        lines.append("MENSAJES PENDIENTES:")
+        lines.append("PENDING MESSAGES:")
         for m in inbox:
             age = _format_age(m["created_epoch"])
             lines.append(f"  [{m['from_sid']}] ({age}): {m['text']}")
@@ -112,7 +112,7 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
     inbox = get_inbox(sid)
     if inbox:
         parts.append("")
-        parts.append("MENSAJES:")
+        parts.append("MESSAGES:")
         for m in inbox:
             age = _format_age(m["created_epoch"])
             parts.append(f"  [{m['from_sid']}] ({age}): {m['text']}")
@@ -120,7 +120,7 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
     questions = get_pending_questions(sid)
     if questions:
         parts.append("")
-        parts.append("PREGUNTAS PENDIENTES (responder con nexo_answer):")
+        parts.append("PENDING QUESTIONS (reply with nexo_answer):")
         for q in questions:
             age = _format_age(q["created_epoch"])
             parts.append(f"  {q['qid']} de {q['from_sid']} ({age}): {q['question']}")
@@ -296,7 +296,7 @@ def handle_stop(sid: str) -> str:
     """Cleanly close a session, removing it from active sessions immediately."""
     _stop_keepalive(sid)
     complete_session(sid)
-    return f"Sesión {sid} cerrada."
+    return f"Session {sid} closed."
 
 
 def handle_status(keyword: str | None = None) -> str:
@@ -310,9 +310,9 @@ def handle_status(keyword: str | None = None) -> str:
         sessions = get_active_sessions()
 
     if not sessions:
-        return "Sin sesiones activas."
+        return "No active sessions."
 
-    lines = ["SESIONES ACTIVAS:"]
+    lines = ["ACTIVE SESSIONS:"]
     for s in sessions:
         age = _format_age(s["last_update_epoch"])
         lines.append(f"  {s['sid']} ({age}) — {s['task']}")

package/src/tools_task_history.py

@@ -28,9 +28,9 @@ def handle_task_list(task_num: str = '', days: int = 30) -> str:
     """Show execution history for all tasks or a specific task number."""
     results = list_task_history(task_num if task_num else None, days)
     if not results:
-        scope = f"task {task_num}" if task_num else "no task"
-        return f"HISTORY: No executions of {scope} in the last {days} days."
-    lines = [f"HISTORIAL ({len(results)} ejecuciones, {days}d):"]
+        scope = f"task {task_num}" if task_num else "any task"
+        return f"HISTORY: No executions for {scope} in the last {days} days."
+    lines = [f"HISTORY ({len(results)} executions, {days}d):"]
     for r in results:
         date_str = _epoch_to_date(r["executed_at"])
         notes_str = f": {r['notes']}" if r.get("notes") else ""
@@ -43,15 +43,15 @@ def handle_task_frequency() -> str:
     overdue = get_overdue_tasks()
     if not overdue:
         return "All tasks up to date."
-    lines = ["TAREAS VENCIDAS:"]
+    lines = ["OVERDUE TASKS:"]
     for t in overdue:
         days_since = t.get("days_since_last")
         if days_since is not None:
-            since_str = f"última hace {days_since:.1f} días"
+            since_str = f"last run {days_since:.1f} days ago"
         else:
-            since_str = "nunca ejecutada"
+            since_str = "never executed"
         lines.append(
             f"  Task {t['task_num']} ({t['task_name']}): "
-            f"{since_str}, frecuencia cada {t['frequency_days']} días"
+            f"{since_str}, frequency every {t['frequency_days']} days"
         )
     return "\n".join(lines)