superlocalmemory 3.3.2__tar.gz → 3.3.6__tar.gz

{superlocalmemory-3.3.2/src/superlocalmemory.egg-info → superlocalmemory-3.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.3.2
+Version: 3.3.6
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: MIT
@@ -72,7 +72,8 @@ Dynamic: license-file
 </p>
 
 <h1 align="center">SuperLocalMemory V3.3</h1>
-<p align="center"><strong>The first local-only AI memory to break 74% retrieval on LoCoMo.<br/>No cloud. No APIs. No data leaves your machine.</strong></p>
+<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.3.6</code> — Install once. Every session remembers the last. Automatically.</p>
 
 <p align="center">
   <code>+16pp vs Mem0 (zero cloud)</code> &nbsp;·&nbsp; <code>85% Open-Domain (best of any system)</code> &nbsp;·&nbsp; <code>EU AI Act Ready</code>

{superlocalmemory-3.3.2 → superlocalmemory-3.3.6}/README.md

@@ -3,7 +3,8 @@
 </p>
 
 <h1 align="center">SuperLocalMemory V3.3</h1>
-<p align="center"><strong>The first local-only AI memory to break 74% retrieval on LoCoMo.<br/>No cloud. No APIs. No data leaves your machine.</strong></p>
+<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.3.6</code> — Install once. Every session remembers the last. Automatically.</p>
 
 <p align="center">
   <code>+16pp vs Mem0 (zero cloud)</code> &nbsp;·&nbsp; <code>85% Open-Domain (best of any system)</code> &nbsp;·&nbsp; <code>EU AI Act Ready</code>

{superlocalmemory-3.3.2 → superlocalmemory-3.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.3.2"
+version = "3.3.6"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "MIT"}
@@ -98,6 +98,10 @@ testpaths = ["tests"]
 pythonpath = ["src"]
 markers = [
     "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+    "ollama: marks tests that require a running Ollama instance",
+]
+filterwarnings = [
+    "ignore::DeprecationWarning:vaderSentiment",
 ]
 
 [tool.coverage.run]

{superlocalmemory-3.3.2 → superlocalmemory-3.3.6}/src/superlocalmemory/cli/commands.py

@@ -18,7 +18,16 @@ from argparse import Namespace
 
 def dispatch(args: Namespace) -> None:
     """Route CLI command to the appropriate handler."""
+    # Auto-install/upgrade hooks on version change (single file read, ~0.1ms)
+    if args.command not in ("hooks", "init", "mcp"):
+        try:
+            from superlocalmemory.hooks.claude_code_hooks import auto_install_if_needed
+            auto_install_if_needed()
+        except Exception:
+            pass
+
     handlers = {
+        "init": cmd_init,
         "setup": cmd_setup,
         "mode": cmd_mode,
         "provider": cmd_provider,
@@ -113,6 +122,10 @@ def cmd_mode(args: Namespace) -> None:
         if (config.embedding.provider != updated.embedding.provider
                 or config.embedding.model_name != updated.embedding.model_name):
             print("  ⚠ Embedding model changed. Re-indexing will run on next recall.")
+
+        # V3.3.4: Warn if Mode C lacks cloud API key
+        if args.value == "c" and not updated.llm.api_key:
+            print("  ⚠ Mode C requires a cloud API key. Run: slm provider set")
     else:
         print(f"Current mode: {config.mode.value.upper()}")
 
@@ -356,12 +369,20 @@ def cmd_forget(args: Namespace) -> None:
             sys.exit(1)
         raise
 
+    dry_run = getattr(args, 'dry_run', False)
+
     if use_json:
         from superlocalmemory.cli.json_output import json_print
         if not matches:
             json_print("forget", data={"matched_count": 0, "deleted_count": 0, "matches": []})
             return
         match_items = [{"fact_id": f.fact_id, "content": f.content[:120]} for f in matches[:20]]
+        if dry_run:
+            json_print("forget", data={
+                "matched_count": len(matches), "deleted_count": 0,
+                "dry_run": True, "matches": match_items,
+            })
+            return
         if getattr(args, 'yes', False):
             for f in matches:
                 engine._db.delete_fact(f.fact_id)
@@ -387,6 +408,9 @@ def cmd_forget(args: Namespace) -> None:
     print(f"Found {len(matches)} matching memories:")
     for f in matches[:10]:
         print(f"  - {f.fact_id[:8]}... {f.content[:80]}")
+    if dry_run:
+        print(f"(dry run — {len(matches)} would be deleted)")
+        return
     if getattr(args, 'yes', False):
         for f in matches:
             engine._db.delete_fact(f.fact_id)
@@ -861,7 +885,8 @@ def cmd_trace(args: Namespace) -> None:
     try:
         config = SLMConfig.load()
         engine = MemoryEngine(config)
-        response = engine.recall(args.query, limit=5)
+        limit = getattr(args, 'limit', 10)
+        response = engine.recall(args.query, limit=limit)
     except Exception as exc:
         if use_json:
             from superlocalmemory.cli.json_output import json_print
@@ -907,6 +932,14 @@ def cmd_trace(args: Namespace) -> None:
 
 def cmd_mcp(_args: Namespace) -> None:
     """Start the V3 MCP server (stdio transport for IDE integration)."""
+    # Auto-install hooks on MCP startup (fast path: ~0.1ms if already current)
+    # CRITICAL: No stdout — MCP uses stdio transport, any print corrupts protocol
+    try:
+        from superlocalmemory.hooks.claude_code_hooks import auto_install_if_needed
+        auto_install_if_needed()
+    except Exception:
+        pass
+
     from superlocalmemory.mcp.server import server
 
     server.run(transport="stdio")
@@ -1126,6 +1159,99 @@ def cmd_profile(args: Namespace) -> None:
 # -- Active Memory commands (V3.1) ------------------------------------------
 
 
+def cmd_init(args: Namespace) -> None:
+    """One-command setup: mode + hooks + IDE connect + warmup."""
+    from pathlib import Path
+    from superlocalmemory.core.config import SLMConfig
+
+    force = getattr(args, "force", False)
+
+    config_exists = (Path.home() / ".superlocalmemory" / "config.json").exists()
+
+    print()
+    print("SuperLocalMemory — One-Time Setup")
+    print("=" * 40)
+
+    # Step 1: Mode selection (interactive)
+    if force or not config_exists:
+        print()
+        from superlocalmemory.cli.setup_wizard import run_wizard
+        run_wizard()
+    else:
+        config = SLMConfig.load()
+        print(f"\n  Already configured: Mode {config.mode.value.upper()}")
+        print(f"  Profile: {config.active_profile}")
+
+    # Step 2: Install hooks (gate always OFF by default)
+    print()
+    print("Installing Claude Code hooks...")
+    from superlocalmemory.hooks.claude_code_hooks import install_hooks, check_status
+
+    status = check_status()
+
+    if status["installed"] and not force:
+        if status["needs_upgrade"]:
+            from superlocalmemory.hooks.claude_code_hooks import upgrade_hooks
+            result = upgrade_hooks()
+            if result.get("upgraded"):
+                print(f"  Hooks upgraded: {result['from_version']} -> {result['to_version']}")
+            else:
+                print(f"  Upgrade issue: {result.get('reason', result.get('errors', ''))}")
+        else:
+            print(f"  Hooks already installed (v{status['version']})")
+    else:
+        result = install_hooks(include_gate=False)
+        if result["success"]:
+            print(f"  Hooks installed: {', '.join(result['hooks_added'])}")
+            print("  SLM: Hooks installed into Claude Code (slm hooks remove to undo)")
+        else:
+            print(f"  Hook install failed: {result['errors']}")
+
+    # Step 3: IDE connection
+    print()
+    print("Detecting IDEs...")
+    try:
+        from superlocalmemory.hooks.ide_connector import IDEConnector
+        connector = IDEConnector()
+        results = connector.connect_all()
+        for ide_id, ide_status in results.items():
+            print(f"  {ide_id}: {ide_status}")
+    except Exception as exc:
+        print(f"  IDE detection skipped: {exc}")
+
+    # Step 4: Warmup (embedding model)
+    print()
+    print("Checking embedding model...")
+    try:
+        from superlocalmemory.core.config import SLMConfig as _Cfg
+        cfg = _Cfg.load()
+        model_name = cfg.embedding.model_name
+        print(f"  Model: {model_name}")
+        # Quick check: try creating embedding service (auto-downloads if needed)
+        from superlocalmemory.core.embeddings import EmbeddingService
+        svc = EmbeddingService(cfg.embedding)
+        test_result = svc.embed_text("test")
+        if test_result is not None and len(test_result) > 0:
+            print("  Status: ready")
+        else:
+            print("  Status: model not available (run: slm warmup)")
+    except Exception as exc:
+        print(f"  Warmup skipped: {exc}")
+        print("  Run 'slm warmup' later to download the embedding model.")
+
+    # Done
+    print()
+    print("=" * 40)
+    print("SLM is active. Your AI now remembers you.")
+    print()
+    print("What happens next:")
+    print("  - Open Claude Code in any project")
+    print("  - SLM auto-injects your memory context")
+    print("  - Decisions, bugs, preferences are captured automatically")
+    print("  - Session summaries saved when you close")
+    print()
+
+
 def cmd_hooks(args: Namespace) -> None:
     """Manage Claude Code hooks for invisible memory injection."""
     from superlocalmemory.hooks.claude_code_hooks import (
@@ -1133,28 +1259,38 @@ def cmd_hooks(args: Namespace) -> None:
     )
 
     action = getattr(args, "action", "status")
+    # Gate is OFF by default. --gate opts in (for brave users).
+    include_gate = getattr(args, "gate", False)
+
     if action == "install":
-        result = install_hooks()
-        if result["scripts"] and result["settings"]:
+        result = install_hooks(include_gate=include_gate)
+        if result["success"]:
             print("SLM hooks installed in Claude Code.")
-            print("Memory context will auto-inject on every new session.")
+            print(f"  Hook types: {', '.join(result['hooks_added'])}")
+            if include_gate:
+                print("  Gate: ON (enforces session_init — experimental)")
+            print("  SLM: Hooks installed into Claude Code (slm hooks remove to undo)")
         else:
-            print(f"Installation incomplete: {result['errors']}")
+            print(f"Installation failed: {result['errors']}")
     elif action == "remove":
         result = remove_hooks()
-        if result["scripts"] and result["settings"]:
+        if result["success"]:
             print("SLM hooks removed from Claude Code.")
         else:
-            print(f"Removal incomplete: {result['errors']}")
+            print(f"Removal failed: {result['errors']}")
     else:
         result = check_status()
         if result["installed"]:
-            print("SLM hooks: INSTALLED")
-            print(f"  Scripts: {result['hooks_dir']}")
-            print("  Claude Code settings: configured")
+            print(f"SLM hooks: INSTALLED (v{result['version']})")
+            print(f"  Hook types: {', '.join(result['hook_types'])}")
+            print(f"  Gate: {'ON' if result['gate_enabled'] else 'OFF'}")
+            if result["needs_upgrade"]:
+                print(f"  Update available: {result['version']} -> {result['latest_version']}")
+                print("  Run: slm hooks install")
         else:
             print("SLM hooks: NOT INSTALLED")
             print("  Run: slm hooks install")
+            print("  Or:  slm init  (full setup)")
 
 
 def cmd_session_context(args: Namespace) -> None:
@@ -1435,6 +1571,7 @@ def cmd_consolidate(args: Namespace) -> None:
 
     use_json = getattr(args, "json", False)
     cognitive = getattr(args, "cognitive", False)
+    dry_run = getattr(args, "dry_run", False)
     profile = getattr(args, "profile", "")
 
     if not cognitive:
@@ -1460,7 +1597,7 @@ def cmd_consolidate(args: Namespace) -> None:
         )
 
         consolidator = CognitiveConsolidator(db=engine._db)
-        result = consolidator.run_pipeline(pid)
+        result = consolidator.run_pipeline(pid, dry_run=dry_run)
     except Exception as exc:
         if use_json:
             from superlocalmemory.cli.json_output import json_print
@@ -1473,7 +1610,7 @@ def cmd_consolidate(args: Namespace) -> None:
     if use_json:
         from superlocalmemory.cli.json_output import json_print
         json_print("consolidate", data={
-            "clusters_found": result.clusters_found,
+            "clusters_processed": result.clusters_processed,
             "blocks_created": result.blocks_created,
             "facts_archived": result.facts_archived,
             "compression_ratio": round(result.compression_ratio, 3),
@@ -1484,7 +1621,7 @@ def cmd_consolidate(args: Namespace) -> None:
         return
 
     print("CCQ Cognitive Consolidation")
-    print(f"  Clusters found:     {result.clusters_found}")
+    print(f"  Clusters processed: {result.clusters_processed}")
     print(f"  Blocks created:     {result.blocks_created}")
     print(f"  Facts archived:     {result.facts_archived}")
     print(f"  Compression ratio:  {result.compression_ratio:.3f}")

{superlocalmemory-3.3.2 → superlocalmemory-3.3.6}/src/superlocalmemory/cli/main.py

@@ -70,6 +70,12 @@ documentation:
 
 def main() -> None:
     """Parse CLI arguments and dispatch to command handlers."""
+    # Fast path: hook invocations bypass argparse entirely (stdlib only, ~30ms)
+    if len(sys.argv) >= 3 and sys.argv[1] == "hook":
+        from superlocalmemory.hooks.hook_handlers import handle_hook
+        handle_hook(sys.argv[2])
+        return
+
     from superlocalmemory.cli.json_output import _get_version
     _ver = _get_version()
 
@@ -85,6 +91,15 @@ def main() -> None:
     sub = parser.add_subparsers(dest="command", title="commands")
 
     # -- Setup & Config ------------------------------------------------
+    init_p = sub.add_parser("init", help="One-command setup: mode + hooks + IDE + warmup")
+    init_p.add_argument(
+        "--force", action="store_true", help="Re-run full setup even if already configured",
+    )
+    init_p.add_argument(
+        "--gate", action="store_true",
+        help="Enable PreToolUse gate (experimental — blocks tools until session_init)",
+    )
+
     sub.add_parser("setup", help="Interactive first-time setup wizard")
 
     mode_p = sub.add_parser("mode", help="Get or set operating mode (a/b/c)")
@@ -123,6 +138,7 @@ def main() -> None:
 
     forget_p = sub.add_parser("forget", help="Delete memories matching a query (fuzzy)")
     forget_p.add_argument("query", help="Query to match for deletion")
+    forget_p.add_argument("--dry-run", action="store_true", default=False, help="Preview matches without deleting")
     forget_p.add_argument("--yes", "-y", action="store_true", help="Skip confirmation prompt")
     forget_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
@@ -151,6 +167,7 @@ def main() -> None:
 
     trace_p = sub.add_parser("trace", help="Recall with per-channel score breakdown")
     trace_p.add_argument("query", help="Search query")
+    trace_p.add_argument("--limit", type=int, default=10, help="Max results (default 10)")
     trace_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
     # -- Diagnostics (continued) ----------------------------------------
@@ -180,6 +197,10 @@ def main() -> None:
         "action", nargs="?", default="status",
         choices=["install", "remove", "status"], help="Action (default: status)",
     )
+    hooks_p.add_argument(
+        "--gate", action="store_true",
+        help="Enable PreToolUse gate (experimental — blocks tools until session_init)",
+    )
 
     ctx_p = sub.add_parser("session-context", help="Print session context (for hooks)")
     ctx_p.add_argument("query", nargs="?", default="", help="Optional context query")
@@ -217,6 +238,10 @@ def main() -> None:
         "--cognitive", action="store_true",
         help="Run CCQ cognitive consolidation",
     )
+    consolidate_p.add_argument(
+        "--dry-run", action="store_true", default=False,
+        help="Preview without applying",
+    )
     consolidate_p.add_argument("--profile", default="", help="Target profile")
     consolidate_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 

{superlocalmemory-3.3.2 → superlocalmemory-3.3.6}/src/superlocalmemory/core/config.py

@@ -612,15 +612,15 @@ class SLMConfig:
 
         rt = data.get("retrieval", {})
         if rt:
-            # V3.3.2 migration: auto-enable ONNX cross-encoder.
-            # Pre-3.3.2 configs had use_cross_encoder=False because the
-            # PyTorch cross-encoder used ~1.5GB RAM. With ONNX backend
-            # (~200MB), it's now safe for all modes. Detect old configs
-            # by the absence of cross_encoder_backend field.
+            # V3.3.2 migration: add ONNX cross-encoder backend field.
+            # Pre-3.3.2 configs lacked cross_encoder_backend. Add it,
+            # but NEVER override an explicit use_cross_encoder setting.
+            # The user's explicit choice always wins.
             if "cross_encoder_backend" not in rt:
-                rt["use_cross_encoder"] = True
-                rt["cross_encoder_model"] = "cross-encoder/ms-marco-MiniLM-L-6-v2"
+                rt.setdefault("cross_encoder_model", "cross-encoder/ms-marco-MiniLM-L-6-v2")
                 rt["cross_encoder_backend"] = "onnx"
+                # Only auto-enable if user didn't explicitly set the field
+                rt.setdefault("use_cross_encoder", True)
             config.retrieval = RetrievalConfig(**{
                 k: v for k, v in rt.items()
                 if k in RetrievalConfig.__dataclass_fields__
@@ -768,6 +768,9 @@ class SLMConfig:
             )
 
         # Mode C — FULL POWER, UNRESTRICTED
+        # Don't carry over local-only providers (ollama) to cloud mode
+        c_provider = llm_provider if llm_provider not in ("ollama", "") else "openrouter"
+        c_model = llm_model if llm_provider not in ("ollama", "") else "anthropic/claude-sonnet-4"
         return cls(
             mode=mode,
             base_dir=_base,
@@ -779,8 +782,8 @@ class SLMConfig:
                 deployment_name=embedding_deployment,
             ),
             llm=LLMConfig(
-                provider=llm_provider or "azure",
-                model=llm_model or "gpt-4.1-mini",
+                provider=c_provider,
+                model=c_model,
                 api_key=llm_api_key,
                 api_base=llm_api_base,
             ),

{superlocalmemory-3.3.2 → superlocalmemory-3.3.6}/src/superlocalmemory/core/maintenance.py

@@ -6,6 +6,7 @@
 
 Periodic batch processing for mathematical layers:
 1. Langevin batch_step on all active facts (self-organization)
+   1a. Backfill: seed uninitialized facts with metadata-aware positions (B+C)
 2. Sheaf batch consistency check on recent facts
 3. Fisher adaptive temperature recalculation
 
@@ -18,15 +19,72 @@ License: MIT
 from __future__ import annotations
 
 import logging
+import math as _math
 from datetime import UTC, datetime, timedelta
 from typing import TYPE_CHECKING
 
+import numpy as np
+
 if TYPE_CHECKING:
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.storage.database import DatabaseManager
 
 logger = logging.getLogger(__name__)
 
+# Backfill constants
+_BACKFILL_BURN_IN_STEPS = 50
+_LANGEVIN_DIM = 8
+_MAX_NORM = 0.99
+
+
+def _compute_equilibrium_radius(
+    access_count: int,
+    age_days: float,
+    importance: float,
+    temperature: float = 0.3,
+    dim: int = 8,
+) -> float:
+    """Compute metadata-aware equilibrium radius (Strategy B).
+
+    Uses the Langevin potential coefficients to estimate where a fact
+    would settle if it had been in the dynamics from the start.
+
+    r_eq ≈ sqrt(T * dim / (2 * effective_alpha))
+    """
+    alpha, beta, gamma, delta = 3.0, 0.8, 0.005, 0.5
+    effective_alpha = (
+        alpha
+        + beta * _math.log(access_count + 1) / 10.0
+        - gamma * min(age_days, 365.0) / 365.0
+        + delta * importance
+    )
+    effective_alpha = max(0.1, effective_alpha)
+    r_eq = _math.sqrt(temperature * dim / (2.0 * effective_alpha))
+    return min(r_eq, _MAX_NORM * 0.95)
+
+
+def _seed_langevin_position(
+    access_count: int,
+    age_days: float,
+    importance: float,
+    temperature: float = 0.3,
+    dim: int = 8,
+) -> list[float]:
+    """Create a metadata-aware initial position (Strategy B).
+
+    Places the fact at the equilibrium radius with a random direction.
+    """
+    r_eq = _compute_equilibrium_radius(
+        access_count, age_days, importance, temperature, dim,
+    )
+    rng = np.random.default_rng()
+    direction = rng.standard_normal(dim)
+    norm = float(np.linalg.norm(direction))
+    if norm < 1e-8:
+        direction = np.ones(dim)
+        norm = float(np.linalg.norm(direction))
+    return (direction / norm * r_eq).tolist()
+
 
 def run_maintenance(
     db: DatabaseManager,
@@ -44,6 +102,7 @@ def run_maintenance(
         Dict of counts: langevin_updated, sheaf_checked, etc.
     """
     counts: dict[str, int] = {
+        "langevin_backfilled": 0,
         "langevin_updated": 0,
         "fisher_coupled": 0,
         "sheaf_checked": 0,
@@ -53,13 +112,60 @@ def run_maintenance(
     if not facts:
         return counts
 
-    # 1. Langevin batch step
+    # 1a. Backfill: seed uninitialized facts with metadata-aware positions (B+C)
+    if config.math.langevin_persist_positions:
+        try:
+            from superlocalmemory.math.langevin import LangevinDynamics
+
+            ld = LangevinDynamics(
+                dim=_LANGEVIN_DIM,
+                dt=config.math.langevin_dt,
+                temperature=config.math.langevin_temperature,
+            )
+
+            backfilled = 0
+            for f in facts:
+                if f.langevin_position is not None:
+                    continue
+                created = datetime.fromisoformat(
+                    f.created_at.replace("Z", "+00:00")
+                ) if f.created_at else datetime.now(UTC)
+                age_days = max(
+                    0.0,
+                    (datetime.now(UTC) - created).total_seconds() / 86400.0,
+                )
+                # Strategy B: metadata-aware seed position
+                position = _seed_langevin_position(
+                    f.access_count, age_days, f.importance,
+                    config.math.langevin_temperature, _LANGEVIN_DIM,
+                )
+                # Strategy C: burn-in from the seeded position
+                for step_i in range(_BACKFILL_BURN_IN_STEPS):
+                    position, _ = ld.step(
+                        position, f.access_count, age_days, f.importance,
+                    )
+                weight = ld.compute_lifecycle_weight(position)
+                lifecycle = ld.get_lifecycle_state(weight).value
+                db.update_fact(f.fact_id, {
+                    "langevin_position": position,
+                    "lifecycle": lifecycle,
+                })
+                f.langevin_position = position  # update in-memory for step 1b
+                backfilled += 1
+
+            counts["langevin_backfilled"] = backfilled
+            if backfilled:
+                logger.info("Langevin backfill: %d facts initialized", backfilled)
+        except Exception as exc:
+            logger.warning("Langevin backfill failed: %s", exc)
+
+    # 1b. Langevin batch step on all positioned facts
     if config.math.langevin_persist_positions:
         try:
             from superlocalmemory.math.langevin import LangevinDynamics
 
             ld = LangevinDynamics(
-                dim=8,
+                dim=_LANGEVIN_DIM,
                 dt=config.math.langevin_dt,
                 temperature=config.math.langevin_temperature,
             )
@@ -165,8 +271,8 @@ def run_maintenance(
             logger.warning("Sheaf maintenance failed: %s", exc)
 
     logger.info(
-        "Maintenance complete: %d Langevin, %d Fisher-coupled, %d Sheaf",
-        counts["langevin_updated"], counts["fisher_coupled"],
-        counts["sheaf_checked"],
+        "Maintenance complete: %d backfilled, %d Langevin, %d Fisher-coupled, %d Sheaf",
+        counts["langevin_backfilled"], counts["langevin_updated"],
+        counts["fisher_coupled"], counts["sheaf_checked"],
     )
     return counts

{superlocalmemory-3.3.2 → superlocalmemory-3.3.6}/src/superlocalmemory/core/store_pipeline.py

@@ -25,6 +25,25 @@ from superlocalmemory.storage.models import (
 
 logger = logging.getLogger(__name__)
 
+# Langevin initialization radius for new facts (ACTIVE zone < 0.3)
+_INIT_LANGEVIN_RADIUS = 0.05
+
+
+def _init_langevin_position(dim: int = 8) -> list[float]:
+    """Initialize Langevin position near origin for a new fact.
+
+    Small random perturbation ensures each fact gets a unique position
+    while staying deep in the ACTIVE zone (radius < 0.3).
+    """
+    import numpy as np
+    rng = np.random.default_rng()
+    direction = rng.standard_normal(dim)
+    norm = float(np.linalg.norm(direction))
+    if norm < 1e-8:
+        direction = np.ones(dim)
+        norm = float(np.linalg.norm(direction))
+    return (direction / norm * _INIT_LANGEVIN_RADIUS).tolist()
+
 
 # ---------------------------------------------------------------------------
 # enrich_fact  (was MemoryEngine._enrich_fact)
@@ -59,6 +78,10 @@ def enrich_fact(
     emotion = tag_emotion(fact.content)
     signal = infer_signal(fact.content)
 
+    # Strategy A: initialize Langevin position near origin (ACTIVE zone).
+    # New facts start as ACTIVE; dynamics will evolve them based on access patterns.
+    langevin_pos = _init_langevin_position(dim=8)
+
     return AtomicFact(
         fact_id=fact.fact_id, memory_id=record.memory_id,
         profile_id=profile_id, content=fact.content,
@@ -73,6 +96,7 @@ def enrich_fact(
         evidence_count=fact.evidence_count,
         source_turn_ids=fact.source_turn_ids, session_id=record.session_id,
         embedding=embedding, fisher_mean=fisher_mean, fisher_variance=fisher_variance,
+        langevin_position=langevin_pos,
         emotional_valence=emotion.valence, emotional_arousal=emotion.arousal,
         signal_type=signal, created_at=fact.created_at,
     )

{superlocalmemory-3.3.2 → superlocalmemory-3.3.6}/src/superlocalmemory/core/worker_pool.py

@@ -142,8 +142,15 @@ class WorkerPool:
     # ------------------------------------------------------------------
 
     def _send(self, request: dict) -> dict:
-        """Send request to worker and get response. Thread-safe."""
-        return self._send_with_timeout(request, timeout=_REQUEST_TIMEOUT)
+        """Send request to worker and get response. Thread-safe.
+
+        Auto-retries once on worker death (idle timeout, crash).
+        """
+        resp = self._send_with_timeout(request, timeout=_REQUEST_TIMEOUT)
+        if not resp.get("ok") and "Worker" in resp.get("error", ""):
+            logger.info("Auto-restarting worker after failure, retrying request")
+            resp = self._send_with_timeout(request, timeout=_REQUEST_TIMEOUT)
+        return resp
 
     def _send_with_timeout(self, request: dict, timeout: float) -> dict:
         """Send request with configurable timeout. Thread-safe."""