superlocalmemory 3.4.1 → 3.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.1",
+  "version": "3.4.3",
   "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.3"
 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:
@@ -110,6 +112,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 +1181,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
+    """Open the web dashboard in the browser.
 
-    port = getattr(args, "port", 8765)
-
-    def _kill_existing_on_port(target_port: int) -> None:
-        """Kill any existing SLM dashboard on the target port.
-
-        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"
 
@@ -53,26 +46,70 @@ _PORT_FILE = Path.home() / ".superlocalmemory" / "daemon.port"
 # ---------------------------------------------------------------------------
 
 def is_daemon_running() -> bool:
-    """Check if daemon is alive via PID file + HTTP health check."""
+    """Check if daemon is alive via PID file + HTTP health check.
+
+    v3.4.3: Checks both port 8765 (new) and 8767 (legacy) for upgrade compat.
+    Also checks ports directly if PID file is missing (daemon started by MCP/hook).
+    """
     if not _PID_FILE.exists():
+        # PID file missing but daemon might still be running (started by MCP/hook)
+        # Try health check on known ports
+        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 is 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
     try:
         pid = int(_PID_FILE.read_text().strip())
-        os.kill(pid, 0)  # Check if process exists
-    except (ValueError, ProcessLookupError, PermissionError):
+        # Cross-platform PID check via psutil if available, else os.kill
+        try:
+            import psutil
+            if not psutil.pid_exists(pid):
+                _PID_FILE.unlink(missing_ok=True)
+                return False
+        except ImportError:
+            try:
+                os.kill(pid, 0)
+            except (ProcessLookupError, PermissionError):
+                _PID_FILE.unlink(missing_ok=True)
+                return False
+    except ValueError:
         _PID_FILE.unlink(missing_ok=True)
         return False
 
-    # PID exists — verify HTTP health
+    # PID exists — verify HTTP health on primary port
     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
+    for try_port in (port, _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:
+                # Update port file if it was stale (upgrade from 8767 → 8765)
+                if try_port != port:
+                    _PORT_FILE.write_text(str(try_port))
+                return True
+        except Exception:
+            continue
+    return False
 
 
 def _get_port() -> int:
@@ -100,22 +137,30 @@ def daemon_request(method: str, path: str, body: dict | None = None) -> dict | N
 
 
 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.3: Starts unified daemon (server/unified_daemon.py) instead of
+    old stdlib daemon. Cross-platform subprocess flags.
+    """
     if is_daemon_running():
         return True
 
-    # Start daemon in background
+    # Start unified daemon in background
     import subprocess
-    cmd = [sys.executable, "-m", "superlocalmemory.cli.daemon", "--start"]
+    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"
 
+    # Cross-platform background process flags
+    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:
-        subprocess.Popen(
-            cmd, stdout=lf, stderr=lf,
-            start_new_session=True,
-        )
+        subprocess.Popen(cmd, stdout=lf, stderr=lf, **kwargs)
 
     # Wait for daemon to become ready (max 30s for cold start)
     for _ in range(60):
@@ -127,19 +172,34 @@ def ensure_daemon() -> bool:
 
 
 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

@@ -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:

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()
+
+    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()
-    print("─── Step 6/6: Verification ───")
+
+    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,16 +521,33 @@ 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()
     print("  Need help?")
     print("    slm doctor     — diagnose issues")