superlocalmemory 3.8.13 → 4.0.0

package/src/superlocalmemory/encoding/scene_builder.py

@@ -24,6 +24,7 @@ logger = logging.getLogger(__name__)
 
 # Similarity threshold for assigning fact to existing scene
 _ASSIGN_THRESHOLD = 0.6
+_MAX_ASSIGNMENT_CANDIDATES = 256
 
 
 class SceneBuilder:
@@ -35,9 +36,10 @@ class SceneBuilder:
     3. If below threshold: create new scene
     """
 
-    def __init__(self, db, embedder=None) -> None:
+    def __init__(self, db, embedder=None, vector_store=None) -> None:
         self._db = db
         self._embedder = embedder
+        self._vector_store = vector_store
         # Key by scene ID, never theme. Themes are deliberately non-unique,
         # while eligibility and durable anchor membership are scene-specific.
         self._scene_embeddings_cache: dict[str, list[float]] = {}
@@ -71,11 +73,14 @@ class SceneBuilder:
         if fact_emb is None:
             return self._create_scene(new_fact, profile_id)
 
-        scenes = self._get_scenes(profile_id)
+        scenes = self._get_assignment_scenes(profile_id, fact_emb)
         if not scenes:
             return self._create_scene(new_fact, profile_id)
 
-        live_scene_embeddings = self._load_live_scene_embeddings(profile_id)
+        live_scene_embeddings = self._load_live_scene_embeddings(
+            profile_id,
+            tuple(scene.scene_id for scene in scenes),
+        )
         live_scene_ids = set(live_scene_embeddings)
         self._scene_embeddings_cache.update({
             scene_id: embedding
@@ -209,41 +214,138 @@ class SceneBuilder:
         )
         return [self._row_to_scene(dict(r)) for r in rows]
 
+    def _get_assignment_scenes(
+        self,
+        profile_id: str,
+        fact_embedding: list[float],
+    ) -> list[MemoryScene]:
+        """Load bounded semantic candidates with a recency fallback.
+
+        Mature stores must not compare every new fact with every historical
+        scene. The fact vector index finds nearby members in bounded time; the
+        normalized membership projection maps them back to scenes. Recent
+        scenes remain a fail-soft fallback for fresh or unavailable indexes.
+        Semantic candidates are ordered first so an old relevant scene cannot
+        be displaced by the recency cap.
+        """
+        recent_rows = self._db.execute(
+            "SELECT ms.* FROM memory_scenes AS ms WHERE ms.profile_id = ? "
+            "AND EXISTS (SELECT 1 FROM scene_fact_members AS live_member "
+            "WHERE live_member.scene_id = ms.scene_id "
+            "AND live_member.profile_id = ms.profile_id) "
+            "ORDER BY ms.last_updated DESC LIMIT ?",
+            (profile_id, _MAX_ASSIGNMENT_CANDIDATES),
+        )
+        recent = [self._row_to_scene(dict(row)) for row in recent_rows]
+
+        nearest_fact_ids: list[str] = []
+        if self._vector_store is not None:
+            try:
+                nearest_fact_ids = [
+                    fact_id
+                    for fact_id, _score in self._vector_store.search(
+                        fact_embedding,
+                        top_k=_MAX_ASSIGNMENT_CANDIDATES,
+                        profile_id=profile_id,
+                    )
+                ]
+            except Exception:
+                nearest_fact_ids = []
+
+        semantic: list[MemoryScene] = []
+        if nearest_fact_ids:
+            placeholders = ",".join("?" for _ in nearest_fact_ids)
+            try:
+                semantic_rows = self._db.execute(
+                    f"""
+                    SELECT ms.*, member.fact_id AS matched_fact_id
+                    FROM scene_fact_members AS member
+                    JOIN memory_scenes AS ms
+                      ON ms.scene_id = member.scene_id
+                     AND ms.profile_id = member.profile_id
+                    WHERE member.profile_id = ?
+                      AND member.fact_id IN ({placeholders})
+                    """,
+                    (profile_id, *nearest_fact_ids),
+                )
+                hit_rank = {
+                    fact_id: rank
+                    for rank, fact_id in enumerate(nearest_fact_ids)
+                }
+                ranked_scenes: dict[str, tuple[int, MemoryScene]] = {}
+                for row in semantic_rows:
+                    data = dict(row)
+                    rank = hit_rank.get(
+                        str(data.pop("matched_fact_id", "")),
+                        len(hit_rank),
+                    )
+                    scene = self._row_to_scene(data)
+                    previous = ranked_scenes.get(scene.scene_id)
+                    if previous is None or rank < previous[0]:
+                        ranked_scenes[scene.scene_id] = (rank, scene)
+                semantic = [
+                    scene
+                    for _rank, scene in sorted(
+                        ranked_scenes.values(), key=lambda item: item[0]
+                    )
+                ]
+            except Exception:
+                # Migration failure or a disabled vector projection must not
+                # make remember fail. The bounded recent set remains valid.
+                semantic = []
+
+        candidates: list[MemoryScene] = []
+        seen: set[str] = set()
+        for scene in (*semantic, *recent):
+            if scene.scene_id in seen:
+                continue
+            seen.add(scene.scene_id)
+            candidates.append(scene)
+            if len(candidates) >= _MAX_ASSIGNMENT_CANDIDATES:
+                break
+        return candidates
+
     def _load_live_scene_embeddings(
         self,
         profile_id: str,
+        scene_ids: tuple[str, ...],
     ) -> dict[str, list[float] | None]:
         """Load one durable anchor embedding for every live scene.
 
-        ``json_each`` resolves the first still-existing fact in each scene, so
-        scenes whose original anchor was consolidated away can still reuse a
-        surviving member. The result also identifies fully stale scene rows,
-        which are ignored by assignment instead of being re-embedded.
+        The normalized membership projection resolves the first still-existing
+        fact in each scene without expanding every scene's JSON array. Scenes
+        whose original anchor was consolidated away can still reuse a surviving
+        member. Fully stale scene rows are ignored instead of being re-embedded.
         """
+        if not scene_ids:
+            return {}
+        placeholders = ",".join("?" for _ in scene_ids)
         try:
             rows = self._db.execute(
-                """
+                f"""
                 WITH live_scene_facts AS (
                     SELECT
                         ms.scene_id,
-                        ms.theme,
                         af.embedding,
                         ROW_NUMBER() OVER (
                             PARTITION BY ms.scene_id
-                            ORDER BY CAST(member.key AS INTEGER)
+                            ORDER BY member.position
                         ) AS member_rank
                     FROM memory_scenes AS ms
-                    JOIN json_each(ms.fact_ids_json) AS member
+                    JOIN scene_fact_members AS member
+                      ON member.scene_id = ms.scene_id
+                     AND member.profile_id = ms.profile_id
                     JOIN atomic_facts AS af
-                      ON af.fact_id = member.value
+                      ON af.fact_id = member.fact_id
                      AND af.profile_id = ms.profile_id
                     WHERE ms.profile_id = ?
+                      AND ms.scene_id IN ({placeholders})
                 )
                 SELECT scene_id, embedding
                 FROM live_scene_facts
                 WHERE member_rank = 1
                 """,
-                (profile_id,),
+                (profile_id, *scene_ids),
             )
         except Exception:
             return {}

package/src/superlocalmemory/encoding/temporal_parser.py

@@ -173,6 +173,10 @@ class TemporalParser:
             return None
         try:
             dt = dateutil_parse(raw_date, fuzzy=True)
+            # Normalize any explicit offset to UTC so stored session dates are
+            # comparable without mixing offsets, keeping the explicit +00:00.
+            if dt.tzinfo is not None:
+                return dt.astimezone(UTC).isoformat()
             return _safe_iso(dt)
         except (ParserError, ValueError, OverflowError):
             logger.debug("Could not parse session_date: %r", raw_date)

package/src/superlocalmemory/evolution/blind_verifier.py

@@ -98,14 +98,21 @@ def parse_verification_response(response: str) -> VerificationResult:
         except (json.JSONDecodeError, TypeError, ValueError):
             pass
 
-    # Fallback: keyword detection
+    # Fallback: keyword detection.
+    # Negative keywords are checked first so that negating phrases such as
+    # "cannot approve" or "not approved" are never mistakenly matched by the
+    # positive keyword "approve".
     lower = response.lower()
+    if any(kw in lower for kw in (
+        "\"passed\": false", "passed: false",
+        "reject", "fail",
+        "cannot approve", "not approve",
+    )):
+        return VerificationResult(passed=False, confidence=0.6, reasoning="keyword match")
+
     if any(kw in lower for kw in ("\"passed\": true", "passed: true", "approve", "looks good")):
         return VerificationResult(passed=True, confidence=0.6, reasoning="keyword match")
 
-    if any(kw in lower for kw in ("\"passed\": false", "passed: false", "reject", "fail")):
-        return VerificationResult(passed=False, confidence=0.6, reasoning="keyword match")
-
     # Default: reject if can't parse (conservative)
     return VerificationResult(
         passed=False,

package/src/superlocalmemory/evolution/evolution_store.py

@@ -12,9 +12,11 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
+import hashlib
 import json
 import logging
 import sqlite3
+import warnings
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
@@ -61,6 +63,44 @@ CREATE TABLE IF NOT EXISTS evolution_cycle_state (
     updated_at TEXT,
     PRIMARY KEY (profile_id, key)
 );
+
+-- Phase 2: append-only status-transition log (LLD Decision B2).
+-- Each state change for a record produces one new row here.
+-- The BEFORE UPDATE trigger enforces immutability at the DB layer.
+CREATE TABLE IF NOT EXISTS skill_evolution_transitions (
+    seq             INTEGER PRIMARY KEY AUTOINCREMENT,
+    record_id       TEXT NOT NULL,
+    profile_id      TEXT NOT NULL DEFAULT 'default',
+    from_status     TEXT NOT NULL,
+    to_status       TEXT NOT NULL,
+    transitioned_at TEXT NOT NULL,
+    actor_id        TEXT DEFAULT '',
+    reason          TEXT DEFAULT '',
+    prev_hash       TEXT DEFAULT '',
+    transition_hash TEXT NOT NULL,
+    metadata        TEXT DEFAULT '{}'
+);
+
+CREATE INDEX IF NOT EXISTS idx_evo_trans_record
+    ON skill_evolution_transitions(record_id, seq);
+
+CREATE INDEX IF NOT EXISTS idx_evo_trans_profile
+    ON skill_evolution_transitions(profile_id, transitioned_at);
+
+-- DB-enforced append-only: any UPDATE on this table is a bug (LLD Decision B2).
+CREATE TRIGGER IF NOT EXISTS no_update_evo_transitions
+BEFORE UPDATE ON skill_evolution_transitions
+BEGIN
+    SELECT RAISE(ABORT, 'skill_evolution_transitions is append-only');
+END;
+
+-- Audit P1-3: DELETE must also be forbidden — otherwise the hash chain can be
+-- silently truncated/erased without a DB abort, breaking the immutable-log claim.
+CREATE TRIGGER IF NOT EXISTS no_delete_evo_transitions
+BEFORE DELETE ON skill_evolution_transitions
+BEGIN
+    SELECT RAISE(ABORT, 'skill_evolution_transitions is append-only');
+END;
 """
 
 # Anti-loop budget
@@ -223,11 +263,194 @@ class EvolutionStore:
         for k in recovered:
             del self._addressed_degradations[k]
 
+    # ------------------------------------------------------------------
+    # Phase 2: append-only transition log
+    # ------------------------------------------------------------------
+
+    def insert_record(self, record: EvolutionRecord, profile_id: str) -> None:
+        """INSERT a new evolution record (CANDIDATE status).
+
+        Unlike save_record, this uses plain INSERT — NOT INSERT OR REPLACE.
+        Raises sqlite3.IntegrityError if a row with the same id already exists.
+        Call this exactly once per candidate (CRIT-1: never reuse record_id).
+        """
+        conn = sqlite3.connect(self._db_path, timeout=10)
+        try:
+            conn.execute(
+                "INSERT INTO skill_evolution_log "
+                "(id, profile_id, skill_name, parent_skill_id, evolution_type, "
+                " trigger_type, generation, status, mutation_summary, evidence, "
+                " original_content, evolved_content, content_diff, "
+                " blind_verified, rejection_reason, created_at, completed_at) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (
+                    record.id,
+                    profile_id,
+                    record.skill_name,
+                    record.parent_skill_id,
+                    record.evolution_type.value,
+                    record.trigger.value,
+                    record.generation,
+                    record.status.value,
+                    record.mutation_summary,
+                    json.dumps(list(record.evidence)),
+                    record.original_content,
+                    record.evolved_content,
+                    record.content_diff,
+                    1 if record.blind_verified else 0,
+                    record.rejection_reason,
+                    record.created_at,
+                    record.completed_at,
+                ),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+    def append_transition(
+        self,
+        record_id: str,
+        profile_id: str,
+        from_status: EvolutionStatus,
+        to_status: EvolutionStatus,
+        *,
+        actor_id: str = "",
+        reason: str = "",
+        metadata: dict | None = None,
+    ) -> str:
+        """Append an immutable status-transition row. Returns transition_hash.
+
+        Hash linkage (audit P2-3): transition_hash = SHA-256 over a canonical,
+        pipe-delimited payload covering EVERY persisted field —
+        ``prev_hash | record_id | from_status | to_status | ts | actor_id |
+        reason | metadata_str``. Delimiters remove concatenation ambiguity and
+        including reason+metadata makes those columns tamper-evident too.
+
+        prev_hash is the transition_hash of the most recent row for this
+        record_id, or 'genesis' for the first transition.
+
+        Concurrency (audit P1-5): the read-prev-then-insert is wrapped in a
+        single ``BEGIN IMMEDIATE`` transaction so two concurrent writers cannot
+        both read the same prev_hash and fork the chain.
+
+        Never calls UPDATE or DELETE. Raises ValueError if from_status == to_status.
+        """
+        if from_status == to_status:
+            raise ValueError(
+                f"append_transition: from_status == to_status == {from_status!r}; "
+                "no-op transitions are not allowed in the append-only log."
+            )
+        ts = datetime.now(timezone.utc).isoformat()
+        metadata_str = json.dumps(metadata or {}, sort_keys=True)
+
+        # isolation_level=None + explicit BEGIN IMMEDIATE = one atomic
+        # select-prev-then-insert critical section per call (P1-5).
+        conn = sqlite3.connect(self._db_path, timeout=10, isolation_level=None)
+        try:
+            conn.execute("BEGIN IMMEDIATE")
+            # Find prev_hash for this record_id (genesis if first)
+            row = conn.execute(
+                "SELECT transition_hash FROM skill_evolution_transitions "
+                "WHERE record_id = ? AND profile_id = ? "
+                "ORDER BY seq DESC LIMIT 1",
+                (record_id, profile_id),
+            ).fetchone()
+            prev_hash = row[0] if row else "genesis"
+
+            # Canonical, delimited payload over ALL persisted fields (P2-3).
+            payload = "|".join((
+                prev_hash, record_id,
+                from_status.value, to_status.value,
+                ts, actor_id, reason, metadata_str,
+            ))
+            transition_hash = hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+            conn.execute(
+                "INSERT INTO skill_evolution_transitions "
+                "(record_id, profile_id, from_status, to_status, "
+                " transitioned_at, actor_id, reason, prev_hash, "
+                " transition_hash, metadata) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (
+                    record_id,
+                    profile_id,
+                    from_status.value,
+                    to_status.value,
+                    ts,
+                    actor_id,
+                    reason,
+                    prev_hash,
+                    transition_hash,
+                    metadata_str,
+                ),
+            )
+            conn.execute("COMMIT")
+            return transition_hash
+        except Exception:
+            try:
+                conn.execute("ROLLBACK")
+            except Exception:
+                pass
+            raise
+        finally:
+            conn.close()
+
+    def get_latest_status(
+        self, record_id: str, profile_id: str,
+    ) -> EvolutionStatus | None:
+        """Return the to_status of the highest-seq transition for record_id.
+
+        Returns None if no transitions exist for this record_id / profile_id.
+        """
+        conn = sqlite3.connect(self._db_path, timeout=10)
+        try:
+            row = conn.execute(
+                "SELECT to_status FROM skill_evolution_transitions "
+                "WHERE record_id = ? AND profile_id = ? "
+                "ORDER BY seq DESC LIMIT 1",
+                (record_id, profile_id),
+            ).fetchone()
+            if row is None:
+                return None
+            return EvolutionStatus(row[0])
+        finally:
+            conn.close()
+
+    def get_transitions(self, record_id: str, profile_id: str) -> list[dict]:
+        """Return all transition rows for record_id ordered by seq ASC."""
+        conn = sqlite3.connect(self._db_path, timeout=10)
+        conn.row_factory = sqlite3.Row
+        try:
+            rows = conn.execute(
+                "SELECT seq, record_id, profile_id, from_status, to_status, "
+                "transitioned_at, actor_id, reason, prev_hash, transition_hash, "
+                "metadata "
+                "FROM skill_evolution_transitions "
+                "WHERE record_id = ? AND profile_id = ? "
+                "ORDER BY seq ASC",
+                (record_id, profile_id),
+            ).fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            conn.close()
+
     # ------------------------------------------------------------------
     # CRUD
     # ------------------------------------------------------------------
 
     def save_record(self, record: EvolutionRecord, profile_id: str) -> None:
+        """DEPRECATED: use insert_record() for new records and append_transition() for state changes.
+
+        Retained for backward-compatibility with existing tests and callers.
+        Uses INSERT OR REPLACE — mutable semantics, not append-only.
+        Will be removed in a future cleanup pass (not Phase 2 scope).
+        """
+        warnings.warn(
+            "EvolutionStore.save_record() is deprecated; "
+            "use insert_record() + append_transition() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         conn = sqlite3.connect(self._db_path, timeout=10)
         try:
             conn.execute(
@@ -306,13 +529,30 @@ class EvolutionStore:
             conn.close()
 
     def count_attempts(self, skill_name: str, profile_id: str) -> int:
+        """Count non-successful evolution attempts for a skill.
+
+        Audit P0-2: with the Phase-2 append-only model, ``skill_evolution_log``
+        rows are frozen at 'candidate' by ``insert_record`` and never updated, so
+        the legacy ``status NOT IN ('promoted')`` filter counted successes too —
+        permanently disabling a skill after MAX_ATTEMPTS_PER_SKILL improvements.
+        The current status is now read from the append-only transitions log
+        (latest ``to_status`` per record), and success states are excluded,
+        mirroring the pre-Phase-2 exclusion of 'promoted'. Legacy rows with no
+        transitions fall back to their frozen log status via COALESCE.
+        """
+        success = ("promoted", "verified_quarantined", "approved", "active")
+        marks = ",".join("?" for _ in success)
         conn = sqlite3.connect(self._db_path, timeout=10)
         try:
             row = conn.execute(
-                "SELECT COUNT(*) FROM skill_evolution_log "
-                "WHERE skill_name = ? AND profile_id = ? "
-                "AND status NOT IN ('promoted')",
-                (skill_name, profile_id),
+                "SELECT COUNT(*) FROM skill_evolution_log l "
+                "WHERE l.skill_name = ? AND l.profile_id = ? "
+                "AND COALESCE("
+                "  (SELECT t.to_status FROM skill_evolution_transitions t "
+                "   WHERE t.record_id = l.id AND t.profile_id = l.profile_id "
+                "   ORDER BY t.seq DESC LIMIT 1), l.status"
+                f") NOT IN ({marks})",
+                (skill_name, profile_id, *success),
             ).fetchone()
             return row[0] if row else 0
         finally:

package/src/superlocalmemory/evolution/llm_dispatch.py

@@ -158,6 +158,7 @@ ALLOWED_LLM_MODELS: frozenset[str] = frozenset({
     "claude-sonnet-4-6",
     "ollama:llama3",
     "ollama:qwen2.5",
+    "openai:gpt-4o-mini",
 })
 
 FORBIDDEN_MODEL_SUBSTRINGS: tuple[str, ...] = ("opus", "gpt-4-turbo")
@@ -301,6 +302,43 @@ def _call_claude_api_backend(
         return ""
 
 
+def _call_openai_api_backend(
+    prompt: str, *, model: str, max_tokens: int,
+) -> str:
+    """Call the OpenAI Chat Completions API directly.
+
+    The API model id is derived from the allow-listed name by stripping
+    the ``"openai:"`` prefix — e.g. ``"openai:gpt-4o-mini"`` → ``"gpt-4o-mini"``.
+    Requires ``OPENAI_API_KEY`` in the environment. Returns empty string on
+    any transport or SDK failure (fail-closed).
+    """
+    openai_model = model.split(":", 1)[1] if model.startswith("openai:") else model
+    try:
+        import openai as _openai  # type: ignore[import-not-found]
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("openai sdk unavailable: %s", exc)
+        return ""
+
+    try:
+        client = _openai.OpenAI()
+        completion = client.chat.completions.create(
+            model=openai_model,
+            max_tokens=max_tokens,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        choices = getattr(completion, "choices", None)
+        if choices and len(choices) > 0:
+            msg = getattr(choices[0], "message", None)
+            if msg:
+                content = getattr(msg, "content", None)
+                if isinstance(content, str):
+                    return content
+        return ""
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("OpenAI API backend failed: %s", exc)
+        return ""
+
+
 # ---------------------------------------------------------------------------
 # Backend registry — dispatches by (allow-listed) model id
 # ---------------------------------------------------------------------------
@@ -337,6 +375,8 @@ def _pick_backend(model: str) -> Callable[..., str]:
     """
     if model.startswith("ollama:"):
         return _call_ollama_backend
+    if model.startswith("openai:"):
+        return _call_openai_api_backend
     if model.startswith("claude-"):
         # Claude CLI path is an alternative — selected when an explicit
         # env flag is set. Default path is the Anthropic API backend.

package/src/superlocalmemory/evolution/model_selection.py

@@ -39,6 +39,7 @@ CHEAPEST_CLAUDE = "claude-haiku-4-5"
 QUALITY_CLAUDE = "claude-sonnet-4-6"
 CHEAPEST_OLLAMA = "ollama:llama3"
 ALT_OLLAMA = "ollama:qwen2.5"
+CHEAPEST_OPENAI = "openai:gpt-4o-mini"
 
 # Short-name → allow-listed model id. Single source of truth for aliasing;
 # ``skill_evolver`` re-exports these for backward compatibility.
@@ -48,6 +49,8 @@ _MODEL_ALIASES: dict[str, str] = {
     "ollama": CHEAPEST_OLLAMA,
     "ollama:llama3": CHEAPEST_OLLAMA,
     "ollama:qwen2.5": ALT_OLLAMA,
+    "openai": CHEAPEST_OPENAI,
+    "openai:gpt-4o-mini": CHEAPEST_OPENAI,
     CHEAPEST_CLAUDE: CHEAPEST_CLAUDE,
     QUALITY_CLAUDE: QUALITY_CLAUDE,
 }
@@ -78,11 +81,18 @@ class ResolvedModels:
 
 
 def _cheapest_for_backend(backend: str) -> str:
-    """Lowest-cost allow-listed model for a detected backend."""
+    """Lowest-cost allow-listed model for a detected backend.
+
+    The configured backend is authoritative: when the caller explicitly
+    names a provider, models are drawn from that provider only —
+    never silently downgraded to a different vendor's offering.
+    """
     if backend == "ollama":
         return CHEAPEST_OLLAMA
-    # claude CLI, anthropic API, and any non-Ollama backend evolution can
-    # actually dispatch route through the cheapest Claude model.
+    if backend == "openai":
+        return CHEAPEST_OPENAI
+    # claude CLI, anthropic API, and any non-Ollama/non-OpenAI backend
+    # route through the cheapest Claude model.
     return CHEAPEST_CLAUDE
 
 
@@ -106,6 +116,8 @@ def _independent_verifier(
     """Pick a cheap verifier that differs from the generator when possible.
 
     - Ollama generator → the *other* local model (both free, distinct).
+    - OpenAI generator → same OpenAI model (single-provider constraint;
+      independence flag will be False — caller logs the condition).
     - Claude generator + local Ollama up → free local verifier.
     - Claude generator, no Ollama → the cheapest *different* Claude tier if
       the generator was a premium model; otherwise reuse the cheapest model
@@ -114,6 +126,9 @@ def _independent_verifier(
     """
     if mutation.startswith("ollama:"):
         return ALT_OLLAMA if mutation != ALT_OLLAMA else CHEAPEST_OLLAMA
+    if mutation.startswith("openai:"):
+        # Honor the configured provider: stay within OpenAI models.
+        return CHEAPEST_OPENAI
     if ollama_available:
         return CHEAPEST_OLLAMA
     if mutation != CHEAPEST_CLAUDE:

package/src/superlocalmemory/evolution/mutation_generator.py

@@ -97,6 +97,9 @@ _SKILL_DENY_PATTERNS: tuple[str, ...] = (
     "os.environ", "subprocess", "exec(", "eval(", "__import__", "import os",
     "import subprocess", "pickle.loads", "curl ", "wget ", "rm -rf",
     "ANTHROPIC_API_KEY", "OPENAI_API_KEY", "AWS_SECRET", "/.ssh/", ".install_token",
+    # Semantic exfiltration patterns — skills must not instruct unauthorized
+    # data transfer or bypass of user consent.
+    "without consent", "exfiltrat",
 )