nexo-brain 7.34.0 → 7.35.0

package/src/scripts/nexo-daily-self-audit.py

@@ -2194,6 +2194,28 @@ def _run_protocol_debt_drain_inline() -> dict:
     }
 
 
+def _run_schema_abstraction_distill_inline() -> dict:
+    """Ola 4 — distill recurring incident archetypes into diagnostic templates.
+
+    Runs the clustering pass over the failure-prevention ledger (+ self-error
+    learnings) and mints/refreshes diagnostic templates idempotently. Guidance
+    only; never blocks. Best-effort: any failure is reported, not raised.
+    """
+    try:
+        import schema_abstraction as sa
+
+        report = sa.distill_templates()
+    except Exception as exc:
+        return {"ok": False, "error": f"distill_failed: {exc}"}
+    return {
+        "ok": bool(report.get("ok")),
+        "templates_created": int(report.get("templates_created") or 0),
+        "templates_refreshed": int(report.get("templates_refreshed") or 0),
+        "incidents": int(report.get("incidents") or 0),
+        "clusters": int(report.get("clusters") or 0),
+    }
+
+
 def _sanitize_watchdog_registry_inline() -> dict:
     hash_registry = _hash_registry_path()
     if not hash_registry.exists():
@@ -2329,6 +2351,24 @@ def run_mechanical_autofixes():
         elif debt_drain.get("error"):
             finding("WARN", "autofix", f"Protocol debt drain inline failed: {debt_drain['error']}")
 
+        # Ola 4 SCHEMA-ABSTRACTION: distill recurring-incident archetypes into
+        # reusable diagnostic templates (idempotent). Surfaces only when a new
+        # template is minted/refreshed; silence otherwise (anti-noise).
+        distill = _run_schema_abstraction_distill_inline()
+        if distill.get("ok"):
+            created = int(distill.get("templates_created") or 0)
+            refreshed = int(distill.get("templates_refreshed") or 0)
+            if created or refreshed:
+                finding(
+                    "INFO",
+                    "autofix",
+                    f"Schema-abstraction distilled diagnostic templates: "
+                    f"created={created}, refreshed={refreshed} "
+                    f"(from {int(distill.get('incidents') or 0)} incidents)",
+                )
+        elif distill.get("error"):
+            finding("WARN", "autofix", f"Schema-abstraction distill inline failed: {distill['error']}")
+
         if NEXO_DB.exists():
             conn = sqlite3.connect(str(NEXO_DB))
             conn.row_factory = sqlite3.Row

package/src/server.py

@@ -1843,6 +1843,60 @@ def nexo_memory_maintenance(
     return handle_memory_maintenance(process_limit, retry_failed, backfill_sources, backfill_limit)
 
 
+@mcp.tool
+def nexo_memory_forget(
+    value: str,
+    mode: str = "secret",
+    dry_run: bool = True,
+    confirm: bool = False,
+    use_regex: bool = False,
+    reason: str = "",
+) -> str:
+    """SELECTIVE-FORGET: verifiably erase a revoked secret, or correct a fact.
+
+    Two modes, never mixed:
+      * mode='secret' (HARD-FORGET): scrubs the secret from EVERY table of ALL
+        LIVE DBs the agent retrieves from — nexo, cognitive, local-context,
+        local-context-usage, and email — discovered by live introspection
+        (sqlite_master + PRAGMA) over each subsystem's own canonical path
+        resolver, not a curated list — plus every FTS index (incl.
+        local_chunks_fts), on-disk transcripts, and legacy shadow DBs (cognitive
+        + local-context). The row is DELETED where it IS the secret (or carries
+        an embedding/FTS copy), and REDACTED in place where the secret is
+        embedded in an otherwise-useful record (diary, item_history.note,
+        local_chunks.text, entity_facts.value, change_log...). It then
+        RE-ENUMERATES and RE-SCANS everything and only returns complete=True at
+        total zero; any survivor (even in a table not anticipated) is reported
+        as complete=False with its <db>.<table> location. Use ONLY for revoked
+        credentials/secrets or toxic data. Destructive run requires
+        dry_run=False AND confirm=True (a dry-run count is returned otherwise).
+        HNSW persisted indices are invalidated. SCOPE: point-in-time backups /
+        snapshots are NOT swept (retention) — rotate the secret; the report's
+        backup_scope field states this so complete=True never overclaims.
+      * mode='fact' (CORRECT-FACT): does NOT delete. Useful memory is preserved
+        via the existing reversible supersede; correct it with
+        nexo_learning_update / supersede instead.
+
+    Args:
+        value: the literal secret value to forget.
+        mode: 'secret' (default, hard) or 'fact' (soft, reversible).
+        dry_run: when True (default) only count matches; never mutate.
+        confirm: required (with dry_run=False) to actually delete in secret mode.
+        use_regex: also match generic secret-shaped tokens (secret mode only).
+        reason: free-text audit note recorded in the ledger.
+    """
+    import memory_forget
+
+    return memory_forget.handle_memory_forget(
+        value=value,
+        mode=mode,
+        dry_run=dry_run,
+        confirm=confirm,
+        use_regex=use_regex,
+        reason=reason,
+    )
+
+
 @mcp.tool
 def nexo_memory_search(
     query: str,

package/src/tools_credentials.py

@@ -320,13 +320,71 @@ def handle_credential_delete(service: str, key: str = '') -> str:
             return f"Credential deleted."
         return f"All BYOK credentials deleted ({removed} files)."
 
+    # Capture the secret value(s) BEFORE deletion so the forget sweep can scrub
+    # any grep-able copies that leaked into memory (FTS, KG, transcripts, etc.).
+    leaked_values: list[str] = []
+    try:
+        existing = get_credential(service, key if key else None) or []
+        for entry in existing:
+            val = str((entry or {}).get("value") or "").strip()
+            if len(val) >= 8:
+                leaked_values.append(val)
+    except Exception:
+        leaked_values = []
+
     deleted = delete_credential(service, key if key else None)
     if not deleted:
         target = f"{service}/{key}" if key else service
         return f"ERROR: No credentials found for '{target}'."
+
+    # Auto-trigger SELECTIVE-FORGET (hard, secret mode) over the revoked value(s)
+    # so revoking the credential leaves no leaked copies in memory. Best-effort:
+    # never let a sweep failure block the credential deletion.
+    forgotten = 0
+    swept = False
+    incomplete = False
+    residual_detail = ""
+    for val in leaked_values:
+        try:
+            import memory_forget
+
+            sweep = memory_forget.sweep_revoked_secret(val, reason=f"credential_deleted:{service}")
+            if sweep.get("destructive"):
+                swept = True
+                # Count BOTH deleted rows and redacted-in-place rows: a leaked
+                # copy embedded in a useful record is scrubbed via redaction, not
+                # deletion, so counting only deletions would under-report.
+                forgotten += int(sweep.get("deleted_total") or 0)
+                forgotten += int(sweep.get("redacted_total") or 0)
+                if not sweep.get("complete", True):
+                    incomplete = True
+                    verification = sweep.get("verification") or {}
+                    survivors = {
+                        **(verification.get("residual_stores") or {}),
+                        **(verification.get("residual_fts") or {}),
+                    }
+                    if verification.get("residual_shadows"):
+                        survivors["shadow_dbs"] = len(verification["residual_shadows"])
+                    if verification.get("residual_transcripts"):
+                        survivors["transcripts"] = len(verification["residual_transcripts"])
+                    if survivors and not residual_detail:
+                        residual_detail = ", ".join(f"{k}={v}" for k, v in survivors.items())
+        except Exception:
+            continue
+
+    suffix = ""
+    if swept:
+        suffix = f" Forget sweep removed {forgotten} leaked copy/copies from memory."
+        if incomplete:
+            suffix += (
+                " WARNING: forget sweep reported RESIDUAL matches — the secret is "
+                "STILL grep-able and was NOT fully removed. Verify manually"
+            )
+            suffix += f" ({residual_detail})." if residual_detail else "."
+
     if key:
-        return f"Credential deleted."
-    return f"All credentials for service deleted."
+        return f"Credential deleted.{suffix}"
+    return f"All credentials for service deleted.{suffix}"
 
 
 def handle_credential_list(service: str = '') -> str:

package/tool-enforcement-map.json

@@ -2052,6 +2052,72 @@
       },
       "triggers_after": []
     },
+    "nexo_schema_abstraction_distill": {
+      "description": "Distill recurring incident archetypes into reusable diagnostic templates (idempotent clustering pass)",
+      "category": "failure_prevention",
+      "source": "plugin:schema_abstraction",
+      "requires": [
+        "failure_prevention_cases"
+      ],
+      "provides": [
+        "diagnostic_templates"
+      ],
+      "internal_calls": [
+        "learning_resolver.candidate_similarity"
+      ],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
+    "nexo_schema_abstraction_templates": {
+      "description": "List distilled diagnostic templates",
+      "category": "failure_prevention",
+      "source": "plugin:schema_abstraction",
+      "requires": [
+        "diagnostic_templates"
+      ],
+      "provides": [],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
+    "nexo_schema_abstraction_match": {
+      "description": "Match an action against diagnostic-template archetypes (primed diagnosis)",
+      "category": "failure_prevention",
+      "source": "plugin:schema_abstraction",
+      "requires": [
+        "diagnostic_templates"
+      ],
+      "provides": [],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
+    "nexo_schema_abstraction_retire": {
+      "description": "Retire a diagnostic template (lifecycle, guidance-only)",
+      "category": "failure_prevention",
+      "source": "plugin:schema_abstraction",
+      "requires": [
+        "diagnostic_templates"
+      ],
+      "provides": [
+        "diagnostic_templates"
+      ],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
     "nexo_goal_engine_status": {
       "description": "Goal Engine telemetry readiness",
       "category": "goal",