nexo-brain 0.8.8 → 0.8.10

package/README.md

@@ -10,7 +10,13 @@
 
 **NEXO Brain transforms any MCP-compatible AI agent from a stateless assistant into a cognitive partner that remembers, learns, forgets, adapts, and builds a relationship with you over time.**
 
-[Watch the overview on YouTube](https://www.youtube.com/watch?v=-uvhicUhGTY)
+<p align="center">
+  <a href="https://www.youtube.com/watch?v=J0hCWnYU4UY">
+    <img src="assets/nexo-brain-infographic-v4.png" alt="NEXO Brain Architecture" width="700">
+  </a>
+</p>
+
+[Watch the 1-minute overview on YouTube](https://www.youtube.com/watch?v=J0hCWnYU4UY)
 
 Every time you close a session, everything is lost. Your agent doesn't remember yesterday's decisions, repeats the same mistakes, and starts from zero. NEXO Brain fixes this with a cognitive architecture modeled after how human memory actually works.
 
@@ -268,7 +274,9 @@ A bi-temporal entity-relationship graph with 988 nodes and 896 edges. Entities a
 A visual interface at `localhost:6174` with 6 pages: Overview (system health at a glance), Graph (interactive D3.js visualization of the knowledge graph), Memory (browse and search all memory stores), Somatic (pain map per file/area), Adaptive (personality signals and weights), and Sessions (active and historical sessions). Built with FastAPI backend and D3.js frontend.
 
 ### Cross-Platform Support
-v0.8.0 adds full Linux and Windows support. The installer detects the platform and configures the appropriate process manager (LaunchAgents on macOS, systemd on Linux, Task Scheduler on Windows). Opportunistic maintenance runs cognitive processes when resources are available.
+v0.8.0 adds full Linux support and Windows via WSL. The installer detects the platform and configures the appropriate process manager (LaunchAgents on macOS, catch-up on startup for Linux). Opportunistic maintenance runs cognitive processes when resources are available.
+
+> **Windows users:** NEXO Brain requires [WSL (Windows Subsystem for Linux)](https://learn.microsoft.com/en-us/windows/wsl/install). Install WSL first, then run `npx nexo-brain` inside the Ubuntu/WSL terminal.
 
 ### Storage Router
 A new abstraction layer routes storage operations through a unified interface, making the system multi-tenant ready. Each operator's data is isolated while sharing the same cognitive engine.
@@ -343,7 +351,7 @@ That's it. No need to run `claude` manually. Atlas will greet you immediately
 
 ### Requirements
 
-- **macOS, Linux, or Windows**
+- **macOS or Linux** (Windows via [WSL](https://learn.microsoft.com/en-us/windows/wsl/install))
 - **Node.js 18+** (for the installer)
 - **Claude Opus (latest version) strongly recommended.** NEXO Brain provides 109+ MCP tools across 19 categories. This cognitive load requires a top-tier model with large context window. Smaller models (Haiku, Sonnet) may struggle with tool selection and produce inconsistent results. Opus handles all 109+ tools without hesitation.
 - Python 3, Homebrew, and Claude Code are installed automatically if missing.

package/bin/nexo-brain.js

@@ -77,8 +77,14 @@ async function main() {
 
   // Check prerequisites
   const platform = process.platform;
-  if (platform !== "darwin" && platform !== "linux" && platform !== "win32") {
-    log(`Unsupported platform: ${platform}. NEXO supports macOS, Linux, and Windows.`);
+  if (platform === "win32") {
+    log("Windows detected. NEXO Brain requires WSL (Windows Subsystem for Linux).");
+    log("Install WSL: https://learn.microsoft.com/en-us/windows/wsl/install");
+    log("Then run this command inside WSL (Ubuntu terminal), not PowerShell/CMD.");
+    process.exit(1);
+  }
+  if (platform !== "darwin" && platform !== "linux") {
+    log(`Unsupported platform: ${platform}. NEXO supports macOS and Linux (Windows via WSL).`);
     process.exit(1);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "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)