nexo-brain 7.27.2 → 7.27.6

package/src/plugins/protocol.py

@@ -61,6 +61,13 @@ R03_TRIVIAL_EVIDENCE_PATTERN = re.compile(
     r"terminado|arreglado|cerrado|solved|resuelto)\s*[\.!]*\s*$",
     re.IGNORECASE,
 )
+P0_P1_FINDING_PATTERN = re.compile(
+    r"^\s*(?:#{1,6}\s+|[-*+]\s+|\d+[.)]\s+)?(?:\*\*)?"
+    r"(P[01])(?:\*\*)?\s*(?:[:\-–—\])\)]|\b)",
+    re.IGNORECASE,
+)
+FOLLOWUP_REF_PATTERN = re.compile(r"\bNF-[A-Z0-9][A-Z0-9-]*\b", re.IGNORECASE)
+ANALYZE_ARTIFACT_SUFFIXES = {".md", ".markdown", ".txt"}
 
 
 def _is_trivial_evidence(text: str) -> tuple[bool, str]:
@@ -85,6 +92,54 @@ def _is_trivial_evidence(text: str) -> tuple[bool, str]:
     return False, ""
 
 
+def _existing_analyze_artifact_paths(refs: list[str]) -> list[Path]:
+    paths_found: list[Path] = []
+    seen: set[str] = set()
+    for ref in refs:
+        clean = str(ref or "").strip()
+        if not clean or clean.lower().startswith("followup_id"):
+            continue
+        if ":" in clean and not clean.startswith("/"):
+            prefix, value = clean.split(":", 1)
+            if prefix.strip().lower() in {"file", "path", "artifact", "report"}:
+                clean = value.strip()
+        candidate = Path(os.path.expanduser(clean))
+        if not candidate.is_file() or candidate.suffix.lower() not in ANALYZE_ARTIFACT_SUFFIXES:
+            continue
+        resolved = str(candidate.resolve())
+        if resolved in seen:
+            continue
+        seen.add(resolved)
+        paths_found.append(candidate)
+    return paths_found
+
+
+def _count_p0_p1_findings(paths_found: list[Path]) -> tuple[int, list[dict]]:
+    total = 0
+    artifacts: list[dict] = []
+    for path in paths_found:
+        findings = 0
+        try:
+            with path.open("r", encoding="utf-8", errors="replace") as fh:
+                for line in fh:
+                    if P0_P1_FINDING_PATTERN.search(line):
+                        findings += 1
+        except OSError:
+            continue
+        if findings:
+            total += findings
+            artifacts.append({"path": str(path), "findings": findings})
+    return total, artifacts
+
+
+def _count_followup_refs(refs: list[str]) -> int:
+    seen: set[str] = set()
+    for ref in refs:
+        for match in FOLLOWUP_REF_PATTERN.findall(str(ref or "")):
+            seen.add(match.upper())
+    return len(seen)
+
+
 def _external_real_world_text(task: dict, *parts: str) -> str:
     fields = [
         task.get("goal", ""),
@@ -1493,6 +1548,7 @@ def handle_task_close(
     if extra_refs:
         refs_line = "Evidence refs: " + ", ".join(extra_refs)
         clean_evidence = f"{clean_evidence}\n{refs_line}".strip() if clean_evidence else refs_line
+    all_evidence_refs = [*_parse_list(task.get("evidence_refs") or "[]"), *extra_refs]
     files_changed_list = _parse_list(files_changed)
     planned_files = _parse_list(task.get("files") or "[]")
     effective_files = files_changed_list or planned_files
@@ -1508,6 +1564,46 @@ def handle_task_close(
         high_stakes=bool(task.get("response_high_stakes")),
     )
 
+    if (task.get("task_type") or "").strip() == "analyze" and clean_outcome == "done":
+        artifact_paths = _existing_analyze_artifact_paths(all_evidence_refs)
+        finding_count, finding_artifacts = _count_p0_p1_findings(artifact_paths)
+        followup_ref_count = _count_followup_refs(all_evidence_refs)
+        if finding_count > followup_ref_count:
+            missing = finding_count - followup_ref_count
+            debt = _ensure_open_debt(
+                task["session_id"],
+                task_id,
+                "analyze_p0_p1_followups_missing",
+                severity="error",
+                evidence=(
+                    f"Analyze task produced {finding_count} P0/P1 finding(s) in report artifact(s) "
+                    f"but evidence_refs only contained {followup_ref_count} followup id(s); "
+                    f"{missing} actionable finding(s) would be left without durable followup. "
+                    f"Artifacts: {json.dumps(finding_artifacts, ensure_ascii=False)}"
+                ),
+                debts=debts_created,
+            )
+            return json.dumps(
+                {
+                    "ok": False,
+                    "error": "Cannot close analyze task as 'done' while P0/P1 report findings lack followup refs.",
+                    "hint": (
+                        "Create one followup for each P0/P1 finding and pass those followup IDs in evidence_refs, "
+                        "then retry nexo_task_close."
+                    ),
+                    "task_id": task_id,
+                    "blocked_by": "analyze_p0_p1_followup_gate",
+                    "debt_id": debt.get("id"),
+                    "debt_type": "analyze_p0_p1_followups_missing",
+                    "findings": finding_count,
+                    "followup_refs": followup_ref_count,
+                    "missing_followups": missing,
+                    "artifacts": finding_artifacts,
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
     pending_corrections = list_session_correction_requirements(
         session_id=task["session_id"],
         status="open",

package/src/pre_answer_router.py

@@ -39,6 +39,7 @@ INJECTING_INTENTS = set(PRE_ANSWER_INTENTS) - {"general"}
 DEFAULT_BUDGET_MS = 2500
 DEFAULT_TOKEN_BUDGET = 2500
 MAX_SOURCE_WORKERS = int(os.environ.get("NEXO_PRE_ANSWER_SOURCE_WORKERS", "6") or "6")
+PRE_ANSWER_SEMANTIC_DECISION_KIND = "pre_answer_intent"
 
 _WORD_RE = re.compile(r"[a-z0-9_./:@-]+")
 _PLAIN_WORD_RE = re.compile(r"[a-z0-9_]+")
@@ -46,6 +47,59 @@ _PATHISH_RE = re.compile(
     r"(?:(?:~|\.{1,2}|/)[\w./@+-]+|[\w.-]+\.(?:py|js|ts|tsx|jsx|md|json|db|sqlite|yml|yaml|txt|csv))"
 )
 _DATEISH_RE = re.compile(r"\b(?:\d{1,2}[/-]\d{1,2}(?:[/-]\d{2,4})?|\d{4}-\d{2}-\d{2})\b")
+_COLD_CONTINUITY_STEMS: tuple[str, ...] = (
+    "promet",
+    "promise",
+    "commit",
+    "compromis",
+    "pendient",
+    "pending",
+    "followup",
+    "deadline",
+    "recordatorio",
+    "reminder",
+    "hice",
+    "hiciste",
+    "hicimos",
+    "hecho",
+    "toque",
+    "toqu",
+    "tocado",
+    "touched",
+)
+_COLD_COMMITMENT_STEMS: tuple[str, ...] = (
+    "promet",
+    "promise",
+    "commit",
+    "compromis",
+    "pendient",
+    "pending",
+    "followup",
+    "deadline",
+    "recordatorio",
+    "reminder",
+)
+_COLD_OPERATOR_TOKENS: frozenset[str] = frozenset(
+    {
+        "i",
+        "me",
+        "my",
+        "you",
+        "your",
+        "we",
+        "our",
+        "yo",
+        "mi",
+        "mis",
+        "me",
+        "tu",
+        "tus",
+        "nosotros",
+        "nuestro",
+        "nuestra",
+        "nero",
+    }
+)
 _SECRET_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = (
     (
         re.compile(
@@ -297,7 +351,7 @@ _INTENT_FEATURE_WEIGHTS: dict[str, dict[str, float]] = {
     "modify_existing": {"modify": 1.30, "existing_ref": 0.70, "location": 0.20, "past_work": 0.20},
     "memory_question": {"memory": 1.40, "past_work": 0.20, "identity": 0.15},
     "identity_authorship": {"identity": 1.20, "past_work": 0.65},
-    "schedule_commitment": {"schedule": 1.55, "past_work": 0.10},
+    "schedule_commitment": {"schedule": 1.55, "past_work": 0.10, "memory": 0.20},
     "runtime_diagnosis": {"runtime": 1.55, "location": 0.15},
 }
 
@@ -432,6 +486,7 @@ _SOURCE_PLANS: dict[str, SourcePlan] = {
         primary=(
             SourceStep("recent_context", timeout_ms=240),
             SourceStep("evidence_ledger", timeout_ms=260),
+            SourceStep("commitments", timeout_ms=180),
             SourceStep("protocol_tasks", timeout_ms=240),
             SourceStep("workflows", timeout_ms=260),
             SourceStep("change_log", timeout_ms=260),
@@ -470,6 +525,9 @@ _SOURCE_PLANS: dict[str, SourcePlan] = {
     "memory_question": SourcePlan(
         intent="memory_question",
         primary=(
+            SourceStep("commitments", timeout_ms=180),
+            SourceStep("reminders", timeout_ms=260),
+            SourceStep("followups", timeout_ms=260),
             SourceStep("diary", timeout_ms=280),
             SourceStep("evidence_ledger", timeout_ms=260),
             SourceStep("memory", timeout_ms=500),
@@ -485,6 +543,7 @@ _SOURCE_PLANS: dict[str, SourcePlan] = {
         primary=(
             SourceStep("recent_context", timeout_ms=240),
             SourceStep("evidence_ledger", timeout_ms=260),
+            SourceStep("commitments", timeout_ms=180),
             SourceStep("diary", timeout_ms=280),
             SourceStep("change_log", timeout_ms=300),
             SourceStep("transcripts", timeout_ms=700),
@@ -494,6 +553,7 @@ _SOURCE_PLANS: dict[str, SourcePlan] = {
     "schedule_commitment": SourcePlan(
         intent="schedule_commitment",
         primary=(
+            SourceStep("commitments", timeout_ms=180),
             SourceStep("reminders", timeout_ms=260),
             SourceStep("followups", timeout_ms=260),
             SourceStep("workflows", timeout_ms=280),
@@ -522,8 +582,81 @@ _EXECUTOR: concurrent.futures.ThreadPoolExecutor | None = None
 
 
 def classify_intent(query: str, *, current_context: str = "") -> IntentClassification:
-    """Classify the turn using multilingual concept overlap, not phrase rules."""
+    """Classify the turn through the semantic router first.
+
+    The legacy concept-overlap scorer remains only as a degraded fallback for
+    installs where the local semantic stack is unavailable.
+    """
     text = f"{query or ''}\n{current_context or ''}".strip()
+    semantic = _classify_intent_semantic(text)
+    if semantic is not None:
+        return semantic
+    fallback = _classify_intent_fallback(text)
+    conservative = _conservative_continuity_fallback(text, fallback)
+    if conservative is not None:
+        return conservative
+    if _demote_cold_generic_continuity(text, fallback):
+        return IntentClassification(
+            intent="general",
+            confidence=0.0,
+            scores={**fallback.scores, "semantic_unavailable": 1.0},
+            features={
+                **fallback.features,
+                "cold_generic_continuity_demoted": 1.0,
+            },
+            language_hints=fallback.language_hints,
+        )
+    return fallback
+
+
+def _classify_intent_semantic(text: str) -> IntentClassification | None:
+    if not text or not _pre_answer_semantic_intent_enabled():
+        return None
+    try:
+        from semantic_router import route as semantic_route
+    except Exception:
+        return None
+
+    result = semantic_route(
+        decision_kind=PRE_ANSWER_SEMANTIC_DECISION_KIND,
+        question=(
+            "Classify the user's pre-answer need into exactly one label. "
+            "prior_work means previous actions, reasons, evidence, or why an artifact was touched. "
+            "file_location means where a file/project/artifact is. "
+            "modify_existing means editing or continuing an existing artifact. "
+            "memory_question means asking remembered facts, decisions, or context. "
+            "identity_authorship means who did something, which session/client acted, or Nero authorship. "
+            "schedule_commitment means promises, pending commitments, reminders, deadlines, or future follow-up. "
+            "runtime_diagnosis means diagnosing NEXO/Brain/Desktop/runtime/tools. "
+            "general means no pre-answer continuity evidence is needed."
+        ),
+        context=text,
+        labels=PRE_ANSWER_INTENTS,
+        allow_remote_fallback=_pre_answer_semantic_remote_enabled(),
+    )
+    if not getattr(result, "ok", False):
+        return None
+
+    label = str(getattr(result, "label", None) or getattr(result, "verdict", "") or "").strip()
+    if label not in PRE_ANSWER_INTENTS:
+        return None
+
+    confidence = _coerce_confidence(getattr(result, "confidence", 0.0), default=0.75)
+    normalized = _normalize(text)
+    tokens = _plain_tokens(normalized)
+    return IntentClassification(
+        intent=label,
+        confidence=confidence if label != "general" else min(confidence, 0.2),
+        scores={label: round(confidence, 4)},
+        features={
+            "semantic_route": 1.0,
+            "semantic_confidence": round(confidence, 4),
+        },
+        language_hints=_language_hints(tokens),
+    )
+
+
+def _classify_intent_fallback(text: str) -> IntentClassification:
     normalized = _normalize(text)
     tokens = _plain_tokens(normalized)
     features = {name: _feature_score(tokens, terms) for name, terms in _FEATURE_LEXICON.items()}
@@ -563,6 +696,108 @@ def classify_intent(query: str, *, current_context: str = "") -> IntentClassific
     )
 
 
+def _conservative_continuity_fallback(
+    text: str,
+    fallback: IntentClassification,
+) -> IntentClassification | None:
+    """Route short operator continuity questions to safe evidence sources.
+
+    This fallback is only a cold-start safety net. The semantic router remains
+    the primary detector; here we require an operational anchor so generic
+    questions do not inject unrelated memory or open commitments.
+    """
+    normalized = _normalize(text)
+    tokens = _plain_tokens(normalized)
+    if not tokens:
+        return None
+    question_like = "?" in text or normalized.startswith(("que ", "qué ", "what ", "which ", "who ", "quien ", "donde ", "where ", "why ", "por que ", "por qué "))
+    if not question_like or len(tokens) > 9:
+        return None
+    pathish = bool(_PATHISH_RE.search(normalized))
+    if (
+        fallback.intent == "file_location"
+        and pathish
+        and fallback.features.get("location", 0.0) <= 0.95
+    ):
+        return IntentClassification(
+            intent="prior_work",
+            confidence=0.40,
+            scores={"prior_work": 0.40, "semantic_unavailable": 1.0},
+            features={"conservative_continuity_fallback": 1.0, "path_context": 1.0},
+            language_hints=_language_hints(tokens),
+        )
+    if fallback.intent in {"file_location", "modify_existing", "runtime_diagnosis"} and fallback.confidence >= 0.60:
+        return None
+    if pathish and fallback.intent == "file_location":
+        return None
+    if not _cold_continuity_anchor(tokens):
+        return None
+    return IntentClassification(
+        intent="memory_question",
+        confidence=0.35,
+        scores={"memory_question": 0.35, "semantic_unavailable": 1.0},
+        features={"conservative_continuity_fallback": 1.0},
+        language_hints=_language_hints(tokens),
+    )
+
+
+def _cold_continuity_anchor(tokens: Iterable[str]) -> bool:
+    token_list = list(tokens)
+    if not token_list:
+        return False
+    if any(token.startswith(stem) for token in token_list for stem in _COLD_CONTINUITY_STEMS):
+        return True
+    if _COLD_OPERATOR_TOKENS.intersection(token_list):
+        return _feature_score(token_list, _FEATURE_LEXICON["past_work"]) >= 0.60
+    return False
+
+
+def _demote_cold_generic_continuity(text: str, fallback: IntentClassification) -> bool:
+    if fallback.intent not in {"prior_work", "memory_question"}:
+        return False
+    normalized = _normalize(text)
+    tokens = _plain_tokens(normalized)
+    if not tokens or len(tokens) > 9:
+        return False
+    question_like = "?" in text or normalized.startswith(("que ", "qué ", "what ", "which ", "who ", "quien ", "donde ", "where ", "why ", "por que ", "por qué "))
+    if not question_like:
+        return False
+    if _PATHISH_RE.search(normalized):
+        return False
+    return not _cold_continuity_anchor(tokens)
+
+
+def _cold_commitment_question(text: str) -> bool:
+    tokens = _plain_tokens(_normalize(text))
+    if not tokens:
+        return False
+    if any(token.startswith(stem) for token in tokens for stem in _COLD_COMMITMENT_STEMS):
+        return True
+    return _feature_score(tokens, _FEATURE_LEXICON["schedule"]) >= 0.60
+
+
+def _pre_answer_semantic_intent_enabled() -> bool:
+    value = os.environ.get("NEXO_PRE_ANSWER_SEMANTIC_INTENT", "1")
+    return str(value or "").strip().lower() not in {"0", "false", "no", "off", "disabled"}
+
+
+def _pre_answer_semantic_remote_enabled() -> bool:
+    value = os.environ.get("NEXO_PRE_ANSWER_SEMANTIC_REMOTE", "0")
+    return str(value or "").strip().lower() in {"1", "true", "yes", "on", "enabled"}
+
+
+def _coerce_confidence(value: Any, *, default: float) -> float:
+    try:
+        parsed = float(value)
+    except Exception:
+        return default
+    if parsed < 0.0:
+        return 0.0
+    if parsed > 1.0:
+        return 1.0
+    return parsed
+
+
 def plan_sources(intent: str) -> SourcePlan:
     return _SOURCE_PLANS.get(intent, _SOURCE_PLANS["general"])
 
@@ -725,6 +960,7 @@ def default_source_adapters() -> dict[str, SourceAdapter]:
         "filesystem": _source_filesystem,
         "guard_context": _source_guard_context,
         "cognitive": _source_cognitive,
+        "commitments": _source_commitments,
         "continuity": _source_continuity,
         "reminders": _source_reminders,
         "followups": _source_followups,
@@ -1354,13 +1590,69 @@ def _source_guard_context(request: SourceRequest) -> SourceResult:
 
 
 def _source_cognitive(request: SourceRequest) -> SourceResult:
-    rows = _query_table_like(
-        "memory_observations",
+    from memory_retrieval import memory_search
+
+    result = memory_search(
         request.query,
-        columns=("title", "summary", "content", "source"),
+        project_hint=request.area,
+        depth="evidence",
         limit=4,
+        process_queue=True,
+    )
+    candidates = result.get("candidates") or []
+    if not candidates:
+        return SourceResult(source="cognitive")
+    lines = []
+    refs: list[str] = []
+    for item in candidates[:4]:
+        refs.extend(str(ref) for ref in item.get("evidence_refs") or [])
+        lines.append(
+            "- "
+            + " | ".join(
+                part
+                for part in (
+                    f"type={item.get('type')}" if item.get("type") else "",
+                    f"subject={_clip(str(item.get('subject') or ''), 160)}" if item.get("subject") else "",
+                    f"summary={_clip(str(item.get('summary') or ''), 320)}" if item.get("summary") else "",
+                )
+                if part
+            )
+        )
+    return SourceResult(
+        source="cognitive",
+        rendered=_clip("\n".join(lines), request.max_chars),
+        evidence_refs=list(dict.fromkeys(refs)),
+        result_count=len(candidates),
+    )
+
+
+def _source_commitments(request: SourceRequest) -> SourceResult:
+    from db import list_commitments
+
+    rows = list_commitments(
+        query=request.query,
+        status="",
+        session_id=request.sid if request.intent == "identity_authorship" else "",
+        project_key=request.area,
+        limit=6,
+    )
+    if not rows and (
+        request.intent == "schedule_commitment"
+        or (request.intent == "memory_question" and _cold_commitment_question(request.query))
+    ):
+        rows = list_commitments(
+            query="",
+            status="open",
+            session_id=request.sid,
+            project_key=request.area,
+            limit=6,
+        )
+    return _rows_result(
+        "commitments",
+        rows,
+        ("id", "status", "deadline", "owner", "statement", "action_ref_type", "action_ref_id", "evidence_ref"),
+        request.max_chars,
     )
-    return _rows_result("cognitive", rows, ("id", "title", "summary", "source"), request.max_chars)
 
 
 def _source_continuity(request: SourceRequest) -> SourceResult:

package/src/r14_correction_learning.py

@@ -4,7 +4,7 @@ Phase 2 Protocol Enforcer Phase C (Layer 2) item R14. Plan doc 1 reads:
 
   IF the last user message -> cognitive_sentiment.is_correction = true
      OR valence < -0.4
-  AND nexo_learning_add does NOT appear in the next 3 tool calls
+  AND nexo_learning_add does NOT appear in the next 2 tool calls
   THEN inject the obligation.
 
 Implementation contract:
@@ -17,7 +17,7 @@ Implementation contract:
     False. Downstream R28 (system prompt) and the auto_capture hook
     still cover the gap; we would rather miss a correction than
     harass the agent with false-positive R14 injections.
-  - The "3-tool-calls window" state lives in the caller
+  - The "2-tool-calls window" state lives in the caller
     (HeadlessEnforcer / Desktop EnforcementEngine). This module only
     exposes the pure decision function and the structured injection
     prompt.
@@ -37,7 +37,7 @@ POSITIVE_LABEL = "negative_feedback"
 INJECTION_PROMPT_TEMPLATE = render_core_prompt("r14-correction-learning-injection")
 
 
-DEFAULT_WINDOW_TOOL_CALLS = 3
+DEFAULT_WINDOW_TOOL_CALLS = 2
 
 
 def detect_correction(user_text: str, *, classifier=None) -> bool:

package/src/requirements.txt

@@ -1,6 +1,10 @@
 # NEXO Brain — runtime dependencies
 # Core (required)
-fastmcp>=2.9.0
+# v7.27.5 — cap fastmcp <3.2.0 hasta validar 3.2.x. Builds intermedias 3.x
+# perdieron el re-export de ToolResult desde fastmcp.tools (live failure
+# en Win10 22H2 Azure VM 2026-05-28). Mantenemos el fallback de import en
+# src/runtime_versioning.py por defensa-en-profundidad.
+fastmcp>=2.9.0,<3.2.0
 numpy
 tomli; python_version < "3.11"
 

package/src/runtime_versioning.py

@@ -13,7 +13,17 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from fastmcp.server.middleware import Middleware
-from fastmcp.tools import ToolResult
+# v7.27.5 — fastmcp 3.x mantiene ToolResult exportado en fastmcp.tools
+# (vía __init__.py re-export de .tool.ToolResult), pero algunas builds
+# intermedias tras la transición 2.x→3.x perdieron el re-export y el import
+# simple falla con `ImportError: cannot import name 'ToolResult' from
+# 'fastmcp.tools'`. Fallback al path canónico .tools.tool para sobrevivir
+# tanto a la versión nueva como a las builds inestables. Confirmado live en
+# máquina virgen Win10 22H2 Azure VM 2026-05-28.
+try:
+    from fastmcp.tools import ToolResult  # noqa: F401
+except ImportError:
+    from fastmcp.tools.tool import ToolResult  # type: ignore[no-redef]
 
 import paths
 

package/src/saved_not_used_audit.py

@@ -44,6 +44,7 @@ class SavedNotUsedConfig:
 
     nexo_db_path: Path | None = None
     local_context_db_path: Path | None = None
+    local_context_usage_db_path: Path | None = None
     email_db_path: Path | None = None
     transcript_roots: tuple[Path, ...] = ()
     desktop_conversations_path: Path | None = None
@@ -89,11 +90,13 @@ def default_config() -> SavedNotUsedConfig:
     if paths is not None:
         nexo_db = _safe_path_call(paths.resolve_db_path)
         local_context = Path(os.environ.get("NEXO_LOCAL_CONTEXT_DB", "")) if os.environ.get("NEXO_LOCAL_CONTEXT_DB") else _safe_path_call(lambda: paths.memory_dir() / "local-context.db")
+        local_context_usage = Path(os.environ.get("NEXO_LOCAL_CONTEXT_USAGE_DB", "")) if os.environ.get("NEXO_LOCAL_CONTEXT_USAGE_DB") else _safe_path_call(lambda: paths.memory_dir() / "local-context-usage.db")
         email_db = _safe_path_call(lambda: paths.nexo_email_dir() / "nexo-email.db")
         cron_spool = _safe_path_call(lambda: paths.operations_dir() / "cron-spool")
     else:
         nexo_db = home / "runtime" / "data" / "nexo.db"
         local_context = home / "runtime" / "memory" / "local-context.db"
+        local_context_usage = home / "runtime" / "memory" / "local-context-usage.db"
         email_db = home / "runtime" / "nexo-email" / "nexo-email.db"
         cron_spool = home / "runtime" / "operations" / "cron-spool"
 
@@ -106,6 +109,7 @@ def default_config() -> SavedNotUsedConfig:
     return SavedNotUsedConfig(
         nexo_db_path=nexo_db,
         local_context_db_path=local_context,
+        local_context_usage_db_path=local_context_usage,
         email_db_path=email_db,
         transcript_roots=transcript_roots,
         desktop_conversations_path=desktop_dir / "conversations.json",
@@ -197,7 +201,7 @@ def _audit_local_context(cfg: SavedNotUsedConfig) -> tuple[StoreAuditRow, list[S
     producer = "nexo-local-index.py -> local_context.api"
     consumer = "nexo_context_router / nexo_local_context / pre_action_context"
     risk = "Local index is written but may not be consulted before answering."
-    test = "local_assets/chunks/entities > 0 requires a recent local_context_queries row."
+    test = "local_assets/chunks/entities > 0 requires recent used_before_response usage events."
     if not cfg.local_context_db_path or not cfg.local_context_db_path.exists():
         row = _row("local_context", producer, store, consumer, "", "", risk, test, "missing", "P2", {"path_exists": False})
         return row, []
@@ -207,14 +211,19 @@ def _audit_local_context(cfg: SavedNotUsedConfig) -> tuple[StoreAuditRow, list[S
         write_counts = {table: _count(conn, table) for table in LOCAL_CONTEXT_WRITE_TABLES}
         query_count = _count(conn, "local_context_queries")
         last_write = _max_many(conn, [(table, ("updated_at", "last_seen_at", "created_at")) for table in LOCAL_CONTEXT_WRITE_TABLES])
-        last_use = _max_timestamp(conn, "local_context_queries", ("created_at", "updated_at"))
+        legacy_last_use = _max_timestamp(conn, "local_context_queries", ("created_at", "updated_at"))
         evidence.update({"write_counts": write_counts, "query_count": query_count})
+    usage_stats = _local_context_usage_stats(cfg)
+    last_use = usage_stats.get("latest_used_before_response_at") or legacy_last_use
+    real_use_count = int(usage_stats.get("used_before_response_count") or 0)
+    evidence["usage_events"] = usage_stats
+    evidence["legacy_last_use"] = legacy_last_use
 
     findings: list[SavedNotUsedFinding] = []
     total_writes = sum(write_counts.values())
     status = "ok"
     severity = "OK"
-    if total_writes and not query_count:
+    if total_writes and not real_use_count:
         status = "saved_not_used"
         severity = "P0"
         findings.append(
@@ -273,6 +282,38 @@ def _audit_local_context(cfg: SavedNotUsedConfig) -> tuple[StoreAuditRow, list[S
     return _row("local_context", producer, store, consumer, last_write, last_use, risk, test, status, severity, evidence), findings
 
 
+def _local_context_usage_stats(cfg: SavedNotUsedConfig) -> dict[str, Any]:
+    usage_path = cfg.local_context_usage_db_path
+    if usage_path is None and cfg.local_context_db_path is not None:
+        usage_path = cfg.local_context_db_path.with_name("local-context-usage.db")
+    evidence = {
+        "path": _path_text(usage_path),
+        "path_exists": bool(usage_path and usage_path.exists()),
+        "total": 0,
+        "used_before_response_count": 0,
+        "latest_at": "",
+        "latest_used_before_response_at": "",
+    }
+    if not usage_path or not usage_path.exists():
+        return evidence
+    with _connect(usage_path) as conn:
+        table = "local_context_usage_events"
+        if not _table_exists(conn, table):
+            return evidence
+        evidence["total"] = _count(conn, table)
+        evidence["used_before_response_count"] = _count_where(conn, table, "COALESCE(used_before_response,0) != 0")
+        evidence["latest_at"] = _max_timestamp(conn, table, ("created_at",))
+        try:
+            row = conn.execute(
+                f"SELECT MAX(created_at) AS value FROM {_quote(table)} WHERE COALESCE(used_before_response,0) != 0"
+            ).fetchone()
+            if row and row["value"] not in (None, ""):
+                evidence["latest_used_before_response_at"] = _time_text(row["value"])
+        except sqlite3.Error:
+            pass
+    return evidence
+
+
 def _audit_memory_pipeline(cfg: SavedNotUsedConfig) -> tuple[StoreAuditRow, list[SavedNotUsedFinding]]:
     store_id = "memory_observations_pipeline"
     producer = "record_memory_event"