superlocalmemory 3.8.0 → 3.8.2

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

@@ -82,6 +82,8 @@ _NO_DAEMON_COMMANDS = {
     "optimize", "cache", "compress", "help-optimize",
     # Bounded loops use an in-process engine store, not the daemon.
     "loop",
+    # v3.8.2 super-help is pure text — never touch the daemon.
+    "help",
     # Lifecycle orchestration must run before any global auto-start hook.
     "serve", "restart",
 }
@@ -114,12 +116,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 +146,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
@@ -278,6 +285,37 @@ def main() -> None:
     db_scale_p.add_argument("--stage-id", help="Stage identifier required by verify/promote")
     db_scale_p.add_argument("--backup-id", help="Backup identifier required by rollback")
 
+    db_reembed_p = db_sub.add_parser(
+        "reembed",
+        help="Backfill NULL embeddings (facts never embedded)",
+    )
+    db_reembed_p.add_argument(
+        "--missing-only",
+        action="store_true",
+        default=True,
+        dest="missing_only",
+        help="Only embed facts with NULL embedding (default and only mode)",
+    )
+    db_reembed_p.add_argument(
+        "--all-profiles",
+        action="store_true",
+        default=False,
+        dest="all_profiles",
+        help="Process all profiles (default: active profile only)",
+    )
+    db_reembed_p.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        metavar="N",
+        help="Maximum facts to embed per run (default: no limit)",
+    )
+    db_reembed_p.add_argument(
+        "--json",
+        action="store_true",
+        help="Output structured JSON",
+    )
+
     # -- Mesh inspection (v3.7.9, M-03) --------------------------------
     mesh_p = sub.add_parser("mesh", help="Inspect the local agent mesh (status/peers)")
     mesh_p.add_argument(
@@ -322,9 +360,11 @@ def main() -> None:
     )
     recall_p.add_argument(
         "--fast", action="store_true",
-        help="Skip graph-assisted candidate expansion and remote agentic verification for a "
-             "latency-bounded response. Other configured retrieval channels still run. "
-             "Use when you need recall before a tool call (e.g. before WebSearch).",
+        help="Force-skip the internal agentic verification round (all six retrieval "
+             "channels + reranker still run). This is already the default (client-driven "
+             "agentic): SLM returns fast local results + confidence signals and lets the "
+             "calling LLM re-query on low confidence. Pass --fast to guarantee the fast "
+             "path even where the server is configured for internal agentic.",
     )
     # v3.6.15: shared memory is opt-in. Unset (None) → resolve the configured
     # default (recall_include_global/shared, both False by default). Explicit
@@ -346,6 +386,15 @@ def main() -> None:
         "--no-shared", dest="include_shared", action="store_false", default=None,
         help="Exclude shared-scope facts from retrieval",
     )
+    # v3.8.2 client-driven agentic: agents parsing --json should ACT on the
+    # confidence signals rather than expect a server-side LLM to reformulate.
+    recall_p.epilog = (
+        "AGENT GUIDANCE (--json): recall returns fast local results plus "
+        "confidence signals. If 'no_confident_match' is true or "
+        "'answer_confidence' is low, rewrite the query into 1-3 more specific "
+        "sub-queries and call recall again before concluding nothing was found. "
+        "Confident match -> use it directly."
+    )
 
     forget_p = sub.add_parser("forget", help="Delete memories matching a query (fuzzy)")
     forget_p.add_argument("query", nargs="?", default=None, help="Query to match for deletion. Optional with --dry-run (previews all memories).")
@@ -392,6 +441,21 @@ def main() -> None:
         "--quick", action="store_true",
         help="Run only the fast checks (deps + config); skip daemon/embedding probes",
     )
+    doctor_p.add_argument(
+        "--fix", action="store_true",
+        help="Auto-repair fixable components (re-download missing models, "
+             "install sqlite-vec) before checking, then report",
+    )
+
+    # v3.8.2 super-help — grouped overview of every command + focused topics.
+    help_p = sub.add_parser(
+        "help",
+        help="Grouped overview of all commands + topics (modes, config, self-heal)",
+    )
+    help_p.add_argument(
+        "topic", nargs="?",
+        help="Optional topic: modes | config | self-heal",
+    )
 
     # LLD-06 §6.6 — `slm wrap <agent> [args...]` activates the Optimize
     # proxy for a specific agent. Supported agents: claude, claude-settings,
@@ -816,8 +880,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/setup_wizard.py

@@ -100,6 +100,25 @@ def _get_ram_gb() -> float:
     return 0.0
 
 
+def _ollama_available() -> bool:
+    """True if a local Ollama server is reachable (or its binary is installed).
+
+    v3.8.2: used to RECOMMEND Mode B at setup with a single keypress. Bounded
+    and fail-safe — a slow/absent Ollama never blocks or slows the wizard.
+    """
+    try:
+        import httpx
+
+        if httpx.get("http://localhost:11434/api/tags", timeout=1.5).status_code == 200:
+            return True
+    except Exception:
+        pass
+    try:
+        return shutil.which("ollama") is not None
+    except Exception:
+        return False
+
+
 # ---------------------------------------------------------------------------
 # Model download
 # ---------------------------------------------------------------------------
@@ -388,14 +407,23 @@ def run_wizard(auto: bool = False) -> None:
         return
 
     # -- Step 2: Mode selection --
+    # v3.8.2: pre-detect Ollama so we can recommend Mode B with one keypress.
+    # No detection → zero-config Mode A. (Non-interactive always stays A: Mode B
+    # needs a pulled model, so we never assume it without the user confirming.)
+    ollama_present = _ollama_available()
+    default_mode = "b" if ollama_present else "a"
     print()
     print("─── Step 2/10: Choose Operating Mode ───")
     print()
-    print("  [A] Local Guardian (recommended)")
+    if ollama_present:
+        print("  ✓ Ollama detected on this machine — Mode B recommended.")
+        print("    Press Enter to accept, or pick another mode.")
+        print()
+    print("  [A] Local Guardian" + ("" if ollama_present else " (recommended)"))
     print("      No model-provider call in the core memory path.")
     print("      Review optional integrations and network policy for your deployment.")
     print()
-    print("  [B] Smart Local")
+    print("  [B] Smart Local" + (" (recommended — Ollama detected)" if ollama_present else ""))
     print("      Local LLM via Ollama for enrichment.")
     print("      Data stays on your machine.")
     print()
@@ -405,10 +433,13 @@ def run_wizard(auto: bool = False) -> None:
     print()
 
     if interactive:
-        choice = _prompt("  Select mode [A/B/C] (default: A): ", "a").lower()
+        choice = _prompt(
+            f"  Select mode [A/B/C] (default: {default_mode.upper()}): ",
+            default_mode,
+        ).lower()
     else:
         choice = "a"
-        print("  Auto-selecting Mode A (non-interactive)")
+        print("  Auto-selecting Mode A (non-interactive, zero-config)")
 
     if choice not in ("a", "b", "c"):
         print(f"  Invalid choice '{choice}', using Mode A.")
@@ -496,6 +527,15 @@ def run_wizard(auto: bool = False) -> None:
     else:
         print(f"\n  ✓ CodeGraph disabled (enable later in {cg_config_path})")
 
+    # v3.8.2: up-front download summary so a large pull is never a surprise on
+    # a metered/slow link. Sizes approximate, one-time, cached locally.
+    if st_ok and not _embedding_is_remote(config):
+        print()
+        print("  Models to download (one-time, cached locally):")
+        print("    • Embedding model   ~500 MB  — required for semantic recall")
+        print("    • Reranker model    ~130 MB  — result quality")
+        print("    • Compression model ~560 MB  — optional (you'll be asked)")
+
     # -- Step 4: Download models --
     print()
     # H-06 (CVE-2025-14926): a malicious HuggingFace checkpoint can execute code
@@ -532,8 +572,25 @@ def run_wizard(auto: bool = False) -> None:
         _download_reranker(_RERANKER_MODEL)
 
     print()
-    print("─── Step 4c/10: Download Compression Model (LLMLingua-2) ───")
-    _download_compressor(_COMPRESSOR_MODEL)
+    print("─── Step 4c/10: Compression Model (LLMLingua-2, ~560MB) ───")
+    print("  Only used for aggressive prompt compression. It also downloads")
+    print("  automatically the first time you enable that feature — so skipping")
+    print("  here is safe.")
+    # v3.8.2: consent-gate the 560MB compressor (was unconditional). Skip by
+    # default; it lazy-downloads on first real use of compression.
+    if not st_ok:
+        print("  ⚠ Skipped (sentence-transformers not installed)")
+    elif interactive:
+        comp_choice = _prompt(
+            "  Download the ~560MB compression model now? [y/N] (default: N): ",
+            "n",
+        ).lower()
+        if comp_choice in ("y", "yes"):
+            _download_compressor(_COMPRESSOR_MODEL)
+        else:
+            print("  ✓ Skipped — downloads automatically when you enable compression.")
+    else:
+        print("  ✓ Skipped (non-interactive) — downloads on first use.")
 
     # -- Step 5: Daemon Configuration (v3.4.3) --
     print()
@@ -655,17 +712,21 @@ def run_wizard(auto: bool = False) -> None:
     print("  It detects degradation, generates improvements, and verifies them blindly.")
     print("  Requires an LLM backend (Claude CLI, Ollama, or API key).")
     print()
+    print("  OFF by default — when enabled it makes background LLM calls.")
     print("  [Y] Enable Skill Evolution")
-    print("  [N] Disable (can enable later: slm config set evolution.enabled true)")
+    print("  [N] Keep disabled (enable later: slm config set evolution.enabled true)")
     print()
 
+    # v3.8.2: default OFF (was Y) — consistent with the npm profiles and no
+    # surprise outbound LLM calls for a fresh user. Opt-in, not opt-out.
     if interactive:
-        evo_choice = _prompt("  Enable Skill Evolution? [Y/n] (default: Y): ", "y").lower()
+        evo_choice = _prompt("  Enable Skill Evolution? [y/N] (default: N): ", "n").lower()
     else:
-        evo_choice = "y"
-        print("  Auto-enabling Skill Evolution (non-interactive)")
+        evo_choice = "n"
+        print("  Skill Evolution stays OFF (non-interactive) — enable later with:")
+        print("    slm config set evolution.enabled true")
 
-    evolution_enabled = evo_choice in ("", "y", "yes")
+    evolution_enabled = evo_choice in ("y", "yes")
 
     # Write evolution config to config.json directly
     # (SLMConfig.save() doesn't serialize evolution)
@@ -753,6 +814,21 @@ def run_wizard(auto: bool = False) -> None:
     else:
         print("  Adapters: none (enable via: slm adapters enable gmail)")
     print()
+    # v3.8.2: surface component self-heal status so the user leaves setup
+    # KNOWING everything they need is present — or exactly what to run if not.
+    try:
+        from superlocalmemory.core import component_registry as _cr
+
+        _sum = _cr.snapshot(config)["summary"]
+        if _sum.get("healthy"):
+            print("  ✓ All components ready — models and dependencies present.")
+        else:
+            print(f"  ⚠ {_sum.get('missing', 0)} component(s) need attention.")
+            print("    SLM auto-repairs fixable ones on daemon start. To check/fix now:")
+            print("      slm doctor          (auto-fix: slm doctor --fix)")
+    except Exception:
+        pass
+    print()
     print("  Quick start:")
     print('    slm remember "your first memory"')
     print('    slm recall "search query"')
@@ -760,8 +836,8 @@ def run_wizard(auto: bool = False) -> None:
     print("    slm adapters enable gmail  → start Gmail ingestion")
     print()
     print("  Need help?")
-    print("    slm doctor     — diagnose issues")
-    print("    slm --help     — all commands")
+    print("    slm help       — every command, grouped (try: slm help self-heal)")
+    print("    slm doctor     — diagnose issues (auto-fix: slm doctor --fix)")
     print("    slm serve install — install auto-start service")
     print("    https://github.com/qualixar/superlocalmemory")
     print()
@@ -816,20 +892,70 @@ def check_first_use(command: str) -> None:
 
 
 def _configure_external_integrations(*, interactive: bool) -> bool:
-    """Request consent before editing Claude Code configuration."""
+    """Request consent before editing Claude Code configuration.
+
+    v3.8.2: after the Claude Code step, a pip user can also wire every OTHER
+    detected IDE in one step (previously only Claude Code was offered here;
+    other IDEs required a manual `slm connect <ide>` each).
+    """
     print()
     print("  Optional Claude Code integration can install the SLM plugin and hooks.")
     if not interactive:
         print("  Skipped in non-interactive setup. Run: slm connect claude-code")
         return False
+    changed = False
     choice = _prompt(
         "  Install Claude Code plugin and hooks now? [y/N] (default: N): ",
         "n",
     ).lower()
-    if choice not in ("y", "yes"):
+    if choice in ("y", "yes"):
+        changed = _install_external_integrations()
+    else:
         print("  Skipped. Run `slm connect claude-code` when ready.")
+    # v3.8.2: offer to connect all other detected IDEs (Cursor, VS Code, …).
+    changed = _configure_other_ides(interactive=interactive) or changed
+    return changed
+
+
+def _configure_other_ides(*, interactive: bool) -> bool:
+    """Consent-gated: connect all OTHER detected IDEs (Cursor, VS Code, …).
+
+    Uses the same IDEConnector the dashboard uses. Best-effort — a failure to
+    detect or connect any single IDE never blocks setup.
+    """
+    if not interactive:
+        return False
+    try:
+        from superlocalmemory.hooks.ide_connector import IDEConnector
+
+        connector = IDEConnector()
+        installed = [s for s in connector.get_status() if s.get("installed")]
+    except Exception:
         return False
-    return _install_external_integrations()
+    others = [s for s in installed if s.get("id") not in ("claude-code", "claude")]
+    if not others:
+        return False
+    names = ", ".join(s.get("name", s.get("id")) for s in others)
+    print()
+    print(f"  Detected other IDEs: {names}")
+    print("  SLM can wire them all so memory works across every editor.")
+    choice = _prompt("  Connect them now? [Y/n] (default: Y): ", "y").lower()
+    if choice not in ("", "y", "yes"):
+        print("  Skipped. Connect any later with: slm connect <ide>")
+        return False
+    changed = False
+    for s in others:
+        ide_id = s.get("id")
+        label = s.get("name", ide_id)
+        try:
+            if connector.connect(ide_id):
+                print(f"    ✓ {label}")
+                changed = True
+            else:
+                print(f"    ⚠ {label} — connect later: slm connect {ide_id}")
+        except Exception:
+            print(f"    ⚠ {label} — connect later: slm connect {ide_id}")
+    return changed
 
 
 def _install_external_integrations() -> bool:

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,