nexo-brain 7.34.0 → 7.36.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.34.0",
+  "version": "7.36.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,7 @@
 
 [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.34.0` is the current packaged-runtime line. Minor release - Cognitive OS Ola 2: a working-memory `resolution_cache` fast-path avoids re-resolving what was just resolved (never-stale, fail-closed: content-snapshot + global watermark + 15-min TTP, repo-map for code), a later action that reveals a prior self-error auto-captures a learning + prevention, the associative graph (Personalized PageRank) connects the dots multi-hop over the KG at answer time (anti-hub, fail-open, per-process cache), Deep Sleep gains a nightly phase that safely merges duplicate learnings (reversible, zero hard-delete, fail-closed backup, daily cap), and a reproducible memory-recall eval bank (recall@k/MRR) lands with a baseline. Builds on v7.33.0 (semantic recall + graph-at-answer + reliability).
+Version `7.36.0` is the current packaged-runtime line. Minor release - local index disk reclaim: the local file/code index (`local-context.db`) no longer grows without bound. It now uses `auto_vacuum=INCREMENTAL` plus a one-time guarded `VACUUM` to convert existing databases, stores embeddings as compact float32 BLOBs instead of JSON text (~4-6x smaller, back-compatible dual-write/dual-read with a resumable backfill and kill switches), reclaims disk on purge/clear, and the daily self-audit now actively compacts at its size cap (`NEXO_LOCAL_INDEX_MAX_BYTES`) instead of only warning. An established index reclaims ~10-20GB immediately and grows several-fold slower; the backup subsystem was audited and is already bounded. Builds on v7.35.0 (selective forget + recurring-incident diagnostic templates).
 
 Previously in `7.31.9`: patch release over v7.31.8 - UI release closeout now has to prove the original reported symptom was reopened with observable evidence before claiming the release is ready.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.34.0",
+  "version": "7.36.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.",
   "homepage": "https://nexo-brain.com",

package/src/db/_hot_context.py

@@ -570,6 +570,21 @@ def build_pre_action_context(
     reminders = _find_related_items("reminders", clean_query, hours=hours, limit=4) if clean_query else []
     followups = _find_related_items("followups", clean_query, hours=hours, limit=4) if clean_query else []
 
+    # Ola 4 SCHEMA-ABSTRACTION: if the current action CLEARLY matches a distilled
+    # recurring-incident archetype (e.g. "cron exit 0 but the tool failed
+    # silently"), prime the complete diagnosis instead of re-diagnosing from
+    # scratch. Best-effort, non-authoritative, precision-first: a template is
+    # surfaced only on a clear archetype match, never in general, and it NEVER
+    # blocks. Any failure here must not break pre-action context.
+    diagnostic_templates: list[dict] = []
+    if clean_query:
+        try:
+            import schema_abstraction as sa
+
+            diagnostic_templates = sa.match_templates_for_action(query=clean_query, limit=1)
+        except Exception:
+            diagnostic_templates = []
+
     return {
         "query": clean_query,
         "context_key": clean_key,
@@ -578,7 +593,8 @@ def build_pre_action_context(
         "events": events,
         "reminders": reminders,
         "followups": followups,
-        "has_matches": bool(contexts or events or reminders or followups),
+        "diagnostic_templates": diagnostic_templates,
+        "has_matches": bool(contexts or events or reminders or followups or diagnostic_templates),
     }
 
 
@@ -592,6 +608,19 @@ def format_pre_action_context_bundle(bundle: dict, *, compact: bool = False) ->
         header += f" — query: {bundle['query'][:120]}"
     lines.append(header)
 
+    # Ola 4: primed diagnosis from a matched recurring-incident archetype goes
+    # FIRST — the whole point is to lead with the right diagnosis.
+    templates = bundle.get("diagnostic_templates") or []
+    if templates:
+        try:
+            import schema_abstraction as sa
+
+            rendered = sa.format_templates_for_injection(templates)
+            if rendered:
+                lines.append(rendered)
+        except Exception:
+            pass
+
     contexts = bundle.get("contexts") or []
     if contexts:
         lines.append("Contexts:")

package/src/db/_schema.py

@@ -2007,6 +2007,7 @@ def _m63_local_context_layer(conn):
             model_revision TEXT NOT NULL DEFAULT '',
             dimension INTEGER NOT NULL,
             vector_json TEXT NOT NULL,
+            vector_blob BLOB,
             created_at REAL NOT NULL
         );
 
@@ -2714,6 +2715,68 @@ def _m75_failure_prevention_ledger(conn):
     _migrate_add_index(conn, "idx_antibody_actions_verification", "antibody_actions", "verification_status, review_due_at")
 
 
+def _m88_schema_abstraction_templates(conn):
+    """Ola 4 — diagnostic templates distilled from recurring incident archetypes.
+
+    NOTE (append-only migration discipline): this used to be called inline from
+    ``_m75_failure_prevention_ledger`` (as ``_m75b_...``). That meant any install
+    already at schema v75 would NEVER create ``diagnostic_templates`` through
+    ``run_migrations()`` (v75 was already marked applied), so the table only
+    appeared via the lazy ``_ensure_tables`` fallback. Promoting it to its own
+    appended migration version makes a normal upgrade from v75 create the table
+    through the standard migration path. Idempotent (``IF NOT EXISTS``), so it is
+    a no-op on installs where ``_ensure_tables``/the old inline call already
+    created it.
+
+    A diagnostic template is the destillation of a GENUINELY recurring class of
+    incident (>= MIN_CLUSTER_SIZE distinct failure cases of the same archetype,
+    by symptom similarity) into a reusable, complete-diagnosis-first checklist
+    that primes the right diagnosis instantly when the archetype reappears,
+    instead of re-diagnosing from scratch (Francisco's canonical case: "cron
+    exit 0 but the tool failed in SILENCE").
+
+    Non-authoritative guidance: templates never block; they only inject a primed
+    diagnosis into pre_action_context on a clear archetype match. Idempotent:
+    deduped by ``template_uid`` (stable hash of archetype key). A template is
+    minted only at high confidence; ambiguity yields nothing (a low-confidence
+    candidate, never an active template).
+    """
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS diagnostic_templates (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            template_uid TEXT NOT NULL UNIQUE,
+            policy_version TEXT NOT NULL DEFAULT 'schema_abstraction.v1',
+            archetype TEXT NOT NULL,
+            archetype_key TEXT NOT NULL,
+            failure_type TEXT NOT NULL DEFAULT 'other',
+            area TEXT NOT NULL DEFAULT '',
+            symptom_pattern TEXT NOT NULL DEFAULT '',
+            diagnosis_steps_json TEXT NOT NULL DEFAULT '[]',
+            prevention TEXT NOT NULL DEFAULT '',
+            match_tokens_json TEXT NOT NULL DEFAULT '[]',
+            member_uids_json TEXT NOT NULL DEFAULT '[]',
+            incident_count INTEGER NOT NULL DEFAULT 0,
+            confidence REAL NOT NULL DEFAULT 0.0,
+            status TEXT NOT NULL DEFAULT 'active',
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            retired_at REAL,
+            retired_reason TEXT NOT NULL DEFAULT '',
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            CHECK(status IN ('active','candidate','retired','superseded')),
+            CHECK(privacy_level IN ('public','normal','private','sensitive','secret')),
+            CHECK(incident_count >= 0),
+            CHECK(confidence >= 0.0 AND confidence <= 1.0)
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_diagnostic_templates_archetype", "diagnostic_templates", "archetype_key")
+    _migrate_add_index(conn, "idx_diagnostic_templates_status", "diagnostic_templates", "status, area")
+    _migrate_add_index(conn, "idx_diagnostic_templates_type", "diagnostic_templates", "failure_type, status")
+
+
 def _m76_semantic_layers(conn):
     """SemanticLayers cache for compact, source-backed continuity.
 
@@ -3402,6 +3465,7 @@ MIGRATIONS = [
     (85, "eval_runs", _m85_eval_runs),
     (86, "resolution_cache", _m86_resolution_cache),
     (87, "resolution_cache_content_snapshot", _m87_resolution_cache_content_snapshot),
+    (88, "schema_abstraction_templates", _m88_schema_abstraction_templates),
 ]
 
 

package/src/deep_sleep_retention.py

@@ -146,6 +146,14 @@ def _prune_db_backups(deep_sleep_dir: Path, report: dict, *, keep: int, apply: b
             _record_delete(report, backup, reason=f"old-db-backup:{family}", apply=apply)
             for sidecar in _sidecars(backup):
                 _record_delete(report, sidecar, reason=f"old-db-backup-sidecar:{family}", apply=apply)
+    # Orphan sweep: -wal/-shm sidecars whose base .db no longer exists (left by
+    # interrupted/legacy deep-sleep processes). The online-backup path produces
+    # sidecar-free snapshots, so any sidecar with a missing base is a true
+    # orphan. Scoped strictly to this deep-sleep backup dir; never the live DBs.
+    for sidecar in list(deep_sleep_dir.glob("*-backup-*.db-wal")) + list(deep_sleep_dir.glob("*-backup-*.db-shm")):
+        base = Path(str(sidecar)[: -len("-wal")]) if str(sidecar).endswith("-wal") else Path(str(sidecar)[: -len("-shm")])
+        if not base.exists():
+            _record_delete(report, sidecar, reason="orphan-db-sidecar", apply=apply)
 
 
 def _prune_contexts(deep_sleep_dir: Path, report: dict, *, keep: int, apply: bool) -> None:

package/src/email_sent_events.py

@@ -8,6 +8,7 @@ sent even when the send path did not originate from an inbound email row.
 from __future__ import annotations
 
 import json
+import os
 import sqlite3
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -43,6 +44,12 @@ RECENT_SENT_EMAILS_TITLE = "EMAILS ENVIADOS ULTIMAS 24H POR LA OPERATIVA"
 
 
 def sent_email_db_path() -> Path:
+    # NEXO_EMAIL_DB lets tests (and the selective-forget live-DB enumerator)
+    # isolate / discover the email store deterministically without rewiring
+    # NEXO_HOME. Falls back to the canonical runtime location.
+    override = os.environ.get("NEXO_EMAIL_DB", "").strip()
+    if override:
+        return Path(override).expanduser()
     return paths.nexo_email_dir() / "nexo-email.db"
 
 

package/src/enforcement_engine.py

@@ -465,6 +465,7 @@ class HeadlessEnforcer:
         self.user_message_count = 0
         self.tool_timestamps: dict[str, float] = {}
         self.msg_since_tool: dict[str, int] = {}
+        self._tool_user_message_index: dict[str, int] = {}
         self.injection_queue: list[dict] = []
         self._started_at = time.time()
         self._injections_done = 0
@@ -551,6 +552,8 @@ class HeadlessEnforcer:
         # seen, periodic/conditional reminders stay suppressed so cron
         # runners can reach TURN_END instead of reopening the task loop.
         self._session_stopped: bool = False
+        self._first_visible_startup_gate_fired: bool = False
+        self._first_visible_text_allowed: bool = False
         try:
             self._post_close_cooldown_seconds = max(
                 0,
@@ -1036,6 +1039,52 @@ class HeadlessEnforcer:
         except Exception:
             pass
 
+    def should_block_first_visible_text(self) -> bool:
+        """Fail closed before the first visible answer when startup context is missing."""
+        if self._first_visible_text_allowed:
+            return False
+        if self.user_message_count <= 0:
+            self._first_visible_text_allowed = True
+            return False
+
+        current_turn = int(self.user_message_count or 0)
+        has_startup = "nexo_startup" in self.tools_called
+        continuity_tools = {
+            "nexo_smart_startup",
+            "nexo_session_diary_read",
+            "nexo_reminders",
+            "nexo_checkpoint_read",
+        }
+        has_continuity = bool(self.tools_called.intersection(continuity_tools))
+        heartbeat_turn = max(
+            self._tool_user_message_index.get("nexo_heartbeat", -1),
+            self._tool_user_message_index.get("nexo_task_open", -1),
+        )
+        has_turn_heartbeat = heartbeat_turn >= current_turn
+
+        missing = []
+        if not has_startup:
+            missing.append("nexo_startup")
+        if not has_continuity:
+            missing.append("continuidad minima")
+        if not has_turn_heartbeat:
+            missing.append("nexo_heartbeat")
+        if not missing:
+            self._first_visible_text_allowed = True
+            return False
+        if self._first_visible_startup_gate_fired:
+            return True
+
+        prompt = (
+            "Before any visible answer, register the session, load minimal continuity, "
+            "and associate the current user message with a heartbeat. Missing: "
+            f"{', '.join(missing)}. Execute the required NEXO tool calls now. "
+            "Do not produce visible text for this reminder."
+        )
+        self._enqueue(prompt, "first-visible-startup-heartbeat-gate", rule_id="R38_first_visible_startup_gate")
+        self._first_visible_startup_gate_fired = True
+        return True
+
     def _check_capability_denial_requires_reality(self, text: str):
         """Block unsupported capability denials until a live source was checked."""
         if not text or not _CAPABILITY_DENIAL_RE.search(text):
@@ -2537,6 +2586,7 @@ class HeadlessEnforcer:
         self.tools_called.add(name)
         self.tool_timestamps[name] = time.time()
         self.msg_since_tool[name] = 0
+        self._tool_user_message_index[name] = int(self.user_message_count or 0)
 
         # v7.6 conditional counter advance. Tools watched by a
         # conditional rule tick a counter on every non-matching call.
@@ -3346,6 +3396,14 @@ def run_with_enforcement(
             msg = event.get("message", {})
             for block in msg.get("content", []):
                 if block.get("type") == "text":
+                    try:
+                        if enforcer.should_block_first_visible_text():
+                            item = enforcer.flush()
+                            if item:
+                                _inject(item["prompt"])
+                            return False
+                    except Exception as _startup_gate_exc:  # noqa: BLE001
+                        _logger.warning("first visible startup gate failed: %s", _startup_gate_exc)
                     collected_text.append(block["text"])
                     # R16 — probe each assistant text block as it arrives
                     # so a declared-done line is caught on the same turn

package/src/hooks/post_tool_use.py

@@ -374,6 +374,118 @@ def _write_json(path: Path, payload: dict) -> None:
     tmp.replace(path)
 
 
+def _pending_trace_path(sid: str) -> Path:
+    safe_sid = "".join(ch if ch.isalnum() or ch in "-_" else "_" for ch in (sid or "unknown"))
+    return _production_closeout_dir() / f"post-change-trace-{safe_sid}.json"
+
+
+def _split_files(value: object) -> set[str]:
+    if value is None:
+        return set()
+    if isinstance(value, (list, tuple, set)):
+        raw = "\n".join(str(item) for item in value)
+    else:
+        raw = str(value)
+    parts = re.split(r"[\n,;]+", raw)
+    return {part.strip() for part in parts if part and part.strip()}
+
+
+def _record_post_change_trace(payload: dict, sid: str) -> None:
+    if not sid:
+        sid = "unknown"
+    path = _pending_trace_path(sid)
+    trace = _read_json(path) or {
+        "sid": sid,
+        "touched_files": [],
+        "guard_files": [],
+        "change_log_files": [],
+        "production_mutation": False,
+        "created_at": time.time(),
+    }
+    tool_name = _tool_name(payload)
+    tool_input = _tool_input(payload)
+    cmd = _extract_command(payload)
+
+    touched = set(trace.get("touched_files") or [])
+    guards = set(trace.get("guard_files") or [])
+    logged = set(trace.get("change_log_files") or [])
+
+    if _is_shared_mutation_payload(payload):
+        touched.update(_split_files(tool_input.get("file_path")))
+        touched.update(_split_files(tool_input.get("path")))
+        touched.update(_split_files(tool_input.get("files")))
+        touched.update(_split_files(tool_input.get("paths")))
+        if cmd:
+            trace["last_mutation_command"] = cmd[:500]
+            if _is_production_mutation_command(cmd):
+                trace["production_mutation"] = True
+
+    if tool_name in {"nexo_guard_check", "mcp__nexo__nexo_guard_check"}:
+        guards.update(_split_files(tool_input.get("files")))
+
+    if _is_change_log_tool(tool_name):
+        logged.update(_split_files(tool_input.get("files")))
+        logged.update(_split_files(tool_input.get("files_changed")))
+        if not logged and touched:
+            logged.update(touched)
+
+    if _is_task_close_tool(tool_name):
+        touched.update(_split_files(tool_input.get("files_changed")))
+
+    trace["touched_files"] = sorted(touched)
+    trace["guard_files"] = sorted(guards)
+    trace["change_log_files"] = sorted(logged)
+    trace["updated_at"] = time.time()
+
+    if touched or guards or logged or trace.get("production_mutation"):
+        _write_json(path, trace)
+
+
+def _missing_trace_items(payload: dict, sid: str) -> list[str]:
+    if not _is_task_close_tool(_tool_name(payload)):
+        return []
+    trace = _read_json(_pending_trace_path(sid or "unknown"))
+    if not trace:
+        return []
+    tool_input = _tool_input(payload)
+    touched = set(trace.get("touched_files") or [])
+    if not touched and not trace.get("production_mutation"):
+        return []
+    guards = set(trace.get("guard_files") or [])
+    logged = set(trace.get("change_log_files") or [])
+    closing_files = _split_files(tool_input.get("files_changed"))
+
+    missing = []
+    if touched and not guards:
+        missing.append("guardias ejecutados")
+    if trace.get("production_mutation") and not logged and not _task_close_payload_has_change_trace(payload):
+        missing.append("registro de cambios")
+    if touched and closing_files and not touched.issubset(closing_files):
+        missing.append("files_changed completo")
+    if touched and not closing_files:
+        missing.append("files_changed")
+    return missing
+
+
+def check_post_change_trace_closeout(payload: dict, sid: str) -> str | None:
+    if not sid:
+        sid = "unknown"
+    _record_post_change_trace(payload, sid)
+    missing = _missing_trace_items(payload, sid)
+    if not missing:
+        if _is_task_close_tool(_tool_name(payload)):
+            _pending_trace_path(sid).unlink(missing_ok=True)
+        return None
+    trace = _read_json(_pending_trace_path(sid))
+    files = ", ".join((trace.get("touched_files") or [])[:6]) or "cambio detectado"
+    message = (
+        "Cierre bloqueado: antes de marcar completado hay que cuadrar archivos tocados, "
+        f"guardias y registro de cambios. Falta: {', '.join(missing)}. "
+        f"Archivos detectados: {files}."
+    )
+    return append_operator_language_contract(message)
+
+
 def check_production_change_log_closeout(payload: dict, sid: str) -> str | None:
     if not sid:
         sid = "unknown"
@@ -551,6 +663,7 @@ def main() -> int:
         sid = _resolve_sid_from_payload(payload)
         reminder = check_inbox_and_emit_reminder(sid)
         change_log_message = check_production_change_log_closeout(payload, sid)
+        post_change_trace_message = check_post_change_trace_closeout(payload, sid)
         shared_scope_message = check_shared_scope_closeout(payload)
         g1_message: str | None = None
         try:
@@ -562,6 +675,7 @@ def main() -> int:
             protocol_message,
             reminder,
             change_log_message,
+            post_change_trace_message,
             shared_scope_message,
             g1_message,
         )