nexo-brain 7.23.13 → 7.25.0

package/src/scripts/deep-sleep/apply_findings.py

@@ -33,6 +33,7 @@ if str(NEXO_CODE) not in sys.path:
 import db as nexo_db
 import paths
 from cognitive_paths import resolve_cognitive_db
+from learning_resolver import resolve_learning_candidate
 
 def _resolve_nexo_db() -> Path:
     candidates = [
@@ -161,21 +162,24 @@ def _top_followups_by_impact(limit: int = 5) -> list[dict]:
             conn.close()
             return []
         impact_factors_sql = ", impact_factors" if "impact_factors" in columns else ""
-        rows = [
-            dict(row)
-            for row in conn.execute(
-                f"""SELECT id, description, date, priority, impact_score{impact_factors_sql}
-                    FROM followups
-                    WHERE status IN ('PENDING', 'ACTIVE', 'WAITING', 'BLOCKED')
-                    ORDER BY
-                      CASE WHEN COALESCE(impact_score, 0) > 0 THEN 0 ELSE 1 END ASC,
-                      COALESCE(impact_score, 0) DESC,
-                      CASE WHEN date IS NULL OR date = '' THEN 1 ELSE 0 END ASC,
-                      date ASC
-                    LIMIT ?""",
-                (max(1, int(limit)),),
-            ).fetchall()
-        ]
+        owner_sql = ", owner" if "owner" in columns else ""
+        rows = []
+        for row in conn.execute(
+            f"""SELECT id, description, date, priority, impact_score, status{owner_sql}{impact_factors_sql}
+                FROM followups
+                ORDER BY
+                  CASE WHEN COALESCE(impact_score, 0) > 0 THEN 0 ELSE 1 END ASC,
+                  COALESCE(impact_score, 0) DESC,
+                  CASE WHEN date IS NULL OR date = '' THEN 1 ELSE 0 END ASC,
+                  date ASC
+                LIMIT ?""",
+            (max(20, int(limit) * 4),),
+        ).fetchall():
+            item = dict(row)
+            if nexo_db.followup_lifecycle_lane(item) == "active":
+                rows.append(item)
+            if len(rows) >= max(1, int(limit)):
+                break
         conn.close()
     except Exception:
         return []
@@ -501,6 +505,18 @@ def _find_learning_match(category: str, title: str, content: str) -> dict | None
     return candidates[0]
 
 
+def _learning_by_id(learning_id: int) -> dict | None:
+    if not learning_id or not NEXO_DB.exists():
+        return None
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    try:
+        row = conn.execute("SELECT * FROM learnings WHERE id = ?", (int(learning_id),)).fetchone()
+        return dict(row) if row else None
+    finally:
+        conn.close()
+
+
 def _update_learning_row(learning_id: int, updates: dict[str, object]) -> None:
     if not updates:
         return
@@ -545,7 +561,34 @@ def add_learning(category: str, title: str, content: str) -> dict:
     if not NEXO_DB.exists():
         return {"success": False, "error": "nexo.db not found"}
     try:
-        existing = _find_learning_match(category, title, content)
+        resolution = resolve_learning_candidate(
+            category=category,
+            title=title,
+            content=content,
+            source_authority="deep_sleep",
+        )
+        if resolution["action"] == "reject":
+            return {"success": False, "error": resolution["reason"], "outcome": "rejected_learning"}
+        if resolution["action"] == "conflict_review":
+            return _flag_learning_contradiction(
+                {
+                    "id": resolution.get("target_id"),
+                    "title": resolution.get("target_title"),
+                    "_similarity": resolution.get("similarity", 0.0),
+                },
+                category,
+                title,
+                content,
+            )
+
+        canonical_supersedes_id = int(resolution.get("target_id") or 0) if resolution["action"] == "supersede" else 0
+        existing = None if canonical_supersedes_id else _find_learning_match(category, title, content)
+        if resolution["action"] == "merge" and int(resolution.get("target_id") or 0):
+            row = _learning_by_id(int(resolution["target_id"]))
+            if row:
+                existing = dict(row)
+                existing["_similarity"] = float(resolution.get("similarity") or 1.0)
+                existing["_contradiction"] = False
         if existing:
             similarity = existing.get("_similarity", 0.0)
             if existing.get("_contradiction"):
@@ -631,7 +674,21 @@ def add_learning(category: str, title: str, content: str) -> dict:
         learning_id = cursor.lastrowid
         conn.commit()
         conn.close()
-        return {"success": True, "id": learning_id, "outcome": "new_learning"}
+        if canonical_supersedes_id:
+            try:
+                nexo_db.supersede_learning(
+                    int(canonical_supersedes_id),
+                    int(learning_id),
+                    f"Superseded by Deep Sleep canonical learning #{learning_id}.",
+                )
+            except Exception:
+                pass
+        return {
+            "success": True,
+            "id": learning_id,
+            "outcome": "new_learning" if not canonical_supersedes_id else "superseding_learning",
+            "supersedes_id": canonical_supersedes_id,
+        }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
@@ -677,6 +734,11 @@ def create_followup(description: str, date: str = "", reasoning_note: str = "",
         )
         if followup_result.get("error"):
             return {"success": False, "error": followup_result["error"]}
+        if desired_status.lower() == "archived":
+            conn = sqlite3.connect(str(NEXO_DB))
+            conn.execute("UPDATE followups SET status = ? WHERE id = ?", ("archived", fid))
+            conn.commit()
+            conn.close()
         if desired_status != "PENDING":
             nexo_db.add_followup_note(
                 fid,

package/src/scripts/nexo-backup.sh

@@ -2,6 +2,8 @@
 # NEXO DB hourly backup — crontab: 0 * * * * $NEXO_HOME/core/scripts/nexo-backup.sh
 NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
 NEXO_DIR="$NEXO_HOME"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+CORE_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 BACKUP_DIR="$NEXO_HOME/runtime/backups"
 if [ ! -d "$BACKUP_DIR" ] && [ -d "$NEXO_HOME/backups" ]; then
     BACKUP_DIR="$NEXO_HOME/backups"
@@ -23,7 +25,35 @@ LOCAL_CONTEXT_MAX_BACKUP_BYTES="${NEXO_LOCAL_CONTEXT_MAX_BACKUP_BYTES:-214748364
 
 mkdir -p "$BACKUP_DIR" "$WEEKLY_DIR"
 
+reconcile_memory_fabric_before_prune() {
+    python3 - "$BACKUP_DIR" "$CORE_DIR" <<'PY' >/dev/null 2>&1 || true
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+backup_dir = Path(sys.argv[1])
+core_dir = Path(sys.argv[2])
+for candidate in (core_dir, core_dir.parent / "src"):
+    if candidate.exists():
+        sys.path.insert(0, str(candidate))
+
+try:
+    import memory_fabric
+
+    memory_fabric.reconcile_backup_diaries(
+        backups_root=backup_dir,
+        max_backup_files=80,
+        limit=10000,
+    )
+except Exception:
+    pass
+PY
+}
+
 cleanup_backups() {
+    reconcile_memory_fabric_before_prune
+
     PRUNER="$NEXO_HOME/core/scripts/prune_runtime_backups.py"
     if [ ! -f "$PRUNER" ]; then
         PRUNER="$(dirname "$0")/prune_runtime_backups.py"

package/src/scripts/nexo-daily-self-audit.py

@@ -75,6 +75,7 @@ from constants import AUTOMATION_SUBPROCESS_TIMEOUT
 from core_prompts import render_core_prompt
 from cognitive_paths import audit_cognitive_db_paths, resolve_cognitive_db
 import db as nexo_db
+from learning_resolver import applies_overlap, looks_contradictory, resolve_learning_candidate
 from public_evolution_queue import queue_public_port_candidate
 
 try:
@@ -390,12 +391,34 @@ def _upsert_inline_learning(
         return {"ok": False, "reason": "learnings_missing"}
 
     columns = _table_columns(conn, "learnings")
+    resolution = resolve_learning_candidate(
+        category=category,
+        title=title,
+        content=content,
+        reasoning=reasoning,
+        prevention=prevention,
+        applies_to=applies_to,
+        priority=priority,
+        source_authority="code_test_evidence",
+        conn=conn,
+    )
+    if resolution["action"] == "reject":
+        return {"ok": False, "reason": resolution["reason"], "resolver": resolution}
+    if resolution["action"] == "conflict_review":
+        return {"ok": False, "reason": "conflict_review_required", "resolver": resolution}
+    resolver_target_id = int(resolution.get("target_id") or 0)
+    supersede_target_id = resolver_target_id if resolution["action"] == "supersede" else 0
     rows = conn.execute(
         "SELECT * FROM learnings WHERE COALESCE(status, 'active') != 'superseded' ORDER BY updated_at DESC, id DESC LIMIT 200"
     ).fetchall()
     target_signature = _topic_signature(f"{title} {content}")
     existing = None
     for row in rows:
+        if resolution["action"] == "merge" and resolver_target_id and int(row["id"]) == resolver_target_id:
+            existing = row
+            break
+        if supersede_target_id:
+            continue
         row_title = str(row["title"] or "").strip() if "title" in columns else ""
         row_content = str(row["content"] or "").strip() if "content" in columns else ""
         row_applies = str(row["applies_to"] or "").strip() if "applies_to" in columns else ""
@@ -471,6 +494,13 @@ def _upsert_inline_learning(
         list(values.values()),
     )
     learning_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
+    if supersede_target_id:
+        _supersede_learning_inline(
+            conn,
+            keep_id=int(learning_id),
+            retire_id=supersede_target_id,
+            note=f"Self-audit canonical resolver superseded learning #{supersede_target_id}.",
+        )
     return {"ok": True, "action": "created", "learning_id": int(learning_id)}
 
 
@@ -681,8 +711,8 @@ def _retire_stale_audit_goals_inline(
                    closed_at = ?
                WHERE goal_id = ?""",
             (
-                "Ninguna. Placeholder stale retirado automáticamente; el self-audit lo recreará si el patrón reaparece.",
-                f"Self-audit placeholder stale >{max_age_hours}h sin workflow runs abiertos.",
+                "None. Stale placeholder removed automatically; self-audit will recreate it if the pattern reappears.",
+                f"Self-audit placeholder stale >{max_age_hours}h without open workflow runs.",
                 now_iso,
                 now_iso,
                 row["goal_id"],
@@ -853,15 +883,20 @@ def check_overdue_reminders():
 def check_overdue_followups():
     if not NEXO_DB.exists():
         return
-    conn = sqlite3.connect(str(NEXO_DB))
     today = datetime.now().strftime("%Y-%m-%d")
-    rows = conn.execute(
-        "SELECT description, date FROM followups WHERE status='PENDING' AND date < ? AND date != '' ORDER BY date",
-        (today,)
-    ).fetchall()
-    conn.close()
+    try:
+        active = (nexo_db.followup_lifecycle_snapshot(limit=5000).get("lanes") or {}).get("active", [])
+        rows = [item for item in active if item.get("date") and str(item["date"]) < today]
+        rows.sort(key=lambda item: str(item.get("date") or ""))
+    except Exception:
+        conn = sqlite3.connect(str(NEXO_DB))
+        rows = conn.execute(
+            "SELECT description, date FROM followups WHERE status='PENDING' AND date < ? AND date != '' ORDER BY date",
+            (today,)
+        ).fetchall()
+        conn.close()
     if rows:
-        finding("WARN", "followups", f"{len(rows)} overdue: {', '.join(r[0][:40] for r in rows[:5])}")
+        finding("WARN", "followups", f"{len(rows)} overdue: {', '.join(str((r.get('description') if isinstance(r, dict) else r[0]) or '')[:40] for r in rows[:5])}")
 
 
 def check_uncommitted_changes():
@@ -1156,8 +1191,6 @@ def check_learning_contradictions():
         conn.close()
         return
 
-    from tools_learnings import _applies_overlap, _looks_contradictory
-
     rows = conn.execute(
         """SELECT id, title, content, applies_to
            FROM learnings
@@ -1168,9 +1201,9 @@ def check_learning_contradictions():
     contradictions: list[tuple[sqlite3.Row, sqlite3.Row]] = []
     for index, left in enumerate(rows):
         for right in rows[index + 1:]:
-            if not _applies_overlap(left["applies_to"], right["applies_to"]):
+            if not applies_overlap(left["applies_to"], right["applies_to"]):
                 continue
-            if not _looks_contradictory(
+            if not looks_contradictory(
                 f"{left['title']} {left['content']}",
                 f"{right['title']} {right['content']}",
             ):

package/src/scripts/nexo-email-migrate-config.py

@@ -171,8 +171,8 @@ def main(argv: list[str]) -> int:
             is_default=False,
         )
         print(
-            f"(cuenta '{args.label}' ya existe — email={account.get('email')}, "
-            "normalizo el contrato agente y sólo completo buzones del operador faltantes)."
+            f"(account '{args.label}' already exists — email={account.get('email')}, "
+            "normalizing the agent contract and only filling missing operator mailboxes)."
         )
     else:
         account = add_email_account(

package/src/scripts/nexo-email-monitor.py

@@ -395,12 +395,12 @@ def load_config():
             return cfg
     except Exception:
         pass
-    # v0.32.5 — graceful return None when no email setup yet. Antes esto
-    # lanzaba FileNotFoundError y el cron de cada minuto generaba 1440
-    # filas de error/día por cliente sin email configurado. 50 clientes
-    # pagados sin email setup → 72k filas de error/día → watchdog L2
-    # alertas falsas → ruido en logs y posible token burn. Ahora el
-    # cron retorna sin error cuando no hay config.
+    # v0.32.5 — return None gracefully when no email setup exists yet. Before
+    # this, FileNotFoundError bubbled up and the once-per-minute cron generated
+    # 1,440 error rows per day per client without configured email. 50 paid
+    # clients without email setup meant 72k error rows/day, false watchdog L2
+    # alerts, log noise, and possible token burn. The cron now returns without
+    # error when config is absent.
     try:
         with open(CONFIG_PATH) as f:
             payload = json.load(f)
@@ -952,8 +952,8 @@ def scan_debt(db_path=EMAIL_DB_PATH, *, max_items=5):
             {
                 "email_id": row["email_id"],
                 "kind": "ack",
-                "label": f"ACK sin cierre >{DEBT_SLA_HOURS}h — {row['subject'] or row['email_id']} [{row['email_id']}]",
-                "detail": f"ack desde {row['last_ack_ts']}",
+                "label": f"ACK without closure >{DEBT_SLA_HOURS}h — {row['subject'] or row['email_id']} [{row['email_id']}]",
+                "detail": f"ack since {row['last_ack_ts']}",
             }
         )
 
@@ -979,8 +979,8 @@ def scan_debt(db_path=EMAIL_DB_PATH, *, max_items=5):
             {
                 "email_id": row["email_id"],
                 "kind": "commitment",
-                "label": f"COMPROMISO sin cierre >{DEBT_SLA_HOURS}h — {row['subject'] or row['email_id']} [{row['email_id']}]",
-                "detail": f"commitment desde {row['last_commitment_ts']}",
+                "label": f"COMMITMENT without closure >{DEBT_SLA_HOURS}h — {row['subject'] or row['email_id']} [{row['email_id']}]",
+                "detail": f"commitment since {row['last_commitment_ts']}",
             }
         )
 
@@ -1932,13 +1932,13 @@ def _localized_operator_escalation_email(
     details: str,
 ) -> tuple[str, str]:
     if _uses_spanish(operator_language):
-        subject = f"[NEXO] Emails que necesitan atención manual ({exhausted_count})"
+        subject = f"[NEXO] Emails requiring manual attention ({exhausted_count})"
         body = (
-            f"Hola {operator_name},\n\n"
-            f"Los siguientes emails ya se han intentado {MAX_EMAIL_ATTEMPTS} veces "
-            f"sin completarse correctamente (la sesión cae antes de terminar):\n\n{details}\n\n"
-            "Los he marcado como `needs_interactive`. "
-            f"Abre {assistant_name} Desktop y pregúntale por ese email para resolverlo manualmente.\n\n"
+            f"Hello {operator_name},\n\n"
+            f"The following emails have already been attempted {MAX_EMAIL_ATTEMPTS} times "
+            f"without succeeding (the session dies before completion):\n\n{details}\n\n"
+            "I marked them as `needs_interactive`. "
+            f"Open {assistant_name} Desktop and ask about the affected email so it can be resolved manually.\n\n"
             f"— {assistant_name}"
         )
         return subject, body
@@ -2494,9 +2494,9 @@ def main():
             return
 
         config = load_config()
-        # v0.32.5 — exit cleanly cuando no hay email setup.
-        # Antes el FileNotFoundError propagaba a 1440 errores/día por
-        # cliente Win sin email. Ahora salimos en silencio.
+        # v0.32.5 — exit cleanly when no email setup exists. Before this,
+        # FileNotFoundError bubbled up to 1,440 errors/day per Windows client
+        # without email. Now the monitor exits silently.
         if config is None:
             log.info("No email config — skipping monitor check.")
             return

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

@@ -5,8 +5,9 @@ NEXO Followup Hygiene — Weekly cleanup of followup/reminder statuses.
 
 Runs Sundays via LaunchAgent (or manually). Tasks:
 1. Normalize dirty statuses (COMPLETED YYYY-MM-DD -> COMPLETED)
-2. Escalate PENDING followups >14 days without updates to needs_decision
-3. Generate summary of orphaned/forgotten followups for synthesis
+2. Move PENDING followups >14 days without updates to stale_review
+3. Expire stale_review followups that stayed untouched for the TTL window
+4. Generate summary of orphaned/forgotten followups for synthesis
 
 No CLI needed — this is pure mechanical cleanup.
 """
@@ -32,6 +33,7 @@ COORD_DIR = paths.coordination_dir()
 LOG_FILE = paths.logs_dir() / "followup-hygiene.log"
 
 TODAY = date.today().isoformat()
+EXPIRE_STALE_REVIEW_DAYS = int(os.environ.get("NEXO_FOLLOWUP_EXPIRE_STALE_REVIEW_DAYS", "90") or "90")
 
 
 def log(msg):
@@ -91,7 +93,7 @@ def main():
     stale = conn.execute(
         "SELECT id, description, date, updated_at FROM followups "
         "WHERE status NOT LIKE 'COMPLETED%' "
-        "AND status NOT IN ('DELETED','archived','blocked','waiting','needs_decision','waiting_user') "
+        "AND UPPER(COALESCE(status, '')) NOT IN ('DELETED','ARCHIVED','BLOCKED','WAITING','WAITING_EXTERNAL','NEEDS_DECISION','WAITING_USER','PARKED','STALE_REVIEW','EXPIRED','DONE') "
         "AND date != '' AND date < ? "
         "AND (updated_at IS NULL OR updated_at = '' OR updated_at < ?) "
         "ORDER BY date",
@@ -106,23 +108,51 @@ def main():
         for s in stale:
             result = nexo_db.update_followup(
                 str(s["id"]),
-                status="needs_decision",
+                status="stale_review",
                 date=TODAY,
                 history_actor="followup-hygiene",
                 history_event="stale_triage",
                 history_note=(
-                    "Weekly hygiene escalated this old due followup to needs_decision "
+                    "Weekly hygiene moved this old due followup to stale_review "
                     "instead of leaving it in the executable briefing indefinitely."
                 ),
             )
             if not result.get("error"):
                 escalated_stale.append(str(s["id"]))
 
-    # 3. Orphaned followups (no date, no recent update)
+    # 3. Expire stale_review followups that received no decision for the TTL window
+    expire_cutoff = datetime.now().timestamp() - (max(1, EXPIRE_STALE_REVIEW_DAYS) * 24 * 60 * 60)
+    expirable = conn.execute(
+        "SELECT id, description, updated_at FROM followups "
+        "WHERE UPPER(COALESCE(status, '')) = 'STALE_REVIEW' "
+        "AND (updated_at IS NULL OR updated_at = '' OR updated_at < ?) "
+        "ORDER BY updated_at ASC",
+        (expire_cutoff,),
+    ).fetchall()
+    expired_ids = []
+    if expirable:
+        log(f"Expiring {len(expirable)} stale_review followups untouched for >{EXPIRE_STALE_REVIEW_DAYS} days:")
+        for item in expirable[:10]:
+            log(f"  {item['id']}: {item['description'][:60]}")
+        for item in expirable:
+            result = nexo_db.update_followup(
+                str(item["id"]),
+                status="expired",
+                history_actor="followup-hygiene",
+                history_event="expired",
+                history_note=(
+                    f"Weekly hygiene expired stale_review followup after "
+                    f"{EXPIRE_STALE_REVIEW_DAYS} days without movement."
+                ),
+            )
+            if not result.get("error"):
+                expired_ids.append(str(item["id"]))
+
+    # 4. Orphaned followups (no date, no recent update)
     orphans = conn.execute(
         "SELECT id, description FROM followups "
         "WHERE status NOT LIKE 'COMPLETED%' "
-        "AND status NOT IN ('DELETED','archived','blocked','waiting') "
+        "AND UPPER(COALESCE(status, '')) NOT IN ('DELETED','ARCHIVED','BLOCKED','WAITING','WAITING_EXTERNAL','NEEDS_DECISION','WAITING_USER','PARKED','STALE_REVIEW','EXPIRED','DONE') "
         "AND (date IS NULL OR date = '') "
         "ORDER BY id"
     ).fetchall()
@@ -141,9 +171,11 @@ def main():
         "dirty_normalized": dirty_f + dirty_r,
         "stale_count": len(stale) if stale else 0,
         "stale_escalated_count": len(escalated_stale),
+        "expired_count": len(expired_ids),
         "orphan_count": len(orphans) if orphans else 0,
         "stale_ids": [s["id"] for s in stale[:20]] if stale else [],
         "stale_escalated_ids": escalated_stale[:20],
+        "expired_ids": expired_ids[:20],
         "orphan_ids": [o["id"] for o in orphans[:20]] if orphans else [],
     }
 
@@ -151,7 +183,7 @@ def main():
     summary_file.parent.mkdir(parents=True, exist_ok=True)
     summary_file.write_text(json.dumps(summary, indent=2))
 
-    log(f"Summary: {dirty_f + dirty_r} normalized, {len(escalated_stale)} stale escalated, {len(orphans) if orphans else 0} orphans")
+    log(f"Summary: {dirty_f + dirty_r} normalized, {len(escalated_stale)} stale escalated, {len(expired_ids)} expired, {len(orphans) if orphans else 0} orphans")
     log("=== Followup Hygiene complete ===")