nexo-brain 7.27.2 → 7.27.6

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

@@ -33,6 +33,8 @@ import re
 import sqlite3
 import subprocess
 import sys
+from difflib import SequenceMatcher
+from email.utils import parsedate_to_datetime
 from datetime import datetime, date, timedelta
 from pathlib import Path
 
@@ -79,6 +81,8 @@ MAX_STALE_TRIAGE_PER_RUN = 8
 MAX_NEEDS_OPERATOR_BRIEFING = 12
 DEFAULT_ASSISTANT_NAME = "Nova"
 DEFAULT_OPERATOR_LANGUAGE = "en"
+DEFAULT_STEADY_STATE_IMAP_HOURS = 12
+DEFAULT_DUPLICATE_NOTE_THRESHOLD = 0.9
 
 # ── Logging ─────────────────────────────────────────────────────────────
 def log(msg: str):
@@ -103,6 +107,159 @@ def save_state(state: dict):
     STATE_FILE.write_text(json.dumps(state, indent=2))
 
 
+def load_runner_config() -> dict:
+    config = {
+        "steady_state_imap_hours": DEFAULT_STEADY_STATE_IMAP_HOURS,
+        "duplicate_note_threshold": DEFAULT_DUPLICATE_NOTE_THRESHOLD,
+    }
+    config_path = NEXO_HOME / "personal" / "config" / "followup-runner.json"
+    if config_path.exists():
+        try:
+            raw = json.loads(config_path.read_text())
+            if isinstance(raw, dict):
+                config.update(raw)
+        except Exception as exc:
+            log(f"Failed to read followup-runner config ({exc})")
+    try:
+        config["steady_state_imap_hours"] = float(
+            os.environ.get("NEXO_FOLLOWUP_STEADY_STATE_IMAP_HOURS", config["steady_state_imap_hours"])
+        )
+    except (TypeError, ValueError):
+        config["steady_state_imap_hours"] = DEFAULT_STEADY_STATE_IMAP_HOURS
+    try:
+        config["duplicate_note_threshold"] = float(
+            os.environ.get("NEXO_FOLLOWUP_DUPLICATE_NOTE_THRESHOLD", config["duplicate_note_threshold"])
+        )
+    except (TypeError, ValueError):
+        config["duplicate_note_threshold"] = DEFAULT_DUPLICATE_NOTE_THRESHOLD
+    return config
+
+
+def _normalise_note_text(value: str) -> str:
+    text = re.sub(r"\s+", " ", str(value or "").strip().lower())
+    text = re.sub(r"\b\d{4}-\d{2}-\d{2}(?:[t ][0-9:.+-z]+)?\b", "<date>", text)
+    text = re.sub(r"\b[0-9]{6,}(?:\.[0-9]+)?\b", "<num>", text)
+    return text
+
+
+def _note_similarity(left: str, right: str) -> float:
+    left_norm = _normalise_note_text(left)
+    right_norm = _normalise_note_text(right)
+    if not left_norm or not right_norm:
+        return 0.0
+    return SequenceMatcher(None, left_norm, right_norm).ratio()
+
+
+def _latest_email_gap_hours() -> float | None:
+    email_db = NEXO_HOME / "runtime" / "nexo-email" / "nexo-email.db"
+    if not email_db.exists():
+        return None
+    try:
+        conn = sqlite3.connect(str(email_db))
+        row = conn.execute(
+            "SELECT received_at FROM emails WHERE received_at IS NOT NULL "
+            "ORDER BY received_at DESC LIMIT 1"
+        ).fetchone()
+        conn.close()
+    except Exception:
+        return None
+    if not row or not row[0]:
+        return None
+    raw = str(row[0]).strip().replace("Z", "+00:00")
+    try:
+        received = datetime.fromisoformat(raw)
+    except ValueError:
+        try:
+            received = parsedate_to_datetime(raw)
+        except (TypeError, ValueError):
+            return None
+    if received.tzinfo is not None:
+        received = received.astimezone().replace(tzinfo=None)
+    return max(0.0, (datetime.now() - received).total_seconds() / 3600)
+
+
+def _db_change_marker() -> dict:
+    if not NEXO_DB.exists():
+        return {}
+    try:
+        conn = sqlite3.connect(str(NEXO_DB))
+        row = conn.execute(
+            "SELECT COUNT(*), COALESCE(MAX(updated_at), 0) FROM followups "
+            "WHERE UPPER(status) NOT LIKE 'COMPLETED%' AND UPPER(status) != 'DELETED'"
+        ).fetchone()
+        history = conn.execute(
+            "SELECT COALESCE(MAX(created_at), 0) FROM item_history "
+            "WHERE actor IS NULL OR actor != 'followup-runner'"
+        ).fetchone()
+        conn.close()
+    except Exception:
+        return {}
+    return {
+        "active_followups": int(row[0] or 0) if row else 0,
+        "max_followup_updated_at": float(row[1] or 0) if row else 0,
+        "max_non_runner_history_at": float(history[0] or 0) if history else 0,
+    }
+
+
+def _recent_runner_notes(fu_id: str, *, limit: int = 4) -> list[str]:
+    try:
+        conn = sqlite3.connect(str(NEXO_DB))
+        rows = conn.execute(
+            "SELECT note FROM item_history "
+            "WHERE item_type='followup' AND item_id=? AND actor='followup-runner' "
+            "ORDER BY created_at DESC LIMIT ?",
+            (fu_id, limit),
+        ).fetchall()
+        conn.close()
+    except Exception:
+        return []
+    return [str(row[0] or "") for row in rows if str(row[0] or "").strip()]
+
+
+def _is_duplicate_steady_state(followup: dict, *, threshold: float) -> bool:
+    notes = _recent_runner_notes(str(followup.get("id") or ""))
+    if not notes:
+        return False
+    current = "\n".join(
+        part
+        for part in (
+            str(followup.get("description") or "").strip(),
+            str(followup.get("verification") or "").strip(),
+            str(followup.get("reasoning") or "").strip(),
+        )
+        if part
+    )
+    if current and max(_note_similarity(current, note) for note in notes) >= threshold:
+        return True
+    if len(notes) >= 2 and _note_similarity(notes[0], notes[1]) >= threshold:
+        return True
+    return False
+
+
+def split_steady_state_skips(actionable: list[dict], state: dict, config: dict) -> tuple[list[dict], list[dict]]:
+    """Skip repeated no-op followups when email and DB state have not moved."""
+    marker = _db_change_marker()
+    previous_marker = (state.get("_meta") or {}).get("last_db_change_marker")
+    email_gap = _latest_email_gap_hours()
+    threshold = float(config.get("duplicate_note_threshold") or DEFAULT_DUPLICATE_NOTE_THRESHOLD)
+    imap_hours = float(config.get("steady_state_imap_hours") or DEFAULT_STEADY_STATE_IMAP_HOURS)
+    steady_state = bool(marker and previous_marker == marker and email_gap is not None and email_gap < imap_hours)
+    if not steady_state:
+        return actionable, []
+
+    kept = []
+    skipped = []
+    for followup in actionable:
+        if _is_duplicate_steady_state(followup, threshold=threshold):
+            skipped.append(followup)
+        else:
+            kept.append(followup)
+    if skipped:
+        ids = ", ".join(str(item.get("id") or "") for item in skipped)
+        log(f"Steady-state auto-skip: {ids} (IMAP gap {email_gap:.1f}h, DB marker unchanged)")
+    return kept, skipped
+
+
 # ── DB access ───────────────────────────────────────────────────────────
 def _parse_date(value: str) -> date | None:
     try:
@@ -670,6 +827,8 @@ def release_lock():
 def get_recent_activity(hours: int = 24) -> str:
     """Build a summary of what the runner did in the last N hours."""
     lines = []
+    config = load_runner_config()
+    duplicate_threshold = float(config.get("duplicate_note_threshold") or DEFAULT_DUPLICATE_NOTE_THRESHOLD)
     try:
         conn = sqlite3.connect(str(NEXO_DB))
         conn.row_factory = sqlite3.Row
@@ -698,13 +857,25 @@ def get_recent_activity(hours: int = 24) -> str:
         if notes:
             lines.append("\nFOLLOWUP NOTES WRITTEN (last 24h):")
             seen = set()
+            compressed = 0
             for n in notes:
                 fid = str(n["followup_id"] or "")
                 if fid in seen:
                     continue
                 seen.add(fid)
                 note_text = str(n["note"] or "")[:150]
+                previous = conn.execute(
+                    "SELECT note FROM item_history "
+                    "WHERE item_type='followup' AND item_id=? AND actor='followup-runner' "
+                    "AND created_at < ? ORDER BY created_at DESC LIMIT 1",
+                    (fid, n["created_at"]),
+                ).fetchone()
+                if previous and _note_similarity(str(previous["note"] or ""), note_text) >= duplicate_threshold:
+                    compressed += 1
+                    note_text = f"{note_text} [nota similar compactada]"
                 lines.append(f"  {fid}: {note_text}")
+            if compressed:
+                lines.append(f"  ({compressed} notas duplicadas compactadas; umbral={duplicate_threshold:.2f})")
 
         conn.close()
     except Exception as e:
@@ -799,8 +970,10 @@ def main():
         return
 
     state = load_state()
+    runner_config = load_runner_config()
     groups = get_all_active_followups(state)
     all_actionable = list(groups["actionable"])
+    all_actionable, steady_skipped = split_steady_state_skips(all_actionable, state, runner_config)
     cooled = groups.get("cooled_down", [])
     stale_triage = groups.get("stale_triage", [])
 
@@ -835,6 +1008,23 @@ def main():
         record_attempt(state, fid, "stale_review")
 
     results = []
+    for fu in steady_skipped:
+        fid = str(fu.get("id") or "")
+        if not fid:
+            continue
+        record_attempt(state, fid, "steady_state")
+        results.append(
+            {
+                "id": fid,
+                "status": "checked",
+                "summary": (
+                    "Auto-skip steady-state: marcador DB sin cambios desde el ciclo anterior, "
+                    f"último IMAP <{runner_config.get('steady_state_imap_hours')}h y nota previa similar."
+                ),
+                "needs_attention": False,
+                "options": None,
+            }
+        )
 
     if all_actionable:
         # Clean previous results
@@ -940,10 +1130,14 @@ def main():
     else:
         log("No followups at all. Runner direct email path removed.")
 
+    if steady_skipped:
+        RESULTS_FILE.write_text(json.dumps({"results": results}, indent=2, ensure_ascii=False))
+
     # Save state with attempts + last run
     if "_meta" not in state:
         state["_meta"] = {}
     state["_meta"]["last_run"] = datetime.now().isoformat()
+    state["_meta"]["last_db_change_marker"] = _db_change_marker()
     save_state(state)
 
     log("Done.")

package/src/semantic_reasoner.py

@@ -83,12 +83,12 @@ def _collect_local_votes(
     vote aggregator can still detect quorum problems.
     """
     try:
-        from classifier_local import LocalZeroShotClassifier
+        from classifier_local import get_shared_zero_shot_classifier
     except Exception as exc:  # pragma: no cover
         _logger.debug("semantic_reasoner: classifier_local unavailable (%s)", exc)
         return []
 
-    clf = LocalZeroShotClassifier(confidence_floor=0.0)
+    clf = get_shared_zero_shot_classifier(confidence_floor=0.0)
     votes: list[tuple[str, float, dict[str, float]]] = []
     for template in _PROMPT_PERTURBATIONS:
         prompt = template.format(q=question)

package/src/semantic_router.py

@@ -30,6 +30,7 @@ the decision carries. This is also what Desktop will consume via the
 from __future__ import annotations
 
 import logging
+import os
 from dataclasses import dataclass, field
 from typing import Any
 
@@ -79,7 +80,7 @@ class RouterResult:
 # Decision kinds + policy table
 # ---------------------------------------------------------------------------
 #
-# The plan enumerates 18 decision_kinds that need to route through here. They
+# The plan enumerates the decision_kinds that need to route through here. They
 # fall into two families:
 #
 #   TEXTUAL     — the first-line local classifier is good enough; the
@@ -111,6 +112,7 @@ TEXTUAL_KINDS: tuple[str, ...] = (
     "reply_event_type",
     "query_intent",
     "sentiment_intent",
+    "pre_answer_intent",
 )
 
 
@@ -136,10 +138,21 @@ _POLICY: dict[str, dict[str, Any]] = {
         "reasoner_mode": "multipass_local",
         "reasoner_threshold": 0.75,
         "allow_remote_fallback": True,
+        "allow_cold_local_load": True,
     }
     for kind in TEXTUAL_KINDS
 }
 
+_POLICY["pre_answer_intent"].update(
+    {
+        # Pre-answer sits on the user-visible latency path. Use the local
+        # semantic classifier when it is already warm, but do not cold-load a
+        # heavy model before answering unless explicitly enabled.
+        "allow_remote_fallback": True,
+        "allow_cold_local_load": False,
+    }
+)
+
 _POLICY.update(
     {
         kind: {
@@ -148,6 +161,7 @@ _POLICY.update(
             "reasoner_mode": "cached_llm",
             "reasoner_threshold": 0.60,
             "allow_remote_fallback": True,
+            "allow_cold_local_load": True,
         }
         for kind in CODE_AWARE_KINDS
     }
@@ -176,6 +190,7 @@ def _run_fast_local(
     context: str = "",
     labels: tuple[str, ...],
     confidence_floor: float,
+    allow_cold_load: bool = True,
 ) -> RouterResult | None:
     """Try ``LocalZeroShotClassifier``. Return None on unavailable or
     below-threshold so the router advances.
@@ -187,12 +202,14 @@ def _run_fast_local(
     when present, and fall back to question for simple direct callers.
     """
     try:
-        from classifier_local import LocalZeroShotClassifier
+        from classifier_local import get_shared_zero_shot_classifier, is_local_classifier_warm
     except Exception as exc:  # pragma: no cover — install not ready
         _logger.debug("semantic_router: classifier_local unavailable (%s)", exc)
         return None
 
-    clf = LocalZeroShotClassifier(confidence_floor=confidence_floor)
+    if not allow_cold_load and not is_local_classifier_warm():
+        return None
+    clf = get_shared_zero_shot_classifier(confidence_floor=confidence_floor)
     classifier_input = (context or "").strip() or question
     result = clf.classify(classifier_input, labels)
     if result is None:
@@ -375,6 +392,28 @@ def _normalize_remote_answer(
 # ---------------------------------------------------------------------------
 
 
+def _env_bool(name: str, *, default: bool) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return str(raw or "").strip().lower() in {"1", "true", "yes", "on", "enabled"}
+
+
+def _allow_cold_local_load(decision_kind: str, policy: dict[str, Any]) -> bool:
+    default = bool(policy.get("allow_cold_local_load", True))
+    if decision_kind == "pre_answer_intent":
+        return _env_bool("NEXO_PRE_ANSWER_ALLOW_COLD_SEMANTIC_LOAD", default=default)
+    return default
+
+
+def _local_classifier_warm() -> bool:
+    try:
+        from classifier_local import is_local_classifier_warm
+    except Exception:
+        return False
+    return is_local_classifier_warm()
+
+
 def route(
     *,
     decision_kind: str,
@@ -407,6 +446,7 @@ def route(
     labels_tuple: tuple[str, ...] | None = (
         tuple(labels) if labels else None
     )
+    allow_cold_load = _allow_cold_local_load(decision_kind, policy)
 
     # Step 1 — fast_local for textual families only.
     if policy["fast_local_threshold"] is not None and labels_tuple:
@@ -415,20 +455,27 @@ def route(
             context=context,
             labels=labels_tuple,
             confidence_floor=float(policy["fast_local_threshold"]),
+            allow_cold_load=allow_cold_load,
         )
         if fast is not None:
             fast.decision_kind = decision_kind
             return fast
 
     # Step 2 — semantic_reasoner (Mode A or B depending on policy).
-    reasoned = _run_semantic_reasoner(
-        decision_kind=decision_kind,
-        question=question,
-        labels=labels_tuple,
-        context=context,
-        mode=str(policy["reasoner_mode"]),
-        confidence_floor=float(policy["reasoner_threshold"]),
-    )
+    reasoned = None
+    if not (
+        str(policy["reasoner_mode"]) == "multipass_local"
+        and not allow_cold_load
+        and not _local_classifier_warm()
+    ):
+        reasoned = _run_semantic_reasoner(
+            decision_kind=decision_kind,
+            question=question,
+            labels=labels_tuple,
+            context=context,
+            mode=str(policy["reasoner_mode"]),
+            confidence_floor=float(policy["reasoner_threshold"]),
+        )
     if reasoned is not None and reasoned.ok:
         return reasoned
 

package/src/server.py

@@ -92,7 +92,7 @@ from tools_automation_sessions import (
     handle_session_log_create,
     handle_session_log_close,
 )
-from plugins.cortex import handle_cortex_check
+from plugins.cortex import handle_cortex_check, handle_cortex_decide
 from plugins.guard import handle_guard_check
 from plugins.protocol import (
     handle_confidence_check,
@@ -632,6 +632,42 @@ def nexo_cortex_check(
     )
 
 
+@mcp.tool
+def nexo_cortex_decide(
+    goal: str,
+    alternatives: str,
+    task_type: str = "execute",
+    impact_level: str = "high",
+    context_hint: str = "",
+    area: str = "",
+    constraints: str = "[]",
+    evidence_refs: str = "[]",
+    session_id: str = "",
+    task_id: str = "",
+    linked_outcome_id: int = 0,
+    goal_profile_id: str = "",
+    goal_id: str = "",
+    auto_create_outcome: bool = False,
+) -> str:
+    """Evaluate concrete alternatives for a high-impact task and persist the recommendation."""
+    return handle_cortex_decide(
+        goal,
+        alternatives,
+        task_type,
+        impact_level,
+        context_hint,
+        area,
+        constraints,
+        evidence_refs,
+        session_id,
+        task_id,
+        linked_outcome_id,
+        goal_profile_id,
+        goal_id,
+        auto_create_outcome,
+    )
+
+
 @mcp.tool
 def nexo_guard_check(files: str = "", area: str = "") -> str:
     """Check learnings relevant to files/area before reading or editing code."""