nexo-brain 7.23.13 → 7.24.0

package/src/learning_resolver.py

@@ -0,0 +1,419 @@
+from __future__ import annotations
+
+"""Canonical learning candidate resolver.
+
+This module decides what should happen to an incoming learning before any
+caller mutates the learnings table. It deliberately returns a decision only;
+MCP tools, Deep Sleep, validators and self-audit own the actual write.
+"""
+
+import re
+import sqlite3
+import unicodedata
+from typing import Any
+
+from db import extract_keywords, get_db
+from db._semantic_similarity import hybrid_similarity_score
+
+
+AUTHORITY_RANKS: dict[str, int] = {
+    "francisco_correction": 100,
+    "explicit_instruction": 80,
+    "code_test_evidence": 60,
+    "deep_sleep": 40,
+    "inference": 20,
+}
+
+CANONICAL_ACTIONS = ("new", "merge", "supersede", "conflict_review", "reject")
+
+NEGATION_PATTERNS = (
+    "do not", "don't", "never", "avoid", "skip", "without", "forbid", "forbidden",
+    "disable", "disabled", "remove", "ban", "bypass",
+    " no ", " nunca ", " evita ", " evitar ", " sin ", " prohibe ", " prohibido ",
+    " desactiva ", " desactivar ", " elimina ", " eliminar ", " bloquea ", " bloquear ",
+)
+CONTRADICTION_PAIRS = (
+    ("enable", "disable"),
+    ("use", "avoid"),
+    ("add", "remove"),
+    ("allow", "forbid"),
+    ("always", "never"),
+    ("before", "after"),
+    ("require", "skip"),
+    ("validate", "skip"),
+    ("validate", "bypass"),
+    ("include", "exclude"),
+    ("activar", "desactivar"),
+    ("usar", "evitar"),
+    ("usar", "no usar"),
+    ("editar", "no editar"),
+    ("tocar", "no tocar"),
+    ("anadir", "eliminar"),
+    ("permitir", "prohibir"),
+    ("validar", "saltar"),
+    ("incluir", "excluir"),
+)
+
+
+def normalize_authority(value: str | None) -> str:
+    clean = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
+    aliases = {
+        "francisco": "francisco_correction",
+        "user_correction": "francisco_correction",
+        "correction": "francisco_correction",
+        "explicit": "explicit_instruction",
+        "operator": "explicit_instruction",
+        "manual": "explicit_instruction",
+        "code": "code_test_evidence",
+        "test": "code_test_evidence",
+        "evidence": "code_test_evidence",
+        "deep": "deep_sleep",
+        "deepsleep": "deep_sleep",
+        "overnight": "deep_sleep",
+        "inferred": "inference",
+    }
+    clean = aliases.get(clean, clean)
+    return clean if clean in AUTHORITY_RANKS else "inference"
+
+
+def authority_rank(value: str | None) -> int:
+    return AUTHORITY_RANKS[normalize_authority(value)]
+
+
+def _normalize_text(text: str) -> str:
+    normalized = unicodedata.normalize("NFKD", str(text or ""))
+    ascii_text = "".join(ch for ch in normalized if not unicodedata.combining(ch))
+    return re.sub(r"\s+", " ", ascii_text.strip().lower())
+
+
+def _tokenize(text: str) -> list[str]:
+    return re.findall(r"[a-z0-9_-]+", _normalize_text(text))
+
+
+def _token_sets_related(left: set[str], right: set[str]) -> bool:
+    if left & right:
+        return True
+    for left_token in left:
+        for right_token in right:
+            if len(left_token) < 5 or len(right_token) < 5:
+                continue
+            if left_token.startswith(right_token[:5]) or right_token.startswith(left_token[:5]):
+                return True
+    return False
+
+
+def _contains_negation(text: str) -> bool:
+    lowered = f" {_normalize_text(text)} "
+    return any(token in lowered for token in NEGATION_PATTERNS)
+
+
+def _negated_action_verbs(text: str) -> set[str]:
+    lowered = _normalize_text(text)
+    matches: set[str] = set()
+    for pattern in (
+        r"(?:never|avoid|skip|disable|remove|forbid|bypass|nunca|evita|evitar|desactiva|desactivar|elimina|eliminar|prohibe|prohibir|bloquea|bloquear)\s+([a-z0-9_-]+)",
+        r"(?:do not|don't|no)\s+([a-z0-9_-]+)",
+        r"(?:without|sin)\s+([a-z0-9_-]+)",
+    ):
+        matches.update(re.findall(pattern, lowered))
+    return {match for match in matches if len(match) > 2}
+
+
+def looks_contradictory(existing_text: str, new_text: str) -> bool:
+    existing_norm = _normalize_text(existing_text)
+    new_norm = _normalize_text(new_text)
+    if not existing_norm or not new_norm:
+        return False
+    existing_tokens = set(_tokenize(existing_norm))
+    new_tokens = set(_tokenize(new_norm))
+    if not _token_sets_related(existing_tokens, new_tokens):
+        return False
+    existing_negated = _negated_action_verbs(existing_norm)
+    new_negated = _negated_action_verbs(new_norm)
+    if existing_negated & new_tokens and not existing_negated & new_negated:
+        return True
+    if new_negated & existing_tokens and not existing_negated & new_negated:
+        return True
+    if _contains_negation(existing_norm) != _contains_negation(new_norm):
+        return True
+    for positive, negative in CONTRADICTION_PAIRS:
+        existing_has_pair = positive in existing_norm or negative in existing_norm
+        new_has_pair = positive in new_norm or negative in new_norm
+        if existing_has_pair and new_has_pair:
+            if (positive in existing_norm and negative in new_norm) or (negative in existing_norm and positive in new_norm):
+                return True
+    return False
+
+
+def _split_applies_to(applies_to: str) -> list[str]:
+    return [item.strip() for item in str(applies_to or "").split(",") if item.strip()]
+
+
+def _normalize_applies_token(value: str) -> str:
+    return str(value or "").replace("\\", "/").rstrip("/").lower()
+
+
+def applies_overlap(left: str, right: str) -> bool:
+    left_tokens = {_normalize_applies_token(item) for item in _split_applies_to(left)}
+    right_tokens = {_normalize_applies_token(item) for item in _split_applies_to(right)}
+    left_tokens.discard("")
+    right_tokens.discard("")
+    if not left_tokens or not right_tokens:
+        return False
+    if left_tokens & right_tokens:
+        return True
+    for left_token in left_tokens:
+        for right_token in right_tokens:
+            if "/" not in left_token and "/" not in right_token:
+                continue
+            if left_token.startswith(f"{right_token}/") or right_token.startswith(f"{left_token}/"):
+                return True
+            if left_token.endswith(f"/{right_token}") or right_token.endswith(f"/{left_token}"):
+                return True
+    return False
+
+
+def _table_columns(conn: sqlite3.Connection, table: str) -> set[str]:
+    try:
+        return {str(row["name"]) for row in conn.execute(f"PRAGMA table_info({table})").fetchall()}
+    except Exception:
+        return set()
+
+
+def _row_authority_rank(row: dict[str, Any]) -> int:
+    text = " ".join(
+        str(row.get(key) or "")
+        for key in ("title", "content", "reasoning", "prevention")
+    ).lower()
+    if "francisco" in text or "correction" in text or "correccion" in text:
+        return AUTHORITY_RANKS["francisco_correction"]
+    priority = str(row.get("priority") or "medium").strip().lower()
+    return {
+        "critical": 85,
+        "high": 70,
+        "medium": 50,
+        "low": 30,
+    }.get(priority, 50)
+
+
+def _similarity(candidate_text: str, row: dict[str, Any]) -> float:
+    existing_text = f"{row.get('title') or ''} {row.get('content') or ''}".strip()
+    if not candidate_text or not existing_text:
+        return 0.0
+    return float(
+        hybrid_similarity_score(
+            candidate_text,
+            existing_text,
+            keyword_extractor=extract_keywords,
+            strong_semantic_threshold=0.82,
+            moderate_semantic_threshold=0.74,
+            moderate_keyword_floor=0.08,
+        )
+    )
+
+
+def _decision(
+    *,
+    action: str,
+    reason: str,
+    target: dict[str, Any] | None,
+    similarity: float = 0.0,
+    source_authority: str,
+    existing_rank: int = 0,
+    candidate: dict[str, Any],
+) -> dict[str, Any]:
+    normalized_authority = normalize_authority(source_authority)
+    return {
+        "ok": action != "reject",
+        "action": action,
+        "allowed_actions": list(CANONICAL_ACTIONS),
+        "reason": reason,
+        "target_id": int(target.get("id") or 0) if target else 0,
+        "target_title": str(target.get("title") or "") if target else "",
+        "target_status": str(target.get("status") or "") if target else "",
+        "similarity": round(float(similarity or 0.0), 4),
+        "source_authority": normalized_authority,
+        "authority_rank": AUTHORITY_RANKS[normalized_authority],
+        "existing_authority_rank": int(existing_rank or 0),
+        "candidate": candidate,
+    }
+
+
+def resolve_learning_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",
+    conn: sqlite3.Connection | None = None,
+) -> dict[str, Any]:
+    """Return the canonical action for an incoming learning candidate."""
+
+    clean_category = str(category or "").strip().lower()
+    clean_title = str(title or "").strip()
+    clean_content = str(content or "").strip()
+    candidate = {
+        "category": clean_category,
+        "title": clean_title,
+        "content_preview": clean_content[:240],
+        "applies_to": str(applies_to or "").strip(),
+        "priority": str(priority or "medium").strip().lower(),
+        "supersedes_id": int(supersedes_id or 0),
+    }
+    if not clean_category:
+        return _decision(
+            action="reject",
+            reason="category_required",
+            target=None,
+            source_authority=source_authority,
+            candidate=candidate,
+        )
+    if not clean_title or not clean_content:
+        return _decision(
+            action="reject",
+            reason="title_and_content_required",
+            target=None,
+            source_authority=source_authority,
+            candidate=candidate,
+        )
+
+    own_conn = conn is None
+    conn = conn or get_db()
+    try:
+        columns = _table_columns(conn, "learnings")
+        if not columns:
+            return _decision(
+                action="new",
+                reason="learnings_table_unavailable",
+                target=None,
+                source_authority=source_authority,
+                candidate=candidate,
+            )
+        status_filter = " AND COALESCE(status, 'active') = 'active'" if "status" in columns else ""
+        order_by = "updated_at DESC, id DESC" if "updated_at" in columns else "id DESC"
+        rows = conn.execute(
+            f"""
+            SELECT *
+              FROM learnings
+             WHERE category = ?
+               {status_filter}
+             ORDER BY {order_by}
+             LIMIT 500
+            """,
+            (clean_category,),
+        ).fetchall()
+        active_rows = [dict(row) for row in rows]
+    finally:
+        if own_conn:
+            pass
+
+    incoming_text = f"{clean_title} {clean_content}".strip()
+    incoming_rank = authority_rank(source_authority)
+    best_sim: tuple[float, dict[str, Any] | None] = (0.0, None)
+    conflict: dict[str, Any] | None = None
+    conflict_similarity = 0.0
+
+    for row in active_rows:
+        row_title = str(row.get("title") or "").strip()
+        row_content = str(row.get("content") or "").strip()
+        if row_title.lower() == clean_title.lower():
+            return _decision(
+                action="merge",
+                reason="exact_title_duplicate",
+                target=row,
+                similarity=1.0,
+                source_authority=source_authority,
+                existing_rank=_row_authority_rank(row),
+                candidate=candidate,
+            )
+
+        row_applies = str(row.get("applies_to") or "")
+        scoped_overlap = bool(applies_to and row_applies and applies_overlap(row_applies, applies_to))
+        if scoped_overlap and looks_contradictory(f"{row_title} {row_content}", incoming_text):
+            sim = _similarity(incoming_text, row)
+            conflict = row
+            conflict_similarity = sim
+            break
+
+        sim = _similarity(incoming_text, row)
+        if sim > best_sim[0]:
+            best_sim = (sim, row)
+
+    if conflict:
+        existing_rank = _row_authority_rank(conflict)
+        normalized_authority = normalize_authority(source_authority)
+        if int(supersedes_id or 0) == int(conflict.get("id") or 0):
+            return _decision(
+                action="supersede",
+                reason="explicit_supersedes_conflict",
+                target=conflict,
+                similarity=conflict_similarity,
+                source_authority=source_authority,
+                existing_rank=existing_rank,
+                candidate=candidate,
+            )
+        can_auto_supersede = (
+            normalized_authority == "francisco_correction"
+            or (
+                normalized_authority == "explicit_instruction"
+                and incoming_rank >= existing_rank
+                and existing_rank < AUTHORITY_RANKS["code_test_evidence"]
+            )
+        )
+        if can_auto_supersede:
+            return _decision(
+                action="supersede",
+                reason="higher_authority_conflict",
+                target=conflict,
+                similarity=conflict_similarity,
+                source_authority=source_authority,
+                existing_rank=existing_rank,
+                candidate=candidate,
+            )
+        return _decision(
+            action="conflict_review",
+            reason="conflicting_active_learning",
+            target=conflict,
+            similarity=conflict_similarity,
+            source_authority=source_authority,
+            existing_rank=existing_rank,
+            candidate=candidate,
+        )
+
+    best_score, best_row = best_sim
+    if best_row and best_score >= 0.85:
+        return _decision(
+            action="merge",
+            reason="high_similarity",
+            target=best_row,
+            similarity=best_score,
+            source_authority=source_authority,
+            existing_rank=_row_authority_rank(best_row),
+            candidate=candidate,
+        )
+
+    return _decision(
+        action="new",
+        reason="no_active_match",
+        target=None,
+        similarity=best_score,
+        source_authority=source_authority,
+        existing_rank=0,
+        candidate=candidate,
+    )
+
+
+__all__ = [
+    "AUTHORITY_RANKS",
+    "CANONICAL_ACTIONS",
+    "applies_overlap",
+    "authority_rank",
+    "looks_contradictory",
+    "normalize_authority",
+    "resolve_learning_candidate",
+]

package/src/lifecycle_events.py

@@ -574,17 +574,17 @@ def write_fallback_diary_for_lifecycle_event(
     technical_reason = str(reason or lifecycle_reason or "fallback-diary").strip()
     diary_session_id = _preferred_diary_session_id(conn, session_id)
     summary = (
-        "Diario automatico de emergencia generado por NEXO Desktop al cerrar "
-        f"'{title}'. No se confirmo un diario escrito por el agente vivo, asi "
-        "que se preserva el snapshot disponible para continuidad."
+        "Automatic emergency diary generated by NEXO Desktop when closing "
+        f"'{title}'. No diary written by the live agent was confirmed, so "
+        "the available snapshot is preserved for continuity."
     )
     decisions = (
-        f"Accion de ciclo de vida: {action}. Evento: {event_id}. "
-        f"Motivo tecnico: {technical_reason}."
+        f"Lifecycle action: {action}. Event: {event_id}. "
+        f"Technical reason: {technical_reason}."
     )
     pending = str(payload.get("current_goal") or payload.get("last_user_message") or "").strip()
     if not pending:
-        pending = "Revisar la conversacion al reabrir y continuar desde el snapshot preservado."
+        pending = "Review the conversation on reopen and continue from the preserved snapshot."
     context_next_parts = [
         f"conversation_id={conversation_id}",
         f"session_id={session_id}",
@@ -602,10 +602,10 @@ def write_fallback_diary_for_lifecycle_event(
         discarded="",
         pending=pending,
         context_next=context_next,
-        mental_state="Fallback automatico: el agente vivo no confirmo el cierre dentro del timeout.",
+        mental_state="Automatic fallback: the live agent did not confirm closure within the timeout.",
         domain="nexo-desktop",
-        user_signals="Cierre/archivo de conversacion; preservar informacion antes de salir.",
-        self_critique="El cierre no debe depender exclusivamente de que el agente responda a tiempo.",
+        user_signals="Conversation close/archive; preserve information before exit.",
+        self_critique="Closure must not depend exclusively on the agent responding in time.",
         source=source or "desktop-lifecycle-fallback",
     )
     return {

package/src/local_context/api.py

@@ -3177,7 +3177,61 @@ def _entity_matches_for_query(conn, query: str, *, limit: int) -> tuple[list[dic
     return matches[: int(limit)], boosts
 
 
-def _context_candidate_rows(conn, entity_asset_ids: list[str], *, base_limit: int = 5000) -> list:
+def _context_prefilter_limit(default: int = 1200) -> int:
+    raw = os.environ.get("NEXO_LOCAL_CONTEXT_PREFILTER_LIMIT", str(default))
+    try:
+        value = int(raw)
+    except Exception:
+        value = default
+    return max(100, min(value, 5000))
+
+
+def _context_candidate_rows(
+    conn,
+    entity_asset_ids: list[str],
+    *,
+    search_query: str = "",
+    base_limit: int = 5000,
+) -> list:
+    terms = _query_terms(search_query)[:6]
+    prefilter_limit = min(int(base_limit or 5000), _context_prefilter_limit())
+    prefilter_rows = []
+    if terms:
+        term_clauses = []
+        params: list[str] = []
+        for term in terms:
+            term_clauses.append("(lower(a.path) LIKE ? OR lower(COALESCE(v.summary, '')) LIKE ? OR lower(c.text) LIKE ?)")
+            like = f"%{term}%"
+            params.extend([like, like, like])
+        prefilter_rows = conn.execute(
+            f"""
+            SELECT c.chunk_id, c.asset_id, c.text, a.path, a.file_type, a.privacy_class, v.summary,
+                   e.vector_json, e.model_id, e.model_revision, e.dimension
+            FROM local_chunks c
+            JOIN local_assets a ON a.asset_id = c.asset_id
+            LEFT JOIN local_asset_versions v ON v.version_id = c.version_id
+            LEFT JOIN local_embeddings e ON e.chunk_id = c.chunk_id
+            WHERE a.status='active'
+              AND a.privacy_class='normal'
+              AND ({" OR ".join(term_clauses)})
+            ORDER BY
+              CASE
+                WHEN {" OR ".join("lower(a.path) LIKE ?" for _ in terms)} THEN 0
+                WHEN {" OR ".join("lower(COALESCE(v.summary, '')) LIKE ?" for _ in terms)} THEN 1
+                ELSE 2
+              END,
+              c.created_at DESC
+            LIMIT ?
+            """,
+            [
+                *params,
+                *(f"%{term}%" for term in terms),
+                *(f"%{term}%" for term in terms),
+                prefilter_limit,
+            ],
+        ).fetchall()
+
+    fallback_limit = prefilter_limit if not terms else max(120, min(500, prefilter_limit // 3))
     base_rows = conn.execute(
         """
         SELECT c.chunk_id, c.asset_id, c.text, a.path, a.file_type, a.privacy_class, v.summary,
@@ -3191,10 +3245,18 @@ def _context_candidate_rows(conn, entity_asset_ids: list[str], *, base_limit: in
         ORDER BY c.created_at DESC
         LIMIT ?
         """,
-        (int(base_limit),),
+        (int(fallback_limit),),
     ).fetchall()
     if not entity_asset_ids:
-        return base_rows
+        rows = []
+        seen_chunks = set()
+        for row in [*prefilter_rows, *base_rows]:
+            chunk_id = row["chunk_id"]
+            if chunk_id in seen_chunks:
+                continue
+            seen_chunks.add(chunk_id)
+            rows.append(row)
+        return rows
 
     placeholders = ",".join("?" for _ in entity_asset_ids)
     entity_rows = conn.execute(
@@ -3216,7 +3278,7 @@ def _context_candidate_rows(conn, entity_asset_ids: list[str], *, base_limit: in
 
     rows = []
     seen_chunks = set()
-    for row in [*entity_rows, *base_rows]:
+    for row in [*entity_rows, *prefilter_rows, *base_rows]:
         chunk_id = row["chunk_id"]
         if chunk_id in seen_chunks:
             continue
@@ -3618,7 +3680,7 @@ def _context_query_conn(
     query_embedding = embeddings.embed_record(search_query)
     qvec = query_embedding["vector"]
     entities_payload, entity_boosts = _entity_matches_for_query(conn, search_query, limit=max(int(limit), 1))
-    rows = _context_candidate_rows(conn, list(entity_boosts.keys()), base_limit=5000)
+    rows = _context_candidate_rows(conn, list(entity_boosts.keys()), search_query=search_query, base_limit=5000)
     scored = []
     stale_embedding_seen = False
     for row in rows:

package/src/local_context/usage_events.py

@@ -310,6 +310,8 @@ def _empty_summary(*, since: float, window_seconds: int, store_path: Path) -> di
         "latest_event_at": 0.0,
         "latest_used_before_response_at": 0.0,
         "by_intent": {},
+        "by_source": {},
+        "by_route_stage": {},
     }
 
 
@@ -371,6 +373,26 @@ def summarize_usage(
             """,
             (since,),
         ).fetchall()
+        source_rows = conn.execute(
+            f"""
+            SELECT source, COUNT(*) AS total
+            FROM {USAGE_TABLE}
+            WHERE created_at >= ?
+            GROUP BY source
+            ORDER BY total DESC, source ASC
+            """,
+            (since,),
+        ).fetchall()
+        stage_rows = conn.execute(
+            f"""
+            SELECT route_stage, COUNT(*) AS total
+            FROM {USAGE_TABLE}
+            WHERE created_at >= ?
+            GROUP BY route_stage
+            ORDER BY total DESC, route_stage ASC
+            """,
+            (since,),
+        ).fetchall()
     finally:
         conn.close()
     return {
@@ -386,6 +408,8 @@ def summarize_usage(
         "latest_event_at": float(totals["latest_event_at"] or 0.0),
         "latest_used_before_response_at": float(totals["latest_used_before_response_at"] or 0.0),
         "by_intent": {str(row["intent"]): int(row["total"] or 0) for row in intent_rows},
+        "by_source": {str(row["source"]): int(row["total"] or 0) for row in source_rows},
+        "by_route_stage": {str(row["route_stage"]): int(row["total"] or 0) for row in stage_rows},
     }
 
 

package/src/memory_observation_processor.py

@@ -16,6 +16,8 @@ import db
 DEFAULT_BACKFILL_LIMIT = 100
 DEFAULT_PENDING_SLA_SECONDS = 3600
 DEFAULT_PROCESS_LIMIT = 100
+DEFAULT_INTRADAY_PROCESS_LIMIT = 20
+DEFAULT_INTRADAY_BACKFILL_LIMIT = 20
 MAX_BATCH_SIZE = 1000
 
 
@@ -275,3 +277,29 @@ def process_incremental(
         "processed": processed,
         "health": health,
     }
+
+
+def process_intraday_cycle(
+    *,
+    process_limit: int = DEFAULT_INTRADAY_PROCESS_LIMIT,
+    backfill_limit: int = DEFAULT_INTRADAY_BACKFILL_LIMIT,
+    pending_sla_seconds: int = DEFAULT_PENDING_SLA_SECONDS,
+    now: float | None = None,
+) -> dict:
+    """Run the low-limit daytime path for evidence-backed intraday facts."""
+
+    return {
+        **process_incremental(
+            process_limit=_clamp_limit(process_limit, DEFAULT_INTRADAY_PROCESS_LIMIT),
+            backfill_limit=_clamp_limit(backfill_limit, DEFAULT_INTRADAY_BACKFILL_LIMIT),
+            pending_sla_seconds=pending_sla_seconds,
+            now=now,
+        ),
+        "mode": "intraday",
+        "limits": {
+            "process_limit": _clamp_limit(process_limit, DEFAULT_INTRADAY_PROCESS_LIMIT),
+            "backfill_limit": _clamp_limit(backfill_limit, DEFAULT_INTRADAY_BACKFILL_LIMIT),
+            "pending_sla_seconds": max(1, int(pending_sla_seconds or DEFAULT_PENDING_SLA_SECONDS)),
+        },
+        "promotion": "hot_context_intraday_fact_only",
+    }

package/src/memory_retrieval.py

@@ -246,8 +246,8 @@ def memory_timeline(query: str = "", *, project_hint: str = "", time_range: str
 def format_memory_search(result: dict) -> str:
     candidates = result.get("candidates") or []
     if not candidates:
-        return "No hay evidencia suficiente en Memory Observations para esa consulta."
-    lines = [f"MEMORY SEARCH ({len(candidates)}) — {result.get('query') or '(sin query)'}"]
+        return "There is not enough evidence in Memory Observations for that query."
+    lines = [f"MEMORY SEARCH ({len(candidates)}) — {result.get('query') or '(no query)'}"]
     for item in candidates:
         refs = item.get("evidence_refs") or []
         refs_note = f" refs={', '.join(refs[:3])}" if refs else " refs=none"
@@ -269,10 +269,10 @@ def answer_memory_question(query: str, *, project_hint: str = "", time_range: st
     candidates = result.get("candidates") or []
     evidence_candidates = [item for item in candidates if item.get("evidence_refs")]
     if not evidence_candidates:
-        return "No tengo evidencia suficiente en la memoria nueva para responder eso sin inventar."
-    lines = ["Respuesta basada en evidencia:"]
+        return "There is not enough evidence in new memory to answer that without inventing."
+    lines = ["Evidence-based answer:"]
     for item in evidence_candidates[:limit]:
         refs = item.get("evidence_refs") or []
-        refs_note = ", ".join(refs[:3]) if refs else "sin refs"
+        refs_note = ", ".join(refs[:3]) if refs else "no refs"
         lines.append(f"- {item.get('summary')} ({refs_note})")
     return "\n".join(lines)

package/src/operator_language.py

@@ -13,6 +13,8 @@ _LANGUAGE_LABELS = {
     "en": "English (en)",
     "es": "Spanish (es)",
     "fr": "French (fr)",
+    "gl": "Galician (gl)",
+    "eu": "Basque (eu)",
     "it": "Italian (it)",
     "ja": "Japanese (ja)",
     "pt": "Portuguese (pt)",