superlocalmemory 2.8.1 → 2.8.3

package/src/qualixar_attribution.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+# Part of Qualixar — Advancing Agent Development Through Research
+"""
+Qualixar Attribution — Cryptographic output signing for provenance tracking.
+
+Signs tool outputs with SHA-256 content hashes and verifiable provenance
+metadata. Part of the 3-layer Qualixar attribution system:
+  Layer 1: Visible attribution (ATTRIBUTION.md, get_attribution())
+  Layer 2: Cryptographic signing (this module)
+  Layer 3: Steganographic watermarking (qualixar_watermark.py)
+"""
+
+import hashlib
+import json
+import time
+from typing import Any, Dict
+
+
+# Registry of all Qualixar research initiative tools
+TOOL_REGISTRY: Dict[str, str] = {
+    "agentassert": "AgentAssert — Behavioral Contracts",
+    "agentassay": "AgentAssay — Stochastic Testing",
+    "skillfortify": "SkillFortify — Security Validation",
+    "superlocalmemory": "SuperLocalMemory — Agent Memory",
+    "telephonebench": "TelephoneBench — Communication Benchmarks",
+    "vibecheck": "VibeCheck — Code Reliability",
+    "agentreplay": "AgentReplay — Time-Travel Debugging",
+    "agentchaos": "AgentChaos — Chaos Engineering",
+    "agentmigrate": "AgentMigrate — Migration Engineering",
+    "agentpact": "AgentPact — Composition Testing",
+}
+
+
+class QualixarSigner:
+    """Signs tool outputs with cryptographic provenance metadata.
+
+    Adds a ``_qualixar`` block to output dictionaries containing a SHA-256
+    content hash, timestamp, tool information, and a verifiable signature.
+
+    Args:
+        tool_name: Identifier for the tool (e.g. ``"superlocalmemory"``).
+        version: Semantic version string of the tool.
+
+    Example::
+
+        signer = QualixarSigner("superlocalmemory", "2.8.3")
+        signed = signer.sign({"memories": [...]})
+        assert QualixarSigner.verify(signed) is True
+    """
+
+    def __init__(self, tool_name: str, version: str) -> None:
+        self.tool_name = tool_name
+        self.version = version
+        self.tool_desc = TOOL_REGISTRY.get(tool_name, tool_name)
+
+    def sign(self, output_data: Any) -> Dict[str, Any]:
+        """Add cryptographic provenance to any output.
+
+        Args:
+            output_data: The data to sign. If a dict, provenance is added
+                in-place. Otherwise wrapped in ``{"data": ...}``.
+
+        Returns:
+            Dictionary with the original data plus a ``_qualixar`` provenance
+            block containing content_hash, timestamp, and signature.
+        """
+        timestamp = time.time()
+        canonical = json.dumps(output_data, sort_keys=True, default=str)
+        content_hash = hashlib.sha256(canonical.encode()).hexdigest()
+
+        provenance = {
+            "_qualixar": {
+                "tool": self.tool_name,
+                "tool_description": self.tool_desc,
+                "version": self.version,
+                "platform": "Qualixar",
+                "timestamp": timestamp,
+                "content_hash": content_hash,
+                "license": "MIT",
+                "attribution": (
+                    f"Generated by {self.tool_desc} v{self.version}"
+                ),
+                "signature": self._compute_signature(
+                    content_hash, timestamp
+                ),
+            }
+        }
+
+        if isinstance(output_data, dict):
+            output_data.update(provenance)
+            return output_data
+        return {"data": output_data, **provenance}
+
+    def _compute_signature(
+        self, content_hash: str, timestamp: float
+    ) -> str:
+        """Compute HMAC-style signature over content hash and timestamp.
+
+        In production, this should use Ed25519 with a private key.
+        The current implementation uses SHA-256 over a canonical string
+        as a lightweight integrity check.
+
+        Args:
+            content_hash: SHA-256 hex digest of the canonical content.
+            timestamp: Unix timestamp of signing.
+
+        Returns:
+            Hex-encoded SHA-256 signature string.
+        """
+        sig_input = (
+            f"{self.tool_name}:{self.version}:"
+            f"{content_hash}:{timestamp}"
+        )
+        return hashlib.sha256(sig_input.encode()).hexdigest()
+
+    @staticmethod
+    def verify(output_data: Dict[str, Any]) -> bool:
+        """Verify an output's provenance signature.
+
+        Re-computes the content hash from the non-provenance fields and
+        compares it against the hash stored in the ``_qualixar`` block.
+
+        Args:
+            output_data: A dictionary previously signed with :meth:`sign`.
+
+        Returns:
+            ``True`` if the content hash matches, ``False`` otherwise.
+        """
+        prov = output_data.get("_qualixar", {})
+        if not prov:
+            return False
+        content = {
+            k: v for k, v in output_data.items() if k != "_qualixar"
+        }
+        canonical = json.dumps(content, sort_keys=True, default=str)
+        expected_hash = hashlib.sha256(canonical.encode()).hexdigest()
+        return prov.get("content_hash") == expected_hash

package/src/qualixar_watermark.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+# Part of Qualixar — Advancing Agent Development Through Research
+"""
+Qualixar Watermark — Steganographic attribution for text outputs.
+
+Embeds invisible zero-width Unicode characters in text to encode a tool
+identifier. The watermark is invisible to human readers but can be
+extracted programmatically to verify provenance.
+
+Part of the 3-layer Qualixar attribution system:
+  Layer 1: Visible attribution (ATTRIBUTION.md, get_attribution())
+  Layer 2: Cryptographic signing (qualixar_attribution.py)
+  Layer 3: Steganographic watermarking (this module)
+
+No external dependencies required.
+"""
+
+# Zero-width characters for binary encoding
+ZW_SPACE = '\u200b'    # Zero-width space  = bit 0
+ZW_JOINER = '\u200d'   # Zero-width joiner = bit 1
+ZW_SEP = '\ufeff'      # Byte order mark   = separator
+
+
+def encode_watermark(text: str, tool_id: str) -> str:
+    """Embed an invisible watermark in text output.
+
+    Converts ``tool_id`` to binary and encodes each bit as a zero-width
+    Unicode character. The watermark is inserted after the first paragraph
+    break (``\\n\\n``) so it remains invisible to human readers.
+
+    Args:
+        text: The text to watermark.
+        tool_id: Short identifier to embed (e.g. ``"slm"``).
+
+    Returns:
+        The original text with the invisible watermark inserted.
+    """
+    binary = ''.join(format(ord(c), '08b') for c in tool_id)
+    watermark = ZW_SEP
+    for bit in binary:
+        watermark += ZW_SPACE if bit == '0' else ZW_JOINER
+    watermark += ZW_SEP
+
+    # Insert after first paragraph break (invisible to users)
+    if '\n\n' in text:
+        idx = text.index('\n\n') + 2
+        return text[:idx] + watermark + text[idx:]
+    return text + watermark
+
+
+def decode_watermark(text: str) -> str:
+    """Extract a hidden watermark from text.
+
+    Locates the zero-width separator characters and decodes the binary
+    payload between them back into the original tool identifier string.
+
+    Args:
+        text: Text that may contain a watermark.
+
+    Returns:
+        The decoded tool identifier, or an empty string if no watermark
+        is found.
+    """
+    start = text.find(ZW_SEP)
+    if start == -1:
+        return ""
+    end = text.find(ZW_SEP, start + 1)
+    if end == -1:
+        return ""
+    encoded = text[start + 1:end]
+    binary = ''.join(
+        '0' if c == ZW_SPACE else '1'
+        for c in encoded
+    )
+    chars = [binary[i:i + 8] for i in range(0, len(binary), 8)]
+    return ''.join(chr(int(b, 2)) for b in chars if len(b) == 8)

package/src/search/engine.py

@@ -172,20 +172,22 @@ class HybridSearchEngine(IndexLoaderMixin, SearchMethodsMixin, FusionMixin):
         id_to_score = {mem_id: score for mem_id, score in raw_results}
 
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        # Fetch memories
-        placeholders = ','.join(['?'] * len(memory_ids))
-        cursor.execute(f'''
-            SELECT id, content, summary, project_path, project_name, tags,
-                   category, parent_id, tree_path, depth, memory_type,
-                   importance, created_at, cluster_id, last_accessed, access_count
-            FROM memories
-            WHERE id IN ({placeholders})
-        ''', memory_ids)
-
-        rows = cursor.fetchall()
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            # Fetch memories
+            placeholders = ','.join(['?'] * len(memory_ids))
+            cursor.execute(f'''
+                SELECT id, content, summary, project_path, project_name, tags,
+                       category, parent_id, tree_path, depth, memory_type,
+                       importance, created_at, cluster_id, last_accessed, access_count
+                FROM memories
+                WHERE id IN ({placeholders})
+            ''', memory_ids)
+
+            rows = cursor.fetchall()
+        finally:
+            conn.close()
 
         # Build result dictionaries
         results = []

package/src/search/index_loader.py

@@ -31,17 +31,19 @@ class IndexLoaderMixin:
         Load documents from database and build search indexes.
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        # Fetch all memories
-        cursor.execute('''
-            SELECT id, content, summary, tags
-            FROM memories
-            ORDER BY id
-        ''')
-
-        rows = cursor.fetchall()
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            # Fetch all memories
+            cursor.execute('''
+                SELECT id, content, summary, tags
+                FROM memories
+                ORDER BY id
+            ''')
+
+            rows = cursor.fetchall()
+        finally:
+            conn.close()
 
         if not rows:
             return

package/src/setup_validator.py

@@ -144,7 +144,7 @@ def check_database() -> Tuple[bool, str, List[str]]:
         try:
             cursor.execute("SELECT COUNT(*) FROM memories")
             memory_count = cursor.fetchone()[0]
-        except:
+        except Exception:
             memory_count = 0
 
         conn.close()
@@ -192,163 +192,165 @@ def initialize_database() -> Tuple[bool, str]:
         MEMORY_DIR.mkdir(parents=True, exist_ok=True)
 
         conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-
-        # Create memories table (core)
-        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 DEFAULT '[]',
-                category TEXT,
-                parent_id INTEGER,
-                tree_path TEXT DEFAULT '/',
-                depth INTEGER DEFAULT 0,
-                memory_type TEXT DEFAULT 'session',
-                importance INTEGER DEFAULT 5,
-                content_hash TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                last_accessed TIMESTAMP,
-                access_count INTEGER DEFAULT 0,
-                compressed_at TIMESTAMP,
-                tier INTEGER DEFAULT 1,
-                cluster_id INTEGER,
-                FOREIGN KEY (parent_id) REFERENCES memories(id)
-            )
-        ''')
-
-        # Create graph tables
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS graph_nodes (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                memory_id INTEGER UNIQUE NOT NULL,
-                entities TEXT DEFAULT '[]',
-                embedding_vector BLOB,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (memory_id) REFERENCES memories(id)
-            )
-        ''')
-
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS graph_edges (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                source_memory_id INTEGER NOT NULL,
-                target_memory_id INTEGER NOT NULL,
-                similarity REAL NOT NULL,
-                relationship_type TEXT,
-                shared_entities TEXT DEFAULT '[]',
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (source_memory_id) REFERENCES memories(id),
-                FOREIGN KEY (target_memory_id) REFERENCES memories(id),
-                UNIQUE(source_memory_id, target_memory_id)
-            )
-        ''')
-
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS graph_clusters (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                cluster_name TEXT,
-                name TEXT,
-                description TEXT,
-                summary TEXT,
-                memory_count INTEGER DEFAULT 0,
-                member_count INTEGER DEFAULT 0,
-                avg_importance REAL DEFAULT 5.0,
-                top_entities TEXT DEFAULT '[]',
-                parent_cluster_id INTEGER,
-                depth INTEGER DEFAULT 0,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (parent_cluster_id) REFERENCES graph_clusters(id) ON DELETE SET NULL
-            )
-        ''')
-
-        # Create pattern learning tables
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS identity_patterns (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                pattern_type TEXT NOT NULL,
-                pattern_key TEXT NOT NULL,
-                pattern_value TEXT,
-                confidence REAL DEFAULT 0.0,
-                frequency INTEGER DEFAULT 1,
-                last_seen TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                UNIQUE(pattern_type, pattern_key)
-            )
-        ''')
-
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS pattern_examples (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                pattern_id INTEGER NOT NULL,
-                memory_id INTEGER NOT NULL,
-                context TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (pattern_id) REFERENCES identity_patterns(id),
-                FOREIGN KEY (memory_id) REFERENCES memories(id)
-            )
-        ''')
-
-        # Create tree table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS memory_tree (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                node_type TEXT NOT NULL,
-                name TEXT NOT NULL,
-                parent_id INTEGER,
-                tree_path TEXT DEFAULT '/',
-                depth INTEGER DEFAULT 0,
-                memory_count INTEGER DEFAULT 0,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (parent_id) REFERENCES memory_tree(id)
-            )
-        ''')
-
-        # Create archive table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS memory_archive (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                original_memory_id INTEGER,
-                compressed_content TEXT NOT NULL,
-                compression_type TEXT DEFAULT 'tier2',
-                original_size INTEGER,
-                compressed_size INTEGER,
-                archived_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )
-        ''')
-
-        # Create system metadata table for watermarking
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS system_metadata (
-                key TEXT PRIMARY KEY,
-                value TEXT NOT NULL
-            )
-        ''')
-
-        # Add system watermark
-        cursor.execute('''
-            INSERT OR REPLACE INTO system_metadata (key, value) VALUES
-            ('product', 'SuperLocalMemory'),
-            ('website', 'https://superlocalmemory.com'),
-            ('repository', 'https://github.com/varun369/SuperLocalMemoryV2'),
-            ('license', 'MIT'),
-            ('schema_version', '2.0.0')
-        ''')
-
-        # Create indexes for performance
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_name)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_memories_cluster ON memories(cluster_id)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_memories_hash ON memories(content_hash)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_graph_edges_source ON graph_edges(source_memory_id)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_graph_edges_target ON graph_edges(target_memory_id)')
-
-        conn.commit()
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            # Create memories table (core)
+            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 DEFAULT '[]',
+                    category TEXT,
+                    parent_id INTEGER,
+                    tree_path TEXT DEFAULT '/',
+                    depth INTEGER DEFAULT 0,
+                    memory_type TEXT DEFAULT 'session',
+                    importance INTEGER DEFAULT 5,
+                    content_hash TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    last_accessed TIMESTAMP,
+                    access_count INTEGER DEFAULT 0,
+                    compressed_at TIMESTAMP,
+                    tier INTEGER DEFAULT 1,
+                    cluster_id INTEGER,
+                    FOREIGN KEY (parent_id) REFERENCES memories(id)
+                )
+            ''')
+
+            # Create graph tables
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS graph_nodes (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    memory_id INTEGER UNIQUE NOT NULL,
+                    entities TEXT DEFAULT '[]',
+                    embedding_vector BLOB,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (memory_id) REFERENCES memories(id)
+                )
+            ''')
+
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS graph_edges (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    source_memory_id INTEGER NOT NULL,
+                    target_memory_id INTEGER NOT NULL,
+                    similarity REAL NOT NULL,
+                    relationship_type TEXT,
+                    shared_entities TEXT DEFAULT '[]',
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (source_memory_id) REFERENCES memories(id),
+                    FOREIGN KEY (target_memory_id) REFERENCES memories(id),
+                    UNIQUE(source_memory_id, target_memory_id)
+                )
+            ''')
+
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS graph_clusters (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    cluster_name TEXT,
+                    name TEXT,
+                    description TEXT,
+                    summary TEXT,
+                    memory_count INTEGER DEFAULT 0,
+                    member_count INTEGER DEFAULT 0,
+                    avg_importance REAL DEFAULT 5.0,
+                    top_entities TEXT DEFAULT '[]',
+                    parent_cluster_id INTEGER,
+                    depth INTEGER DEFAULT 0,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (parent_cluster_id) REFERENCES graph_clusters(id) ON DELETE SET NULL
+                )
+            ''')
+
+            # Create pattern learning tables
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS identity_patterns (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    pattern_type TEXT NOT NULL,
+                    pattern_key TEXT NOT NULL,
+                    pattern_value TEXT,
+                    confidence REAL DEFAULT 0.0,
+                    frequency INTEGER DEFAULT 1,
+                    last_seen TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    UNIQUE(pattern_type, pattern_key)
+                )
+            ''')
+
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS pattern_examples (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    pattern_id INTEGER NOT NULL,
+                    memory_id INTEGER NOT NULL,
+                    context TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (pattern_id) REFERENCES identity_patterns(id),
+                    FOREIGN KEY (memory_id) REFERENCES memories(id)
+                )
+            ''')
+
+            # Create tree table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS memory_tree (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    node_type TEXT NOT NULL,
+                    name TEXT NOT NULL,
+                    parent_id INTEGER,
+                    tree_path TEXT DEFAULT '/',
+                    depth INTEGER DEFAULT 0,
+                    memory_count INTEGER DEFAULT 0,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (parent_id) REFERENCES memory_tree(id)
+                )
+            ''')
+
+            # Create archive table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS memory_archive (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    original_memory_id INTEGER,
+                    compressed_content TEXT NOT NULL,
+                    compression_type TEXT DEFAULT 'tier2',
+                    original_size INTEGER,
+                    compressed_size INTEGER,
+                    archived_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            ''')
+
+            # Create system metadata table for watermarking
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS system_metadata (
+                    key TEXT PRIMARY KEY,
+                    value TEXT NOT NULL
+                )
+            ''')
+
+            # Add system watermark
+            cursor.execute('''
+                INSERT OR REPLACE INTO system_metadata (key, value) VALUES
+                ('product', 'SuperLocalMemory'),
+                ('website', 'https://superlocalmemory.com'),
+                ('repository', 'https://github.com/varun369/SuperLocalMemoryV2'),
+                ('license', 'MIT'),
+                ('schema_version', '2.0.0')
+            ''')
+
+            # Create indexes for performance
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_name)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_memories_cluster ON memories(cluster_id)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_memories_hash ON memories(content_hash)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_graph_edges_source ON graph_edges(source_memory_id)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_graph_edges_target ON graph_edges(target_memory_id)')
+
+            conn.commit()
+        finally:
+            conn.close()
 
         return True, "Database initialized successfully"
 
@@ -425,9 +427,9 @@ def validate_setup(auto_fix: bool = False) -> bool:
         print("\n✓ All required checks passed!")
         print("\nQuick Start Commands:")
         print("  1. Add a memory:")
-        print("     superlocalmemoryv2:remember 'Your content here'")
+        print("     superlocalmemoryv2-remember 'Your content here'")
         print("\n  2. Search memories:")
-        print("     superlocalmemoryv2:recall 'search query'")
+        print("     superlocalmemoryv2-recall 'search query'")
         print("\n  3. Build knowledge graph (after adding 2+ memories):")
         print("     python ~/.claude-memory/graph_engine.py build")
         print("\n  4. Start UI server:")