nexo-brain 7.1.4 → 7.1.7

package/src/cli.py

@@ -700,6 +700,83 @@ def _automations_set_schedule(args):
     return 0
 
 
+def _core_schedules_list(args):
+    from core_schedule_controls import list_core_schedules
+
+    rows = list_core_schedules()
+    if args.json:
+        print(json.dumps({"ok": True, "core_schedules": rows}, indent=2, ensure_ascii=False))
+        return 0
+    if not rows:
+        print("No core schedules available.")
+        return 0
+    for row in rows:
+        schedule = str(row.get("effective_schedule_label") or "—")
+        note = str(row.get("note") or "").strip()
+        extra = f" · {note}" if note else ""
+        print(f"{row.get('name')} · {schedule}{extra}")
+    return 0
+
+
+def _core_schedules_status(args):
+    from core_schedule_controls import get_core_schedule_status
+
+    result = get_core_schedule_status(args.name)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok") else 1
+    if not result.get("ok"):
+        print(result.get("error", "Failed to read core schedule"), file=sys.stderr)
+        return 1
+    print(f"{result.get('name')} -> {result.get('effective_schedule_label') or '—'}")
+    default_label = (result.get("default_schedule_label") or "").strip()
+    if default_label:
+        print(f"  default: {default_label}")
+    note = (result.get("note") or "").strip()
+    if note:
+        print(f"  note: {note}")
+    return 0
+
+
+def _core_schedules_set(args):
+    from core_schedule_controls import set_core_schedule
+
+    interval_seconds = None
+    daily_at = None
+    if getattr(args, "every_minutes", None) is not None:
+        interval_seconds = int(args.every_minutes) * 60
+    elif getattr(args, "every_seconds", None) is not None:
+        interval_seconds = int(args.every_seconds)
+    elif getattr(args, "daily_at", None):
+        daily_at = str(args.daily_at).strip()
+
+    result = set_core_schedule(
+        args.name,
+        interval_seconds=interval_seconds,
+        daily_at=daily_at,
+        clear=bool(getattr(args, "reset", False)),
+    )
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok") else 1
+    if not result.get("ok"):
+        print(result.get("error", "Failed to update core schedule"), file=sys.stderr)
+        return 1
+    label = str(result.get("effective_schedule_label") or "").strip()
+    source = str(result.get("schedule_source") or "manifest").strip()
+    if label:
+        print(f"Core schedule updated for {result['name']}: {label} ({source})")
+    else:
+        print(f"Core schedule updated for {result['name']}.")
+    warning = str(result.get("warning") or "").strip()
+    if warning:
+        print(f"  Warning: {warning}")
+    sync_result = result.get("runtime_sync") if isinstance(result.get("runtime_sync"), dict) else {}
+    if sync_result.get("ok") is False:
+        print(f"  Warning: saved, but runtime sync failed: {sync_result.get('error', 'unknown error')}")
+    return 0
+
+
 def _scripts_remove(args):
     from script_registry import remove_personal_script
 
@@ -976,6 +1053,12 @@ def _scripts_call(args):
         print(f"Invalid JSON input: {e}", file=sys.stderr)
         return 1
 
+    # Legacy `scripts call nexo_doctor` callers predate the explicit doctor-plane
+    # contract. Keep the plugin strict, but default the CLI compatibility surface
+    # to the install/runtime plane that old callers implicitly meant.
+    if tool_name == "nexo_doctor" and isinstance(payload, dict) and not str(payload.get("plane") or "").strip():
+        payload["plane"] = "installation_live"
+
     def _bootstrap_mcp():
         os.environ["NEXO_CLI_MODE"] = "1"
         from db import init_db
@@ -2541,6 +2624,28 @@ def main():
     automations_schedule_group.add_argument("--reset", action="store_true", help="Restore the shipped default cadence")
     automations_schedule_p.add_argument("--json", action="store_true", help="JSON output")
 
+    core_schedules_parser = sub.add_parser("core-schedules", help="Manage structural core cron cadences")
+    core_schedules_sub = core_schedules_parser.add_subparsers(dest="core_schedules_command")
+
+    core_schedules_list_p = core_schedules_sub.add_parser("list", help="List structural core schedules")
+    core_schedules_list_p.add_argument("--json", action="store_true", help="JSON output")
+
+    core_schedules_status_p = core_schedules_sub.add_parser("status", help="Read one structural core schedule")
+    core_schedules_status_p.add_argument("name", help="Core cron name")
+    core_schedules_status_p.add_argument("--json", action="store_true", help="JSON output")
+
+    core_schedules_schedule_p = core_schedules_sub.add_parser(
+        "schedule",
+        help="Change the cadence of a structural core cron",
+    )
+    core_schedules_schedule_p.add_argument("name", help="Core cron name")
+    core_schedules_schedule_group = core_schedules_schedule_p.add_mutually_exclusive_group(required=True)
+    core_schedules_schedule_group.add_argument("--every-minutes", type=int, help="Run the cron every N minutes")
+    core_schedules_schedule_group.add_argument("--every-seconds", type=int, help="Run the cron every N seconds")
+    core_schedules_schedule_group.add_argument("--daily-at", type=str, help="Run the cron at HH:MM and preserve any weekday")
+    core_schedules_schedule_group.add_argument("--reset", action="store_true", help="Restore the shipped default cadence")
+    core_schedules_schedule_p.add_argument("--json", action="store_true", help="JSON output")
+
     # -- update --
     update_parser = sub.add_parser("update", help="Update installed runtime")
     update_parser.add_argument("--json", action="store_true", help="JSON output")
@@ -2846,6 +2951,15 @@ def main():
             return _automations_set_schedule(args)
         automations_parser.print_help()
         return 0
+    elif args.command == "core-schedules":
+        if args.core_schedules_command == "list":
+            return _core_schedules_list(args)
+        elif args.core_schedules_command == "status":
+            return _core_schedules_status(args)
+        elif args.core_schedules_command == "schedule":
+            return _core_schedules_set(args)
+        core_schedules_parser.print_help()
+        return 0
     elif args.command == "chat":
         return _chat(args)
     elif args.command == "export":

package/src/client_preferences.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 """Client and automation preference helpers stored in config/schedule.json."""
 
 import os
+import json
 import shutil
 import sys
 from pathlib import Path
@@ -74,6 +75,85 @@ def _codex_bootstrap_path(home: Path) -> Path:
     return home / ".codex" / "AGENTS.md"
 
 
+def _desktop_product_requested(home: Path | None = None) -> bool:
+    if str(os.environ.get("NEXO_DESKTOP_MANAGED", "")).strip() == "1":
+        return True
+    explicit_home = home is not None
+    base = (home or _user_home()).expanduser()
+    mode_paths = (
+        base / ".nexo" / "personal" / "config" / "product-mode.json",
+        base / ".nexo" / "config" / "product-mode.json",
+    )
+    for mode_path in mode_paths:
+        try:
+            payload = json.loads(mode_path.read_text())
+        except Exception:
+            continue
+        if not isinstance(payload, dict):
+            continue
+        if payload.get("desktop_managed") is True:
+            return True
+        if str(payload.get("product_mode") or "").strip().lower() == "desktop_closed_product":
+            return True
+    desktop_markers = [
+        base / "Applications" / "NEXO Desktop.app",
+        base / "Library" / "Application Support" / "NEXO Desktop",
+        base / ".local" / "share" / "NEXO Desktop",
+        base / ".config" / "NEXO Desktop",
+    ]
+    if not explicit_home:
+        desktop_markers.insert(0, Path("/Applications/NEXO Desktop.app"))
+    for marker in desktop_markers:
+        try:
+            if marker.exists():
+                return True
+        except Exception:
+            continue
+    return False
+
+
+def _managed_claude_prefix(home: Path | None = None) -> Path:
+    explicit = str(os.environ.get("NEXO_CLAUDE_PREFIX", "")).strip()
+    if explicit:
+        return Path(explicit).expanduser()
+    return (home or _user_home()) / ".nexo" / "runtime" / "bootstrap" / "npm-global"
+
+
+def _path_within(candidate: Path, parent: Path) -> bool:
+    try:
+        candidate.expanduser().resolve(strict=False).relative_to(parent.expanduser().resolve(strict=False))
+        return True
+    except Exception:
+        return False
+
+
+def _managed_claude_binary(home: Path | None = None) -> str:
+    base = (home or _user_home()).expanduser()
+    managed_prefix = _managed_claude_prefix(base)
+    persisted_paths = [
+        base / ".nexo" / "config" / "claude-cli-path",
+        base / ".nexo" / "personal" / "config" / "claude-cli-path",
+    ]
+    candidates: list[Path] = []
+    for persisted in persisted_paths:
+        try:
+            raw = persisted.read_text(encoding="utf-8").strip()
+        except Exception:
+            raw = ""
+        if raw:
+            candidates.append(Path(raw))
+    candidates.append(managed_prefix / "bin" / "claude")
+    for candidate in candidates:
+        try:
+            if not candidate.exists():
+                continue
+        except Exception:
+            continue
+        if _path_within(candidate, managed_prefix):
+            return str(candidate)
+    return ""
+
+
 def _coerce_bool(value, default: bool) -> bool:
     if isinstance(value, bool):
         return value
@@ -584,7 +664,10 @@ def _which_with_nvm(name: str, home: Path | None = None) -> str:
 def detect_installed_clients(user_home: str | os.PathLike[str] | None = None) -> dict[str, dict]:
     home = Path(user_home).expanduser() if user_home else _user_home()
 
-    claude_bin = os.environ.get("CLAUDE_BIN", "").strip() or _which_with_nvm("claude", home)
+    if _desktop_product_requested(home):
+        claude_bin = _managed_claude_binary(home)
+    else:
+        claude_bin = os.environ.get("CLAUDE_BIN", "").strip() or _which_with_nvm("claude", home)
     codex_bin = os.environ.get("CODEX_BIN", "").strip() or _which_with_nvm("codex", home)
 
     if sys.platform == "darwin":

package/src/client_sync.py

@@ -12,6 +12,8 @@ import subprocess
 import sys
 from pathlib import Path
 
+from calibration_runtime import load_runtime_calibration
+
 try:
     import tomllib
 except ModuleNotFoundError:  # Python < 3.11
@@ -117,7 +119,7 @@ def _resolve_operator_name(nexo_home: Path, explicit: str = "") -> str:
     env_name = os.environ.get("NEXO_NAME", "").strip()
     if env_name:
         return env_name
-    calibration = _read_json_file(nexo_home / "personal" / "brain" / "calibration.json")
+    calibration = load_runtime_calibration(nexo_home / "personal" / "brain" / "calibration.json")
     user_payload = calibration.get("user")
     if isinstance(user_payload, dict):
         candidate = str(user_payload.get("assistant_name", "")).strip()
@@ -190,6 +192,28 @@ def _managed_claude_prefix(user_home: Path | None = None) -> Path:
     return home / ".nexo" / "runtime" / "bootstrap" / "npm-global"
 
 
+def _desktop_product_requested(user_home: Path | None = None) -> bool:
+    if str(os.environ.get("NEXO_DESKTOP_MANAGED", "")).strip() == "1":
+        return True
+    home = (user_home or _user_home()).expanduser()
+    mode_paths = [
+        home / ".nexo" / "personal" / "config" / "product-mode.json",
+        home / ".nexo" / "config" / "product-mode.json",
+    ]
+    for path in mode_paths:
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        if not isinstance(payload, dict):
+            continue
+        if payload.get("desktop_managed") is True:
+            return True
+        if str(payload.get("product_mode") or "").strip().lower() == "desktop_closed_product":
+            return True
+    return False
+
+
 def _bundled_npm_runtime() -> tuple[str, str]:
     node_bin = str(os.environ.get("NEXO_DESKTOP_NODE", "")).strip()
     npm_cli = str(os.environ.get("NEXO_DESKTOP_NPM_CLI", "")).strip()
@@ -224,6 +248,7 @@ def _installed_client_path(client_key: str, *, user_home: Path | None = None) ->
 
 def ensure_claude_code_installed(*, user_home: str | os.PathLike[str] | None = None) -> dict:
     home_path = Path(user_home).expanduser() if user_home else _user_home()
+    desktop_managed = _desktop_product_requested(home_path)
     existing = _installed_client_path("claude_code", user_home=home_path)
     if existing:
         _persist_managed_claude_path(existing, user_home=home_path)
@@ -232,7 +257,7 @@ def ensure_claude_code_installed(*, user_home: str | os.PathLike[str] | None = N
             "client": "claude_code",
             "installed": True,
             "changed": False,
-            "action": "already_installed",
+            "action": "already_installed_managed" if desktop_managed else "already_installed",
             "path": existing,
             "attempts": [],
         }
@@ -281,6 +306,27 @@ def ensure_claude_code_installed(*, user_home: str | os.PathLike[str] | None = N
                 "attempts": attempts,
             }
 
+    if desktop_managed:
+        error = (
+            "Desktop-managed install requires the NEXO Desktop bundled Claude runtime; "
+            "global `npx`/`npm -g` fallbacks are disabled."
+        )
+        if desktop_node and bundled_npm_cli:
+            error = (
+                "Desktop-managed Claude install did not produce the managed "
+                "`~/.nexo/runtime/bootstrap/npm-global/bin/claude` binary."
+            )
+        return {
+            "ok": False,
+            "client": "claude_code",
+            "installed": False,
+            "changed": False,
+            "action": "managed_install_failed",
+            "path": "",
+            "attempts": attempts,
+            "error": error,
+        }
+
     try:
         probe = subprocess.run(
             ["npx", "-y", CLAUDE_CODE_NPM_PACKAGE, "--version"],

package/src/cognitive/_search.py

@@ -1,7 +1,9 @@
 """NEXO Cognitive — Search, retrieval, ranking."""
 import math
+import os
 import re
 import sqlite3
+import time
 import numpy as np
 from datetime import datetime, timezone
 
@@ -17,6 +19,92 @@ from cognitive._core import (
     rehearsal_profile_update,
 )
 
+_QUERY_INTENT_SCORE_THRESHOLD = 0.72
+_QUERY_INTENT_SCORE_MARGIN = 0.14
+_QUERY_INTENT_LOCAL_CONFIDENCE_THRESHOLD = float(
+    os.environ.get("NEXO_QUERY_INTENT_LOCAL_CONFIDENCE", "0.67")
+)
+_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"),
+    ("A definition, explanation of what something is, or conceptual clarification", "definition"),
+    ("A reasoning question asking why something happens or what caused it", "reasoning"),
+    ("A question about dates, sequence, chronology, or timeline", "temporal"),
+    ("A technical code, syntax, API, or implementation lookup", "technical"),
+    ("A general lookup or recall request for facts, status, or previous context", "lookup"),
+)
+_QUERY_INTENT_CUES = {
+    "howto": ("how to", "how do", "steps", "como", "cómo", "guide", "walkthrough"),
+    "definition": ("what is", "what are", "define", "explain", "que es", "qué es", "meaning of"),
+    "reasoning": ("why", "por que", "por qué", "reason", "cause", "because", "motivo"),
+    "temporal": ("when", "timeline", "date", "fecha", "cuando", "cuándo", "chronology"),
+    "technical": ("::", "def ", "class ", "fn ", "function ", "api", "endpoint", "stack trace"),
+}
+
+
+def _query_intent_cache_key(query: str) -> str:
+    return " ".join((query or "").lower().split())[:600]
+
+
+def _semantic_query_intent_scores(query: str) -> dict[str, float]:
+    lowered = " " + " ".join((query or "").lower().split()) + " "
+    if len(lowered.strip()) < 8:
+        return {}
+    scores: dict[str, float] = {}
+    for intent, cues in _QUERY_INTENT_CUES.items():
+        hits = [cue for cue in cues if cue in lowered]
+        if not hits:
+            continue
+        score = 0.0
+        for cue in hits:
+            score += 0.28 if " " in cue else 0.18
+        scores[intent] = min(0.98, score)
+    return scores
+
+
+def _local_classify_query_intent(query: str) -> dict:
+    key = _query_intent_cache_key(query)
+    if len(key) < 12:
+        return {"available": False, "label": None, "reason": "text_too_short"}
+
+    cached = _QUERY_INTENT_CACHE.get(key)
+    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"}
+        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"}
+        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",
+        }
+        _QUERY_INTENT_CACHE[key] = {
+            **payload,
+            "expires_at": time.time() + _QUERY_INTENT_CACHE_TTL_SECONDS,
+        }
+        return payload
+    except Exception as exc:
+        return {"available": False, "label": None, "reason": f"classifier_error:{exc}"}
+
 def bm25_search(query_text: str, stores: str = "both", top_k: int = 20,
                 source_type_filter: str = "") -> list[dict]:
     """BM25 keyword search using SQLite FTS5. Returns ranked results by relevance."""
@@ -436,16 +524,27 @@ def _kg_boost_results(results: list[dict], max_boost: float = 0.08) -> list[dict
 # ============================================================================
 
 def _classify_query_intent(query: str) -> str:
-    """Classify query intent into one of 6 categories (Vestige-style)."""
-    lower = query.lower().strip()
-    if lower.startswith(("how to", "how do", "steps", "cómo")):
-        return "howto"
-    if lower.startswith(("what is", "what are", "define", "explain", "qué es")):
-        return "definition"
-    if lower.startswith(("why", "por qué")) or "reason" in lower or "porque" in lower:
-        return "reasoning"
-    if lower.startswith(("when", "cuándo")) or "date" in lower or "timeline" in lower or "fecha" in lower:
-        return "temporal"
+    """Classify query intent with semantic/local routing before lookup fallback."""
+    scores = _semantic_query_intent_scores(query)
+    if scores:
+        ordered = sorted(scores.items(), key=lambda item: item[1], reverse=True)
+        winner, winner_score = ordered[0]
+        runner_up = ordered[1][1] if len(ordered) > 1 else 0.0
+        if winner_score >= _QUERY_INTENT_SCORE_THRESHOLD and (winner_score - runner_up) >= _QUERY_INTENT_SCORE_MARGIN:
+            return winner
+
+    local_result = _local_classify_query_intent(query)
+    if local_result.get("available"):
+        confidence = float(local_result.get("confidence", 0.0) or 0.0)
+        label = local_result.get("label")
+        if isinstance(label, str) and confidence >= _QUERY_INTENT_LOCAL_CONFIDENCE_THRESHOLD:
+            return label
+
+    if scores:
+        winner, winner_score = max(scores.items(), key=lambda item: item[1])
+        if winner_score >= 0.35:
+            return winner
+
     if any(c in query for c in ("(", "{", "::", "def ", "class ", "fn ", "function ")):
         return "technical"
     return "lookup"

package/src/cognitive/_trust.py

@@ -1,4 +1,5 @@
 """NEXO Cognitive — Trust scoring, sentiment, dissonance."""
+import os
 import re
 import numpy as np
 from datetime import datetime, timedelta, timezone
@@ -267,6 +268,72 @@ SENTIMENT_INTENTS = (
     "neutral",
 )
 
+_LOCAL_SENTIMENT_CONFIDENCE_THRESHOLD = float(
+    os.environ.get("NEXO_SENTIMENT_LOCAL_CONFIDENCE", "0.68")
+)
+_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"),
+    ("The user is acknowledging or confirming that the assistant helped", "acknowledgement"),
+    ("The user is asking a question or requesting clarification", "question"),
+    ("The user is giving an instruction or a direct task to execute", "instruction"),
+    ("The user needs immediate action because the situation is urgent", "urgency"),
+    ("The user is complaining or expressing frustration", "complaint"),
+    ("The user is praising the assistant or celebrating the result", "praise"),
+    ("The message is neutral and mostly informational", "neutral"),
+)
+
+
+def _local_sentiment_cache_key(text: str) -> str:
+    return " ".join((text or "").lower().split())[:600]
+
+
+def _local_classify_sentiment_intent(text: str) -> dict:
+    key = _local_sentiment_cache_key(text)
+    if len(key) < 12:
+        return {"available": False, "label": None, "reason": "text_too_short"}
+
+    import time
+
+    now = time.time()
+    cached = _LOCAL_SENTIMENT_CACHE.get(key)
+    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"}
+        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"}
+        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",
+        }
+        _LOCAL_SENTIMENT_CACHE[key] = {
+            **payload,
+            "expires_at": now + _LOCAL_SENTIMENT_CACHE_TTL_SECONDS,
+        }
+        return payload
+    except Exception as exc:
+        return {"available": False, "label": None, "reason": f"classifier_error:{exc}"}
+
 
 def detect_sentiment(text: str) -> dict:
     """Analyze user's text for sentiment signals.
@@ -366,6 +433,29 @@ def detect_sentiment(text: str) -> dict:
         )
     )
 
+    semantic_override = False
+    local_intent = None
+    if (
+        len(text.strip()) >= 18
+        and (
+            not any([
+                correction_hits,
+                ack_hits,
+                instruction_hits,
+                question_hits,
+                urgency_hits,
+                positive_hits,
+            ])
+            or (sentiment == "negative" and not correction_hits and not question_hits)
+            or abs(pos_score - neg_score) <= 1
+        )
+    ):
+        local_result = _local_classify_sentiment_intent(text)
+        confidence = float(local_result.get("confidence", 0.0) or 0.0)
+        if local_result.get("available") and confidence >= _LOCAL_SENTIMENT_CONFIDENCE_THRESHOLD:
+            local_intent = local_result.get("label")
+            semantic_override = isinstance(local_intent, str)
+
     # Intent: prioritized enum — correction > question > instruction >
     # urgency > acknowledgement/praise > complaint > neutral.
     if is_correction:
@@ -385,6 +475,33 @@ def detect_sentiment(text: str) -> dict:
     else:
         intent = "neutral"
 
+    if semantic_override and local_intent in SENTIMENT_INTENTS:
+        intent = local_intent
+        if local_intent == "correction":
+            is_correction = True
+            sentiment = "negative"
+            intensity = max(float(intensity), 0.7)
+            guidance = "MODE: Ultra-concise. Zero explanations. Solve and show result."
+            valence = min(valence, -0.6)
+        elif local_intent == "urgency":
+            sentiment = "urgent"
+            intensity = max(float(intensity), 0.8)
+            guidance = "MODE: Immediate action. No preambles."
+            valence = min(valence, -0.2)
+        elif local_intent == "complaint":
+            sentiment = "negative"
+            intensity = max(float(intensity), 0.65)
+            guidance = "MODE: Concise. Less context, more direct action."
+            valence = min(valence, -0.45)
+        elif local_intent in {"acknowledgement", "praise"}:
+            sentiment = "positive"
+            intensity = max(float(intensity), 0.6)
+            if not guidance:
+                guidance = "MODE: Normal. Good time to suggest backlog ideas or improvements."
+            valence = max(valence, 0.45)
+        elif local_intent in {"question", "instruction"} and sentiment == "neutral":
+            intensity = max(float(intensity), 0.5)
+
     return {
         "sentiment": sentiment,
         "intensity": round(intensity, 2),