superlocalmemory 2.8.0 → 2.8.2

package/mcp_server.py

@@ -560,6 +560,36 @@ def _maybe_passive_decay() -> None:
         pass
 
 
+# ============================================================================
+# Eager initialization — ensure schema migration runs at startup (v2.8)
+# ============================================================================
+
+def _eager_init():
+    """Initialize all engines at startup. Ensures schema migration runs."""
+    try:
+        get_store()  # Triggers MemoryStoreV2._init_db() which creates v2.8 columns
+    except Exception:
+        pass  # Don't block server startup
+    try:
+        from lifecycle.lifecycle_engine import LifecycleEngine
+        LifecycleEngine()  # Triggers _ensure_columns()
+    except Exception:
+        pass
+    try:
+        from behavioral.outcome_tracker import OutcomeTracker
+        OutcomeTracker(str(Path.home() / ".claude-memory" / "learning.db"))
+    except Exception:
+        pass
+    try:
+        from compliance.audit_db import AuditDB
+        AuditDB(str(Path.home() / ".claude-memory" / "audit.db"))
+    except Exception:
+        pass
+
+# Run once at module load
+_eager_init()
+
+
 # ============================================================================
 # MCP TOOLS (Functions callable by AI)
 # ============================================================================
@@ -579,13 +609,13 @@ async def remember(
     """
     Save content to SuperLocalMemory with intelligent indexing.
 
-    This calls the SAME backend as /superlocalmemoryv2:remember skill.
+    This calls the SAME backend as /superlocalmemoryv2-remember skill.
     All memories are stored in the same local SQLite database.
 
     Args:
         content: The content to remember (required)
         tags: Comma-separated tags (optional, e.g. "python,api,backend")
-        project: Project name (optional, groups related memories)
+        project: Project name to scope the memory
         importance: Importance score 1-10 (default 5)
 
     Returns:
@@ -1394,7 +1424,12 @@ try:
 
     @mcp.tool(annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False))
     async def compact_memories(dry_run: bool = True, profile: str = None) -> dict:
-        """Evaluate and compact stale memories through lifecycle transitions. dry_run=True by default."""
+        """Evaluate and compact stale memories through lifecycle transitions. dry_run=True by default.
+
+        Args:
+            dry_run: If True (default), show what would happen without changes.
+            profile: Profile name to filter.
+        """
         return await _compact_memories(dry_run, profile)
 
     @mcp.tool(annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False))
@@ -1649,7 +1684,7 @@ if __name__ == "__main__":
     print("  - list_recent(limit)", file=sys.stderr)
     print("  - get_status()", file=sys.stderr)
     print("  - build_graph()", file=sys.stderr)
-    print("  - switch_profile(name)", file=sys.stderr)
+    print("  - switch_profile(name)   [Project/Profile switch]", file=sys.stderr)
     print("  - backup_status()        [Auto-Backup]", file=sys.stderr)
     if LEARNING_AVAILABLE:
         print("  - memory_used(memory_id, query, usefulness)  [v2.7 Learning]", file=sys.stderr)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "Your AI Finally Remembers You - Local-first intelligent memory system for AI assistants. Works with Claude, Cursor, Windsurf, VS Code/Copilot, Codex, and 17+ AI tools. 100% local, zero cloud dependencies.",
   "keywords": [
     "ai-memory",
@@ -22,7 +22,9 @@
     "chatgpt",
     "chatgpt-connector",
     "openai",
-    "deep-research"
+    "deep-research",
+    "qualixar",
+    "agent-development-platform"
   ],
   "author": {
     "name": "Varun Pratap Bhardwaj",

package/skills/slm-list-recent/SKILL.md

@@ -336,7 +336,7 @@ date
 - `slm remember` - Save a new memory
 - `slm recall` - Search memories by relevance
 - `slm status` - Check memory count and stats
-- `slm switch-profile` - View different project's memories
+- `slm switch-profile` - View different profile's memories
 
 ---
 

package/skills/slm-remember/SKILL.md

@@ -157,7 +157,7 @@ slm remember "Commit: $commit_msg (${commit_hash:0:7})" \
 - **Cross-tool sync:** All AI tools access same database (Cursor, ChatGPT, Claude, etc.)
 - **Unlimited:** No memory limits, no quotas
 - **Privacy:** Your data stays on your computer
-- **Profiles:** Use `slm switch-profile` for project isolation
+- **Profiles:** Use `slm switch-profile` for profile isolation
 
 ## Related Commands
 

package/skills/slm-status/SKILL.md

@@ -155,7 +155,7 @@ Corrupted Entries:       0 found
 - **Last Used:** Last access timestamp
 
 **Profiles allow:**
-- Project isolation
+- Profile isolation
 - Context switching
 - Separate memory spaces
 

package/skills/slm-switch-profile/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: slm-switch-profile
-description: Switch between memory profiles for project isolation and context management. Use when the user wants to change project context, separate work/personal memories, or manage multiple independent memory spaces. Each profile has its own database, graph, and patterns.
+description: Switch between memory profiles for context isolation and management. Use when the user wants to change profile context, separate work/personal memories, or manage multiple independent memory spaces. Each profile has its own database, graph, and patterns.
 version: "2.1.0"
 license: MIT
 compatibility: "Requires SuperLocalMemory V2 installed at ~/.claude-memory/"
@@ -26,8 +26,8 @@ slm switch-profile <name> [--create]
 
 Each profile has its own:
 - ✅ **Separate database** - Zero context bleeding
-- ✅ **Independent knowledge graph** - Project-specific relationships
-- ✅ **Unique patterns** - Different coding preferences per project
+- ✅ **Independent knowledge graph** - Profile-specific relationships
+- ✅ **Unique patterns** - Different coding preferences per profile
 - ✅ **Isolated history** - No cross-contamination
 
 **Think of profiles as workspaces:**

package/src/graph/graph_core.py

@@ -80,7 +80,7 @@ class GraphEngine:
                 logger.error(f"Missing required tables: {missing}")
                 return {'success': False, 'error': 'database_not_initialized',
                         'message': f"Database not initialized. Missing tables: {', '.join(missing)}",
-                        'fix': "Run 'superlocalmemoryv2:status' first to initialize the database, or add some memories."}
+                        'fix': "Run 'superlocalmemoryv2-status' first to initialize the database, or add some memories."}
 
             active_profile = self._get_active_profile()
             logger.info(f"Building graph for profile: {active_profile}")
@@ -91,12 +91,12 @@ class GraphEngine:
             if len(memories) == 0:
                 return {'success': False, 'error': 'no_memories',
                         'message': 'No memories found in database.',
-                        'fix': "Add some memories first: superlocalmemoryv2:remember 'Your content here'"}
+                        'fix': "Add some memories first: superlocalmemoryv2-remember 'Your content here'"}
             if len(memories) < 2:
                 return {'success': False, 'error': 'insufficient_memories',
                         'message': 'Need at least 2 memories to build knowledge graph.',
                         'memories': len(memories),
-                        'fix': "Add more memories: superlocalmemoryv2:remember 'Your content here'"}
+                        'fix': "Add more memories: superlocalmemoryv2-remember 'Your content here'"}
 
             memories = apply_sampling(cursor, memories, active_profile)
             clear_profile_graph_data(cursor, conn, memories, active_profile)

package/src/hnsw_index.py

@@ -139,12 +139,18 @@ class HNSWIndex:
             with open(self.metadata_path, 'r') as f:
                 metadata = json.load(f)
 
-            # Validate metadata
+            # Validate metadata — auto-rebuild on dimension mismatch
             if metadata.get('dimension') != self.dimension:
-                logger.warning(
-                    f"Index dimension mismatch: {metadata.get('dimension')} != {self.dimension}. "
-                    "Will rebuild index."
+                logger.info(
+                    "Index dimension changed: %s -> %s. "
+                    "Deleting old index files and rebuilding.",
+                    metadata.get('dimension'), self.dimension,
                 )
+                try:
+                    self.index_path.unlink(missing_ok=True)
+                    self.metadata_path.unlink(missing_ok=True)
+                except OSError as del_err:
+                    logger.warning("Could not delete old index files: %s", del_err)
                 return
 
             # Load HNSW index

package/src/lifecycle/lifecycle_engine.py

@@ -38,6 +38,7 @@ class LifecycleEngine:
         self._db_path = str(db_path)
         self._config_path = config_path
         self._lock = threading.Lock()
+        self._ensure_columns()
 
     def _get_connection(self) -> sqlite3.Connection:
         """Get a SQLite connection to memory.db."""
@@ -45,6 +46,34 @@ class LifecycleEngine:
         conn.row_factory = sqlite3.Row
         return conn
 
+    def _ensure_columns(self) -> None:
+        """Ensure v2.8 lifecycle columns exist in memories table."""
+        try:
+            conn = self._get_connection()
+            try:
+                cursor = conn.cursor()
+                cursor.execute("PRAGMA table_info(memories)")
+                existing = {row[1] for row in cursor.fetchall()}
+                v28_cols = [
+                    ("lifecycle_state", "TEXT DEFAULT 'active'"),
+                    ("lifecycle_updated_at", "TIMESTAMP"),
+                    ("lifecycle_history", "TEXT DEFAULT '[]'"),
+                    ("access_level", "TEXT DEFAULT 'public'"),
+                ]
+                for col_name, col_type in v28_cols:
+                    if col_name not in existing:
+                        try:
+                            cursor.execute(
+                                f"ALTER TABLE memories ADD COLUMN {col_name} {col_type}"
+                            )
+                        except sqlite3.OperationalError:
+                            pass
+                conn.commit()
+            finally:
+                conn.close()
+        except Exception:
+            pass  # Graceful degradation — don't block engine init
+
     def is_valid_transition(self, from_state: str, to_state: str) -> bool:
         """Check if a state transition is valid per the state machine.
 
@@ -70,10 +99,22 @@ class LifecycleEngine:
         """
         conn = self._get_connection()
         try:
-            row = conn.execute(
-                "SELECT lifecycle_state FROM memories WHERE id = ?",
-                (memory_id,),
-            ).fetchone()
+            try:
+                row = conn.execute(
+                    "SELECT lifecycle_state FROM memories WHERE id = ?",
+                    (memory_id,),
+                ).fetchone()
+            except sqlite3.OperationalError as e:
+                if "no such column" in str(e):
+                    conn.close()
+                    self._ensure_columns()
+                    conn = self._get_connection()
+                    row = conn.execute(
+                        "SELECT lifecycle_state FROM memories WHERE id = ?",
+                        (memory_id,),
+                    ).fetchone()
+                else:
+                    raise
             if row is None:
                 return None
             return row["lifecycle_state"] or "active"
@@ -278,10 +319,22 @@ class LifecycleEngine:
         conn = self._get_connection()
         try:
             dist = {state: 0 for state in self.STATES}
-            rows = conn.execute(
-                "SELECT lifecycle_state, COUNT(*) as cnt "
-                "FROM memories GROUP BY lifecycle_state"
-            ).fetchall()
+            try:
+                rows = conn.execute(
+                    "SELECT lifecycle_state, COUNT(*) as cnt "
+                    "FROM memories GROUP BY lifecycle_state"
+                ).fetchall()
+            except sqlite3.OperationalError as e:
+                if "no such column" in str(e):
+                    conn.close()
+                    self._ensure_columns()
+                    conn = self._get_connection()
+                    rows = conn.execute(
+                        "SELECT lifecycle_state, COUNT(*) as cnt "
+                        "FROM memories GROUP BY lifecycle_state"
+                    ).fetchall()
+                else:
+                    raise
             for row in rows:
                 state = row["lifecycle_state"] if row["lifecycle_state"] else "active"
                 if state in dist:

package/src/lifecycle/lifecycle_evaluator.py

@@ -59,6 +59,15 @@ class LifecycleEvaluator:
         conn.row_factory = sqlite3.Row
         return conn
 
+    def _ensure_lifecycle_columns(self) -> None:
+        """Ensure v2.8 lifecycle columns exist via LifecycleEngine."""
+        try:
+            from lifecycle.lifecycle_engine import LifecycleEngine
+            engine = LifecycleEngine(db_path=self._db_path)
+            engine._ensure_columns()
+        except Exception:
+            pass  # Best effort — don't block evaluation
+
     def evaluate_memories(
         self,
         profile: Optional[str] = None,
@@ -87,7 +96,17 @@ class LifecycleEvaluator:
                 query += " AND profile = ?"
                 params.append(profile)
 
-            rows = conn.execute(query, params).fetchall()
+            try:
+                rows = conn.execute(query, params).fetchall()
+            except sqlite3.OperationalError as e:
+                if "no such column" in str(e):
+                    conn.close()
+                    self._ensure_lifecycle_columns()
+                    conn = self._get_connection()
+                    rows = conn.execute(query, params).fetchall()
+                else:
+                    raise
+
             recommendations = []
             now = datetime.now()
 
@@ -123,11 +142,24 @@ class LifecycleEvaluator:
         config = self._load_config()
         conn = self._get_connection()
         try:
-            row = conn.execute(
-                "SELECT id, lifecycle_state, importance, last_accessed, created_at "
-                "FROM memories WHERE id = ?",
-                (memory_id,),
-            ).fetchone()
+            try:
+                row = conn.execute(
+                    "SELECT id, lifecycle_state, importance, last_accessed, created_at "
+                    "FROM memories WHERE id = ?",
+                    (memory_id,),
+                ).fetchone()
+            except sqlite3.OperationalError as e:
+                if "no such column" in str(e):
+                    conn.close()
+                    self._ensure_lifecycle_columns()
+                    conn = self._get_connection()
+                    row = conn.execute(
+                        "SELECT id, lifecycle_state, importance, last_accessed, created_at "
+                        "FROM memories WHERE id = ?",
+                        (memory_id,),
+                    ).fetchone()
+                else:
+                    raise
             if row is None:
                 return None
             return self._evaluate_row(row, config, datetime.now())

package/src/mcp_tools_v28.py

@@ -46,7 +46,7 @@ async def report_outcome(
         action_type: Category (code_written, decision_made, debug_resolved, etc.).
         context: Optional JSON string with additional context metadata.
         agent_id: Identifier for the reporting agent.
-        project: Project name for scoping.
+        project: Project name for scoping outcomes.
 
     Returns:
         Dict with success status and outcome_id on success.
@@ -170,17 +170,18 @@ async def compact_memories(
 
     Args:
         dry_run: If True (default), show what would happen without changes.
-        profile: Optional profile filter.
+        profile: Optional profile filter to scope compaction.
 
     Returns:
         Dict with recommendations (dry_run=True) or transition counts (dry_run=False).
     """
+    active_profile = profile
     try:
         from lifecycle.lifecycle_evaluator import LifecycleEvaluator
         from lifecycle.lifecycle_engine import LifecycleEngine
 
         evaluator = LifecycleEvaluator(DEFAULT_MEMORY_DB)
-        recommendations = evaluator.evaluate_memories(profile=profile)
+        recommendations = evaluator.evaluate_memories(profile=active_profile)
 
         if dry_run:
             return {

package/src/memory-profiles.py

@@ -496,6 +496,7 @@ class ProfileManager:
         return True
 
 
+
 def main():
     parser = argparse.ArgumentParser(
         description='SuperLocalMemory V2 - Profile Management (Column-Based)',

package/src/memory_store_v2.py

@@ -1201,7 +1201,8 @@ class MemoryStoreV2:
         Removing or obscuring this attribution violates the license terms.
 
         Returns:
-            Dictionary with creator information and attribution requirements
+            Dictionary with creator information and attribution requirements,
+            including Qualixar platform provenance.
         """
         with self._read_connection() as conn:
             cursor = conn.cursor()
@@ -1218,6 +1219,10 @@ class MemoryStoreV2:
                 'attribution_required': 'yes'
             }
 
+        # Qualixar platform provenance (non-breaking additions)
+        attribution['platform'] = 'Qualixar'
+        attribution['verify_url'] = 'https://qualixar.com'
+
         return attribution
 
     def export_for_context(self, query: str, max_tokens: int = 4000) -> str:

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.1")
+        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/setup_validator.py

@@ -425,9 +425,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:")