superlocalmemory 3.4.10 → 3.4.12

package/README.md

@@ -4,7 +4,7 @@
 
 <h1 align="center">SuperLocalMemory V3.4</h1>
 <p align="center"><strong>Every other AI forgets. Yours won't.</strong><br/><em>Infinite memory for Claude Code, Cursor, Windsurf & 17+ AI tools.</em></p>
-<p align="center"><code>v3.4.4 "Neural Glass"</code> — Install once. Every session remembers the last. Automatically.</p>
+<p align="center"><code>v3.4.11</code> — Install once. Every session remembers the last. Automatically.</p>
 <p align="center"><strong>Backed by 3 peer-reviewed research papers</strong> · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 
 <p align="center">
@@ -378,14 +378,20 @@ Auto-capture hooks: `slm hooks install` + `slm observe` + `slm session-context`.
 - Auto-learned soft prompts injected into agent context
 - Behavioral pattern detection and outcome tracking
 
-### Skill Evolution (NEW in v3.4.10)
-- **Per-skill performance tracking** — automatically tracks which skills succeed and which fail, across sessions
-- **Execution trace analysis** — mines tool usage patterns around skill invocations to determine effectiveness
-- **Skill entities in Entity Explorer** — each skill becomes a browsable entity with performance facts and evolution history
-- **Dedicated Skill Evolution dashboard tab** — overview cards, performance assertions, skill correlations
-- **Behavioral assertions for skill routing** — soft prompts recommend high-performing skills in future sessions
-- **ECC integration** — enhanced observation support with [Everything Claude Code](https://github.com/affaan-m/everything-claude-code) via `slm ingest --source ecc`
-- **IDE compatibility:** Skill tracking currently works with Claude Code. The `/api/v3/tool-event` endpoint accepts events from any IDE client — adapters for other IDEs in future releases.
+### Skill Evolution
+- **Per-skill performance tracking** — tracks which skills succeed and fail across sessions (zero-LLM, always on)
+- **Evolution engine** — 3-trigger system with blind verification. Off by default — enable via `slm config set evolution.enabled true`
+- **MCP tools** — `evolve_skill`, `skill_health`, `skill_lineage` for programmatic access
+- **Lineage DAG** — visual evolution history in the dashboard
+- **CLI config** — `slm config get/set` for all evolution settings
+- **Post-session triggers** — automatic analysis on session end via Stop hook
+- **[ECC](https://github.com/affaan-m/everything-claude-code) integration** — optional enhanced observations via `slm ingest --source ecc`
+
+### Tiered Storage & Scaling
+- **4-tier lifecycle** — active, warm, cold, archived with automatic promotion/demotion
+- **Deep recall** — archived facts searchable at reduced weight
+- **Graph pruning** — automatic cleanup of orphan edges, self-loops, duplicates
+- **Fact consolidation** — clusters related facts into consolidated summaries
 
 ### Trust & Security
 - Bayesian Beta-distribution trust scoring (per-agent, per-fact)
@@ -396,9 +402,9 @@ Auto-capture hooks: `slm hooks install` + `slm observe` + `slm session-context`.
 ### Infrastructure
 - 23-tab web dashboard with real-time visualization
 - 17+ IDE integrations (Claude, Cursor, Windsurf, VS Code, JetBrains, Zed, etc.)
-- 35 MCP tools + 7 MCP resources
+- 38 MCP tools + 7 MCP resources
 - Profile isolation (independent memory spaces)
-- 1400+ tests, AGPL v3, cross-platform (Mac/Linux/Windows)
+- 2,900+ tests, AGPL v3, cross-platform (Mac/Linux/Windows)
 - CPU-only — no GPU required
 - Automatic orphaned process cleanup
 

package/docs/skill-evolution.md

@@ -70,8 +70,10 @@ The dedicated **Skill Evolution** tab in the SLM dashboard shows:
 
 - **Overview cards** — Total skill events, unique skills, performance assertions, skill correlations
 - **Skill performance cards** — Per-skill effective score, invocation count, confidence level
+- **Evolution Engine status** — Backend detection, enable/disable toggle, run button
+- **Skill Lineage DAG** — Visual graph of evolved skill versions (parent → child relationships)
+- **Lineage table** — Clickable rows showing evolution type, status, verification result
 - **Skill correlations** — Which skills work well together
-- **Compatibility notice** — Current IDE support status
 
 Access: Open `http://localhost:8765` and navigate to the Skill Evolution tab in the sidebar.
 
@@ -132,23 +134,69 @@ This reads ECC's observation files from `~/.claude/homunculus/projects/*/observa
 
 ## Configuration
 
-### Enable/Disable Skill Tracking
+### Skill Tracking (C1 — always on)
 
-Skill tracking is enabled by default when the SLM hook is registered. To check:
+Skill performance tracking is enabled by default when the SLM hook is registered. Zero-LLM, zero-cost. Runs as Step 10 in the consolidation pipeline.
 
 ```bash
 slm status  # Shows hook registration status
+slm consolidate --cognitive  # Trigger manual consolidation
 ```
 
-### Consolidation
+### Skill Evolution (C2 — off by default)
 
-Skill performance mining runs as Step 10 in the consolidation pipeline. It processes only new events since the last run (incremental). To trigger manually:
+The Skill Evolution Engine uses LLM calls to generate improved skill versions. **It is OFF by default** — end users must opt in.
+
+**Why off by default:** Evolution makes LLM calls (confirmation gate + mutation + blind verification). Even with budget caps, users should consciously enable this and configure their LLM backend.
+
+#### Enable via CLI
 
 ```bash
-slm consolidate --cognitive
+slm config set evolution.enabled true
+```
+
+#### Enable via Interactive Installer
+
+```bash
+slm setup  # Interactive wizard includes evolution opt-in
+```
+
+#### Enable via Dashboard
+
+Navigate to Settings → Skill Evolution → Enable.
+
+### LLM Backend — Auto-Detect
+
+Evolution uses a single auto-detect chain. No manual configuration needed for most users:
+
+```
+Priority 1: `claude` CLI available → spawn `claude --model haiku` (FREE, best quality)
+Priority 2: Ollama running         → use Ollama (FREE, local)
+Priority 3: API key set            → use Anthropic/OpenAI API (paid)
+Priority 4: Nothing available      → dashboard-only (show candidates, manual evolution)
 ```
 
-### Minimum Thresholds
+This means:
+- **Claude Code users:** Evolution works for free — uses your existing Claude subscription
+- **Other IDE users with Ollama:** Evolution works for free — uses local Ollama
+- **Advanced users:** Can point at Anthropic/OpenAI API if preferred
+
+```bash
+# Override auto-detect (optional — most users never need this)
+slm config set evolution.backend claude
+slm config set evolution.backend ollama
+slm config set evolution.backend anthropic
+```
+
+### Full Evolution Config Reference
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `evolution.enabled` | `false` | Master switch — off by default, opt-in |
+| `evolution.backend` | `auto` | LLM backend: `auto`, `claude`, `ollama`, `anthropic`, `openai` |
+| `evolution.max_evolutions_per_cycle` | `3` | Budget cap per consolidation cycle |
+
+### Tracking Thresholds (C1)
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
@@ -172,11 +220,30 @@ SLM's skill evolution system draws from:
 
 ---
 
+## MCP Tools
+
+Three MCP tools are available for programmatic access:
+
+| Tool | Description |
+|------|-------------|
+| `evolve_skill` | Manually trigger evolution for a specific skill |
+| `skill_health` | Get health metrics (invocations, error rate, status) for skills |
+| `skill_lineage` | Get evolution lineage tree for a skill |
+
+These tools are registered automatically and available in all supported IDEs.
+
+## CLI Commands
+
+```bash
+slm config get evolution.enabled     # Check if evolution is enabled
+slm config set evolution.enabled true  # Enable evolution
+slm config set evolution.backend auto  # Set LLM backend
+```
+
 ## What's Next
 
-- **C2: Arsenal Evolution Engine** — Automatic skill mutation with 3-trigger system, LLM confirmation gate, and blind verification. Evolved skills stored in `~/.claude/skills/evolved/`.
-- **C3: SLM Productization** — New MCP tools (`evolve_skill`, `skill_health`, `skill_lineage`), new fact types, full dashboard evolution history.
-- **IDE Adapters** — Cursor, Windsurf, VS Code Copilot, JetBrains support.
+- **IDE Adapters** — Cursor, Windsurf, VS Code Copilot, JetBrains support for skill tracking.
+- **Skill lineage visualization improvements** — Richer DAG with performance history overlay.
 
 ---
 

package/ide/hooks/tool-event-hook.sh

@@ -76,14 +76,14 @@ import json, sys, os, re
 
 # Secret scrubbing pattern (adopted from ECC observe.sh)
 _SECRET_RE = re.compile(
-    r"(?i)(api[_-]?key|token|secret|password|authorization|credentials?|auth)"
+    r"(?i)(api[_-]?key|[a-z_]*_key|token|secret|password|pass\b|authorization|credentials?|auth)"
     r"""([\"'"'"'"'"'"'\s:=]+)"""
     r"([A-Za-z]+\s+)?"
     r"([A-Za-z0-9_\-/.+=]{8,})"
 )
 
 def scrub(val, max_len=500):
-    """Truncate and scrub secrets from a value."""
+    """Scrub secrets first, then truncate."""
     if val is None:
         return ""
     if isinstance(val, dict):
@@ -92,10 +92,10 @@ def scrub(val, max_len=500):
         s = json.dumps(val, default=str)
     else:
         s = str(val)
-    s = s[:max_len]
-    return _SECRET_RE.sub(
+    s = _SECRET_RE.sub(
         lambda m: m.group(1) + m.group(2) + (m.group(3) or "") + "[REDACTED]", s
     )
+    return s[:max_len]
 
 try:
     data = json.load(sys.stdin)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.10",
+  "version": "3.4.12",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.10"
+version = "3.4.12"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}
@@ -112,8 +112,9 @@ superlocalmemory = ["ui/**/*"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["src"]
+addopts = "-m 'not slow and not ollama'"
 markers = [
-    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+    "slow: marks tests as slow — real engine/model loading (run with: pytest -m slow)",
     "ollama: marks tests that require a running Ollama instance",
 ]
 filterwarnings = [

package/src/superlocalmemory/cli/commands.py

@@ -64,6 +64,9 @@ def dispatch(args: Namespace) -> None:
         "adapters": cmd_adapters,
         # V3.4.8 external observation ingestion
         "ingest": cmd_ingest,
+        # V3.4.11 skill evolution
+        "config": cmd_config,
+        "evolve": cmd_evolve,
     }
     handler = handlers.get(args.command)
     if handler:
@@ -341,6 +344,173 @@ def cmd_ingest(args: Namespace) -> None:
     _ingest(args)
 
 
+# -- Config & Evolution (V3.4.11) -----------------------------------------------
+
+
+def cmd_config(args: Namespace) -> None:
+    """Get or set config values (dot-notation).
+
+    Usage:
+      slm config set evolution.enabled true
+      slm config set evolution.backend auto
+      slm config get evolution.enabled
+      slm config get evolution.backend
+    """
+    import json
+    from pathlib import Path
+
+    use_json = getattr(args, "json", False)
+    action = getattr(args, "action", "get")
+    key = getattr(args, "key", "")
+    value = getattr(args, "value", None)
+
+    config_path = Path.home() / ".superlocalmemory" / "config.json"
+
+    # Read existing config
+    cfg: dict = {}
+    if config_path.exists():
+        try:
+            cfg = json.loads(config_path.read_text())
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    if action == "get":
+        # Parse dot-notation key (e.g. "evolution.enabled")
+        parts = key.split(".") if key else []
+        node = cfg
+        for part in parts:
+            if isinstance(node, dict) and part in node:
+                node = node[part]
+            else:
+                node = None
+                break
+
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("config", data={"key": key, "value": node})
+        else:
+            if node is None:
+                print(f"{key}: (not set)")
+            else:
+                print(f"{key}: {node}")
+
+    elif action == "set":
+        _ALLOWED_CONFIG_KEYS = {
+            "evolution.enabled", "evolution.backend", "evolution.max_evolutions_per_cycle",
+            "mesh_enabled", "daemon_idle_timeout", "entity_compilation_enabled",
+        }
+        if key not in _ALLOWED_CONFIG_KEYS:
+            if use_json:
+                from superlocalmemory.cli.json_output import json_print
+                json_print("config", error={
+                    "code": "DISALLOWED_KEY",
+                    "message": f"'{key}' is not a configurable key. Allowed: {', '.join(sorted(_ALLOWED_CONFIG_KEYS))}",
+                })
+            else:
+                print(f"Error: '{key}' is not a configurable key. Allowed: {', '.join(sorted(_ALLOWED_CONFIG_KEYS))}")
+            sys.exit(1)
+
+        if not key or value is None:
+            if use_json:
+                from superlocalmemory.cli.json_output import json_print
+                json_print("config", error={
+                    "code": "INVALID_INPUT",
+                    "message": "Usage: slm config set <key> <value>",
+                })
+            else:
+                print("Usage: slm config set <key> <value>")
+            sys.exit(1)
+
+        # Parse value: booleans, numbers, strings
+        parsed_value: object
+        if value.lower() in ("true", "yes", "on"):
+            parsed_value = True
+        elif value.lower() in ("false", "no", "off"):
+            parsed_value = False
+        else:
+            try:
+                parsed_value = int(value)
+            except ValueError:
+                try:
+                    parsed_value = float(value)
+                except ValueError:
+                    parsed_value = value
+
+        # Set via dot-notation (e.g. "evolution.enabled" -> cfg["evolution"]["enabled"])
+        parts = key.split(".")
+        node = cfg
+        for part in parts[:-1]:
+            if part not in node or not isinstance(node.get(part), dict):
+                node[part] = {}
+            node = node[part]
+        old_value = node.get(parts[-1])
+        node[parts[-1]] = parsed_value
+
+        # Write back
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path.write_text(json.dumps(cfg, indent=2) + "\n")
+
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("config", data={
+                "key": key, "old_value": old_value, "new_value": parsed_value,
+            })
+        else:
+            print(f"{key}: {old_value} -> {parsed_value}")
+
+    else:
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("config", error={
+                "code": "UNKNOWN_ACTION",
+                "message": f"Unknown action: {action}. Use 'get' or 'set'.",
+            })
+        else:
+            print(f"Unknown config action: {action}. Use 'get' or 'set'.")
+        sys.exit(1)
+
+
+def cmd_evolve(args: Namespace) -> None:
+    """Run skill evolution for a session (called from Stop hook).
+
+    Reads config.json to check if evolution is enabled.
+    If enabled, imports SkillEvolver and runs run_post_session().
+    If disabled, exits silently (zero output for fire-and-forget).
+    """
+    import json
+    from pathlib import Path
+
+    session_id = getattr(args, "session", "") or ""
+    profile = getattr(args, "profile", "default") or "default"
+
+    if not session_id:
+        return  # Silent exit — nothing to do without a session
+
+    # Check if evolution is enabled via config.json
+    config_path = Path.home() / ".superlocalmemory" / "config.json"
+    try:
+        cfg = json.loads(config_path.read_text()) if config_path.exists() else {}
+    except (json.JSONDecodeError, OSError):
+        return  # Config unreadable — silent exit
+
+    evolution_cfg = cfg.get("evolution", {})
+    if not evolution_cfg.get("enabled", False):
+        return  # Disabled — silent exit
+
+    # Heavy imports only if enabled (this runs as a Popen child)
+    try:
+        from superlocalmemory.evolution.skill_evolver import SkillEvolver
+
+        db_path = Path.home() / ".superlocalmemory" / "memory.db"
+        if not db_path.exists():
+            return
+
+        evolver = SkillEvolver(db_path)
+        evolver.run_post_session(session_id, profile)
+    except Exception:
+        pass  # Best-effort — don't crash the Stop hook
+
+
 def cmd_adapters(args: Namespace) -> None:
     """Manage ingestion adapters (Gmail, Calendar, Transcript).
 

package/src/superlocalmemory/cli/main.py

@@ -313,6 +313,26 @@ def main() -> None:
     )
     ingest_p.add_argument("--json", action="store_true", help="Output structured JSON")
 
+    # V3.4.11: Config get/set (dot-notation)
+    config_p = sub.add_parser(
+        "config",
+        help="Get or set config values (e.g. slm config set evolution.enabled true)",
+    )
+    config_p.add_argument(
+        "action", choices=["get", "set"], help="Action: get or set",
+    )
+    config_p.add_argument("key", help="Config key in dot notation (e.g. evolution.enabled)")
+    config_p.add_argument("value", nargs="?", default=None, help="Value to set (for 'set' action)")
+    config_p.add_argument("--json", action="store_true", help="Output structured JSON")
+
+    # V3.4.11: Skill evolution (called from Stop hook, fire-and-forget)
+    evolve_p = sub.add_parser(
+        "evolve",
+        help="Run post-session skill evolution (internal, called by Stop hook)",
+    )
+    evolve_p.add_argument("--session", default="", help="Session ID to process")
+    evolve_p.add_argument("--profile", default="default", help="Profile ID")
+
     args = parser.parse_args()
 
     if not args.command:
@@ -328,6 +348,7 @@ def main() -> None:
     # Cross-platform: macOS + Windows + Linux.
     _NO_DAEMON_COMMANDS = {
         "setup", "mode", "provider", "connect", "migrate", "mcp", "warmup",
+        "config", "evolve",
     }
     if args.command not in _NO_DAEMON_COMMANDS:
         try:

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: