nexo-brain 7.9.1 → 7.9.3

package/.claude-plugin/plugin.json

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

package/README.md

@@ -18,7 +18,9 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.9.1` is the current packaged-runtime line. Patch release that starts the semantic-router site migration promised after v7.9.0: six safe textual-conversational callers now route through `semantic_router.route(...)` instead of importing `enforcement_classifier.classify` directly (`session_end_intent`, `r14_correction_learning`, `r16_declared_done`, `r17_promise_debt`, `autonomy_mandate`, `guard_verbal_ack`). The patch also fixes the semantic stack's local layers to classify the live `context` text rather than letting static prompt templates dominate zero-shot decisions, and migrates the six callers to semantic labels (`session_end`/`continue_session`, `negative_feedback`/`ordinary_request`, etc.) instead of generic `yes`/`no`. Existing fail-closed behaviour and test injection seams are preserved. Targeted verification: 105 tests passing across router, reasoner, migrated call sites, and their enforcement integrations. Remaining textual/code-aware callers stay tracked under `NF-SEMANTIC-ROUTER-SITE-MIGRATION` for later focused patches. No Desktop bump.
+Version `7.9.3` is the current packaged-runtime line. Patch release that hardens Brain's canonical lifecycle plan for Desktop close/archive/delete/app-exit diary guarantees: `canonical_actions` now publish the v2 canonical shape (`type` plus `payload.prompt`) while keeping one-release compatibility mirrors (`kind` plus top-level `prompt`) for older Desktop clients. This lets Desktop execute resume → diary prompt → stop with one exact owner per lifecycle event and preserve Brain-side dedupe by event id. Targeted verification: `pytest tests/test_lifecycle_events.py` (25 passing) plus release-readiness after artifact sync.
+
+Previously in `7.9.2`: patch release that completes the Brain semantic-router site migration: the remaining decision callers now route through `semantic_router.route(...)` with named `decision_kind` policies (`r20_constant_change`, `r34_identity_coherence`, `t4_r15`, `t4_r23e`, `t4_r23f`, `t4_r23h`, `followup_operator_attention`, `drive_signal_type`, `drive_area`, `reply_event_type`, `query_intent`, and `sentiment_intent`). Brain now owns model choice, thresholds, and fallback behaviour centrally instead of each caller carrying its own classifier policy. The patch also fixes packaged headless Guardian map loading: `enforcement_engine` and `agent_runner` now check the installed core directory (`~/.nexo/core/tool-enforcement-map.json`) so followup-runner, morning-agent, digest, and email-monitor load the map instead of falling back to unguarded subprocess execution. Targeted verification: 100 semantic/router/enforcer tests, 125 Drive/cognitive/productization tests, and release-readiness passing.
 
 Previously in `7.9.0`: minor release that ships the foundation of the semantic stack (router + reasoner + CLI) under the ONEPASS LLM Coverage plan, plus two product-bug fixes observed in the wild on 2026-04-23. New `src/semantic_router.py` exposes 18 named `decision_kinds` (13 textual + 5 code-aware) with a per-kind policy table and the layer chain `fast_local → semantic_reasoner → remote_fallback`. New `src/semantic_reasoner.py` adds Mode A (`multipass_local`: reuses the mDeBERTa pin with three prompt-perturbed passes + majority vote + 0.75 floor) and Mode B (`cached_llm`: wrapper over `call_model_raw` with a pid+uuid atomic-write 24h-TTL disk cache at `~/.nexo/runtime/operations/semantic-reasoner-cache.json`, SHA-256 keyed by `decision_kind` + normalized input, LRU-bounded at 2000 entries, corrupt entries dropped on read). New `scripts/semantic-classify.py` JSON-in JSON-out CLI lets external MCP clients (including the closed-source NEXO Desktop companion) query Brain as the single semantic authority. New `NEXO_SEMANTIC_REASONER` kill switch (`0`/`off`/`false`/`no`/`disable`/`disabled`) honours the plan mandate for a runtime opt-out separate from `NEXO_LOCAL_CLASSIFIER`. Bug fixes: `bin/nexo-brain.js` upgrade flow now copies `templates/` root the same way fresh install and same-version refresh already did (Maria iMac 7.1.10→7.8.1 upgrade had lost 27 core-prompts templates and broken post-update import verification); and `tool-enforcement-map.json` `nexo_startup.enforcement.inject_prompt` now instructs the model to preload the 13 `mcp__nexo__*` protocol tools via `ToolSearch` before calling `nexo_startup` when the host MCP client defers tool schemas (Claude Code with many MCPs installed). Audit-driven hardening: router/reasoner defensively use `getattr` over the `call_model_raw` module and add a trailing `except Exception` so provider errors degrade with `remote_error` instead of propagating; cache writes use pid+uuid tmp + `fsync` + `os.replace` to survive concurrent writers; `NEXO_SEMANTIC_REASONER_TTL` parse tolerates malformed values. Tests: +50 (22 router, 20 reasoner, 8 CLI). Per-site migration of existing callers (`session_end_intent`, `r14`, `r16`, `r17`, `r20`, `r34`, T4 gates, `tools_drive`, `nexo-followup-runner`) is explicitly deferred to follow-up patch releases and tracked as `NF-SEMANTIC-ROUTER-SITE-MIGRATION`; nothing in this release changes the behaviour of the existing callers. Companion coordinated release: NEXO Desktop v0.28.0.
 

package/package.json

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

package/src/agent_runner.py

@@ -792,6 +792,7 @@ def _build_enforcement_system_prompt() -> str:
     map_path = NEXO_HOME / "tool-enforcement-map.json"
     if not map_path.exists():
         for candidate in [
+            Path(__file__).parent / "tool-enforcement-map.json",
             Path(__file__).parent.parent / "tool-enforcement-map.json",
         ]:
             if candidate.exists():

package/src/cognitive/_search.py

@@ -27,7 +27,6 @@ _QUERY_INTENT_LOCAL_CONFIDENCE_THRESHOLD = float(
 _QUERY_INTENT_CACHE_TTL_SECONDS = int(
     os.environ.get("NEXO_QUERY_INTENT_LOCAL_CACHE_TTL", "21600")
 )
-_LOCAL_QUERY_INTENT_CLASSIFIER = None
 _QUERY_INTENT_CACHE: dict[str, dict] = {}
 _QUERY_INTENT_LABELS = (
     ("A how-to guide, procedure, or step-by-step instruction request", "howto"),
@@ -75,27 +74,27 @@ def _local_classify_query_intent(query: str) -> dict:
     if cached and cached.get("expires_at", 0) > time.time():
         return {k: v for k, v in cached.items() if k != "expires_at"}
 
-    global _LOCAL_QUERY_INTENT_CLASSIFIER
     try:
-        if _LOCAL_QUERY_INTENT_CLASSIFIER is None:
-            from classifier_local import LocalZeroShotClassifier
-
-            _LOCAL_QUERY_INTENT_CLASSIFIER = LocalZeroShotClassifier(
-                confidence_floor=_QUERY_INTENT_LOCAL_CONFIDENCE_THRESHOLD,
-            )
-        if not _LOCAL_QUERY_INTENT_CLASSIFIER.is_available():
-            return {"available": False, "label": None, "reason": "classifier_unavailable"}
+        from semantic_router import route as semantic_route
+    except Exception as exc:
+        return {"available": False, "label": None, "reason": f"router_unavailable:{exc}"}
+    try:
         label_texts = [label for label, _intent in _QUERY_INTENT_LABELS]
         intent_by_label = {label: intent for label, intent in _QUERY_INTENT_LABELS}
-        result = _LOCAL_QUERY_INTENT_CLASSIFIER.classify(query, label_texts)
-        if result is None:
-            return {"available": False, "label": None, "reason": "classifier_failed"}
+        result = semantic_route(
+            decision_kind="query_intent",
+            question="Classify the user's search query intent.",
+            context=query,
+            labels=tuple(label_texts),
+        )
+        if not result.ok:
+            return {"available": False, "label": None, "reason": result.error or "router_no_route"}
         intent = intent_by_label.get(result.label)
         payload = {
             "available": intent is not None,
             "label": intent,
             "confidence": float(result.confidence or 0.0),
-            "reason": "local_zero_shot",
+            "reason": result.route_used,
         }
         _QUERY_INTENT_CACHE[key] = {
             **payload,
@@ -103,7 +102,7 @@ def _local_classify_query_intent(query: str) -> dict:
         }
         return payload
     except Exception as exc:
-        return {"available": False, "label": None, "reason": f"classifier_error:{exc}"}
+        return {"available": False, "label": None, "reason": f"router_error:{exc}"}
 
 def bm25_search(query_text: str, stores: str = "both", top_k: int = 20,
                 source_type_filter: str = "") -> list[dict]:

package/src/cognitive/_trust.py

@@ -274,7 +274,6 @@ _LOCAL_SENTIMENT_CONFIDENCE_THRESHOLD = float(
 _LOCAL_SENTIMENT_CACHE_TTL_SECONDS = int(
     os.environ.get("NEXO_SENTIMENT_LOCAL_CACHE_TTL", "21600")
 )
-_LOCAL_SENTIMENT_CLASSIFIER = None
 _LOCAL_SENTIMENT_CACHE: dict[str, dict] = {}
 _LOCAL_SENTIMENT_LABELS = (
     ("The user is correcting the assistant or saying the assistant is wrong", "correction"),
@@ -304,27 +303,27 @@ def _local_classify_sentiment_intent(text: str) -> dict:
     if cached and cached.get("expires_at", 0) > now:
         return {k: v for k, v in cached.items() if k != "expires_at"}
 
-    global _LOCAL_SENTIMENT_CLASSIFIER
     try:
-        if _LOCAL_SENTIMENT_CLASSIFIER is None:
-            from classifier_local import LocalZeroShotClassifier
-
-            _LOCAL_SENTIMENT_CLASSIFIER = LocalZeroShotClassifier(
-                confidence_floor=_LOCAL_SENTIMENT_CONFIDENCE_THRESHOLD,
-            )
-        if not _LOCAL_SENTIMENT_CLASSIFIER.is_available():
-            return {"available": False, "label": None, "reason": "classifier_unavailable"}
+        from semantic_router import route as semantic_route
+    except Exception as exc:
+        return {"available": False, "label": None, "reason": f"router_unavailable:{exc}"}
+    try:
         label_texts = [label for label, _intent in _LOCAL_SENTIMENT_LABELS]
         intent_by_label = {label: intent for label, intent in _LOCAL_SENTIMENT_LABELS}
-        result = _LOCAL_SENTIMENT_CLASSIFIER.classify(text, label_texts)
-        if result is None:
-            return {"available": False, "label": None, "reason": "classifier_failed"}
+        result = semantic_route(
+            decision_kind="sentiment_intent",
+            question="Classify the operator message sentiment intent.",
+            context=text,
+            labels=tuple(label_texts),
+        )
+        if not result.ok:
+            return {"available": False, "label": None, "reason": result.error or "router_no_route"}
         intent = intent_by_label.get(result.label)
         payload = {
             "available": intent in SENTIMENT_INTENTS,
             "label": intent,
             "confidence": float(result.confidence or 0.0),
-            "reason": "local_zero_shot",
+            "reason": result.route_used,
         }
         _LOCAL_SENTIMENT_CACHE[key] = {
             **payload,
@@ -332,7 +331,7 @@ def _local_classify_sentiment_intent(text: str) -> dict:
         }
         return payload
     except Exception as exc:
-        return {"available": False, "label": None, "reason": f"classifier_error:{exc}"}
+        return {"available": False, "label": None, "reason": f"router_error:{exc}"}
 
 
 def detect_sentiment(text: str) -> dict:

package/src/enforcement_engine.py

@@ -322,6 +322,7 @@ def _redact_for_log(text: str, max_len: int = 200) -> str:
 
 def _load_map() -> dict | None:
     for candidate in [
+        Path(__file__).parent / MAP_FILENAME,
         paths.home() / MAP_FILENAME,
         paths.brain_dir() / MAP_FILENAME,
         paths.legacy_brain_dir() / MAP_FILENAME,
@@ -613,7 +614,7 @@ class HeadlessEnforcer:
 
         correction_detector is an injection point for tests. In production it
         defaults to r14_correction_learning.detect_correction which routes
-        through enforcement_classifier + call_model_raw. Fail-closed: a
+        through semantic_router. Fail-closed: a
         broken classifier keeps the window closed (no false positives).
         """
         self.user_message_count += 1
@@ -1134,7 +1135,6 @@ class HeadlessEnforcer:
             self._t4_gate_warned = set()
         try:
             from t4_llm_gate import build_prompt, classify_with_llm
-            from enforcement_classifier import classify as _classifier_raw
         except Exception as exc:
             key = (rule_id, f"import:{exc.__class__.__name__}")
             if key not in self._t4_gate_warned:
@@ -1147,15 +1147,40 @@ class HeadlessEnforcer:
             )
             return False
 
-        # Auditor H1 fix: the legacy bool contract of `classify` collapses
-        # "classifier said no" and "classifier response unparseable after
-        # two retries — conservative fallback" into the same False, which
-        # would silently suppress destructive rules (R23e/R23f/R23h) when
-        # the backend responds with garbage. Force the tristate path so
-        # "unknown" falls through to regex behaviour instead of becoming
-        # a silent rule disable.
+        # Auditor H1 invariant: only an explicit semantic "no" may suppress
+        # a regex hit. Router unavailable/no_route/ambiguous answers fall
+        # through as "unknown" so the original rule still protects us.
         def _classifier_tristate(q: str, ctx: str) -> str:
-            return _classifier_raw(q, ctx, tristate=True)
+            decision_kind_by_rule = {
+                "R15": "t4_r15",
+                "R23e": "t4_r23e",
+                "R23f": "t4_r23f",
+                "R23h": "t4_r23h",
+            }
+            decision_kind = decision_kind_by_rule.get(rule_id)
+            if not decision_kind:
+                return "unknown"
+            try:
+                from semantic_router import route as semantic_route
+            except Exception:
+                return "unknown"
+            try:
+                result = semantic_route(
+                    decision_kind=decision_kind,
+                    question=q,
+                    context=ctx,
+                    labels=("rule_applies", "false_positive"),
+                )
+            except Exception:
+                return "unknown"
+            if not result.ok:
+                return "unknown"
+            label = result.label or result.verdict
+            if label == "rule_applies":
+                return "yes"
+            if label == "false_positive":
+                return "no"
+            return "unknown"
 
         prompt = build_prompt(rule_id, span=span, context=context)
         if not prompt:
@@ -1885,6 +1910,31 @@ class HeadlessEnforcer:
         if mode == "off":
             return
         recent_names = [r.tool for r in self.recent_tool_records]
+        if classifier is None:
+            def _semantic_classifier(question: str, context: str):
+                try:
+                    from semantic_router import route as semantic_route
+                except Exception:
+                    return "unknown"
+                try:
+                    result = semantic_route(
+                        decision_kind="r34_identity_coherence",
+                        question=question,
+                        context=context,
+                        labels=("past_action_denial", "not_a_denial"),
+                    )
+                except Exception:
+                    return "unknown"
+                if not result.ok:
+                    return "unknown"
+                label = result.label or result.verdict
+                if label == "past_action_denial":
+                    return "yes"
+                if label == "not_a_denial":
+                    return "no"
+                return "unknown"
+
+            classifier = _semantic_classifier
         try:
             inject, prompt, matched = _r34_should(
                 text, recent_tool_names=recent_names, classifier=classifier,

package/src/lifecycle_prompts.py

@@ -19,7 +19,7 @@ import json
 from typing import Any, Dict, List, Optional
 
 
-PLAN_VERSION = 1
+PLAN_VERSION = 2
 
 
 # Actions that trigger a canonical diary+stop plan. `switch` and
@@ -79,6 +79,27 @@ def _diary_prompt_for_action(
     )
 
 
+def _canonical_action(
+    action_id: str,
+    action_type: str,
+    session_id: str,
+    timeout_ms: int,
+    **extra: Any,
+) -> Dict[str, Any]:
+    """Build one Desktop action with the v2 shape plus one-release mirrors."""
+    action: Dict[str, Any] = {
+        "id": action_id,
+        "type": action_type,
+        # Compatibility mirror for Desktop <= 0.28.1. Remove after one
+        # release once every supported Desktop consumes `type`.
+        "kind": action_type,
+        "session_id": str(session_id),
+        "timeout_ms": timeout_ms,
+    }
+    action.update(extra)
+    return action
+
+
 def build_canonical_plan(
     event_id: str,
     action: str,
@@ -106,26 +127,19 @@ def build_canonical_plan(
     prompt = _diary_prompt_for_action(action, conversation_id, payload_snapshot)
 
     actions: List[Dict[str, Any]] = [
-        {
-            "id": "a1",
-            "kind": "resume_session",
-            "session_id": str(session_id),
-            "timeout_ms": DEFAULT_RESUME_TIMEOUT_MS,
-        },
-        {
-            "id": "a2",
-            "kind": "inject_prompt",
-            "session_id": str(session_id),
-            "prompt": prompt,
-            "expected_tool_call": "nexo_session_diary_write",
-            "timeout_ms": DEFAULT_INJECT_TIMEOUT_MS,
-        },
-        {
-            "id": "a3",
-            "kind": "stop_session",
-            "session_id": str(session_id),
-            "timeout_ms": DEFAULT_STOP_TIMEOUT_MS,
-        },
+        _canonical_action("a1", "resume_session", str(session_id), DEFAULT_RESUME_TIMEOUT_MS),
+        _canonical_action(
+            "a2",
+            "inject_prompt",
+            str(session_id),
+            DEFAULT_INJECT_TIMEOUT_MS,
+            payload={"prompt": prompt},
+            # Compatibility mirror for Desktop <= 0.28.1. Remove after one
+            # release once every supported Desktop consumes `payload.prompt`.
+            prompt=prompt,
+            expected_tool_call="nexo_session_diary_write",
+        ),
+        _canonical_action("a3", "stop_session", str(session_id), DEFAULT_STOP_TIMEOUT_MS),
     ]
     return {
         "canonical_plan_id": canonical_plan_id(event_id, PLAN_VERSION),

package/src/r20_constant_change.py

@@ -9,10 +9,11 @@ Fase 2 Protocol Enforcer Fase D item R20. Plan doc 1 reads:
 Decision logic is split in two:
 
   1. classify_edit_is_constant_change(file_path, new_string, classifier)
-     → bool. Uses enforcement_classifier over a prompt that asks whether
-     the edited region looks like a module-level constant, enum member,
-     configuration key, or shared global (as opposed to a local variable,
-     helper body, or doc-string edit).
+     → bool. Uses semantic_router decision_kind ``r20_constant_change``
+     over a prompt that asks whether the edited region looks like a
+     module-level constant, enum member, configuration key, or shared
+     global (as opposed to a local variable, helper body, or doc-string
+     edit).
 
   2. recent_grep_covers_symbol(symbol, recent_tool_records) → bool.
      Structural — walks the recent tool records (same shape as R13) and
@@ -30,6 +31,8 @@ import re
 from core_prompts import render_core_prompt
 
 CLASSIFIER_QUESTION = render_core_prompt("r20-constant-change-question")
+SEMANTIC_LABELS = ("shared_constant_change", "local_or_non_constant_change")
+POSITIVE_LABEL = "shared_constant_change"
 
 INJECTION_PROMPT_TEMPLATE = render_core_prompt(
     "r20-constant-change-injection",
@@ -62,10 +65,21 @@ def classify_edit_is_constant_change(
         return False
     if classifier is None:
         try:
-            from enforcement_classifier import classify as classifier  # type: ignore
+            from semantic_router import route as semantic_route
         except Exception:
             return False
     context = f"File: {file_path}\n\nEdited region:\n{new_string[:400]}"
+    if classifier is None:
+        try:
+            result = semantic_route(
+                decision_kind="r20_constant_change",
+                question=CLASSIFIER_QUESTION,
+                context=context,
+                labels=SEMANTIC_LABELS,
+            )
+            return bool(result.ok and (result.label or result.verdict) == POSITIVE_LABEL)
+        except Exception:
+            return False
     try:
         return bool(classifier(question=CLASSIFIER_QUESTION, context=context))
     except Exception:

package/src/r34_identity_coherence.py

@@ -14,7 +14,7 @@ Detection strategy (two layers):
      positive rate (any agent message saying "I haven't done X" today
      would match even when the action is plainly something NEXO has not
      done).
-  2. LLM classifier confirmation (shared with T4). When the regex fires
+  2. Semantic router confirmation. When the regex fires
      AND no shared-brain tool has been called this turn, the classifier
      decides whether the message is really a past-tense denial worth
      nudging. Tests use a fake classifier to avoid hitting the SDK.
@@ -34,8 +34,8 @@ from core_prompts import render_core_prompt
 def _verdict_to_bool(verdict: Any) -> bool:
     """Normalize a classifier verdict to an inject/no-inject decision.
 
-    The shared ``enforcement_classifier.classify`` exposes a ``tristate``
-    mode that returns ``"yes"``/``"no"``/``"unknown"`` strings. A naive
+    The engine-level semantic router adapter returns ``"yes"``/``"no"``/
+    ``"unknown"`` strings. A naive
     ``bool(verdict)`` wrap treats ``"unknown"`` (and any non-empty string
     the model may produce) as truthy, which is fail-OPEN for R34. Only
     a real ``True`` or an explicit ``"yes"`` should trigger an injection;
@@ -122,10 +122,9 @@ def should_inject_r34(
         return False, "", ""
     if classifier is None:
         return True, INJECTION_PROMPT, matched
-    # LLM disambiguation — reuses T4 infra. The engine passes a lambda
-    # that calls enforcement_classifier.classify under the hood. Parse
-    # the verdict via _verdict_to_bool so tristate "unknown" does not
-    # coerce to True.
+    # Semantic disambiguation — the engine passes a lambda that routes
+    # through semantic_router. Parse the verdict via _verdict_to_bool so
+    # tristate "unknown" does not coerce to True.
     try:
         raw_verdict = classifier(CLASSIFIER_QUESTION, message)
     except Exception:

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

@@ -159,30 +159,8 @@ def _classifier_requires_operator_attention(text: str, operator_name: str = "")
     clean_text = " ".join(str(text or "").split())
     if len(clean_text) < 12:
         return None
-    try:
-        from classifier_local import LocalZeroShotClassifier
-    except Exception:
-        return None
-
-    classifier = LocalZeroShotClassifier(confidence_floor=0.72)
-    if not classifier.is_available():
-        return None
 
     needs_attention, can_continue, waiting_external = _operator_attention_label_set(operator_name)
-    result = classifier.classify(clean_text, labels=(needs_attention, can_continue, waiting_external))
-    if result is None or result.confidence < 0.72:
-        return None
-    if result.label == needs_attention:
-        return True
-    if result.label in {can_continue, waiting_external}:
-        return False
-    return None
-
-
-def _llm_requires_operator_attention(text: str, operator_name: str = "") -> bool | None:
-    clean_text = " ".join(str(text or "").split())
-    if len(clean_text) < 24:
-        return None
     clean_operator = " ".join(str(operator_name or "").split()).strip()
     subject = clean_operator if clean_operator else "the operator"
     question = render_core_prompt(
@@ -194,22 +172,32 @@ def _llm_requires_operator_attention(text: str, operator_name: str = "") -> bool
         pending_item=clean_text,
     )
     try:
-        from enforcement_classifier import ClassifierUnavailableError, classify
+        from semantic_router import route as semantic_route
     except Exception:
         return None
     try:
-        verdict = classify(question, context=context, tier="muy_bajo", tristate=True)
-    except ClassifierUnavailableError:
-        return None
+        result = semantic_route(
+            decision_kind="followup_operator_attention",
+            question=question,
+            context=context,
+            labels=(needs_attention, can_continue, waiting_external),
+        )
     except Exception:
         return None
-    if verdict == "yes":
+    if not result.ok:
+        return None
+    label = result.label or result.verdict
+    if label == needs_attention:
         return True
-    if verdict == "no":
+    if label in {can_continue, waiting_external}:
         return False
     return None
 
 
+def _llm_requires_operator_attention(text: str, operator_name: str = "") -> bool | None:
+    return _classifier_requires_operator_attention(text, operator_name=operator_name)
+
+
 def _followup_needs_operator_attention(followup: dict, operator_name: str = "") -> bool:
     status = str(followup.get("status") or "").strip().lower()
     owner = str(followup.get("owner") or "").strip().lower()

package/src/scripts/nexo-send-reply.py

@@ -94,7 +94,6 @@ RESOLUTION_PATTERNS = (
 )
 
 _REPLY_EVENT_CONFIDENCE = float(os.environ.get("NEXO_REPLY_EVENT_CONFIDENCE", "0.72"))
-_LOCAL_REPLY_EVENT_CLASSIFIER = None
 _REPLY_EVENT_LABELS = (
     ("The reply acknowledges receipt or says the work starts now", "ack"),
     ("The reply makes a future commitment or promises an update later", "commitment"),
@@ -180,20 +179,20 @@ def _classify_reply_event_semantically(body_text):
     if len(text) < 20:
         return None
 
-    global _LOCAL_REPLY_EVENT_CLASSIFIER
     try:
-        if _LOCAL_REPLY_EVENT_CLASSIFIER is None:
-            from classifier_local import LocalZeroShotClassifier
-
-            _LOCAL_REPLY_EVENT_CLASSIFIER = LocalZeroShotClassifier(
-                confidence_floor=_REPLY_EVENT_CONFIDENCE,
-            )
-        if not _LOCAL_REPLY_EVENT_CLASSIFIER.is_available():
-            return None
+        from semantic_router import route as semantic_route
+    except Exception:
+        return None
+    try:
         label_texts = [label for label, _canonical in _REPLY_EVENT_LABELS]
         canonical_by_label = {label: canonical for label, canonical in _REPLY_EVENT_LABELS}
-        result = _LOCAL_REPLY_EVENT_CLASSIFIER.classify(text, label_texts)
-        if result is None:
+        result = semantic_route(
+            decision_kind="reply_event_type",
+            question="Classify the email reply lifecycle event.",
+            context=text,
+            labels=tuple(label_texts),
+        )
+        if not result.ok:
             return None
         if float(result.confidence or 0.0) < _REPLY_EVENT_CONFIDENCE:
             return None

package/src/tools_drive.py

@@ -8,7 +8,6 @@ heartbeat, task_close, and diary consolidation.
 import json
 import os
 import re
-import subprocess
 import time
 import unicodedata
 from core_prompts import render_core_prompt
@@ -30,29 +29,14 @@ _SEMANTIC_THRESHOLD = 0.75
 _SEMANTIC_MARGIN = 0.15
 _LLM_MIN_TEXT_CHARS = int(os.environ.get("NEXO_DRIVE_LLM_MIN_CHARS", "24"))
 _LOCAL_CONFIDENCE_THRESHOLD = float(os.environ.get("NEXO_DRIVE_LOCAL_CONFIDENCE", "0.72"))
-_LLM_TIMEOUT_SECONDS = int(os.environ.get("NEXO_DRIVE_LLM_TIMEOUT", "20"))
 _LLM_CONFIDENCE_THRESHOLD = float(os.environ.get("NEXO_DRIVE_LLM_CONFIDENCE", "0.62"))
 _LLM_CACHE_TTL_SECONDS = int(os.environ.get("NEXO_DRIVE_LLM_CACHE_TTL", "21600"))
-_LLM_ALLOWED_LABELS = {"anomaly", "pattern", "gap", "opportunity", "none"}
 _LLM_CLASSIFICATION_CACHE: dict[str, dict] = {}
-_AREA_LLM_ALLOWED_LABELS = {
-    "shopify",
-    "google-ads",
-    "meta-ads",
-    "wazion",
-    "nexo",
-    "canaririural",
-    "seo",
-    "email",
-    "none",
-}
 _LLM_AREA_CLASSIFICATION_CACHE: dict[str, dict] = {}
 _LOCAL_ALLOWED_LABELS = ("anomaly", "pattern", "gap", "opportunity", "none")
-_LOCAL_SIGNAL_CLASSIFIER = None
 _AREA_SCORE_THRESHOLD = 0.64
 _AREA_SCORE_MARGIN = 0.14
 _AREA_LOCAL_CONFIDENCE_THRESHOLD = float(os.environ.get("NEXO_DRIVE_AREA_LOCAL_CONFIDENCE", "0.66"))
-_LOCAL_AREA_CLASSIFIER = None
 
 _SIGNAL_CUES = {
     "anomaly": {
@@ -323,29 +307,29 @@ def _local_classify_signal(text: str) -> dict:
     if len(text_norm) < _LLM_MIN_TEXT_CHARS:
         return {"available": False, "label": None, "reason": "text_too_short"}
 
-    global _LOCAL_SIGNAL_CLASSIFIER
     try:
-        if _LOCAL_SIGNAL_CLASSIFIER is None:
-            from classifier_local import LocalZeroShotClassifier
-
-            _LOCAL_SIGNAL_CLASSIFIER = LocalZeroShotClassifier(
-                confidence_floor=_LOCAL_CONFIDENCE_THRESHOLD,
-            )
-        if not _LOCAL_SIGNAL_CLASSIFIER.is_available():
-            return {"available": False, "label": None, "reason": "classifier_unavailable"}
-        result = _LOCAL_SIGNAL_CLASSIFIER.classify(text, _LOCAL_ALLOWED_LABELS)
-        if result is None:
-            return {"available": False, "label": None, "reason": "classifier_failed"}
+        from semantic_router import route as semantic_route
+    except Exception as exc:
+        return {"available": False, "label": None, "reason": f"router_unavailable:{exc}"}
+    try:
+        result = semantic_route(
+            decision_kind="drive_signal_type",
+            question=render_core_prompt("drive-signal-classifier-system"),
+            context=text.strip()[:3000],
+            labels=_LOCAL_ALLOWED_LABELS,
+        )
+        if not result.ok:
+            return {"available": False, "label": None, "reason": result.error or "router_no_route"}
         label = result.label if result.label in _LOCAL_ALLOWED_LABELS else None
         return {
             "available": label is not None,
             "label": None if label == "none" else label,
             "confidence": float(result.confidence or 0.0),
-            "reason": "local_zero_shot",
-            "source": "local",
+            "reason": result.route_used,
+            "source": "semantic_router",
         }
     except Exception as exc:
-        return {"available": False, "label": None, "reason": f"classifier_error:{exc}"}
+        return {"available": False, "label": None, "reason": f"router_error:{exc}"}
 
 
 def _llm_classify_signal(text: str) -> dict:
@@ -359,54 +343,7 @@ def _llm_classify_signal(text: str) -> dict:
     if cached and cached.get("expires_at", 0) > now:
         return {k: v for k, v in cached.items() if k != "expires_at"}
 
-    try:
-        from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
-    except Exception as exc:
-        return {"available": False, "label": None, "reason": f"runner_unavailable:{exc}"}
-
-    json_system_prompt = render_core_prompt("drive-signal-classifier-system")
-    prompt = render_core_prompt(
-        "drive-signal-classifier-user",
-        text=text.strip()[:3000],
-    )
-
-    try:
-        result = run_automation_prompt(
-            prompt,
-            caller="tools/drive_search",
-            task_profile="fast",
-            timeout=_LLM_TIMEOUT_SECONDS,
-            output_format="text",
-            append_system_prompt=json_system_prompt,
-        )
-    except (AutomationBackendUnavailableError, subprocess.TimeoutExpired) as exc:
-        return {"available": False, "label": None, "reason": f"automation_unavailable:{exc}"}
-    except Exception as exc:
-        return {"available": False, "label": None, "reason": f"automation_error:{exc}"}
-
-    if result.returncode != 0:
-        return {"available": False, "label": None, "reason": f"automation_returncode:{result.returncode}"}
-
-    parsed = _extract_json_object(result.stdout)
-    if not parsed:
-        return {"available": False, "label": None, "reason": "invalid_json"}
-
-    label = str(parsed.get("label", "") or "").strip().lower()
-    if label not in _LLM_ALLOWED_LABELS:
-        return {"available": False, "label": None, "reason": "invalid_label"}
-
-    try:
-        confidence = float(parsed.get("confidence", 0.0) or 0.0)
-    except (TypeError, ValueError):
-        confidence = 0.0
-
-    classification = {
-        "available": True,
-        "label": None if label == "none" else label,
-        "confidence": confidence,
-        "reason": str(parsed.get("reason", "") or ""),
-        "source": "llm",
-    }
+    classification = _local_classify_signal(text)
     _LLM_CLASSIFICATION_CACHE[cache_key] = {
         **classification,
         "expires_at": now + _LLM_CACHE_TTL_SECONDS,
@@ -425,54 +362,7 @@ def _llm_classify_area(text: str) -> dict:
     if cached and cached.get("expires_at", 0) > now:
         return {k: v for k, v in cached.items() if k != "expires_at"}
 
-    try:
-        from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
-    except Exception as exc:
-        return {"available": False, "label": None, "reason": f"runner_unavailable:{exc}"}
-
-    json_system_prompt = render_core_prompt("drive-area-classifier-system")
-    prompt = render_core_prompt(
-        "drive-area-classifier-user",
-        text=text.strip()[:3000],
-    )
-
-    try:
-        result = run_automation_prompt(
-            prompt,
-            caller="tools/drive_area",
-            task_profile="fast",
-            timeout=_LLM_TIMEOUT_SECONDS,
-            output_format="text",
-            append_system_prompt=json_system_prompt,
-        )
-    except (AutomationBackendUnavailableError, subprocess.TimeoutExpired) as exc:
-        return {"available": False, "label": None, "reason": f"automation_unavailable:{exc}"}
-    except Exception as exc:
-        return {"available": False, "label": None, "reason": f"automation_error:{exc}"}
-
-    if result.returncode != 0:
-        return {"available": False, "label": None, "reason": f"automation_returncode:{result.returncode}"}
-
-    parsed = _extract_json_object(result.stdout)
-    if not parsed:
-        return {"available": False, "label": None, "reason": "invalid_json"}
-
-    label = str(parsed.get("label", "") or "").strip().lower()
-    if label not in _AREA_LLM_ALLOWED_LABELS:
-        return {"available": False, "label": None, "reason": "invalid_label"}
-
-    try:
-        confidence = float(parsed.get("confidence", 0.0) or 0.0)
-    except (TypeError, ValueError):
-        confidence = 0.0
-
-    classification = {
-        "available": True,
-        "label": None if label == "none" else label,
-        "confidence": confidence,
-        "reason": str(parsed.get("reason", "") or ""),
-        "source": "llm",
-    }
+    classification = _local_classify_area(text)
     _LLM_AREA_CLASSIFICATION_CACHE[cache_key] = {
         **classification,
         "expires_at": now + _LLM_CACHE_TTL_SECONDS,
@@ -554,31 +444,31 @@ def _local_classify_area(text: str) -> dict:
     if len(text_norm) < _LLM_MIN_TEXT_CHARS:
         return {"available": False, "label": None, "reason": "text_too_short"}
 
-    global _LOCAL_AREA_CLASSIFIER
     try:
-        if _LOCAL_AREA_CLASSIFIER is None:
-            from classifier_local import LocalZeroShotClassifier
-
-            _LOCAL_AREA_CLASSIFIER = LocalZeroShotClassifier(
-                confidence_floor=_AREA_LOCAL_CONFIDENCE_THRESHOLD,
-            )
-        if not _LOCAL_AREA_CLASSIFIER.is_available():
-            return {"available": False, "label": None, "reason": "classifier_unavailable"}
+        from semantic_router import route as semantic_route
+    except Exception as exc:
+        return {"available": False, "label": None, "reason": f"router_unavailable:{exc}"}
+    try:
         label_texts = [label for label, _canonical in _AREA_LOCAL_LABELS]
         canonical_by_label = {label: canonical for label, canonical in _AREA_LOCAL_LABELS}
-        result = _LOCAL_AREA_CLASSIFIER.classify(text, label_texts)
-        if result is None:
-            return {"available": False, "label": None, "reason": "classifier_failed"}
+        result = semantic_route(
+            decision_kind="drive_area",
+            question=render_core_prompt("drive-area-classifier-system"),
+            context=text.strip()[:3000],
+            labels=tuple(label_texts),
+        )
+        if not result.ok:
+            return {"available": False, "label": None, "reason": result.error or "router_no_route"}
         canonical = canonical_by_label.get(result.label)
         return {
             "available": canonical is not None,
             "label": None if canonical == "none" else canonical,
             "confidence": float(result.confidence or 0.0),
-            "reason": "local_zero_shot",
-            "source": "local",
+            "reason": result.route_used,
+            "source": "semantic_router",
         }
     except Exception as exc:
-        return {"available": False, "label": None, "reason": f"classifier_error:{exc}"}
+        return {"available": False, "label": None, "reason": f"router_error:{exc}"}
 
 
 def _legacy_keyword_area(text: str) -> str: