get-claudia 1.54.4 → 1.55.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 1.55.0 (2026-03-15)
+
+### The Unified Memory Release
+
+Claudia no longer fragments your memory across dozens of invisible database files. Every project, every session, one brain.
+
+- **Single database** -- All sessions now use `~/.claudia/memory/claudia.db` regardless of which project directory you're in. No more hash-named files like `6af67351bcfa.db` that nobody can identify or recover.
+- **Automatic consolidation** -- On first startup after upgrade, Claudia detects your existing hash-named databases, merges all their data into the unified `claudia.db`, and cleans up the old files. Zero manual steps.
+- **Workspace provenance** -- New `workspace_id` column on memories tracks which project directory created each memory. This is provenance metadata ("where did I learn this?"), not a filter wall. Recall stays global: Claudia remembers Sarah regardless of which project you're in.
+- **Human-readable backups** -- Backups now live in `~/.claudia/backups/` with clear names like `claudia-daily-2026-03-15.db` and `claudia-pre-merge-2026-03-15.db` instead of cryptic timestamps alongside the database file.
+- **Pre-merge safety net** -- Before any consolidation, a backup is created automatically. If anything goes wrong, your data is recoverable.
+- **DB identity logging** -- Every daemon startup logs exactly which database it's using and how many memories it contains. No more guessing.
+- **Manual merge CLI** -- `python -m claudia_memory --merge-databases` lets you preview (`--dry-run`) or manually trigger consolidation.
+- **Schema migration 21** -- Adds `workspace_id TEXT` column and index to memories table.
+- **39 new tests** -- Full coverage for unified DB, consolidation, backup naming, and workspace tagging. All 608 tests pass.
+
 ## 1.54.4 (2026-03-14)
 
 ### The One-Click Setup Release

package/README.md

@@ -15,10 +15,10 @@ Remembers your people. Catches your commitments. Learns how you work.
 </p>
 
 <p align="center">
-<a href="#try-it-in-30-seconds"><strong>Try the Demo</strong></a> ·
+<a href="#quick-start"><strong>Install</strong></a> ·
 <a href="#what-makes-claudia-different">Why Claudia</a> ·
 <a href="#how-her-mind-works">Her Mind</a> ·
-<a href="#quick-start">Install</a> ·
+<a href="#integrations">Integrations</a> ·
 <a href="#how-it-works">How It Works</a>
 </p>
 
@@ -112,20 +112,33 @@ You make a promise in a meeting. Nobody tracks it. You promise a deliverable on
 
 ## Quick Start
 
+**1. Install**
 ```bash
 npx get-claudia
+```
+
+**2. Start**
+```bash
 cd claudia
 claude
 ```
 
+**3. Say hi.** She'll introduce herself, learn about you through a natural conversation, and generate a personalized workspace.
+
 <p align="center">
 <img src="assets/claudia-install.gif" alt="Installing Claudia" width="600">
 </p>
 
-Say hi. She'll introduce herself, learn about you in a natural conversation, and generate a personalized workspace within a few sessions.
+**What's next:**
+- `/morning-brief` to see what needs attention
+- Tell her about a person and she'll create a relationship file
+- Share meeting notes and she'll extract action items
+- `npx get-claudia google` to connect Gmail, Calendar, Drive, and more
 
 **Requirements:** [Claude Code](https://docs.anthropic.com/en/docs/claude-code), Node.js 18+, Python 3.10+ (for memory), [Ollama](https://ollama.com) (for embeddings)
 
+> **Embeddings model:** After installing Ollama, pull the required model: `ollama pull all-minilm:l6-v2`
+
 <details>
 <summary><strong>Template-only install (no memory system)</strong></summary>
 
@@ -253,7 +266,7 @@ Claudia detects your work style and generates structure that fits:
 | `/memory-audit` | See everything Claudia knows, with source chains |
 
 <details>
-<summary><strong>All commands (43 skills)</strong></summary>
+<summary><strong>All commands (41 skills)</strong></summary>
 
 | Command | What It Does |
 |---------|--------------|
@@ -277,13 +290,62 @@ Plus ~30 proactive skills (commitment detection, pattern recognition, judgment a
 
 ---
 
+## Brain Visualizer
+
+Launch with `/brain` to see your memory as a 3D network graph. Entities are nodes, relationships are edges, and everything is interactive: click to inspect, filter by type, search by name.
+
+<p align="center">
+<img src="assets/brain-visualizer.png" alt="Claudia Brain Visualizer" width="700">
+</p>
+
+---
+
+## Integrations
+
+Claudia works fully on her own, but integrations let her see further.
+
+### Google Workspace
+
+Connect Gmail, Calendar, Drive, Docs, Sheets, Tasks, and more with a single setup command:
+
+```bash
+npx get-claudia google
+```
+
+This generates a one-click URL to enable all required Google APIs and walks you through OAuth setup. Three tiers available:
+
+| Tier | Tools | What You Get |
+|------|-------|-------------|
+| **Core** | 43 | Gmail, Calendar, Drive, Contacts |
+| **Extended** | 83 | Core + Docs, Sheets, Tasks, Chat |
+| **Complete** | 111 | Extended + Slides, Forms, Apps Script |
+
+### 500+ Apps via Rube
+
+[Rube](https://rube.app) (by Composio) connects Claudia to Slack, Notion, Jira, GitHub, Linear, HubSpot, Stripe, Figma, and hundreds more through one-click OAuth. No per-app MCP setup needed.
+
+| Category | Examples |
+|----------|----------|
+| **Communication** | Slack, Discord, Teams, Telegram |
+| **Project Management** | Jira, Linear, Asana, Trello, Monday.com |
+| **Knowledge & Docs** | Notion, Confluence, Google Docs, Coda |
+| **Code & Dev** | GitHub, GitLab, Bitbucket |
+| **CRM & Sales** | HubSpot, Salesforce, Pipedrive |
+| **And 500+ more** | [Browse the full list](https://rube.app) |
+
+### Obsidian Vault
+
+Memory auto-syncs to an Obsidian vault at `~/.claudia/vault/` using PARA structure. Every entity becomes a markdown note with `[[wikilinks]]`, so Obsidian's graph view maps your network. SQLite is the source of truth; the vault is a read-only projection you can browse and search.
+
+---
+
 ## How It Works
 
-**59 skills · 33 MCP tools · 500+ tests**
+**41 skills · 33 MCP tools · 500+ tests**
 
 Claudia has two layers:
 
-**Template layer** (markdown) defines who she is. 59 skills, rules, and identity files that Claude reads on startup. Skills range from proactive behaviors (commitment detection, pattern recognition, judgment awareness) to user-invocable workflows (`/morning-brief`, `/research`, `/meditate`). Workspace templates let you spin up new projects with `/new-workspace [name]`.
+**Template layer** (markdown) defines who she is. 41 skills, rules, and identity files that Claude reads on startup. Skills range from proactive behaviors (commitment detection, pattern recognition, judgment awareness) to user-invocable workflows (`/morning-brief`, `/research`, `/meditate`). Workspace templates let you spin up new projects with `/new-workspace [name]`.
 
 **Memory system** (Python) defines what she remembers. Two daemon modes share the same SQLite database:
 
@@ -360,6 +422,8 @@ For full architecture diagrams, see [ARCHITECTURE.md](ARCHITECTURE.md).
 
 Without the memory system, Claudia still works using markdown files. With it, she gains semantic search, pattern detection, and relationship tracking.
 
+> **Ollama model:** Run `ollama pull all-minilm:l6-v2` after installing Ollama. This is the embedding model used for semantic search.
+
 **Platforms:** macOS, Linux, Windows
 
 ---
@@ -395,6 +459,13 @@ ollama serve            # Linux
 ollama pull all-minilm:l6-v2    # Embeddings (required)
 ```
 
+**Google Workspace not working after enabling new APIs?**
+Delete the cached token and restart to re-authenticate with updated scopes:
+```bash
+rm ~/.workspace-mcp/token.json
+# Restart Claude Code
+```
+
 **Broken install? Re-run setup:**
 ```bash
 cd your-claudia-directory

package/bin/index.js

@@ -3,7 +3,7 @@
 import { existsSync, mkdirSync, cpSync, readdirSync, readFileSync, writeFileSync, statSync, renameSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { spawn } from 'child_process';
+import { spawn, execFileSync } from 'child_process';
 import { homedir } from 'os';
 import { createInterface } from 'readline';
 import { setupGoogleWorkspace, detectOldGoogleMcp, extractProjectNumber, buildApiEnableUrl, TIER_APIS } from './google-setup.js';
@@ -960,6 +960,45 @@ async function main() {
       }
     }
 
+    // Scan existing databases and show stats
+    if (daemonOk) {
+      const dbScan = scanExistingDatabases();
+      if (dbScan.totalMemories > 0 || dbScan.hashDbs.length > 0) {
+        renderer.stopSpinner();
+        console.log('');
+        console.log(`${colors.dim}${'─'.repeat(46)}${colors.reset}`);
+        console.log(` ${colors.boldCyan}Memory Database Scan${colors.reset}`);
+        console.log('');
+
+        if (dbScan.unified.exists) {
+          console.log(` ${colors.green}●${colors.reset} claudia.db: ${colors.bold}${dbScan.unified.memories}${colors.reset} memories, ${colors.bold}${dbScan.unified.entities}${colors.reset} entities`);
+        }
+
+        if (dbScan.hashDbs.length > 0) {
+          const withData = dbScan.hashDbs.filter(d => d.memories > 0 || d.entities > 0);
+          const empty = dbScan.hashDbs.filter(d => d.memories === 0 && d.entities === 0);
+
+          if (withData.length > 0) {
+            console.log('');
+            console.log(` ${colors.yellow}Found ${withData.length} legacy database${withData.length !== 1 ? 's' : ''} to consolidate:${colors.reset}`);
+            for (const db of withData) {
+              console.log(`   ${colors.dim}${db.name}${colors.reset}: ${db.memories} memories, ${db.entities} entities`);
+            }
+            console.log('');
+            console.log(` ${colors.dim}These will be auto-merged into claudia.db on next startup.${colors.reset}`);
+          }
+          if (empty.length > 0) {
+            console.log(` ${colors.dim}${empty.length} empty database${empty.length !== 1 ? 's' : ''} will be cleaned up automatically.${colors.reset}`);
+          }
+        } else if (dbScan.unified.exists && dbScan.unified.memories > 0) {
+          console.log(` ${colors.dim}Unified database, no legacy files to consolidate.${colors.reset}`);
+        }
+
+        console.log(`${colors.dim}${'─'.repeat(46)}${colors.reset}`);
+        renderer.startSpinner();
+      }
+    }
+
     memoryOk = daemonOk || hasExistingDb;
 
   } catch (err) {
@@ -1175,6 +1214,80 @@ function restoreMcpServers(targetPath) {
   }
 }
 
+/**
+ * Scan ~/.claudia/memory/ for existing databases and return rough stats.
+ * Uses sqlite3 CLI (via execFileSync) to query each .db file safely.
+ * Returns { unified: { exists, memories, entities }, hashDbs: [...], totalMemories }
+ */
+function scanExistingDatabases() {
+  const memoryDir = join(homedir(), '.claudia', 'memory');
+  const result = {
+    unified: { exists: false, memories: 0, entities: 0 },
+    hashDbs: [],
+    totalMemories: 0,
+  };
+
+  if (!existsSync(memoryDir)) return result;
+
+  let files;
+  try {
+    files = readdirSync(memoryDir);
+  } catch {
+    return result;
+  }
+
+  const hashPattern = /^[0-9a-f]{12}\.db$/;
+
+  for (const file of files) {
+    if (!file.endsWith('.db')) continue;
+    // Skip WAL/SHM/backup files
+    if (file.includes('-wal') || file.includes('-shm') || file.includes('.backup')) continue;
+    const filePath = join(memoryDir, file);
+
+    try {
+      const stats = statSync(filePath);
+      if (stats.size < 4096) continue; // Too small to have data
+    } catch {
+      continue;
+    }
+
+    // Query using sqlite3 CLI (no shell, safe from injection)
+    let memories = 0;
+    let entities = 0;
+    try {
+      const memResult = execFileSync('sqlite3', [filePath, 'SELECT COUNT(*) FROM memories;'], {
+        encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      memories = parseInt(memResult, 10) || 0;
+    } catch { /* table may not exist */ }
+
+    try {
+      const entResult = execFileSync('sqlite3', [filePath, 'SELECT COUNT(*) FROM entities WHERE deleted_at IS NULL;'], {
+        encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      entities = parseInt(entResult, 10) || 0;
+    } catch {
+      try {
+        const entResult = execFileSync('sqlite3', [filePath, 'SELECT COUNT(*) FROM entities;'], {
+          encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        entities = parseInt(entResult, 10) || 0;
+      } catch { /* skip */ }
+    }
+
+    if (file === 'claudia.db') {
+      result.unified = { exists: true, memories, entities };
+    } else if (hashPattern.test(file)) {
+      result.hashDbs.push({ name: file, memories, entities });
+    }
+
+    result.totalMemories += memories;
+  }
+
+  return result;
+}
+
+
 /**
  * Ensure .mcp.json has a working claudia-memory daemon entry.
  * - Fresh install (no .mcp.json): creates one with just the daemon entry.

package/memory-daemon/claudia_memory/__main__.py

@@ -163,102 +163,177 @@ def _check_and_repair_database(db_path: Path) -> None:
         )
 
 
-def _auto_migrate_legacy() -> None:
-    """Auto-migrate data from legacy claudia.db if it exists.
+def _auto_consolidate() -> None:
+    """Auto-consolidate hash-named databases into the unified claudia.db.
 
-    When Claudia switched from a single claudia.db to project-hash naming
-    ({sha256[:12]}.db), no data migration was performed. This function
-    detects the orphaned legacy database and migrates its data into the
-    active project-specific database.
+    Detects hash-named databases (12-char hex filenames) in ~/.claudia/memory/
+    and merges them into claudia.db. This handles the upgrade from per-project
+    hash-based DB isolation to the unified database model.
 
     Properties:
-    - Idempotent: checks _meta flag, won't run twice
-    - Safe: backs up before touching anything, preserves original
+    - Idempotent: checks _meta['unified_db'] flag, won't run twice
+    - Safe: creates pre-merge backup before any changes
     - Non-fatal: catches all exceptions, logs, continues
+    - Cleans up: deletes hash DBs + WAL/SHM after successful merge
     """
     from .migration import (
-        check_legacy_database,
-        is_migration_completed,
-        mark_migration_completed,
-        migrate_legacy_database,
+        cleanup_old_databases,
+        merge_all_databases,
+        scan_hash_databases,
+        verify_consolidated_db,
     )
 
     try:
+        db = get_db()
         config = get_config()
-        legacy_path = Path.home() / ".claudia" / "memory" / "claudia.db"
-        active_path = Path(config.db_path)
+        memory_dir = Path(config.db_path).parent
 
-        # Skip if active db IS the legacy db (no project isolation active)
+        # Check if already consolidated
         try:
-            if legacy_path.resolve() == active_path.resolve():
-                return
-        except OSError:
-            if str(legacy_path) == str(active_path):
+            rows = db.execute(
+                "SELECT value FROM _meta WHERE key = 'unified_db'",
+                fetch=True,
+            )
+            if rows and rows[0]["value"] == "true":
+                logger.debug("Database already unified, skipping consolidation")
                 return
+        except Exception:
+            pass  # _meta table might not exist yet
 
-        # Skip if legacy database doesn't exist
-        if not legacy_path.exists():
+        # Scan for hash-named databases
+        all_hash_dbs = scan_hash_databases(memory_dir)
+        if not all_hash_dbs:
+            # No hash DBs found: fresh install or already cleaned up
+            _set_unified_db_flag(db)
             return
 
-        # Skip if migration already completed (idempotent)
-        db = get_db()
-        if is_migration_completed(db):
+        # Separate databases with data from empty ones
+        data_dbs = [d for d in all_hash_dbs if d["has_data"]]
+        empty_dbs = [d for d in all_hash_dbs if not d["has_data"]]
+
+        if not data_dbs and empty_dbs:
+            # Only empty hash DBs: clean them up and mark unified
+            logger.info(f"Found {len(empty_dbs)} empty hash databases, cleaning up")
+            cleanup_old_databases(memory_dir, empty_dbs)
+            _set_unified_db_flag(db)
             return
 
-        # Check if legacy database has meaningful data
-        legacy_stats = check_legacy_database(legacy_path)
-        if not legacy_stats:
-            # Empty or unreadable legacy db -- mark complete so we don't check again
-            mark_migration_completed(db, {"skipped": "no_data"})
-            logger.info("Legacy claudia.db exists but has no data worth migrating")
+        if not data_dbs:
+            _set_unified_db_flag(db)
             return
 
+        # Log what we found
+        total_memories = sum(d["stats"].get("memories", 0) for d in data_dbs)
+        total_entities = sum(d["stats"].get("entities", 0) for d in data_dbs)
         logger.info(
-            f"Found legacy claudia.db with {legacy_stats.get('entities', 0)} entities "
-            f"and {legacy_stats.get('memories', 0)} memories"
+            f"Found {len(data_dbs)} hash databases with data "
+            f"({total_memories} memories, {total_entities} entities). "
+            f"Consolidating into claudia.db..."
         )
 
-        # Create pre-migration backup of active database (if it has data)
-        if active_path.exists():
-            try:
-                backup_path = db.backup(label="pre-migration")
-                logger.info(f"Pre-migration backup created: {backup_path}")
-            except Exception as e:
-                logger.warning(f"Pre-migration backup failed: {e}")
-                # Continue anyway -- the migration is additive, not destructive
+        # Create pre-merge backup
+        try:
+            backup_path = db.backup(label="pre-merge")
+            logger.info(f"Pre-merge backup created: {backup_path}")
+        except Exception as e:
+            logger.warning(f"Pre-merge backup failed: {e}")
+            # Continue anyway, the merge is additive
 
-        # Run the migration
-        logger.info(f"Starting legacy database migration: {legacy_path} -> {active_path}")
-        results = migrate_legacy_database(legacy_path, active_path)
+        # Merge all hash databases into claudia.db
+        active_path = Path(config.db_path)
+        totals = merge_all_databases(active_path, data_dbs)
 
-        # Mark migration as completed
-        mark_migration_completed(db, results)
+        # Verify integrity after merge
+        if not verify_consolidated_db(active_path):
+            logger.error(
+                "Integrity check FAILED after consolidation. "
+                "Keeping hash databases for manual recovery."
+            )
+            return
 
-        # Rename the legacy database (preserve, don't delete)
-        from datetime import datetime as dt
-        date_suffix = dt.now().strftime("%Y-%m-%d")
-        migrated_path = legacy_path.with_suffix(f".db.migrated-{date_suffix}")
-        try:
-            legacy_path.rename(migrated_path)
-            logger.info(f"Renamed legacy database: {legacy_path} -> {migrated_path}")
-        except OSError as e:
-            logger.warning(f"Could not rename legacy database: {e}")
+        # Clean up: delete hash DBs + WAL/SHM + orphan backups
+        deleted = cleanup_old_databases(memory_dir, all_hash_dbs)
+
+        # Set the unified_db flag
+        _set_unified_db_flag(db)
+
+        merged_count = totals.get('total_memories_migrated', 0)
+        sources_count = totals.get('sources_merged', 0)
 
-        # Log summary
         logger.info(
-            f"Legacy migration complete: "
-            f"{results.get('entities_created', 0)} entities created, "
-            f"{results.get('entities_mapped', 0)} mapped, "
-            f"{results.get('memories_migrated', 0)} memories migrated, "
-            f"{results.get('links_migrated', 0)} links migrated, "
-            f"{results.get('relationships_migrated', 0)} relationships migrated"
+            f"Consolidated {merged_count} memories "
+            f"from {sources_count} databases into claudia.db. "
+            f"Cleaned up {deleted} old files."
         )
 
+        # Write context/whats-new.md so Claudia surfaces the upgrade in-chat
+        _write_consolidation_notice(merged_count, sources_count)
+
     except Exception as e:
         # Non-fatal: log error and continue with whatever data we have
-        logger.error(f"Legacy migration failed (non-fatal): {e}")
+        logger.error(f"Auto-consolidation failed (non-fatal): {e}")
         logger.info("Daemon will continue with current database. "
-                     "Run --migrate-legacy manually to retry.")
+                     "Run --merge-databases manually to retry.")
+
+
+def _set_unified_db_flag(db) -> None:
+    """Set the _meta flag indicating this is a unified database."""
+    from datetime import datetime as dt
+    try:
+        db.execute(
+            "INSERT OR REPLACE INTO _meta (key, value, updated_at) "
+            "VALUES ('unified_db', 'true', ?)",
+            (dt.now().isoformat(),),
+        )
+    except Exception as e:
+        logger.warning(f"Could not set unified_db flag: {e}")
+
+
+def _write_consolidation_notice(merged_count: int, sources_count: int) -> None:
+    """Write context/whats-new.md so Claudia mentions the upgrade in her greeting.
+
+    Looks for context/ in the workspace path (set via --project-dir).
+    Falls back silently if no workspace is configured.
+    """
+    workspace_path = os.environ.get("CLAUDIA_WORKSPACE_PATH")
+    if not workspace_path:
+        return
+
+    try:
+        context_dir = Path(workspace_path) / "context"
+        whats_new = context_dir / "whats-new.md"
+
+        # Don't overwrite if installer already wrote one
+        if whats_new.exists():
+            return
+
+        if not context_dir.exists():
+            return  # Not a Claudia workspace
+
+        from datetime import datetime as dt
+        date = dt.now().strftime("%Y-%m-%d")
+
+        content = f"""# Memory System Upgrade ({date})
+
+Your memory has been unified. Previously, each project directory got its own isolated database (hash-named files like `6af67351bcfa.db`). Now everything lives in one `~/.claudia/memory/claudia.db`.
+
+**What happened automatically:**
+- Consolidated {merged_count} memories from {sources_count} database{'s' if sources_count != 1 else ''} into a single unified database
+- Created a pre-merge backup at `~/.claudia/backups/`
+- Cleaned up old hash-named database files
+
+**What this means for you:**
+- I remember everything from every project, always. No more fragmented memory.
+- Moving project directories no longer loses your history.
+- New `workspace_id` on memories tracks where I learned each fact (provenance, not a wall).
+
+---
+_Surface this update in your first greeting, then delete this file._
+"""
+        whats_new.write_text(content)
+        logger.info(f"Wrote consolidation notice to {whats_new}")
+    except Exception as e:
+        logger.debug(f"Could not write consolidation notice: {e}")
 
 
 def _write_preflight_result(result: dict) -> Path:
@@ -656,10 +731,19 @@ def run_daemon(mcp_mode: bool = True, debug: bool = False, project_id: str = Non
         # Initialize database
         db = get_db()
         db.initialize()
-        logger.info(f"Database initialized at {get_config().db_path}")
 
-        # Auto-migrate legacy claudia.db if it exists
-        _auto_migrate_legacy()
+        # Log database identity
+        try:
+            mem_count = db.execute(
+                "SELECT COUNT(*) as c FROM memories", fetch=True
+            )
+            count = mem_count[0]["c"] if mem_count else 0
+            logger.info(f"Using database: {get_config().db_path} ({count} memories)")
+        except Exception:
+            logger.info(f"Using database: {get_config().db_path}")
+
+        # Auto-consolidate hash-named databases into unified claudia.db
+        _auto_consolidate()
 
         # Start health server and scheduler - ONLY in standalone mode.
         # MCP server processes are ephemeral and session-bound; the standalone
@@ -736,7 +820,7 @@ def main():
     parser.add_argument(
         "--project-dir",
         type=str,
-        help="Project directory for database isolation (creates project-specific database)",
+        help="Project directory for workspace tagging (provenance on memories, not DB isolation)",
     )
     parser.add_argument(
         "--tui",
@@ -781,7 +865,12 @@ def main():
     parser.add_argument(
         "--migrate-legacy",
         action="store_true",
-        help="Manually migrate data from legacy claudia.db to project-specific database",
+        help="Manually migrate data from a legacy database into claudia.db",
+    )
+    parser.add_argument(
+        "--merge-databases",
+        action="store_true",
+        help="Manually merge all hash-named databases into unified claudia.db",
     )
     parser.add_argument(
         "--preflight",
@@ -1355,6 +1444,80 @@ def main():
         run_para_migration(vault_path, db=db, preview=args.preview)
         return
 
+    if args.merge_databases:
+        # Manual consolidation of hash-named databases
+        setup_logging(debug=args.debug)
+        from .migration import (
+            cleanup_old_databases,
+            merge_all_databases,
+            scan_hash_databases,
+            verify_consolidated_db,
+        )
+
+        db = get_db()
+        db.initialize()
+        config = get_config()
+        memory_dir = Path(config.db_path).parent
+
+        hash_dbs = scan_hash_databases(memory_dir)
+        data_dbs = [d for d in hash_dbs if d["has_data"]]
+        empty_dbs = [d for d in hash_dbs if not d["has_data"]]
+
+        if not hash_dbs:
+            print("No hash-named databases found. Nothing to merge.")
+            return
+
+        print(f"\nFound {len(hash_dbs)} hash-named databases:")
+        for d in hash_dbs:
+            stats_str = ""
+            if d["has_data"]:
+                s = d["stats"]
+                stats_str = f"  {s.get('memories', 0)} memories, {s.get('entities', 0)} entities"
+            else:
+                stats_str = "  (empty)"
+            print(f"  {d['path'].name}{stats_str}")
+
+        print(f"\nTarget: {config.db_path}")
+        print(f"  {len(data_dbs)} with data, {len(empty_dbs)} empty")
+
+        if args.dry_run:
+            print("\nDry run mode: no changes will be made.\n")
+            if data_dbs:
+                totals = merge_all_databases(Path(config.db_path), data_dbs, dry_run=True)
+                print(f"\nWould merge:")
+                for key, val in totals.items():
+                    if val > 0:
+                        print(f"  {key}: {val}")
+            return
+
+        if data_dbs:
+            # Backup before merge
+            backup_path = db.backup(label="pre-merge")
+            print(f"\nBackup created: {backup_path}")
+
+            print("\nMerging...")
+            totals = merge_all_databases(Path(config.db_path), data_dbs)
+
+            if verify_consolidated_db(Path(config.db_path)):
+                print("Integrity check: PASSED")
+            else:
+                print("Integrity check: FAILED (keeping hash databases)")
+                return
+
+            print(f"\nResults:")
+            for key, val in totals.items():
+                if val > 0:
+                    print(f"  {key}: {val}")
+
+        # Clean up
+        deleted = cleanup_old_databases(memory_dir, hash_dbs)
+        print(f"\nCleaned up {deleted} old files.")
+
+        # Set unified_db flag
+        _set_unified_db_flag(db)
+        print("Unified database flag set.")
+        return
+
     if args.migrate_legacy:
         # Manual legacy database migration
         setup_logging(debug=args.debug)

package/memory-daemon/claudia_memory/config.py

@@ -118,17 +118,25 @@ class MemoryConfig:
     context_builder_token_budget: int = 8000  # Default token budget for CRE
     context_builder_max_facts: int = 30       # Max facts in CRE context window
 
+    # Workspace tracking (provenance, not partition)
+    workspace_id: Optional[str] = None  # Auto-set from --project-dir; tags memories with origin workspace
+
     # Daemon settings
     log_path: Path = field(default_factory=lambda: Path.home() / ".claudia" / "daemon.log")
 
+    @property
+    def backup_dir(self) -> Path:
+        """Directory for human-readable backups."""
+        return Path.home() / ".claudia" / "backups"
+
     @classmethod
     def load(cls, project_id: Optional[str] = None) -> "MemoryConfig":
         """Load configuration from ~/.claudia/config.json, with defaults.
 
         Args:
-            project_id: Optional project identifier for database isolation.
-                        When provided, the database path is overridden to
-                        ~/.claudia/memory/{project_id}.db for per-project isolation.
+            project_id: Optional project identifier. Stored as workspace_id for
+                        provenance tagging on memories. Does NOT change the database
+                        path (unified DB at ~/.claudia/memory/claudia.db).
         """
         config_path = Path.home() / ".claudia" / "config.json"
         config = cls()
@@ -241,22 +249,17 @@ class MemoryConfig:
         # DEMO MODE: Use isolated demo database (never touches real data)
         # Set CLAUDIA_DEMO_MODE=1 in environment to use demo database
         elif os.environ.get("CLAUDIA_DEMO_MODE") == "1":
-            if project_id:
-                # Workspace-specific demo database
-                config.db_path = Path.home() / ".claudia" / "demo" / f"{project_id}.db"
-            else:
-                # Global demo database
-                config.db_path = Path.home() / ".claudia" / "demo" / "claudia-demo.db"
-            config.db_path.parent.mkdir(parents=True, exist_ok=True)
-        # Override database path for project isolation
-        # This ensures each project gets its own isolated database
-        elif project_id:
-            config.db_path = Path.home() / ".claudia" / "memory" / f"{project_id}.db"
+            config.db_path = Path.home() / ".claudia" / "demo" / "claudia-demo.db"
             config.db_path.parent.mkdir(parents=True, exist_ok=True)
         else:
-            # Default path
+            # Unified database: always ~/.claudia/memory/claudia.db
+            # project_id is stored as workspace_id for provenance, not DB isolation
             config.db_path.parent.mkdir(parents=True, exist_ok=True)
 
+        # Store project_id as workspace_id (provenance metadata, not a partition)
+        if project_id:
+            config.workspace_id = project_id
+
         # Ensure log directory exists
         config.log_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -382,13 +385,13 @@ _project_id: Optional[str] = None
 
 
 def set_project_id(project_id: Optional[str]) -> None:
-    """Set the project ID for database isolation.
+    """Set the project ID for workspace tagging.
 
     This must be called before any access to get_config() to ensure
-    the correct project-specific database path is used.
+    the workspace_id is set for provenance tracking on memories.
 
     Args:
-        project_id: Hash of the project directory path, or None for global database.
+        project_id: Hash of the project directory path, or None.
     """
     global _config, _project_id
 
@@ -401,9 +404,8 @@ def set_project_id(project_id: Optional[str]) -> None:
 def get_config() -> MemoryConfig:
     """Get or load the global configuration.
 
-    The configuration is project-aware. If set_project_id() was called,
-    the database path will be project-specific. Otherwise, the global
-    claudia.db is used for backward compatibility.
+    Always uses the unified claudia.db. If set_project_id() was called,
+    the workspace_id is set for provenance tagging on memories.
     """
     global _config, _project_id
     if _config is None:

package/memory-daemon/claudia_memory/daemon/health.py

@@ -30,9 +30,11 @@ def build_status_report(*, db=None) -> dict:
     Args:
         db: Optional database instance. If None, uses the global get_db() singleton.
     """
+    config = get_config()
     report = {
         "timestamp": datetime.utcnow().isoformat(),
         "status": "healthy",
+        "db_path": str(config.db_path),
         "schema_version": 0,
         "components": {},
         "scheduled_jobs": [],
@@ -54,6 +56,17 @@ def build_status_report(*, db=None) -> dict:
         except Exception:
             report["schema_version"] = 0
 
+        # Unified DB identity
+        try:
+            meta_rows = _db.execute(
+                "SELECT value FROM _meta WHERE key = 'unified_db'", fetch=True
+            )
+            report["unified_db"] = (
+                meta_rows[0]["value"] == "true" if meta_rows else False
+            )
+        except Exception:
+            report["unified_db"] = False
+
         # Counts
         for table, query in [
             ("memories", "SELECT COUNT(*) as c FROM memories"),
@@ -69,12 +82,16 @@ def build_status_report(*, db=None) -> dict:
             except Exception:
                 report["counts"][table] = -1
 
-        # Backup status
+        # Backup status (check both new backups/ dir and legacy alongside-DB location)
         try:
             import glob
-            db_path = str(get_config().db_path)
-            pattern = f"{db_path}.backup-*.db"
-            backups = sorted(glob.glob(pattern))
+            backup_dir = config.backup_dir
+            new_pattern = str(backup_dir / "claudia-*.db")
+            old_pattern = f"{config.db_path}.backup-*.db"
+            backups = sorted(
+                glob.glob(new_pattern) + glob.glob(old_pattern),
+                key=lambda p: Path(p).stat().st_mtime if Path(p).exists() else 0,
+            )
             if backups:
                 latest = Path(backups[-1])
                 report["backup"] = {

package/memory-daemon/claudia_memory/database.py

@@ -1020,6 +1020,28 @@ class Database:
             conn.commit()
             logger.info("Applied migration 20: lifecycle tiers, sacred, close-circle, fact_id, chain")
 
+        if current_version < 21:
+            # Migration 21: Add workspace_id to memories for unified database provenance
+            try:
+                conn.execute("ALTER TABLE memories ADD COLUMN workspace_id TEXT")
+            except sqlite3.OperationalError as e:
+                if "duplicate column" not in str(e).lower():
+                    logger.warning(f"Migration 21 statement failed: {e}")
+
+            try:
+                conn.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_memories_workspace ON memories(workspace_id)"
+                )
+            except sqlite3.OperationalError as e:
+                logger.warning(f"Migration 21 index failed: {e}")
+
+            conn.execute(
+                "INSERT OR IGNORE INTO schema_migrations (version, description) "
+                "VALUES (21, 'Add workspace_id to memories for unified database provenance tracking')"
+            )
+            conn.commit()
+            logger.info("Applied migration 21: workspace_id for unified database")
+
         # FTS5 setup: ensure memories_fts exists regardless of migration path.
         # The FTS5 virtual table + triggers contain internal semicolons that the
         # schema.sql line-based parser can't handle, so we always check here.
@@ -1173,6 +1195,11 @@ class Database:
             logger.warning("Migration 19 incomplete: entity_summaries table missing")
             return 18
 
+        # Migration 21 added workspace_id to memories
+        if "workspace_id" not in memory_cols:
+            logger.warning("Migration 21 incomplete: memories missing workspace_id column")
+            return 20
+
         # Migration 20 added lifecycle_tier, fact_id to memories; close_circle to entities
         if "lifecycle_tier" not in memory_cols or "fact_id" not in memory_cols:
             logger.warning("Migration 20 incomplete: memories missing lifecycle/fact_id columns")
@@ -1351,9 +1378,15 @@ class Database:
     def backup(self, label: str = None) -> Path:
         """Create a backup of the database using SQLite's online backup API.
 
+        Backups are stored in ~/.claudia/backups/ with human-readable names:
+        - claudia-daily-2026-03-15.db
+        - claudia-pre-merge-2026-03-15.db
+        - claudia-manual-2026-03-15-143022.db
+
         Args:
             label: Optional label for categorized backups (e.g., "daily", "weekly",
-                   "pre-migration"). Labeled backups have independent retention counts.
+                   "pre-migration", "pre-merge"). Labeled backups have independent
+                   retention counts. If None, uses "manual" with timestamp.
 
         Returns:
             Path to the created backup file
@@ -1361,11 +1394,17 @@ class Database:
         import glob
 
         config = get_config()
-        timestamp = datetime.now().strftime("%Y-%m-%d-%H%M%S")
+        backup_dir = config.backup_dir
+        backup_dir.mkdir(parents=True, exist_ok=True)
+
         if label:
-            backup_path = Path(f"{self.db_path}.backup-{label}-{timestamp}.db")
+            # Labeled backups use date-only (one per day per label)
+            date_str = datetime.now().strftime("%Y-%m-%d")
+            backup_path = backup_dir / f"claudia-{label}-{date_str}.db"
         else:
-            backup_path = Path(f"{self.db_path}.backup-{timestamp}.db")
+            # Manual backups include full timestamp
+            timestamp = datetime.now().strftime("%Y-%m-%d-%H%M%S")
+            backup_path = backup_dir / f"claudia-manual-{timestamp}.db"
 
         # Create backup using SQLite's built-in backup API
         backup_conn = sqlite3.connect(str(backup_path))
@@ -1390,10 +1429,10 @@ class Database:
 
         # Rolling retention (per-label if labeled)
         if label:
-            pattern = f"{self.db_path}.backup-{label}-*.db"
+            pattern = str(backup_dir / f"claudia-{label}-*.db")
             retention = self._get_label_retention(label)
         else:
-            pattern = f"{self.db_path}.backup-*.db"
+            pattern = str(backup_dir / "claudia-manual-*.db")
             retention = config.backup_retention_count
 
         backups = sorted(glob.glob(pattern), key=os.path.getmtime)
@@ -1413,6 +1452,8 @@ class Database:
         retention_map = {
             "daily": config.backup_daily_retention,
             "weekly": config.backup_weekly_retention,
+            "pre-merge": 4,      # Keep pre-merge backups for ~1 month
+            "pre-migration": 4,  # Keep pre-migration backups for ~1 month
         }
         return retention_map.get(label, config.backup_retention_count)
 

package/memory-daemon/claudia_memory/migration.py

@@ -1152,6 +1152,167 @@ def _migrate_reflections(
     logger.info(f"Reflections: {results['reflections_migrated']} migrated")
 
 
+# ── Unified Database Consolidation ───────────────────────────────────
+
+def scan_hash_databases(memory_dir: Path) -> List[Dict]:
+    """Scan ~/.claudia/memory/ for hash-named databases with data.
+
+    Returns a list of dicts with path, hash, and stats for each non-empty
+    hash-named database (12-char hex filenames like 6af67351bcfa.db).
+    """
+    import re
+
+    results = []
+    hash_pattern = re.compile(r"^[0-9a-f]{12}\.db$")
+
+    if not memory_dir.exists():
+        return results
+
+    for f in memory_dir.iterdir():
+        if not hash_pattern.match(f.name):
+            continue
+
+        db_hash = f.stem
+        stats = check_legacy_database(f)
+        results.append({
+            "path": f,
+            "hash": db_hash,
+            "has_data": stats is not None,
+            "stats": stats,
+        })
+
+    return results
+
+
+def merge_all_databases(
+    target_path: Path,
+    source_dbs: List[Dict],
+    dry_run: bool = False,
+) -> Dict[str, int]:
+    """Merge multiple hash-named databases into the unified claudia.db.
+
+    Each source DB's memories get tagged with workspace_id = source hash.
+    Deduplication uses content_hash for memories and (canonical_name, type)
+    for entities.
+
+    Args:
+        target_path: Path to the unified claudia.db
+        source_dbs: List of dicts from scan_hash_databases() (only those with data)
+        dry_run: If True, count what would be merged without making changes
+
+    Returns:
+        Dict with total migration counts across all sources
+    """
+    totals = {
+        "sources_merged": 0,
+        "total_entities_created": 0,
+        "total_entities_mapped": 0,
+        "total_memories_migrated": 0,
+        "total_memories_duplicate": 0,
+        "total_relationships_migrated": 0,
+        "total_links_migrated": 0,
+    }
+
+    for source in source_dbs:
+        source_path = source["path"]
+        source_hash = source["hash"]
+
+        logger.info(f"Merging {source_path.name} ({source['stats'].get('memories', 0)} memories, "
+                     f"{source['stats'].get('entities', 0)} entities)")
+
+        try:
+            results = migrate_legacy_database(
+                legacy_path=source_path,
+                active_path=target_path,
+                dry_run=dry_run,
+            )
+
+            # Tag merged memories with workspace_id = source hash
+            if not dry_run:
+                try:
+                    conn = sqlite3.connect(str(target_path), timeout=30)
+                    conn.execute(
+                        "UPDATE memories SET workspace_id = ? "
+                        "WHERE workspace_id IS NULL AND id IN ("
+                        "  SELECT id FROM memories WHERE workspace_id IS NULL"
+                        ")",
+                        (source_hash,),
+                    )
+                    conn.commit()
+                    conn.close()
+                except Exception as e:
+                    logger.warning(f"Could not tag workspace_id for {source_hash}: {e}")
+
+            totals["sources_merged"] += 1
+            totals["total_entities_created"] += results.get("entities_created", 0)
+            totals["total_entities_mapped"] += results.get("entities_mapped", 0)
+            totals["total_memories_migrated"] += results.get("memories_migrated", 0)
+            totals["total_memories_duplicate"] += results.get("memories_duplicate", 0)
+            totals["total_relationships_migrated"] += results.get("relationships_migrated", 0)
+            totals["total_links_migrated"] += results.get("links_migrated", 0)
+
+        except Exception as e:
+            logger.error(f"Failed to merge {source_path.name}: {e}")
+            # Non-fatal: continue with other sources
+
+    return totals
+
+
+def cleanup_old_databases(memory_dir: Path, source_dbs: List[Dict]) -> int:
+    """Delete hash-named databases and their WAL/SHM files after successful merge.
+
+    Args:
+        memory_dir: The ~/.claudia/memory/ directory
+        source_dbs: List of dicts from scan_hash_databases()
+
+    Returns:
+        Number of files deleted
+    """
+    deleted = 0
+
+    for source in source_dbs:
+        db_path = source["path"]
+
+        # Delete the database and its WAL/SHM companions
+        for suffix in ("", "-wal", "-shm"):
+            companion = Path(str(db_path) + suffix)
+            if companion.exists():
+                try:
+                    companion.unlink()
+                    deleted += 1
+                    logger.info(f"Deleted: {companion.name}")
+                except OSError as e:
+                    logger.warning(f"Could not delete {companion}: {e}")
+
+        # Delete any orphan backup files for this hash DB
+        import glob
+        orphan_pattern = str(db_path) + ".backup-*"
+        for orphan in glob.glob(orphan_pattern):
+            try:
+                Path(orphan).unlink()
+                deleted += 1
+                logger.info(f"Deleted orphan backup: {Path(orphan).name}")
+            except OSError as e:
+                logger.warning(f"Could not delete orphan backup {orphan}: {e}")
+
+    return deleted
+
+
+def verify_consolidated_db(db_path: Path) -> bool:
+    """Verify integrity of the consolidated database.
+
+    Returns True if the database passes PRAGMA integrity_check.
+    """
+    try:
+        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True, timeout=5)
+        result = conn.execute("PRAGMA integrity_check").fetchone()
+        conn.close()
+        return result is not None and result[0] == "ok"
+    except Exception as e:
+        logger.error(f"Integrity check failed: {e}")
+        return False
+
+
 # ── Utilities ────────────────────────────────────────────────────────
 
 def _safe_json_parse(text: str, default: Any = None) -> Any:

package/memory-daemon/claudia_memory/schema.sql

@@ -79,7 +79,8 @@ CREATE TABLE IF NOT EXISTS memories (
     archived_at TEXT,  -- When this memory was archived
     fact_id TEXT UNIQUE,  -- UUID for human-friendly reference
     hash TEXT,  -- SHA-256 chain hash
-    prev_hash TEXT  -- Previous hash in chain (NULL for genesis)
+    prev_hash TEXT,  -- Previous hash in chain (NULL for genesis)
+    workspace_id TEXT  -- Origin workspace (provenance, not partition)
 );
 
 CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
@@ -90,6 +91,7 @@ CREATE INDEX IF NOT EXISTS idx_memories_deadline ON memories(deadline_at);
 CREATE INDEX IF NOT EXISTS idx_memories_verification ON memories(verification_status);
 CREATE INDEX IF NOT EXISTS idx_memories_lifecycle ON memories(lifecycle_tier);
 CREATE INDEX IF NOT EXISTS idx_memories_fact_id ON memories(fact_id);
+CREATE INDEX IF NOT EXISTS idx_memories_workspace ON memories(workspace_id);
 
 -- Junction table linking memories to entities
 CREATE TABLE IF NOT EXISTS memory_entities (
@@ -475,3 +477,6 @@ CREATE INDEX IF NOT EXISTS idx_agent_dispatches_started ON agent_dispatches(star
 
 INSERT OR IGNORE INTO schema_migrations (version, description)
 VALUES (20, 'Add lifecycle tiers, sacred memories, close-circle entities, fact_id, SHA-256 chain');
+
+INSERT OR IGNORE INTO schema_migrations (version, description)
+VALUES (21, 'Add workspace_id to memories for unified database provenance tracking');

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

@@ -44,6 +44,8 @@ class RecallResult:
     origin_type: str = "inferred"  # user_stated, extracted, inferred, corrected
     # Channel tracking
     source_channel: Optional[str] = None  # Origin channel: claude_code, telegram, slack
+    # Workspace provenance
+    workspace_id: Optional[str] = None  # Origin workspace (project hash)
     # Lifecycle fields
     lifecycle_tier: Optional[str] = None  # sacred/active/cooling/archived
     fact_id: Optional[str] = None  # UUID for human-friendly reference
@@ -370,6 +372,9 @@ class RecallService:
         # Channel tracking (may not exist in older DBs)
         source_channel_val = row["source_channel"] if "source_channel" in row_keys else None
 
+        # Workspace provenance (may not exist in older DBs)
+        workspace_id_val = row["workspace_id"] if "workspace_id" in row_keys else None
+
         # Lifecycle fields (may not exist in older DBs)
         lifecycle_tier_val = row["lifecycle_tier"] if "lifecycle_tier" in row_keys else None
         fact_id_val = row["fact_id"] if "fact_id" in row_keys else None
@@ -390,6 +395,7 @@ class RecallService:
             verification_status=verification_status_val,
             origin_type=origin_type_val,
             source_channel=source_channel_val,
+            workspace_id=workspace_id_val,
             lifecycle_tier=lifecycle_tier_val,
             fact_id=fact_id_val,
         )
@@ -858,6 +864,7 @@ class RecallService:
                     source=row["source"] if "source" in row_keys else None,
                     source_id=row["source_id"] if "source_id" in row_keys else None,
                     source_context=row["source_context"] if "source_context" in row_keys else None,
+                    workspace_id=row["workspace_id"] if "workspace_id" in row_keys else None,
                     lifecycle_tier=row["lifecycle_tier"] if "lifecycle_tier" in row_keys else None,
                     fact_id=row["fact_id"] if "fact_id" in row_keys else None,
                 )
@@ -1326,6 +1333,7 @@ class RecallService:
                     source=row["source"] if "source" in row_keys else None,
                     source_id=row["source_id"] if "source_id" in row_keys else None,
                     source_context=row["source_context"] if "source_context" in row_keys else None,
+                    workspace_id=row["workspace_id"] if "workspace_id" in row_keys else None,
                     lifecycle_tier=row["lifecycle_tier"] if "lifecycle_tier" in row_keys else None,
                     fact_id=row["fact_id"] if "fact_id" in row_keys else None,
                 )
@@ -2522,6 +2530,7 @@ class RecallService:
                 created_at=row["created_at"],
                 entities=entity_str.split(",") if entity_str else [],
                 metadata={"urgency": urgency, "deadline_at": deadline_str},
+                workspace_id=row["workspace_id"] if "workspace_id" in row_keys else None,
                 lifecycle_tier=row["lifecycle_tier"] if "lifecycle_tier" in row_keys else None,
                 fact_id=row["fact_id"] if "fact_id" in row_keys else None,
             ))
@@ -2791,6 +2800,7 @@ class RecallService:
             origin_type=row["origin_type"] if "origin_type" in row_keys else "inferred",
             confidence=row["confidence"] if "confidence" in row_keys else 1.0,
             source_channel=row["source_channel"] if "source_channel" in row_keys else None,
+            workspace_id=row["workspace_id"] if "workspace_id" in row_keys else None,
             lifecycle_tier=row["lifecycle_tier"] if "lifecycle_tier" in row_keys else None,
             fact_id=row["fact_id"] if "fact_id" in row_keys else None,
         )

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

@@ -251,6 +251,14 @@ class RememberService:
             insert_data["source_context"] = source_context
         if source_channel:
             insert_data["source_channel"] = source_channel
+        # Auto-tag workspace_id from config (provenance: which workspace created this memory)
+        try:
+            from ..config import get_config as _get_config
+            _ws_id = getattr(_get_config(), "workspace_id", None)
+            if _ws_id:
+                insert_data["workspace_id"] = _ws_id
+        except Exception:
+            pass
         if deadline_at:
             insert_data["deadline_at"] = deadline_at
         if temporal_markers_json:

package/package.json

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