nexo-brain 6.1.0 → 6.3.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "6.1.0",
+  "version": "6.3.0",
   "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 `6.1.0` is the current packaged-runtime line: the Protocol Enforcer Fase 2 ships — a Capa 2 runtime guardian with 25 rules (R13–R25 + R23b–R23m) that keep Claude Code / Codex / Desktop aligned to NEXO protocol. Rule coverage: pre-Edit guard (R13), post-correction learning window (R14), declared-done without close (R16), Nora/María read-only destructive block (R25), plus 21 more across stream wrapper layers (Fase C + D + D2). Also lands migration v43 `session_claude_aliases` — a 1-to-N map from NEXO sid to every Claude session UUID, fixing the NEXO Desktop multi-conversation block where every second conversation's PreToolUse hook failed with "unknown target". External-LLM audit + Opus 4.7 self-audit cycle applied (log redaction with modern token formats, R23f heredoc multiline, R23h native PATH resolution, R14 awaited, hermetic map lookup, cross-engine parity harness strict). Suite: 291 pass + 2 skip documented.
+Version `6.3.0` is the current packaged-runtime line — Plan Consolidado wave 2, coordinated with NEXO Desktop v0.18.0. Closes the remaining Guardian roadmap items that do not require an invasive structure migration: extended `cognitive_sentiment` shape (is_correction/valence/intent), extended `entities` schema, 21 labelled rule fixtures with R13 spike gates, Fase F telemetry loops + Deep Sleep phase, pinned local zero-shot classifier skeleton (mDeBERTa), hook respects `NEXO_MIGRATING=1`, `origin` column on `personal_scripts`, and the T4 LLM gate wrapping R15/R23e/R23f/R23h (byte-parity Py ↔ JS). Two pre-release auditors flagged a CRITICAL in the first JS wire (method-name + async mismatch) and a HIGH (classifier bool conflated "no" with "unparseable"); both corrected with regression tests before merge.
+
+Previously in `6.1.1`: small fix to `nexo --help` so the `Latest: vX` line reliably appears when NEXO Desktop invokes the CLI via subprocess — unblocks the Desktop Brain auto-update banner that previously couldn't parse the version delta. No behaviour change for interactive terminal users; the 6-hour registry cache still rate-limits network calls. Bundles all v6.1.0 Protocol Enforcer Fase 2 + multi-claude-sid hotfix content.
 
 Previously in `6.0.2`: adds the reserved caller prefix `personal/*` so scripts living in `~/.nexo/scripts/` can invoke the automation backend with their own caller id without editing `src/resonance_map.py`. New kwarg `tier` (`"maximo"` / `"alto"` / `"medio"` / `"bajo"`) on `run_automation_prompt`, `run_automation_interactive`, `nexo_helper.run_automation_text`, `nexo_helper.run_automation_json`, and `nexo-agent-run.py --tier`. Precedence for `personal/*` callers: explicit `tier=` → explicit `reasoning_effort=` → `calibration.preferences.default_resonance` → `DEFAULT_RESONANCE` (`alto`). Registered callers keep their behaviour unchanged. New guide: [`docs/personal-scripts-guide.md`](docs/personal-scripts-guide.md).
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "nexo-brain",
-  "version": "6.1.0",
+  "version": "6.3.0",
   "mcpName": "io.github.wazionapps/nexo",
-  "description": "NEXO Brain — 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.",
+  "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",
   "bin": {
     "nexo-brain": "./bin/nexo-brain.js",

package/src/classifier_local.py

@@ -0,0 +1,176 @@
+"""Plan Consolidado 0.21 — Local zero-shot multilingual classifier.
+
+Skeleton + pinned HuggingFace coordinates. The heavy load
+(`transformers`, ~500 MB model download) is lazy so the rest of the
+runtime does not pay the cost on every import.
+
+Contract:
+
+    clf = LocalZeroShotClassifier()
+    result = clf.classify(
+        "lo hemos dejado, ya estaría",
+        labels=("done_claim", "status_update", "question", "noise"),
+    )
+    result == {"label": "done_claim", "confidence": 0.87, "scores": {...}}
+
+When transformers is not installed or the download fails (offline),
+`classify` returns `None` and `classify_fail_closed` returns a
+conservative fallback label so rules degrade gracefully (item 0.20).
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from dataclasses import dataclass
+from typing import Iterable
+
+_logger = logging.getLogger(__name__)
+
+
+# Keep in lockstep with docs/classifier-model-notes.md.
+# Plan 0.21 wave-2 update: the original pin
+# (MoritzLaurer/mDeBERTa-v3-base-mnli-xnli @ a1a5a76) refused to load
+# under transformers 5.x with a missing `model_type` error. Switched
+# to the multilingual-2mil7 sibling which is the same DeBERTa-v2
+# architecture, multilingual, and loads cleanly. Revision pinned to
+# the last HF upstream commit verified in smoke.
+MODEL_ID = "MoritzLaurer/mDeBERTa-v3-base-xnli-multilingual-nli-2mil7"
+MODEL_REVISION = "b5113eb38ab63efdd7f280f8c144ea8b13f978ce"
+DEFAULT_CONFIDENCE_FLOOR = 0.6
+
+
+@dataclass
+class ClassificationResult:
+    label: str
+    confidence: float
+    scores: dict[str, float]
+    latency_ms: float
+
+
+class LocalZeroShotClassifier:
+    """Lazy wrapper around transformers' zero-shot-classification pipeline.
+
+    Thread-safe lazy load; failures degrade to `classify(...) = None` so
+    the Guardian can decide whether to invoke the LLM fallback
+    (`call_model_raw`) or a conservative regex path.
+    """
+
+    def __init__(
+        self,
+        *,
+        model_id: str = MODEL_ID,
+        revision: str = MODEL_REVISION,
+        confidence_floor: float = DEFAULT_CONFIDENCE_FLOOR,
+    ) -> None:
+        self.model_id = model_id
+        self.revision = revision
+        self.confidence_floor = confidence_floor
+        self._pipe = None
+        self._load_failed = False
+        self._lock = threading.Lock()
+
+    # ------------------------------------------------------------------
+    # Lazy load
+    # ------------------------------------------------------------------
+    def _ensure_loaded(self) -> bool:
+        if self._pipe is not None:
+            return True
+        if self._load_failed:
+            return False
+        with self._lock:
+            if self._pipe is not None:
+                return True
+            if self._load_failed:
+                return False
+            try:
+                from transformers import pipeline  # type: ignore
+            except Exception as exc:  # pragma: no cover — no HF on CI
+                _logger.warning(
+                    "classifier_local disabled: transformers unavailable (%s)",
+                    exc,
+                )
+                self._load_failed = True
+                return False
+            try:
+                self._pipe = pipeline(
+                    "zero-shot-classification",
+                    model=self.model_id,
+                    revision=self.revision,
+                    device=-1,  # CPU-only
+                )
+                return True
+            except Exception as exc:  # pragma: no cover — network / disk
+                _logger.warning(
+                    "classifier_local pipeline failed to initialise: %s", exc
+                )
+                self._load_failed = True
+                return False
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def is_available(self) -> bool:
+        return self._ensure_loaded()
+
+    def classify(
+        self,
+        text: str,
+        labels: Iterable[str],
+        *,
+        multi_label: bool = False,
+    ) -> ClassificationResult | None:
+        """Return best label + confidence or None if the local pipeline
+        is unavailable."""
+        if not text or not labels:
+            return None
+        if not self._ensure_loaded():
+            return None
+        import time
+        t0 = time.time()
+        try:
+            raw = self._pipe(  # type: ignore[operator]
+                text,
+                candidate_labels=list(labels),
+                multi_label=multi_label,
+            )
+        except Exception as exc:  # pragma: no cover
+            _logger.warning("classifier_local inference failed: %s", exc)
+            return None
+        latency_ms = (time.time() - t0) * 1000.0
+        scores = dict(zip(raw["labels"], raw["scores"]))
+        top_label = raw["labels"][0]
+        return ClassificationResult(
+            label=top_label,
+            confidence=float(raw["scores"][0]),
+            scores=scores,
+            latency_ms=latency_ms,
+        )
+
+    def classify_fail_closed(
+        self,
+        text: str,
+        labels: Iterable[str],
+        fallback_label: str,
+    ) -> ClassificationResult:
+        """Never returns None — falls back to `fallback_label` with
+        confidence 0 so the Guardian can still decide without crashing.
+        """
+        got = self.classify(text, labels)
+        if got is not None and got.confidence >= self.confidence_floor:
+            return got
+        return ClassificationResult(
+            label=fallback_label,
+            confidence=0.0,
+            scores={label: 0.0 for label in labels},
+            latency_ms=0.0,
+        )
+
+
+__all__ = [
+    "LocalZeroShotClassifier",
+    "ClassificationResult",
+    "MODEL_ID",
+    "MODEL_REVISION",
+    "DEFAULT_CONFIDENCE_FLOOR",
+]

package/src/cli.py

@@ -118,10 +118,23 @@ def _fetch_latest_version(timeout_seconds: int = 2) -> str | None:
 
 
 def _should_refresh_latest_version() -> bool:
-    try:
-        return sys.stdout.isatty() or sys.stderr.isatty()
-    except Exception:
-        return False
+    """Decide whether to hit the npm registry to refresh `latest` version.
+
+    Prior behaviour gated this on `isatty()` so `nexo --help` never made
+    a network call outside an interactive terminal. That also meant NEXO
+    Desktop — which spawns `nexo` via subprocess with piped stdio — could
+    never populate the version cache, so the Desktop update banner for
+    Brain never saw a newer `Latest: vX` line in the help output and no
+    Brain update was ever offered automatically (v6.1.1 fix).
+
+    The 6-hour `max_age_seconds` at `_load_latest_version_cache()` is the
+    real rate-limit. This function now returns True unconditionally so
+    missing/stale cache entries are always refreshed, regardless of tty
+    context. Fail-closed: `_fetch_latest_version` still catches every
+    subprocess error and returns None, so the help line falls back to
+    installed-only when npm is unreachable.
+    """
+    return True
 
 
 def _version_sort_key(raw: str) -> tuple[tuple[int, ...], int, str]:

package/src/cognitive/_core.py

@@ -67,6 +67,42 @@ URGENCY_SIGNALS = {
     "rápido", "ya", "ahora", "urgente", "asap", "inmediatamente", "corre",
 }
 
+# Correction signals — text patterns that indicate the user is correcting NEXO.
+# Stronger than generic negative: implies "you were wrong, here's the truth".
+CORRECTION_SIGNALS = {
+    "no es", "no era", "te equivocas", "estás equivocad", "eso no",
+    "está mal", "esta mal", "mal hecho", "eso es falso",
+    "incorrecto", "ya te dije",
+    # Auditor H2 removed "otra vez" — benign phrases like
+    # "envíame la lista otra vez" were producing false corrections.
+    "es al revés", "es al reves",
+    "wrong", "that's wrong", "you're wrong", "incorrect",
+    "not quite", "actually,", "fix it",
+}
+
+# Acknowledgement signals — user explicitly confirms something NEXO proposed.
+ACKNOWLEDGEMENT_SIGNALS = {
+    "gracias", "perfecto", "genial", "exactly", "correcto",
+    "así es", "asi es", "bien hecho", "buen trabajo",
+}
+
+# Instruction signals — user asks NEXO to do something.
+INSTRUCTION_SIGNALS = {
+    "haz ", "hazlo", "crea ", "ejecuta ", "implementa ", "arregla ",
+    "envía ", "envia ", "mueve ", "dime ", "revisa ", "borra ",
+    "actualiza ", "publica ", "lanza ",
+    "run ", "execute ", "implement ", "send ", "review ",
+    "update ", "publish ", "ship ",
+}
+
+# Question signals — interrogatives.
+QUESTION_SIGNALS = {
+    "?", "¿", "qué ", "cómo ", "cuándo ", "dónde ", "por qué", "cual ",
+    "cuál ", "puedes ", "podrías ",
+    "what ", "how ", "when ", "where ", "why ", "which ", "can you",
+    "could you",
+}
+
 # Trust score events — default deltas (overridable via trust_event_config table)
 _DEFAULT_TRUST_EVENTS = {
     # Positive

package/src/cognitive/_trust.py

@@ -3,7 +3,15 @@ import re
 import numpy as np
 from datetime import datetime, timedelta, timezone
 from cognitive._core import _get_db, embed, cosine_similarity, _blob_to_array
-from cognitive._core import POSITIVE_SIGNALS, NEGATIVE_SIGNALS, URGENCY_SIGNALS
+from cognitive._core import (
+    POSITIVE_SIGNALS,
+    NEGATIVE_SIGNALS,
+    URGENCY_SIGNALS,
+    CORRECTION_SIGNALS,
+    ACKNOWLEDGEMENT_SIGNALS,
+    INSTRUCTION_SIGNALS,
+    QUESTION_SIGNALS,
+)
 
 
 # Trust score events — default deltas (overridable via trust_event_config table)
@@ -248,31 +256,57 @@ def check_correction_fatigue() -> list[dict]:
 
     return fatigued
 
+SENTIMENT_INTENTS = (
+    "correction",
+    "acknowledgement",
+    "question",
+    "instruction",
+    "urgency",
+    "complaint",
+    "praise",
+    "neutral",
+)
+
+
 def detect_sentiment(text: str) -> dict:
     """Analyze user's text for sentiment signals.
 
-    Returns detected sentiment, intensity, and action guidance for NEXO.
+    Returns detected sentiment, intensity, action guidance, and the structured
+    shape required by Plan Consolidado 0.2:
+      - is_correction: bool
+      - valence: float in [-1.0, 1.0]
+      - intent: enum (SENTIMENT_INTENTS)
+
     Not a model — keyword + heuristic based. Fast and deterministic.
     """
     if not text:
-        return {"sentiment": "neutral", "intensity": 0.5, "signals": [], "guidance": ""}
+        return {
+            "sentiment": "neutral",
+            "intensity": 0.5,
+            "signals": [],
+            "guidance": "",
+            "is_correction": False,
+            "valence": 0.0,
+            "intent": "neutral",
+        }
 
     text_lower = text.lower()
-    words = set(text_lower.split())
 
     positive_hits = [s for s in POSITIVE_SIGNALS if s in text_lower]
     negative_hits = [s for s in NEGATIVE_SIGNALS if s in text_lower]
     urgency_hits = [s for s in URGENCY_SIGNALS if s in text_lower]
+    correction_hits = [s for s in CORRECTION_SIGNALS if s in text_lower]
+    ack_hits = [s for s in ACKNOWLEDGEMENT_SIGNALS if s in text_lower]
+    instruction_hits = [s for s in INSTRUCTION_SIGNALS if s in text_lower]
+    question_hits = [s for s in QUESTION_SIGNALS if s in text_lower]
 
     # Heuristics
     is_short = len(text) < 30
-    has_caps = any(c.isupper() for c in text[1:]) if len(text) > 1 else False  # ignore first char
-    has_exclamation = "!" in text
     all_caps_words = sum(1 for w in text.split() if w.isupper() and len(w) > 1)
 
     # Score
-    pos_score = len(positive_hits)
-    neg_score = len(negative_hits)
+    pos_score = len(positive_hits) + len(ack_hits)
+    neg_score = len(negative_hits) + len(correction_hits)
 
     # Caps/short boost negative
     if all_caps_words >= 2:
@@ -283,7 +317,7 @@ def detect_sentiment(text: str) -> dict:
     if urgency_hits:
         neg_score += 1  # Urgency often means something is wrong
 
-    # Determine sentiment
+    # Determine sentiment label
     if neg_score > pos_score and neg_score >= 1:
         sentiment = "negative"
         intensity = min(1.0, 0.3 + neg_score * 0.15)
@@ -304,11 +338,62 @@ def detect_sentiment(text: str) -> dict:
         intensity = 0.5
         guidance = ""
 
+    # Valence: normalized -1..1 from raw pos/neg counts (ignores caps boost).
+    raw_pos = len(positive_hits) + len(ack_hits)
+    raw_neg = len(negative_hits) + len(correction_hits)
+    denom = max(raw_pos + raw_neg, 1)
+    valence = round((raw_pos - raw_neg) / denom, 3)
+    if urgency_hits and valence >= 0:
+        valence = round(min(valence - 0.2, 1.0), 3)
+
+    # is_correction: prioritize explicit correction signals. The
+    # fallback path (no explicit CORRECTION_SIGNALS hit) requires a
+    # stronger combination to avoid false-positives from general venting
+    # directed at third-party systems (e.g. "FAILED", "no funciona"):
+    # explicit 2+ all-caps words OR a direct second-person reference
+    # (tú/te/you) that anchors the correction at NEXO.
+    second_person = any(
+        tok in (" " + text_lower + " ")
+        for tok in (" tú ", " te ", " you ", " eso ", " eso que ")
+    )
+    is_correction = bool(correction_hits) or (
+        sentiment == "negative"
+        and is_short
+        and not question_hits
+        and (
+            all_caps_words >= 2
+            or (raw_neg >= 2 and second_person)
+        )
+    )
+
+    # Intent: prioritized enum — correction > question > instruction >
+    # urgency > acknowledgement/praise > complaint > neutral.
+    if is_correction:
+        intent = "correction"
+    elif question_hits:
+        intent = "question"
+    elif instruction_hits:
+        intent = "instruction"
+    elif urgency_hits:
+        intent = "urgency"
+    elif ack_hits and sentiment != "negative":
+        intent = "acknowledgement"
+    elif positive_hits and sentiment == "positive":
+        intent = "praise"
+    elif sentiment == "negative":
+        intent = "complaint"
+    else:
+        intent = "neutral"
+
     return {
         "sentiment": sentiment,
         "intensity": round(intensity, 2),
-        "signals": positive_hits + negative_hits + urgency_hits,
+        "signals": positive_hits + negative_hits + urgency_hits
+        + correction_hits + ack_hits + instruction_hits,
         "guidance": guidance,
+        "is_correction": is_correction,
+        "valence": valence,
+        "intent": intent,
     }
 
 

package/src/db/_core.py

@@ -259,6 +259,11 @@ def init_db():
             type TEXT NOT NULL DEFAULT 'general',
             value TEXT NOT NULL,
             notes TEXT DEFAULT '',
+            aliases TEXT DEFAULT '[]',
+            metadata TEXT DEFAULT '{}',
+            source TEXT NOT NULL DEFAULT 'manual',
+            confidence REAL NOT NULL DEFAULT 1.0,
+            access_mode TEXT DEFAULT 'unknown',
             created_at REAL NOT NULL,
             updated_at REAL NOT NULL
         );

package/src/db/_schema.py

@@ -406,6 +406,7 @@ def _m20_personal_scripts_registry(conn):
             last_run_at TEXT DEFAULT NULL,
             last_exit_code INTEGER DEFAULT NULL,
             last_synced_at TEXT DEFAULT (datetime('now')),
+            origin TEXT NOT NULL DEFAULT 'user',
             created_at TEXT DEFAULT (datetime('now')),
             updated_at TEXT DEFAULT (datetime('now'))
         )
@@ -1082,6 +1083,41 @@ def _m43_session_claude_aliases(conn):
     )
 
 
+def _m45_personal_scripts_origin(conn):
+    """Plan Consolidado F0.1 — mark whether a personal_scripts row is
+    installed by NEXO Core (origin='core'), contributed by the operator
+    (origin='user'), or a dev-only core-dev script (origin='core-dev').
+
+    Used by `nexo update` to know which rows it can replace without
+    overwriting operator-authored automations, and by the Desktop
+    Automations panel (F0.2) to segment the list.
+
+    Idempotent.
+    """
+    _migrate_add_column(conn, "personal_scripts", "origin", "TEXT NOT NULL DEFAULT 'user'")
+    _migrate_add_index(conn, "idx_personal_scripts_origin", "personal_scripts", "origin")
+
+
+def _m44_entities_extended_schema(conn):
+    """Plan Consolidado 0.3 — extend entities with aliases/metadata/source/confidence/access_mode.
+
+    - aliases:     TEXT DEFAULT '[]'   (JSON array of alternative names)
+    - metadata:    TEXT DEFAULT '{}'   (JSON object of arbitrary key/value)
+    - source:      TEXT DEFAULT 'manual'
+                   (enum: preset | manual | quarantine_approved | auto_detected)
+    - confidence:  REAL DEFAULT 1.0     (0..1 — preset=1.0, quarantine≈0.6)
+    - access_mode: TEXT DEFAULT 'unknown'
+                   (enum: read_only | read_write | write_only | unknown)
+
+    Idempotent.
+    """
+    _migrate_add_column(conn, "entities", "aliases", "TEXT DEFAULT '[]'")
+    _migrate_add_column(conn, "entities", "metadata", "TEXT DEFAULT '{}'")
+    _migrate_add_column(conn, "entities", "source", "TEXT NOT NULL DEFAULT 'manual'")
+    _migrate_add_column(conn, "entities", "confidence", "REAL NOT NULL DEFAULT 1.0")
+    _migrate_add_column(conn, "entities", "access_mode", "TEXT DEFAULT 'unknown'")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -1126,6 +1162,8 @@ MIGRATIONS = [
     (41, "automation_sessions_columns", _m41_automation_sessions_columns),
     (42, "v6_0_1_hotfix", _m42_v6_0_1_hotfix),
     (43, "session_claude_aliases", _m43_session_claude_aliases),
+    (44, "entities_extended_schema", _m44_entities_extended_schema),
+    (45, "personal_scripts_origin", _m45_personal_scripts_origin),
 ]
 
 

package/src/enforcement_classifier.py

@@ -121,7 +121,8 @@ def classify(
     call_raw: Callable[..., str] = call_model_raw,
     cache: _TTLCache = _cache,
     tier: str = "muy_bajo",
-) -> bool:
+    tristate: bool = False,
+):
     """Run a triple-reinforced yes/no classification.
 
     Args:
@@ -130,11 +131,23 @@ def classify(
         call_raw: Injection point for tests — defaults to call_model_raw.
         cache: TTL cache instance. Tests can pass a fresh cache.
         tier: Resonance tier. Default "muy_bajo" (Haiku / gpt-5.4-mini).
+        tristate: When True, return "yes" / "no" / "unknown" as strings.
+            "unknown" represents the conservative-parse-fallback path
+            which existing bool callers cannot distinguish from a real
+            "no". Plan Consolidado wave-2 auditor H1 required this
+            differentiation for destructive rules (R23e, R23f, R23h)
+            wired through the T4 gate: silently suppressing a rule on
+            an unparseable classifier answer is fail-open and unsafe.
+            Default False keeps legacy callers compatible.
 
     Returns:
-        True iff the classifier confidently answers "yes". False otherwise
-        (including when the second retry fails — conservative fallback per
-        plan doc 1 "triple refuerzo").
+        With ``tristate=False`` (default): ``True`` iff the classifier
+        confidently answers "yes", ``False`` otherwise (including the
+        conservative fallback when both retries fail to parse).
+
+        With ``tristate=True``: one of the strings ``"yes"``, ``"no"``,
+        or ``"unknown"``. ``"unknown"`` is returned when both retries
+        produce an unparseable response.
 
     Raises:
         ClassifierUnavailableError: Propagated from call_model_raw when the
@@ -145,6 +158,8 @@ def classify(
     cached = cache.get(key)
     if cached is not None:
         _logger.debug("CACHE_HIT key=%s → %s", key[:12], cached)
+        if tristate:
+            return "yes" if cached else "no"
         return cached
 
     user_text = question if not context else f"{question}\n\nContext:\n{context}"
@@ -161,6 +176,8 @@ def classify(
     if parsed is not None:
         cache.put(key, parsed)
         _logger.debug("FIRST_OK raw=%r → %s", first, parsed)
+        if tristate:
+            return "yes" if parsed else "no"
         return parsed
 
     # Retry with stricter reformulation — one time, then give up conservative.
@@ -176,13 +193,21 @@ def classify(
     if parsed is not None:
         cache.put(key, parsed)
         _logger.debug("RETRY_OK raw=%r → %s", second, parsed)
+        if tristate:
+            return "yes" if parsed else "no"
         return parsed
 
-    # Both attempts unparseable. Conservative default: NO.
+    # Both attempts unparseable. Legacy callers get the conservative False;
+    # tristate callers get "unknown" so a T4 destructive-rule gate can
+    # fall through to regex instead of silently suppressing the rule
+    # on an unparseable classifier answer.
     _logger.warning(
-        "PARSER_FAIL (fallback no) first=%r second=%r q=%r",
+        "PARSER_FAIL (fallback) first=%r second=%r q=%r",
         first, second, question[:120],
     )
+    if tristate:
+        # Do NOT cache "unknown" — retrying on the next call is desirable.
+        return "unknown"
     cache.put(key, False)
     return False