nexo-brain 7.23.13 → 7.25.0

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

@@ -73,7 +73,7 @@ RESULTS_FILE = data_dir() / "followup-runner-results.json"
 CLI_TIMEOUT = AUTOMATION_SUBPROCESS_TIMEOUT
 LOCK_FILE = LOG_DIR / "followup-runner.lock"
 MAX_FOLLOWUPS_PER_RUN = 5  # Focus: Opus can actually execute 5, not 30
-COOLDOWN_DAYS = 3  # Don't retry needs_decision/blocked for 3 days
+COOLDOWN_DAYS = 3  # Don't retry waiting_user/stale_review/blocked for 3 days
 STALE_FOLLOWUP_TRIAGE_DAYS = 14
 MAX_STALE_TRIAGE_PER_RUN = 8
 MAX_NEEDS_OPERATOR_BRIEFING = 12
@@ -134,7 +134,7 @@ def _history_has_recent_movement(history, *, days: int = STALE_FOLLOWUP_TRIAGE_D
 
 def _is_stale_followup_for_triage(followup: dict) -> bool:
     status = str(followup.get("status") or "").strip().lower()
-    if status in {"needs_decision", "waiting_user", "blocked", "waiting"}:
+    if status in {"needs_decision", "waiting_user", "blocked", "waiting", "stale_review"}:
         return False
     if _followup_days_overdue(str(followup.get("date") or "")) < STALE_FOLLOWUP_TRIAGE_DAYS:
         return False
@@ -148,7 +148,7 @@ def _is_in_cooldown(fu_id: str, state: dict) -> bool:
     if not last:
         return False
     last_status = last.get("status", "")
-    if last_status not in ("needs_decision", "blocked"):
+    if last_status not in ("needs_decision", "waiting_user", "stale_review", "blocked"):
         return False
     last_date_str = last.get("date", "")
     if not last_date_str:
@@ -298,17 +298,17 @@ def get_all_active_followups(state: dict) -> dict:
     conn = sqlite3.connect(str(NEXO_DB))
     conn.row_factory = sqlite3.Row
     try:
-        rows = conn.execute(
-            "SELECT id, description, date, reasoning, verification, priority, recurrence, status, owner, updated_at "
-            "FROM followups WHERE status NOT LIKE 'COMPLETED%' "
-            "AND UPPER(COALESCE(status, '')) NOT IN ('BLOCKED', 'ARCHIVED', 'DELETED', 'WAITING', 'DONE') "
-            "AND description NOT LIKE '[Abandoned]%' "
-            "ORDER BY "
-            "  CASE priority "
-            "    WHEN 'critical' THEN 1 WHEN 'high' THEN 2 "
-            "    WHEN 'medium' THEN 3 WHEN 'low' THEN 4 ELSE 5 END, "
-            "  date ASC"
-        ).fetchall()
+        snapshot = nexo_db.followup_lifecycle_snapshot(limit=5000)
+        rows = [
+            item for item in (snapshot.get("lanes") or {}).get("active", [])
+            if not str(item.get("description") or "").startswith("[Abandoned]")
+        ]
+        rows.sort(
+            key=lambda item: (
+                {"critical": 1, "high": 2, "medium": 3, "low": 4}.get(str(item.get("priority") or "medium"), 5),
+                str(item.get("date") or "9999-12-31"),
+            )
+        )
 
         result = {"actionable": [], "needs_operator": [], "future": [], "backlog": [], "cooled_down": [], "stale_triage": []}
         undated_triage_budget = 2
@@ -429,7 +429,7 @@ def complete_followup_if_needed(fu_id: str, result_summary: str = ""):
         return
     try:
         nexo_db.complete_followup(fu_id, result_summary)
-        log(f"  {fu_id}: marcado completado por el runner")
+        log(f"  {fu_id}: marked completed por el runner")
     except Exception as exc:
         log(f"  {fu_id}: failed to mark followup as completed ({exc})")
 
@@ -488,7 +488,7 @@ def attention_reminder_id(fu_id: str) -> str:
 
 
 def attention_reminder_category(status: str) -> str:
-    return "decisions" if status == "needs_decision" else "waiting"
+    return "decisions" if status in {"needs_decision", "waiting_user", "stale_review"} else "waiting"
 
 
 def attention_reminder_description(
@@ -502,14 +502,14 @@ def attention_reminder_description(
     detail = " ".join((summary or "").split())
     if not detail:
         detail = (
-            "El runner no puede cerrar este punto sin intervención del operador."
+            "The runner cannot close this item without operator input."
             if _uses_spanish(operator_language)
             else "The runner cannot close this item without operator input."
         )
     description = f"{fu_id}: {detail}"
     opts_text = render_options(options)
     if opts_text:
-        description += f" {'Opciones' if _uses_spanish(operator_language) else 'Options'}: {opts_text}"
+        description += f" {'Options' if _uses_spanish(operator_language) else 'Options'}: {opts_text}"
     return description[:480]
 
 
@@ -548,7 +548,7 @@ def upsert_attention_reminder(
             log(f"  {fu_id}: failed to update reminder {reminder_id} ({result['error']})")
             return
         nexo_db.add_reminder_note(reminder_id, description, actor="followup-runner")
-        log(f"  {fu_id}: reminder {reminder_id} actualizado para orchestrator")
+        log(f"  {fu_id}: reminder {reminder_id} updated for orchestrator")
         return
 
     result = nexo_db.create_reminder(
@@ -565,7 +565,7 @@ def upsert_attention_reminder(
         f"source_followup={fu_id} status={status}",
         actor="followup-runner",
     )
-    log(f"  {fu_id}: reminder {reminder_id} creado para orchestrator")
+    log(f"  {fu_id}: reminder {reminder_id} created for orchestrator")
 
 
 def resolve_attention_reminder(fu_id: str, *, resolution: str = ""):
@@ -579,14 +579,14 @@ def resolve_attention_reminder(fu_id: str, *, resolution: str = ""):
     if resolution:
         nexo_db.add_reminder_note(
             reminder_id,
-            f"Resuelto desde {fu_id}: {resolution[:300]}",
+            f"Resolved from {fu_id}: {resolution[:300]}",
             actor="followup-runner",
         )
     result = nexo_db.complete_reminder(reminder_id)
     if result.get("error"):
         log(f"  {fu_id}: failed to complete reminder {reminder_id} ({result['error']})")
         return
-    log(f"  {fu_id}: reminder {reminder_id} marcado completado")
+    log(f"  {fu_id}: reminder {reminder_id} marked completed")
 
 
 def defer_followup_after_attention(
@@ -602,7 +602,7 @@ def defer_followup_after_attention(
     details = summary.strip()
     opts_text = render_options(options)
     if opts_text:
-        details = f"{details}\nOpciones: {opts_text}"
+        details = f"{details}\nOptions: {opts_text}"
     if details:
         note_result = nexo_db.add_followup_note(
             fu_id,
@@ -690,10 +690,10 @@ def get_recent_activity(hours: int = 24) -> str:
 
         # Recent followup notes from the runner
         notes = conn.execute(
-            "SELECT followup_id, note, created_at FROM followup_history "
-            "WHERE actor='followup-runner' AND created_at >= datetime('now', ?)"
+            "SELECT item_id AS followup_id, note, created_at FROM item_history "
+            "WHERE item_type='followup' AND actor='followup-runner' AND created_at >= ? "
             "ORDER BY created_at DESC LIMIT 10",
-            (f"-{hours} hours",)
+            ((datetime.now() - timedelta(hours=hours)).timestamp(),),
         ).fetchall()
         if notes:
             lines.append("\nFOLLOWUP NOTES WRITTEN (last 24h):")
@@ -821,7 +821,7 @@ def main():
         update_followup_fields(
             fid,
             date_value=date.today().isoformat(),
-            status="needs_decision",
+            status="stale_review",
             history_event="stale_triage",
             history_note=summary,
         )
@@ -829,10 +829,10 @@ def main():
             fid,
             summary=summary,
             options={"a": "close obsolete", "b": "reschedule", "c": "convert to next action"},
-            status="needs_decision",
+            status="stale_review",
             operator_language=_operator_language(),
         )
-        record_attempt(state, fid, "needs_decision")
+        record_attempt(state, fid, "stale_review")
 
     results = []
 
@@ -914,7 +914,7 @@ def main():
             advance_recurrent(fid, recurrence, summary)
             resolve_attention_reminder(fid, resolution=summary)
             record_attempt(state, fid, "checked")
-        elif r["status"] in ("needs_decision", "blocked"):
+        elif r["status"] in ("needs_decision", "waiting_user", "stale_review", "blocked"):
             defer_followup_after_attention(
                 fid,
                 summary=summary,
@@ -929,7 +929,7 @@ def main():
 
     total = len(all_actionable) + len(groups["needs_operator"]) + len(groups["future"]) + len(groups["backlog"]) + len(stale_triage)
     attention_handed_off = any(
-        r.get("needs_attention") or r["status"] in ("needs_decision", "blocked")
+        r.get("needs_attention") or r["status"] in ("needs_decision", "waiting_user", "stale_review", "blocked")
         for r in results
     )
     if total > 0 or results:

package/src/scripts/nexo-inbox-hook.sh

@@ -65,7 +65,7 @@ if [ -n "$MESSAGES" ]; then
 fi
 
 if [ -n "$QUESTIONS" ]; then
-    echo "  ⚠ PREGUNTAS de otra terminal — responder con nexo_answer:"
+    echo "  ⚠ QUESTIONS from another terminal — answer with nexo_answer:"
     echo "$QUESTIONS" | while IFS='|' read -r qid from question; do
         echo "  Q[$qid] de [$from]: $question"
     done

package/src/scripts/nexo-learning-validator.py

@@ -62,6 +62,7 @@ DB_PATH = data_dir() / "nexo.db"
 
 from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 from core_prompts import render_core_prompt
+from learning_resolver import resolve_learning_candidate
 
 try:
     from client_preferences import resolve_user_model as _resolve_user_model
@@ -79,12 +80,12 @@ def get_all_learnings(category: str | None = None) -> list[dict]:
     conn.row_factory = sqlite3.Row
     if category:
         rows = conn.execute(
-            "SELECT id, category, title, content FROM learnings WHERE category = ?",
+            "SELECT id, category, title, content FROM learnings WHERE category = ? AND COALESCE(status, 'active') = 'active'",
             (category,),
         ).fetchall()
     else:
         rows = conn.execute(
-            "SELECT id, category, title, content FROM learnings"
+            "SELECT id, category, title, content FROM learnings WHERE COALESCE(status, 'active') = 'active'"
         ).fetchall()
     conn.close()
     return [dict(r) for r in rows]
@@ -131,6 +132,12 @@ def validate_finding(finding: str, category: str | None = None) -> dict:
             "recommendation": str
         }
     """
+    resolver = resolve_learning_candidate(
+        category=category or "process",
+        title=(finding or "Finding").strip()[:120] or "Finding",
+        content=finding or "",
+        source_authority="code_test_evidence" if any(token in (finding or "").lower() for token in ("test", "traceback", "stack", "verified", "evidence")) else "inference",
+    )
     learnings = get_all_learnings(category)
 
     if not learnings:
@@ -139,6 +146,7 @@ def validate_finding(finding: str, category: str | None = None) -> dict:
             "confidence": 0,
             "matching_learnings": [],
             "recommendation": "No learnings in DB — finding is new by default",
+            "resolver": resolver,
         }
 
     learnings_ref = [
@@ -168,13 +176,26 @@ def validate_finding(finding: str, category: str | None = None) -> dict:
         )
         parsed = _extract_json(result.stdout)
         if result.returncode == 0 and parsed:
+            parsed["resolver"] = resolver
             return parsed
     except AutomationBackendUnavailableError:
         pass
     except Exception:
         pass
 
-    return _mechanical_validate(finding, learnings)
+    result = _mechanical_validate(finding, learnings)
+    result["resolver"] = resolver
+    if resolver.get("action") in {"merge", "supersede", "conflict_review"}:
+        result["known"] = True
+        result["confidence"] = max(float(result.get("confidence") or 0), float(resolver.get("similarity") or 0.7))
+        result["matching_learnings"] = result.get("matching_learnings") or [{
+            "id": resolver.get("target_id"),
+            "category": category or "process",
+            "title": resolver.get("target_title"),
+            "similarity": resolver.get("similarity"),
+        }]
+        result["recommendation"] = f"Resolver action: {resolver.get('action')} ({resolver.get('reason')})"
+    return result
 
 
 def _mechanical_validate(finding: str, learnings: list[dict]) -> dict:

package/src/scripts/nexo-memory-fabric.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# nexo: name=memory-fabric
+# nexo: description=Refresh transcript search, historical backup diaries, and graph links.
+# nexo: runtime=python
+# nexo: cron_id=memory-fabric
+# nexo: schedule=02:35
+# nexo: recovery_policy=catchup
+# nexo: run_on_boot=true
+# nexo: run_on_wake=true
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+
+RUNTIME_ROOT = Path(__file__).resolve().parents[1]
+if str(RUNTIME_ROOT) not in sys.path:
+    sys.path.insert(0, str(RUNTIME_ROOT))
+
+
+def _int_env(name: str, default: int) -> int:
+    raw = os.environ.get(name, "").strip()
+    if not raw:
+        return default
+    try:
+        return max(1, int(raw))
+    except ValueError:
+        return default
+
+
+def main() -> int:
+    import memory_fabric
+
+    result = memory_fabric.repair_memory_fabric(
+        transcript_limit=_int_env("NEXO_MEMORY_FABRIC_TRANSCRIPT_LIMIT", 1000),
+        backup_limit=_int_env("NEXO_MEMORY_FABRIC_BACKUP_LIMIT", 10000),
+    )
+    print(json.dumps(result, ensure_ascii=False, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/server.py

@@ -79,7 +79,7 @@ from tools_reminders_crud import (
 from tools_learnings import (
     handle_learning_add, handle_learning_search,
     handle_learning_update, handle_learning_delete, handle_learning_list,
-    handle_learning_quality,
+    handle_learning_quality, handle_learning_resolve_candidate,
 )
 from tools_credentials import (
     handle_credential_get, handle_credential_create,
@@ -1089,6 +1089,19 @@ def nexo_context_router(query: str, intent: str = "answer", limit: int = 4, curr
     return json.dumps(result, ensure_ascii=False)
 
 
+@mcp.tool
+def nexo_cognitive_control_observatory(window_seconds: int = 86400) -> str:
+    """Read-only metrics for Local Context, learnings, followups and intraday memory."""
+    from cognitive_control_observatory import build_cognitive_control_observatory
+
+    return json.dumps(
+        build_cognitive_control_observatory(window_seconds=window_seconds),
+        ensure_ascii=False,
+        indent=2,
+        sort_keys=True,
+    )
+
+
 @mcp.tool
 def nexo_local_asset_get(asset_id: str) -> str:
     """Return one indexed local asset by asset id."""
@@ -1386,6 +1399,23 @@ def nexo_memory_observation_process(limit: int = 25, backfill_limit: int = 100,
     )
 
 
+@mcp.tool
+def nexo_intraday_memory_cycle(limit: int = 20, backfill_limit: int = 20, pending_sla_seconds: int = 3600) -> str:
+    """Run a low-limit daytime memory observation cycle that only publishes evidence-backed intraday facts."""
+    from memory_observation_processor import process_intraday_cycle
+
+    return json.dumps(
+        process_intraday_cycle(
+            process_limit=limit,
+            backfill_limit=backfill_limit,
+            pending_sla_seconds=pending_sla_seconds,
+        ),
+        ensure_ascii=False,
+        indent=2,
+        sort_keys=True,
+    )
+
+
 @mcp.tool
 def nexo_memory_observation_list(
     query: str = "",
@@ -1968,6 +1998,19 @@ def nexo_followup_get(id: str) -> str:
     return handle_followup_get(id)
 
 
+@mcp.tool
+def nexo_followup_lifecycle(limit: int = 500) -> str:
+    """Return followups grouped by lifecycle lane for runner, dashboard and startup parity."""
+    from db import followup_lifecycle_snapshot
+
+    return json.dumps(
+        followup_lifecycle_snapshot(limit=limit),
+        ensure_ascii=False,
+        indent=2,
+        sort_keys=True,
+    )
+
+
 @mcp.tool
 def nexo_followup_update(
     id: str,
@@ -2066,6 +2109,7 @@ def nexo_learning_add(
     review_days: int = 30,
     priority: str = "medium",
     supersedes_id: int = 0,
+    source_authority: str = "explicit_instruction",
 ) -> str:
     """Add a new learning (resolved error, pattern, gotcha).
 
@@ -2079,11 +2123,39 @@ def nexo_learning_add(
         review_days: Days until this learning should be reviewed again (default 30).
         priority: critical, high, medium, low (default: medium). Critical/high never decay below floor.
         supersedes_id: Existing learning ID this new canonical rule replaces (optional).
+        source_authority: Authority tier for conflict resolution: francisco_correction, explicit_instruction, code_test_evidence, deep_sleep, inference.
     """
     return handle_learning_add(
         category, title, content, reasoning,
         prevention=prevention, applies_to=applies_to,
         review_days=review_days, priority=priority, supersedes_id=supersedes_id,
+        source_authority=source_authority,
+    )
+
+
+@mcp.tool
+def nexo_learning_resolve_candidate(
+    category: str,
+    title: str,
+    content: str,
+    reasoning: str = "",
+    prevention: str = "",
+    applies_to: str = "",
+    priority: str = "medium",
+    supersedes_id: int = 0,
+    source_authority: str = "inference",
+) -> str:
+    """Dry-run the canonical learning resolver without creating or updating learnings."""
+    return handle_learning_resolve_candidate(
+        category=category,
+        title=title,
+        content=content,
+        reasoning=reasoning,
+        prevention=prevention,
+        applies_to=applies_to,
+        priority=priority,
+        supersedes_id=supersedes_id,
+        source_authority=source_authority,
     )
 
 

package/src/system_catalog.py

@@ -262,110 +262,110 @@ def _guide_for_tool(name: str) -> dict[str, list]:
     if name == "nexo_learning_add":
         return {
             "workflow": [
-                "Usa `applies_to` si quieres que el guard recuerde este learning antes de tocar un archivo, directorio o patrón concreto.",
-                "Usa `priority` (`critical`, `high`, `medium`, `low`) para marcar severidad operativa.",
+                "Use `applies_to` if you want the pre-edit check to surface this learning before touching a concrete file, directory, or pattern.",
+                "Use `priority` (`critical`, `high`, `medium`, `low`) to mark operational severity.",
             ],
             "examples": [
                 {
-                    "title": "Learning mínimo",
-                    "code": 'nexo_learning_add(category="shopify", title="Hacer pull antes de editar", content="Siempre sincronizar antes de editar el tema live.")',
+                    "title": "Minimal learning",
+                    "code": 'nexo_learning_add(category="shopify", title="Pull before editing", content="Always sync before editing the live theme.")',
                 },
                 {
-                    "title": "Learning ligado a archivo o patrón",
-                    "code": 'nexo_learning_add(category="recambios-bmw", title="Pull antes de editar theme", content="El admin puede tocar JSONs live.", applies_to="/abs/path/templates/product.json,templates/*.json,sections/*.liquid", prevention="Ejecutar `shopify theme pull` antes de editar.", priority="high")',
+                    "title": "Learning linked to a file or pattern",
+                    "code": 'nexo_learning_add(category="recambios-bmw", title="Pull before editing theme", content="The admin can touch live JSON files.", applies_to="/abs/path/templates/product.json,templates/*.json,sections/*.liquid", prevention="Run `shopify theme pull` before editing.", priority="high")',
                 },
             ],
             "common_errors": [
-                "Usar `severity` en vez de `priority`.",
-                "Olvidar `title`, que es obligatorio.",
-                "No poner `applies_to` cuando quieres que el warning salte antes de tocar archivos concretos.",
+                "Using `severity` instead of `priority`.",
+                "Omitting `title`, which is required.",
+                "Omitting `applies_to` when you want the warning to appear before touching concrete files.",
             ],
         }
     if name == "nexo_learning_update":
         return {
             "workflow": [
-                "Úsalo para completar o endurecer un learning existente cuando descubres nuevos archivos afectados, mejor `prevention` o prioridad distinta.",
+                "Use it to complete or harden an existing learning when you discover newly affected files, a better `prevention`, or a different priority.",
             ],
             "examples": [
                 {
-                    "title": "Añadir alcance a un learning existente",
-                    "code": 'nexo_learning_update(id=57, applies_to="/abs/path/file.py,src/plugins/*.py", prevention="Leer schema antes del primer uso", priority="high")',
+                    "title": "Add scope to an existing learning",
+                    "code": 'nexo_learning_update(id=57, applies_to="/abs/path/file.py,src/plugins/*.py", prevention="Read the schema before first use", priority="high")',
                 },
             ],
             "common_errors": [
-                "Intentar recrear el learning desde cero cuando basta con actualizar el existente.",
+                "Recreating the learning from scratch when updating the existing one is enough.",
             ],
         }
     if name == "nexo_reminder_get":
         return {
             "workflow": [
-                "Devuelve el `READ_TOKEN` necesario para `update`, `delete`, `restore` y `note` sobre ese reminder.",
+                "Returns the `READ_TOKEN` required for `update`, `delete`, `restore`, and `note` on that reminder.",
             ],
             "examples": [
                 {
-                    "title": "Leer reminder y obtener token",
+                    "title": "Read reminder and get token",
                     "code": 'nexo_reminder_get(id="R87")',
                 },
             ],
             "common_errors": [
-                "Intentar editar o borrar un reminder sin llamar antes a `nexo_reminder_get`.",
+                "Trying to edit or delete a reminder without calling `nexo_reminder_get` first.",
             ],
         }
     if name in {"nexo_reminder_update", "nexo_reminder_delete", "nexo_reminder_restore", "nexo_reminder_note"}:
         return {
             "workflow": [
-                "Primero llama `nexo_reminder_get(id=\"R87\")` para obtener `READ_TOKEN`.",
-                f"Luego reutiliza ese `READ_TOKEN` en `{name}(...)`.",
+                "First call `nexo_reminder_get(id=\"R87\")` to obtain `READ_TOKEN`.",
+                f"Then reuse that `READ_TOKEN` in `{name}(...)`.",
             ],
             "examples": [
                 {
-                    "title": "1. Obtener token",
+                    "title": "1. Get token",
                     "code": 'nexo_reminder_get(id="R87")',
                 },
                 {
-                    "title": "2. Reutilizar READ_TOKEN",
+                    "title": "2. Reuse READ_TOKEN",
                     "code": f'{name}(id="R87", read_token="TOKEN")',
                 },
             ],
             "common_errors": [
-                "Llamar a esta tool sin `READ_TOKEN` válido.",
-                "Usar un `READ_TOKEN` de otro reminder o de una lectura antigua.",
+                "Calling this tool without a valid `READ_TOKEN`.",
+                "Using a `READ_TOKEN` from another reminder or an older read.",
             ],
         }
     if name == "nexo_followup_get":
         return {
             "workflow": [
-                "Devuelve el `READ_TOKEN` necesario para `update`, `delete`, `restore` y `note` sobre ese followup.",
+                "Returns the `READ_TOKEN` required for `update`, `delete`, `restore`, and `note` on that followup.",
             ],
             "examples": [
                 {
-                    "title": "Leer followup y obtener token",
+                    "title": "Read followup and get token",
                     "code": 'nexo_followup_get(id="NF45")',
                 },
             ],
             "common_errors": [
-                "Intentar editar o borrar un followup sin llamar antes a `nexo_followup_get`.",
+                "Trying to edit or delete a followup without calling `nexo_followup_get` first.",
             ],
         }
     if name in {"nexo_followup_update", "nexo_followup_delete", "nexo_followup_restore", "nexo_followup_note"}:
         return {
             "workflow": [
-                "Primero llama `nexo_followup_get(id=\"NF45\")` para obtener `READ_TOKEN`.",
-                f"Luego reutiliza ese `READ_TOKEN` en `{name}(...)`.",
+                "First call `nexo_followup_get(id=\"NF45\")` to obtain `READ_TOKEN`.",
+                f"Then reuse that `READ_TOKEN` in `{name}(...)`.",
             ],
             "examples": [
                 {
-                    "title": "1. Obtener token",
+                    "title": "1. Get token",
                     "code": 'nexo_followup_get(id="NF45")',
                 },
                 {
-                    "title": "2. Reutilizar READ_TOKEN",
+                    "title": "2. Reuse READ_TOKEN",
                     "code": f'{name}(id="NF45", read_token="TOKEN")',
                 },
             ],
             "common_errors": [
-                "Llamar a esta tool sin `READ_TOKEN` válido.",
-                "Usar un `READ_TOKEN` de otro followup o de una lectura antigua.",
+                "Calling this tool without a valid `READ_TOKEN`.",
+                "Using a `READ_TOKEN` from another followup or an older read.",
             ],
         }
     return {}