superlocalmemory 3.4.57__tar.gz → 3.5.0__tar.gz

{superlocalmemory-3.4.57/src/superlocalmemory.egg-info → superlocalmemory-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.57
+Version: 3.5.0
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later
@@ -69,6 +69,8 @@ Provides-Extra: ui
 Requires-Dist: fastapi[all]>=0.135.1; extra == "ui"
 Requires-Dist: uvicorn>=0.42.0; extra == "ui"
 Requires-Dist: python-multipart<1.0.0,>=0.0.6; extra == "ui"
+Provides-Extra: injection
+Requires-Dist: tiktoken>=0.8.0; extra == "injection"
 Provides-Extra: learning
 Requires-Dist: lightgbm>=4.0.0; extra == "learning"
 Provides-Extra: performance
@@ -79,7 +81,7 @@ Requires-Dist: google-auth-oauthlib>=1.2.0; extra == "ingestion"
 Requires-Dist: google-api-python-client>=2.100.0; extra == "ingestion"
 Requires-Dist: icalendar>=6.0.0; extra == "ingestion"
 Provides-Extra: full
-Requires-Dist: superlocalmemory[ingestion,learning,performance,search,ui]; extra == "full"
+Requires-Dist: superlocalmemory[ingestion,injection,learning,performance,search,ui]; extra == "full"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1; extra == "dev"

{superlocalmemory-3.4.57 → superlocalmemory-3.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.57"
+version = "3.5.0"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}
@@ -89,6 +89,9 @@ ui = [
     "uvicorn>=0.42.0",
     "python-multipart>=0.0.6,<1.0.0",
 ]
+injection = [
+    "tiktoken>=0.8.0",
+]
 learning = [
     "lightgbm>=4.0.0",
 ]
@@ -102,7 +105,7 @@ ingestion = [
     "icalendar>=6.0.0",
 ]
 full = [
-    "superlocalmemory[search,ui,learning,performance,ingestion]",
+    "superlocalmemory[search,ui,learning,performance,ingestion,injection]",
 ]
 dev = [
     "pytest>=8.0",

superlocalmemory-3.5.0/src/superlocalmemory/__init__.py

@@ -0,0 +1,65 @@
+"""SuperLocalMemory — information-geometric agent memory."""
+
+import os
+
+# --- OpenMP multi-library guard (permanent fix, v3.4.58) -------------------
+# SLM ships with torch, scikit-learn, and lightgbm — each bundles its own
+# libomp.dylib on macOS ARM (Apple Silicon). When all three are loaded in the
+# same process, the Intel OpenMP runtime detects duplicate libraries and either
+# (a) emits OMP: Error #15 and aborts, or (b) crashes with SIGSEGV in
+# __kmp_suspend_initialize_thread (address 0x580 — null thread-struct deref)
+# when LightGBM's parallel fork tries to coordinate with PyTorch's thread pool.
+#
+# KMP_DUPLICATE_LIB_OK=TRUE tells the runtime to elect one master instance
+# and continue rather than abort. This is the upstream-recommended workaround
+# for mixed-dependency environments (PyTorch docs, scikit-learn FAQ, LightGBM
+# issue #3877). Use unconditional assignment — not setdefault — so user env
+# cannot accidentally disable this safety net by setting it to FALSE.
+#
+# OMP_NUM_THREADS=2 caps the maximum thread count before any C library reads
+# it. With ≤2 threads the problematic parallel fork path in LightGBM's
+# DatasetLoader::ConstructFromSampleData is avoided on all observed crash
+# configurations. SLM datasets are small (50–5 000 rows); 2 threads gives
+# ~90% of the performance of max-core training at zero crash risk.
+# Users who need more threads can set SLM_LGBM_THREADS=N to override
+# the per-call cap in ranker_retrain_online.py.
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+if "OMP_NUM_THREADS" not in os.environ:
+    os.environ["OMP_NUM_THREADS"] = "2"
+# ---------------------------------------------------------------------------
+
+__version__ = "3.4.64"
+
+_REQUIRED_VERSIONS = {
+    "sentence_transformers": "5.3.0",
+    "onnxruntime": "1.24.4",
+}
+
+
+def _check_critical_deps() -> None:
+    """Warn if embedding-critical packages have wrong versions."""
+    import warnings
+    for mod_name, expected in _REQUIRED_VERSIONS.items():
+        try:
+            mod = __import__(mod_name)
+            actual = getattr(mod, "__version__", None)
+            if actual and actual != expected:
+                warnings.warn(
+                    f"SuperLocalMemory requires {mod_name}=={expected} but "
+                    f"{actual} is installed. This causes memory blow-up on "
+                    f"Apple Silicon. Fix: pip install {mod_name}=={expected}",
+                    stacklevel=2,
+                )
+        except ImportError:
+            pass
+
+
+# Only run the dep check when a full (non-LIGHT) engine is in use.
+# The MCP server runs in LIGHT mode — importing onnxruntime here
+# breaks the LIGHT engine contract (ONNX_LOADED must stay False).
+# Skip when SLM_SKIP_DEP_CHECK=1 or SLM_DISABLE_WARMUP_SIDE_EFFECTS=1.
+if not (
+    os.environ.get("SLM_SKIP_DEP_CHECK") == "1"
+    or os.environ.get("SLM_DISABLE_WARMUP_SIDE_EFFECTS") == "1"
+):
+    _check_critical_deps()

{superlocalmemory-3.4.57 → superlocalmemory-3.5.0}/src/superlocalmemory/cli/commands.py

@@ -2067,14 +2067,18 @@ def cmd_session_context(args: Namespace) -> None:
     This ensures the SessionStart hook completes within its 15s timeout even
     when Ollama requires a 60s+ cold start.  The fast path returns:
       - Core Memory blocks (always-on context)
-      - Recent high-importance memories (last 7 days)
+      - Recent high-importance memories (last N days)
       - Session summary from last session
     Falls back to the full engine path only if --full is passed explicitly.
+
+    v3.4.65: uses shared injection formatter (render_context) for identical
+    output across MCP and CLI surfaces. --json flag returns structured JSON.
     """
     import sqlite3
     from pathlib import Path
     from superlocalmemory.core.config import SLMConfig
 
+    use_json = getattr(args, "json", False)
     use_full = getattr(args, "full", False)
 
     if use_full:
@@ -2093,13 +2097,21 @@ def cmd_session_context(args: Namespace) -> None:
                 query=getattr(args, "query", "") or "recent decisions and important context",
             )
             if context:
-                print(context)
+                if use_json:
+                    from superlocalmemory.cli.json_output import json_print
+                    json_print("session-context", data={"context": context}, next_actions=[
+                        {"command": "slm recall --json <query>", "description": "Search memories"},
+                    ])
+                else:
+                    print(context)
         except Exception as exc:
             logger.debug("session-context (full) failed: %s", exc)
         return
 
     # ── FAST PATH: direct SQLite, no engine, <500ms ──────────────
     try:
+        from superlocalmemory.core.injection import InjectableMemory, render_context
+
         config = SLMConfig.load()
         db_path = config.base_dir / "memory.db"
         if not db_path.exists():
@@ -2108,78 +2120,113 @@ def cmd_session_context(args: Namespace) -> None:
         pid = config.active_profile
         conn = sqlite3.connect(str(db_path))
         conn.row_factory = sqlite3.Row
-        sections = []
 
-        # 1. Core Memory blocks (compiled high-value context)
+        # Collect facts for injection — same queries as pre-v3.4.65 but
+        # mapped into InjectableMemory for the shared formatter.
+        inj_mems: list[InjectableMemory] = []
+
+        # Core Memory blocks (compiled high-value context)
         try:
-            rows = conn.execute(
+            cm_rows = conn.execute(
                 "SELECT block_type, content FROM core_memory_blocks "
                 "WHERE profile_id = ? ORDER BY block_type",
                 (pid,),
             ).fetchall()
-            if rows:
-                blocks = [f"[{r['block_type']}] {r['content']}" for r in rows]
-                sections.append("## Core Memory\n" + "\n".join(blocks))
+            for r in cm_rows:
+                content = f"[{r['block_type']}] {r['content']}"
+                inj_mems.append(InjectableMemory(
+                    content=content, score=1.0, fact_id="",
+                    importance=1.0, access_count=10,
+                    pinned=True,
+                ))
         except sqlite3.OperationalError:
             pass
 
-        # 2. Recent important memories — age gate from --max-age-days (default 30)
+        # Recent important memories — age gate from --max-age-days (default 30)
         max_age = getattr(args, "max_age_days", 30)
         age_clause = (
             f"AND created_at >= datetime('now', '-{int(max_age)} days') "
             if max_age > 0 else ""
         )
         try:
-            rows = conn.execute(
-                "SELECT content, fact_type, created_at FROM atomic_facts "
+            fact_rows = conn.execute(
+                "SELECT fact_id, content, importance, access_count, fact_type FROM atomic_facts "
                 "WHERE profile_id = ? "
                 f"{age_clause}"
                 "AND lifecycle = 'active' "
                 "ORDER BY importance DESC, created_at DESC LIMIT 10",
                 (pid,),
             ).fetchall()
-            if rows:
-                items = []
-                for r in rows:
-                    content = r["content"][:200]
-                    items.append(f"- [{r['fact_type'] or 'fact'}] {content}")
-                sections.append("## Recent Context (7 days)\n" + "\n".join(items))
+            for r in fact_rows:
+                inj_mems.append(InjectableMemory(
+                    content=r["content"],
+                    score=r["importance"] or 0.5,
+                    fact_id=r["fact_id"],
+                    importance=r["importance"] or 0.0,
+                    access_count=r["access_count"] or 0,
+                ))
         except sqlite3.OperationalError:
             pass
 
-        # 3. Session markers (last session summary)
+        # Session markers (last session summary)
         try:
-            rows = conn.execute(
-                "SELECT content, created_at FROM atomic_facts "
+            sess_rows = conn.execute(
+                "SELECT fact_id, content, importance, access_count FROM atomic_facts "
                 "WHERE profile_id = ? AND content LIKE 'Session%' "
                 "ORDER BY created_at DESC LIMIT 3",
                 (pid,),
             ).fetchall()
-            if rows:
-                items = [f"- {r['content'][:150]}" for r in rows]
-                sections.append("## Recent Sessions\n" + "\n".join(items))
+            for r in sess_rows:
+                inj_mems.append(InjectableMemory(
+                    content=r["content"],
+                    score=r["importance"] or 0.3,
+                    fact_id=r["fact_id"],
+                    importance=r["importance"] or 0.0,
+                    access_count=r["access_count"] or 0,
+                ))
         except sqlite3.OperationalError:
             pass
 
-        # 4. V3.3 Soft prompts (auto-learned patterns)
+        conn.close()
+
+        if not inj_mems:
+            return
+
+        # V3.3 Soft prompts (auto-learned patterns) — append as high-importance
         try:
-            rows = conn.execute(
+            conn2 = sqlite3.connect(str(db_path))
+            conn2.row_factory = sqlite3.Row
+            sp_rows = conn2.execute(
                 "SELECT category, content FROM soft_prompt_templates "
                 "WHERE profile_id = ? AND active = 1 "
                 "ORDER BY confidence DESC LIMIT 5",
                 (pid,),
             ).fetchall()
-            if rows:
-                items = [f"- [{r['category']}] {r['content'][:150]}" for r in rows]
-                sections.append("## Learned Patterns\n" + "\n".join(items))
-        except sqlite3.OperationalError:
+            conn2.close()
+            for r in sp_rows:
+                inj_mems.append(InjectableMemory(
+                    content=f"[{r['category']}] {r['content']}",
+                    score=0.7, fact_id="",
+                    importance=0.7, access_count=5,
+                ))
+        except Exception:
             pass
 
-        conn.close()
+        cfg_inj = getattr(config, "injection", None)
+        context = render_context(inj_mems, mode=config.mode.value.upper(), cfg=cfg_inj, wrap=True)
+        if context:
+            if use_json:
+                from superlocalmemory.cli.json_output import json_print
+                json_print("session-context", data={
+                    "context": context,
+                    "memory_count": len(inj_mems),
+                    "mode": config.mode.value.upper(),
+                }, next_actions=[
+                    {"command": "slm recall --json <query>", "description": "Search memories"},
+                ])
+            else:
+                print(context)
 
-        if sections:
-            header = f"# SLM Session Context — {config.active_profile}"
-            print(header + "\n\n" + "\n\n".join(sections))
     except Exception as exc:
         logger.debug("session-context (fast) failed: %s", exc)
 

{superlocalmemory-3.4.57 → superlocalmemory-3.5.0}/src/superlocalmemory/cli/daemon.py

@@ -171,6 +171,17 @@ def _start_daemon_subprocess() -> bool:
     else:
         kwargs["start_new_session"] = True
 
+    # v3.4.60: Force OMP_NUM_THREADS=1 in daemon env BEFORE Python imports
+    # numpy/torch/lightgbm. Setting it in __init__.py is too late on M5 Pro —
+    # by the time superlocalmemory.__init__ runs, libomp has already been
+    # initialized by an earlier import, causing the SIGSEGV at
+    # __kmp_suspend_initialize_thread when lightgbm forks its worker pool.
+    # Forcing serial OpenMP eliminates the parallel barrier race entirely.
+    daemon_env = os.environ.copy()
+    daemon_env["OMP_NUM_THREADS"] = "1"
+    daemon_env["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+    kwargs["env"] = daemon_env
+
     with open(log_file, "a") as lf:
         proc = subprocess.Popen(cmd, stdout=lf, stderr=lf, **kwargs)
 
@@ -523,8 +534,10 @@ class DaemonHandler(BaseHTTPRequestHandler):
                     session_id = f"http:{int(_t.time() * 1000)}"
 
                 engine = _get_engine()
+                raw_fast = params.get("fast", ["false"])[0]
+                fast = raw_fast.lower() in ("true", "1")
                 response = engine.recall(
-                    query, limit=limit, session_id=session_id,
+                    query, limit=limit, session_id=session_id, fast=fast,
                 )
                 # Return the same field shape as recall_worker._handle_recall,
                 # so MCP processes that proxy through the daemon get recall_trace-

{superlocalmemory-3.4.57 → superlocalmemory-3.5.0}/src/superlocalmemory/cli/main.py

@@ -136,7 +136,7 @@ def main() -> None:
 
     mode_p = sub.add_parser("mode", help="Get or set operating mode (a/b/c)")
     mode_p.add_argument(
-        "value", nargs="?", choices=["a", "b", "c"], help="Mode to set",
+        "value", nargs="?", choices=["a", "b", "c", "A", "B", "C"], help="Mode to set",
     )
     mode_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 

{superlocalmemory-3.4.57 → superlocalmemory-3.5.0}/src/superlocalmemory/core/backend_orchestrator.py

@@ -62,7 +62,7 @@ class BackendOrchestrator:
     def __init__(self, config: SLMConfig, db: DatabaseManager) -> None:
         self._config = config
         self._db = db
-        self._data_dir = Path(config.data_dir)
+        self._data_dir = Path(getattr(config, "data_dir", None) or config.base_dir)
         self._cozo: Any = None
         self._lancedb: Any = None
         self._tiers: Any = None
@@ -236,22 +236,28 @@ class BackendOrchestrator:
     # ------------------------------------------------------------------
 
     def _detect_cozo(self) -> bool:
-        if self._config.get("graph_backend") == "sqlite":
-            return False
-        try:
-            import pycozo  # noqa: F401
-            return True
-        except ImportError:
+        gb = getattr(self._config, "graph_backend", "auto") or "auto"
+        if gb == "sqlite":
             return False
+        if gb in ("auto", "cozo"):
+            try:
+                import pycozo  # noqa: F401
+                return True
+            except ImportError:
+                return False
+        return False
 
     def _detect_lancedb(self) -> bool:
-        if self._config.get("vector_backend") == "sqlite-vec":
-            return False
-        try:
-            import lancedb  # noqa: F401
-            return True
-        except ImportError:
+        vb = getattr(self._config, "vector_backend", "auto") or "auto"
+        if vb == "sqlite-vec":
             return False
+        if vb in ("auto", "lancedb"):
+            try:
+                import lancedb  # noqa: F401
+                return True
+            except ImportError:
+                return False
+        return False
 
     # ------------------------------------------------------------------
     # Internal: Init

{superlocalmemory-3.4.57 → superlocalmemory-3.5.0}/src/superlocalmemory/core/config.py

@@ -233,6 +233,50 @@ class MathConfig:
     # Rate-Distortion (production only, disabled for benchmarks)
 
 
+# ---------------------------------------------------------------------------
+# Context Injection (v3.4.65)
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class InjectionConfig:
+    """Context-injection budgets & framing (v3.4.65).
+
+    Single source of truth for what reaches the agent at session_init,
+    prestage_context, and the recall hooks. Replaces scattered char caps.
+
+    Budgets are in *estimated tokens* (chars/4 heuristic; see
+    core/injection.estimate_tokens). Mode-aware: A=fast/cheap, C=rich.
+    """
+    enabled: bool = True
+
+    # Mode-aware TOTAL budget (core block + recall), in estimated tokens.
+    total_budget_tokens_a: int = 2000
+    total_budget_tokens_b: int = 4000
+    total_budget_tokens_c: int = 8000
+
+    # Per-memory ceiling (estimated tokens). Whole-memory inclusion until
+    # the total budget is hit; this only clamps a single oversized memory.
+    per_memory_max_tokens: int = 600
+
+    # Core Memory Block (Letta pattern).
+    core_block_enabled: bool = True
+    core_block_max_facts: int = 5
+    core_block_max_tokens: int = 1000
+    core_block_importance_min: float = 0.8
+    core_block_min_access_count: int = 2
+
+    # Lost-in-the-middle: place strongest at top & bottom edges.
+    edge_ordering: bool = True
+
+    # Trust framing. False (shipped) = cautious "reference only" wrapper.
+    # True (Varun personal) = clean "memory context" framing.
+    # redact_secrets ALWAYS runs regardless.
+    trust_first_party: bool = False
+
+    # prestage_context response byte cap (was hardcoded 16 KB).
+    prestage_max_response_bytes: int = 64 * 1024
+
+
 # ---------------------------------------------------------------------------
 # Master Config
 # ---------------------------------------------------------------------------
@@ -613,6 +657,10 @@ class SLMConfig:
     parameterization: ParameterizationConfig = field(
         default_factory=ParameterizationConfig,
     )
+    injection: InjectionConfig = field(default_factory=InjectionConfig)
+    # v3.5.0: scaling backends — "sqlite" / "cozo" / "auto" / "lancedb" / "sqlite-vec" / "auto".
+    graph_backend: str = "auto"       # "auto" = cozo if pycozo installed, else sqlite
+    vector_backend: str = "auto"      # "auto" = lancedb if installed, else sqlite-vec
     evolution: EvolutionConfig = field(default_factory=EvolutionConfig)
 
     # v3.4.3: Daemon configuration
@@ -701,6 +749,24 @@ class SLMConfig:
                 if k in EvolutionConfig.__dataclass_fields__
             })
 
+        # V3.4.65: Injection config (additive — defaults if missing from JSON)
+        inj = data.get("injection", {}) or {}
+        config.injection = InjectionConfig(
+            enabled=bool(inj.get("enabled", True)),
+            total_budget_tokens_a=int(inj.get("total_budget_tokens_a", 2000)),
+            total_budget_tokens_b=int(inj.get("total_budget_tokens_b", 4000)),
+            total_budget_tokens_c=int(inj.get("total_budget_tokens_c", 8000)),
+            per_memory_max_tokens=int(inj.get("per_memory_max_tokens", 600)),
+            core_block_enabled=bool(inj.get("core_block_enabled", True)),
+            core_block_max_facts=int(inj.get("core_block_max_facts", 5)),
+            core_block_max_tokens=int(inj.get("core_block_max_tokens", 1000)),
+            core_block_importance_min=float(inj.get("core_block_importance_min", 0.8)),
+            core_block_min_access_count=int(inj.get("core_block_min_access_count", 2)),
+            edge_ordering=bool(inj.get("edge_ordering", True)),
+            trust_first_party=bool(inj.get("trust_first_party", False)),
+            prestage_max_response_bytes=int(inj.get("prestage_max_response_bytes", 64 * 1024)),
+        )
+
         return config
 
     def save(
@@ -775,6 +841,23 @@ class SLMConfig:
             "max_evolutions_per_cycle": self.evolution.max_evolutions_per_cycle,
         }
 
+        # V3.4.65: Persist injection config
+        data["injection"] = {
+            "enabled": self.injection.enabled,
+            "total_budget_tokens_a": self.injection.total_budget_tokens_a,
+            "total_budget_tokens_b": self.injection.total_budget_tokens_b,
+            "total_budget_tokens_c": self.injection.total_budget_tokens_c,
+            "per_memory_max_tokens": self.injection.per_memory_max_tokens,
+            "core_block_enabled": self.injection.core_block_enabled,
+            "core_block_max_facts": self.injection.core_block_max_facts,
+            "core_block_max_tokens": self.injection.core_block_max_tokens,
+            "core_block_importance_min": self.injection.core_block_importance_min,
+            "core_block_min_access_count": self.injection.core_block_min_access_count,
+            "edge_ordering": self.injection.edge_ordering,
+            "trust_first_party": self.injection.trust_first_party,
+            "prestage_max_response_bytes": self.injection.prestage_max_response_bytes,
+        }
+
         # 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:
@@ -1000,80 +1083,87 @@ class SLMConfig:
         new_mode: str,
         base_dir: Path | None = None,
     ) -> "SLMConfig":
-        """Switch to a different mode, preserving the old mode's config.
-
-        v3.4.54: Saves the current config as ``mode_{old}.json``, then
-        loads ``mode_{new}.json`` (or creates it from defaults if it
-        doesn't exist). Writes ``current_mode`` and persists the new
-        active config as ``config.json`` for backward compatibility
-        with tooling that reads it directly.
+        """Switch to a different mode, preserving ALL non-mode settings.
+
+        v3.4.58 fix: Only ``config.mode`` changes. The previous implementation
+        called ``for_mode()`` (which resets embedding/LLM/retrieval to mode
+        defaults) whenever the target mode's per-mode file didn't exist.
+        This silently clobbered custom embeddings, endpoints, and LLM config.
+
+        Correct behavior:
+          - Load the current (old) config from config.json.
+          - Save it to mode_{old}.json for the 3-mode system.
+          - If mode_{new}.json exists, load it (user had a prior config for that mode).
+          - If mode_{new}.json does NOT exist: start from the OLD config, change
+            only the mode field. This preserves embedding, retrieval, forgetting, etc.
+          - Exception: if user has NO LLM provider AND is switching to B/C, populate
+            sensible LLM defaults so the daemon doesn't start dead.
+          - Write the result to config.json (backward compat) and current_mode.
 
         Returns the new active config.
         """
+        import copy
+        import dataclasses
+
         from superlocalmemory.storage.models import Mode as _M
         _base = base_dir or DEFAULT_BASE_DIR
         _base.mkdir(parents=True, exist_ok=True)
 
         old_config = cls.load(_base / "config.json")
         old_mode = old_config.mode.value.lower()
-
         new_mode_val = _M(new_mode.lower())
 
-        # 1. Save current config to its per-mode file (unless already
-        #    matched — prevents overwriting user customizations)
+        # 1. Save current config to its per-mode file (preserve customizations)
         if old_mode != new_mode.lower():
             old_path = cls._mode_config_path(_base, old_config.mode)
             old_config.save(old_path)
 
-        # 2. Try to load the target mode's saved config.
+        # 2. Determine new config:
+        #    a) mode_{new}.json exists → user had prior config for this mode, use it
+        #    b) otherwise → copy old config, change only mode
         new_path = cls._mode_config_path(_base, new_mode_val)
-        need_migration = False
         if new_path.exists():
             try:
                 new_config = cls.load(new_path)
-                # Ensure the loaded config actually has the right mode
                 if new_config.mode != new_mode_val:
-                    new_config = cls.for_mode(new_mode_val, base_dir=_base)
+                    # Corrupt/mismatched mode file — rebuild preserving old values
+                    new_config = copy.copy(old_config)
+                    new_config.mode = new_mode_val
             except Exception:
-                new_config = cls.for_mode(new_mode_val, base_dir=_base)
+                new_config = copy.copy(old_config)
+                new_config.mode = new_mode_val
         else:
-            # First time switching to this mode: try migrating from
-            # legacy config.json if it was already in this mode
-            legacy = _base / "config.json"
-            if legacy.exists():
-                try:
-                    import json
-                    _data = json.loads(legacy.read_text(encoding="utf-8"))
-                    _legacy_mode = _data.get("mode", "").lower()
-                    if _legacy_mode == new_mode.lower():
-                        # config.json IS this mode — use it directly
-                        new_config = cls.load(legacy)
-                        need_migration = True
-                    else:
-                        new_config = cls.for_mode(new_mode_val, base_dir=_base)
-                except Exception:
-                    new_config = cls.for_mode(new_mode_val, base_dir=_base)
-            else:
-                new_config = cls.for_mode(new_mode_val, base_dir=_base)
+            # First time switching to this mode: start from old config, change mode only.
+            # Use dataclasses.replace() to produce a new frozen-compatible object.
+            new_config = dataclasses.replace(old_config, mode=new_mode_val)
+
+        # 3. LLM default population — ONLY if user has no provider AND switching to B/C.
+        #    Never overwrites an existing provider.
+        if new_mode_val in (_M.B, _M.C) and not new_config.llm.provider:
+            if new_mode_val == _M.B:
+                new_config = dataclasses.replace(
+                    new_config,
+                    llm=LLMConfig(
+                        provider="ollama",
+                        model="llama3.2",
+                        api_base="http://localhost:11434",
+                    ),
+                )
+            else:  # Mode C
+                new_config = dataclasses.replace(
+                    new_config,
+                    llm=LLMConfig(
+                        provider="openrouter",
+                        model="anthropic/claude-sonnet-4",
+                    ),
+                )
 
-        # 3. Save as active config.json (backward compat)
+        # 4. Save as active config.json (backward compat)
         new_config.save(_base / "config.json", mode_change=True)
 
-        # 4. Write current_mode
+        # 5. Write current_mode
         cls.write_current_mode(new_mode, _base)
 
-        # 5. On first migration, also save mode_a.json and mode_c.json
-        #    so users have a complete set
-        if need_migration:
-            for _m in (_M.A, _M.B, _M.C):
-                _mp = cls._mode_config_path(_base, _m)
-                if not _mp.exists():
-                    try:
-                        _mc = cls.for_mode(_m, base_dir=_base)
-                        _mc.save(_mp)
-                    except Exception:
-                        pass
-
         return new_config
 
     @classmethod