superlocalmemory 3.4.5 → 3.4.8

package/src/superlocalmemory/math/langevin.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Riemannian Langevin dynamics with persistence for memory lifecycle.

package/src/superlocalmemory/math/polar_quant.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3
 
 """PolarQuant embedding quantization.

package/src/superlocalmemory/math/qjl.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3
 
 """QJL (Quantized Johnson-Lindenstrauss) 1-bit residual correction.

package/src/superlocalmemory/math/sheaf.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Sheaf cohomology for contradiction detection at ENCODING time.

package/src/superlocalmemory/math/turbo_quant.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3
 
 """TurboQuant embedding quantization (ICLR 2026).

package/src/superlocalmemory/mcp/resources.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SuperLocalMemory V3 — MCP Resources (6 resources).

package/src/superlocalmemory/mcp/server.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SuperLocalMemory V3 — MCP Server.
@@ -76,6 +76,9 @@ _ESSENTIAL_TOOLS: set[str] = {
     # Infinite memory + learning (4)
     "consolidate_cognitive", "get_soft_prompts",
     "set_mode", "report_outcome",
+    # v3.4.7: Two-way learning (4)
+    "log_tool_event", "get_assertions",
+    "reinforce_assertion", "contradict_assertion",
 }
 
 # v3.4.4: Mesh tools — enabled if mesh_enabled in config or SLM_MCP_MESH_TOOLS=1
@@ -134,6 +137,7 @@ from superlocalmemory.mcp.tools_v33 import register_v33_tools
 from superlocalmemory.mcp.resources import register_resources
 from superlocalmemory.mcp.tools_code_graph import register_code_graph_tools
 from superlocalmemory.mcp.tools_mesh import register_mesh_tools
+from superlocalmemory.mcp.tools_learning import register_learning_tools
 
 register_core_tools(_target, get_engine)
 register_v28_tools(_target, get_engine)
@@ -143,6 +147,7 @@ register_v33_tools(_target, get_engine)
 register_resources(server, get_engine)  # Resources always registered (not tools)
 register_code_graph_tools(_target, get_engine)  # CodeGraph: filtered like other tools (SLM_MCP_ALL_TOOLS=1 to show all)
 register_mesh_tools(_target, get_engine)  # v3.4.4: Mesh P2P tools — ships with SLM, no separate slm-mesh needed
+register_learning_tools(_target, get_engine)  # v3.4.7: Two-way learning tools
 
 
 # V3.3.21: Eager engine warmup — start initializing BEFORE first tool call.
@@ -152,7 +157,7 @@ register_mesh_tools(_target, get_engine)  # v3.4.4: Mesh P2P tools — ships wit
 # the first tool call arrives (1-2s later), the engine is already warm.
 # This applies to ALL IDEs: Claude Code, Cursor, Antigravity, Gemini CLI, etc.
 def _eager_warmup() -> None:
-    """Pre-warm engine + ensure daemon is running (background thread)."""
+    """Pre-warm engine + ensure daemon is running + auto-register mesh (background thread)."""
     import logging
     _logger = logging.getLogger(__name__)
     try:
@@ -170,6 +175,16 @@ def _eager_warmup() -> None:
     except Exception as exc:
         _logger.debug("Daemon auto-start failed (non-fatal): %s", exc)
 
+    # V3.4.6: Auto-register this MCP session as a mesh peer immediately.
+    # Previously, registration was lazy (only on first mesh tool call).
+    # Now every Claude session appears on the mesh from startup.
+    try:
+        from superlocalmemory.mcp.tools_mesh import auto_register_mesh
+        auto_register_mesh()
+        _logger.info("Mesh peer auto-registered at startup")
+    except Exception as exc:
+        _logger.debug("Mesh auto-register failed (non-fatal): %s", exc)
+
 import threading
 _warmup_thread = threading.Thread(target=_eager_warmup, daemon=True, name="mcp-warmup")
 _warmup_thread.start()

package/src/superlocalmemory/mcp/shared.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3
 
 """Shared MCP utilities — single source of truth for helpers used

package/src/superlocalmemory/mcp/tools.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """Backward compatibility — tools are now split across sub-modules.

package/src/superlocalmemory/mcp/tools_active.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SuperLocalMemory V3.1 — Active Memory MCP Tools.

package/src/superlocalmemory/mcp/tools_code_graph.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory v3.4 — CodeGraph MCP Tools
 
 """22 MCP tools for CodeGraph: 17 graph + 5 bridge.

package/src/superlocalmemory/mcp/tools_core.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SuperLocalMemory V3 — Core MCP Tools (13 tools).

package/src/superlocalmemory/mcp/tools_learning.py

@@ -0,0 +1,221 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""SLM v3.4.7 "The Learning Brain" — Learning MCP Tools.
+
+Two-way learning tools:
+  - log_tool_event: Passive tool usage telemetry
+  - get_assertions: Retrieve behavioral assertions
+  - reinforce_assertion: Explicitly reinforce a learned pattern
+  - contradict_assertion: Mark a learned pattern as wrong
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import uuid
+from datetime import datetime, timezone
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+_MAX_SUMMARY_LEN = 500  # Truncate input/output summaries
+
+
+def register_learning_tools(server, get_engine: Callable) -> None:
+    """Register learning MCP tools for two-way intelligence."""
+
+    @server.tool()
+    async def log_tool_event(
+        tool_name: str,
+        event_type: str = "invoke",
+        input_summary: str = "",
+        output_summary: str = "",
+        duration_ms: int = 0,
+        metadata: str = "{}",
+    ) -> dict:
+        """Log a tool usage event for behavioral learning.
+
+        Passive telemetry — low overhead, no LLM calls.
+        Events feed into the behavioral assertion mining pipeline
+        during consolidation. Accessible via MCP, CLI, and hooks.
+
+        Args:
+            tool_name: Name of the tool (e.g. "Read", "Edit", "Bash")
+            event_type: One of 'invoke', 'complete', 'error', 'correction'
+            input_summary: Truncated input (max 500 chars, auto-scrubbed)
+            output_summary: Truncated output (max 500 chars, auto-scrubbed)
+            duration_ms: Execution time in milliseconds
+            metadata: JSON string with additional context
+        """
+        engine = get_engine()
+        now = datetime.now(timezone.utc).isoformat()
+        session_id = os.environ.get("CLAUDE_SESSION_ID", "unknown")
+        project_path = (
+            os.environ.get("CLAUDE_PROJECT_DIR")
+            or os.environ.get("PROJECT_PATH")
+            or os.getcwd()
+        )
+
+        # Scrub and truncate
+        input_clean = _scrub(input_summary[:_MAX_SUMMARY_LEN])
+        output_clean = _scrub(output_summary[:_MAX_SUMMARY_LEN])
+
+        try:
+            engine._db.execute(
+                "INSERT INTO tool_events "
+                "(session_id, profile_id, project_path, tool_name, event_type, "
+                " input_summary, output_summary, duration_ms, metadata, created_at) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (session_id, engine.profile_id, project_path, tool_name,
+                 event_type, input_clean, output_clean, duration_ms, metadata, now),
+            )
+            return {"success": True, "tool": tool_name, "event": event_type}
+        except Exception as exc:
+            logger.debug("log_tool_event failed: %s", exc)
+            return {"success": False, "error": str(exc)}
+
+    @server.tool()
+    async def get_assertions(
+        min_confidence: float = 0.0,
+        category: str = "",
+        project_path: str = "",
+        limit: int = 50,
+    ) -> dict:
+        """Get learned behavioral assertions.
+
+        Behavioral assertions are patterns SLM discovered from your usage:
+        trigger conditions paired with recommended actions, each with a
+        confidence score that evolves over time.
+
+        Args:
+            min_confidence: Minimum confidence threshold (0.0-1.0)
+            category: Filter by category (workflow, code_style, tool_preference, communication)
+            project_path: Filter by project (empty = all including global)
+            limit: Maximum results
+        """
+        engine = get_engine()
+        try:
+            query = (
+                "SELECT id, trigger_condition, action, category, confidence, "
+                "evidence_count, reinforcement_count, contradiction_count, "
+                "project_path, source, created_at, updated_at "
+                "FROM behavioral_assertions "
+                "WHERE profile_id = ? AND confidence >= ?"
+            )
+            params: list = [engine.profile_id, min_confidence]
+
+            if category:
+                query += " AND category = ?"
+                params.append(category)
+            if project_path:
+                query += " AND (project_path = ? OR project_path = '')"
+                params.append(project_path)
+
+            query += " ORDER BY confidence DESC LIMIT ?"
+            params.append(limit)
+
+            rows = engine._db.execute(query, tuple(params))
+            assertions = [dict(r) for r in rows]
+            return {
+                "assertions": assertions,
+                "count": len(assertions),
+                "min_confidence": min_confidence,
+            }
+        except Exception as exc:
+            logger.debug("get_assertions failed: %s", exc)
+            return {"assertions": [], "count": 0, "error": str(exc)}
+
+    @server.tool()
+    async def reinforce_assertion(assertion_id: str) -> dict:
+        """Reinforce a behavioral assertion (increase confidence).
+
+        Call this when an assertion's recommendation was helpful.
+        Confidence increases via Bayesian update toward 1.0.
+
+        Args:
+            assertion_id: The assertion ID to reinforce
+        """
+        engine = get_engine()
+        return _update_assertion_confidence(engine._db, assertion_id, reinforce=True)
+
+    @server.tool()
+    async def contradict_assertion(assertion_id: str) -> dict:
+        """Contradict a behavioral assertion (decrease confidence).
+
+        Call this when an assertion's recommendation was wrong.
+        Confidence decays by 30%. Assertions below 0.2 are auto-deleted.
+
+        Args:
+            assertion_id: The assertion ID to contradict
+        """
+        engine = get_engine()
+        return _update_assertion_confidence(engine._db, assertion_id, reinforce=False)
+
+
+def _update_assertion_confidence(db, assertion_id: str, reinforce: bool) -> dict:
+    """Bayesian confidence update for behavioral assertions."""
+    now = datetime.now(timezone.utc).isoformat()
+    try:
+        row = db.execute(
+            "SELECT confidence, reinforcement_count, contradiction_count "
+            "FROM behavioral_assertions WHERE id = ?",
+            (assertion_id,),
+        )
+        rows = list(row)
+        if not rows:
+            return {"success": False, "error": "assertion not found"}
+
+        r = dict(rows[0])
+        old_conf = r["confidence"]
+
+        if reinforce:
+            new_conf = old_conf + (1.0 - old_conf) * 0.15  # Bayesian nudge toward 1.0
+            db.execute(
+                "UPDATE behavioral_assertions SET confidence = ?, "
+                "reinforcement_count = reinforcement_count + 1, "
+                "last_reinforced_at = ?, updated_at = ? WHERE id = ?",
+                (round(new_conf, 4), now, now, assertion_id),
+            )
+        else:
+            new_conf = old_conf * 0.7  # 30% decay
+            db.execute(
+                "UPDATE behavioral_assertions SET confidence = ?, "
+                "contradiction_count = contradiction_count + 1, "
+                "last_contradicted_at = ?, updated_at = ? WHERE id = ?",
+                (round(new_conf, 4), now, now, assertion_id),
+            )
+            # Auto-delete if confidence drops below 0.2
+            if new_conf < 0.2:
+                db.execute(
+                    "DELETE FROM behavioral_assertions WHERE id = ?",
+                    (assertion_id,),
+                )
+                return {
+                    "success": True, "action": "deleted",
+                    "reason": f"confidence dropped to {new_conf:.3f} (below 0.2 threshold)",
+                }
+
+        return {
+            "success": True,
+            "action": "reinforced" if reinforce else "contradicted",
+            "old_confidence": round(old_conf, 4),
+            "new_confidence": round(new_conf, 4),
+        }
+    except Exception as exc:
+        return {"success": False, "error": str(exc)}
+
+
+def _scrub(text: str) -> str:
+    """Remove potential secrets from telemetry text."""
+    import re
+    # Remove API keys, tokens, passwords
+    text = re.sub(r'\b(sk-|pk-|api[_-]?key[_-]?)[A-Za-z0-9_-]{10,}\b', '[REDACTED]', text)
+    text = re.sub(r'\b[A-Za-z0-9+/]{40,}={0,2}\b', '[REDACTED]', text)  # Base64 strings
+    text = re.sub(r'password\s*[=:]\s*\S+', 'password=[REDACTED]', text, flags=re.IGNORECASE)
+    return text

package/src/superlocalmemory/mcp/tools_mesh.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SLM Mesh MCP Tools — P2P agent communication via the unified daemon.
@@ -29,6 +29,7 @@ logger = logging.getLogger(__name__)
 # Unique peer ID for this MCP server session
 _PEER_ID = str(uuid.uuid4())[:12]
 _SESSION_SUMMARY = ""
+_PROJECT_PATH = ""  # v3.4.6: detected from cwd or CLAUDE_PROJECT_DIR
 _HEARTBEAT_INTERVAL = 25  # seconds (broker marks stale at 30s, dead at 60s)
 _HEARTBEAT_THREAD: threading.Thread | None = None
 _REGISTERED = False
@@ -46,6 +47,15 @@ def _daemon_url() -> str:
     return f"http://127.0.0.1:{port}"
 
 
+def _detect_project_path() -> str:
+    """Detect current project path from env or cwd."""
+    return (
+        os.environ.get("CLAUDE_PROJECT_DIR")
+        or os.environ.get("PROJECT_PATH")
+        or os.getcwd()
+    )
+
+
 def _mesh_request(method: str, path: str, body: dict | None = None) -> dict | None:
     """Send request to daemon mesh broker."""
     import urllib.request
@@ -63,18 +73,24 @@ def _mesh_request(method: str, path: str, body: dict | None = None) -> dict | No
 
 def _ensure_registered() -> None:
     """Register this session with the mesh broker if not already."""
-    global _REGISTERED
+    global _REGISTERED, _PROJECT_PATH
     if _REGISTERED:
         return
 
+    _PROJECT_PATH = _detect_project_path()
     result = _mesh_request("POST", "/register", {
         "peer_id": _PEER_ID,
         "session_id": os.environ.get("CLAUDE_SESSION_ID", _PEER_ID),
         "summary": _SESSION_SUMMARY or "SLM MCP session",
+        "project_path": _PROJECT_PATH,
+        "agent_type": os.environ.get("CLAUDE_AGENT_TYPE", "claude_code"),
     })
     if result:
         _REGISTERED = True
         _start_heartbeat()
+        pending = result.get("pending_messages", 0)
+        if pending > 0:
+            logger.info("Mesh: %d pending messages waiting", pending)
 
 
 def _start_heartbeat() -> None:
@@ -96,6 +112,15 @@ def _start_heartbeat() -> None:
     logger.info("Mesh heartbeat started (peer_id=%s, interval=%ds)", _PEER_ID, _HEARTBEAT_INTERVAL)
 
 
+def auto_register_mesh() -> None:
+    """Called from server.py warmup to register this session immediately.
+
+    v3.4.6: Sessions register at MCP startup, not lazily on first tool call.
+    This ensures every Claude session is visible on the mesh from the start.
+    """
+    _ensure_registered()
+
+
 def register_mesh_tools(server, get_engine: Callable) -> None:
     """Register all 8 mesh MCP tools."""
 
@@ -105,6 +130,8 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
 
         Call this at the start of every session. Other agents can see your summary
         and send you messages. The session stays alive via automatic heartbeat.
+        v3.4.6: Sessions auto-register at MCP startup, but calling this updates
+        the summary so other sessions know what you're doing.
 
         Args:
             summary: What this session is working on (e.g. "Fixing auth bug in api.py")
@@ -123,6 +150,7 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
         return {
             "peer_id": _PEER_ID,
             "summary": _SESSION_SUMMARY,
+            "project_path": _PROJECT_PATH,
             "registered": True,
             "heartbeat_active": _HEARTBEAT_THREAD is not None,
             "broker_response": result,
@@ -146,11 +174,14 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
 
     @server.tool()
     async def mesh_send(to: str, message: str) -> dict:
-        """Send a message to another peer session.
+        """Send a message to another peer session, broadcast, or project.
 
         Args:
-            to: The peer_id of the recipient (from mesh_peers)
-            message: The message content to send
+            to: Target — one of:
+                - A peer_id from mesh_peers (direct message)
+                - "broadcast" (all active + future sessions within 48h)
+                - "project:/path/to/dir" (all sessions in that project directory)
+            message: The message content (max 4KB — use file paths for large data)
         """
         _ensure_registered()
         result = _mesh_request("POST", "/send", {
@@ -164,15 +195,27 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
     async def mesh_inbox() -> dict:
         """Read messages sent to this session.
 
-        Returns unread messages from other peer sessions.
-        Messages are marked as read after retrieval.
+        Returns unread messages: direct + broadcast + project-targeted.
+        Broadcast/project messages are delivered to ALL matching sessions.
+        Messages auto-expire after 48 hours.
         """
         _ensure_registered()
-        messages = _mesh_request("GET", f"/inbox/{_PEER_ID}")
-        if messages:
-            # Mark as read
-            _mesh_request("POST", f"/inbox/{_PEER_ID}/read")
-        return messages or {"messages": [], "count": 0}
+        project = _PROJECT_PATH or _detect_project_path()
+        messages = _mesh_request(
+            "GET", f"/inbox/{_PEER_ID}?project_path={project}",
+        )
+        msg_list = (messages or {}).get("messages", [])
+        # Auto-mark unread messages as read
+        unread_ids = [m["id"] for m in msg_list if not m.get("read")]
+        if unread_ids:
+            _mesh_request("POST", f"/inbox/{_PEER_ID}/read", {
+                "message_ids": unread_ids,
+            })
+        return {
+            "messages": msg_list,
+            "count": len(msg_list),
+            "unread": len(unread_ids),
+        }
 
     @server.tool()
     async def mesh_state(key: str = "", value: str = "", action: str = "get") -> dict:

package/src/superlocalmemory/mcp/tools_v28.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SuperLocalMemory V3 — V2.8 Ported MCP Tools (6 tools).
@@ -53,6 +53,28 @@ def register_v28_tools(server, get_engine: Callable) -> None:
                 profile_id=engine.profile_id,
                 context=ctx,
             )
+
+            # v3.4.7: Bridge outcomes → learning signals for two-way learning.
+            # Previously, outcomes were stored but never created learning signals.
+            try:
+                from superlocalmemory.learning.feedback import FeedbackCollector
+                from pathlib import Path as _Path
+                learning_db = _Path.home() / ".superlocalmemory" / "learning.db"
+                collector = FeedbackCollector(learning_db)
+                signal_map = {"success": ("user_positive", 1.0),
+                              "failure": ("user_negative", 0.0),
+                              "partial": ("user_correction", 0.5)}
+                sig_type, sig_val = signal_map.get(outcome, ("user_correction", 0.5))
+                for fid in ids:
+                    collector.record_explicit(
+                        profile_id=engine.profile_id,
+                        fact_id=fid,
+                        signal_type=sig_type,
+                        value=sig_val,
+                    )
+            except Exception as exc2:
+                logger.debug("Outcome→signal bridge: %s", exc2)
+
             return {"success": True, "outcome_id": ao.outcome_id, "outcome": outcome}
         except Exception as exc:
             logger.exception("report_outcome failed")

package/src/superlocalmemory/mcp/tools_v3.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SuperLocalMemory V3 — V3-Only MCP Tools (5 tools).

package/src/superlocalmemory/mcp/tools_v33.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SuperLocalMemory V3.3 — New MCP Tools (6 tools).

package/src/superlocalmemory/mesh/__init__.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under the Elastic License 2.0 - see LICENSE file
+# Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
 """SLM Mesh — Python port of the P2P agent communication broker.