nexo-brain 7.9.0 → 7.9.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.0",
+  "version": "7.9.2",
   "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.0` is the current packaged-runtime line. 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.
+Version `7.9.2` is the current packaged-runtime line. 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.
 
 Previously in `7.8.2`: patch release that fixes the compact-hook observability gap Francisco flagged after v7.8.1: `hook_runs.session_id` was empty for 7 out of 8 recent compaction rows (and when populated it stored the raw Claude Code token instead of the NEXO sid), so per-session queries over `hook_runs` for compact events could not be joined back to the NEXO session that actually compacted. v7.8.2 adds `src/hooks/compact_session_resolver.py` with `resolve_nexo_sid(claude_session_id)`, which walks the same rails the shell already uses: `sessions.claude_session_id` match, then `session_claude_aliases.claude_session_id` (most recent `last_seen` wins), then the per-conversation sidecar under `runtime/data/compacting/<safe-claude-id>.txt`, then the legacy global sidecar for single-conversation setups. `src/hooks/pre_compact.py` and `src/hooks/post_compact.py` now call the resolver and store the real NEXO sid in `hook_runs.session_id`; both wrappers also stash `{claude_session_id, sid_source}` in `hook_runs.metadata` so "why is this row still empty?" has a one-query answer. Nine new tests in `tests/test_hook_runs_compact_sid_resolution.py` pin the five resolver rails (sessions / alias / sidecar / legacy / none), malformed-sidecar rejection, the pre- and post-compact wrapper end-to-end paths, and the empty-state wrapper rail so a clean audit trail is written even when nothing resolves. No Desktop bump.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.0",
+  "version": "7.9.2",
   "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/autonomy_mandate.py

@@ -39,6 +39,7 @@ from core_prompts import render_core_prompt
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 STATE_PATH = NEXO_HOME / "runtime" / "data" / "autonomy_mandate.json"
 CLASSIFIER_QUESTION = render_core_prompt("autonomy-mandate-question")
+SEMANTIC_LABELS = ("autonomy_mandate", "not_mandate")
 
 # Marker list per NF-DS-45569A27. Case-insensitive substring match.
 MARKERS = (
@@ -119,9 +120,21 @@ def _detect_marker(text: str, *, classifier=None) -> Optional[str]:
             return marker
     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 None
+        try:
+            result = semantic_route(
+                decision_kind="autonomy_mandate",
+                question=CLASSIFIER_QUESTION,
+                context=text.strip()[:1200],
+                labels=SEMANTIC_LABELS,
+            )
+            if bool(result.ok and (result.label or result.verdict) == "autonomy_mandate"):
+                return _SEMANTIC_MARKER
+        except Exception:
+            return None
+        return None
     try:
         if bool(classifier(question=CLASSIFIER_QUESTION, context=text.strip()[:1200])):
             return _SEMANTIC_MARKER

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/guard_verbal_ack.py

@@ -10,6 +10,7 @@ from core_prompts import render_core_prompt
 
 
 CLASSIFIER_QUESTION = render_core_prompt("guard-verbal-ack-question")
+SEMANTIC_LABELS = ("explicit_ack", "not_ack")
 
 
 def _build_context(
@@ -44,7 +45,7 @@ def detect_guard_verbal_ack(
         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 = _build_context(
@@ -54,6 +55,17 @@ def detect_guard_verbal_ack(
         file_path=file_path,
         guard_summary=guard_summary,
     )
+    if classifier is None:
+        try:
+            result = semantic_route(
+                decision_kind="guard_verbal_ack",
+                question=CLASSIFIER_QUESTION,
+                context=context,
+                labels=SEMANTIC_LABELS,
+            )
+            return bool(result.ok and (result.label or result.verdict) == "explicit_ack")
+        except Exception:
+            return False
     try:
         return bool(classifier(question=CLASSIFIER_QUESTION, context=context))
     except Exception:

package/src/r14_correction_learning.py

@@ -9,10 +9,9 @@ Fase 2 Protocol Enforcer Fase C (Capa 2) item R14. Plan doc 1 reads:
 
 Implementation contract:
 
-  - Correction detection goes through the enforcement_classifier
-    (triple-reinforced yes/no on call_model_raw). Learning #122
-    prohibits keyword-based semantic detection; the classifier path
-    is the sanctioned alternative.
+  - Correction detection goes through semantic_router decision_kind
+    ``r14_correction``. Learning #122 prohibits keyword-based semantic
+    detection; the router path is the sanctioned alternative.
   - Fail-closed: when the classifier is unavailable (no API key,
     automation_backend=none, timeout, 5xx), is_correction returns
     False. Downstream R28 (system prompt) and the auto_capture hook
@@ -31,6 +30,8 @@ from __future__ import annotations
 from core_prompts import render_core_prompt
 
 CLASSIFIER_QUESTION = render_core_prompt("r14-correction-learning-question")
+SEMANTIC_LABELS = ("negative_feedback", "ordinary_request")
+POSITIVE_LABEL = "negative_feedback"
 
 
 INJECTION_PROMPT_TEMPLATE = render_core_prompt("r14-correction-learning-injection")
@@ -45,7 +46,7 @@ def detect_correction(user_text: str, *, classifier=None) -> bool:
     Args:
         user_text: Raw user-role text from the stream.
         classifier: Injection point for tests. Defaults to
-            enforcement_classifier.classify.
+            semantic_router.route(decision_kind="r14_correction").
 
     Fail-closed on ClassifierUnavailableError — returns False rather
     than raising so the caller's enforcement loop never crashes on a
@@ -62,7 +63,17 @@ def detect_correction(user_text: str, *, classifier=None) -> bool:
         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
+        try:
+            result = semantic_route(
+                decision_kind="r14_correction",
+                question=CLASSIFIER_QUESTION,
+                context=text,
+                labels=SEMANTIC_LABELS,
+            )
+            return bool(result.ok and (result.label or result.verdict) == POSITIVE_LABEL)
         except Exception:
             return False
     try:

package/src/r16_declared_done.py

@@ -10,9 +10,9 @@ Exposes detect_declared_done(assistant_text, classifier=None) → bool and
 the reminder prompt template. The window-and-state tracking lives in
 the HeadlessEnforcer / Desktop EnforcementEngine, not here.
 
-Classifier contract: same triple-reinforced yes/no path as R14
-(enforcement_classifier.classify → call_model_raw). Fail-closed on
-unavailable backend → detect returns False rather than raising.
+Classifier contract: same semantic_router yes/no path as R14
+(``decision_kind=r16_declared_done``). Fail-closed on unavailable backend →
+detect returns False rather than raising.
 
 Mirror: nexo-desktop/lib/r16-declared-done.js (pending, landing in the
 next tranche alongside the JS classifier infrastructure).
@@ -22,6 +22,7 @@ from __future__ import annotations
 from core_prompts import render_core_prompt
 
 CLASSIFIER_QUESTION = render_core_prompt("r16-declared-done-question")
+SEMANTIC_LABELS = ("declared_done", "not_done")
 
 
 INJECTION_PROMPT_TEMPLATE = render_core_prompt("r16-declared-done-injection")
@@ -43,7 +44,17 @@ def detect_declared_done(assistant_text: str, *, classifier=None) -> bool:
         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
+        try:
+            result = semantic_route(
+                decision_kind="r16_declared_done",
+                question=CLASSIFIER_QUESTION,
+                context=text,
+                labels=SEMANTIC_LABELS,
+            )
+            return bool(result.ok and (result.label or result.verdict) == "declared_done")
         except Exception:
             return False
     try:

package/src/r17_promise_debt.py

@@ -9,9 +9,9 @@ Fase 2 Protocol Enforcer Fase D item R17. Plan doc 1 reads:
 Exposes detect_promise(text, classifier) → bool. State (promise window
 countdown) lives in the caller — mirrors the R14 / R16 pattern.
 
-Classifier path is the same as R14 / R16: enforcement_classifier.classify
-routes through call_model_raw with triple reinforcement. Fail-closed on
-any unavailable backend (no promise flagged rather than a false positive).
+Classifier path is the same as R14 / R16:
+semantic_router decision_kind ``r17_promise_debt``. Fail-closed on any
+unavailable backend (no promise flagged rather than a false positive).
 
 Mirror: nexo-desktop/lib/r17-promise-debt.js (bundled with Fase D JS
 twins at the end of the tranche).
@@ -21,6 +21,7 @@ from __future__ import annotations
 from core_prompts import render_core_prompt
 
 CLASSIFIER_QUESTION = render_core_prompt("r17-promise-debt-question")
+SEMANTIC_LABELS = ("promise", "no_promise")
 
 INJECTION_PROMPT_TEMPLATE = render_core_prompt("r17-promise-debt-injection")
 
@@ -37,7 +38,17 @@ def detect_promise(assistant_text: str, *, classifier=None) -> bool:
         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
+        try:
+            result = semantic_route(
+                decision_kind="r17_promise_debt",
+                question=CLASSIFIER_QUESTION,
+                context=text,
+                labels=SEMANTIC_LABELS,
+            )
+            return bool(result.ok and (result.label or result.verdict) == "promise")
         except Exception:
             return False
     try:

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/semantic_reasoner.py

@@ -143,6 +143,7 @@ def _reason_multipass_local(
     *,
     decision_kind: str,
     question: str,
+    context: str = "",
     labels: tuple[str, ...] | None,
     confidence_floor: float,
 ):
@@ -156,7 +157,8 @@ def _reason_multipass_local(
             error="multipass_local requires labels",
         )
 
-    votes = _collect_local_votes(question, labels)
+    semantic_input = (context or "").strip() or question
+    votes = _collect_local_votes(semantic_input, labels)
     label, confidence, meta = _aggregate_votes(votes, confidence_floor)
     if label is None:
         return RouterResult(
@@ -557,6 +559,7 @@ def reason(
         return _reason_multipass_local(
             decision_kind=decision_kind,
             question=question,
+            context=context,
             labels=labels_tuple,
             confidence_floor=confidence_floor,
         )

package/src/semantic_router.py

@@ -173,11 +173,19 @@ def policy_for(decision_kind: str) -> dict[str, Any] | None:
 def _run_fast_local(
     *,
     question: str,
+    context: str = "",
     labels: tuple[str, ...],
     confidence_floor: float,
 ) -> RouterResult | None:
     """Try ``LocalZeroShotClassifier``. Return None on unavailable or
-    below-threshold so the router advances."""
+    below-threshold so the router advances.
+
+    The first layer must classify the actual user/assistant payload. For
+    guard decisions the ``question`` is usually a stable prompt template and
+    the live text lives in ``context``; feeding both into a zero-shot NLI
+    classifier makes the static prompt dominate the decision. Use context
+    when present, and fall back to question for simple direct callers.
+    """
     try:
         from classifier_local import LocalZeroShotClassifier
     except Exception as exc:  # pragma: no cover — install not ready
@@ -185,7 +193,8 @@ def _run_fast_local(
         return None
 
     clf = LocalZeroShotClassifier(confidence_floor=confidence_floor)
-    result = clf.classify(question, labels)
+    classifier_input = (context or "").strip() or question
+    result = clf.classify(classifier_input, labels)
     if result is None:
         return None
     if result.confidence < confidence_floor:
@@ -403,6 +412,7 @@ def route(
     if policy["fast_local_threshold"] is not None and labels_tuple:
         fast = _run_fast_local(
             question=question,
+            context=context,
             labels=labels_tuple,
             confidence_floor=float(policy["fast_local_threshold"]),
         )

package/src/session_end_intent.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from core_prompts import render_core_prompt
 
 CLASSIFIER_QUESTION = render_core_prompt("session-end-intent-question")
+SEMANTIC_LABELS = ("session_end", "continue_session")
 
 
 def detect_session_end_intent(user_text: str, *, classifier=None) -> bool:
@@ -16,7 +17,17 @@ def detect_session_end_intent(user_text: str, *, classifier=None) -> bool:
         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
+        try:
+            result = semantic_route(
+                decision_kind="session_end_intent",
+                question=CLASSIFIER_QUESTION,
+                context=text,
+                labels=SEMANTIC_LABELS,
+            )
+            return bool(result.ok and (result.label or result.verdict) == "session_end")
         except Exception:
             return False
     try:

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: