superlocalmemory 2.3.7 → 2.4.0

package/src/memory-profiles.py

@@ -12,55 +12,219 @@ Attribution must be preserved in all copies or derivatives.
 """
 
 """
-SuperLocalMemory V2 - Profile Management System
+SuperLocalMemory V2 - Profile Management System (Column-Based)
 
-Allows users to maintain separate memory databases for different contexts/personalities:
+v2.4.0: Rewritten to use column-based profiles in a SINGLE database.
+All memories live in one memory.db with a 'profile' column.
+Switching profiles = updating config. No file copying. No data loss risk.
+
+Previous versions used separate database files per profile, which caused
+data loss when switching. This version is backward compatible and will
+auto-migrate old profile directories on first run.
+
+Allows users to maintain separate memory contexts:
 - Work profile: Professional coding memories
 - Personal profile: Personal projects and learning
 - Client-specific profiles: Different clients get isolated memories
 - Experimentation profile: Testing and experiments
-
-Each profile is completely isolated with its own:
-- Database (memory.db)
-- Graph data
-- Learned patterns
-- Compressed archives
 """
 
 import os
 import sys
 import json
-import shutil
+import sqlite3
+import hashlib
 from pathlib import Path
 from datetime import datetime
 import argparse
+import re
 
 MEMORY_DIR = Path.home() / ".claude-memory"
+DB_PATH = MEMORY_DIR / "memory.db"
 PROFILES_DIR = MEMORY_DIR / "profiles"
-CURRENT_PROFILE_FILE = MEMORY_DIR / ".current_profile"
 CONFIG_FILE = MEMORY_DIR / "profiles.json"
 
 
 class ProfileManager:
+    """
+    Column-based profile manager. All memories in ONE database.
+    Profile = a value in the 'profile' column of the memories table.
+    Switching = updating which profile name is active in config.
+    """
+
     def __init__(self):
         self.memory_dir = MEMORY_DIR
-        self.profiles_dir = PROFILES_DIR
-        self.current_profile_file = CURRENT_PROFILE_FILE
+        self.db_path = DB_PATH
         self.config_file = CONFIG_FILE
 
-        # Ensure profiles directory exists
-        self.profiles_dir.mkdir(exist_ok=True)
+        # Ensure memory directory exists
+        self.memory_dir.mkdir(exist_ok=True)
+
+        # Ensure profile column exists in DB
+        self._ensure_profile_column()
 
         # Load or create config
         self.config = self._load_config()
 
+        # Auto-migrate old profile directories if they exist
+        self._migrate_old_profiles()
+
+    def _ensure_profile_column(self):
+        """Add 'profile' column to memories table if it doesn't exist."""
+        if not self.db_path.exists():
+            return
+
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        cursor.execute("PRAGMA table_info(memories)")
+        columns = {row[1] for row in cursor.fetchall()}
+
+        if 'profile' not in columns:
+            cursor.execute("ALTER TABLE memories ADD COLUMN profile TEXT DEFAULT 'default'")
+            cursor.execute("UPDATE memories SET profile = 'default' WHERE profile IS NULL")
+            try:
+                cursor.execute("CREATE INDEX IF NOT EXISTS idx_profile ON memories(profile)")
+            except sqlite3.OperationalError:
+                pass
+            conn.commit()
+
+        conn.close()
+
+    def _migrate_old_profiles(self):
+        """
+        Backward compatibility: migrate old separate-DB profiles into the main DB.
+        Old profiles stored in ~/.claude-memory/profiles/<name>/memory.db
+        New profiles use a 'profile' column in the main memory.db
+        """
+        profiles_dir = MEMORY_DIR / "profiles"
+        if not profiles_dir.exists():
+            return
+
+        migrated_any = False
+        for profile_dir in profiles_dir.iterdir():
+            if not profile_dir.is_dir():
+                continue
+
+            profile_db = profile_dir / "memory.db"
+            if not profile_db.exists():
+                continue
+
+            profile_name = profile_dir.name
+            marker_file = profile_dir / ".migrated_to_column"
+
+            # Skip if already migrated
+            if marker_file.exists():
+                continue
+
+            # Import memories from old profile DB
+            try:
+                self._import_from_old_profile(profile_name, profile_db)
+                # Mark as migrated
+                marker_file.write_text(datetime.now().isoformat())
+                migrated_any = True
+            except Exception as e:
+                print(f"  Warning: Could not migrate profile '{profile_name}': {e}", file=sys.stderr)
+
+        if migrated_any:
+            print("  Profile migration complete (old separate DBs -> column-based)", file=sys.stderr)
+
+    def _import_from_old_profile(self, profile_name, old_db_path):
+        """Import memories from an old separate-DB profile into main DB."""
+        if not self.db_path.exists():
+            return
+
+        main_conn = sqlite3.connect(self.db_path)
+        main_cursor = main_conn.cursor()
+
+        old_conn = sqlite3.connect(old_db_path)
+        old_cursor = old_conn.cursor()
+
+        # Get existing hashes
+        main_cursor.execute("SELECT content_hash FROM memories WHERE content_hash IS NOT NULL")
+        existing_hashes = {row[0] for row in main_cursor.fetchall()}
+
+        # Get columns from old DB
+        old_cursor.execute("PRAGMA table_info(memories)")
+        old_columns = {row[1] for row in old_cursor.fetchall()}
+
+        # Build SELECT based on available columns
+        select_cols = ['content', 'summary', 'project_path', 'project_name', 'tags',
+                       'category', 'memory_type', 'importance', 'created_at', 'updated_at',
+                       'content_hash']
+        available_cols = [c for c in select_cols if c in old_columns]
+
+        if 'content' not in available_cols:
+            old_conn.close()
+            main_conn.close()
+            return
+
+        old_cursor.execute(f"SELECT {', '.join(available_cols)} FROM memories")
+        rows = old_cursor.fetchall()
+
+        imported = 0
+        for row in rows:
+            row_dict = dict(zip(available_cols, row))
+            content = row_dict.get('content', '')
+            content_hash = row_dict.get('content_hash')
+
+            if not content:
+                continue
+
+            # Generate hash if missing
+            if not content_hash:
+                content_hash = hashlib.sha256(content.encode()).hexdigest()[:32]
+
+            if content_hash in existing_hashes:
+                continue
+
+            try:
+                main_cursor.execute('''
+                    INSERT INTO memories (content, summary, project_path, project_name, tags,
+                                          category, memory_type, importance, created_at, updated_at,
+                                          content_hash, profile)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ''', (
+                    content,
+                    row_dict.get('summary'),
+                    row_dict.get('project_path'),
+                    row_dict.get('project_name'),
+                    row_dict.get('tags'),
+                    row_dict.get('category'),
+                    row_dict.get('memory_type', 'session'),
+                    row_dict.get('importance', 5),
+                    row_dict.get('created_at'),
+                    row_dict.get('updated_at'),
+                    content_hash,
+                    profile_name
+                ))
+                imported += 1
+                existing_hashes.add(content_hash)
+            except sqlite3.IntegrityError:
+                pass
+
+        main_conn.commit()
+        old_conn.close()
+        main_conn.close()
+
+        if imported > 0:
+            # Add profile to config if not present
+            config = self._load_config()
+            if profile_name not in config.get('profiles', {}):
+                config['profiles'][profile_name] = {
+                    'name': profile_name,
+                    'description': f'Memory profile: {profile_name} (migrated)',
+                    'created_at': datetime.now().isoformat(),
+                    'last_used': None
+                }
+                self._save_config(config)
+
     def _load_config(self):
         """Load profiles configuration."""
         if self.config_file.exists():
             with open(self.config_file, 'r') as f:
                 return json.load(f)
         else:
-            # Default config
             config = {
                 'profiles': {
                     'default': {
@@ -83,11 +247,8 @@ class ProfileManager:
         with open(self.config_file, 'w') as f:
             json.dump(config, f, indent=2)
 
-    def _get_profile_path(self, profile_name):
-        """Get directory path for a profile with security validation."""
-        import re
-
-        # SECURITY: Validate profile name to prevent path traversal
+    def _validate_profile_name(self, profile_name):
+        """Validate profile name for security."""
         if not profile_name:
             raise ValueError("Profile name cannot be empty")
 
@@ -97,327 +258,239 @@ class ProfileManager:
         if len(profile_name) > 50:
             raise ValueError("Profile name too long (max 50 characters)")
 
-        if profile_name in ['.', '..', 'default']:
+        if profile_name in ['.', '..']:
             raise ValueError(f"Reserved profile name: {profile_name}")
 
-        path = (self.profiles_dir / profile_name).resolve()
-
-        # SECURITY: Ensure path stays within profiles directory
-        if not str(path).startswith(str(self.profiles_dir.resolve())):
-            raise ValueError("Invalid profile path - path traversal detected")
+    def _get_memory_count(self, profile_name):
+        """Get memory count for a specific profile."""
+        if not self.db_path.exists():
+            return 0
 
-        return path
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute("SELECT COUNT(*) FROM memories WHERE profile = ?", (profile_name,))
+        count = cursor.fetchone()[0]
+        conn.close()
+        return count
 
-    def _get_main_files(self):
-        """Get list of main memory system files to copy."""
-        return [
-            'memory.db',
-            'config.json',
-            'vectors'
-        ]
+    def get_active_profile(self):
+        """Get the currently active profile name."""
+        return self.config.get('active_profile', 'default')
 
     def list_profiles(self):
-        """List all available profiles."""
-        print("\n" + "="*60)
+        """List all available profiles with memory counts."""
+        print("\n" + "=" * 60)
         print("AVAILABLE MEMORY PROFILES")
-        print("="*60)
+        print("=" * 60)
 
         active = self.config.get('active_profile', 'default')
 
-        if not self.config['profiles']:
+        if not self.config.get('profiles'):
             print("\n  No profiles found. Create one with: create <name>")
             return
 
-        print(f"\n{'Profile':20s} {'Description':35s} {'Status':10s}")
-        print("-" * 70)
+        print(f"\n{'Profile':20s} {'Description':30s} {'Memories':10s} {'Status':10s}")
+        print("-" * 75)
 
         for name, info in self.config['profiles'].items():
             status = "ACTIVE" if name == active else ""
-            desc = info.get('description', 'No description')[:35]
-            marker = "→ " if name == active else "  "
-            print(f"{marker}{name:18s} {desc:35s} {status:10s}")
+            desc = info.get('description', 'No description')[:30]
+            marker = "-> " if name == active else "   "
+            count = self._get_memory_count(name)
+            print(f"{marker}{name:17s} {desc:30s} {count:<10d} {status:10s}")
 
         print(f"\nTotal profiles: {len(self.config['profiles'])}")
         print(f"Active profile: {active}")
 
     def create_profile(self, name, description=None, from_current=False):
-        """Create a new profile."""
+        """
+        Create a new profile.
+        Column-based: just adds to config. If from_current, copies memories.
+        """
         print(f"\nCreating profile: {name}")
 
-        # Check if profile exists
+        self._validate_profile_name(name)
+
         if name in self.config['profiles']:
-            print(f"❌ Error: Profile '{name}' already exists")
+            print(f"Error: Profile '{name}' already exists")
             return False
 
-        # Create profile directory
-        profile_path = self._get_profile_path(name)
-        profile_path.mkdir(exist_ok=True)
-
         if from_current:
-            # Copy current memory system to new profile
-            print("  Copying current memory system...")
-
-            for file in self._get_main_files():
-                src = self.memory_dir / file
-                dst = profile_path / file
-
-                if src.exists():
-                    if src.is_dir():
-                        shutil.copytree(src, dst, dirs_exist_ok=True)
-                    else:
-                        shutil.copy2(src, dst)
-                    print(f"    ✓ Copied {file}")
+            # Copy current profile's memories to new profile
+            active = self.config.get('active_profile', 'default')
+            if self.db_path.exists():
+                conn = sqlite3.connect(self.db_path)
+                cursor = conn.cursor()
+                cursor.execute("""
+                    INSERT INTO memories (content, summary, project_path, project_name, tags,
+                                          category, parent_id, tree_path, depth, memory_type,
+                                          importance, created_at, updated_at, last_accessed,
+                                          access_count, content_hash, cluster_id, profile)
+                    SELECT content, summary, project_path, project_name, tags,
+                           category, parent_id, tree_path, depth, memory_type,
+                           importance, created_at, updated_at, last_accessed,
+                           access_count, NULL, cluster_id, ?
+                    FROM memories WHERE profile = ?
+                """, (name, active))
+                copied = cursor.rowcount
+                conn.commit()
+
+                # Generate new content hashes for copied memories
+                cursor.execute("SELECT id, content FROM memories WHERE profile = ? AND content_hash IS NULL", (name,))
+                for row in cursor.fetchall():
+                    new_hash = hashlib.sha256(row[1].encode()).hexdigest()[:32]
+                    try:
+                        cursor.execute("UPDATE memories SET content_hash = ? WHERE id = ?", (new_hash + f"_{name}", row[0]))
+                    except sqlite3.IntegrityError:
+                        pass
+                conn.commit()
+                conn.close()
+
+                print(f"  Copied {copied} memories from '{active}' profile")
+            else:
+                print("  No database found, creating empty profile")
         else:
-            # Initialize empty profile with V2 schema
-            print("  Initializing empty profile with V2 schema...")
-            self._initialize_empty_profile(profile_path)
+            print(f"  Empty profile created (memories will be saved here when active)")
 
         # Add to config
         self.config['profiles'][name] = {
             'name': name,
-            'description': description or f"Memory profile: {name}",
+            'description': description or f'Memory profile: {name}',
             'created_at': datetime.now().isoformat(),
             'last_used': None,
             'created_from': 'current' if from_current else 'empty'
         }
         self._save_config()
 
-        print(f"✅ Profile '{name}' created successfully")
+        print(f"Profile '{name}' created successfully")
         return True
 
-    def _initialize_empty_profile(self, profile_path):
-        """Initialize empty profile with V2 schema."""
-        # Import the migration script's initialization logic
-        import sqlite3
-
-        db_path = profile_path / "memory.db"
-        conn = sqlite3.connect(db_path)
-        cursor = conn.cursor()
-
-        # Create basic V2 schema (simplified version)
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS memories (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                content TEXT NOT NULL,
-                summary TEXT,
-                project_path TEXT,
-                project_name TEXT,
-                tags TEXT,
-                category TEXT,
-                memory_type TEXT DEFAULT 'session',
-                importance INTEGER DEFAULT 5,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                last_accessed TIMESTAMP,
-                access_count INTEGER DEFAULT 0,
-                content_hash TEXT UNIQUE,
-                parent_id INTEGER,
-                tree_path TEXT,
-                depth INTEGER DEFAULT 0,
-                cluster_id INTEGER,
-                tier INTEGER DEFAULT 1
-            )
-        ''')
-
-        # Add other essential tables
-        tables = [
-            'memory_tree', 'graph_nodes', 'graph_edges',
-            'graph_clusters', 'identity_patterns',
-            'pattern_examples', 'memory_archive'
-        ]
-
-        for table in tables:
-            cursor.execute(f'CREATE TABLE IF NOT EXISTS {table} (id INTEGER PRIMARY KEY)')
-
-        conn.commit()
-        conn.close()
-
-        # Create basic config
-        config = {
-            "version": "2.0.0",
-            "embedding_model": "local-tfidf",
-            "max_context_tokens": 4000
-        }
-
-        with open(profile_path / "config.json", 'w') as f:
-            json.dump(config, f, indent=2)
-
-        print("    ✓ Initialized V2 schema")
-
     def switch_profile(self, name):
-        """Switch to a different profile."""
+        """
+        Switch to a different profile.
+        Column-based: just updates the active_profile in config. Instant. No data risk.
+        """
         if name not in self.config['profiles']:
-            print(f"❌ Error: Profile '{name}' not found")
+            print(f"Error: Profile '{name}' not found")
             print(f"   Available: {', '.join(self.config['profiles'].keys())}")
             return False
 
-        current = self.config.get('active_profile')
+        current = self.config.get('active_profile', 'default')
 
         if current == name:
             print(f"Already using profile: {name}")
             return True
 
-        print(f"\nSwitching from '{current}' to '{name}'...")
-
-        # Save current profile (skip for 'default' — it uses main DB directly)
-        if current and current != 'default' and current in self.config['profiles']:
-            self._save_current_to_profile(current)
-
-        # Load new profile
-        self._load_profile_to_main(name)
-
-        # Update config
+        # Column-based switch: just update config
         self.config['active_profile'] = name
         self.config['profiles'][name]['last_used'] = datetime.now().isoformat()
         self._save_config()
 
-        print(f"✅ Switched to profile: {name}")
-        print(f"\n⚠️  IMPORTANT: Restart Claude CLI to use new profile!")
+        count = self._get_memory_count(name)
+        print(f"\nSwitched to profile: {name} ({count} memories)")
+        print(f"Previous profile: {current}")
         return True
 
-    def _save_current_to_profile(self, profile_name):
-        """Save current main memory system to profile."""
-        print(f"  Saving current state to profile '{profile_name}'...")
-
-        profile_path = self._get_profile_path(profile_name)
-        profile_path.mkdir(exist_ok=True)
-
-        for file in self._get_main_files():
-            src = self.memory_dir / file
-            dst = profile_path / file
-
-            if src.exists():
-                # Remove old version
-                if dst.exists():
-                    if dst.is_dir():
-                        shutil.rmtree(dst)
-                    else:
-                        dst.unlink()
-
-                # Copy current
-                if src.is_dir():
-                    shutil.copytree(src, dst)
-                else:
-                    shutil.copy2(src, dst)
-
-        print(f"    ✓ Saved to {profile_path}")
-
-    def _load_profile_to_main(self, profile_name):
-        """Load profile to main memory system."""
-        print(f"  Loading profile '{profile_name}'...")
-
-        profile_path = self._get_profile_path(profile_name)
-
-        if not profile_path.exists():
-            print(f"    ⚠️  Profile directory not found, will create on switch")
-            return
-
-        for file in self._get_main_files():
-            src = profile_path / file
-            dst = self.memory_dir / file
-
-            if src.exists():
-                # Remove old version
-                if dst.exists():
-                    if dst.is_dir():
-                        shutil.rmtree(dst)
-                    else:
-                        dst.unlink()
-
-                # Copy profile
-                if src.is_dir():
-                    shutil.copytree(src, dst)
-                else:
-                    shutil.copy2(src, dst)
-
-        print(f"    ✓ Loaded from {profile_path}")
-
     def delete_profile(self, name, force=False):
-        """Delete a profile."""
+        """Delete a profile. Moves memories to 'default' or deletes them."""
         if name not in self.config['profiles']:
-            print(f"❌ Error: Profile '{name}' not found")
+            print(f"Error: Profile '{name}' not found")
             return False
 
         if name == 'default':
-            print(f"❌ Error: Cannot delete 'default' profile")
+            print(f"Error: Cannot delete 'default' profile")
             return False
 
         if self.config.get('active_profile') == name:
-            print(f"❌ Error: Cannot delete active profile")
-            print(f"   Switch to another profile first")
+            print(f"Error: Cannot delete active profile")
+            print(f"   Switch to another profile first: slm profile switch default")
             return False
 
+        count = self._get_memory_count(name)
+
         if not force:
-            print(f"\n⚠️  WARNING: This will permanently delete profile '{name}'")
+            print(f"\nWARNING: This will delete profile '{name}' ({count} memories)")
+            print(f"Memories will be moved to 'default' profile before deletion.")
             response = input(f"Type profile name '{name}' to confirm: ")
 
             if response != name:
                 print("Cancelled.")
                 return False
 
-        # Delete profile directory
-        profile_path = self._get_profile_path(name)
-        if profile_path.exists():
-            shutil.rmtree(profile_path)
-            print(f"  ✓ Deleted profile directory")
+        # Move memories to default profile
+        if self.db_path.exists() and count > 0:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            cursor.execute("UPDATE memories SET profile = 'default' WHERE profile = ?", (name,))
+            moved = cursor.rowcount
+            conn.commit()
+            conn.close()
+            print(f"  Moved {moved} memories to 'default' profile")
 
         # Remove from config
         del self.config['profiles'][name]
         self._save_config()
 
-        print(f"✅ Profile '{name}' deleted")
+        print(f"Profile '{name}' deleted")
         return True
 
     def show_current(self):
-        """Show current active profile."""
+        """Show current active profile with stats."""
         active = self.config.get('active_profile', 'default')
 
         if active in self.config['profiles']:
             info = self.config['profiles'][active]
 
-            print("\n" + "="*60)
+            print("\n" + "=" * 60)
             print("CURRENT ACTIVE PROFILE")
-            print("="*60)
+            print("=" * 60)
             print(f"\nProfile: {active}")
             print(f"Description: {info.get('description', 'N/A')}")
             print(f"Created: {info.get('created_at', 'N/A')}")
             print(f"Last used: {info.get('last_used', 'N/A')}")
 
-            # Show stats if database exists
-            db_path = self.memory_dir / "memory.db"
-            if db_path.exists():
-                import sqlite3
-                conn = sqlite3.connect(db_path)
-                cursor = conn.cursor()
-
-                cursor.execute('SELECT COUNT(*) FROM memories')
-                memory_count = cursor.fetchone()[0]
+            count = self._get_memory_count(active)
+            print(f"\nMemories in this profile: {count}")
 
-                print(f"\nMemories: {memory_count}")
+            # Show total memories across all profiles
+            if self.db_path.exists():
+                conn = sqlite3.connect(self.db_path)
+                cursor = conn.cursor()
+                cursor.execute("SELECT COUNT(*) FROM memories")
+                total = cursor.fetchone()[0]
                 conn.close()
+                print(f"Total memories (all profiles): {total}")
         else:
-            print(f"⚠️  Current profile '{active}' not found in config")
+            print(f"Warning: Current profile '{active}' not found in config")
+            print("Resetting to 'default' profile...")
+            self.config['active_profile'] = 'default'
+            self._save_config()
 
     def rename_profile(self, old_name, new_name):
-        """Rename a profile."""
+        """Rename a profile. Updates the column value in all memories."""
         if old_name not in self.config['profiles']:
-            print(f"❌ Error: Profile '{old_name}' not found")
+            print(f"Error: Profile '{old_name}' not found")
             return False
 
         if new_name in self.config['profiles']:
-            print(f"❌ Error: Profile '{new_name}' already exists")
+            print(f"Error: Profile '{new_name}' already exists")
             return False
 
         if old_name == 'default':
-            print(f"❌ Error: Cannot rename 'default' profile")
+            print(f"Error: Cannot rename 'default' profile")
             return False
 
-        # Rename directory
-        old_path = self._get_profile_path(old_name)
-        new_path = self._get_profile_path(new_name)
+        self._validate_profile_name(new_name)
 
-        if old_path.exists():
-            old_path.rename(new_path)
+        # Update profile column in all memories
+        if self.db_path.exists():
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            cursor.execute("UPDATE memories SET profile = ? WHERE profile = ?", (new_name, old_name))
+            updated = cursor.rowcount
+            conn.commit()
+            conn.close()
+            print(f"  Updated {updated} memories")
 
         # Update config
         self.config['profiles'][new_name] = self.config['profiles'][old_name]
@@ -429,13 +502,13 @@ class ProfileManager:
 
         self._save_config()
 
-        print(f"✅ Profile renamed: '{old_name}' → '{new_name}'")
+        print(f"Profile renamed: '{old_name}' -> '{new_name}'")
         return True
 
 
 def main():
     parser = argparse.ArgumentParser(
-        description='SuperLocalMemory V2 - Profile Management',
+        description='SuperLocalMemory V2 - Profile Management (Column-Based)',
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog='''
 Examples:
@@ -451,14 +524,19 @@ Examples:
   # Create profile from current memories
   python memory-profiles.py create personal --from-current
 
-  # Switch to different profile
+  # Switch to different profile (instant, no restart needed)
   python memory-profiles.py switch work
 
-  # Delete a profile
+  # Delete a profile (memories moved to default)
   python memory-profiles.py delete old-profile
 
   # Rename profile
   python memory-profiles.py rename old-name new-name
+
+Architecture (v2.4.0):
+  All profiles share ONE database (memory.db).
+  Each memory has a 'profile' column.
+  Switching profiles = changing config. Instant. Safe.
         '''
     )
 
@@ -469,7 +547,7 @@ Examples:
     parser.add_argument('name2', nargs='?', help='Second name (for rename)')
     parser.add_argument('--description', help='Profile description')
     parser.add_argument('--from-current', action='store_true',
-                       help='Create from current memory system')
+                       help='Create from current profile memories')
     parser.add_argument('--force', action='store_true',
                        help='Force operation without confirmation')
 
@@ -485,7 +563,7 @@ Examples:
 
     elif args.command == 'create':
         if not args.name:
-            print("❌ Error: Profile name required")
+            print("Error: Profile name required")
             print("   Usage: python memory-profiles.py create <name>")
             sys.exit(1)
 
@@ -493,21 +571,21 @@ Examples:
 
     elif args.command == 'switch':
         if not args.name:
-            print("❌ Error: Profile name required")
+            print("Error: Profile name required")
             sys.exit(1)
 
         manager.switch_profile(args.name)
 
     elif args.command == 'delete':
         if not args.name:
-            print("❌ Error: Profile name required")
+            print("Error: Profile name required")
             sys.exit(1)
 
         manager.delete_profile(args.name, args.force)
 
     elif args.command == 'rename':
         if not args.name or not args.name2:
-            print("❌ Error: Both old and new names required")
+            print("Error: Both old and new names required")
             print("   Usage: python memory-profiles.py rename <old> <new>")
             sys.exit(1)