superlocalmemory 3.4.1 → 3.4.4

package/README.md

@@ -2,9 +2,9 @@
   <img src="https://superlocalmemory.com/assets/logo-mark.png" alt="SuperLocalMemory" width="200"/>
 </p>
 
-<h1 align="center">SuperLocalMemory V3.3</h1>
+<h1 align="center">SuperLocalMemory V3.4</h1>
 <p align="center"><strong>Every other AI forgets. Yours won't.</strong><br/><em>Infinite memory for Claude Code, Cursor, Windsurf & 17+ AI tools.</em></p>
-<p align="center"><code>v3.3.26</code> — Install once. Every session remembers the last. Automatically.</p>
+<p align="center"><code>v3.4.4 "Neural Glass"</code> — Install once. Every session remembers the last. Automatically.</p>
 <p align="center"><strong>Backed by 3 peer-reviewed research papers</strong> · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 
 <p align="center">
@@ -340,20 +340,17 @@ slm dashboard    # Opens at http://localhost:8765
 ```
 
 <details open>
-<summary><strong>Dashboard Screenshots</strong> (click to collapse)</summary>
-<p align="center"><img src="docs/screenshots/01-dashboard-main.png" alt="Dashboard Overview — 3,100+ memories, 430K connections" width="600"/></p>
+<summary><strong>Dashboard Demo — v3.4.4 "Neural Glass"</strong> (click to collapse)</summary>
 <p align="center">
-<img src="docs/screenshots/02-knowledge-graph.png" alt="Knowledge Graph — Sigma.js WebGL with community detection, chat, quick actions, timeline" width="290"/>
-<img src="docs/screenshots/06-graph-communities.png" alt="Graph Communities — Louvain clustering with colored nodes" width="290"/>
-</p>
-<p align="center">
-<img src="docs/screenshots/03-patterns-learning.png" alt="Patterns — 50 learned behavioral patterns with confidence bars" width="190"/>
-<img src="docs/screenshots/04-learning-dashboard.png" alt="Learning — 722 signals, ML Model phase, tech preferences" width="190"/>
-<img src="docs/screenshots/05-behavioral-analysis.png" alt="Behavioral — pattern analysis with confidence distribution" width="190"/>
+  <a href="https://github.com/qualixar/superlocalmemory/issues/15">
+    <video src="https://github.com/user-attachments/assets/c3b54a1d-f62a-4ea7-bba7-900435e7b3ab" width="800" autoplay loop muted playsinline>
+      Your browser does not support the video tag. <a href="https://github.com/qualixar/superlocalmemory/issues/15">Watch the demo</a>.
+    </video>
+  </a>
 </p>
 </details>
 
-**v3.4.1 Visual Intelligence:** Sigma.js WebGL knowledge graph with community detection (Louvain/Leiden), 5 quick insight actions, D3 memory timeline, graph-enhanced retrieval (PageRank bias + community boost + contradiction suppression), and 56 auto-mined behavioral patterns. 23+ tabs. Runs locally — no data leaves your machine.
+**v3.4.4 "Neural Glass":** 21-tab sidebar dashboard with light + dark theme. Knowledge Graph (Sigma.js WebGL, community detection), Health Monitor, Entity Explorer (1,300+ entities), Mesh Peers (P2P agent communication), Ingestion Status (Gmail/Calendar/Transcript management), Privacy blur mode. Always-on daemon with auto-start. 8 mesh MCP tools built-in. Cross-platform: macOS + Windows + Linux. All data stays local.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.1",
+  "version": "3.4.4",
   "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.4.1"
+version = "3.4.4"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}
@@ -49,6 +49,9 @@ dependencies = [
     "tree-sitter-language-pack>=0.3,<2",
     "rustworkx>=0.15,<1",
     "watchdog>=4.0,<6",
+    # V3.4.3: Unified Brain
+    "psutil>=5.9.0",
+    "structlog>=24.0.0,<27.0.0",
 ]
 
 [project.optional-dependencies]
@@ -72,8 +75,14 @@ performance = [
     "diskcache>=5.6.0",
     "orjson>=3.9.0",
 ]
+ingestion = [
+    "keyring>=25.0.0",
+    "google-auth-oauthlib>=1.2.0",
+    "google-api-python-client>=2.100.0",
+    "icalendar>=6.0.0",
+]
 full = [
-    "superlocalmemory[search,ui,learning,performance]",
+    "superlocalmemory[search,ui,learning,performance,ingestion]",
 ]
 dev = [
     "pytest>=8.0",

package/scripts/postinstall.js

@@ -15,7 +15,7 @@ const os = require('os');
 const fs = require('fs');
 
 console.log('\n════════════════════════════════════════════════════════════');
-console.log('  SuperLocalMemory V3 — Post-Installation');
+console.log('  SuperLocalMemory V3 — The Unified Brain');
 console.log('  by Varun Pratap Bhardwaj / Qualixar');
 console.log('  https://github.com/qualixar/superlocalmemory');
 console.log('════════════════════════════════════════════════════════════\n');
@@ -164,6 +164,17 @@ if (pipInstall(perfDeps, 'performance')) {
     console.log('⚠ Performance deps skipped (system works fine without them).');
 }
 
+// V3.4.3: Unified Brain dependencies (health monitor, structured logging, file watching)
+const brainDeps = ['psutil>=5.9.0', 'structlog>=24.0.0', 'watchdog>=4.0.0'];
+console.log('\nInstalling Unified Brain dependencies (health monitor, file watcher)...');
+if (pipInstall(brainDeps, 'brain')) {
+    console.log('✓ Unified Brain deps installed (psutil + structlog + watchdog)');
+    console.log('  Health monitoring, structured logging, and file watching enabled');
+} else {
+    console.log('⚠ Unified Brain deps partially installed (health monitoring may be limited).');
+    console.log('  Run manually: pip install psutil structlog watchdog');
+}
+
 // --- Step 3b: Install the superlocalmemory package itself ---
 // This ensures `python -m superlocalmemory.cli.main` always resolves the
 // correct version, even when invoked outside the Node.js wrapper (e.g.,
@@ -281,13 +292,21 @@ if (setupResult.status === 0) {
 
 // --- Done ---
 console.log('\n════════════════════════════════════════════════════════════');
-console.log('  ✓ SuperLocalMemory V3 installed!');
+console.log('  ✓ SuperLocalMemory V3 — The Unified Brain installed!');
 console.log('');
 console.log('  Quick start:');
-console.log('    slm remember "..."   # Store a memory');
-console.log('    slm recall "..."     # Search memories');
-console.log('    slm dashboard        # Open web dashboard');
-console.log('    slm setup            # Re-run setup wizard');
+console.log('    slm remember "..."        # Store a memory');
+console.log('    slm recall "..."          # Search memories');
+console.log('    slm dashboard             # Open web dashboard');
+console.log('    slm serve                 # Start 24/7 daemon');
+console.log('    slm adapters enable gmail # Enable Gmail ingestion');
+console.log('    slm setup                 # Re-run 9-step wizard');
+console.log('');
+console.log('  New in v3.4.3:');
+console.log('    • Unified daemon (one process, 24/7, < 700MB)');
+console.log('    • SLM Mesh (agent-to-agent P2P built in)');
+console.log('    • Entity compilation (auto knowledge summaries)');
+console.log('    • Ingestion adapters (Gmail, Calendar, Transcripts)');
 console.log('');
-console.log('  Docs: https://github.com/qualixar/superlocalmemory/wiki');
+console.log('  Docs: https://github.com/qualixar/superlocalmemory');
 console.log('════════════════════════════════════════════════════════════\n');

package/src/superlocalmemory/cli/commands.py

@@ -58,6 +58,8 @@ def dispatch(args: Namespace) -> None:
         "reap": cmd_reap,
         # V3.3.21 daemon
         "serve": cmd_serve,
+        # V3.4.3 ingestion adapters
+        "adapters": cmd_adapters,
     }
     handler = handlers.get(args.command)
     if handler:
@@ -94,6 +96,35 @@ def cmd_serve(args: Namespace) -> None:
                 print("Daemon: RUNNING (could not get status)")
         else:
             print("Daemon: NOT RUNNING")
+        # Also show OS service status
+        try:
+            from superlocalmemory.cli.service_installer import service_status
+            svc = service_status()
+            installed = svc.get("installed", False)
+            print(f"OS Service: {'INSTALLED' if installed else 'NOT INSTALLED'} "
+                  f"({svc.get('service_type', svc.get('platform', '?'))})")
+        except Exception:
+            pass
+        return
+
+    if action == 'install':
+        # Install OS-level service for auto-start on boot/login
+        from superlocalmemory.cli.service_installer import install_service
+        print("Installing SLM as OS service (auto-start on login)...")
+        if install_service():
+            print("Service installed \u2713 — SLM will auto-start on login.")
+            print("  slm serve status    — check service status")
+            print("  slm serve uninstall — remove auto-start")
+        else:
+            print("Failed to install service. Check logs.")
+        return
+
+    if action == 'uninstall':
+        from superlocalmemory.cli.service_installer import uninstall_service
+        if uninstall_service():
+            print("OS service removed \u2713 — SLM will no longer auto-start.")
+        else:
+            print("Failed to remove service.")
         return
 
     # Default: start
@@ -110,6 +141,26 @@ def cmd_serve(args: Namespace) -> None:
         print("Failed to start daemon. Check ~/.superlocalmemory/logs/daemon.log")
 
 
+# -- Ingestion Adapters (V3.4.3) ------------------------------------------
+
+
+def cmd_adapters(args: Namespace) -> None:
+    """Manage ingestion adapters (Gmail, Calendar, Transcript).
+
+    Usage:
+      slm adapters list                — show all adapters
+      slm adapters enable <name>       — enable an adapter
+      slm adapters disable <name>      — disable and stop
+      slm adapters start <name>        — start running
+      slm adapters stop <name>         — stop running
+      slm adapters status              — detailed status
+    """
+    from superlocalmemory.ingestion.adapter_manager import handle_adapters_cli
+    # args.rest contains everything after "adapters"
+    rest = getattr(args, 'rest', []) or []
+    handle_adapters_cli(rest)
+
+
 # -- Setup & Config (no --json — interactive commands) ---------------------
 
 
@@ -1159,72 +1210,32 @@ def _warmup_diagnose() -> None:
 
 
 def cmd_dashboard(args: Namespace) -> None:
-    """Launch the web dashboard."""
-    try:
-        import uvicorn
-    except ImportError:
-        print("Dashboard requires additional deps. Run: slm doctor")
-        print("Or install manually: pip install 'fastapi[all]' uvicorn")
-        sys.exit(1)
-
-    import os
-    import signal
-    import socket
-
-    port = getattr(args, "port", 8765)
-
-    def _kill_existing_on_port(target_port: int) -> None:
-        """Kill any existing SLM dashboard on the target port.
+    """Open the web dashboard in the browser.
 
-        V3.3.2: ONE port, no auto-increment. If port is busy with
-        another SLM instance, kill it. If busy with a non-SLM process,
-        warn and exit — never silently shift to a different port.
-        """
-        if sys.platform == "win32":
-            return  # Windows: user must close manually
-        try:
-            import subprocess
-            result = subprocess.run(
-                ["lsof", "-ti", f":{target_port}"],
-                capture_output=True, text=True, timeout=5,
-            )
-            if result.returncode == 0 and result.stdout.strip():
-                pids = result.stdout.strip().split("\n")
-                for pid_str in pids:
-                    pid = int(pid_str.strip())
-                    if pid == os.getpid():
-                        continue
-                    # Check if it's an SLM/Python process
-                    ps_result = subprocess.run(
-                        ["ps", "-p", str(pid), "-o", "command="],
-                        capture_output=True, text=True, timeout=5,
-                    )
-                    cmd = ps_result.stdout.strip().lower()
-                    if "superlocalmemory" in cmd or "slm" in cmd or "uvicorn" in cmd:
-                        os.kill(pid, signal.SIGTERM)
-                        print(f"  Stopped previous dashboard (PID {pid})")
-                        import time
-                        time.sleep(1)
-        except Exception:
-            pass  # Best-effort
-
-    _kill_existing_on_port(port)
+    v3.4.3: Dashboard is now served by the unified daemon. This command
+    ensures the daemon is running and opens the browser. It does NOT
+    start a separate server (saves ~500MB RAM from duplicate engine).
+    """
+    from superlocalmemory.cli.daemon import ensure_daemon, _get_port
 
-    # Brief wait for port to fully release after killing old process
-    import time
-    time.sleep(1)
+    port = getattr(args, "port", None) or _get_port()
 
-    print("=" * 60)
     print("  SuperLocalMemory V3 — Web Dashboard")
-    print("=" * 60)
-    print(f"  Dashboard:  http://localhost:{port}")
-    print(f"  API Docs:   http://localhost:{port}/api/docs")
-    print("  Press Ctrl+C to stop\n")
+    print(f"  Starting daemon if needed...")
+
+    if not ensure_daemon():
+        print("  ✗ Could not start daemon. Run `slm doctor` to diagnose.")
+        sys.exit(1)
 
-    from superlocalmemory.server.ui import create_app
+    url = f"http://localhost:{port}"
+    print(f"  ✓ Daemon running")
+    print(f"  Dashboard: {url}")
+    print(f"  API Docs:  {url}/docs")
 
-    app = create_app()
-    uvicorn.run(app, host="127.0.0.1", port=port, log_level="info")
+    # Open browser
+    import webbrowser
+    webbrowser.open(url)
+    print("\n  Dashboard opened in browser. Daemon continues running in background.")
 
 
 # -- Profiles (supports --json) -------------------------------------------

package/src/superlocalmemory/cli/daemon.py

@@ -2,26 +2,18 @@
 # Licensed under the Elastic License 2.0 - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
-"""SLM Daemon — keeps engine warm for instant CLI/MCP response.
+"""SLM Daemon — client functions for communicating with the unified daemon.
 
-Problem: CLI cold start is 23s (embedding worker spawn + model load).
-Solution: Background daemon keeps MemoryEngine warm. CLI commands route
-requests through the daemon via localhost HTTP (~10ms overhead).
+The unified daemon (server/unified_daemon.py) runs as a single FastAPI/uvicorn
+process on port 8765, with port 8767 as a backward-compat TCP redirect.
 
-Architecture:
-  slm serve       → starts daemon (engine init, workers warm, ~600MB RAM)
-  slm remember X  → HTTP POST to daemon → instant (no cold start)
-  slm recall X    → HTTP GET from daemon → instant
-  slm serve stop  → graceful shutdown, workers killed, RAM freed
+This module contains CLIENT functions used by CLI commands:
+  - is_daemon_running(): check if daemon is alive
+  - ensure_daemon(): start daemon if not running
+  - stop_daemon(): gracefully stop the daemon
+  - daemon_request(): send HTTP request to daemon
 
-Auto-start: if daemon not running on CLI use, starts it automatically.
-Auto-shutdown: after 30 min idle (configurable via SLM_DAEMON_IDLE_TIMEOUT).
-
-Memory safety:
-  - RSS watchdog on embedding worker (2.5GB cap)
-  - Worker recycling every 5000 requests
-  - Parent watchdog kills workers if daemon dies
-  - SQLite WAL mode for concurrent access
+The actual daemon server code is in server/unified_daemon.py.
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
 License: Elastic-2.0
@@ -42,8 +34,9 @@ from threading import Thread
 
 logger = logging.getLogger(__name__)
 
-_DEFAULT_PORT = 8767
-_DEFAULT_IDLE_TIMEOUT = 1800  # 30 min
+_DEFAULT_PORT = 8765  # v3.4.3: unified daemon on 8765 (was 8767)
+_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"
 _PORT_FILE = Path.home() / ".superlocalmemory" / "daemon.port"
 
@@ -52,27 +45,69 @@ _PORT_FILE = Path.home() / ".superlocalmemory" / "daemon.port"
 # Client: check if daemon running + send requests
 # ---------------------------------------------------------------------------
 
-def is_daemon_running() -> bool:
-    """Check if daemon is alive via PID file + HTTP health check."""
-    if not _PID_FILE.exists():
-        return False
+def _is_pid_alive(pid: int) -> bool:
+    """Cross-platform check if a process with given PID exists."""
     try:
-        pid = int(_PID_FILE.read_text().strip())
-        os.kill(pid, 0)  # Check if process exists
-    except (ValueError, ProcessLookupError, PermissionError):
-        _PID_FILE.unlink(missing_ok=True)
-        return False
+        import psutil
+        return psutil.pid_exists(pid)
+    except ImportError:
+        try:
+            os.kill(pid, 0)
+            return True
+        except (ProcessLookupError, PermissionError):
+            return False
 
-    # PID exists — verify HTTP health
-    port = _get_port()
-    try:
-        import urllib.request
-        resp = urllib.request.urlopen(
-            f"http://127.0.0.1:{port}/health", timeout=2,
-        )
-        return resp.status == 200
-    except Exception:
-        return False
+
+def is_daemon_running() -> bool:
+    """Check if daemon is alive via PID file + HTTP health check.
+
+    v3.4.4 FIX: If PID is alive, returns True EVEN IF health check fails.
+    This prevents starting duplicate daemons when the existing one is
+    warming up (Ollama processing, model download, embedding init).
+
+    Priority:
+      1. PID file exists AND process alive → True (daemon warming up or ready)
+      2. No PID file → try health check on known ports (MCP/hook started daemon)
+      3. PID file stale (process dead) → clean up, return False
+    """
+    if _PID_FILE.exists():
+        try:
+            pid = int(_PID_FILE.read_text().strip())
+            if _is_pid_alive(pid):
+                # PID alive = daemon exists. Don't check health — it might be warming up.
+                # This is the critical fix: NEVER start a second daemon if PID is alive.
+                return True
+            else:
+                # Process died — clean up stale PID file
+                _PID_FILE.unlink(missing_ok=True)
+                _PORT_FILE.unlink(missing_ok=True)
+        except (ValueError, OSError):
+            _PID_FILE.unlink(missing_ok=True)
+
+    # No PID file — maybe daemon was started by MCP/hook without PID file.
+    # Try health check on known ports as last resort.
+    for try_port in (_DEFAULT_PORT, _LEGACY_PORT):
+        try:
+            import urllib.request
+            resp = urllib.request.urlopen(
+                f"http://127.0.0.1:{try_port}/health", timeout=2,
+            )
+            if resp.status == 200:
+                # Daemon running without PID file — write one for future checks
+                try:
+                    import json as _json
+                    data = _json.loads(resp.read().decode())
+                    pid = data.get("pid")
+                    if pid:
+                        _PID_FILE.parent.mkdir(parents=True, exist_ok=True)
+                        _PID_FILE.write_text(str(pid))
+                        _PORT_FILE.write_text(str(try_port))
+                except Exception:
+                    pass
+                return True
+        except Exception:
+            continue
+    return False
 
 
 def _get_port() -> int:
@@ -99,47 +134,132 @@ def daemon_request(method: str, path: str, body: dict | None = None) -> dict | N
         return None
 
 
+_LOCK_FILE = Path.home() / ".superlocalmemory" / "daemon.lock"
+
+
 def ensure_daemon() -> bool:
-    """Start daemon if not running. Returns True if daemon is ready."""
+    """Start daemon if not running. Returns True if daemon is ready.
+
+    v3.4.4 BULLETPROOF:
+      1. If PID alive → return True immediately (even if warming up)
+      2. File lock prevents two callers from starting concurrent daemons
+      3. After starting, waits for PID file (not health check) — fast detection
+      4. Cross-platform: macOS + Windows + Linux
+    """
     if is_daemon_running():
         return True
 
-    # Start daemon in background
-    import subprocess
-    cmd = [sys.executable, "-m", "superlocalmemory.cli.daemon", "--start"]
-    log_dir = Path.home() / ".superlocalmemory" / "logs"
-    log_dir.mkdir(parents=True, exist_ok=True)
-    log_file = log_dir / "daemon.log"
-
-    with open(log_file, "a") as lf:
-        subprocess.Popen(
-            cmd, stdout=lf, stderr=lf,
-            start_new_session=True,
-        )
-
-    # Wait for daemon to become ready (max 30s for cold start)
-    for _ in range(60):
-        time.sleep(0.5)
+    # File lock — prevent concurrent starts from multiple CLI/MCP calls
+    lock_fd = None
+    try:
+        _LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
+        lock_fd = open(_LOCK_FILE, "w")
+
+        # Cross-platform file locking
+        if sys.platform == "win32":
+            import msvcrt
+            try:
+                msvcrt.locking(lock_fd.fileno(), msvcrt.LK_NBLCK, 1)
+            except (IOError, OSError):
+                # Another process is starting the daemon — just wait for it
+                lock_fd.close()
+                return _wait_for_daemon(timeout=60)
+        else:
+            import fcntl
+            try:
+                fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except (IOError, OSError):
+                lock_fd.close()
+                return _wait_for_daemon(timeout=60)
+
+        # Re-check after acquiring lock (another process may have started it)
         if is_daemon_running():
             return True
 
+        # Start unified daemon in background
+        import subprocess
+        cmd = [sys.executable, "-m", "superlocalmemory.server.unified_daemon", "--start"]
+        log_dir = Path.home() / ".superlocalmemory" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / "daemon.log"
+
+        kwargs: dict = {}
+        if sys.platform == "win32":
+            kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+        else:
+            kwargs["start_new_session"] = True
+
+        with open(log_file, "a") as lf:
+            proc = subprocess.Popen(cmd, stdout=lf, stderr=lf, **kwargs)
+
+        # Write PID immediately so other callers see it during warmup
+        _PID_FILE.write_text(str(proc.pid))
+        _PORT_FILE.write_text(str(_DEFAULT_PORT))
+
+        return _wait_for_daemon(timeout=60)
+
+    except Exception as exc:
+        logger.debug("ensure_daemon error: %s", exc)
+        return False
+    finally:
+        if lock_fd:
+            try:
+                lock_fd.close()
+            except Exception:
+                pass
+            try:
+                _LOCK_FILE.unlink(missing_ok=True)
+            except Exception:
+                pass
+
+
+def _wait_for_daemon(timeout: int = 60) -> bool:
+    """Wait for daemon to become reachable. Checks PID alive first (fast),
+    then health endpoint (confirms HTTP server is bound)."""
+    for _ in range(timeout * 2):  # check every 0.5s
+        time.sleep(0.5)
+        if is_daemon_running():
+            # PID is alive — now optionally check if HTTP is ready
+            port = _get_port()
+            try:
+                import urllib.request
+                urllib.request.urlopen(f"http://127.0.0.1:{port}/health", timeout=2)
+                return True  # HTTP is ready
+            except Exception:
+                # PID alive but HTTP not ready — daemon is warming up, that's OK
+                return True
     return False
 
 
 def stop_daemon() -> bool:
-    """Stop the running daemon gracefully."""
+    """Stop the running daemon gracefully.
+
+    v3.4.3: Uses psutil for cross-platform process termination.
+    Falls back to os.kill if psutil unavailable.
+    """
     if not _PID_FILE.exists():
         return True
     try:
         pid = int(_PID_FILE.read_text().strip())
-        os.kill(pid, signal.SIGTERM)
-        # Wait for cleanup
-        for _ in range(20):
-            time.sleep(0.5)
-            try:
-                os.kill(pid, 0)
-            except ProcessLookupError:
-                break
+
+        # Cross-platform termination via psutil
+        try:
+            import psutil
+            proc = psutil.Process(pid)
+            proc.terminate()  # SIGTERM on Unix, TerminateProcess on Windows
+            proc.wait(timeout=10)
+        except ImportError:
+            # Fallback: direct signal (works on Unix, may fail on Windows)
+            os.kill(pid, signal.SIGTERM)
+            for _ in range(20):
+                time.sleep(0.5)
+                try:
+                    os.kill(pid, 0)
+                except ProcessLookupError:
+                    break
+        except Exception:
+            pass
+
         _PID_FILE.unlink(missing_ok=True)
         _PORT_FILE.unlink(missing_ok=True)
         return True

package/src/superlocalmemory/cli/main.py

@@ -195,8 +195,8 @@ def main() -> None:
     serve_p = sub.add_parser("serve", help="Start/stop daemon for instant CLI response (~600MB RAM)")
     serve_p.add_argument(
         "action", nargs="?", default="start",
-        choices=["start", "stop", "status"],
-        help="start (default), stop, or status",
+        choices=["start", "stop", "status", "install", "uninstall"],
+        help="start (default), stop, status, install (OS service), uninstall",
     )
 
     # -- Profiles ------------------------------------------------------
@@ -272,6 +272,16 @@ def main() -> None:
     )
     reap_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
+    # V3.4.3: Ingestion adapters
+    adapters_p = sub.add_parser(
+        "adapters",
+        help="Manage ingestion adapters (Gmail, Calendar, Transcript)",
+    )
+    adapters_p.add_argument(
+        "rest", nargs="*", default=[],
+        help="Subcommand: list, enable, disable, start, stop, status [name]",
+    )
+
     args = parser.parse_args()
 
     if not args.command:
@@ -282,6 +292,19 @@ def main() -> None:
     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.
+    # Cross-platform: macOS + Windows + Linux.
+    _NO_DAEMON_COMMANDS = {
+        "setup", "mode", "provider", "connect", "migrate", "mcp", "warmup",
+    }
+    if args.command not in _NO_DAEMON_COMMANDS:
+        try:
+            from superlocalmemory.cli.daemon import ensure_daemon
+            ensure_daemon()  # Starts daemon if not running; no-op if already up
+        except Exception:
+            pass  # Don't block CLI if daemon start fails — commands have fallbacks
+
     from superlocalmemory.cli.commands import dispatch
 
     dispatch(args)