get-claudia 1.55.17 → 1.55.19

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 1.55.19 (2026-03-19)
+
+### The Self-Healer
+
+Bulletproof installer for non-technical users. Existing installs auto-fix on the next `npx get-claudia`.
+
+- **Auto-rebuild Python 3.14 venvs** -- If your existing venv uses Python 3.14+ and a compatible Python (3.13/3.12/3.11) is available, the installer automatically rebuilds the venv. No user action needed.
+- **Auto-install Python 3.12** -- On macOS with Homebrew, if only Python 3.14 exists, the installer runs `brew install python@3.12` automatically before creating the venv.
+- **LaunchAgent verification** -- After registering the macOS LaunchAgent, the installer now verifies the standalone daemon is actually running via `launchctl list`. If not running, force-reloads the agent. On Linux, enables and starts the systemd user service. Fixes the silent failure where backups, consolidation, and decay never ran.
+- **Clear degradation messaging** -- When falling back to Python 3.14+ (no compatible version available), the installer now shows a yellow warning explaining that spaCy is unavailable and entity extraction will use regex only.
+
+## 1.55.18 (2026-03-19)
+
+### Data Quality & Python Compatibility
+
+Six fixes addressing two community discussions. All additive, no schema changes, no new pip dependencies.
+
+- **Briefing counts now exclude invalidated records** -- The `memory.briefing` MCP tool was counting soft-deleted commitments (58 shown when 14 active). Added `AND invalidated_at IS NULL` to both commitment count queries and `AND deleted_at IS NULL` to the cooling relationships query. The first numbers users see at session start are now accurate. (Discussion #25)
+- **Entity type inference from name keywords** -- New `_infer_entity_type()` function detects organizational keywords (Inc, LLC, Corp, University), project keywords (Project, Sprint, MVP), concept keywords (methodology, framework), and location keywords (Office, HQ) in entity names. "Acme Corp" now creates an organization entity, not a person. Only runs when creating new entities; explicit types and existing entities are never overridden. (Discussion #25)
+- **Consolidation fuzzy name dedup** -- Added Method 3 to overnight dedup: SequenceMatcher fuzzy name comparison across same-type entity pairs. Catches typo variants like "Kris Krisko" vs "Kris Krisco" (>= 0.90 similarity) and prefix matches like "Sarah" vs "Sarah Johnson". Advisory only: stores candidates in predictions table for user review, never auto-merges. Runs even without sqlite-vec. (Discussion #25)
+- **Wildcard entity search works** -- `memory.entities(query="*")` now returns all non-deleted entities instead of nothing. The `*` was being wrapped in `LIKE "%*%"`, matching the literal asterisk. Also added `AND deleted_at IS NULL` to all search paths. (Discussion #25)
+- **Installer prefers Python < 3.14** -- Both `install.sh` and `bin/index.js` now try Python 3.13, 3.12, and 3.11 before falling back to 3.14+. Previously, systems with only 3.12 and 3.14 installed (no 3.13) would get a 3.14 venv, causing spaCy to fail with a Pydantic V1 ConfigError. The daemon still works on 3.14 (graceful degradation to regex-only extraction), but prefers < 3.14 when available. (Discussion #29)
+- **Python version cap** -- `requires-python` in pyproject.toml now caps at `<3.14` until spaCy (blis wheels), pydantic-core (PyO3 ceiling), and numpy (cp314 wheels) ship 3.14 support.
+- 706 tests pass, 0 regressions, 46 new tests across 4 new test files.
+
 ## 1.55.17 (2026-03-18)
 
 ### The Quiet Observer

package/bin/index.js

@@ -347,7 +347,21 @@ async function installOllama() {
 
 /** Check if Python 3.10+ is available. Returns the command name or null. */
 async function isPythonInstalled() {
-  for (const cmd of ['python3', 'python']) {
+  // Prefer Python < 3.14 (spaCy/pydantic-core don't support 3.14 yet)
+  // Try versioned binaries first (3.13, 3.12, 3.11), then unversioned python3
+  const candidates = [
+    'python3.13', 'python3.12', 'python3.11',  // Versioned: guaranteed < 3.14
+    'python3', 'python',                         // Unversioned: check version
+  ];
+  // On macOS, also check Homebrew paths explicitly
+  if (process.platform === 'darwin') {
+    candidates.unshift(
+      '/opt/homebrew/bin/python3.13', '/opt/homebrew/bin/python3.12', '/opt/homebrew/bin/python3.11',
+      '/usr/local/bin/python3.13', '/usr/local/bin/python3.12', '/usr/local/bin/python3.11',
+    );
+  }
+  let fallback314 = null;
+  for (const cmd of candidates) {
     const ver = await new Promise((resolve) => {
       const proc = spawn(cmd, ['--version'], { stdio: 'pipe', timeout: 5000 });
       let stdout = '';
@@ -356,11 +370,15 @@ async function isPythonInstalled() {
       proc.on('error', () => resolve(''));
     });
     const match = ver.match(/Python (\d+)\.(\d+)/);
-    if (match && (parseInt(match[1]) > 3 || (parseInt(match[1]) === 3 && parseInt(match[2]) >= 10))) {
-      return cmd;
+    if (match) {
+      const major = parseInt(match[1]);
+      const minor = parseInt(match[2]);
+      if (major === 3 && minor >= 10 && minor < 14) return cmd;
+      // Remember 3.14+ as fallback (daemon works, just no spaCy)
+      if (major === 3 && minor >= 14 && !fallback314) fallback314 = cmd;
     }
   }
-  return null;
+  return fallback314;
 }
 
 /**
@@ -896,10 +914,74 @@ async function main() {
       if (!supportsInPlace) renderer.appendLine('daemon', 'warn', 'Python 3.10+ not found');
       rootCause = { step: 'daemon', issue: 'python' };
     } else {
-      // Phase 2: Create venv if it doesn't exist
+      // Phase 2: Create venv (or rebuild if using Python 3.14)
+      if (existsSync(venvPython)) {
+        // Self-heal: check if existing venv uses Python 3.14+
+        const venvVer = await new Promise((resolve) => {
+          const proc = spawn(venvPython, ['-c', 'import sys; print(sys.version_info.minor)'], {
+            stdio: 'pipe', timeout: 5000
+          });
+          let out = '';
+          proc.stdout.on('data', (d) => { out += d.toString(); });
+          proc.on('close', () => resolve(out.trim()));
+          proc.on('error', () => resolve(''));
+        });
+        if (venvVer && parseInt(venvVer) >= 14 && pythonCmd !== venvPython) {
+          // Check if pythonCmd is < 3.14
+          const sysVer = await new Promise((resolve) => {
+            const proc = spawn(pythonCmd, ['-c', 'import sys; print(sys.version_info.minor)'], {
+              stdio: 'pipe', timeout: 5000
+            });
+            let out = '';
+            proc.stdout.on('data', (d) => { out += d.toString(); });
+            proc.on('close', () => resolve(out.trim()));
+            proc.on('error', () => resolve(''));
+          });
+          if (sysVer && parseInt(sysVer) < 14) {
+            renderer.update('daemon', 'active', `rebuilding venv (3.14→3.${sysVer})...`);
+            // Rebuild venv with better Python
+            await new Promise((resolve) => {
+              const proc = spawn(pythonCmd, ['-m', 'venv', '--clear', daemonVenvDir], {
+                stdio: 'pipe', timeout: 30000
+              });
+              proc.on('close', (code) => resolve(code === 0));
+              proc.on('error', () => resolve(false));
+            });
+          }
+        }
+      }
+
       if (!existsSync(venvPython)) {
         renderer.update('daemon', 'active', 'creating venv...');
         mkdirSync(join(homedir(), '.claudia', 'daemon'), { recursive: true });
+
+        // If pythonCmd is 3.14+ and we're on macOS with Homebrew, auto-install 3.12
+        if (process.platform === 'darwin') {
+          const cmdVer = await new Promise((resolve) => {
+            const proc = spawn(pythonCmd, ['-c', 'import sys; print(sys.version_info.minor)'], {
+              stdio: 'pipe', timeout: 5000
+            });
+            let out = '';
+            proc.stdout.on('data', (d) => { out += d.toString(); });
+            proc.on('close', () => resolve(out.trim()));
+            proc.on('error', () => resolve(''));
+          });
+          if (cmdVer && parseInt(cmdVer) >= 14) {
+            renderer.update('daemon', 'active', 'installing Python 3.12...');
+            const installed312 = await new Promise((resolve) => {
+              const proc = spawn('brew', ['install', 'python@3.12'], {
+                stdio: 'pipe', timeout: 300000
+              });
+              proc.on('close', (code) => resolve(code === 0));
+              proc.on('error', () => resolve(false));
+            });
+            if (installed312) {
+              // Re-detect best Python
+              pythonCmd = await isPythonInstalled() || pythonCmd;
+            }
+          }
+        }
+
         const venvCreated = await new Promise((resolve) => {
           const proc = spawn(pythonCmd, ['-m', 'venv', daemonVenvDir], { stdio: 'pipe' });
           proc.on('close', (code) => resolve(code === 0));
@@ -1002,9 +1084,54 @@ async function main() {
       }
     }
 
-    // Register LaunchAgent for standalone daemon (macOS only)
+    // Register LaunchAgent and verify standalone daemon is running (macOS only)
     if (daemonOk && process.platform === 'darwin') {
       await ensureLaunchAgent(venvPython);
+      // Verify daemon is actually running (self-heal for existing installs)
+      const daemonRunning = await new Promise((resolve) => {
+        const proc = spawn('launchctl', ['list', 'com.claudia.memory'], {
+          stdio: 'pipe', timeout: 5000
+        });
+        let out = '';
+        proc.stdout.on('data', (d) => { out += d.toString(); });
+        proc.on('close', (code) => {
+          // launchctl list returns PID in first column, or "-" if not running
+          const pid = out.trim().split(/\s+/)[0];
+          resolve(code === 0 && pid !== '-' && pid !== '');
+        });
+        proc.on('error', () => resolve(false));
+      });
+      if (!daemonRunning) {
+        // Force reload: unload then load
+        const plistPath = join(homedir(), 'Library', 'LaunchAgents', 'com.claudia.memory.plist');
+        if (existsSync(plistPath)) {
+          await new Promise((resolve) => {
+            const proc = spawn('launchctl', ['unload', plistPath], { stdio: 'pipe', timeout: 5000 });
+            proc.on('close', () => resolve());
+            proc.on('error', () => resolve());
+          });
+          await new Promise((resolve) => {
+            const proc = spawn('launchctl', ['load', plistPath], { stdio: 'pipe', timeout: 5000 });
+            proc.on('close', () => resolve());
+            proc.on('error', () => resolve());
+          });
+        }
+      }
+    }
+
+    // On Linux, verify systemd service is enabled and running
+    if (daemonOk && process.platform === 'linux') {
+      const serviceFile = join(homedir(), '.config', 'systemd', 'user', 'claudia-memory.service');
+      if (existsSync(serviceFile)) {
+        // Enable and start if not running
+        await new Promise((resolve) => {
+          const proc = spawn('systemctl', ['--user', 'enable', '--now', 'claudia-memory'], {
+            stdio: 'pipe', timeout: 10000
+          });
+          proc.on('close', () => resolve());
+          proc.on('error', () => resolve());
+        });
+      }
     }
 
     // MCP Config step: verify .mcp.json is correct and check stdio server count

package/memory-daemon/claudia_memory/mcp/server.py

@@ -373,7 +373,7 @@ async def _handle_entities(arguments, db, config, logger, **ctx):
             )
         entity_id = remember_entity(
             name=name_val,
-            entity_type=arguments.get("type", "person"),
+            entity_type=arguments.get("type", ""),
             description=arguments.get("description"),
             aliases=arguments.get("aliases"),
         )
@@ -1136,7 +1136,7 @@ async def _handle_batch(arguments, db, config, logger, **ctx):
             if op_type == "entity":
                 entity_id = remember_entity(
                     name=op["name"],
-                    entity_type=op.get("type", "person"),
+                    entity_type=op.get("type", ""),
                     description=op.get("description"),
                     aliases=op.get("aliases"),
                     _precomputed_embedding=embeddings_map.get(i),
@@ -3248,14 +3248,14 @@ def _build_briefing() -> str:
     # 1. Active commitments count + stale count
     try:
         total_row = db.execute(
-            "SELECT COUNT(*) as cnt FROM memories WHERE type = 'commitment' AND importance > 0.1",
+            "SELECT COUNT(*) as cnt FROM memories WHERE type = 'commitment' AND importance > 0.1 AND invalidated_at IS NULL",
             fetch=True,
         )
         total_commitments = total_row[0]["cnt"] if total_row else 0
 
         stale_cutoff = (datetime.utcnow() - timedelta(days=7)).isoformat()
         stale_row = db.execute(
-            "SELECT COUNT(*) as cnt FROM memories WHERE type = 'commitment' AND importance > 0.1 AND created_at < ?",
+            "SELECT COUNT(*) as cnt FROM memories WHERE type = 'commitment' AND importance > 0.1 AND invalidated_at IS NULL AND created_at < ?",
             (stale_cutoff,),
             fetch=True,
         )
@@ -3274,6 +3274,7 @@ def _build_briefing() -> str:
             """
             SELECT COUNT(*) as cnt FROM entities
             WHERE type = 'person' AND importance > 0.3
+              AND deleted_at IS NULL
               AND updated_at < ?
             """,
             (cooling_cutoff,),

package/memory-daemon/claudia_memory/services/consolidate.py

@@ -2503,49 +2503,105 @@ class ConsolidateService:
                             "method": "alias_overlap",
                             "shared_alias": row["alias"],
                         })
+        except Exception as e:
+            logger.debug(f"Alias overlap dedupe failed: {e}")
 
-            # Store top candidates as predictions for user review
-            now = datetime.utcnow()
-            for candidate in candidates[:10]:
-                content = (
-                    f"Possible duplicate entities: '{candidate['entity_1']['name']}' "
-                    f"and '{candidate['entity_2']['name']}' "
-                    f"({candidate['similarity']:.0%} similar via {candidate['method']}). "
-                    f"Consider merging with memory.merge_entities."
-                )
-                # Check for existing dedupe prediction
-                existing = self.db.execute(
-                    """
-                    SELECT id FROM predictions
-                    WHERE prediction_type = 'suggestion'
-                      AND metadata LIKE ?
-                      AND expires_at > ?
-                    LIMIT 1
-                    """,
-                    (f'%"dedupe_pair": [{candidate["entity_1"]["id"]}, {candidate["entity_2"]["id"]}]%',
-                     now.isoformat()),
-                    fetch=True,
-                )
+        # Method 3: Fuzzy name comparison (SequenceMatcher)
+        # Catches typo variants and prefix matches that embeddings and aliases miss.
+        # Runs even without sqlite-vec. Advisory only: never auto-merges.
+        try:
+            from difflib import SequenceMatcher
 
-                if not existing:
-                    self.db.insert(
-                        "predictions",
-                        {
-                            "content": content,
-                            "prediction_type": "suggestion",
-                            "priority": 0.6 + 0.3 * candidate["similarity"],
-                            "expires_at": (now + timedelta(days=14)).isoformat(),
-                            "created_at": now.isoformat(),
-                            "metadata": json.dumps({
-                                "dedupe_pair": [candidate["entity_1"]["id"], candidate["entity_2"]["id"]],
-                                "similarity": candidate["similarity"],
-                                "method": candidate["method"],
-                            }),
-                        },
-                    )
+            all_entities = self.db.execute(
+                """
+                SELECT id, name, canonical_name, type
+                FROM entities
+                WHERE deleted_at IS NULL AND importance > 0.05
+                ORDER BY type, canonical_name
+                """,
+                fetch=True,
+            ) or []
+
+            # Group by type for same-type comparison only
+            by_type: dict = {}
+            for ent in all_entities:
+                by_type.setdefault(ent["type"], []).append(ent)
+
+            for etype, group in by_type.items():
+                for i, e1 in enumerate(group):
+                    for e2 in group[i + 1:]:
+                        pair_key = (min(e1["id"], e2["id"]), max(e1["id"], e2["id"]))
+                        if pair_key in seen_pairs:
+                            continue
 
+                        cn1 = e1["canonical_name"]
+                        cn2 = e2["canonical_name"]
+
+                        # Fuzzy ratio check
+                        ratio = SequenceMatcher(None, cn1, cn2).ratio()
+                        if ratio >= threshold:
+                            seen_pairs.add(pair_key)
+                            candidates.append({
+                                "entity_1": {"id": e1["id"], "name": e1["name"], "type": e1["type"]},
+                                "entity_2": {"id": e2["id"], "name": e2["name"], "type": e2["type"]},
+                                "similarity": round(ratio, 3),
+                                "method": "fuzzy_name",
+                            })
+                            continue
+
+                        # Prefix match: short name is prefix of longer name
+                        shorter, longer = (cn1, cn2) if len(cn1) <= len(cn2) else (cn2, cn1)
+                        if len(shorter) >= 3 and longer.startswith(shorter):
+                            if pair_key not in seen_pairs:
+                                seen_pairs.add(pair_key)
+                                candidates.append({
+                                    "entity_1": {"id": e1["id"], "name": e1["name"], "type": e1["type"]},
+                                    "entity_2": {"id": e2["id"], "name": e2["name"], "type": e2["type"]},
+                                    "similarity": 0.80,
+                                    "method": "fuzzy_name_prefix",
+                                })
         except Exception as e:
-            logger.warning(f"Auto dedupe failed: {e}")
+            logger.debug(f"Fuzzy name dedupe failed: {e}")
+
+        # Store top candidates as predictions for user review
+        now = datetime.utcnow()
+        for candidate in candidates[:10]:
+            content = (
+                f"Possible duplicate entities: '{candidate['entity_1']['name']}' "
+                f"and '{candidate['entity_2']['name']}' "
+                f"({candidate['similarity']:.0%} similar via {candidate['method']}). "
+                f"Consider merging with memory.merge_entities."
+            )
+            # Check for existing dedupe prediction
+            existing = self.db.execute(
+                """
+                SELECT id FROM predictions
+                WHERE prediction_type = 'suggestion'
+                  AND metadata LIKE ?
+                  AND expires_at > ?
+                LIMIT 1
+                """,
+                (f'%"dedupe_pair": [{candidate["entity_1"]["id"]}, {candidate["entity_2"]["id"]}]%',
+                 now.isoformat()),
+                fetch=True,
+            )
+
+            if not existing:
+                self.db.insert(
+                    "predictions",
+                    {
+                        "content": content,
+                        "prediction_type": "suggestion",
+                        "priority": 0.6 + 0.3 * candidate["similarity"],
+                        "expires_at": (now + timedelta(days=14)).isoformat(),
+                        "created_at": now.isoformat(),
+                        "metadata": json.dumps({
+                            "dedupe_pair": [candidate["entity_1"]["id"], candidate["entity_2"]["id"]],
+                            "similarity": candidate["similarity"],
+                            "method": candidate["method"],
+                        }),
+                    },
+                )
 
         if candidates:
             logger.info(f"Found {len(candidates)} potential entity duplicates")

package/memory-daemon/claudia_memory/services/recall.py

@@ -971,9 +971,9 @@ class RecallService:
         Returns:
             List of matching entities
         """
-        canonical = self.extractor.canonical_name(query)
+        is_wildcard = not query or query.strip() in ("*", "")
 
-        # Try exact match first
+        # Base query with joins for counts
         sql = """
             SELECT e.*,
                    COUNT(DISTINCT me.memory_id) as memory_count,
@@ -983,9 +983,14 @@ class RecallService:
             LEFT JOIN memory_entities me ON e.id = me.entity_id
             LEFT JOIN memories m ON me.memory_id = m.id
             LEFT JOIN relationships r ON e.id = r.source_entity_id OR e.id = r.target_entity_id
-            WHERE e.canonical_name LIKE ? OR e.name LIKE ?
+            WHERE e.deleted_at IS NULL
         """
-        params = [f"%{canonical}%", f"%{query}%"]
+        params = []
+
+        if not is_wildcard:
+            canonical = self.extractor.canonical_name(query)
+            sql += " AND (e.canonical_name LIKE ? OR e.name LIKE ?)"
+            params.extend([f"%{canonical}%", f"%{query}%"])
 
         if entity_types:
             placeholders = ", ".join(["?" for _ in entity_types])

package/memory-daemon/claudia_memory/services/remember.py

@@ -56,6 +56,47 @@ def _strip_private(content: str) -> str:
     return stripped if stripped else content
 
 
+def _infer_entity_type(name: str) -> str:
+    """Infer entity type from name keywords when no explicit type is provided.
+
+    Checks for organizational, project, concept, and location keywords.
+    Returns 'person' as fallback when no keywords match.
+    Conservative: only clear keyword signals trigger inference.
+    """
+    lower = name.lower()
+    words = lower.split()
+
+    # Location keywords (checked first: "Company HQ" is a location, not an org)
+    location_keywords = ["office", "hq", "headquarters", "campus", "building"]
+    for kw in location_keywords:
+        if kw in words:
+            return "location"
+
+    # Organization keywords (check as whole words)
+    org_keywords = [
+        "inc", "llc", "corp", "corporation", "foundation", "university",
+        "lab", "labs", "ltd", "gmbh", "company", "institute", "associates",
+        "group", "partners",
+    ]
+    for kw in org_keywords:
+        if kw in words:
+            return "organization"
+
+    # Project keywords
+    project_keywords = ["project", "sprint", "mvp", "initiative", "campaign"]
+    for kw in project_keywords:
+        if kw in words:
+            return "project"
+
+    # Concept keywords
+    concept_keywords = ["methodology", "framework", "theory", "protocol", "strategy"]
+    for kw in concept_keywords:
+        if kw in words:
+            return "concept"
+
+    return "person"
+
+
 class RememberService:
     """Store and manage memories"""
 
@@ -360,7 +401,7 @@ class RememberService:
     def remember_entity(
         self,
         name: str,
-        entity_type: str = "person",
+        entity_type: str = "",
         description: Optional[str] = None,
         aliases: Optional[List[str]] = None,
         metadata: Optional[Dict] = None,
@@ -379,6 +420,10 @@ class RememberService:
         Returns:
             Entity ID
         """
+        # Infer type from name keywords when no type is specified
+        if not entity_type or not entity_type.strip():
+            entity_type = _infer_entity_type(name)
+
         # Run deterministic guards
         existing_names = [
             row["canonical_name"]
@@ -1734,7 +1779,7 @@ class RememberService:
             entity_type=extracted.type,
         )
 
-    def _find_or_create_entity(self, name: str, entity_type: str = "person") -> Optional[int]:
+    def _find_or_create_entity(self, name: str, entity_type: str = "") -> Optional[int]:
         """Find entity by name or create if not exists"""
         canonical = self.extractor.canonical_name(name)
 

package/memory-daemon/pyproject.toml

@@ -11,7 +11,7 @@ license = {text = "Apache-2.0"}
 authors = [
     {name = "Kamil Banc"}
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.10,<3.14"  # 3.14 blocked: spaCy/pydantic-core/numpy lack wheels
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",

package/package.json

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