nexo-brain 7.9.0 → 7.9.1

package/.claude-plugin/plugin.json

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