nexo-brain 7.33.0 → 7.34.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.33.0",
+  "version": "7.34.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.33.0` is the current packaged-runtime line. Minor release - Cognitive OS Ola 1 (phase 2): memory search now finds by MEANING (observation embeddings + FTS/vector fusion), the KG/causal graph is read at answer time (kg_neighbors pre-answer source), local files are recalled via FTS5, nightly learning consolidation no longer times out, correction capture is reliable (soft), and the followup runner uses an atomic lock. Builds on v7.32.0 (causal-graph populate + workflow reaper + the 7.31.14 critical fixes).
+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).
 
 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.33.0",
+  "version": "7.34.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/__init__.py

@@ -168,7 +168,7 @@ from db._entities import (
 # Episodic memory
 from db._episodic import (
     cleanup_old_changes, change_log_retention_days, change_log_retention_policy,
-    log_change, search_changes, update_change_commit, auto_resolve_followups,
+    log_change, search_changes, get_change_watermark, update_change_commit, auto_resolve_followups,
     cleanup_old_decisions, log_decision, update_decision_outcome,
     get_memory_review_queue, find_decisions_by_context_ref, search_decisions,
     cleanup_old_diaries, write_session_diary,
@@ -197,6 +197,7 @@ from db._protocol import (
     VALID_TASK_TYPES,
     VALID_CLOSE_OUTCOMES,
     create_protocol_task, get_protocol_task, close_protocol_task,
+    list_recent_closed_tasks,
     set_protocol_task_guard_acknowledged,
     create_protocol_debt, resolve_protocol_debts, list_protocol_debts,
     record_session_correction_requirement, list_session_correction_requirements,

package/src/db/_episodic.py

@@ -93,6 +93,38 @@ def search_changes(query: str = '', files: str = '', days: int = 30) -> list[dic
     return [dict(r) for r in rows]
 
 
+def get_change_watermark(sid: str | None = None) -> int:
+    """Cheap monotonic integer that rises whenever a relevant mutation lands.
+
+    Used by the resolution cache (working memory) as the "nothing changed"
+    invalidation signal — Francisco's third rule. ``change_log`` is the ledger
+    where the PostToolUse hook records every code/config/state mutation, so
+    ``MAX(id)`` is a one-SELECT, monotonic, append-only proxy for "did anything
+    change since I cached this answer?". If the watermark advanced, the cache
+    is invalidated by conservatism (prefer recomputing over serving stale).
+
+    ``sid`` optionally narrows the watermark to a single session's mutations.
+    Returns 0 when the ledger is empty or unavailable (which a fresh cache
+    entry will also store, so an empty ledger never spuriously invalidates).
+    """
+    try:
+        conn = get_db()
+        if sid:
+            row = conn.execute(
+                "SELECT MAX(id) FROM change_log WHERE session_id = ?", (str(sid),)
+            ).fetchone()
+        else:
+            row = conn.execute("SELECT MAX(id) FROM change_log").fetchone()
+    except Exception:
+        return 0
+    if not row or row[0] is None:
+        return 0
+    try:
+        return int(row[0])
+    except (TypeError, ValueError):
+        return 0
+
+
 def auto_resolve_followups(change: dict) -> list[str]:
     """Cross-reference a change_log entry with open followups. Auto-completes matches.
 

package/src/db/_protocol.py

@@ -436,6 +436,41 @@ def close_protocol_task(
     return get_protocol_task(task_id) or {}
 
 
+def list_recent_closed_tasks(
+    *,
+    outcome: str = "done",
+    exclude_task_id: str = "",
+    limit: int = 200,
+    within_days: int = 0,
+) -> list[dict]:
+    """Return recently CLOSED protocol tasks for self-error detection.
+
+    Read-only. Ordered most-recent-first by ``closed_at``. The self-error
+    detector compares the just-closed task against these prior closures to
+    spot a later action that corrects something a previous task already
+    claimed as ``done``. Kept deliberately narrow (status filter + small
+    limit) so it never scans the whole history on every close.
+    """
+    conn = get_db()
+    clauses = ["status = ?", "closed_at IS NOT NULL"]
+    params: list[object] = [str(outcome).strip() or "done"]
+    if exclude_task_id:
+        clauses.append("task_id != ?")
+        params.append(exclude_task_id.strip())
+    if within_days and within_days > 0:
+        clauses.append("closed_at >= datetime('now', ?)")
+        params.append(f"-{int(within_days)} days")
+    where = " AND ".join(clauses)
+    rows = conn.execute(
+        f"""SELECT * FROM protocol_tasks
+            WHERE {where}
+            ORDER BY closed_at DESC
+            LIMIT ?""",
+        (*params, max(1, int(limit))),
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
 def create_protocol_debt(
     session_id: str,
     debt_type: str,

package/src/db/_schema.py

@@ -3213,6 +3213,108 @@ def _m83_observation_embeddings(conn):
     conn.commit()
 
 
+def _m85_eval_runs(conn):
+    """Time series for the memory eval bench (recall@k / MRR / semantic gain).
+
+    One row per (run, metric) so the table is queryable as a series: the
+    before/after delta of an Ola 1 change is just two rows for the same metric
+    with different ``ola1_enabled``. ``model_warm`` distinguishes numbers from
+    the real embedding model (1) vs the deterministic offline fallback (0), so
+    a CI run (fallback, pipeline check) is never confused with a Deep Sleep run
+    (real model, semantic quality). Append-only and additive — re-running the
+    harness inserts new rows, never mutates old ones.
+
+    Mirrors the existing _m28_automation_runs / _m34_cortex_evaluations shape.
+    """
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS eval_runs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            suite TEXT NOT NULL DEFAULT '',
+            case_set_id TEXT DEFAULT '',
+            case_set_version TEXT DEFAULT '',
+            fixture_hash TEXT DEFAULT '',
+            metric TEXT NOT NULL DEFAULT '',
+            value REAL NOT NULL DEFAULT 0.0,
+            ola1_enabled INTEGER NOT NULL DEFAULT 1,
+            model_warm INTEGER NOT NULL DEFAULT 0,
+            created_at TEXT DEFAULT (datetime('now'))
+        )
+        """
+    )
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_eval_runs_suite ON eval_runs(suite)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_eval_runs_metric ON eval_runs(suite, metric)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_eval_runs_created ON eval_runs(created_at)")
+    conn.commit()
+
+
+def _m86_resolution_cache(conn):
+    """Working-memory / resolution cache for the pre-answer router and repo maps.
+
+    Non-authoritative, like semantic_layers (_m76): the canonical facts still
+    live in diary/workflows/tasks/evidence/memory/learnings/change_log and in
+    the git repos themselves. This table only caches the FINAL organized
+    result of a retrieval (a ``PreAnswerRoute.to_dict()`` for ``kind='route'``)
+    or a lightweight repo snapshot (``kind='repo_map'``), keyed by a
+    deterministic ``cache_key`` (route_cache_key | ``repo:{project_key}``).
+
+    The anti-stale contract (Francisco's rule of gold) lives in the read path
+    (``resolution_cache.is_valid``): a HIT is only valid when ALL hold —
+    (1) now() < expires_at, (2) status=='fresh',
+    (3) source_fingerprint recomputed == stored, (4) change_watermark global ==
+    stored. The columns below exist to support exactly that check. The
+    ``instant`` tier (ttl=0) never writes here.
+    """
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS resolution_cache (
+            cache_key          TEXT PRIMARY KEY,
+            kind               TEXT NOT NULL DEFAULT 'route',
+            intent             TEXT NOT NULL DEFAULT '',
+            area               TEXT NOT NULL DEFAULT '',
+            sid                TEXT NOT NULL DEFAULT '',
+            result_json        TEXT NOT NULL,
+            source_fingerprint TEXT NOT NULL,
+            source_refs_json   TEXT NOT NULL DEFAULT '[]',
+            change_watermark   INTEGER NOT NULL DEFAULT 0,
+            status             TEXT NOT NULL DEFAULT 'fresh',
+            policy_version     TEXT NOT NULL DEFAULT '',
+            resolved_at        REAL NOT NULL,
+            expires_at         REAL NOT NULL DEFAULT 0,
+            hit_count          INTEGER NOT NULL DEFAULT 0,
+            CHECK(kind IN ('route', 'repo_map')),
+            CHECK(status IN ('fresh', 'stale', 'expired', 'invalid'))
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_resolution_cache_status_exp", "resolution_cache", "status, expires_at")
+    _migrate_add_index(conn, "idx_resolution_cache_kind", "resolution_cache", "kind, sid")
+    _migrate_add_index(conn, "idx_resolution_cache_fingerprint", "resolution_cache", "source_fingerprint")
+    conn.commit()
+
+
+def _m87_resolution_cache_content_snapshot(conn):
+    """Per-row content snapshot for the resolution cache's anti-stale check.
+
+    The fingerprint (``source_fingerprint``) is a single opaque digest over the
+    versions of the consulted refs. It proved the AGGREGATE changed but could
+    not by itself say WHICH ref moved, and — more importantly — it relied on
+    ``semantic_layers.source_version_for`` keyed by CANONICAL prefixes
+    (``followup:``), while the pre-answer router emits its own SOURCE-NAME refs
+    (``followups:``). Those source-name refs resolved to an ``unsupported``
+    namespace → empty version → an inert fingerprint, so a followup completed by
+    a plain UPDATE (no change_log write → watermark unmoved) was served stale.
+
+    This column stores an explicit ``{ref: version}`` map captured from the REAL
+    rows at write time (``resolution_cache.row_version_snapshot``). On read we
+    re-read those same rows by id and compare — the snapshot is now the PRIMARY
+    freshness guarantee; TTL and the global watermark remain cheap fast-fails.
+    Idempotent, append-only ALTER (non-destructive).
+    """
+    _migrate_add_column(conn, "resolution_cache", "content_snapshot_json", "TEXT NOT NULL DEFAULT '{}'")
+    conn.commit()
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -3297,6 +3399,9 @@ MIGRATIONS = [
     (81, "core_rules_product_metadata", _m81_core_rules_product_metadata),
     (82, "confidence_checks", _m82_confidence_checks),
     (83, "observation_embeddings", _m83_observation_embeddings),
+    (85, "eval_runs", _m85_eval_runs),
+    (86, "resolution_cache", _m86_resolution_cache),
+    (87, "resolution_cache_content_snapshot", _m87_resolution_cache_content_snapshot),
 ]
 
 

package/src/local_context/usage_events.py

@@ -352,6 +352,7 @@ def record_router_usage(
     elapsed_ms: int | None = None,
     deadline_ms: int | None = None,
     used_before_response: bool = True,
+    cache_hit: bool = False,
     db_path: str | os.PathLike[str] | None = None,
 ) -> dict[str, Any]:
     evidence_refs = router_payload.get("evidence_refs") or []
@@ -374,6 +375,7 @@ def record_router_usage(
         "escalated_from": router_payload.get("escalated_from") or budget_policy.get("escalated_from") or "",
         "escalated_to": router_payload.get("escalated_to") or budget_policy.get("escalated_to") or "",
         "route_cache_key": budget_policy.get("route_cache_key") or "",
+        "cache_hit": bool(cache_hit or router_payload.get("cache_hit")),
         "max_sources": budget_policy.get("max_sources") or 0,
         "max_source_timeout_ms": budget_policy.get("max_source_timeout_ms") or 0,
         "allowed_sources": budget_policy.get("allowed_sources") or [],

package/src/message_batch_preview.py

@@ -0,0 +1,290 @@
+"""Build safe HTML previews before real WhatsApp/email batch sends.
+
+This module is intentionally send-agnostic: it reads code/log/queue artifacts,
+separates internal or test messages from deliverable candidates, renders a
+sanitized HTML review document, and enforces a hard cap on real sends.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+from email_presentation import compose_html_document, text_to_html_fragment
+from tools_email_guard import should_block_email_send
+
+
+DEFAULT_REAL_SEND_LIMIT = 10
+INTERNAL_MARKERS = (
+    "[internal]",
+    "internal:",
+    "nexo_internal",
+    "solo interno",
+    "nota interna",
+    "mensaje interno",
+    "test:",
+    "[test]",
+    "dry-run",
+    "dry_run",
+    "prueba",
+)
+TEST_RECIPIENT_PATTERNS = (
+    re.compile(r"(^|@)(example|test|localhost)(\.|$)", re.I),
+    re.compile(r"\+test\b", re.I),
+    re.compile(r"^(?:0+|123456789|600000000)$"),
+)
+
+
+@dataclass(frozen=True)
+class PreviewMessage:
+    source: str
+    channel: str
+    recipient: str
+    body: str
+    subject: str = ""
+    metadata: dict[str, Any] | None = None
+
+    @property
+    def fingerprint(self) -> str:
+        base = "\x1f".join([
+            self.channel.strip().lower(),
+            self.recipient.strip().lower(),
+            self.subject.strip(),
+            " ".join(self.body.split()),
+        ])
+        return str(abs(hash(base)))
+
+
+@dataclass(frozen=True)
+class PreviewResult:
+    deliverable: list[PreviewMessage]
+    internal_or_test: list[PreviewMessage]
+    blocked: list[dict[str, str]]
+    real_send_limit: int
+
+    @property
+    def capped_deliverable(self) -> list[PreviewMessage]:
+        return self.deliverable[: self.real_send_limit]
+
+    @property
+    def over_limit_count(self) -> int:
+        return max(0, len(self.deliverable) - self.real_send_limit)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "deliverable_count": len(self.deliverable),
+            "capped_deliverable_count": len(self.capped_deliverable),
+            "internal_or_test_count": len(self.internal_or_test),
+            "blocked_count": len(self.blocked),
+            "real_send_limit": self.real_send_limit,
+            "over_limit_count": self.over_limit_count,
+            "deliverable": [_message_to_dict(m) for m in self.capped_deliverable],
+            "internal_or_test": [_message_to_dict(m) for m in self.internal_or_test],
+            "blocked": self.blocked,
+        }
+
+
+def _message_to_dict(message: PreviewMessage) -> dict[str, Any]:
+    return {
+        "source": message.source,
+        "channel": message.channel,
+        "recipient": message.recipient,
+        "subject": message.subject,
+        "body": message.body,
+        "metadata": message.metadata or {},
+        "fingerprint": message.fingerprint,
+    }
+
+
+def read_messages(paths: Iterable[Path | str]) -> list[PreviewMessage]:
+    messages: list[PreviewMessage] = []
+    for raw_path in paths:
+        path = Path(raw_path)
+        if not path.exists() or not path.is_file():
+            raise FileNotFoundError(str(path))
+        text = path.read_text(encoding="utf-8", errors="replace")
+        messages.extend(_parse_artifact(path, text))
+    return messages
+
+
+def _parse_artifact(path: Path, text: str) -> list[PreviewMessage]:
+    stripped = text.strip()
+    if not stripped:
+        return []
+    if path.suffix.lower() == ".jsonl":
+        rows = [json.loads(line) for line in stripped.splitlines() if line.strip()]
+        return [_row_to_message(row, path, index) for index, row in enumerate(rows, start=1)]
+    if path.suffix.lower() == ".json":
+        payload = json.loads(stripped)
+        if isinstance(payload, list):
+            rows = payload
+        elif isinstance(payload, dict):
+            rows = payload.get("messages") or payload.get("items") or payload.get("queue") or [payload]
+        else:
+            rows = []
+        return [_row_to_message(row, path, index) for index, row in enumerate(rows, start=1) if isinstance(row, dict)]
+    return [PreviewMessage(source=str(path), channel="log", recipient="", body=stripped)]
+
+
+def _row_to_message(row: dict[str, Any], path: Path, index: int) -> PreviewMessage:
+    recipient = str(
+        row.get("recipient")
+        or row.get("to")
+        or row.get("phone")
+        or row.get("email")
+        or ""
+    ).strip()
+    body = str(
+        row.get("body")
+        or row.get("message")
+        or row.get("text")
+        or row.get("html")
+        or ""
+    ).strip()
+    channel = str(row.get("channel") or row.get("type") or _infer_channel(recipient)).strip().lower()
+    subject = str(row.get("subject") or "").strip()
+    return PreviewMessage(
+        source=f"{path}:{index}",
+        channel=channel or "unknown",
+        recipient=recipient,
+        subject=subject,
+        body=body,
+        metadata={k: v for k, v in row.items() if k not in {"body", "message", "text", "html"}},
+    )
+
+
+def _infer_channel(recipient: str) -> str:
+    if "@" in recipient:
+        return "email"
+    if recipient:
+        return "whatsapp"
+    return "unknown"
+
+
+def is_internal_or_test(message: PreviewMessage) -> bool:
+    haystack = " ".join([
+        message.channel,
+        message.recipient,
+        message.subject,
+        message.body,
+        json.dumps(message.metadata or {}, ensure_ascii=False, sort_keys=True),
+    ]).lower()
+    if any(marker in haystack for marker in INTERNAL_MARKERS):
+        return True
+    recipient = message.recipient.strip()
+    return any(pattern.search(recipient) for pattern in TEST_RECIPIENT_PATTERNS)
+
+
+def build_preview(messages: Iterable[PreviewMessage], *, real_send_limit: int = DEFAULT_REAL_SEND_LIMIT) -> PreviewResult:
+    if real_send_limit < 1:
+        raise ValueError("real_send_limit must be >= 1")
+    deliverable: list[PreviewMessage] = []
+    internal_or_test: list[PreviewMessage] = []
+    blocked: list[dict[str, str]] = []
+    seen: set[str] = set()
+
+    for message in messages:
+        if is_internal_or_test(message):
+            internal_or_test.append(message)
+            continue
+        blocked_by_secret, reason = should_block_email_send(
+            "\n".join([message.subject, message.body, json.dumps(message.metadata or {}, ensure_ascii=False)])
+        )
+        if blocked_by_secret:
+            blocked.append({"source": message.source, "recipient": message.recipient, "reason": reason})
+            continue
+        if message.fingerprint in seen:
+            blocked.append({"source": message.source, "recipient": message.recipient, "reason": "duplicate message"})
+            continue
+        seen.add(message.fingerprint)
+        deliverable.append(message)
+
+    return PreviewResult(
+        deliverable=deliverable,
+        internal_or_test=internal_or_test,
+        blocked=blocked,
+        real_send_limit=real_send_limit,
+    )
+
+
+def render_preview_html(result: PreviewResult) -> str:
+    parts = [
+        "<h1>Previsualización de lote</h1>",
+        "<table><tbody>",
+        f"<tr><th>Enviables</th><td>{len(result.deliverable)}</td></tr>",
+        f"<tr><th>Incluidos por límite</th><td>{len(result.capped_deliverable)}</td></tr>",
+        f"<tr><th>Internos/tests separados</th><td>{len(result.internal_or_test)}</td></tr>",
+        f"<tr><th>Bloqueados</th><td>{len(result.blocked)}</td></tr>",
+        f"<tr><th>Exceso de lote</th><td>{result.over_limit_count}</td></tr>",
+        "</tbody></table>",
+        "<h2>Candidatos a envío real</h2>",
+        _render_message_list(result.capped_deliverable),
+        "<h2>Separados: internos/tests</h2>",
+        _render_message_list(result.internal_or_test),
+        "<h2>Bloqueados</h2>",
+        _render_blocked(result.blocked),
+    ]
+    return compose_html_document("".join(parts))
+
+
+def _render_message_list(messages: list[PreviewMessage]) -> str:
+    if not messages:
+        return "<p>Ninguno.</p>"
+    rows = []
+    for message in messages:
+        body = text_to_html_fragment(message.body[:1200])
+        rows.append(
+            "<tr>"
+            f"<td>{text_to_html_fragment(message.channel)}</td>"
+            f"<td>{text_to_html_fragment(message.recipient or '(sin destinatario)')}</td>"
+            f"<td>{text_to_html_fragment(message.subject or message.source)}</td>"
+            f"<td>{body}</td>"
+            "</tr>"
+        )
+    return "<table><thead><tr><th>Canal</th><th>Destino</th><th>Asunto/fuente</th><th>Mensaje</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
+
+
+def _render_blocked(blocked: list[dict[str, str]]) -> str:
+    if not blocked:
+        return "<p>Ninguno.</p>"
+    rows = [
+        "<tr>"
+        f"<td>{text_to_html_fragment(item.get('source', ''))}</td>"
+        f"<td>{text_to_html_fragment(item.get('recipient', ''))}</td>"
+        f"<td>{text_to_html_fragment(item.get('reason', ''))}</td>"
+        "</tr>"
+        for item in blocked
+    ]
+    return "<table><thead><tr><th>Fuente</th><th>Destino</th><th>Motivo</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Generate a safe HTML preview for WhatsApp/email batch candidates.")
+    parser.add_argument("paths", nargs="+", help="JSON, JSONL, log, or text artifacts to inspect.")
+    parser.add_argument("--limit", type=int, default=DEFAULT_REAL_SEND_LIMIT, help="Maximum real sends allowed in one batch.")
+    parser.add_argument("--html-out", required=True, help="Destination HTML preview file.")
+    parser.add_argument("--json-out", default="", help="Optional JSON summary destination.")
+    args = parser.parse_args(argv)
+
+    result = build_preview(read_messages(args.paths), real_send_limit=args.limit)
+    Path(args.html_out).write_text(render_preview_html(result), encoding="utf-8")
+    if args.json_out:
+        Path(args.json_out).write_text(json.dumps(result.to_dict(), indent=2, ensure_ascii=False), encoding="utf-8")
+    print(json.dumps({
+        "html_out": args.html_out,
+        "json_out": args.json_out,
+        "deliverable": len(result.deliverable),
+        "capped_deliverable": len(result.capped_deliverable),
+        "internal_or_test": len(result.internal_or_test),
+        "blocked": len(result.blocked),
+        "over_limit": result.over_limit_count,
+    }, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())