superlocalmemory 3.4.1 → 3.4.4

package/src/superlocalmemory/cli/service_installer.py

@@ -0,0 +1,367 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the Elastic License 2.0 - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""OS-level service installer — daemon survives reboots.
+
+Cross-platform:
+  - macOS:   LaunchAgent plist (user-level, no sudo)
+  - Linux:   systemd user service (no sudo)
+  - Windows: Task Scheduler (runs at logon)
+
+Usage:
+  slm serve install   — install OS service
+  slm serve uninstall — remove OS service
+  slm serve status    — show daemon + service status
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_SERVICE_NAME = "com.qualixar.superlocalmemory"
+_DISPLAY_NAME = "SuperLocalMemory Daemon"
+
+
+def get_python_path() -> str:
+    """Get the full path to the Python interpreter running SLM."""
+    return sys.executable
+
+
+def get_log_path() -> Path:
+    log_dir = Path.home() / ".superlocalmemory" / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir / "daemon.log"
+
+
+def get_error_log_path() -> Path:
+    log_dir = Path.home() / ".superlocalmemory" / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir / "daemon-error.log"
+
+
+# ─── macOS: LaunchAgent ───────────────────────────────────────────────────
+
+def _macos_plist_path() -> Path:
+    return Path.home() / "Library" / "LaunchAgents" / f"{_SERVICE_NAME}.plist"
+
+
+def _macos_plist_content() -> str:
+    python = get_python_path()
+    log = get_log_path()
+    err_log = get_error_log_path()
+
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>{_SERVICE_NAME}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>{python}</string>
+        <string>-m</string>
+        <string>superlocalmemory.server.unified_daemon</string>
+        <string>--start</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
+    <key>StandardOutPath</key>
+    <string>{log}</string>
+    <key>StandardErrorPath</key>
+    <string>{err_log}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/usr/bin:/bin:{Path(python).parent}</string>
+        <key>HOME</key>
+        <string>{Path.home()}</string>
+    </dict>
+</dict>
+</plist>
+"""
+
+
+def install_macos() -> bool:
+    plist = _macos_plist_path()
+    plist.parent.mkdir(parents=True, exist_ok=True)
+    plist.write_text(_macos_plist_content())
+    logger.info("Wrote LaunchAgent plist: %s", plist)
+
+    # Load the service
+    try:
+        subprocess.run(
+            ["launchctl", "unload", str(plist)],
+            capture_output=True, timeout=10,
+        )
+    except Exception:
+        pass
+
+    result = subprocess.run(
+        ["launchctl", "load", str(plist)],
+        capture_output=True, text=True, timeout=10,
+    )
+    if result.returncode == 0:
+        logger.info("LaunchAgent loaded successfully")
+        return True
+    else:
+        logger.error("launchctl load failed: %s", result.stderr)
+        return False
+
+
+def uninstall_macos() -> bool:
+    plist = _macos_plist_path()
+    if plist.exists():
+        try:
+            subprocess.run(
+                ["launchctl", "unload", str(plist)],
+                capture_output=True, timeout=10,
+            )
+        except Exception:
+            pass
+        plist.unlink()
+        logger.info("LaunchAgent removed: %s", plist)
+    return True
+
+
+def status_macos() -> dict:
+    result = subprocess.run(
+        ["launchctl", "list", _SERVICE_NAME],
+        capture_output=True, text=True, timeout=10,
+    )
+    installed = result.returncode == 0
+    return {
+        "platform": "macOS",
+        "service_type": "LaunchAgent",
+        "installed": installed,
+        "plist_path": str(_macos_plist_path()),
+        "details": result.stdout.strip() if installed else "Not installed",
+    }
+
+
+# ─── Linux: systemd user service ──────────────────────────────────────────
+
+def _linux_service_path() -> Path:
+    return Path.home() / ".config" / "systemd" / "user" / "superlocalmemory.service"
+
+
+def _linux_service_content() -> str:
+    python = get_python_path()
+    log = get_log_path()
+
+    return f"""[Unit]
+Description={_DISPLAY_NAME}
+After=network.target
+
+[Service]
+Type=simple
+ExecStart={python} -m superlocalmemory.server.unified_daemon --start
+Restart=on-failure
+RestartSec=30
+StandardOutput=append:{log}
+StandardError=append:{get_error_log_path()}
+Environment=HOME={Path.home()}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin:{Path(python).parent}
+
+[Install]
+WantedBy=default.target
+"""
+
+
+def install_linux() -> bool:
+    service = _linux_service_path()
+    service.parent.mkdir(parents=True, exist_ok=True)
+    service.write_text(_linux_service_content())
+    logger.info("Wrote systemd user service: %s", service)
+
+    try:
+        subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True, timeout=10)
+        subprocess.run(["systemctl", "--user", "enable", "superlocalmemory"], capture_output=True, timeout=10)
+        result = subprocess.run(
+            ["systemctl", "--user", "start", "superlocalmemory"],
+            capture_output=True, text=True, timeout=10,
+        )
+        if result.returncode == 0:
+            logger.info("systemd user service started")
+            return True
+        else:
+            logger.error("systemctl start failed: %s", result.stderr)
+            return False
+    except FileNotFoundError:
+        logger.warning("systemctl not found — systemd not available on this system")
+        return False
+
+
+def uninstall_linux() -> bool:
+    try:
+        subprocess.run(["systemctl", "--user", "stop", "superlocalmemory"], capture_output=True, timeout=10)
+        subprocess.run(["systemctl", "--user", "disable", "superlocalmemory"], capture_output=True, timeout=10)
+    except Exception:
+        pass
+    service = _linux_service_path()
+    if service.exists():
+        service.unlink()
+        logger.info("systemd user service removed: %s", service)
+    try:
+        subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True, timeout=10)
+    except Exception:
+        pass
+    return True
+
+
+def status_linux() -> dict:
+    try:
+        result = subprocess.run(
+            ["systemctl", "--user", "is-active", "superlocalmemory"],
+            capture_output=True, text=True, timeout=10,
+        )
+        active = result.stdout.strip() == "active"
+        return {
+            "platform": "Linux",
+            "service_type": "systemd user service",
+            "installed": True,
+            "active": active,
+            "details": result.stdout.strip(),
+        }
+    except Exception:
+        return {"platform": "Linux", "service_type": "systemd", "installed": False}
+
+
+# ─── Windows: Task Scheduler ─────────────────────────────────────────────
+
+_WINDOWS_TASK_NAME = "SuperLocalMemory"
+
+
+def install_windows() -> bool:
+    python = get_python_path()
+    log = get_log_path()
+
+    # Create a VBS wrapper to run Python without console window
+    vbs_path = Path.home() / ".superlocalmemory" / "start-daemon.vbs"
+    vbs_path.parent.mkdir(parents=True, exist_ok=True)
+    vbs_content = (
+        f'Set WshShell = CreateObject("WScript.Shell")\n'
+        f'WshShell.Run """{python}"" -m superlocalmemory.server.unified_daemon --start", 0, False\n'
+    )
+    vbs_path.write_text(vbs_content)
+
+    # Use schtasks to create a logon trigger task
+    try:
+        # Remove existing task if any
+        subprocess.run(
+            ["schtasks", "/Delete", "/TN", _WINDOWS_TASK_NAME, "/F"],
+            capture_output=True, timeout=10,
+        )
+    except Exception:
+        pass
+
+    try:
+        result = subprocess.run(
+            [
+                "schtasks", "/Create",
+                "/TN", _WINDOWS_TASK_NAME,
+                "/TR", f'wscript.exe "{vbs_path}"',
+                "/SC", "ONLOGON",
+                "/RL", "LIMITED",
+                "/F",
+            ],
+            capture_output=True, text=True, timeout=10,
+        )
+        if result.returncode == 0:
+            logger.info("Windows Task Scheduler task created: %s", _WINDOWS_TASK_NAME)
+            return True
+        else:
+            logger.error("schtasks create failed: %s", result.stderr)
+            return False
+    except FileNotFoundError:
+        logger.warning("schtasks not found — not a standard Windows system")
+        return False
+
+
+def uninstall_windows() -> bool:
+    try:
+        subprocess.run(
+            ["schtasks", "/Delete", "/TN", _WINDOWS_TASK_NAME, "/F"],
+            capture_output=True, timeout=10,
+        )
+        logger.info("Windows Task Scheduler task removed")
+    except Exception:
+        pass
+
+    vbs_path = Path.home() / ".superlocalmemory" / "start-daemon.vbs"
+    if vbs_path.exists():
+        vbs_path.unlink()
+
+    return True
+
+
+def status_windows() -> dict:
+    try:
+        result = subprocess.run(
+            ["schtasks", "/Query", "/TN", _WINDOWS_TASK_NAME, "/FO", "LIST"],
+            capture_output=True, text=True, timeout=10,
+        )
+        installed = result.returncode == 0
+        return {
+            "platform": "Windows",
+            "service_type": "Task Scheduler",
+            "installed": installed,
+            "task_name": _WINDOWS_TASK_NAME,
+            "details": result.stdout.strip()[:200] if installed else "Not installed",
+        }
+    except Exception:
+        return {"platform": "Windows", "service_type": "Task Scheduler", "installed": False}
+
+
+# ─── Cross-platform dispatcher ───────────────────────────────────────────
+
+def install_service() -> bool:
+    """Install OS-level service for auto-start on login/boot."""
+    if sys.platform == "darwin":
+        return install_macos()
+    elif sys.platform == "win32":
+        return install_windows()
+    elif sys.platform.startswith("linux"):
+        return install_linux()
+    else:
+        logger.warning("Unsupported platform: %s", sys.platform)
+        return False
+
+
+def uninstall_service() -> bool:
+    """Remove OS-level service."""
+    if sys.platform == "darwin":
+        return uninstall_macos()
+    elif sys.platform == "win32":
+        return uninstall_windows()
+    elif sys.platform.startswith("linux"):
+        return uninstall_linux()
+    else:
+        return False
+
+
+def service_status() -> dict:
+    """Get OS-level service status."""
+    if sys.platform == "darwin":
+        return status_macos()
+    elif sys.platform == "win32":
+        return status_windows()
+    elif sys.platform.startswith("linux"):
+        return status_linux()
+    else:
+        return {"platform": sys.platform, "installed": False, "details": "Unsupported platform"}

package/src/superlocalmemory/cli/setup_wizard.py

@@ -259,7 +259,7 @@ def run_wizard(auto: bool = False) -> None:
 
     print()
     print("╔══════════════════════════════════════════════════════════╗")
-    print("║  SuperLocalMemory V3 — Setup Wizard                    ║")
+    print("║  SuperLocalMemory V3 — The Unified Brain               ║")
     print("║  by Varun Pratap Bhardwaj / Qualixar                   ║")
     print("╚══════════════════════════════════════════════════════════╝")
     print()
@@ -373,9 +373,9 @@ def run_wizard(auto: bool = False) -> None:
     else:
         print(f"\n  ✓ CodeGraph disabled (enable later in {cg_config_path})")
 
-    # -- Step 4: Download embedding model --
+    # -- Step 4: Download models --
     print()
-    print("─── Step 4/6: Download Embedding Model ───")
+    print("─── Step 4/9: Download Embedding Model ───")
 
     if not st_ok:
         print("  ⚠ Skipped (sentence-transformers not installed)")
@@ -385,18 +385,129 @@ def run_wizard(auto: bool = False) -> None:
         if not embed_ok:
             print("  ⚠ Model will download on first use (may take a few minutes)")
 
-    # -- Step 4: Download reranker model --
     print()
-    print("─── Step 5/6: Download Reranker Model ───")
+    print("─── Step 4b/9: Download Reranker Model ───")
 
     if not st_ok:
         print("  ⚠ Skipped (sentence-transformers not installed)")
     else:
         _download_reranker(_RERANKER_MODEL)
 
-    # -- Step 5: Verification --
+    # -- Step 5: Daemon Configuration (v3.4.3) --
+    print()
+    print("─── Step 5/9: Daemon Configuration ───")
+    print()
+    print("  The SLM daemon runs in the background for instant memory access.")
+    print()
+    print("  [1] 24/7 Always-On (recommended — brain never sleeps)")
+    print("  [2] Auto-shutdown after idle (saves RAM when not coding)")
     print()
-    print("─── Step 6/6: Verification ───")
+
+    if interactive:
+        daemon_choice = _prompt("  Select daemon mode [1/2] (default: 1): ", "1")
+    else:
+        daemon_choice = "1"
+        print("  Auto-selecting 24/7 mode (non-interactive)")
+
+    if daemon_choice == "2":
+        if interactive:
+            timeout_choice = _prompt("  Idle timeout [30m/1h/2h] (default: 30m): ", "30m")
+        else:
+            timeout_choice = "30m"
+        timeout_map = {"30m": 1800, "1h": 3600, "2h": 7200}
+        config.daemon_idle_timeout = timeout_map.get(timeout_choice, 1800)
+        print(f"\n  ✓ Auto-shutdown after {timeout_choice} idle")
+    else:
+        config.daemon_idle_timeout = 0
+        print("\n  ✓ 24/7 Always-On mode")
+
+    config.save()
+
+    # -- Step 6: Mesh Communication (v3.4.3) --
+    print()
+    print("─── Step 6/9: Mesh Communication ───")
+    print()
+    print("  SLM Mesh enables agent-to-agent P2P communication.")
+    print("  Multiple AI sessions can share knowledge in real-time.")
+    print()
+    print("  [Y] Enable Mesh (recommended)")
+    print("  [N] Disable Mesh")
+    print()
+
+    if interactive:
+        mesh_choice = _prompt("  Enable Mesh? [Y/n] (default: Y): ", "y").lower()
+    else:
+        mesh_choice = "y"
+        print("  Auto-enabling Mesh (non-interactive)")
+
+    config.mesh_enabled = mesh_choice in ("", "y", "yes")
+    config.save()
+    print(f"\n  ✓ Mesh {'enabled' if config.mesh_enabled else 'disabled'}")
+
+    # -- Step 7: Ingestion Adapters (v3.4.3) --
+    print()
+    print("─── Step 7/9: Ingestion Adapters ───")
+    print()
+    print("  These let SLM learn from your email, calendar, and meetings.")
+    print("  All adapters are OFF by default. You can enable them later.")
+    print()
+    print("  Available adapters:")
+    print("    • Gmail Ingestion     — requires Google OAuth setup")
+    print("    • Google Calendar     — shares Gmail credentials")
+    print("    • Meeting Transcripts — watches a folder for .srt/.vtt files")
+    print()
+
+    if interactive:
+        adapter_input = _prompt("  Enable any now? [Enter to skip, or type: gmail,calendar,transcript]: ", "")
+    else:
+        adapter_input = ""
+
+    # Save adapter preferences (actual setup happens via `slm adapters enable X`)
+    adapters_config = {"gmail": False, "calendar": False, "transcript": False}
+    if adapter_input:
+        for name in adapter_input.split(","):
+            name = name.strip().lower()
+            if name in adapters_config:
+                adapters_config[name] = True
+
+    adapters_path = _SLM_HOME / "adapters.json"
+    import json as _json
+    adapters_path.write_text(_json.dumps(
+        {k: {"enabled": v, "tier": "polling"} for k, v in adapters_config.items()},
+        indent=2,
+    ))
+
+    enabled_adapters = [k for k, v in adapters_config.items() if v]
+    if enabled_adapters:
+        print(f"\n  ✓ Enabled: {', '.join(enabled_adapters)}")
+        print("    Run `slm adapters start <name>` to begin ingestion")
+    else:
+        print("\n  ✓ All adapters disabled (enable later: slm adapters enable gmail)")
+
+    # -- Step 8: Entity Compilation (v3.4.3) --
+    print()
+    print("─── Step 8/9: Entity Compilation ───")
+    print()
+    print("  Entity compilation builds knowledge summaries per person,")
+    print("  project, and concept. Runs automatically during consolidation.")
+    print()
+    print("  [Y] Enable entity compilation (recommended)")
+    print("  [N] Disable")
+    print()
+
+    if interactive:
+        ec_choice = _prompt("  Enable entity compilation? [Y/n] (default: Y): ", "y").lower()
+    else:
+        ec_choice = "y"
+        print("  Auto-enabling entity compilation (non-interactive)")
+
+    config.entity_compilation_enabled = ec_choice in ("", "y", "yes")
+    config.save()
+    print(f"\n  ✓ Entity compilation {'enabled' if config.entity_compilation_enabled else 'disabled'}")
+
+    # -- Step 9: Verification --
+    print()
+    print("─── Step 9/9: Verification ───")
 
     if st_ok:
         verified = _verify_installation()
@@ -410,20 +521,50 @@ def run_wizard(auto: bool = False) -> None:
     print()
     print("╔══════════════════════════════════════════════════════════╗")
     if verified:
-        print("║  ✓ Setup Complete — SuperLocalMemory is ready!         ║")
+        print("║  ✓ Setup Complete — The Unified Brain is ready!        ║")
     else:
         print("║  ✓ Setup Complete — basic config saved                 ║")
         print("║    Models will auto-download on first use              ║")
     print("╚══════════════════════════════════════════════════════════╝")
     print()
+
+    # Summary of choices
+    daemon_mode = "24/7" if config.daemon_idle_timeout == 0 else f"auto-shutdown ({config.daemon_idle_timeout}s)"
+    print(f"  Enabled: Mode {choice.upper()}, Daemon ({daemon_mode})", end="")
+    if config.mesh_enabled:
+        print(", Mesh", end="")
+    if config.entity_compilation_enabled:
+        print(", Entity Compilation", end="")
+    if code_graph_enabled:
+        print(", CodeGraph", end="")
+    print()
+    if enabled_adapters:
+        print(f"  Adapters: {', '.join(enabled_adapters)}")
+    else:
+        print("  Adapters: none (enable via: slm adapters enable gmail)")
+    print()
     print("  Quick start:")
     print('    slm remember "your first memory"')
     print('    slm recall "search query"')
-    print("    slm dashboard")
+    print("    slm dashboard              → http://localhost:8765")
+    print("    slm adapters enable gmail  → start Gmail ingestion")
+    print()
+    # V3.4.4: Auto-install OS service for daemon persistence (survive reboots)
+    try:
+        from superlocalmemory.cli.service_installer import install_service
+        print("  Installing OS service for auto-start...")
+        if install_service():
+            print("  ✓ SLM will auto-start on login — zero friction.")
+        else:
+            print("  ⚠ OS service not installed (run: slm serve install)")
+    except Exception:
+        print("  ⚠ Could not install OS service (run: slm serve install)")
+
     print()
     print("  Need help?")
     print("    slm doctor     — diagnose issues")
     print("    slm --help     — all commands")
+    print("    slm serve install — install auto-start service")
     print("    https://github.com/qualixar/superlocalmemory")
     print()
 

package/src/superlocalmemory/core/config.py

@@ -153,6 +153,10 @@ class RetrievalConfig:
     temporal_proximity_days: int = 30
 
     # Reranking (V3.3.2: ONNX backend enabled for all modes)
+    # V3.4.2: Tested gte-reranker-modernbert-base (8K context) — REGRESSED
+    # LoCoMo from 68.4% to 64.1%. Reverted to MiniLM-L-12-v2. The 512-token
+    # limit is acceptable because SLM's 6-channel retrieval pre-filters
+    # relevant facts before reranking. See bench-v342-locomo.md.
     use_cross_encoder: bool = True
     cross_encoder_model: str = "cross-encoder/ms-marco-MiniLM-L-12-v2"
     cross_encoder_backend: str = ""  # "" = PyTorch (~500MB stable), "onnx" = ONNX (leaks on ARM64 CoreML)
@@ -577,6 +581,19 @@ class SLMConfig:
         default_factory=ParameterizationConfig,
     )
 
+    # v3.4.3: Daemon configuration
+    daemon_idle_timeout: int = 0       # 0 = 24/7 (no auto-kill). >0 = seconds before auto-kill.
+    daemon_port: int = 8765            # Primary daemon port
+    daemon_legacy_port: int = 8767     # Backward-compat redirect port
+    daemon_enable_legacy_port: bool = True  # Set False to disable 8767 redirect
+
+    # v3.4.3: Entity compilation
+    entity_compilation_enabled: bool = True
+    entity_compilation_retrieval_boost: float = 1.0  # 1.0 = disabled. >1.0 = boost score.
+
+    # v3.4.3: Mesh
+    mesh_enabled: bool = True
+
     def __post_init__(self) -> None:
         if self.db_path is None:
             self.db_path = self.base_dir / DEFAULT_DB_NAME
@@ -629,6 +646,17 @@ class SLMConfig:
                 if k in RetrievalConfig.__dataclass_fields__
             })
 
+        # V3.4.3 config fields (additive — missing keys get dataclass defaults)
+        config.daemon_idle_timeout = data.get("daemon_idle_timeout", 0)
+        config.daemon_port = data.get("daemon_port", 8765)
+        config.daemon_legacy_port = data.get("daemon_legacy_port", 8767)
+        config.daemon_enable_legacy_port = data.get("daemon_enable_legacy_port", True)
+        config.entity_compilation_enabled = data.get("entity_compilation_enabled", True)
+        config.entity_compilation_retrieval_boost = data.get(
+            "entity_compilation_retrieval_boost", 1.0,
+        )
+        config.mesh_enabled = data.get("mesh_enabled", True)
+
         return config
 
     def save(self, config_path: Path | None = None) -> None:

package/src/superlocalmemory/core/consolidation_engine.py

@@ -27,6 +27,7 @@ from __future__ import annotations
 
 import json
 import logging
+import threading
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any
 
@@ -141,7 +142,13 @@ class ConsolidationEngine:
         """Called after each store() in store_pipeline.py.
 
         Increments internal counter.  When counter hits step_count_trigger
-        (default 50), runs lightweight consolidation.
+        (default 50), runs lightweight consolidation AND queues async
+        graph analysis.
+
+        V3.4.2: Graph analysis runs in background thread after every
+        lightweight consolidation trigger. This populates fact_importance
+        (PageRank, communities, bridge scores) so retrieval channels can
+        use graph intelligence without blocking store/recall latency.
 
         Returns True if lightweight consolidation was triggered.
         """
@@ -152,9 +159,39 @@ class ConsolidationEngine:
         if self._store_count >= self._config.step_count_trigger:
             self._store_count = 0
             self.consolidate(profile_id, lightweight=True)
+            # V3.4.2: Queue graph analysis in background (non-blocking)
+            self._queue_graph_analysis(profile_id)
             return True
         return False
 
+    def _queue_graph_analysis(self, profile_id: str) -> None:
+        """Run graph_analyzer.compute_and_store() in a background thread.
+
+        V3.4.2: Populates fact_importance table with PageRank, community_id,
+        degree_centrality, and bridge_score. Next recall() automatically
+        uses updated graph intelligence for entity channel and spreading
+        activation. Takes ~200-800ms, runs on daemon thread, zero impact
+        on store/recall latency.
+        """
+        if self._graph_analyzer is None:
+            return
+        analyzer = self._graph_analyzer
+        pid = profile_id
+
+        def _run() -> None:
+            try:
+                result = analyzer.compute_and_store(pid)
+                logger.info(
+                    "Background graph analysis complete: %d nodes, %d communities",
+                    result.get("node_count", 0),
+                    result.get("community_count", 0),
+                )
+            except Exception as exc:
+                logger.debug("Background graph analysis failed (non-fatal): %s", exc)
+
+        t = threading.Thread(target=_run, daemon=True, name="graph-analysis-bg")
+        t.start()
+
     def get_core_memory(self, profile_id: str) -> dict[str, str]:
         """Load all Core Memory blocks for a profile.