superlocalmemory 3.4.9 → 3.4.11

package/src/superlocalmemory/cli/setup_wizard.py

@@ -265,7 +265,7 @@ def run_wizard(auto: bool = False) -> None:
     print()
 
     # -- Step 1: System check --
-    print("─── Step 1/6: System Check ───")
+    print("─── Step 1/10: System Check ───")
     print()
     py_ver = platform.python_version()
     py_ok = sys.version_info >= (3, 11)
@@ -293,7 +293,7 @@ def run_wizard(auto: bool = False) -> None:
 
     # -- Step 2: Mode selection --
     print()
-    print("─── Step 2/6: Choose Operating Mode ───")
+    print("─── Step 2/10: Choose Operating Mode ───")
     print()
     print("  [A] Local Guardian (recommended)")
     print("      Zero cloud. Zero LLM. Full privacy.")
@@ -342,7 +342,7 @@ def run_wizard(auto: bool = False) -> None:
 
     # -- Step 3: Code Knowledge Graph --
     print()
-    print("─── Step 3/6: Code Knowledge Graph ───")
+    print("─── Step 3/10: Code Knowledge Graph ───")
     print()
     print("  CodeGraph builds a structural map of your codebase using Tree-sitter.")
     print("  It gives your AI assistant blast-radius analysis, call graphs,")
@@ -375,7 +375,7 @@ def run_wizard(auto: bool = False) -> None:
 
     # -- Step 4: Download models --
     print()
-    print("─── Step 4/9: Download Embedding Model ───")
+    print("─── Step 4/10: Download Embedding Model ───")
 
     if not st_ok:
         print("  ⚠ Skipped (sentence-transformers not installed)")
@@ -386,7 +386,7 @@ def run_wizard(auto: bool = False) -> None:
             print("  ⚠ Model will download on first use (may take a few minutes)")
 
     print()
-    print("─── Step 4b/9: Download Reranker Model ───")
+    print("─── Step 4b/10: Download Reranker Model ───")
 
     if not st_ok:
         print("  ⚠ Skipped (sentence-transformers not installed)")
@@ -395,7 +395,7 @@ def run_wizard(auto: bool = False) -> None:
 
     # -- Step 5: Daemon Configuration (v3.4.3) --
     print()
-    print("─── Step 5/9: Daemon Configuration ───")
+    print("─── Step 5/10: Daemon Configuration ───")
     print()
     print("  The SLM daemon runs in the background for instant memory access.")
     print()
@@ -425,7 +425,7 @@ def run_wizard(auto: bool = False) -> None:
 
     # -- Step 6: Mesh Communication (v3.4.3) --
     print()
-    print("─── Step 6/9: Mesh Communication ───")
+    print("─── Step 6/10: Mesh Communication ───")
     print()
     print("  SLM Mesh enables agent-to-agent P2P communication.")
     print("  Multiple AI sessions can share knowledge in real-time.")
@@ -446,7 +446,7 @@ def run_wizard(auto: bool = False) -> None:
 
     # -- Step 7: Ingestion Adapters (v3.4.3) --
     print()
-    print("─── Step 7/9: Ingestion Adapters ───")
+    print("─── Step 7/10: Ingestion Adapters ───")
     print()
     print("  These let SLM learn from your email, calendar, and meetings.")
     print("  All adapters are OFF by default. You can enable them later.")
@@ -486,7 +486,7 @@ def run_wizard(auto: bool = False) -> None:
 
     # -- Step 8: Entity Compilation (v3.4.3) --
     print()
-    print("─── Step 8/9: Entity Compilation ───")
+    print("─── Step 8/10: Entity Compilation ───")
     print()
     print("  Entity compilation builds knowledge summaries per person,")
     print("  project, and concept. Runs automatically during consolidation.")
@@ -505,9 +505,50 @@ def run_wizard(auto: bool = False) -> None:
     config.save()
     print(f"\n  ✓ Entity compilation {'enabled' if config.entity_compilation_enabled else 'disabled'}")
 
-    # -- Step 9: Verification --
+    # -- Step 9: Skill Evolution (v3.4.11) --
     print()
-    print("─── Step 9/9: Verification ───")
+    print("─── Step 9/10: Skill Evolution ───")
+    print()
+    print("  SLM can automatically evolve skills that underperform.")
+    print("  It detects degradation, generates improvements, and verifies them blindly.")
+    print("  Requires an LLM backend (Claude CLI, Ollama, or API key).")
+    print()
+    print("  [Y] Enable Skill Evolution")
+    print("  [N] Disable (can enable later: slm config set evolution.enabled true)")
+    print()
+
+    if interactive:
+        evo_choice = _prompt("  Enable Skill Evolution? [Y/n] (default: Y): ", "y").lower()
+    else:
+        evo_choice = "y"
+        print("  Auto-enabling Skill Evolution (non-interactive)")
+
+    evolution_enabled = evo_choice in ("", "y", "yes")
+
+    # Write evolution config to config.json directly
+    # (SLMConfig.save() doesn't serialize evolution)
+    _SLM_HOME.mkdir(parents=True, exist_ok=True)
+    evo_config_path = _SLM_HOME / "config.json"
+    evo_cfg: dict = {}
+    if evo_config_path.exists():
+        try:
+            evo_cfg = json.loads(evo_config_path.read_text())
+        except (json.JSONDecodeError, OSError):
+            pass
+    evo_cfg["evolution"] = {
+        "enabled": evolution_enabled,
+        "backend": "auto",
+    }
+    evo_config_path.write_text(json.dumps(evo_cfg, indent=2) + "\n")
+
+    if evolution_enabled:
+        print(f"\n  ✓ Skill Evolution enabled (backend: auto-detect)")
+    else:
+        print(f"\n  ✓ Skill Evolution disabled")
+
+    # -- Step 10: Verification --
+    print()
+    print("─── Step 10/10: Verification ───")
 
     if st_ok:
         verified = _verify_installation()
@@ -537,6 +578,8 @@ def run_wizard(auto: bool = False) -> None:
         print(", Entity Compilation", end="")
     if code_graph_enabled:
         print(", CodeGraph", end="")
+    if evolution_enabled:
+        print(", Skill Evolution", end="")
     print()
     if enabled_adapters:
         print(f"  Adapters: {', '.join(enabled_adapters)}")

package/src/superlocalmemory/core/config.py

@@ -490,6 +490,25 @@ class TemporalValidatorConfig:
     include_expired_in_history: bool = True
 
 
+@dataclass(frozen=True)
+class EvolutionConfig:
+    """Configuration for Skill Evolution Engine (v3.4.10).
+
+    OFF by default — opt in via `slm setup` (interactive) or
+    `slm config set evolution.enabled true` (CLI).
+
+    Backend auto-detection priority:
+      1. `claude` CLI available → spawn `claude --model haiku` (ECC pattern, free)
+      2. Ollama running → use Ollama (free, local)
+      3. API key set → use Anthropic/OpenAI API (paid)
+      4. Nothing → dashboard-only (show candidates, manual evolution)
+    """
+
+    enabled: bool = False                        # OFF by default, opt-in
+    backend: str = "auto"                        # auto, claude, ollama, anthropic, openai
+    max_evolutions_per_cycle: int = 3            # Budget cap per consolidation
+
+
 @dataclass(frozen=True)
 class AutoInvokeConfig:
     """Configuration for the Auto-Invoke Engine (Phase 2).
@@ -580,6 +599,7 @@ class SLMConfig:
     parameterization: ParameterizationConfig = field(
         default_factory=ParameterizationConfig,
     )
+    evolution: EvolutionConfig = field(default_factory=EvolutionConfig)
 
     # v3.4.3: Daemon configuration
     daemon_idle_timeout: int = 0       # 0 = 24/7 (no auto-kill). >0 = seconds before auto-kill.
@@ -657,6 +677,14 @@ class SLMConfig:
         )
         config.mesh_enabled = data.get("mesh_enabled", True)
 
+        # V3.4.10: Evolution config
+        evo = data.get("evolution", {})
+        if evo:
+            config.evolution = EvolutionConfig(**{
+                k: v for k, v in evo.items()
+                if k in EvolutionConfig.__dataclass_fields__
+            })
+
         return config
 
     def save(self, config_path: Path | None = None) -> None:
@@ -696,6 +724,13 @@ class SLMConfig:
             },
         }
 
+        # V3.4.11: Persist evolution config (C-CONFIGSAVE fix)
+        data["evolution"] = {
+            "enabled": self.evolution.enabled,
+            "backend": self.evolution.backend,
+            "max_evolutions_per_cycle": self.evolution.max_evolutions_per_cycle,
+        }
+
         # Preserve existing V3.3 config sections that aren't in for_mode()
         for key in ("forgetting", "quantization", "sagq", "embedding_signature", "auto_invoke"):
             if key in existing:

package/src/superlocalmemory/core/consolidation_engine.py

@@ -178,6 +178,37 @@ class ConsolidationEngine:
                     logger.debug("Soft prompt generation (non-fatal): %s", exc)
                     results["soft_prompts"] = {"error": str(exc)}
 
+                # Step 10 (v3.4.10): Mine skill performance from tool events.
+                # Creates per-skill assertions and skill correlation patterns.
+                try:
+                    from superlocalmemory.learning.skill_performance_miner import SkillPerformanceMiner
+                    spm = SkillPerformanceMiner(self._db.db_path)
+                    results["skill_performance"] = spm.mine(profile_id)
+                except Exception as exc:
+                    logger.debug("Skill performance mining (non-fatal): %s", exc)
+                    results["skill_performance"] = {"error": str(exc)}
+
+                # Step 11 (v3.4.10): Skill evolution — 3-trigger system.
+                # Runs degradation + health check triggers. Post-session
+                # trigger runs separately from the Stop hook.
+                # Never on recall/remember hot path. Budget: max 3 per cycle.
+                try:
+                    from superlocalmemory.evolution.skill_evolver import SkillEvolver
+                    evolver = SkillEvolver(self._db.db_path)
+                    results["skill_evolution"] = evolver.run_consolidation_cycle(profile_id)
+                except Exception as exc:
+                    logger.debug("Skill evolution (non-fatal): %s", exc)
+                    results["skill_evolution"] = {"error": str(exc)}
+
+                # Step 12 (v3.4.11): Generate soft prompts for evolved skills.
+                # Queries promoted evolutions and creates/updates custom soft
+                # prompts so the AI prefers evolved skill variants.
+                try:
+                    results["evolution_soft_prompts"] = self._step12_evolution_soft_prompts(profile_id)
+                except Exception as exc:
+                    logger.debug("Evolution soft prompts (non-fatal): %s", exc)
+                    results["evolution_soft_prompts"] = {"error": str(exc)}
+
             results["success"] = True
         except Exception as exc:
             logger.warning(
@@ -588,6 +619,113 @@ class ConsolidationEngine:
             logger.warning("CCQ step failed (non-fatal): %s", exc)
             return {"error": str(exc)}
 
+    # ------------------------------------------------------------------
+    # Step 12: Evolution Soft Prompts
+    # ------------------------------------------------------------------
+
+    def _step12_evolution_soft_prompts(self, profile_id: str) -> dict[str, Any]:
+        """Generate soft prompts for promoted evolved skills.
+
+        Queries skill_evolution_log for promoted evolutions and creates
+        or updates soft_prompt_templates with category='custom' so the
+        AI agent prefers evolved skill variants over originals.
+
+        Uses 'custom' category because the soft_prompt_templates CHECK
+        constraint does not include 'skill_evolution'. The content is
+        prefixed with [SKILL_EVOLUTION] for easy filtering.
+        """
+        import sqlite3 as _sqlite3
+
+        db_path = str(self._db.db_path)
+
+        conn = _sqlite3.connect(db_path, timeout=10)
+        conn.row_factory = _sqlite3.Row
+
+        # Fetch promoted evolutions
+        try:
+            promoted_rows = conn.execute(
+                "SELECT id, skill_name, parent_skill_id, evolution_type, "
+                "mutation_summary, created_at "
+                "FROM skill_evolution_log "
+                "WHERE status = 'promoted' "
+                "ORDER BY created_at DESC LIMIT 20",
+            ).fetchall()
+        except _sqlite3.OperationalError:
+            # Table may not exist yet
+            conn.close()
+            return {"created": 0, "message": "skill_evolution_log table not found"}
+
+        created_count = 0
+        now = datetime.now(timezone.utc).isoformat()
+
+        for row in promoted_rows:
+            r = dict(row)
+            skill_name = r["skill_name"]
+            parent = r.get("parent_skill_id") or skill_name
+            evo_type = r["evolution_type"]
+            summary = r.get("mutation_summary", "")
+            evo_id = r["id"]
+
+            # Build prompt content
+            content = (
+                f"[SKILL_EVOLUTION] Evolved skill: '{skill_name}' "
+                f"({'replaces' if evo_type == 'fix' else 'extends'} '{parent}' "
+                f"via {evo_type}). {summary}. "
+                f"Use the evolved version for better results."
+            )
+
+            # Use a deterministic prompt_id based on the evolution record
+            prompt_id = f"evo-{evo_id}"
+
+            # Check if prompt already exists
+            existing = conn.execute(
+                "SELECT prompt_id FROM soft_prompt_templates WHERE prompt_id = ?",
+                (prompt_id,),
+            ).fetchone()
+
+            if existing:
+                # M-REPLACE: Update existing record instead of INSERT OR REPLACE
+                # to avoid silently dropping columns with defaults
+                try:
+                    conn.execute(
+                        "UPDATE soft_prompt_templates "
+                        "SET content = ?, updated_at = ? "
+                        "WHERE prompt_id = ?",
+                        (content, now, prompt_id),
+                    )
+                except _sqlite3.OperationalError as upd_exc:
+                    logger.debug("Failed to update soft prompt %s: %s", prompt_id, upd_exc)
+                continue
+
+            try:
+                conn.execute(
+                    "INSERT OR IGNORE INTO soft_prompt_templates "
+                    "(prompt_id, profile_id, category, content, source_pattern_ids, "
+                    " confidence, effectiveness, token_count, retention_score, "
+                    " active, version, created_at, updated_at) "
+                    "VALUES (?, ?, 'custom', ?, ?, 0.8, 0.5, ?, 1.0, 1, 1, ?, ?)",
+                    (prompt_id, profile_id, content,
+                     json.dumps([evo_id]),
+                     len(content.split()),  # Rough token estimate
+                     now, now),
+                )
+                if conn.total_changes:
+                    created_count += 1
+            except _sqlite3.IntegrityError:
+                # Unique constraint on (profile_id, category) WHERE active=1
+                logger.debug(
+                    "Skipping soft prompt for %s: unique constraint on active custom",
+                    skill_name,
+                )
+
+        conn.commit()
+        conn.close()
+
+        return {
+            "promoted_skills_found": len(promoted_rows),
+            "soft_prompts_created": created_count,
+        }
+
     # ------------------------------------------------------------------
     # Core Memory Block Storage
     # ------------------------------------------------------------------

package/src/superlocalmemory/core/embedding_worker.py

@@ -170,7 +170,7 @@ def _worker_main() -> None:
             # a fresh worker on next request (existing mechanism in embeddings.py).
             # V3.3.21: Configurable via SLM_EMBED_WORKER_RSS_LIMIT_MB (default 2500MB).
             import resource
-            _rss_limit = int(os.environ.get("SLM_EMBED_WORKER_RSS_LIMIT_MB", 2500))
+            _rss_limit = int(os.environ.get("SLM_EMBED_WORKER_RSS_LIMIT_MB", 4000))
             rss_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024 / 1024
             if rss_mb > _rss_limit:
                 sys.exit(0)

package/src/superlocalmemory/core/engine.py

@@ -139,6 +139,20 @@ class MemoryEngine:
         except Exception as exc:
             logger.debug("V3.4.7 schema migration: %s", exc)
 
+        # V3.4.10: Apply "Fortress" schema (backup_destinations, entity_blacklist)
+        try:
+            from superlocalmemory.storage.schema_v3410 import apply_v3410_schema
+            apply_v3410_schema(str(self._db.db_path))
+        except Exception as exc:
+            logger.debug("V3.4.10 schema migration: %s", exc)
+
+        # V3.4.11: Apply "Scale-Ready" schema (pinned_facts, backend_status, fact_consolidations)
+        try:
+            from superlocalmemory.storage.schema_v3411 import apply_v3411_schema
+            apply_v3411_schema(str(self._db.db_path))
+        except Exception as exc:
+            logger.debug("V3.4.11 schema migration: %s", exc)
+
         self._embedder = init_embedder(self._config)
 
         if self._caps.llm_fact_extraction:
@@ -377,6 +391,11 @@ class MemoryEngine:
     def close(self) -> None:
         if self._maintenance_scheduler is not None:
             self._maintenance_scheduler.stop()
+        if self._db is not None:
+            try:
+                self._db.close()
+            except Exception:
+                pass
         self._initialized = False
 
     @property