superlocalmemory 3.6.8 → 3.6.10

package/CHANGELOG.md

@@ -5,6 +5,89 @@ All notable changes to SuperLocalMemory V3 will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.6.10] - 2026-06-14 — Optimize correctness (cache + lossless compression) · MCP per-agent identity · runtime toggles · benchmark + shadow-capture · Issue #38
+
+This release makes the **Optimize** subsystem (the HTTP proxy that caches and compresses LLM API calls) correct, observable, and **independently controllable at runtime**, adds **per-agent identity** to the HTTP MCP transport, ships a **benchmark + shadow-capture** harness that proves the cache and compression behaviour, and fixes GitHub issue #38. Cache and compression remain **default-OFF** and are now separately toggleable from the dashboard.
+
+### Added — Independent runtime control of cache vs compression
+
+- **Cache and compression are separate switches**, both live at runtime from the dashboard — enable caching only, compression only, both, or neither, without restarting the daemon. The config watchdog rebuilds the proxy hook chain in place on change.
+
+### Added — MCP per-agent identity over HTTP (`/mcp/{agent_id}`)
+
+- **Per-agent attribution without per-agent processes.** The HTTP MCP endpoint accepts an agent-id path segment — `http://127.0.0.1:8765/mcp/claude`, `/mcp/hermes`, `/mcp/gemini`, etc. The daemon extracts it (root_path-aware ASGI wrapper) into a per-request `ContextVar`, so `remember`, `recall`, `observe`, `delete_memory`, `update_memory`, `session_init`, and event emission all tag the correct agent. Many agents share one daemon instead of one `slm mcp` stdio process each. Bare `/mcp/` is unchanged → default `mcp_client` (backward compatible). Precedence: URL path → `SLM_AGENT_ID` env (stdio) → `mcp_client`. URL agent-ids are sanitized (charset-restricted, 64-char cap). See `docs/distributed-deployment.md`.
+
+### Added — Benchmark + shadow-capture (`benchmarks/optimize/`)
+
+- **Correctness benchmark** drives the shipped cache + compression code: exact-cache replay is 100% hit + byte-identical, exact false-hit rate is **0** (the wrong-answer guard), semantic-tier wiring honours its threshold, and safe-mode compression is **lossless** for JSON/code/prose (code forwarded unchanged). Enforced in CI by `tests/optimize/test_benchmark.py`.
+- **Shadow-capture mode** (`SLM_OPTIMIZE_CAPTURE=1`): pure-passthrough proxy records real `{request, response, model, tokens, content_type}` exchanges to `~/.superlocalmemory/optimize_capture.jsonl` (0600, `O_NOFOLLOW`, git-ignored, 1 MB/side cap, secrets never recorded) for replay into the benchmark. No cache/compress while capturing.
+
+### Changed — Compression rebuilt on a research-backed layered design
+
+- **Removed the homegrown extractive JSON/code compressors** (they truncated JSON strings, capped arrays, and stubbed code bodies — lossy and unsafe). Safe mode is now **lossless** (whitespace + compact-JSON normalization only; code untouched). Aggressive mode adds **LLMLingua-2** (`microsoft/llmlingua-2-xlm-roberta-large-meetingbank`) for **prose only** — never code, numbers, structured data, instructions, or the current turn. Dead `compress_json`/`compress_code` toggles removed.
+
+### Fixed — Cache correctness & observability
+
+- **Semantic cache tier is now wired** into the proxy `get/check/set` path (was dead code); default-off, conservative 0.98 return threshold, benchmarked false-hit guard. See `docs/optimize-config.md` for threshold-tuning guidance.
+- **Token accounting corrected** — input tokens (the biggest save) and real output tokens are now counted on cache hits instead of 0/estimates.
+- **Cache survives machine-id changes** — the AES-GCM key/salt is persisted (0600), fixing the total-miss after VM clone / container / OS reinstall.
+- **UI opt-in is real** — a `proxy_enabled` toggle now actually mounts the proxy.
+
+### Fixed — Issue #38 (frontend)
+
+- **Brain page no longer stuck on "Couldn't load Brain"** on a healthy backend — pane activation fires `fetchBrain` and reads the install token from the same source as the working endpoints.
+- **"Test Connection" no longer 401s on an empty API key** in no-auth (Mode B) — when the key is empty no `Authorization` header is sent.
+
+### Security (v3.6.10 audit, Stage 8/9)
+
+- Capture file: `O_NOFOLLOW` + unconditional `0600` (symlink-append + TOCTOU closed); in-memory stream accumulator bounded (CWE-400); synchronous capture writes offloaded off the event loop; `extract_usage` uses an explicit provider allowlist (no silent mis-parse). URL agent-ids sanitized at the single extraction chokepoint.
+
+## [3.6.9] - 2026-06-11 — Full 7-layer recall quality · event-loop safety · health watchdog
+
+This release fixes seven GitHub issues, one critical production incident, five post-implementation audit bugs, and two event-loop deadlocks introduced in v3.6.7. All 7 retrieval layers (semantic, BM25, temporal, spreading activation, Hopfield, entity graph, cross-encoder reranker) now operate at full designed quality with no capability tradeoffs.
+
+### Fixed — Production incident
+
+- **BUG-A (CRITICAL): Health monitor RSS watchdog no longer kills the embedding worker.** On machines with <16 GB RAM the hardcoded 2500 MB budget caused the watchdog to kill the ~1 GB ONNX embedding worker during recall bursts. Semantic channel silently scored 0.0, recall fell back to keyword-only FTS5/BM25 ("DEGRADED MODE"), and the v3.6.8 health monitor reported false-healthy because it checked worker liveness rather than semantic signal quality. Fixed by: (1) defaulting the budget to 40% of physical RAM (floor 2500 MB) with `SLM_RSS_BUDGET_MB` env override; (2) protecting the embedder from the kill list — the reranker is targeted first as it can be recreated without losing recall quality; (3) adding `HealthConfig` dataclass and `SLMConfig.load()` parsing so `config.json` `"health"` keys now actually take effect.
+
+### Fixed — GitHub issues
+
+- **#34: Mesh tools no longer deadlock the daemon.** All 8 async mesh MCP tools called blocking `urllib.urlopen` loopback HTTP against the daemon's own `/mcp` endpoint introduced in v3.6.7. From inside the event loop this self-deadlocked uvicorn's single-thread executor, causing a graceful-shutdown timeout that killed the daemon. All 8 call sites wrapped in `asyncio.to_thread`. MCP lifespan hardened so a tool-level exception cannot propagate to uvicorn's shutdown handler. `heartbeat_active` and `registered` return live state instead of hardcoded literals.
+- **#35: `session_init` now returns a `session_id`.** Three spots fixed: (1) `tools_active.py` — `session_init` now passes `session_id` through to callers; (2) `engine.py` `store_fast` — lifts `session_id` from metadata onto the `MemoryRecord` row so facts are correctly attributed to sessions; (3) `close_session` — queries the DB for the most recent session instead of chasing a phantom `_last_session_id` that was never assigned, and `summary_events_created` now returns real counts.
+- **#36-1: HTTP MCP now reachable from LAN hosts.** The new `SLM_MCP_ALLOWED_HOSTS` env (opt-in, default localhost-only) overrides FastMCP's DNS-rebinding protection that rejected non-`127.0.0.1` `Host` headers on LAN deployments. Accepts comma-separated `host:port*` patterns or `*`. Security default is unchanged — the endpoint stays localhost-only without explicit opt-in.
+- **#36-2: `slm mcp` and the HTTP daemon no longer race for port 8765.** `ensure_daemon` now checks TCP connectivity in addition to PID file + HTTP health, detecting systemd-started daemons mid-startup before attempting a second bind. `SLM_DAEMON_PORT` is now fully wired end-to-end (previously only read in `commands.py` URL construction, ignored in the actual uvicorn bind and `_start_daemon_subprocess`). Wrapped in `try/except ValueError` so a malformed env value fails with a clear message rather than a silent zero-port bind.
+- **#33 + #37: Environment variable reference table published.** All ~90 `SLM_*` variables documented in `docs/distributed-deployment.md` with type, default, scope, and example. Closes both issues.
+- **#32: Python version requirement corrected.** Docs previously stated "3.10 or later" — the codebase enforces 3.11+. Updated `getting-started.md`, added Ubuntu 22.04 deadsnakes install path and a new `docs/install-linux.md`.
+
+### Fixed — Event-loop blocking (post-v3.6.7 audit)
+
+The v3.6.7 in-process HTTP MCP transport changed the execution context of all MCP tools from stdio subprocess threads to async event-loop coroutines. Three core tools made blocking HTTP or I/O calls that safe in a subprocess become event-loop deadlocks in the new context.
+
+- **`session_init` no longer blocks the event loop.** `pool_recall` called `DaemonPoolProxy.recall` which uses blocking `urllib.urlopen` internally. Wrapped in `asyncio.to_thread`.
+- **`observe` no longer blocks the event loop.** `auto.capture()` is a synchronous function that makes an internal HTTP call. Wrapped in `asyncio.to_thread`.
+- **`remember` no longer blocks the event loop.** Both `is_daemon_running()` (file-system check + HTTP probe) and `daemon_request()` (blocking HTTP POST) wrapped in `asyncio.to_thread`.
+
+### Fixed — Post-implementation audit (5 bugs)
+
+- **`close_session` crash eliminated.** `tools_active.py` `close_session` called `engine._db._get_conn()`, a private method removed in a prior refactor. Changed to the public `engine._db.execute()` API.
+- **`TransportSecuritySettings` import no longer fails on older MCP SDK versions.** The import was at module level in `unified_daemon.py`, causing an `ImportError` on MCP SDK < 1.27. Moved inside the `if _mcp_allowed:` conditional so it only loads when the HTTP transport is actually being activated.
+- **`SLM_DAEMON_PORT` no longer silently becomes 0 on invalid input.** `int(os.environ.get("SLM_DAEMON_PORT", "") or 8765)` evaluated to `int("")` → `ValueError` → port 0. Wrapped in `try/except ValueError` with a fallback to 8765 and a log warning.
+- **Health monitor cmdline truncation increased.** `cmdline[:80]` silently dropped long Python command lines (common with virtualenv paths), producing false "not SLM" negatives. Increased to `cmdline[:200]`.
+- **Daemon `_DEFAULT_PORT` no longer crashes on malformed env.** Same `ValueError` guard added to the module-level `_DEFAULT_PORT` assignment in `cli/daemon.py`.
+
+### Changed — Recall performance (zero quality tradeoff)
+
+- **SpreadingActivation: 418ms → 36ms (12×).** Neighbor lookups for each graph node are now cached across propagation iterations. The neighbor list is static within a single recall — re-querying SQL per iteration (up to ~120 queries per propagation) was pure waste. The cache is local to the call, so correctness is unchanged.
+- **`fast=True` deprecated.** `fast=True` was added in v3.4.40 when SpreadingActivation took 418ms. With SA now completing in ~36ms, `fast=True` (which disables SA) is actually *slower* than `fast=False` and reduces recall quality by dropping a full retrieval channel. `MemoryEngine.recall()` now logs a `WARNING` and silently treats `fast=True` as `False`. The parameter is retained for API backward compatibility and will be removed in v3.7.x. All built-in callers already passed `fast=False`.
+- Hopfield `prefilter_candidates` and entity-graph scoring candidates retain their original designed values (1000 and 100 respectively) — no quality tradeoffs were made in pursuit of latency targets.
+
+### Added
+
+- `HealthConfig` dataclass in `core/config.py` and `"health"` section parsing in `SLMConfig.load()`.
+- `SLM_RSS_BUDGET_MB` environment variable for operator control of the health watchdog kill threshold.
+- `docs/distributed-deployment.md` — complete guide for LXC/container/multi-machine setups with full `SLM_*` environment variable reference (closes #33 + #37).
+- `docs/install-linux.md` — Ubuntu 22.04 / Debian install guide with venv, pipx, and pyenv paths plus a systemd unit template.
+
 ## [3.6.8] - 2026-06-11 — Runtime recall-health monitor (self-healing recall)
 
 ### Fixed

package/README.md

@@ -33,18 +33,22 @@
 <details>
 <summary><strong>What's New in V3.6 — Optimize: SKIP, SHRINK, DISCOUNT, REMEMBER</strong> (click to expand)</summary>
 
-> V3.6 is the only local-first layer that SKIPS repeat LLM calls (cache: 100% saved), SHRINKS prompts 60-95% (compress: extractive + LLMLingua-2), and DISCOUNTS prefix costs (align: native KV-cache) — and remembers everything — in one install. **Your first cache hit pays for the install time. Hours of coding on repeat, minimal API cost.**
+> V3.6 is the only local-first layer that SKIPS repeat LLM calls (cache: 100% saved on a hit), SHRINKS prose prompts (compress: lossless-by-default, opt-in LLMLingua-2), and DISCOUNTS prefix costs (align: native KV-cache) — and remembers everything — in one install. **Your first cache hit pays for the install time. Hours of coding on repeat, minimal API cost.**
+>
+> **v3.6.10:** cache and compression are now **independent runtime switches** (cache-only, compress-only, both, or neither — toggle live from the dashboard, no restart). Compression was rebuilt to be **lossless by default** (the old string/array/code truncation is gone); aggressive mode adds LLMLingua-2 for **prose only** — never code, numbers, structured data, or the current turn.
 
 ### The Three Levers
 
 | Lever | Mechanism | Saving | Off by default? |
 |-------|-----------|:------:|:---------------:|
-| **Cache** | Skip repeat calls — exact-match SQLite lookup, vCache-gated semantic (opt-in) | **100% on a hit** (input + output) | Cache ON, Semantic OFF |
-| **Compress** | Shrink prompts — extractive JSON/code (lossless) + LLMLingua-2 prose (opt-in) | **60–95% on a miss** (input only) | Safe mode ON, Aggressive OFF |
+| **Cache** | Skip repeat calls — exact-match SQLite lookup (zero false hits), vCache-gated semantic (opt-in) | **100% on a hit** (input + output) | Cache ON, Semantic OFF |
+| **Compress** | Shrink prompts — **safe = lossless** normalization; **aggressive = LLMLingua-2 prose only** (opt-in) | Safe: small + lossless · Aggressive: large on prose | Safe mode, Aggressive OFF |
 | **Align** | Stabilize prefix — maximize provider prefix-cache discounts | **Lossless extra** | ON when compression is ON |
 
 **Memory** (v3.5's existing engine) runs in parallel — it shapes *what is in* the prompt (relevant facts); Optimize decides *whether and how* it is sent.
 
+> **Independent at runtime:** enable caching only, compression only, both, or neither — from the dashboard Optimize tab, applied live (no restart). Each AI client can also get its own memory identity over HTTP MCP via `http://127.0.0.1:8765/mcp/{agent_id}`.
+
 ### Quick Start
 
 ```bash
@@ -60,7 +64,7 @@ slm wrap claude
 |:--------|:-------------|
 | `slm optimize status\|on\|off\|savings` | Master Optimize control + savings report (USD/INR/tokens) |
 | `slm cache status\|clear\|invalidate\|ttl\|semantic` | Cache sub-control — exact + semantic tiers |
-| `slm compress status\|mode\|code\|prose\|ccr\|align` | Compression control — per-channel toggles |
+| `slm compress status\|mode\|prose` | Compression control — safe (lossless) / aggressive (LLMLingua-2 prose) |
 | `slm proxy [--port] [--provider]` | Start the interception proxy (port 8765) |
 | `slm wrap <agent>` | Proxy-activate an agent — one command to start saving |
 | `slm help-optimize [topic]` | Full developer reference + per-agent setup recipes |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.6.8",
+  "version": "3.6.10",
   "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.6.8"
+version = "3.6.10"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}
@@ -69,6 +69,11 @@ dependencies = [
     "scikit-learn==1.8.0",
     # Vector KNN extension for the semantic channel.
     "sqlite-vec==0.1.9",
+    # v3.6.10: LLMLingua-2 prose compression (aggressive mode, opt-in at runtime).
+    # Hard dependency so `pip install superlocalmemory` ships compression-ready;
+    # the ~560MB model downloads on first setup/warmup (fail-open). Verified the
+    # pin does NOT disturb the transformers/torch/numpy pins above.
+    "llmlingua==0.2.2",
 ]
 
 [project.optional-dependencies]

package/src/superlocalmemory/__init__.py

@@ -1,4 +1,8 @@
-"""SuperLocalMemory — information-geometric agent memory."""
+"""SuperLocalMemory — information-geometric agent memory.
+
+v3.6.9: all 7 retrieval layers at full quality (Hopfield@1000, entity_graph@100,
+SA neighbor-cache fix, fast=True deprecated). See CHANGELOG.md.
+"""
 
 import os
 
@@ -28,7 +32,7 @@ if "OMP_NUM_THREADS" not in os.environ:
     os.environ["OMP_NUM_THREADS"] = "2"
 # ---------------------------------------------------------------------------
 
-__version__ = "3.6.8"
+__version__ = "3.6.10"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

package/src/superlocalmemory/cli/compress_cmd.py

@@ -2,7 +2,7 @@
 # Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
-"""Handlers for ``slm compress status|mode|code|prose|ccr``."""
+"""Handlers for ``slm compress status|mode|prose``."""
 
 from __future__ import annotations
 
@@ -19,11 +19,6 @@ def _get_store():
     return ConfigStore()
 
 
-def _get_cache_db():
-    from superlocalmemory.optimize.storage.db import CacheDB
-    return CacheDB()
-
-
 def _write_config(**fields) -> None:
     """5-step immutable config-write."""
     store = _get_store()
@@ -44,18 +39,31 @@ def cmd_compress(args: Namespace) -> None:
     sub = getattr(args, "compress_command", None)
     _dispatch = {
         "status": cmd_compress_status,
-        "mode": cmd_compress_mode,
-        "code": cmd_compress_code,
-        "prose": cmd_compress_prose,
-        "ccr": cmd_compress_ccr,
-        "align": cmd_compress_align,
+        "mode":   cmd_compress_mode,
+        "prose":  cmd_compress_prose,
+        # removed in v3.6.10: code, ccr, align (extractive compressors removed)
+        "code":   _cmd_compress_removed("code"),
+        "ccr":    _cmd_compress_removed("ccr"),
+        "align":  _cmd_compress_removed("align"),
     }
     handler = _dispatch.get(sub or "")
     if handler:
         handler(args)
     else:
-        print("Usage: slm compress status|mode|code|prose|ccr [options]")
+        print("Usage: slm compress status|mode|prose [options]")
+        sys.exit(0)
+
+
+def _cmd_compress_removed(name: str):
+    def handler(args: Namespace) -> None:
+        print(
+            f"slm compress {name}: removed in SLM v3.6.10. "
+            f"Extractive {name} compression has been replaced by "
+            f"Layer 1 (lossless whitespace) + Layer 2 (LLMLingua-2 prose). "
+            f"Use 'slm compress prose on' to enable prose compression."
+        )
         sys.exit(0)
+    return handler
 
 
 def cmd_compress_status(args: Namespace) -> None:
@@ -68,21 +76,19 @@ def cmd_compress_status(args: Namespace) -> None:
             "status": "ok",
             "compress_enabled": cfg.compress_enabled,
             "compress_mode": cfg.compress_mode,
-            "compress_code": cfg.compress_code,
             "compress_prose": cfg.compress_prose,
-            "compress_ccr": cfg.compress_ccr,
+            "compress_protect_recent": cfg.compress_protect_recent,
         }
         print(json.dumps(data, indent=2))
         return
 
     print("Compression status:")
-    print(f"  Enabled:  {'yes' if cfg.compress_enabled else 'no'}")
-    print(f"  Mode:     {cfg.compress_mode}")
-    print(f"  Code:     {'ON' if cfg.compress_code else 'OFF'}"
-          "  (extractive JSON/code — lossless structure)")
-    print(f"  Prose:    {'ON' if cfg.compress_prose else 'OFF'}")
-    print(f"  CCR:      {'ON' if cfg.compress_ccr else 'OFF'}"
-          " (reversible context retrieval)")
+    print(f"  Enabled:         {'yes' if cfg.compress_enabled else 'no'}")
+    print(f"  Mode:            {cfg.compress_mode}")
+    print(f"  Prose (Layer 2): {'ON' if cfg.compress_prose else 'OFF'}"
+          "  (LLMLingua-2, aggressive mode only)")
+    print(f"  Protect recent:  {cfg.compress_protect_recent} user turns")
+    print("  Layer 1 (lossless whitespace normalization) is always ON when enabled.")
 
 
 def cmd_compress_mode(args: Namespace) -> None:
@@ -103,23 +109,8 @@ def cmd_compress_mode(args: Namespace) -> None:
     print("Daemon hot-reload: active within 2s. No restart required.")
 
 
-def cmd_compress_code(args: Namespace) -> None:
-    """Enable or disable code/JSON compression."""
-    use_json = getattr(args, "json", False)
-    value = getattr(args, "code_value", "on")
-
-    _write_config(compress_code=(value == "on"))
-
-    if use_json:
-        print(json.dumps({"status": "ok", "compress_code": value == "on"}))
-        return
-
-    print(f"Code compression: {'ENABLED' if value == 'on' else 'DISABLED'}.")
-    print("Daemon hot-reload: active within 2s.")
-
-
 def cmd_compress_prose(args: Namespace) -> None:
-    """Enable or disable prose compression."""
+    """Enable or disable prose compression (Layer 2, LLMLingua-2)."""
     use_json = getattr(args, "json", False)
     value = getattr(args, "prose_value", "off")
 
@@ -141,39 +132,10 @@ def cmd_compress_prose(args: Namespace) -> None:
         print(json.dumps({"status": "ok", "compress_prose": value == "on"}))
         return
 
-    print(f"Prose compression: {'ENABLED' if value == 'on' else 'DISABLED'}.")
+    print(f"Prose compression (LLMLingua-2): {'ENABLED' if value == 'on' else 'DISABLED'}.")
+    if value == "on":
+        print("  Requires: compress_mode=aggressive and llmlingua package installed.")
+        print("  Run: slm compress mode aggressive  (if not already set)")
     if value == "on" and "compress_enabled" in fields:
         print("  (also enabled global compress)")
     print("Daemon hot-reload: active within 2s.")
-
-
-def cmd_compress_align(args: Namespace) -> None:
-    """Enable or disable alignment compression."""
-    use_json = getattr(args, "json", False)
-    value = getattr(args, "align_value", "on")
-
-    _write_config(compress_align=(value == "on"))
-
-    if use_json:
-        print(json.dumps({"status": "ok", "compress_align": value == "on"}))
-        return
-
-    print(f"Alignment compression: {'ENABLED' if value == 'on' else 'DISABLED'}.")
-    print("Daemon hot-reload: active within 2s.")
-
-
-def cmd_compress_ccr(args: Namespace) -> None:
-    """Enable or disable CCR (Compressed Context Retrieval)."""
-    use_json = getattr(args, "json", False)
-    value = getattr(args, "ccr_value", "off")
-
-    _write_config(compress_ccr=(value == "on"))
-
-    if use_json:
-        print(json.dumps({"status": "ok", "compress_ccr": value == "on"}))
-        return
-
-    print(f"CCR (Compressed Context Retrieval): {'ENABLED' if value == 'on' else 'DISABLED'}.")
-    if value == "on":
-        print("Originals stored in llmcache.db for reversible retrieval.")
-    print("Daemon hot-reload: active within 2s.")

package/src/superlocalmemory/cli/daemon.py

@@ -34,7 +34,10 @@ from threading import Thread
 
 logger = logging.getLogger(__name__)
 
-_DEFAULT_PORT = 8765  # v3.4.3: unified daemon on 8765 (was 8767)
+try:
+    _DEFAULT_PORT = int(os.environ.get("SLM_DAEMON_PORT", "") or 8765)
+except ValueError:
+    _DEFAULT_PORT = 8765
 _LEGACY_PORT = 8767   # backward-compat redirect
 _DEFAULT_IDLE_TIMEOUT = 0  # v3.4.3: 24/7 default (was 1800)
 _PID_FILE = Path.home() / ".superlocalmemory" / "daemon.pid"
@@ -160,7 +163,13 @@ def _start_daemon_subprocess() -> bool:
         return True
 
     import subprocess
-    cmd = [sys.executable, "-m", "superlocalmemory.server.unified_daemon", "--start"]
+    # v3.6.9 (#33): pass SLM_DAEMON_PORT as explicit --port= so the daemon
+    # binds the right port even when the env var reaches the subprocess.
+    _target_port = _DEFAULT_PORT
+    cmd = [
+        sys.executable, "-m", "superlocalmemory.server.unified_daemon",
+        "--start", f"--port={_target_port}",
+    ]
     log_dir = Path.home() / ".superlocalmemory" / "logs"
     log_dir.mkdir(parents=True, exist_ok=True)
     log_file = log_dir / "daemon.log"
@@ -187,7 +196,7 @@ def _start_daemon_subprocess() -> bool:
 
     # Write PID immediately so other callers see it during warmup
     _PID_FILE.write_text(str(proc.pid))
-    _PORT_FILE.write_text(str(_DEFAULT_PORT))
+    _PORT_FILE.write_text(str(_target_port))
 
     return _wait_for_daemon(timeout=60)
 
@@ -237,6 +246,19 @@ def ensure_daemon() -> bool:
         if is_daemon_running():
             return True
 
+        # v3.6.9 (#36): TCP-level check catches a systemd-started daemon that
+        # has bound the port but hasn't written a PID file yet (e.g. different
+        # HOME for the service user vs. the SSH user).  If the port is already
+        # bound, don't start a second daemon — wait for HTTP readiness instead.
+        try:
+            import socket as _socket
+            with _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM) as _s:
+                _s.settimeout(1)
+                if _s.connect_ex(("127.0.0.1", _DEFAULT_PORT)) == 0:
+                    return _wait_for_daemon(timeout=30)
+        except Exception:
+            pass
+
         # Start unified daemon in background — delegated to helper so the
         # same logic can be reused by callers that already hold the lock.
         return _start_daemon_subprocess()

package/src/superlocalmemory/cli/optimize_cmd.py

@@ -97,9 +97,7 @@ def cmd_optimize_status(args: Namespace) -> None:
           f" semantic: {'OFF' if not cfg.semantic_enabled else f'{cfg.ttl.semantic_seconds}s'})")
     print(f"  Compress:  {'enabled' if cfg.compress_enabled else 'disabled'}"
           f"  (mode: {cfg.compress_mode},"
-          f" code: {'ON' if cfg.compress_code else 'OFF'},"
-          f" prose: {'ON' if cfg.compress_prose else 'OFF'},"
-          f" CCR: {'ON' if cfg.compress_ccr else 'OFF'})")
+          f" prose/L2: {'ON' if cfg.compress_prose else 'OFF'})")
     proxy_status = f"running on :{OPTIMIZE_DEFAULT_PORT}" if proxy_running else "not running"
     print(f"  Proxy:     {proxy_status}")
     print(f"  Config:    ~/.superlocalmemory/optimize.json  (version {cfg.config_version})")

package/src/superlocalmemory/cli/setup_wizard.py

@@ -32,6 +32,8 @@ _SLM_HOME = Path(os.environ.get("SL_MEMORY_PATH", Path.home() / ".superlocalmemo
 _SETUP_MARKER = _SLM_HOME / ".setup-complete"
 _EMBED_MODEL = "nomic-ai/nomic-embed-text-v1.5"
 _RERANKER_MODEL = "cross-encoder/ms-marco-MiniLM-L-12-v2"
+# v3.6.10: compulsory LLMLingua-2 prose compression model (~560MB, aggressive mode).
+_COMPRESSOR_MODEL = "microsoft/llmlingua-2-xlm-roberta-large-meetingbank"
 
 
 # ---------------------------------------------------------------------------
@@ -178,6 +180,49 @@ def _download_reranker(model_name: str) -> bool:
         return False
 
 
+def _download_compressor(model_name: str) -> bool:
+    """Download the LLMLingua-2 prose compression model (v3.6.10).
+
+    Mirrors _download_reranker: a subprocess forces the HF download with visible
+    progress. Fail-open — a network hiccup must NOT break setup; the model also
+    lazy-downloads on first use in prose_llmlingua.py.
+    """
+    print(f"\n  Downloading compression model: {model_name}")
+    print(f"  (LLMLingua-2 prose compressor, ~560MB — aggressive mode only)\n")
+
+    script = (
+        "from llmlingua import PromptCompressor; "
+        f"PromptCompressor(model_name='{model_name}', use_llmlingua2=True, "
+        "device_map='cpu'); "
+        "print('OK')"
+    )
+
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c", script],
+            timeout=900,  # 560MB on a slow link can exceed 5 min
+            capture_output=False,
+            text=True,
+            env={
+                **os.environ,
+                "CUDA_VISIBLE_DEVICES": "",
+                "TOKENIZERS_PARALLELISM": "false",
+                "TORCH_DEVICE": "cpu",
+            },
+        )
+        if result.returncode == 0:
+            print(f"  ✓ Compression model ready")
+            return True
+        print(f"  ✗ Compression model download failed (will lazy-download on first use)")
+        return False
+    except ImportError:
+        print(f"  ⚠ llmlingua not installed — compression model will download on first use")
+        return False
+    except Exception as exc:
+        print(f"  ✗ Compression model error: {exc}")
+        return False
+
+
 # ---------------------------------------------------------------------------
 # Verification
 # ---------------------------------------------------------------------------
@@ -393,6 +438,10 @@ def run_wizard(auto: bool = False) -> None:
     else:
         _download_reranker(_RERANKER_MODEL)
 
+    print()
+    print("─── Step 4c/10: Download Compression Model (LLMLingua-2) ───")
+    _download_compressor(_COMPRESSOR_MODEL)
+
     # -- Step 5: Daemon Configuration (v3.4.3) --
     print()
     print("─── Step 5/10: Daemon Configuration ───")

package/src/superlocalmemory/core/config.py

@@ -654,6 +654,25 @@ class AutoInvokeConfig:
     relevance_threshold: float = 0.3           # Legacy compat with AutoRecall
 
 
+# ---------------------------------------------------------------------------
+# Health Config (v3.6.9 BUG-A)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class HealthConfig:
+    """Health-monitor tuning knobs.
+
+    All values have safe defaults so an empty ``"health": {}`` JSON section
+    silently inherits them. The ``global_rss_budget_mb`` default is computed
+    at runtime (40% of physical RAM, floor 2500 MB) so low-RAM boxes keep the
+    old behaviour while large machines are never accidentally throttled.
+    """
+    global_rss_budget_mb: int = 0          # 0 = compute at runtime (40% RAM, floor 2500)
+    heartbeat_timeout_sec: int = 60
+    health_check_interval_sec: int = 15
+    enable_structured_logging: bool = True
+
+
 # ---------------------------------------------------------------------------
 # Master Config
 # ---------------------------------------------------------------------------
@@ -698,6 +717,7 @@ class SLMConfig:
     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)
+    health: HealthConfig = field(default_factory=HealthConfig)
 
     # v3.4.3: Daemon configuration
     daemon_idle_timeout: int = 0       # 0 = 24/7 (no auto-kill). >0 = seconds before auto-kill.
@@ -789,6 +809,14 @@ class SLMConfig:
                 if k in EvolutionConfig.__dataclass_fields__
             })
 
+        # V3.6.9: Health monitor config (BUG-A — previously silently ignored)
+        hlth = data.get("health", {})
+        if hlth:
+            config.health = HealthConfig(**{
+                k: v for k, v in hlth.items()
+                if k in HealthConfig.__dataclass_fields__
+            })
+
         # V3.4.65: Injection config (additive — defaults if missing from JSON)
         inj = data.get("injection", {}) or {}
         config.injection = InjectionConfig(

package/src/superlocalmemory/core/engine.py

@@ -452,7 +452,9 @@ class MemoryEngine:
         now = datetime.now(timezone.utc).isoformat()
         record = MemoryRecord(
             profile_id=self._profile_id, content=content,
-            session_date=now[:10], metadata=metadata or {},
+            session_date=now[:10],
+            session_id=(metadata or {}).get("session_id", ""),
+            metadata=metadata or {},
         )
         self._db.store_memory(record)
         # Lightweight regex entities (matches store_pipeline verbatim path) so
@@ -520,13 +522,22 @@ class MemoryEngine:
         on a background worker.
 
         V3.4.40 (2026-05-09): ``fast=True`` skips the SpreadingActivation
-        5th channel for sub-second response. The other 4 channels still
-        run. Use when recall must complete before another tool call (e.g.
-        agent recall before WebSearch).
+        channel. Deprecated in v3.6.9 — SA now completes in ~36ms after the
+        neighbor-cache fix; fast=True is slower than fast=False and reduces
+        recall quality. The parameter is accepted for backward compatibility
+        but is silently treated as False.
         """
         self._require_full("recall")
         self._ensure_init()
 
+        if fast:
+            logger.warning(
+                "fast=True is deprecated (v3.6.9): SpreadingActivation now "
+                "completes in ~36ms; fast mode is slower and reduces quality. "
+                "Pass fast=False (the default) to silence this warning."
+            )
+            fast = False
+
         pid = profile_id or self._profile_id
 
         from superlocalmemory.core.recall_pipeline import run_recall

package/src/superlocalmemory/core/health_monitor.py

@@ -130,14 +130,26 @@ class HealthMonitor:
         "superlocalmemory.core.reranker_worker",
         "superlocalmemory.core.recall_worker",
     )
+    # Workers that are LOAD-BEARING for recall quality — never kill these
+    # first; prefer killing the reranker (gracefully degrades) or GC instead.
+    _EMBEDDING_IDENTIFIER = "superlocalmemory.core.embedding_worker"
 
     def __init__(
         self,
-        global_rss_budget_mb: int = 2500,
+        global_rss_budget_mb: int = 0,
         heartbeat_timeout_sec: int = 60,
         check_interval_sec: int = 15,
         enable_structured_logging: bool = True,
     ):
+        # Compute RAM-scaled default when 0 is passed (or when the caller
+        # explicitly passes 0 meaning "auto"). Floor at 2500 so low-RAM boxes
+        # keep the old conservative behaviour.
+        if global_rss_budget_mb <= 0:
+            if PSUTIL_AVAILABLE:
+                phys_mb = psutil.virtual_memory().total // (1024 * 1024)
+                global_rss_budget_mb = max(2500, int(phys_mb * 0.40))
+            else:
+                global_rss_budget_mb = 8000  # safe fallback when psutil absent
         self._budget_mb = global_rss_budget_mb
         self._heartbeat_timeout = heartbeat_timeout_sec
         self._interval = check_interval_sec
@@ -207,7 +219,7 @@ class HealthMonitor:
                     slm_workers.append({
                         "pid": child.pid,
                         "rss_mb": round(rss_mb, 1),
-                        "cmdline": cmdline[:80],
+                        "cmdline": cmdline[:200],
                     })
             except (psutil.NoSuchProcess, psutil.AccessDenied):
                 continue
@@ -225,22 +237,33 @@ class HealthMonitor:
             budget_mb=self._budget_mb,
         )
 
-        # RSS budget enforcement
+        # RSS budget enforcement — spare the embedding worker (load-bearing for
+        # recall quality). Kill the reranker first (degrades gracefully); only
+        # fall back to the embedder if it is the only worker remaining.
         if total_rss_mb > self._budget_mb and slm_workers:
-            heaviest = max(slm_workers, key=lambda w: w["rss_mb"])
+            non_embedder = [
+                w for w in slm_workers
+                if self._EMBEDDING_IDENTIFIER not in w["cmdline"]
+            ]
+            candidate = (
+                max(non_embedder, key=lambda w: w["rss_mb"])
+                if non_embedder
+                else max(slm_workers, key=lambda w: w["rss_mb"])
+            )
             logger.warning(
-                "RSS budget exceeded (%.0fMB > %dMB). Killing heaviest worker PID %d (%.0fMB)",
-                total_rss_mb, self._budget_mb, heaviest["pid"], heaviest["rss_mb"],
+                "RSS budget exceeded (%.0fMB > %dMB). Killing worker PID %d (%.0fMB)",
+                total_rss_mb, self._budget_mb, candidate["pid"], candidate["rss_mb"],
             )
             log_structured(
                 level="warning",
                 operation="rss_budget_kill",
-                killed_pid=heaviest["pid"],
-                killed_rss_mb=heaviest["rss_mb"],
+                killed_pid=candidate["pid"],
+                killed_rss_mb=candidate["rss_mb"],
                 total_rss_mb=round(total_rss_mb, 1),
+                spared_embedder=bool(non_embedder),
             )
             try:
-                psutil.Process(heaviest["pid"]).terminate()
+                psutil.Process(candidate["pid"]).terminate()
             except psutil.NoSuchProcess:
                 pass