get-claudia 1.2.4 → 1.2.6

package/README.md

@@ -43,39 +43,36 @@ Say hi. She'll introduce herself and set things up for you.
 
 ---
 
+## What's New in v1.2.5
+
+**Fully automatic memory system** - No more manual steps after install:
+
+- **Works after reboot** - Ollama and the memory daemon auto-start on login (macOS LaunchAgent)
+- **Python 3.13 support** - sqlite-vec now works on all Python versions
+- **Boot resilience** - Daemon waits for Ollama to start instead of failing silently
+- **Better diagnostics** - Run `~/.claudia/diagnose.sh` to check all services
+
+The memory system just works now. Install, reboot, and everything comes back up.
+
+---
+
 ## Already Have Claudia? Add Memory.
 
-If you installed Claudia before the memory system existed, you can upgrade:
+If you installed Claudia before the memory system existed, just run the installer again:
 
 ```bash
-# Clone the repo (or pull latest if you have it)
-git clone https://github.com/kbanc/claudia.git
-cd claudia/memory-daemon
-
-# Run the installer
-./scripts/install.sh
+npx get-claudia
 ```
 
-The installer will:
+When prompted, say **yes** to install the memory system. The installer will:
 - Set up the memory daemon at `~/.claudia/daemon/`
-- Install Ollama for local embeddings (optional but recommended)
-- Configure auto-start so the daemon runs on login
-- Show you what to add to your `.mcp.json`
-
-After installing, add this to your Claudia project's `.mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "claudia-memory": {
-      "command": "~/.claudia/daemon/venv/bin/python",
-      "args": ["-m", "claudia_memory.mcp.server"]
-    }
-  }
-}
-```
+- Install Ollama for semantic search (optional but recommended)
+- Configure auto-start so everything runs on login
+- Pull the embedding model automatically
+- Verify all services are working
+- Update your `.mcp.json` automatically
 
-Restart Claude Code, and Claudia now has persistent memory.
+Restart Claude Code in a new terminal, and Claudia now has persistent memory.
 
 ---
 
@@ -83,11 +80,12 @@ Restart Claude Code, and Claudia now has persistent memory.
 
 | Traditional AI | Claudia |
 |----------------|---------|
-| Forgets everything between sessions | **Persistent memory** — SQLite + vector search, never forgets |
+| Forgets everything between sessions | **Persistent memory** — SQLite + vector search, survives reboots |
 | Treats conversations as isolated | **Tracks relationships** — People files, not just tasks |
 | Waits for instructions | **Proactive** — Surfaces risks before they become problems |
 | One-size-fits-all | **Personalized** — Structure generated for your work style |
 | Cloud-based, data harvested | **Local** — Runs on your machine, your context stays yours |
+| Breaks after system updates | **Resilient** — Auto-starts on boot, retries on failure |
 
 ---
 
@@ -256,6 +254,44 @@ See what she surfaces. Then tell her about a person you work with.
 
 ---
 
+## Troubleshooting
+
+**Memory tools not appearing?**
+```bash
+# Check all services
+~/.claudia/diagnose.sh
+
+# Common fixes:
+# 1. Restart Claude Code in a NEW terminal (it reads .mcp.json at startup)
+# 2. Check daemon health: curl http://localhost:3848/health
+# 3. View logs: tail -f ~/.claudia/daemon-stderr.log
+```
+
+**Ollama not running after reboot?**
+```bash
+# Load the LaunchAgent
+launchctl load ~/Library/LaunchAgents/com.ollama.serve.plist
+
+# Or start manually
+ollama serve
+```
+
+**Vector search not working?**
+```bash
+# Check if sqlite-vec is installed
+~/.claudia/daemon/venv/bin/python -c "import sqlite_vec; print('ok')"
+
+# If not, install it
+~/.claudia/daemon/venv/bin/pip install sqlite-vec
+```
+
+**Pull the embedding model**
+```bash
+ollama pull all-minilm:l6-v2
+```
+
+---
+
 ## License
 
 Apache 2.0 — Use it, modify it, make it yours.

package/bin/index.js

@@ -56,37 +56,55 @@ async function main() {
   const args = process.argv.slice(2);
   const arg = args[0];
 
-  // Support "." for current directory
-  const isCurrentDir = arg === '.';
+  // Support "." or "upgrade" for current directory
+  const isCurrentDir = arg === '.' || arg === 'upgrade';
   const targetDir = isCurrentDir ? '.' : (arg || 'claudia');
   const targetPath = isCurrentDir ? process.cwd() : join(process.cwd(), targetDir);
   const displayDir = isCurrentDir ? 'current directory' : targetDir;
 
   // Check if directory already exists and has conflicting files
+  let isUpgrade = false;
+
   if (existsSync(targetPath)) {
     const contents = readdirSync(targetPath);
     const hasConflict = contents.some(f => f === 'CLAUDE.md' || f === '.claude');
+
     if (hasConflict) {
-      console.log(`\n${colors.yellow}⚠${colors.reset}  Claudia files already exist in ${displayDir}.`);
-      console.log(`   Remove CLAUDE.md and .claude/ first, or choose a different location.\n`);
-      process.exit(1);
+      // Check if this is an upgrade (existing memories to migrate)
+      const hasExistingMemories = existsSync(join(targetPath, 'context', 'me.md')) ||
+                                  existsSync(join(targetPath, 'context', 'learnings.md')) ||
+                                  existsSync(join(targetPath, 'context', 'patterns.md')) ||
+                                  existsSync(join(targetPath, 'people'));
+
+      if (hasExistingMemories) {
+        console.log(`\n${colors.cyan}✓${colors.reset} Found existing Claudia instance with memories.`);
+        isUpgrade = true;
+        // Don't exit - proceed to memory installation
+      } else {
+        // Fresh install conflict - exit as before
+        console.log(`\n${colors.yellow}⚠${colors.reset}  Claudia files already exist in ${displayDir}.`);
+        console.log(`   Remove CLAUDE.md and .claude/ first, or choose a different location.\n`);
+        process.exit(1);
+      }
     }
   }
 
-  // Create target directory if not current dir
-  if (!isCurrentDir) {
+  // Create target directory if not current dir (only for fresh installs)
+  if (!isCurrentDir && !isUpgrade) {
     mkdirSync(targetPath, { recursive: true });
   }
 
-  // Copy template files (v2 - minimal seed)
-  const templatePath = join(__dirname, '..', 'template-v2');
+  // Copy template files (v2 - minimal seed) - skip for upgrades
+  if (!isUpgrade) {
+    const templatePath = join(__dirname, '..', 'template-v2');
 
-  try {
-    cpSync(templatePath, targetPath, { recursive: true });
-    console.log(`${colors.green}✓${colors.reset} Installed in ${displayDir}`);
-  } catch (error) {
-    console.error(`\n${colors.yellow}⚠${colors.reset}  Error copying files: ${error.message}`);
-    process.exit(1);
+    try {
+      cpSync(templatePath, targetPath, { recursive: true });
+      console.log(`${colors.green}✓${colors.reset} Installed in ${displayDir}`);
+    } catch (error) {
+      console.error(`\n${colors.yellow}⚠${colors.reset}  Error copying files: ${error.message}`);
+      process.exit(1);
+    }
   }
 
   // Ask about enhanced memory system
@@ -113,10 +131,14 @@ async function main() {
 
     if (existsSync(memoryDaemonPath)) {
       try {
-        // Run the install script
+        // Run the install script, passing project path for upgrades
         const result = spawn('bash', [memoryDaemonPath], {
           stdio: 'inherit',
-          shell: true
+          shell: true,
+          env: {
+            ...process.env,
+            CLAUDIA_PROJECT_PATH: isUpgrade ? targetPath : ''
+          }
         });
 
         result.on('close', (code) => {

package/memory-daemon/claudia_memory/database.py

@@ -46,46 +46,54 @@ class Database:
             conn.execute("PRAGMA synchronous = NORMAL")
             conn.execute("PRAGMA foreign_keys = ON")
 
-            # Try to load sqlite-vec extension
+            # Try to load sqlite-vec for vector search
+            # Priority: sqlite_vec Python package first (works on Python 3.13+),
+            # then fall back to native extension loading
+            loaded = False
+
+            # Method 1: Try sqlite_vec Python package (recommended, works everywhere)
             try:
-                conn.enable_load_extension(True)
-                # Try common locations for sqlite-vec
-                sqlite_vec_paths = [
-                    "vec0",  # If installed system-wide
-                    "/usr/local/lib/sqlite-vec/vec0",
-                    "/opt/homebrew/lib/sqlite-vec/vec0",
-                    str(Path.home() / ".local" / "lib" / "sqlite-vec" / "vec0"),
-                ]
-
-                loaded = False
-                for path in sqlite_vec_paths:
-                    try:
-                        conn.load_extension(path)
-                        loaded = True
-                        logger.debug(f"Loaded sqlite-vec from {path}")
-                        break
-                    except sqlite3.OperationalError:
-                        continue
-
-                if not loaded:
-                    # Try loading via sqlite_vec Python package
-                    try:
-                        import sqlite_vec
-                        sqlite_vec.load(conn)
-                        loaded = True
-                        logger.debug("Loaded sqlite-vec via Python package")
-                    except ImportError:
-                        pass
-
-                if not loaded:
-                    logger.warning(
-                        "sqlite-vec extension not found. Vector search will be unavailable. "
-                        "Install with: pip install sqlite-vec"
-                    )
-
-                conn.enable_load_extension(False)
+                import sqlite_vec
+                sqlite_vec.load(conn)
+                loaded = True
+                logger.debug("Loaded sqlite-vec via Python package")
+            except ImportError:
+                logger.debug("sqlite_vec package not installed")
             except Exception as e:
-                logger.warning(f"Could not load sqlite-vec: {e}")
+                logger.debug(f"sqlite_vec package failed: {e}")
+
+            # Method 2: Try native extension loading (for systems with pre-installed sqlite-vec)
+            if not loaded:
+                try:
+                    conn.enable_load_extension(True)
+                    sqlite_vec_paths = [
+                        "vec0",  # If installed system-wide
+                        "/usr/local/lib/sqlite-vec/vec0",
+                        "/opt/homebrew/lib/sqlite-vec/vec0",
+                        str(Path.home() / ".local" / "lib" / "sqlite-vec" / "vec0"),
+                    ]
+
+                    for path in sqlite_vec_paths:
+                        try:
+                            conn.load_extension(path)
+                            loaded = True
+                            logger.debug(f"Loaded sqlite-vec from {path}")
+                            break
+                        except sqlite3.OperationalError:
+                            continue
+
+                    conn.enable_load_extension(False)
+                except AttributeError:
+                    # Python 3.13+ may not have enable_load_extension
+                    logger.debug("enable_load_extension not available (Python 3.13+)")
+                except Exception as e:
+                    logger.debug(f"Extension loading failed: {e}")
+
+            if not loaded:
+                logger.warning(
+                    "sqlite-vec not available. Vector search will be disabled. "
+                    "Install with: pip install sqlite-vec"
+                )
 
             self._local.connection = conn
 

package/memory-daemon/claudia_memory/embeddings.py

@@ -3,10 +3,13 @@ Embedding service for Claudia Memory System
 
 Connects to local Ollama for generating text embeddings.
 Uses all-minilm:l6-v2 model (384 dimensions) for semantic search.
+
+Includes retry logic to wait for Ollama to start (e.g., after system boot).
 """
 
 import asyncio
 import logging
+import time
 from typing import List, Optional
 
 import httpx
@@ -15,6 +18,10 @@ from .config import get_config
 
 logger = logging.getLogger(__name__)
 
+# Retry configuration for waiting on Ollama
+OLLAMA_RETRY_ATTEMPTS = 5
+OLLAMA_RETRY_DELAY = 2  # seconds
+
 
 class EmbeddingService:
     """Generate embeddings using local Ollama"""
@@ -40,11 +47,52 @@ class EmbeddingService:
             self._sync_client = httpx.Client(timeout=30.0)
         return self._sync_client
 
+    async def _wait_for_ollama(self, max_retries: int = OLLAMA_RETRY_ATTEMPTS, delay: float = OLLAMA_RETRY_DELAY) -> bool:
+        """Wait for Ollama to be available with retries (async)"""
+        client = await self._get_client()
+        for i in range(max_retries):
+            try:
+                response = await client.get(f"{self.host}/api/tags", timeout=5.0)
+                if response.status_code == 200:
+                    logger.debug(f"Ollama available after {i + 1} attempt(s)")
+                    return True
+            except Exception:
+                pass
+            if i < max_retries - 1:
+                logger.debug(f"Waiting for Ollama (attempt {i + 1}/{max_retries})...")
+                await asyncio.sleep(delay)
+        return False
+
+    def _wait_for_ollama_sync(self, max_retries: int = OLLAMA_RETRY_ATTEMPTS, delay: float = OLLAMA_RETRY_DELAY) -> bool:
+        """Wait for Ollama to be available with retries (sync)"""
+        client = self._get_sync_client()
+        for i in range(max_retries):
+            try:
+                response = client.get(f"{self.host}/api/tags", timeout=5.0)
+                if response.status_code == 200:
+                    logger.debug(f"Ollama available after {i + 1} attempt(s)")
+                    return True
+            except Exception:
+                pass
+            if i < max_retries - 1:
+                logger.debug(f"Waiting for Ollama (attempt {i + 1}/{max_retries})...")
+                time.sleep(delay)
+        return False
+
     async def is_available(self) -> bool:
-        """Check if Ollama is running and model is available"""
+        """Check if Ollama is running and model is available.
+
+        Uses retry logic to wait for Ollama if it's starting up (e.g., after boot).
+        """
         if self._available is not None:
             return self._available
 
+        # Wait for Ollama to be available (with retries)
+        if not await self._wait_for_ollama():
+            logger.warning("Ollama not available after retries. Vector search disabled.")
+            self._available = False
+            return self._available
+
         try:
             client = await self._get_client()
             response = await client.get(f"{self.host}/api/tags")
@@ -65,16 +113,25 @@ class EmbeddingService:
             else:
                 self._available = False
         except Exception as e:
-            logger.warning(f"Ollama not available: {e}")
+            logger.warning(f"Ollama error: {e}")
             self._available = False
 
         return self._available
 
     def is_available_sync(self) -> bool:
-        """Synchronous check if Ollama is available"""
+        """Synchronous check if Ollama is available.
+
+        Uses retry logic to wait for Ollama if it's starting up (e.g., after boot).
+        """
         if self._available is not None:
             return self._available
 
+        # Wait for Ollama to be available (with retries)
+        if not self._wait_for_ollama_sync():
+            logger.warning("Ollama not available after retries. Vector search disabled.")
+            self._available = False
+            return self._available
+
         try:
             client = self._get_sync_client()
             response = client.get(f"{self.host}/api/tags")
@@ -88,7 +145,7 @@ class EmbeddingService:
             else:
                 self._available = False
         except Exception as e:
-            logger.warning(f"Ollama not available: {e}")
+            logger.warning(f"Ollama error: {e}")
             self._available = False
 
         return self._available

package/memory-daemon/scripts/diagnose.sh

@@ -94,18 +94,73 @@ else
     echo -e "   ${DIM}Database will be created on first use.${NC}"
 fi
 
-# Check 7: Ollama (optional)
-echo -n "7. Ollama for vectors... "
+# Check 7: Ollama installed
+echo -n "7. Ollama installed... "
+if command -v ollama &> /dev/null; then
+    echo -e "${GREEN}✓ OK${NC}"
+else
+    echo -e "${YELLOW}○ Not installed (keyword search will be used)${NC}"
+    echo -e "   ${DIM}Optional: brew install ollama${NC}"
+fi
+
+# Check 8: Ollama running
+echo -n "8. Ollama running... "
+if curl -s http://localhost:11434/api/tags &>/dev/null; then
+    echo -e "${GREEN}✓ Running${NC}"
+else
+    echo -e "${YELLOW}○ Not running${NC}"
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        if [ -f "$HOME/Library/LaunchAgents/com.ollama.serve.plist" ]; then
+            echo -e "   ${DIM}LaunchAgent exists - try: launchctl load ~/Library/LaunchAgents/com.ollama.serve.plist${NC}"
+        else
+            echo -e "   ${DIM}Start with: ollama serve${NC}"
+        fi
+    else
+        echo -e "   ${DIM}Start with: ollama serve${NC}"
+    fi
+    ISSUES_FOUND=$((ISSUES_FOUND + 1))
+fi
+
+# Check 9: Ollama auto-start (macOS only)
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    echo -n "9. Ollama auto-start... "
+    if [ -f "$HOME/Library/LaunchAgents/com.ollama.serve.plist" ]; then
+        echo -e "${GREEN}✓ LaunchAgent configured${NC}"
+    else
+        echo -e "${YELLOW}○ No LaunchAgent${NC}"
+        echo -e "   ${DIM}Ollama won't start on boot. Re-run memory installer to configure.${NC}"
+    fi
+else
+    echo -e "9. Ollama auto-start... ${DIM}(Linux - check systemd if needed)${NC}"
+fi
+
+# Check 10: Embedding model
+echo -n "10. Embedding model... "
 if command -v ollama &> /dev/null; then
     if ollama list 2>/dev/null | grep -q "minilm"; then
-        echo -e "${GREEN}✓ Available with embedding model${NC}"
+        echo -e "${GREEN}✓ all-minilm model available${NC}"
     else
-        echo -e "${YELLOW}○ Installed but no embedding model${NC}"
+        echo -e "${YELLOW}○ No embedding model${NC}"
         echo -e "   ${DIM}Run: ollama pull all-minilm:l6-v2${NC}"
+        ISSUES_FOUND=$((ISSUES_FOUND + 1))
     fi
 else
-    echo -e "${YELLOW}○ Not installed (keyword search will be used)${NC}"
-    echo -e "   ${DIM}Optional: brew install ollama${NC}"
+    echo -e "${DIM}○ Skipped (Ollama not installed)${NC}"
+fi
+
+# Check 11: sqlite-vec (vector search)
+echo -n "11. Vector search (sqlite-vec)... "
+VENV_PYTHON="$HOME/.claudia/daemon/venv/bin/python"
+if [ -f "$VENV_PYTHON" ]; then
+    if $VENV_PYTHON -c "import sqlite_vec; print('ok')" 2>/dev/null | grep -q "ok"; then
+        echo -e "${GREEN}✓ sqlite-vec available${NC}"
+    else
+        echo -e "${YELLOW}○ sqlite-vec not working${NC}"
+        echo -e "   ${DIM}Fix: $HOME/.claudia/daemon/venv/bin/pip install sqlite-vec${NC}"
+        ISSUES_FOUND=$((ISSUES_FOUND + 1))
+    fi
+else
+    echo -e "${RED}✗ Virtual environment missing${NC}"
 fi
 
 # Summary

package/memory-daemon/scripts/install.sh

@@ -94,7 +94,7 @@ random_message() {
 }
 
 # Check Python
-echo -e "${BOLD}Step 1/7: Environment Check${NC}"
+echo -e "${BOLD}Step 1/8: Environment Check${NC}"
 echo
 if command -v python3 &> /dev/null; then
     PYTHON=$(command -v python3)
@@ -137,22 +137,88 @@ else
     fi
 fi
 
+# Configure Ollama to auto-start on boot (macOS)
+if [[ "$OSTYPE" == "darwin"* ]] && [ "$OLLAMA_AVAILABLE" = true ]; then
+    OLLAMA_PLIST="$HOME/Library/LaunchAgents/com.ollama.serve.plist"
+
+    if [ ! -f "$OLLAMA_PLIST" ]; then
+        # Find Ollama binary location
+        OLLAMA_BIN=$(command -v ollama)
+
+        mkdir -p "$HOME/Library/LaunchAgents"
+        cat > "$OLLAMA_PLIST" << PLIST
+<?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>com.ollama.serve</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>$OLLAMA_BIN</string>
+        <string>serve</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>/tmp/ollama.log</string>
+    <key>StandardErrorPath</key>
+    <string>/tmp/ollama.err</string>
+</dict>
+</plist>
+PLIST
+        launchctl load "$OLLAMA_PLIST" 2>/dev/null || true
+        echo -e "  ${GREEN}✓${NC} Ollama configured to auto-start on boot"
+    else
+        echo -e "  ${GREEN}✓${NC} Ollama LaunchAgent already configured"
+    fi
+fi
+
 echo
 echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
 echo
 
 # Pull embedding model
-echo -e "${BOLD}Step 2/7: AI Models${NC}"
+echo -e "${BOLD}Step 2/8: AI Models${NC}"
 echo
 if [ "$OLLAMA_AVAILABLE" = true ]; then
+    # Ensure Ollama is running before pulling model
+    if ! curl -s http://localhost:11434/api/tags &>/dev/null; then
+        echo -e "  ${CYAN}◐${NC} Starting Ollama server..."
+        ollama serve &>/dev/null &
+        OLLAMA_PID=$!
+
+        # Wait for Ollama to be ready (up to 10 seconds)
+        for i in {1..10}; do
+            if curl -s http://localhost:11434/api/tags &>/dev/null; then
+                break
+            fi
+            sleep 1
+        done
+
+        if curl -s http://localhost:11434/api/tags &>/dev/null; then
+            echo -e "  ${GREEN}✓${NC} Ollama server running"
+        else
+            echo -e "  ${YELLOW}!${NC} Could not start Ollama (will retry on boot)"
+        fi
+    else
+        echo -e "  ${GREEN}✓${NC} Ollama server already running"
+    fi
+
+    # Pull embedding model
     if ollama list 2>/dev/null | grep -q "all-minilm"; then
         echo -e "  ${GREEN}✓${NC} Embedding model ready"
     else
         echo -e "  ${CYAN}◐${NC} Downloading embedding model (45MB)..."
         echo -e "    ${DIM}This gives Claudia semantic understanding${NC}"
         echo
-        ollama pull all-minilm:l6-v2 2>/dev/null || echo -e "  ${YELLOW}!${NC} Model pull failed, continuing"
-        echo -e "  ${GREEN}✓${NC} Model downloaded"
+        if ollama pull all-minilm:l6-v2 2>/dev/null; then
+            echo -e "  ${GREEN}✓${NC} Model downloaded"
+        else
+            echo -e "  ${YELLOW}!${NC} Model pull failed (will retry when Ollama runs)"
+        fi
     fi
 else
     echo -e "  ${YELLOW}○${NC} Skipping (Ollama not available)"
@@ -164,7 +230,7 @@ echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━
 echo
 
 # Create directories
-echo -e "${BOLD}Step 3/7: Creating Home${NC}"
+echo -e "${BOLD}Step 3/8: Creating Home${NC}"
 echo
 mkdir -p "$DAEMON_DIR"
 mkdir -p "$MEMORY_DIR"
@@ -181,10 +247,11 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SOURCE_DIR="$(dirname "$SCRIPT_DIR")"
 
 # Copy daemon files
-echo -e "${BOLD}Step 4/7: Installing Core${NC}"
+echo -e "${BOLD}Step 4/8: Installing Core${NC}"
 echo
 echo -e "  ${CYAN}◐${NC} Copying memory system files..."
 cp -r "$SOURCE_DIR/claudia_memory" "$DAEMON_DIR/"
+cp -r "$SOURCE_DIR/scripts" "$DAEMON_DIR/"
 cp "$SOURCE_DIR/pyproject.toml" "$DAEMON_DIR/"
 cp "$SOURCE_DIR/requirements.txt" "$DAEMON_DIR/"
 echo -e "  ${GREEN}✓${NC} Core files installed"
@@ -199,7 +266,7 @@ echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━
 echo
 
 # Create virtual environment
-echo -e "${BOLD}Step 5/7: Python Environment${NC}"
+echo -e "${BOLD}Step 5/8: Python Environment${NC}"
 echo
 echo -e "  ${CYAN}◐${NC} Creating isolated environment..."
 $PYTHON -m venv "$VENV_DIR"
@@ -224,7 +291,7 @@ echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━
 echo
 
 # Configure auto-start
-echo -e "${BOLD}Step 6/7: Auto-Start Setup${NC}"
+echo -e "${BOLD}Step 6/8: Auto-Start Setup${NC}"
 echo
 
 if [[ "$OSTYPE" == "darwin"* ]]; then
@@ -309,20 +376,90 @@ echo
 echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
 echo
 
-# Verify
-echo -e "${BOLD}Step 7/7: Verification${NC}"
+# Memory Migration (for upgrades)
+echo -e "${BOLD}Step 7/8: Memory Migration${NC}"
+echo
+
+if [ -n "$CLAUDIA_PROJECT_PATH" ]; then
+    # Check if there are memories to migrate
+    if [ -d "$CLAUDIA_PROJECT_PATH/context" ] || [ -d "$CLAUDIA_PROJECT_PATH/people" ]; then
+        echo -e "  ${CYAN}◐${NC} Found existing memories to migrate..."
+
+        # Wait a moment for daemon to start
+        sleep 2
+
+        # Run migration in quiet mode
+        "$VENV_DIR/bin/python" "$DAEMON_DIR/scripts/migrate_markdown.py" --quiet "$CLAUDIA_PROJECT_PATH"
+
+        if [ $? -eq 0 ]; then
+            echo -e "  ${GREEN}✓${NC} Memories migrated to database"
+        else
+            echo -e "  ${YELLOW}!${NC} Migration had issues (memories still in markdown)"
+            echo -e "    ${DIM}You can retry manually: ~/.claudia/daemon/venv/bin/python -m claudia_memory.scripts.migrate_markdown $CLAUDIA_PROJECT_PATH${NC}"
+        fi
+    else
+        echo -e "  ${DIM}No existing memories found to migrate${NC}"
+    fi
+else
+    echo -e "  ${DIM}Fresh install - no migration needed${NC}"
+fi
+
+echo
+echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo
+
+# Verify all services
+echo -e "${BOLD}Step 8/8: Verification${NC}"
 echo
-echo -e "  ${CYAN}◐${NC} Waiting for daemon to start..."
+echo -e "  ${CYAN}◐${NC} Checking all services..."
 sleep 3
 
+# Check 1: Ollama running
+if curl -s http://localhost:11434/api/tags &>/dev/null; then
+    echo -e "  ${GREEN}✓${NC} Ollama running"
+else
+    echo -e "  ${YELLOW}○${NC} Ollama not running (will start on next boot)"
+fi
+
+# Check 2: Ollama LaunchAgent (macOS)
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    if [ -f "$HOME/Library/LaunchAgents/com.ollama.serve.plist" ]; then
+        echo -e "  ${GREEN}✓${NC} Ollama auto-start configured"
+    else
+        echo -e "  ${YELLOW}○${NC} Ollama auto-start not configured"
+    fi
+fi
+
+# Check 3: Embedding model
+if [ "$OLLAMA_AVAILABLE" = true ] && ollama list 2>/dev/null | grep -q "minilm"; then
+    echo -e "  ${GREEN}✓${NC} Embedding model ready"
+else
+    echo -e "  ${YELLOW}○${NC} Embedding model pending"
+fi
+
+# Check 4: sqlite-vec (vector search)
+if "$VENV_DIR/bin/python" -c "import sqlite_vec" 2>/dev/null; then
+    echo -e "  ${GREEN}✓${NC} Vector search available (sqlite-vec)"
+else
+    echo -e "  ${YELLOW}○${NC} Vector search unavailable (keyword search only)"
+fi
+
+# Check 5: Memory daemon health
 if curl -s "http://localhost:3848/health" 2>/dev/null | grep -q "healthy"; then
-    echo -e "  ${GREEN}✓${NC} Health check passed"
+    echo -e "  ${GREEN}✓${NC} Memory daemon running"
     HEALTH_OK=true
 else
-    echo -e "  ${YELLOW}○${NC} Health check pending (daemon still starting)"
+    echo -e "  ${YELLOW}○${NC} Memory daemon starting..."
     HEALTH_OK=false
 fi
 
+# Check 6: Claudia LaunchAgent (macOS)
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    if [ -f "$HOME/Library/LaunchAgents/com.claudia.memory.plist" ]; then
+        echo -e "  ${GREEN}✓${NC} Claudia auto-start configured"
+    fi
+fi
+
 echo
 echo -e "${DIM}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
 echo

package/memory-daemon/scripts/migrate_markdown.py

@@ -346,13 +346,22 @@ def main():
         action="store_true",
         help="Enable debug logging",
     )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Non-interactive mode (for automated migration)",
+    )
 
     args = parser.parse_args()
 
-    logging.basicConfig(
-        level=logging.DEBUG if args.debug else logging.INFO,
-        format="%(asctime)s - %(levelname)s - %(message)s",
-    )
+    if args.quiet:
+        # Suppress all logging in quiet mode
+        logging.basicConfig(level=logging.ERROR)
+    else:
+        logging.basicConfig(
+            level=logging.DEBUG if args.debug else logging.INFO,
+            format="%(asctime)s - %(levelname)s - %(message)s",
+        )
 
     # Initialize database
     db = get_db()
@@ -363,8 +372,24 @@ def main():
         if not args.path.exists():
             logger.error(f"Path not found: {args.path}")
             sys.exit(1)
+
+        if not args.quiet:
+            print(f"Migrating: {args.path}")
+
         stats = migrate_instance(args.path, args.dry_run)
-        print(f"\nMigrated: {stats}")
+
+        if args.quiet:
+            # Quiet mode - minimal output for automated migration
+            total = sum(stats.values())
+            if total > 0:
+                print(f"  - Migrated {stats['me']} items from context/me.md") if stats.get('me') else None
+                print(f"  - Migrated {stats['learnings']} items from context/learnings.md") if stats.get('learnings') else None
+                print(f"  - Migrated {stats['patterns']} items from context/patterns.md") if stats.get('patterns') else None
+                print(f"  - Migrated {stats['commitments']} items from context/commitments.md") if stats.get('commitments') else None
+                if stats.get('people'):
+                    print(f"  - Migrated {stats['people']} people with {stats.get('memories', 0)} facts")
+        else:
+            print(f"\nMigrated: {stats}")
 
     elif args.all:
         # Migrate all instances
@@ -373,11 +398,12 @@ def main():
             logger.info("No Claudia instances found")
             sys.exit(0)
 
-        print(f"Found {len(instances)} Claudia instance(s):\n")
-        for i, instance in enumerate(instances, 1):
-            print(f"  {i}. {instance}")
+        if not args.quiet:
+            print(f"Found {len(instances)} Claudia instance(s):\n")
+            for i, instance in enumerate(instances, 1):
+                print(f"  {i}. {instance}")
 
-        if not args.dry_run:
+        if not args.dry_run and not args.quiet:
             confirm = input("\nMigrate all? (y/n) ")
             if confirm.lower() != "y":
                 sys.exit(0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",