nexo-brain 7.23.8 → 7.23.11

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.23.7",
+  "version": "7.23.11",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,9 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.23.6` is the current packaged-runtime line. Patch over v7.23.5 - `nexo update` clears safe legacy `cognitive.db` shadows and keeps superseded archives under runtime backup retention.
+Version `7.23.11` is the current packaged-runtime line. Patch over v7.23.10 - older installed runtimes can update safely even when `cognitive_paths.py` has not been synced yet.
+
+Previously in `7.23.6`: patch over v7.23.5 - `nexo update` clears safe legacy `cognitive.db` shadows and keeps superseded archives under runtime backup retention.
 
 Previously in `7.23.5`: patch over v7.23.4 - `nexo update` keeps external CLI maintenance summary copy in English.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.23.8",
+  "version": "7.23.11",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/auto_update.py

@@ -32,7 +32,23 @@ except ModuleNotFoundError as exc:
             sys.path.insert(0, core_path)
     from product_mode import enforce_desktop_product_contract
 from runtime_home import export_resolved_nexo_home, managed_nexo_home
-from cognitive_paths import cleanup_legacy_cognitive_db_artifacts
+
+try:
+    from cognitive_paths import cleanup_legacy_cognitive_db_artifacts
+except ModuleNotFoundError as exc:
+    if getattr(exc, "name", "") != "cognitive_paths":
+        raise
+
+    # Older installed runtimes may import this newer auto_update.py before
+    # cognitive_paths.py has been copied into place. Keep update importable so
+    # the sync can finish and deliver the missing module.
+    def cleanup_legacy_cognitive_db_artifacts(*, dry_run: bool = False) -> dict:
+        return {
+            "ok": True,
+            "skipped": True,
+            "reason": "cognitive_paths_unavailable_until_runtime_sync",
+            "dry_run": dry_run,
+        }
 
 try:
     from tree_hygiene import is_duplicate_artifact_name

package/src/dashboard/templates/chat.html

@@ -331,14 +331,14 @@ async function sendMessage() {
       const data = await res.json();
       chatHistory.push({
         role: 'nexo',
-        content: data.answer || 'Sin respuesta.',
+        content: data.answer || 'No response.',
         data: data.data || null,
         query_type: data.query_type || null
       });
     }
   } catch (err) {
     hideTyping();
-    chatHistory.push({ role: 'nexo', content: `Error de conexion: ${err.message}` });
+    chatHistory.push({ role: 'nexo', content: `Connection error: ${err.message}` });
   }
 
   isWaiting = false;

package/src/doctor/planes.py

@@ -6,24 +6,24 @@ from doctor.models import DoctorCheck
 
 VALID_DIAGNOSTIC_PLANES = {
     "product_public": {
-        "label": "producto público",
-        "use": "release contracts, artefactos publicados, compare/, docs y surfaces públicas del repo",
+        "label": "public product",
+        "use": "release contracts, published artifacts, compare/, docs, and public repo surfaces",
     },
     "runtime_personal": {
-        "label": "runtime personal",
-        "use": "~/.nexo, scripts personales, followups, reminders y hábitos operativos del operador",
+        "label": "personal runtime",
+        "use": "~/.nexo, personal scripts, followups, reminders, and operator work habits",
     },
     "installation_live": {
-        "label": "instalación viva",
-        "use": "runtime instalado, hooks activos, clientes conectados, cron sync y parity de la instalación local",
+        "label": "live installation",
+        "use": "installed runtime, active hooks, connected clients, cron sync, and local installation parity",
     },
     "database_real": {
-        "label": "BD real",
-        "use": "SQLite/MySQL reales, filas, schema, deudas, sesiones y evidencia persistida",
+        "label": "real database",
+        "use": "real SQLite/MySQL, rows, schema, debts, sessions, and persisted evidence",
     },
     "cooperator": {
-        "label": "co-operador",
-        "use": "comportamiento del agente, protocolo, comunicación y decisiones del asistente",
+        "label": "co-operator",
+        "use": "agent behavior, protocol, communication, and assistant decisions",
     },
 }
 
@@ -53,17 +53,17 @@ def diagnostic_plane_preflight(plane: str = "") -> tuple[str, DoctorCheck | None
             tier="orchestrator",
             status="critical",
             severity="error",
-            summary=f"Plano diagnóstico desconocido: {raw_plane}",
+            summary=f"Unknown diagnostic plane: {raw_plane}",
             evidence=[
-                f"planes válidos: {options}",
-                "Usa `runtime_personal` para ~/.nexo y hábitos del runtime; `installation_live` para hooks/clientes/instalación; `database_real` para filas y schema reales.",
+                f"valid planes: {options}",
+                "Use `runtime_personal` for ~/.nexo and runtime habits; `installation_live` for hooks/clients/installation; `database_real` for real rows and schema.",
             ],
             repair_plan=[
-                "Repite `nexo_doctor` o `nexo doctor` con `plane='runtime_personal'`, `plane='installation_live'` o `plane='database_real'`.",
-                "Si el problema pertenece a producto público o al co-operador, usa el surface correcto en vez de NEXO Doctor.",
+                "Run `nexo_doctor` or `nexo doctor` again with `plane='runtime_personal'`, `plane='installation_live'`, or `plane='database_real'`.",
+                "If the issue belongs to the public product or the co-operator, use the correct surface instead of NEXO Doctor.",
             ],
             escalation_prompt=(
-                "El plano elegido no existe. Repite el diagnóstico con un plano válido para evitar mezclar runtime, instalación, BD real o surfaces ajenas al doctor."
+                "The selected plane does not exist. Repeat the diagnosis with a valid plane to avoid mixing runtime, installation, real DB, or non-doctor surfaces."
             ),
         )
 
@@ -74,17 +74,17 @@ def diagnostic_plane_preflight(plane: str = "") -> tuple[str, DoctorCheck | None
             tier="orchestrator",
             status="degraded",
             severity="warn",
-            summary=f"NEXO Doctor no es la superficie correcta para el plano {plane_info['label']}",
+            summary=f"NEXO Doctor is not the correct surface for the {plane_info['label']} plane",
             evidence=[
                 f"plane: {clean_plane}",
-                f"este plano se diagnostica mejor desde: {plane_info['use']}",
+                f"this plane is better diagnosed from: {plane_info['use']}",
             ],
             repair_plan=[
-                "Si quieres diagnosticar runtime/instalación/BD, vuelve a lanzar el doctor con el plano correcto.",
-                "Si el problema es del producto público o del co-operador, usa release checks, repo checks o herramientas de protocolo/sesión en vez de Doctor.",
+                "If you want to diagnose runtime/installation/DB, rerun the doctor with the correct plane.",
+                "If the issue belongs to the public product or the co-operator, use release checks, repo checks, or protocol/session tools instead of Doctor.",
             ],
             escalation_prompt=(
-                "El plano elegido no corresponde al runtime doctor. Cambia de plano o de herramienta antes de seguir para no mezclar diagnóstico técnico con producto o comportamiento del agente."
+                "The selected plane does not belong to the runtime doctor. Change the plane or tool before continuing so technical diagnosis is not mixed with product or agent behavior."
             ),
         )
 

package/src/plugins/cards.py

@@ -47,8 +47,8 @@ def _api_base() -> str:
     return raw.strip().rstrip("/") or DEFAULT_API_BASE
 
 
-def _normalize_locale(locale: str = "es") -> str:
-    return "en" if str(locale or "").lower().startswith("en") else "es"
+def _normalize_locale(locale: str = "en") -> str:
+    return "es" if str(locale or "").lower().startswith("es") else "en"
 
 
 def _shared_auth_candidates() -> list[Path]:
@@ -126,12 +126,12 @@ def _decode_body(raw: bytes) -> dict[str, Any]:
         return {"raw": raw.decode("utf-8", errors="replace")[:1000]}
 
 
-def _request_json(method: str, path: str, *, body: dict[str, Any] | None = None, locale: str = "es") -> dict[str, Any]:
+def _request_json(method: str, path: str, *, body: dict[str, Any] | None = None, locale: str = "en") -> dict[str, Any]:
     token = _read_token()
     if not token:
         return _error(
             "not_authenticated",
-            "No hay sesión NEXO Desktop disponible para consultar fichas.",
+            "No NEXO Desktop session is available to fetch protocol cards.",
         )
 
     data = json.dumps(body or {}, ensure_ascii=False).encode("utf-8") if body is not None else None
@@ -169,13 +169,13 @@ def _request_json(method: str, path: str, *, body: dict[str, Any] | None = None,
         return _error("network_error", str(exc))
 
 
-def handle_card_catalog(locale: str = "es") -> str:
+def handle_card_catalog(locale: str = "en") -> str:
     """Return the visible official protocol card catalog. Never includes protocols."""
     params = urllib.parse.urlencode({"locale": _normalize_locale(locale)})
     return _json(_request_json("GET", f"/api/cards/catalog?{params}", locale=locale))
 
 
-def handle_card_get(slug: str, locale: str = "es") -> str:
+def handle_card_get(slug: str, locale: str = "en") -> str:
     """Fetch one official protocol card, including protocol text, by slug."""
     clean_slug = str(slug or "").strip()
     if not clean_slug:
@@ -189,7 +189,7 @@ def handle_card_match(
     query: str,
     limit: int = 5,
     include_protocol: bool = True,
-    locale: str = "es",
+    locale: str = "en",
     category: str = "",
     business_type: str = "",
 ) -> str:

package/src/r14_correction_learning.py

@@ -1,11 +1,11 @@
 """r14_correction_learning — detect user corrections and demand a learning_add.
 
-Fase 2 Protocol Enforcer Fase C (Capa 2) item R14. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase C (Layer 2) item R14. Plan doc 1 reads:
 
-  SI último user msg → cognitive_sentiment.is_correction = true
-     O valence < -0.4
-  Y en los 3 tool calls siguientes NO aparece nexo_learning_add
-  ENTONCES inyectar obligación.
+  IF the last user message -> cognitive_sentiment.is_correction = true
+     OR valence < -0.4
+  AND nexo_learning_add does NOT appear in the next 3 tool calls
+  THEN inject the obligation.
 
 Implementation contract:
 

package/src/r15_project_context.py

@@ -1,10 +1,10 @@
 """r15_project_context — demand project context before editing a project path.
 
-Fase 2 Protocol Enforcer Fase D item R15. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase D item R15. Plan doc 1 reads:
 
-  SI user msg menciona entidad type=project registrada
-  Y en sesión no hay nexo_recall(proyecto) NI lectura atlas
-  ENTONCES inyectar obligación.
+  IF the user message mentions a registered entity with type=project
+  AND the session has no nexo_recall(project) nor atlas read
+  THEN inject the obligation.
 
 This module exposes pure helpers:
 

package/src/r16_declared_done.py

@@ -1,10 +1,10 @@
 """r16_declared_done — detect "I'm done" outputs without nexo_task_close.
 
-Fase 2 Protocol Enforcer Fase C (Capa 2) item R16. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase C (Layer 2) item R16. Plan doc 1 reads:
 
-  SI classifier detecta que último output afirma tarea completada
-  Y hay protocol task abierta
-  ENTONCES inyectar obligación task_close con evidence.
+  IF the classifier detects that the last output claims task completion
+  AND there is an open protocol task
+  THEN inject the task_close-with-evidence obligation.
 
 Exposes detect_declared_done(assistant_text, classifier=None) → bool and
 the reminder prompt template. The window-and-state tracking lives in

package/src/r17_promise_debt.py

@@ -1,10 +1,10 @@
 """r17_promise_debt — detect assistant promises that were not executed.
 
-Fase 2 Protocol Enforcer Fase D item R17. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase D item R17. Plan doc 1 reads:
 
-  SI classifier detecta promesa de acción futura en output al usuario
-  Y en los 2 turnos siguientes no hay tool calls relevantes
-  ENTONCES flag promise_debt + recordatorio.
+  IF the classifier detects a future-action promise in user-facing output
+  AND the next 2 turns have no relevant tool calls
+  THEN flag promise_debt + reminder.
 
 Exposes detect_promise(text, classifier) → bool. State (promise window
 countdown) lives in the caller — mirrors the R14 / R16 pattern.
@@ -13,7 +13,7 @@ Classifier path is the same as R14 / R16:
 semantic_router decision_kind ``r17_promise_debt``. Fail-closed on any
 unavailable backend (no promise flagged rather than a false positive).
 
-Mirror: nexo-desktop/lib/r17-promise-debt.js (bundled with Fase D JS
+Mirror: nexo-desktop/lib/r17-promise-debt.js (bundled with Phase D JS
 twins at the end of the tranche).
 """
 from __future__ import annotations

package/src/r18_followup_autocomplete.py

@@ -1,17 +1,17 @@
 """r18_followup_autocomplete — suggest followup_complete retroactively.
 
-Fase 2 Protocol Enforcer Fase D item R18. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase D item R18. Plan doc 1 reads:
 
-  Al abrir sesión: cargar followups activos
-  SI acción ejecutada coincide (>70%) con followup activo
-  ENTONCES sugerir followup_complete.
+  On session open: load active followups
+  IF the executed action matches an active followup (>70%)
+  THEN suggest followup_complete.
 
 R18 is a SUGGESTION rule (not a block). The enforcer emits a single
 reminder per followup hit per turn, and operators / Cortex decide
 whether to actually call nexo_followup_complete.
 
 Reuses the Jaccard matcher from tools_reminders_crud.find_completable_
-followups (Fase B R04 helper) rather than duplicating the matching
+followups (Phase B R04 helper) rather than duplicating the matching
 logic. The trigger signal is the tool_name + tool_input of the agent's
 actions — we build a one-shot "action description" string from those
 and run the R04 matcher over it.

package/src/r19_project_grep.py

@@ -1,10 +1,10 @@
 """r19_project_grep — require Grep before Write on project paths with require_grep flag.
 
-Fase 2 Protocol Enforcer Fase D item R19. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase D item R19. Plan doc 1 reads:
 
-  SI intent Write sobre path de entidad type=project con flag require_grep
-  Y no hubo Grep buscando símbolo/función previamente
-  ENTONCES inyectar obligación grep.
+  IF the intent is Write on a type=project entity path with require_grep
+  AND there was no prior Grep for the symbol/function
+  THEN inject the grep obligation.
 
 Pure decision module — state (projects list, recent_tool_records) is
 owned by the caller (HeadlessEnforcer).

package/src/r20_constant_change.py

@@ -1,10 +1,10 @@
 """r20_constant_change — demand grep-all-usages before changing a constant.
 
-Fase 2 Protocol Enforcer Fase D item R20. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase D item R20. Plan doc 1 reads:
 
-  SI classifier detecta que Edit modifica constante/global/config compartida
-  Y no hubo Grep del símbolo
-  ENTONCES inyectar obligación grep TODOS los usos.
+  IF the classifier detects that Edit changes a shared constant/global/config
+  AND there was no Grep for the symbol
+  THEN inject an obligation to grep ALL usages.
 
 Decision logic is split in two:
 

package/src/r21_legacy_path.py

@@ -1,10 +1,10 @@
 """r21_legacy_path — warn when a command / edit touches a legacy path.
 
-Fase 2 Protocol Enforcer Fase D item R21. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase D item R21. Plan doc 1 reads:
 
-  SI intent Bash o Edit con path contiene entrada de entity_list
+  IF Bash or Edit intent path contains an entity_list entry
      type=legacy_path
-  ENTONCES inyectar recordatorio canónico.
+  THEN inject the canonical reminder.
 
 Pure decision module. Legacy-path entities are seeded at `nexo init`
 from src/presets/entities_universal.json (the ~/claude → ~/.nexo mapping).

package/src/r22_personal_script.py

@@ -1,10 +1,10 @@
 """r22_personal_script — demand context lookup before creating a personal script.
 
-Fase 2 Protocol Enforcer Fase D item R22. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase D item R22. Plan doc 1 reads:
 
-  SI intent nexo_personal_script_create O Write sobre scripts/
-  Y no hubo personal_scripts_list + skill_match + learning_search
-  ENTONCES inyectar obligación.
+  IF the intent is nexo_personal_script_create OR Write under scripts/
+  AND there was no personal_scripts_list + skill_match + learning_search
+  THEN inject the obligation.
 
 R22 fires BEFORE introducing a new personal script to make sure the
 agent first checked:

package/src/r23_ssh_without_atlas.py

@@ -1,10 +1,10 @@
 """r23_ssh_without_atlas — demand atlas lookup before SSHing to an unknown host.
 
-Fase 2 Protocol Enforcer Fase D item R23. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase D item R23. Plan doc 1 reads:
 
-  SI intent Bash con ssh|scp|rsync|curl hacia host
-  Y host no está en entity_list type=host
-  ENTONCES inyectar obligación leer atlas.
+  IF Bash intent uses ssh|scp|rsync|curl toward a host
+  AND the host is not in entity_list type=host
+  THEN inject the atlas-read obligation.
 
 Reuses the host-extraction primitive from r25 (imported lazily to avoid
 a hard dependency — same mirror is provided on the JS side via the r25

package/src/r24_stale_memory.py

@@ -1,10 +1,10 @@
 """r24_stale_memory — warn when a stale memory is cited without verification.
 
-Fase 2 Protocol Enforcer Fase D item R24. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase D item R24. Plan doc 1 reads:
 
-  SI en los últimos 3 turnos se citó dato de recall/memory con age>7
-  Y no hubo tool call de verificación fresh
-  ENTONCES warning.
+  IF the last 3 turns cited recall/memory data with age>7
+  AND there was no fresh verification tool call
+  THEN warn.
 
 Implementation approach:
 

package/src/r25_nora_maria_read_only.py

@@ -1,16 +1,16 @@
 """r25_nora_maria_read_only — block destructive SSH/scp/rsync to read-only hosts.
 
-Fase 2 Protocol Enforcer Fase C (Capa 2) item R25. Plan doc 1 reads:
+Phase 2 Protocol Enforcer Phase C (Layer 2) item R25. Plan doc 1 reads:
 
-  SI intent Bash "ssh" hacia host con entity.access_mode=read_only
-  Y comando incluye verbos destructivos (rm/mv/>/>>/sed -i)
-  Y user message no contiene permiso explícito
-  ENTONCES BLOQUEAR + pedir confirmación.
+  IF Bash "ssh" intent targets a host with entity.access_mode=read_only
+  AND the command includes destructive verbs (rm/mv/>/>>/sed -i)
+  AND the user message contains no explicit permission
+  THEN BLOCK + ask for confirmation.
 
 The enforcer runs in observer mode (headless subprocess, Desktop
 stream wrapper), so "blocking" in practice means enqueueing a hard,
 prominent injection that names the host and the destructive verb.
-The MCP-side guard (Capa 1 learnings #283 / #336 / #358) and the
+The MCP-side guard (Layer 1 learnings #283 / #336 / #358) and the
 system-prompt rule R32 keep the agent from actually issuing the
 command when it honours the reminder.
 

package/src/runtime_versioning.py

@@ -890,15 +890,28 @@ def _mcp_client_readiness(
 ) -> dict:
     generation = runtime_generation(installed_version_value, installed_fp, str(active_runtime_root()))
     process_fp = str(state.get("process_fingerprint") or "").strip()
+    service_fp = str(service_status.get("runtime_fingerprint") or "").strip()
+    effective_process_fp = process_fp or service_fp
     service_ok = bool(service_status.get("ok", True))
     fingerprint_ready = (
         bool(installed_fp)
-        and bool(process_fp)
-        and process_fp != "unknown"
-        and installed_fp == process_fp
+        and bool(effective_process_fp)
+        and effective_process_fp != "unknown"
+        and installed_fp == effective_process_fp
+    )
+    marker_recoverable_reason = str(state.get("reason") or "") in {
+        "marker_required",
+        "process_fingerprint_missing",
+    }
+    marker_recoverable_for_client = (
+        bool(client)
+        and bool(state.get("restart_required"))
+        and marker_recoverable_reason
+        and fingerprint_ready
+        and service_ok
     )
     global_ready = (
-        not bool(state.get("restart_required"))
+        (not bool(state.get("restart_required")) or marker_recoverable_for_client)
         and fingerprint_ready
         and service_ok
     )
@@ -906,13 +919,13 @@ def _mcp_client_readiness(
         global_reason = "runtime_service_unavailable"
     elif not installed_fp:
         global_reason = "installed_fingerprint_missing"
-    elif not process_fp or process_fp == "unknown":
+    elif not effective_process_fp or effective_process_fp == "unknown":
         global_reason = "process_fingerprint_missing"
-    elif installed_fp != process_fp:
+    elif installed_fp != effective_process_fp:
         global_reason = "process_fingerprint_mismatch"
     else:
         global_reason = "ready"
-    if state.get("restart_required"):
+    if state.get("restart_required") and not marker_recoverable_for_client:
         return {
             "runtime_generation": generation,
             "global_ready": False,
@@ -1003,6 +1016,11 @@ def build_mcp_status(*, client: str = "") -> dict:
         service_status=service_status,
     )
     client_states = read_mcp_client_states()
+    service_fp = str(service_status.get("runtime_fingerprint") or "").strip()
+    effective_process_fp = process_fp or service_fp
+    restart_required = bool(state["restart_required"]) and not bool(
+        readiness["client_ready"]
+    )
     return {
         "ok": True,
         "schema_version": MCP_STATUS_SCHEMA_VERSION,
@@ -1013,14 +1031,14 @@ def build_mcp_status(*, client: str = "") -> dict:
         "process_fingerprint": process_fp,
         "fingerprint_match": (
             bool(installed_fp)
-            and bool(process_fp)
-            and process_fp != "unknown"
-            and installed_fp == process_fp
+            and bool(effective_process_fp)
+            and effective_process_fp != "unknown"
+            and installed_fp == effective_process_fp
         ),
         "active_runtime_root": str(active_runtime_root()),
         "active_runtime_version": read_version_for_path(active_runtime_root()),
-        "restart_required": bool(state["restart_required"]),
-        "reason": state["reason"],
+        "restart_required": restart_required,
+        "reason": state["reason"] if restart_required else "",
         "client_action": readiness["client_action"],
         "reason_code": readiness["reason_code"],
         "global_ready": bool(readiness["global_ready"]),

package/src/skills/run-nexo-audit-phase/guide.md

@@ -1,43 +1,43 @@
 # Run NEXO Audit Phase
 
-Usa esta skill cuando haya que ejecutar una fase de auditoria de NEXO y el cuello de botella sea decidir el alcance de `evolution_apply` y arrancar una tanda de items con disciplina empirica.
+Use this skill when a NEXO audit phase must be run and the bottleneck is deciding the `evolution_apply` scope and starting a batch of items with empirical discipline.
 
-## Pasos
-1. Abre `goal + workflow + task` y fija el terreno real antes de interpretar el informe:
-   - repo/runtime activo
-   - DB real
-   - mecanismo de update
-   - tests y estado git
-2. Fija la regla de autonomia antes de empezar:
-   - Francisco no quiere checkpoints uno-a-uno para trabajo mecanico
-   - NEXO hace branches, PRs, merge y reporta despues con evidencia
-   - solo un blast radius arquitectonico enorme merece checkpoint
-3. Trata `evolution_apply` como una decision tecnica de implementacion, no como permiso humano:
-   - el camino de apply ya existe via `evolution_log` + `_apply_accepted_proposals`
-   - el sandbox/snapshot/rollback protege la materializacion del cambio aceptado
-   - no dupliques ese mecanismo en deep sleep ni en el runner de auditoria
-4. Lanza la verificacion empirica de todos los items en paralelo:
-   - `grep + read` del codigo
-   - SQL/schema real
-   - AST/tests/imports/logs cuando aplique
-   - asume FP hasta que la evidencia lo contradiga
-5. Clasifica cada item:
+## Steps
+1. Open `goal + workflow + task` and establish the real surface before interpreting the report:
+   - active repo/runtime
+   - real DB
+   - update mechanism
+   - tests and git status
+2. Set the autonomy rule before starting:
+   - Francisco does not want one-by-one checkpoints for mechanical work
+   - NEXO creates branches, PRs, merges, and reports afterward with evidence
+   - only a huge architectural blast radius deserves a checkpoint
+3. Treat `evolution_apply` as a technical implementation decision, not as human permission:
+   - the apply path already exists through `evolution_log` + `_apply_accepted_proposals`
+   - sandbox/snapshot/rollback protects materialization of the accepted change
+   - do not duplicate that mechanism in deep sleep or the audit runner
+4. Launch empirical verification of all items in parallel:
+   - `grep + read` over code
+   - real SQL/schema
+   - AST/tests/imports/logs when applicable
+   - assume FP until evidence contradicts it
+5. Classify each item:
    - `real_gap`
-   - `casi_fp`
+   - `near_fp`
    - `fp`
-6. Ordena solo los `real_gap` por riesgo/blast radius y ejecutalos con worktree aislado si tocan core.
-7. Por cada `real_gap`:
+6. Order only `real_gap` items by risk/blast radius and execute them with an isolated worktree if they touch core.
+7. For each `real_gap`:
    - `guard_check`
    - `track`
-   - branch propia
-   - implementacion minima
-   - tests adyacentes
+   - dedicated branch
+   - minimal implementation
+   - adjacent tests
    - PR + auto-merge squash
-   - seguir al siguiente sin esperar CI salvo bloqueo real
-8. Para `fp` o `casi_fp`, captura learning/patron reusable en vez de reimplementar.
-9. Cierra la fase con evidencia real: PRs, tests, merge status y resultados de verificacion.
+   - continue to the next item without waiting for CI unless there is a real blocker
+8. For `fp` or `near_fp`, capture a learning/reusable pattern instead of reimplementing.
+9. Close the phase with real evidence: PRs, tests, merge status, and verification results.
 
 ## Gotchas
-- Learning #198: no confundas "como trabaja NEXO" con "que puede aplicar evolution_apply". Lo primero ya esta resuelto: autonomia total.
-- `apply_findings.py` ya stagea `code_change` en `evolution_log`; `nexo-evolution-run.py` ya consume `accepted` con sandbox/snapshot/rollback. Si el item pide eso, primero verifica si ya existe.
-- En Fase 1+2 la auditoria automatica sobreestimo ~70% de gaps. Si no hay evidencia dura, no abras codigo.
+- Learning #198: do not confuse "how NEXO works" with "what evolution_apply may apply". The first is already settled: full autonomy.
+- `apply_findings.py` already stages `code_change` in `evolution_log`; `nexo-evolution-run.py` already consumes `accepted` with sandbox/snapshot/rollback. If the item asks for that, first verify whether it already exists.
+- In Phase 1+2 the automated audit overestimated about 70% of gaps. If there is no hard evidence, do not open code.

package/src/skills/run-nexo-audit-phase/skill.json

@@ -1,7 +1,7 @@
 {
   "id": "SK-RUN-NEXO-AUDIT-PHASE",
   "name": "Run NEXO Audit Phase",
-  "description": "Workflow para ejecutar una fase de auditoria de NEXO con autonomia total y verificacion empirica. Cubre el patron repetido de decidir el scope de evolution_apply y arrancar una tanda de items sin checkpoints manuales.",
+  "description": "Workflow for running a NEXO audit phase with full autonomy and empirical verification. Covers the recurring pattern of deciding the evolution_apply scope and starting a batch of items without manual checkpoints.",
   "level": "published",
   "mode": "guide",
   "source_kind": "core",
@@ -17,26 +17,26 @@
   ],
   "trigger_patterns": [
     "evolution_apply sandbox scope",
-    "fase 2 item 1",
-    "arrancar verificacion empirica",
-    "ejecutar fase de auditoria nexo",
+    "phase 2 item 1",
+    "start empirical verification",
+    "run nexo audit phase",
     "audit phase nexo",
     "7 items audit"
   ],
   "steps": [
-    "Abrir goal, workflow y task antes de tocar la auditoria; resolver repo/runtime real, DB real, tests y estado git antes de interpretar el informe.",
-    "Fijar la regla de autonomia: NEXO hace branches, PRs, merge y progreso periodico; no pedir checkpoints uno-a-uno a Francisco para trabajo mecanico.",
-    "Para `evolution_apply`, separar dos planos: el sandbox es para materializar/aplicar cambios aceptados con snapshot/rollback; no es un freno para el modo de trabajo autonomo del agente.",
-    "Lanzar verificacion empirica de TODOS los items en paralelo: grep+read, SQL/schema real, AST/tests, logs. Partir de la hipotesis de FP hasta tener evidencia.",
-    "Clasificar cada item en `real_gap`, `casi_fp` o `fp` y ordenar solo los reales por blast radius/riesgo.",
-    "Si hay que tocar core, usar worktree aislado; por item real: guard_check -> track -> branch -> implement -> tests adyacentes -> PR -> auto-merge squash.",
-    "Para items FP o casi-FP, capturar learning o ajustar el patron reusable en vez de reimplementar.",
-    "Cerrar con evidencia de PRs, tests y merge status reales; no usar diarios o workflow text como sustituto."
+    "Open the goal, workflow, and task before touching the audit; resolve the real repo/runtime, real DB, tests, and git status before interpreting the report.",
+    "Set the autonomy rule: NEXO creates branches, PRs, merges, and periodic progress reports; do not ask Francisco for one-by-one checkpoints for mechanical work.",
+    "For `evolution_apply`, separate two planes: the sandbox materializes/applies accepted changes with snapshot/rollback; it is not a brake on the agent's autonomous work mode.",
+    "Launch empirical verification of ALL items in parallel: grep+read, real SQL/schema, AST/tests, logs. Start from the FP hypothesis until evidence says otherwise.",
+    "Classify each item as `real_gap`, `near_fp`, or `fp`, and order only real items by blast radius/risk.",
+    "If core must be touched, use an isolated worktree; for each real item: guard_check -> track -> branch -> implement -> adjacent tests -> PR -> auto-merge squash.",
+    "For FP or near-FP items, capture a learning or adjust the reusable pattern instead of reimplementing.",
+    "Close with real PR, test, and merge-status evidence; do not use diaries or workflow text as substitutes."
   ],
   "gotchas": [
-    "No pedir aprobacion manual a Francisco para cada PR: learning #198 confirma autonomia total con transparencia y reportes periodicos.",
-    "No duplicar el sandbox de evolution en otros sitios: el apply de cambios aceptados ya reutiliza evolution_log + sandbox/snapshot/rollback.",
-    "El ratio historico de FPs en esta clase de auditoria es alto; si no hay evidencia concreta, el item no se toca."
+    "Do not ask Francisco for manual approval on every PR: learning #198 confirms full autonomy with transparency and periodic reports.",
+    "Do not duplicate the evolution sandbox elsewhere: accepted-change apply already reuses evolution_log + sandbox/snapshot/rollback.",
+    "The historical FP rate for this audit class is high; if there is no concrete evidence, the item is not touched."
   ],
   "params_schema": {
     "audit_file": {

package/src/skills/run-nexo-core-fix-cycle/guide.md

@@ -1,17 +1,17 @@
 # Run NEXO Core Fix Cycle
 
-Usa esta skill cuando haya que implementar y verificar un grupo pequeño de fixes del core de NEXO sin improvisar el plano ni repetir siempre la misma fase de descubrimiento y test.
+Use this skill when a small group of NEXO core fixes must be implemented and verified without improvising the plane or repeating the same discovery and test phase every time.
 
 ## Steps
-1. Fija primero el plano: repo público `nexo`, runtime instalado `~/.nexo` y claims/documentación pública. No mezcles esos tres mundos.
-2. Abre `nexo_task_open(...)` y `nexo_workflow_open(...)` antes de tocar código. Si el fix es de acción, pasa también por `nexo_cortex_decide(...)`.
-3. Ejecuta la skill con `areas` ajustadas al fix. El helper te devuelve el mapa de archivos y corre la batería de tests focalizada para `protocol`, `plane`, `guard`, `cortex` y/o `release`.
-4. Implementa el cambio mínimo defendible solo en la superficie correcta. Si el problema es producto, se arregla en el repo; no en `~/.nexo`.
-5. Reejecuta la skill para revalidar el clúster exacto de tests tocado por el fix.
-6. Cierra con `nexo_task_close(...)` y evidencia real. Si hubo edición real, deja `change_log` y captura learning si cambió una regla canónica.
+1. First fix the plane: public `nexo` repo, installed `~/.nexo` runtime, and public claims/docs. Do not mix those three worlds.
+2. Open `nexo_task_open(...)` and `nexo_workflow_open(...)` before touching code. If the fix is action-related, also pass through `nexo_cortex_decide(...)`.
+3. Run the skill with `areas` adjusted to the fix. The helper returns the file map and runs the focused test battery for `protocol`, `plane`, `guard`, `cortex`, and/or `release`.
+4. Implement the smallest defensible change only on the correct surface. If the problem is product-level, fix it in the repo, not in `~/.nexo`.
+5. Rerun the skill to revalidate the exact test cluster touched by the fix.
+6. Close with `nexo_task_close(...)` and real evidence. If there was a real edit, leave `change_log` and capture a learning if a canonical rule changed.
 
 ## Gotchas
-- No uses diary, workflow text o intuición como sustituto de git/tests/runtime reales.
-- Si el fix toca doctor o claims públicos, fija el `plane` explícito antes de ejecutar diagnósticos.
-- Si el fix toca release o runtime update, usa la vía oficial (`nexo update`, doctor, skill de release final) y no scripts laterales.
-- Si el helper no encuentra un área, añade la superficie nueva de forma explícita en la skill en vez de seguir repitiendo grep manual disperso.
+- Do not use diary, workflow text, or intuition as a substitute for real git/tests/runtime evidence.
+- If the fix touches doctor or public claims, set the explicit `plane` before running diagnostics.
+- If the fix touches release or runtime update, use the official path (`nexo update`, doctor, final release skill), not side scripts.
+- If the helper does not find an area, add the new surface explicitly to the skill instead of continuing scattered manual grep.

package/src/skills/run-nexo-core-fix-cycle/skill.json

@@ -1,7 +1,7 @@
 {
   "id": "SK-RUN-NEXO-CORE-FIX-CYCLE",
   "name": "Run NEXO Core Fix Cycle",
-  "description": "Mapea las superficies core impactadas y ejecuta la verificación focalizada para ciclos pequeños de fixes de NEXO sin mezclar repo público, runtime y claims no verificados.",
+  "description": "Map impacted core surfaces and run focused verification for small NEXO fix cycles without mixing the public repo, runtime, and unverified claims.",
   "level": "published",
   "mode": "hybrid",
   "source_kind": "core",
@@ -16,11 +16,11 @@
     "verification"
   ],
   "trigger_patterns": [
-    "dos fixes core nexo",
+    "two nexo core fixes",
     "core fix cycle",
-    "enforcement protocolario",
-    "plano antes del diagnostico",
-    "ciclo fix core nexo"
+    "protocol enforcement",
+    "plane before diagnosis",
+    "nexo core fix cycle"
   ],
   "params_schema": {
     "areas": {

package/templates/core-prompts/t4-r15-project-context-gate.md

@@ -4,8 +4,8 @@ Examples:
 + User: "Vamos a arreglar el bug del checkout" -> yes
 + User: "Hazme un refactor del login de CanaRirural" -> yes
 + User: "Revisa la PR del orchestrator" -> yes
-- User: "qué hora es" -> no
-- User: "gracias, ya está" -> no
+- User: "what time is it" -> no
+- User: "thanks, that's done" -> no
 - User: "dime un chiste" -> no
 
 Now decide. Input: