nexo-brain 7.37.4 → 7.38.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.37.4",
+  "version": "7.38.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,9 +18,9 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.37.4` is the current packaged-runtime line. Patch release over v7.37.3 - product-gap reporting, stale briefing noise, and opportunity loops: Deep Sleep reports recurring NEXO product gaps through sanitized Desktop support tickets, self-audit preserves closed internal opportunities, the morning briefing reads item history before resurfacing decisions, and support-ticket tools match the live backend contract.
+Version `7.38.0` is the current packaged-runtime line. Minor release over v7.37.4 - closeout integrity and operator-facing discipline: proactive status on long opaque work, per-item verified state on batch closeouts, decision-readable first responses, an automatic production change ledger across a wider mutation surface, new closure/evidence/cost-secret audit modules, and a correction-learning gate that never blocks mid-work. New behavioral rules ship in shadow/log mode by default.
 
-Previously in `7.37.3`: patch release over v7.37.2 - release pipeline timeout hardening: the Brain publish workflow keeps the full pre-publish pytest gate, but now gives slow GitHub runners enough time to finish the suite and release readiness before public-channel publication.
+Previously in `7.37.4`: patch release over v7.37.3 - product-gap reporting, stale briefing noise, and opportunity loops: Deep Sleep reports recurring NEXO product gaps through sanitized Desktop support tickets, self-audit preserves closed internal opportunities, the morning briefing reads item history before resurfacing decisions, and support-ticket tools match the live backend contract.
 
 Previously in `7.37.2`: patch release over v7.37.1 - runtime shutdown and CI stability: session keepalive writers now stop before the shared SQLite connection closes, SQLite close is serialized under the write lock, and the full Brain test workflow has enough time to finish instead of cancelling slow-but-valid runs. The v7.37.2 tag attempt did not publish npm/GitHub release artifacts; v7.37.3 is the public line.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.37.4",
+  "version": "7.38.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/closure_promise_audit.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+"""Retrospective closure audit for uncaptured promises and corrections."""
+
+import re
+from dataclasses import asdict, dataclass
+from typing import Callable, Iterable, Literal
+
+
+SignalKind = Literal["promise", "correction"]
+CaptureCheck = Callable[[str], bool]
+
+_PROMISE_PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(r"\b(?:lo\s+dejo\s+registrad[oa]|queda\s+registrad[oa])\b", re.I),
+    re.compile(r"\b(?:luego|manana|ma[nñ]ana|cuando\s+cierre|al\s+cerrar)\b", re.I),
+    re.compile(r"\b(?:te\s+aviso|lo\s+retomo|queda\s+pendiente)\b", re.I),
+    re.compile(r"\b(?:I(?:'ll| will)\s+(?:record|follow up|do|check)|later|tomorrow)\b", re.I),
+)
+
+_CORRECTION_PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(r"\b(?:no[, ]+|eso\s+no|te\s+equivocas|est[aá]\s+mal)\b", re.I),
+    re.compile(r"\b(?:corrige|correcci[oó]n|no\s+es\s+eso|as[ií]\s+no)\b", re.I),
+    re.compile(r"\b(?:wrong|incorrect|that'?s\s+not|you\s+missed)\b", re.I),
+)
+
+
+@dataclass(frozen=True)
+class ClosureSignal:
+    kind: SignalKind
+    text: str
+    matched: str
+    persisted: bool
+    debt: bool
+    recommended_action: str
+    reason: str
+
+
+@dataclass(frozen=True)
+class ClosureAudit:
+    ok: bool
+    debt_count: int
+    signals: list[ClosureSignal]
+
+    def to_dict(self) -> dict:
+        return {
+            "ok": self.ok,
+            "debt_count": self.debt_count,
+            "signals": [asdict(signal) for signal in self.signals],
+        }
+
+
+def audit_closure(
+    assistant_text: str,
+    user_text: str = "",
+    *,
+    has_followup_for: CaptureCheck | None = None,
+    has_learning_for: CaptureCheck | None = None,
+    brain_down: bool = False,
+) -> ClosureAudit:
+    """Find promises/corrections that were not persisted before closure.
+
+    The audit is fail-closed: if persistence cannot be checked, the signal is
+    surfaced as explicit debt instead of being silently ignored.
+    """
+
+    signals: list[ClosureSignal] = []
+    for text, patterns, kind in (
+        (assistant_text, _PROMISE_PATTERNS, "promise"),
+        (user_text, _CORRECTION_PATTERNS, "correction"),
+    ):
+        for matched in _matches(text, patterns):
+            signals.append(
+                _evaluate_signal(
+                    kind=kind,
+                    text=text,
+                    matched=matched,
+                    checker=has_followup_for if kind == "promise" else has_learning_for,
+                    brain_down=brain_down,
+                )
+            )
+
+    debt_count = sum(1 for signal in signals if signal.debt)
+    return ClosureAudit(ok=debt_count == 0, debt_count=debt_count, signals=signals)
+
+
+def _matches(text: str, patterns: Iterable[re.Pattern[str]]) -> list[str]:
+    clean = text or ""
+    found: list[str] = []
+    seen: set[str] = set()
+    for pattern in patterns:
+        for match in pattern.finditer(clean):
+            value = match.group(0).strip()
+            key = value.lower()
+            if key not in seen:
+                seen.add(key)
+                found.append(value)
+    return found
+
+
+def _evaluate_signal(
+    *,
+    kind: SignalKind,
+    text: str,
+    matched: str,
+    checker: CaptureCheck | None,
+    brain_down: bool,
+) -> ClosureSignal:
+    action = "create_followup" if kind == "promise" else "create_learning"
+    if brain_down:
+        return ClosureSignal(kind, text, matched, False, True, "mark_debt", "brain_down")
+    if checker is None:
+        return ClosureSignal(kind, text, matched, False, True, action, "missing_capture_check")
+    try:
+        persisted = bool(checker(text))
+    except Exception as exc:  # pragma: no cover - reason asserted without type coupling
+        return ClosureSignal(
+            kind,
+            text,
+            matched,
+            False,
+            True,
+            action,
+            f"capture_check_failed:{type(exc).__name__}",
+        )
+    return ClosureSignal(
+        kind,
+        text,
+        matched,
+        persisted,
+        not persisted,
+        "none" if persisted else action,
+        "captured" if persisted else "not_captured",
+    )
+

package/src/cost_secret_sweep.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+"""Daily cost/secret sweep queue builder."""
+
+import glob
+import json
+import os
+import re
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Iterable
+
+try:
+    from evidence_ledger import _SECRET_PATTERNS
+except Exception:  # pragma: no cover
+    _SECRET_PATTERNS = (
+        re.compile(r"(token\s*[=:]\s*)[^\s'\"]{8,}", re.I),
+        re.compile(r"(password\s*[=:]\s*)[^\s'\"]{6,}", re.I),
+        re.compile(r"(api[_-]?key\s*[=:]\s*)[^\s'\"]{8,}", re.I),
+    )
+
+
+_CATEGORY_RULES: tuple[tuple[str, re.Pattern[str], int, int, str], ...] = (
+    ("billing_exhausted", re.compile(r"\b(billing|saldo|quota|cuota).{0,40}\b(agot|exhaust|insufficient|sin saldo)", re.I), 3, 1, "revisar billing y recarga"),
+    ("pasted_key", re.compile(r"\b(sk-[A-Za-z0-9_-]{20,}|gh[pousr]_[A-Za-z0-9_]{20,}|AIza[A-Za-z0-9_-]{30,})\b"), 2, 3, "rotar clave pegada y mover a gestor"),
+    ("bridge_token", re.compile(r"\b(bridge|mcp|internal).{0,30}\b(token|api[_-]?key)\b", re.I), 2, 2, "rotar token puente y revisar scope"),
+    ("env_secret", re.compile(r"\b(env|\.env|log|stdout|trace).{0,30}\b(token|password|secret|api[_-]?key)\b", re.I), 2, 3, "mover secreto fuera de env/logs expuestos"),
+    ("rotation_pending", re.compile(r"(?=.*\b(rotar|rotation|comprometid|expuest|leak|public)\b)(?=.*\b(token|clave|secret|password|credencial|credential|api[_-]?key)\b)", re.I | re.S), 2, 2, "cerrar rotacion con evidencia"),
+)
+
+
+@dataclass(frozen=True)
+class SweepItem:
+    category: str
+    source: str
+    summary: str
+    economic_impact: int
+    exposure: int
+    priority: int
+    recommendation: str
+
+
+def build_sweep_queue(records: Iterable[dict]) -> list[SweepItem]:
+    """Return one prioritized queue sorted by economic impact x exposure."""
+
+    items: list[SweepItem] = []
+    for record in records:
+        text = str(record.get("text") or record.get("summary") or "")
+        source = str(record.get("source") or "unknown")
+        for category, pattern, economic, exposure, recommendation in _CATEGORY_RULES:
+            if not pattern.search(text):
+                continue
+            item = SweepItem(
+                category=category,
+                source=source,
+                summary=redact_secrets(text)[:500],
+                economic_impact=int(record.get("economic_impact") or economic),
+                exposure=int(record.get("exposure") or exposure),
+                priority=int(record.get("economic_impact") or economic) * int(record.get("exposure") or exposure),
+                recommendation=recommendation,
+            )
+            items.append(item)
+            break
+    return sorted(items, key=lambda item: (-item.priority, item.category, item.source))
+
+
+def collect_text_sources(paths: Iterable[str]) -> list[dict]:
+    records: list[dict] = []
+    for pattern in paths:
+        for filename in glob.glob(pattern):
+            path = Path(filename)
+            if not path.is_file():
+                continue
+            try:
+                text = path.read_text(errors="replace")
+            except OSError:
+                continue
+            records.append({"source": str(path), "text": text[:20000]})
+    return records
+
+
+def run_sweep(*, records: Iterable[dict] = (), paths: Iterable[str] = ()) -> dict:
+    all_records = list(records)
+    all_records.extend(collect_text_sources(paths))
+    queue = build_sweep_queue(all_records)
+    return {
+        "generated_at": int(time.time()),
+        "count": len(queue),
+        "queue": [asdict(item) for item in queue],
+    }
+
+
+def default_paths(nexo_home: str | None = None) -> list[str]:
+    home = Path(nexo_home or os.environ.get("NEXO_HOME") or "~/.nexo").expanduser()
+    return [
+        str(home / "runtime" / "logs" / "*.log"),
+        str(home / "runtime" / "operations" / "*.jsonl"),
+        str(home / ".env"),
+    ]
+
+
+def append_jsonl_report(report: dict, output_path: str) -> None:
+    path = Path(output_path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write(json.dumps(report, ensure_ascii=False, sort_keys=True) + "\n")
+
+
+def redact_secrets(text: str) -> str:
+    redacted = str(text or "")
+    for pattern in _SECRET_PATTERNS:
+        redacted = pattern.sub(_redact_match, redacted)
+    return redacted
+
+
+def _redact_match(match: re.Match[str]) -> str:
+    if match.lastindex:
+        return f"{match.group(1)}[REDACTED]"
+    return "[REDACTED]"

package/src/email_credentials.py

@@ -16,6 +16,7 @@ from urllib.parse import quote, unquote
 
 KEYRING_SERVICE = "com.nexo.email"
 KEYRING_MARKER_PREFIX = "keyring://"
+HEADLESS_FALLBACK_SERVICE_SUFFIX = "::headless-fallback"
 
 
 def _db():
@@ -42,6 +43,10 @@ def _account_name(service: str, key: str) -> str:
     return f"{service}:{key}"
 
 
+def _headless_fallback_ref(service: str, key: str) -> tuple[str, str]:
+    return f"{service}{HEADLESS_FALLBACK_SERVICE_SUFFIX}", key
+
+
 def _keyring_module():
     try:
         return importlib.import_module("keyring")
@@ -78,6 +83,32 @@ def _write_db_value(service: str, key: str, value: str, notes: str) -> None:
     conn.commit()
 
 
+def _delete_db_value(service: str, key: str) -> None:
+    conn = _db()
+    conn.execute("DELETE FROM credentials WHERE service = ? AND key = ?", (service, key))
+    conn.commit()
+
+
+def _write_headless_fallback(service: str, key: str, value: str, notes: str) -> None:
+    fallback_service, fallback_key = _headless_fallback_ref(service, key)
+    _write_db_value(
+        fallback_service,
+        fallback_key,
+        value,
+        notes + " (headless fallback mirror)",
+    )
+
+
+def _read_headless_fallback(service: str, key: str) -> str:
+    fallback_service, fallback_key = _headless_fallback_ref(service, key)
+    return _read_stored_value(fallback_service, fallback_key)
+
+
+def _delete_headless_fallback(service: str, key: str) -> None:
+    fallback_service, fallback_key = _headless_fallback_ref(service, key)
+    _delete_db_value(fallback_service, fallback_key)
+
+
 def store_email_credential(service: str, key: str, value: str, notes: str = "email account password") -> str:
     """Store an email password and return the SQLite value written.
 
@@ -96,6 +127,7 @@ def store_email_credential(service: str, key: str, value: str, notes: str = "ema
     if keyring is not None:
         try:
             keyring.set_password(KEYRING_SERVICE, _account_name(service, key), value)
+            _write_headless_fallback(service, key, value, notes)
             stored = _marker(service, key)
             _write_db_value(service, key, stored, notes + " (stored in system keyring)")
             return stored
@@ -118,12 +150,13 @@ def read_email_credential(service: str, key: str) -> str:
 
     keyring = _keyring_module()
     if keyring is None:
-        return ""
+        return _read_headless_fallback(*parsed)
     try:
         value = keyring.get_password(KEYRING_SERVICE, _account_name(*parsed))
     except Exception:
-        return ""
-    return str(value or "")
+        value = ""
+    value = str(value or "")
+    return value or _read_headless_fallback(*parsed)
 
 
 def delete_email_credential(service: str, key: str) -> None:
@@ -140,9 +173,8 @@ def delete_email_credential(service: str, key: str) -> None:
         except Exception:
             pass
 
-    conn = _db()
-    conn.execute("DELETE FROM credentials WHERE service = ? AND key = ?", (service, key))
-    conn.commit()
+    _delete_db_value(service, key)
+    _delete_headless_fallback(service, key)
 
 
 def is_keyring_marker(value: str) -> bool:

package/src/enforcement_engine.py

@@ -31,12 +31,16 @@ except ImportError:  # pragma: no cover  — fallback for editable installs with
 try:
     from r14_correction_learning import (
         detect_correction as _detect_correction,
+        detect_accepted_correction as _detect_accepted_correction,
         INJECTION_PROMPT_TEMPLATE as _R14_PROMPT,
+        ACCEPTANCE_INJECTION_PROMPT_TEMPLATE as _R14_ACCEPTANCE_PROMPT,
         DEFAULT_WINDOW_TOOL_CALLS as _R14_WINDOW,
     )
 except ImportError:  # pragma: no cover
     _detect_correction = None  # type: ignore
+    _detect_accepted_correction = None  # type: ignore
     _R14_PROMPT = ""  # type: ignore
+    _R14_ACCEPTANCE_PROMPT = ""  # type: ignore
     _R14_WINDOW = 3
 
 try:
@@ -981,7 +985,78 @@ class HeadlessEnforcer:
         self._r14_correction_seen_for_turn = False
         self._r14_correction_text = ""
 
-    def on_assistant_text(self, text: str, *, declared_detector=None, has_open_task=None):
+    def _learning_add_seen_for_current_turn(self) -> bool:
+        current_turn = int(self.user_message_count or 0)
+        return any(
+            self._tool_user_message_index.get(tool, -1) >= current_turn
+            for tool in ("nexo_learning_add",)
+        )
+
+    def _record_missing_learning_after_accepted_correction(self) -> None:
+        if not self._session_id:
+            return
+        try:
+            from db import create_protocol_debt, list_protocol_debts, record_session_correction_requirement  # type: ignore
+
+            record_session_correction_requirement(
+                self._session_id,
+                self._r14_correction_text,
+                source="r14_accepted_correction_gate",
+            )
+            existing = list_protocol_debts(
+                status="open",
+                session_id=self._session_id,
+                debt_type="missing_learning_after_correction",
+                limit=1,
+            )
+            if not existing:
+                create_protocol_debt(
+                    self._session_id,
+                    "missing_learning_after_correction",
+                    severity="error",
+                    evidence=(
+                        "R14 detected that the assistant accepted a user correction "
+                        "before nexo_learning_add was called."
+                    ),
+                )
+        except Exception:
+            pass
+
+    def _check_r14_accepted_correction(self, text: str, *, accepted_detector=None) -> None:
+        if not self._r14_correction_seen_for_turn:
+            return
+        if self._learning_add_seen_for_current_turn():
+            return
+        detector = accepted_detector if accepted_detector is not None else _detect_accepted_correction
+        if detector is None:
+            return
+        mode = self._guardian_rule_mode("R14_correction_learning")
+        if mode == "off":
+            return
+        try:
+            accepted = bool(
+                detector(
+                    text or "",
+                    correction_text=self._r14_correction_text,
+                )
+            )
+        except Exception as exc:  # noqa: BLE001
+            _logger.warning("R14 accepted-correction detector failed (%s); staying silent", exc)
+            accepted = False
+        if not accepted:
+            return
+        if mode == "shadow":
+            _logger.info("[R14 SHADOW] would block accepted correction without learning_add")
+            return
+        self._enqueue(
+            _R14_ACCEPTANCE_PROMPT,
+            "r14:accepted-correction-without-learning",
+            rule_id="R14_correction_learning",
+        )
+        self._record_missing_learning_after_accepted_correction()
+        _logger.info("[R14 %s] enqueued accepted-correction learning gate", mode.upper())
+
+    def on_assistant_text(self, text: str, *, declared_detector=None, has_open_task=None, accepted_correction_detector=None):
         """R16 — scan assistant message for done-claim with open protocol_task.
 
         Args:
@@ -1005,6 +1080,10 @@ class HeadlessEnforcer:
             self._check_jargon_text(text, tag="r26:first-response-jargon")
         self._check_execute_before_ask(text)
         self._check_capability_denial_requires_reality(text)
+        self._check_r14_accepted_correction(
+            text,
+            accepted_detector=accepted_correction_detector,
+        )
         if _detect_declared_done is None:
             return
         mode = self._guardian_rule_mode("R16_declared_done")
@@ -1362,6 +1441,7 @@ class HeadlessEnforcer:
             r"\bgcloud\s+builds\s+(?:submit|triggers\s+run)\b",
             r"\bgcloud\s+run\s+(?:deploy|services\s+update|jobs\s+deploy|jobs\s+update)\b",
             r"\bgcloud\s+dns\s+record-sets\s+transaction\s+execute\b",
+            r"\b(?:alembic\s+upgrade|prisma\s+migrate\s+deploy|sequelize\s+db:migrate|knex\s+migrate:latest|rails\s+db:migrate|python(?:3)?\s+manage\.py\s+migrate|php\s+artisan\s+migrate)\b",
             r"\b(?:whmapi1|uapi|cpapi2)\b",
             r"\b(?:cloudflare|cfcli)\b.*\b(?:dns|record)\b.*\b(?:create|delete|update|patch|put|post)\b",
             r"\bcurl\b(?=.*api\.cloudflare\.com/client/v4/zones/.*/dns_records)(?=.*(?:-X|--request)\s*(?:POST|PUT|PATCH|DELETE)\b)",

package/src/evidence_matrix.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+"""Require live evidence before root-cause claims in sensitive domains."""
+
+import re
+from dataclasses import dataclass
+from typing import Any, Callable, Iterable, Literal
+
+try:  # Reuse the existing ledger when available, but keep tests injectable.
+    from evidence_ledger import search_evidence as _ledger_search
+except Exception:  # pragma: no cover
+    _ledger_search = None
+
+
+Verdict = Literal["pass", "needs_evidence", "not_applicable"]
+SearchFn = Callable[[str], Iterable[Any]]
+
+_DOMAIN_PATTERNS: dict[str, tuple[re.Pattern[str], ...]] = {
+    "provider": (re.compile(r"\b(provider|proveedor|cloudflare|openai|shopify|stripe|google)\b", re.I),),
+    "quota": (re.compile(r"\b(quota|cuota|limit|limite|l[ií]mite|billing agotado)\b", re.I),),
+    "payment": (re.compile(r"\b(payment|pago|billing|facturaci[oó]n|tarjeta|stripe)\b", re.I),),
+    "token": (re.compile(r"\b(token|api[_ -]?key|clave|secret|secreto|credential|credencial)\b", re.I),),
+    "firewall": (re.compile(r"\b(firewall|csf|waf|iptables|cloud armor|bloque[oó])\b", re.I),),
+    "production": (re.compile(r"\b(prod|producci[oó]n|live|deploy|cloud run|server|servidor)\b", re.I),),
+    "customer_impact": (re.compile(r"\b(cliente|customer|venta|pedido|impacto|ca[ií]da|503|5xx)\b", re.I),),
+}
+
+_CAUSE_PATTERN = re.compile(
+    r"\b(causa|root cause|porque|por\s+que|se debe a|caused by|culpa|fall[oó]\s+por|bloqueado por)\b",
+    re.I,
+)
+_HEDGED_PATTERN = re.compile(
+    r"\b(podr[ií]a|parece|posible|hip[oó]tesis|hay que verificar|no confirmado|maybe|might|could)\b|\?$",
+    re.I,
+)
+
+
+@dataclass(frozen=True)
+class EvidenceMatrixResult:
+    verdict: Verdict
+    domains: list[str]
+    evidence_count: int
+    reason: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "verdict": self.verdict,
+            "domains": self.domains,
+            "evidence_count": self.evidence_count,
+            "reason": self.reason,
+        }
+
+
+def validate_claim(
+    text: str,
+    *,
+    evidence_refs: Iterable[Any] | None = None,
+    search: SearchFn | None = None,
+) -> EvidenceMatrixResult:
+    """Validate a sensitive causal claim against live evidence pointers."""
+
+    claim = text or ""
+    domains = _domains_for(claim)
+    if not domains or not _CAUSE_PATTERN.search(claim) or _HEDGED_PATTERN.search(claim):
+        return EvidenceMatrixResult("not_applicable", domains, 0, "non_causal_or_hedged")
+
+    refs = [ref for ref in (evidence_refs or []) if ref]
+    if refs:
+        return EvidenceMatrixResult("pass", domains, len(refs), "explicit_evidence_refs")
+
+    search_fn = search or _ledger_search
+    if search_fn is not None:
+        try:
+            hits = list(search_fn(claim) or [])
+        except Exception:
+            hits = []
+        if hits:
+            return EvidenceMatrixResult("pass", domains, len(hits), "ledger_evidence")
+
+    return EvidenceMatrixResult(
+        "needs_evidence",
+        domains,
+        0,
+        "cita un log, query, endpoint, commit o reproduccion antes de afirmar causa raiz",
+    )
+
+
+def _domains_for(text: str) -> list[str]:
+    return [
+        domain
+        for domain, patterns in _DOMAIN_PATTERNS.items()
+        if any(pattern.search(text or "") for pattern in patterns)
+    ]
+