superlocalmemory 3.8.0 → 3.8.1

package/src/superlocalmemory/cli/commands.py

@@ -159,7 +159,10 @@ def cmd_session(args: Namespace) -> None:
 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", "codex", "init", "mcp"):
+    if (
+        args.command not in ("hooks", "codex", "init", "mcp")
+        and not getattr(args, "dry_run", False)
+    ):
         try:
             from superlocalmemory.hooks.claude_code_hooks import auto_install_if_needed
             auto_install_if_needed()
@@ -958,16 +961,22 @@ def _agents_md_source_factory():
     Gracefully skips if absent — never fails the MCP write.
     """
     from pathlib import Path
+    import sysconfig
 
     # Resolve relative to the package root (src/superlocalmemory/../../)
     _pkg_root = Path(__file__).resolve().parents[3]
-    _agents_src = _pkg_root / "plugin-src" / "rules" / "AGENTS.md"
+    _candidates = (
+        _pkg_root / "plugin-src" / "rules" / "AGENTS.md",
+        Path(sysconfig.get_path("data")) / "share" / "superlocalmemory"
+        / "portable-kit" / "rules" / "AGENTS.md",
+    )
 
     def _read() -> str | None:
-        if _agents_src.exists():
-            return _agents_src.read_text(encoding="utf-8")
+        for candidate in _candidates:
+            if candidate.exists():
+                return candidate.read_text(encoding="utf-8")
         logger.warning(
-            "WP-05 AGENTS.md not found at %s — skipping AGENTS.md write", _agents_src
+            "WP-05 AGENTS.md is not bundled — skipping AGENTS.md write"
         )
         return None
 
@@ -1008,9 +1017,10 @@ def cmd_connect(args: Namespace) -> None:
                 here=here,
                 profile=profile,
                 agents_md_source=_agents_md_source_factory(),
+                dry_run=getattr(args, "dry_run", False),
             )
 
-            if not result.get("error"):
+            if not result.get("error") and not getattr(args, "dry_run", False):
                 from superlocalmemory.infra.local_diagnostics import record_operation
 
                 record_operation("activation", client=ide_arg)
@@ -1029,6 +1039,7 @@ def cmd_connect(args: Namespace) -> None:
                 sys.exit(1)
 
             status_sym = {"wrote": "[+]", "merged": "[~]", "unchanged": "[=]",
+                          "would_write": "[~]",
                           "skipped": "[s]", "error": "[!]"}.get(
                 result["mcp_config"], "[?]"
             )
@@ -1057,6 +1068,7 @@ def cmd_connect(args: Namespace) -> None:
     from superlocalmemory.hooks.ide_connector import IDEConnector
 
     connector = IDEConnector()
+    dry_run = bool(getattr(args, "dry_run", False))
 
     if getattr(args, 'json', False):
         from superlocalmemory.cli.json_output import json_print
@@ -1068,6 +1080,14 @@ def cmd_connect(args: Namespace) -> None:
         elif getattr(args, "ide", None):
             success = connector.connect(args.ide)
             json_print("connect", data={"ide": args.ide, "connected": success})
+        elif dry_run:
+            json_print(
+                "connect",
+                data={
+                    "dry_run": True,
+                    "would_configure": connector.get_status(),
+                },
+            )
         else:
             json_print("connect", data={"results": connector.connect_all()},
                        next_actions=[
@@ -1081,6 +1101,12 @@ def cmd_connect(args: Namespace) -> None:
             mark = "[+]" if s["installed"] else "[-]"
             print(f"  {mark} {s['name']:20s} {s['config_path']}")
         return
+    if dry_run:
+        status = connector.get_status()
+        print("Dry run — no IDE, hook, config, or SLM data files were written.")
+        for item in status:
+            print(f"  would inspect/configure: {item['name']} ({item['config_path']})")
+        return
     if getattr(args, "ide", None):
         success = connector.connect(args.ide)
         print(f"{'Connected' if success else 'Failed'}: {args.ide}")
@@ -1563,16 +1589,86 @@ def cmd_forget(args: Namespace) -> None:
 
 def cmd_delete(args: Namespace) -> None:
     """Delete a specific memory by exact fact ID."""
+    import urllib.parse
+
+    from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.core.engine import MemoryEngine
 
     use_json = getattr(args, 'json', False)
+    fact_id = args.fact_id.strip()
+    if is_daemon_running():
+        path = "/api/memories/" + urllib.parse.quote(fact_id, safe="")
+        confirmed = getattr(args, "yes", False)
+        content = ""
+        if not confirmed:
+            detail = daemon_request(
+                "GET",
+                "/api/facts/" + urllib.parse.quote(fact_id, safe=""),
+            )
+            if not isinstance(detail, dict):
+                if use_json:
+                    from superlocalmemory.cli.json_output import json_print
+                    json_print("delete", error={
+                        "code": "DAEMON_MUTATION_FAILED",
+                        "message": "Resident daemon could not resolve the memory.",
+                    })
+                    sys.exit(1)
+                raise RuntimeError("Resident daemon could not resolve the memory.")
+            content = str(detail.get("content") or "")
+            if use_json:
+                from superlocalmemory.cli.json_output import json_print
+                json_print("delete", data={
+                    "fact_id": fact_id,
+                    "content": content[:120],
+                    "deleted": False,
+                    "hint": "Add --yes to confirm deletion",
+                }, next_actions=[
+                    {
+                        "command": f"slm delete {fact_id} --json --yes",
+                        "description": "Confirm deletion",
+                    },
+                ])
+                return
+            print(f"Memory: {content[:120]}")
+            confirmed = input("Delete this memory? [y/N] ").strip().lower() in (
+                "y", "yes",
+            )
+            if not confirmed:
+                print("Cancelled.")
+                return
+
+        result = daemon_request("DELETE", path)
+        if not isinstance(result, dict) or not result.get("success"):
+            if use_json:
+                from superlocalmemory.cli.json_output import json_print
+                json_print("delete", error={
+                    "code": "DAEMON_MUTATION_FAILED",
+                    "message": "Resident daemon rejected the delete operation.",
+                })
+                sys.exit(1)
+            raise RuntimeError("Resident daemon rejected the delete operation.")
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print(
+                "delete",
+                data={"deleted": fact_id, "content": content[:120]},
+                next_actions=[
+                    {
+                        "command": "slm list --json",
+                        "description": "Verify remaining memories",
+                    },
+                ],
+            )
+        else:
+            print(f"Deleted: {fact_id}")
+        return
+
     try:
         config = SLMConfig.load()
         engine = MemoryEngine(config)
         engine.initialize()
 
-        fact_id = args.fact_id.strip()
         rows = engine._db.execute(
             "SELECT content FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
             (fact_id, engine.profile_id),
@@ -1642,6 +1738,9 @@ def cmd_delete(args: Namespace) -> None:
 
 def cmd_update(args: Namespace) -> None:
     """Update the content of a specific memory by exact fact ID."""
+    import urllib.parse
+
+    from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.core.engine import MemoryEngine
 
@@ -1657,6 +1756,34 @@ def cmd_update(args: Namespace) -> None:
         print("Error: content cannot be empty")
         return
 
+    if is_daemon_running():
+        path = "/api/memories/" + urllib.parse.quote(fact_id, safe="")
+        result = daemon_request("PATCH", path, {"content": new_content})
+        if not isinstance(result, dict) or not result.get("success"):
+            if use_json:
+                from superlocalmemory.cli.json_output import json_print
+                json_print("update", error={
+                    "code": "DAEMON_MUTATION_FAILED",
+                    "message": "Resident daemon rejected the update operation.",
+                })
+                sys.exit(1)
+            raise RuntimeError("Resident daemon rejected the update operation.")
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("update", data={
+                "fact_id": fact_id,
+                "new_content": new_content[:120],
+            }, next_actions=[
+                {
+                    "command": "slm list --json",
+                    "description": "List recent memories",
+                },
+            ])
+        else:
+            print(f"New: {new_content[:100]}")
+            print(f"Updated: {fact_id}")
+        return
+
     try:
         config = SLMConfig.load()
         engine = MemoryEngine(config)

package/src/superlocalmemory/cli/daemon.py

@@ -267,6 +267,13 @@ def daemon_request(
         if capability is not None:
             headers["X-SLM-Daemon-Capability"] = capability
             headers["X-SLM-Target-Instance"] = descriptor.instance_id
+        # Daemon ownership proves that this CLI targets the local instance; it
+        # does not replace a dashboard user's profile-scoped authorization in
+        # governed workspaces. The user opts in by supplying an explicit
+        # session through the process environment (never logged or persisted).
+        user_session = os.environ.get("SLM_USER_SESSION", "").strip()
+        if user_session:
+            headers["X-SLM-User-Session"] = user_session
         req = urllib.request.Request(url, data=data, headers=headers, method=method)
         resp = urllib.request.urlopen(req, timeout=timeout_seconds)
         return json.loads(resp.read().decode())

package/src/superlocalmemory/cli/loop_cmd.py

@@ -19,11 +19,11 @@ store rooted at the active data root (``SLM_DATA_DIR`` or
 from __future__ import annotations
 
 import json
-import os
 from argparse import Namespace
 from pathlib import Path
 from typing import Any
 
+from superlocalmemory.infra.data_root import canonical_data_root
 from superlocalmemory.loops import (
     Bounds,
     LapResult,
@@ -35,12 +35,7 @@ from superlocalmemory.loops import (
 
 
 def _data_root() -> Path:
-    value = (
-        os.environ.get("SLM_DATA_DIR")
-        or os.environ.get("SL_MEMORY_PATH")
-        or os.environ.get("SLM_HOME")
-    )
-    return Path(value).expanduser() if value else Path.home() / ".superlocalmemory"
+    return canonical_data_root()
 
 
 class _FailOpenLedger:

package/src/superlocalmemory/cli/main.py

@@ -114,12 +114,17 @@ def main() -> None:
         or any(arg in {"-h", "--help"} for arg in sys.argv[1:])
         or (len(sys.argv) == 2 and sys.argv[1] in {"-v", "--version"})
     )
+    _is_connect_dry_run = (
+        len(sys.argv) >= 2
+        and sys.argv[1] == "connect"
+        and "--dry-run" in sys.argv[2:]
+    )
 
     # WP-07: lazy first-run init — runs after hook/mcp fast-paths so stdout
     # is never polluted on those paths (CRIT-3, MCP JSON-RPC purity).
     # Guarded: any failure must not crash the CLI (AC4).
     _is_mcp_cmd = len(sys.argv) >= 2 and sys.argv[1] == "mcp"
-    if not _is_mcp_cmd and not _is_metadata_cmd:
+    if not _is_mcp_cmd and not _is_metadata_cmd and not _is_connect_dry_run:
         try:
             from superlocalmemory.cli._lazy_init import _ensure_initialized
             _ensure_initialized()
@@ -139,7 +144,7 @@ def main() -> None:
 
     # One-time post-upgrade banner — silent for fresh installs and
     # same-version runs. Guarded against I/O errors internally.
-    if not _is_mcp_stdio and not _is_metadata_cmd:
+    if not _is_mcp_stdio and not _is_metadata_cmd and not _is_connect_dry_run:
         from superlocalmemory.cli.version_banner import check_and_emit_upgrade_banner
         if check_and_emit_upgrade_banner(_ver):
             # First post-upgrade invocation: apply the data-dir migration if
@@ -816,8 +821,9 @@ def main() -> None:
         sys.exit(0)
 
     # V3.3.19: Auto-trigger setup wizard on first use
-    from superlocalmemory.cli.setup_wizard import check_first_use
-    check_first_use(args.command)
+    if not (args.command == "connect" and getattr(args, "dry_run", False)):
+        from superlocalmemory.cli.setup_wizard import check_first_use
+        check_first_use(args.command)
 
     # V3.4.4: Auto-start daemon for all commands that need it.
     # SLM is always-on — close laptop, reboot, crash: daemon auto-recovers.

package/src/superlocalmemory/cli/version_banner.py

@@ -26,6 +26,15 @@ _VERSION_PATTERN = re.compile(r"^[0-9A-Za-z.\-+_]{1,32}$")
 
 _MAX_MARKER_BYTES = 64  # a semver string is ≤ 32 chars; 64 is plenty
 
+_RELEASE_NOTES: dict[str, tuple[str, ...]] = {
+    "3.8.1": (
+        "Large existing databases no longer delay daemon readiness",
+        "Failed enrichment retries stop after ten automatic attempts",
+        "Dashboard panes stay mounted between navigation changes",
+        "Local model workers stay warm for a 30-minute working session",
+    ),
+}
+
 
 def _data_dir() -> Path:
     from superlocalmemory.infra.data_root import canonical_data_root
@@ -116,11 +125,16 @@ def _banner(prior: str | None, current: str) -> str:
     header = (f"SuperLocalMemory upgraded from {prior} to {current}"
               if prior else
               f"SuperLocalMemory upgraded to {current} (from an earlier version)")
+    notes = _RELEASE_NOTES.get(
+        current,
+        (
+            "The installed version has changed; existing memory remains in place",
+            "See the release notes for version-specific changes",
+        ),
+    )
     return "\n".join([
         header,
-        "  - Multi-IDE MCP processes now share a worker — large RAM drop",
-        "  - Feedback and learning signals flow from every IDE to the daemon",
-        "  - Silent data migration complete; no manual steps required",
+        *(f"  - {note}" for note in notes),
         "Run `slm doctor` to verify your setup.",
         "",
     ])

package/src/superlocalmemory/core/backend_orchestrator.py

@@ -52,7 +52,7 @@ class BackendOrchestrator:
     """Central coordinator for multi-backend architecture.
 
     Lifecycle:
-      on_daemon_start() → migrate backends → ready
+      on_daemon_start() → initialize bounded backend state → ready
       sync_new_fact() → called from store_pipeline after SQLite write
       health_check() → returns status of all backends
     """
@@ -71,7 +71,7 @@ class BackendOrchestrator:
     # ------------------------------------------------------------------
 
     def on_daemon_start(self) -> None:
-        """Called once on daemon startup. Order matters (F-11: rebalance before migration)."""
+        """Initialize bounded backend state without delaying daemon readiness."""
         logger.info("BackendOrchestrator: daemon starting")
 
         # 1. Apply schema (if not already applied)
@@ -82,18 +82,13 @@ class BackendOrchestrator:
         try:
             from superlocalmemory.core.tier_manager import evaluate_tiers
             self._tiers = evaluate_tiers
-            logger.info("BackendOrchestrator: TierManager initialized")
+            logger.info("BackendOrchestrator: tier evaluator registered")
         except Exception as exc:
             logger.warning("TierManager init failed (non-fatal): %s", exc)
 
-        # 3. Run initial tier rebalance FIRST (F-11: before migration)
-        try:
-            from superlocalmemory.core.tier_manager import evaluate_tiers as rebalance
-            result = rebalance(self._db)
-            logger.info("BackendOrchestrator: initial rebalance — %s",
-                         result.get("total_evaluated", "?"))
-        except Exception as exc:
-            logger.warning("Initial rebalance failed (non-fatal): %s", exc)
+        # Full-database tier evaluation belongs to MaintenanceScheduler. Running
+        # it here blocks FastAPI lifespan readiness on mature upgrade databases
+        # and occurs before optional projection backends are fully registered.
 
         self._recover_interrupted_scale_promotion()
 
@@ -107,12 +102,12 @@ class BackendOrchestrator:
             )
             return
 
-        # 4. Initialize CozoDB if available
+        # 3. Initialize CozoDB if available
         cozo_available = self._detect_cozo()
         if cozo_available:
             self._init_cozo()
 
-        # 5. Initialize LanceDB if available
+        # 4. Initialize LanceDB if available
         lancedb_available = self._detect_lancedb()
         if lancedb_available:
             self._init_lancedb()
@@ -139,13 +134,19 @@ class BackendOrchestrator:
         try:
             from superlocalmemory.core.scale_engine import ScaleEngineManager
 
-            result = ScaleEngineManager(self._config, profile_id="default").recover_interrupted_promotion()
+            result = ScaleEngineManager(
+                self._config,
+                profile_id="default",
+            ).recover_interrupted_promotion()
             if result:
                 logger.warning("Scale Engine promotion recovery: %s", result)
         except Exception as exc:
             # A scale projection is derived data. Startup must keep serving
             # canonical SQLite even if optional recovery itself is unhealthy.
-            logger.error("Scale Engine recovery requires repair; Local Core remains active: %s", exc)
+            logger.error(
+                "Scale Engine recovery requires repair; Local Core remains active: %s",
+                exc,
+            )
 
     # ------------------------------------------------------------------
     # Incremental Sync (F-04: called from store_pipeline)
@@ -401,7 +402,8 @@ class BackendOrchestrator:
     def _apply_schema_v345(self) -> None:
         try:
             from superlocalmemory.storage.schema_v345 import (
-                apply_migration, schema_version_applied,
+                apply_migration,
+                schema_version_applied,
             )
             # #47 fix: use raw_connection() — DatabaseManager has no `.conn`,
             # so the old code raised AttributeError that was silently swallowed,

package/src/superlocalmemory/core/embedding_worker.py

@@ -75,6 +75,8 @@ _TRUSTED_REMOTE_CODE_MODELS = frozenset({
     "nomic-ai/nomic-embed-text-v1",
 })
 
+_RSS_LIMIT_MB = int(os.environ.get("SLM_EMBED_WORKER_RSS_LIMIT_MB", 2500))
+
 
 def _trusts_remote_code(model_name: str) -> bool:
     return model_name in _TRUSTED_REMOTE_CODE_MODELS
@@ -119,10 +121,10 @@ def _worker_main() -> None:
     _start_parent_watchdog()
 
     import numpy as np
+
     from superlocalmemory.core.platform_utils import get_rss_mb
 
     model = None
-    model_name = None
     dim = 0
 
     for line in sys.stdin:
@@ -154,7 +156,6 @@ def _worker_main() -> None:
                     _respond({"ok": False, "error": f"Dimension mismatch: {dim} != {expected_dim}"})
                     model = None
                     continue
-                model_name = name
                 _respond({"ok": True, "dim": dim, "model": name, "backend": active_backend})
             else:
                 _respond({"ok": False, "error": "Model load failed"})
@@ -170,7 +171,6 @@ def _worker_main() -> None:
                 model, active_backend = _load_embedding_model(name)
                 if model is not None:
                     dim = model.get_sentence_embedding_dimension()
-                    model_name = name
                 else:
                     _respond({"ok": False, "error": "Model load failed"})
                     continue
@@ -185,9 +185,8 @@ def _worker_main() -> None:
                 _respond({"ok": False, "error": str(exc)})
 
             # V3.3.16: RSS watchdog — V3.4.24: cross-platform via platform_utils.
-            _rss_limit = int(os.environ.get("SLM_EMBED_WORKER_RSS_LIMIT_MB", 1800))
             rss_mb = get_rss_mb()
-            if rss_mb > 0 and rss_mb > _rss_limit:
+            if rss_mb > 0 and rss_mb > _RSS_LIMIT_MB:
                 sys.exit(0)
 
             continue