nexo-brain 7.32.0 → 7.34.0

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())

package/src/plugins/protocol.py

@@ -157,7 +157,10 @@ def _requires_external_real_world_check(task: dict, *parts: str) -> bool:
     if str(task.get("task_type") or "").strip() not in ACTION_TASKS:
         return False
     text = _external_real_world_text(task, *parts)
-    return any(keyword in text for keyword in EXTERNAL_REAL_WORLD_ACTION_KEYWORDS)
+    return any(
+        _contains_external_action_keyword(text, keyword)
+        for keyword in EXTERNAL_REAL_WORLD_ACTION_KEYWORDS
+    )
 
 
 def _has_external_real_world_evidence(text: str) -> bool:
@@ -169,6 +172,18 @@ def _has_external_real_world_evidence(text: str) -> bool:
     return has_verify_verb and has_artifact
 
 
+def _contains_external_action_keyword(text: str, keyword: str) -> bool:
+    clean_text = str(text or "").lower()
+    clean_keyword = str(keyword or "").lower().strip()
+    if not clean_text or not clean_keyword:
+        return False
+    return re.search(
+        rf"(?<![a-z0-9]){re.escape(clean_keyword)}(?![a-z0-9])",
+        clean_text,
+        re.IGNORECASE,
+    ) is not None
+
+
 ACTION_TASKS = {"edit", "execute", "delegate"}
 RESPONSE_TASKS = {"answer", "analyze"}
 _GUARD_TOUCH_DEBT_TYPES = {
@@ -1146,13 +1161,16 @@ def _capture_learning(
     content: str,
     reasoning: str,
     priority: str = "high",
+    prevention: str = "",
+    applies_to_override: str = "",
+    source_authority: str = "explicit_instruction",
 ) -> dict:
     from tools_learnings import find_conflicting_active_learning, handle_learning_add
 
     clean_title = (title or "").strip()[:120]
     clean_content = (content or "").strip()
     clean_reasoning = (reasoning or f"Captured from protocol task {task_id}").strip()
-    applies_to = ",".join(effective_files)
+    applies_to = applies_to_override.strip() if applies_to_override.strip() else ",".join(effective_files)
     if not clean_title or not clean_content:
         return {"ok": False, "error": "insufficient context for learning capture"}
 
@@ -1168,9 +1186,11 @@ def _capture_learning(
         title=clean_title,
         content=clean_content,
         reasoning=clean_reasoning,
+        prevention=prevention,
         applies_to=applies_to,
         priority=priority,
         supersedes_id=supersedes_id,
+        source_authority=source_authority,
     )
     match = re.search(r"Learning #(\d+) added", response)
     if match:
@@ -1180,6 +1200,20 @@ def _capture_learning(
             "response": response,
             "superseded_id": supersedes_id or None,
         }
+    # A near/exact duplicate is a SUCCESSFUL no-op merge — the learning already
+    # exists and no duplicate row was created (handle_learning_add returns
+    # "already exists" / "resolved as merge"). Treat it as success so idempotent
+    # re-captures (e.g. the same self-detected error twice) do not report a
+    # phantom learning_ok=False in the close-response telemetry.
+    dedup = re.search(r"Learning #(\d+) (?:already exists|resolved as merge)", response)
+    if dedup:
+        return {
+            "ok": True,
+            "deduped": True,
+            "id": int(dedup.group(1)),
+            "response": response,
+            "superseded_id": supersedes_id or None,
+        }
     return {
         "ok": False,
         "error": response,
@@ -1217,6 +1251,136 @@ def _auto_capture_learning(task: dict, task_id: str, effective_files: list[str],
     )
 
 
+# ── Forgotten-step followup detector (objective omission markers) ──────
+_FORGOTTEN_STEP_FOLLOWUP_RE = re.compile(
+    r"\b(?:forgot|forgotten|missed|omitted|never (?:created|added|set up|configured|deployed|ran)|"
+    r"missing (?:the )?(?:cron|step|trigger|hook|migration|index|webhook|deploy)|"
+    r"olvid[éeè]|me olvid[éeè]|falt[óoa]ba?|no se (?:cre[óo]|configur[óo]|despleg[óo]|registr[óo]))\b",
+    re.IGNORECASE,
+)
+
+
+def _followup_signals_forgotten_step(*descriptions: object) -> bool:
+    """True only when a followup description objectively states an omission.
+
+    A generic 'verify weekly' or 'monitor X' followup must NOT count — only an
+    explicit 'forgot/missing/never created the cron' style description does.
+    """
+    for desc in descriptions:
+        text = str(desc or "").strip()
+        if text and _FORGOTTEN_STEP_FOLLOWUP_RE.search(text):
+            return True
+    return False
+
+
+def _detect_and_capture_self_error(
+    task: dict,
+    task_id: str,
+    *,
+    clean_outcome: str,
+    closure_text: str,
+    correction: bool,
+    effective_files: list[str],
+    forgotten_step_followup: bool,
+    debts_created: list[dict],
+) -> dict | None:
+    """Ola 2 — auto-detect that a PRIOR own action was wrong and learn from it.
+
+    Runs AFTER the current task is closed. Compares it against recently
+    closed-as-done tasks; on high-confidence objective evidence it creates a
+    learning with a concrete prevention rule (source_authority=code_test_evidence,
+    NOT a Francisco correction). On low confidence it records a low-confidence
+    candidate as an INFO protocol_debt — never a learning. Best-effort: any
+    failure returns None and never blocks the close.
+
+    Returns a small dict describing what happened (for the close response), or
+    None when nothing was detected / on error.
+    """
+    try:
+        import self_error_detector as sed
+        from db import list_recent_closed_tasks
+
+        # Only closes that actually claim progress can host / reveal a self-error.
+        if clean_outcome not in {"done", "partial"}:
+            return None
+
+        prior_tasks = list_recent_closed_tasks(
+            outcome="done",
+            exclude_task_id=task_id,
+            within_days=sed.LOOKBACK_DAYS,
+            limit=sed.MAX_PRIOR_TASKS,
+        )
+        if not prior_tasks:
+            # Nothing previously declared done → cannot have a revealed self-error
+            # from file overlap. A forgotten-step followup alone is candidate-only.
+            if not forgotten_step_followup:
+                return None
+
+        evaluation = sed.evaluate_self_error(
+            current_task=task,
+            prior_tasks=prior_tasks,
+            closure_text=closure_text,
+            correction_happened=correction,
+            forgotten_step_followup=forgotten_step_followup,
+        )
+
+        decision = evaluation.get("decision")
+        if decision == "none":
+            return None
+
+        if decision == "candidate":
+            # Low-confidence: record a quiet INFO candidate, NEVER a learning.
+            # Reuses the existing open-debt dedup so the same candidate does not
+            # pile up across repeated closes of the same task.
+            debt = _ensure_open_debt(
+                task.get("session_id", ""),
+                task_id,
+                "self_error_candidate",
+                severity="info",
+                evidence=(
+                    f"Low-confidence self-error candidate (confidence="
+                    f"{evaluation.get('confidence')}, signal={evaluation.get('signal')}). "
+                    f"{'; '.join(evaluation.get('reasons') or [])[:400]}"
+                ),
+                debts=debts_created,
+            )
+            return {
+                "decision": "candidate",
+                "confidence": evaluation.get("confidence"),
+                "signal": evaluation.get("signal"),
+                "debt_id": debt.get("id"),
+            }
+
+        # decision == "fire": create the learning with a concrete prevention.
+        payload = sed.build_self_error_learning(current_task=task, evaluation=evaluation)
+        learning = _capture_learning(
+            task,
+            task_id,
+            effective_files,
+            category=payload["category"],
+            title=payload["title"],
+            content=payload["content"],
+            reasoning=payload["reasoning"],
+            priority="high",
+            prevention=payload["prevention"],
+            applies_to_override=payload["applies_to"],
+            source_authority=payload["source_authority"],
+        )
+        return {
+            "decision": "fire",
+            "confidence": evaluation.get("confidence"),
+            "signal": evaluation.get("signal"),
+            "prior_task_id": evaluation.get("prior_task_id"),
+            "overlap_files": evaluation.get("overlap_files"),
+            "learning_ok": bool(learning.get("ok")),
+            "learning_id": learning.get("id"),
+            "learning_error": None if learning.get("ok") else learning.get("error"),
+        }
+    except Exception:
+        # Self-error detection is strictly best-effort; never break a close.
+        return None
+
+
 def _append_debt_ref(debts: list[dict], debt: dict, *, debt_type: str, severity: str):
     debt_id = debt.get("id")
     if debt_id and any(item.get("id") == debt_id for item in debts):
@@ -2170,31 +2334,30 @@ def handle_task_close(
         limit=3,
     )
     if pending_corrections:
-        debt = _ensure_open_debt(
-            task["session_id"],
-            task_id,
-            "missing_learning_after_correction",
-            severity="error",
-            evidence=(
-                "User correction was detected for this session and has not "
-                "been resolved by nexo_learning_add. task_close is blocked "
-                "until a durable learning is persisted."
-            ),
-            debts=debts_created,
-        )
-        return json.dumps(
-            {
-                "ok": False,
-                "error": "Cannot close task while a detected user correction has no durable nexo_learning_add.",
-                "hint": "Call nexo_learning_add with the reusable rule learned from the correction, then retry nexo_task_close.",
-                "task_id": task_id,
-                "blocked_by": "d5_correction_learning_required",
-                "debt_id": debt.get("id"),
-                "pending_corrections": len(pending_corrections),
-            },
-            ensure_ascii=False,
-            indent=2,
+        # SOFT enforcement (Ola 1): do NOT block the close. A detected user
+        # correction without a durable nexo_learning_add opens/dedupes an
+        # error-severity protocol_debt and the task still closes. The daily
+        # self-audit + correction_requirement_summary surface the open debt, and
+        # if THIS close supplies the learning, the `if correction:` block below
+        # captures it and resolves both the requirement and the debt. A hard
+        # block here interrupted the operator on every correction (friction);
+        # the debt is the non-blocking signal instead.
+        learning_in_this_close = bool(
+            (learning_title or "").strip() and (learning_content or "").strip()
         )
+        if not learning_in_this_close:
+            _ensure_open_debt(
+                task["session_id"],
+                task_id,
+                "missing_learning_after_correction",
+                severity="error",
+                evidence=(
+                    "User correction detected for this session without a durable "
+                    "nexo_learning_add; debt opened (soft enforcement) — task closed "
+                    "but a follow-up learning is required."
+                ),
+                debts=debts_created,
+            )
 
     # ── Evidence enforcement: reject 'done' without proof ──
     # G1 hardening: "done" is no longer allowed to degrade into a debt-only
@@ -2643,6 +2806,25 @@ def handle_task_close(
         followup_id=created_followup_id,
         outcome_notes=outcome_notes,
     )
+
+    # ── Ola 2: auto-detect a PRIOR own action that this close reveals as
+    # wrong (e.g. code shipped earlier but the cron was never created). On
+    # high-confidence objective evidence, capture an immediate learning +
+    # prevention rule (source_authority=code_test_evidence, not a Francisco
+    # correction); on low confidence, only a quiet INFO candidate. Strictly
+    # best-effort — runs after the task is already persisted-closed.
+    self_error = _detect_and_capture_self_error(
+        task,
+        task_id,
+        clean_outcome=clean_outcome,
+        closure_text=closure_text,
+        correction=correction,
+        effective_files=effective_files,
+        forgotten_step_followup=_followup_signals_forgotten_step(
+            followup_description, outcome_notes
+        ),
+        debts_created=debts_created,
+    )
     capture_context_event(
         event_type=f"protocol_task_{clean_outcome}",
         title=(task.get("goal") or task_id)[:160],
@@ -2724,10 +2906,17 @@ def handle_task_close(
         pass  # Drive detection is best-effort
 
     open_debts = list_protocol_debts(status="open", task_id=task_id, limit=20)
+    # The self-error CANDIDATE debt is an informational, non-actionable signal
+    # (low confidence; recorded for audit/dedup, never a learning). It must not
+    # flip an otherwise-clean close into "done_with_debts" — that would be the
+    # exact kind of noise/debt Francisco rejects.
+    status_debts = [
+        debt for debt in open_debts if debt.get("debt_type") != "self_error_candidate"
+    ]
 
     status = "clean"
     next_action = "Task closed cleanly."
-    if open_debts:
+    if status_debts:
         if clean_outcome == "done":
             status = "done_with_debts"
             next_action = "Task closed as done, but resolve the open protocol debt next."
@@ -2779,6 +2968,8 @@ def handle_task_close(
         "memory_event": memory_event,
         "memory_event_ok": bool(memory_event and memory_event.get("ok")),
     }
+    if self_error:
+        response["self_error"] = self_error
     if durable_checkpoint:
         response["durable_checkpoint"] = durable_checkpoint
     return json.dumps(response, ensure_ascii=False, indent=2)