nexo-brain 7.23.13 → 7.24.0

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/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 {}

package/src/tools_learnings.py

@@ -1,16 +1,25 @@
 """Learnings CRUD tools: add, search, update, delete, list."""
 
+import json
 import os
 import re
+import unicodedata
 from datetime import datetime
 
 from db import (create_learning, update_learning, delete_learning, search_learnings,
                 list_learnings, find_similar_learnings, get_db, now_epoch, supersede_learning, extract_keywords,
                 resolve_session_correction_requirements)
+from learning_resolver import (
+    applies_overlap as _canonical_applies_overlap,
+    looks_contradictory as _canonical_looks_contradictory,
+    resolve_learning_candidate,
+)
 
 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"),
@@ -23,6 +32,15 @@ CONTRADICTION_PAIRS = (
     ("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"),
 )
 
 
@@ -40,26 +58,13 @@ def _normalize_applies_token(value: str) -> str:
 
 
 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 "/" in left_token or "/" in right_token:
-                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
+    return _canonical_applies_overlap(left, right)
 
 
 def _normalize_text(text: str) -> str:
-    return re.sub(r"\s+", " ", str(text or "").strip().lower())
+    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]:
@@ -67,7 +72,7 @@ def _tokenize(text: str) -> list[str]:
 
 
 def _contains_negation(text: str) -> bool:
-    lowered = _normalize_text(text)
+    lowered = f" {_normalize_text(text)} "
     return any(token in lowered for token in NEGATION_PATTERNS)
 
 
@@ -75,37 +80,16 @@ def _negated_action_verbs(text: str) -> set[str]:
     lowered = _normalize_text(text)
     matches = set()
     for pattern in (
-        r"(?:never|avoid|skip|disable|remove|forbid|bypass)\s+([a-z0-9_-]+)",
-        r"(?:do not|don't)\s+([a-z0-9_-]+)",
+        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 (existing_tokens & new_tokens):
-        return False
-    existing_negated_verbs = _negated_action_verbs(existing_norm)
-    new_negated_verbs = _negated_action_verbs(new_norm)
-    if existing_negated_verbs & new_tokens and not existing_negated_verbs & new_negated_verbs:
-        return True
-    if new_negated_verbs & existing_tokens and not existing_negated_verbs & new_negated_verbs:
-        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
+    return _canonical_looks_contradictory(existing_text, new_text)
 
 
 def _find_conflicting_active_learning(conn, *, category: str, title: str, content: str,
@@ -286,7 +270,8 @@ def score_learning_quality(row: dict, conn=None) -> dict:
 
 def handle_learning_add(category: str, title: str, content: str, reasoning: str = '',
                         prevention: str = '', applies_to: str = '', review_days: int = 30,
-                        priority: str = 'medium', supersedes_id: int = 0) -> str:
+                        priority: str = 'medium', supersedes_id: int = 0,
+                        source_authority: str = 'explicit_instruction') -> str:
     """Add a new learning entry to the specified category.
 
     Args:
@@ -304,15 +289,55 @@ def handle_learning_add(category: str, title: str, content: str, reasoning: str
     category = category.lower().strip()
     if not category:
         return "ERROR: Category cannot be empty."
-    # Dedup guard: block exact title duplicates in same category
     conn = get_db()
-    existing = conn.execute(
-        "SELECT id, title FROM learnings WHERE LOWER(title) = LOWER(?) AND category = ? AND status = 'active'",
-        (title.strip(), category)
-    ).fetchone()
-    if existing:
-        _resolve_pending_correction_learning(int(existing["id"]))
-        return f"Learning #{existing['id']} already exists with same title in {category}: {existing['title']}. Use nexo_learning_update to modify it."
+    resolution = resolve_learning_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,
+        conn=conn,
+    )
+    if resolution["action"] == "reject":
+        return f"ERROR: Learning candidate rejected: {resolution['reason']}."
+    if resolution["action"] == "merge":
+        existing_id = int(resolution.get("target_id") or 0)
+        existing = conn.execute("SELECT id, title, weight FROM learnings WHERE id = ?", (existing_id,)).fetchone()
+        if existing:
+            if resolution.get("reason") == "exact_title_duplicate":
+                _resolve_pending_correction_learning(existing_id)
+                return f"Learning #{existing['id']} already exists with same title in {category}: {existing['title']}. Use nexo_learning_update to modify it."
+            old_weight = float(existing["weight"] or 0.0)
+            new_weight = min(1.0, old_weight + 0.1)
+            conn.execute(
+                "UPDATE learnings SET weight = ?, updated_at = ? WHERE id = ?",
+                (new_weight, now_epoch(), existing_id),
+            )
+            conn.commit()
+            _resolve_pending_correction_learning(existing_id)
+            return (
+                f"Learning #{existing_id} resolved as merge ({resolution['reason']}, similarity "
+                f"{float(resolution.get('similarity') or 0):.2f}). No duplicate created. "
+                f"Weight bumped {old_weight:.2f} -> {new_weight:.2f}. Use nexo_learning_update(id={existing_id}) "
+                "to refine the canonical text."
+            )
+    if resolution["action"] == "conflict_review":
+        conflicting = {
+            "id": resolution.get("target_id"),
+            "title": resolution.get("target_title"),
+            "applies_to": applies_to,
+        }
+        return (
+            f"ERROR: Contradictory active learning #{conflicting['id']} already exists for applies_to="
+            f"{conflicting.get('applies_to', '')}: {conflicting['title']}. "
+            f"Supersede or update the existing canonical rule instead of creating two active file rules."
+        )
+    if resolution["action"] == "supersede":
+        supersedes_id = int(resolution.get("target_id") or supersedes_id or 0)
 
     # ── R05 (Fase 2 Protocol Enforcer): auto-merge on high Jaccard similarity ──
     # When a near-duplicate active learning exists (Jaccard >= R05 threshold),
@@ -356,19 +381,6 @@ def handle_learning_add(category: str, title: str, content: str, reasoning: str
                     f"→ {new_weight:.2f}. Use nexo_learning_update(id={existing_id}) if you need to "
                     "refine the canonical text."
                 )
-    conflicting = _find_conflicting_active_learning(
-        conn,
-        category=category,
-        title=title,
-        content=content,
-        applies_to=applies_to,
-    )
-    if conflicting and int(supersedes_id or 0) != int(conflicting["id"]):
-        return (
-            f"ERROR: Contradictory active learning #{conflicting['id']} already exists for applies_to="
-            f"{conflicting.get('applies_to', '')}: {conflicting['title']}. "
-            f"Supersede or update the existing canonical rule instead of creating two active file rules."
-        )
     result = create_learning(
         category, title, content, reasoning=reasoning, supersedes_id=(int(supersedes_id) if supersedes_id else None)
     )
@@ -508,6 +520,25 @@ def handle_learning_add(category: str, title: str, content: str, reasoning: str
     return f"Learning #{result['id']} added in {category}: {title}{meta_str} ✓verified{repetition_msg}{retro_meta_msg}{correction_msg}"
 
 
+def handle_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 mutating state."""
+    result = resolve_learning_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,
+    )
+    return json.dumps(result, ensure_ascii=False, indent=2)
+
+
 def handle_learning_search(query: str, category: str = '') -> str:
     """Search learnings by query string, optionally filtered by category."""
     results = search_learnings(query, category if category else None)

package/src/tools_memory_v2.py

@@ -173,8 +173,8 @@ def handle_memory_timeline(
     result = memory_timeline(query, project_hint=project_hint, time_range=time_range, limit=limit)
     candidates = result.get("candidates") or []
     if not candidates:
-        return "No hay eventos suficientes para construir timeline."
-    lines = [f"MEMORY TIMELINE ({len(candidates)}) — {query or time_range or '(sin query)'}"]
+        return "There are not enough events to build a timeline."
+    lines = [f"MEMORY TIMELINE ({len(candidates)}) — {query or time_range or '(no query)'}"]
     for item in candidates:
         refs = item.get("evidence_refs") or []
         refs_note = f" refs={', '.join(refs[:3])}" if refs else ""

package/src/tools_sessions.py

@@ -1334,10 +1334,21 @@ def handle_context_packet(area: str, files: str = "") -> str:
         parts.append("")
 
     # 3. Active followups for this area
-    followups = conn.execute(
-        "SELECT id, description, date, verification FROM followups WHERE status = 'PENDING' AND (description LIKE ? OR verification LIKE ?) ORDER BY date ASC LIMIT 10",
+    from db import followup_lifecycle_lane, normalize_followup_status
+
+    followup_rows = conn.execute(
+        "SELECT id, description, date, verification, status, owner FROM followups "
+        "WHERE (description LIKE ? OR verification LIKE ?) ORDER BY date ASC LIMIT 50",
         (f"%{area}%", f"%{area}%")
     ).fetchall()
+    followups = []
+    for row in followup_rows:
+        item = dict(row)
+        item["status"] = normalize_followup_status(item.get("status"))
+        if followup_lifecycle_lane(item) == "active":
+            followups.append(item)
+        if len(followups) >= 10:
+            break
     if followups:
         parts.append("## ACTIVE FOLLOWUPS")
         for f in followups:
@@ -1479,11 +1490,18 @@ def handle_smart_startup_query() -> str:
         sent_email_block = ""
 
     # 1. Pending followups (what NEXO needs to do)
-    followups = conn.execute(
-        "SELECT description FROM followups WHERE status = 'PENDING' ORDER BY date ASC LIMIT 5"
-    ).fetchall()
-    for f in followups:
-        query_parts.append(f['description'][:100])
+    try:
+        from db import followup_lifecycle_snapshot
+
+        active_followups = (followup_lifecycle_snapshot(limit=500).get("lanes") or {}).get("active", [])[:5]
+        for f in active_followups:
+            query_parts.append(str(f.get("description") or "")[:100])
+    except Exception:
+        followups = conn.execute(
+            "SELECT description FROM followups WHERE status = 'PENDING' ORDER BY date ASC LIMIT 5"
+        ).fetchall()
+        for f in followups:
+            query_parts.append(f['description'][:100])
 
     # 2. Due reminders (what the user needs to know)
     reminders = conn.execute(