superlocalmemory 3.8.13 → 4.0.0

package/src/superlocalmemory/mcp/tools_code_graph.py

@@ -19,6 +19,10 @@ import time
 from pathlib import Path
 from typing import Any, Callable
 
+from mcp.types import ToolAnnotations
+
+from superlocalmemory.core.admission import admits
+from superlocalmemory.core.operation_request import OperationKind
 from superlocalmemory.core.security_primitives import (
     PathTraversalError,
     safe_resolve,
@@ -108,6 +112,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # ==================================================================
 
     @server.tool()
+    @admits(OperationKind.CORRECT)
     async def build_code_graph(
         repo_path: str,
         languages: str = "",
@@ -242,6 +247,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # ==================================================================
 
     @server.tool()
+    @admits(OperationKind.CORRECT)
     async def update_code_graph(
         repo_path: str = "",
         changed_files: str = "",
@@ -390,7 +396,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 3: get_blast_radius
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_blast_radius(
         changed_files: str,
         max_depth: int = 2,
@@ -452,7 +458,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 4: get_review_context
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_review_context(
         changed_files: str,
         include_source: bool = True,
@@ -509,7 +515,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
         "tests_for", "inherits_from", "inherited_by", "contains",
     })
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def query_graph(
         pattern: str,
         target: str = "",
@@ -608,7 +614,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 6: semantic_search_code
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def semantic_search_code(
         query: str,
         kind: str = "",
@@ -658,7 +664,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 7: list_graph_stats
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def list_graph_stats() -> dict:
         """Get code graph size and health metrics."""
         try:
@@ -705,7 +711,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 8: find_large_functions
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def find_large_functions(
         threshold: int = 50,
         limit: int = 20,
@@ -752,7 +758,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 9: list_flows
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def list_flows(
         sort_by: str = "criticality",
         limit: int = 20,
@@ -809,7 +815,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 10: get_flow
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_flow(
         flow_name: str,
     ) -> dict:
@@ -860,7 +866,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 11: get_affected_flows
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_affected_flows(
         changed_files: str,
     ) -> dict:
@@ -920,7 +926,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 12: list_communities
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def list_communities(
         sort_by: str = "cohesion",
         limit: int = 20,
@@ -967,7 +973,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 13: get_community
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_community(
         community_id: int,
     ) -> dict:
@@ -1014,7 +1020,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 14: get_architecture_overview
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_architecture_overview() -> dict:
         """Get high-level architecture map showing communities and their relationships."""
         try:
@@ -1063,7 +1069,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 15: detect_changes
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def detect_changes(
         base: str = "HEAD~1",
     ) -> dict:
@@ -1122,7 +1128,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 16: refactor_preview
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def refactor_preview(
         action: str,
         target: str,
@@ -1216,6 +1222,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # ==================================================================
 
     @server.tool()
+    @admits(OperationKind.CORRECT)
     async def apply_refactor(
         action: str,
         target: str,
@@ -1250,7 +1257,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 18 (BRIDGE): code_memory_search
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def code_memory_search(
         code_entity: str,
         link_type: str = "",
@@ -1320,7 +1327,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 19 (BRIDGE): code_entity_history
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def code_entity_history(
         code_entity: str,
     ) -> dict:
@@ -1390,7 +1397,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 20 (BRIDGE): enrich_blast_radius
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def enrich_blast_radius(
         changed_files: str,
         max_depth: int = 2,
@@ -1464,7 +1471,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     # Tool 21 (BRIDGE): code_stale_check
     # ==================================================================
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def code_stale_check(
         scope: str = "all",
     ) -> dict:
@@ -1538,6 +1545,7 @@ def register_code_graph_tools(server, get_engine: Callable) -> None:
     })
 
     @server.tool()
+    @admits(OperationKind.CORRECT)
     async def link_memory_to_code(
         fact_id: str,
         code_entity: str,

package/src/superlocalmemory/mcp/tools_context.py

@@ -21,6 +21,8 @@ from datetime import datetime, timezone
 from threading import Lock
 from typing import Callable
 
+from mcp.types import ToolAnnotations
+
 from superlocalmemory.core.security_primitives import redact_secrets
 
 logger = logging.getLogger(__name__)
@@ -64,7 +66,10 @@ _DEFAULT_LIMITER = _RateLimiter()
 
 
 # RecallFn for the tool. Callers inject a real recall engine; tests inject fakes.
-PrestageRecallFn = Callable[[str, int, str], list[dict]]
+# Phase 4b: extended to accept optional 4th positional arg (as_of: str | None).
+# Legacy callers with a 3-arg signature are handled by the try/except TypeError
+# fallback in prestage_context() (Decision A2, LLD §Module 8).
+PrestageRecallFn = Callable[..., list[dict]]
 
 
 def _iso_now() -> str:
@@ -100,12 +105,17 @@ def prestage_context(
     session_id: str = "default",
     recall_fn: PrestageRecallFn,
     limiter: _RateLimiter | None = None,
+    as_of: str | None = None,
 ) -> dict:
     """Proactive-context tool body.
 
     Pure function: takes an injected recall_fn + limiter. The MCP server
     wrapper in the session process wires the real engine and shares a
     single limiter instance.
+
+    Phase 4b: optional ``as_of`` (ISO 8601 UTC) for point-in-time context.
+    Normalized at entry; invalid input is silently ignored (background tool).
+    3-arg recall_fn callers are supported via TypeError fallback (Decision A2).
     """
     _limiter = limiter or _DEFAULT_LIMITER
     if not _limiter.allow(session_id):
@@ -127,8 +137,29 @@ def prestage_context(
         }
     limit = max(1, min(int(limit), 50))
 
+    # Normalize as_of at prestage boundary. Invalid input → silently ignore
+    # (prestage is background; user-facing surfaces raise instead).
+    _as_of: str | None = None
+    if as_of:
+        from superlocalmemory.retrieval.temporal_utils import normalize_as_of
+        _as_of = normalize_as_of(as_of)
+        if _as_of is None:
+            logger.warning("prestage_context: invalid as_of %r; ignoring", as_of)
+
     try:
-        raw = recall_fn(query, limit, profile_id) or []
+        # Decision A2 (LLD §Module 8) + audit P2 (CRIT-3): decide arity by
+        # INSPECTING the callable, not by catching TypeError. A bare
+        # `except TypeError` would silently swallow a genuine TypeError raised
+        # inside a 4-arg recall_fn body and drop as_of (silent wrong PIT view).
+        import inspect as _inspect
+        try:
+            _arity = len(_inspect.signature(recall_fn).parameters)
+        except (TypeError, ValueError):
+            _arity = 4  # unintrospectable (partial/builtin) → assume as_of-capable
+        if _arity >= 4:
+            raw = recall_fn(query, limit, profile_id, _as_of) or []
+        else:
+            raw = recall_fn(query, limit, profile_id) or []
     except Exception as exc:
         logger.warning("prestage_context recall failed: %s", exc)
         return {
@@ -172,20 +203,31 @@ def prestage_context(
 def register_prestage_tool(server, recall_fn: PrestageRecallFn,
                            *, session_id_fn: Callable[[], str] | None = None
                            ) -> None:
-    """Register the ``prestage_context`` tool on an MCP server."""
+    """Register the ``prestage_context`` tool on an MCP server.
+
+    The tool function is named ``prestage_context`` so profile filters
+    (``func.__name__``) and docs agree.
+    """
     limiter = _RateLimiter()
+    # Module-level pure function (avoid UnboundLocalError from nested def name).
+    _pure_prestage = globals()["prestage_context"]
 
-    @server.tool()
-    async def prestage_context_tool(  # pragma: no cover — MCP wiring
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
+    async def prestage_context(  # noqa: F811 — MCP tool surface name
         query: str,
         limit: int = 5,
         profile_id: str = "default",
+        as_of: str | None = None,
     ) -> dict:
-        """Proactively return top-K memories for a query."""
+        """Proactively return top-K memories for a query.
+
+        Optional ``as_of`` (ISO 8601 UTC) for point-in-time context retrieval.
+        """
         session_id = session_id_fn() if session_id_fn else "default"
-        return prestage_context(
+        return _pure_prestage(
             query, limit=limit, profile_id=profile_id,
-            session_id=session_id, recall_fn=recall_fn, limiter=limiter,
+            session_id=session_id, recall_fn=recall_fn,
+            limiter=limiter, as_of=as_of,
         )
 
 

package/src/superlocalmemory/mcp/tools_core.py

@@ -19,7 +19,9 @@ from typing import Callable
 
 from mcp.types import ToolAnnotations
 
+from superlocalmemory.core.admission import admits
 from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
+from superlocalmemory.core.operation_request import OperationKind
 from superlocalmemory.infra.data_root import state_path
 from superlocalmemory.mcp._daemon_proxy import daemon_unavailable_error
 from superlocalmemory.mcp.shared import authorize_mcp_mutation
@@ -63,6 +65,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
     """Register the 13 core MCP tools on *server*."""
 
     @server.tool()
+    @admits(OperationKind.REMEMBER)
     async def remember(
         content: str, tags: str = "", project: str = "",
         importance: int = 5, session_id: str = "",
@@ -91,13 +94,25 @@ def register_core_tools(server, get_engine: Callable) -> None:
             "session_id": session_id,
         }
         effective_idempotency_key = idempotency_key
-        if not effective_idempotency_key and session_id:
-            material = (
-                f"{agent_id}\0{session_id}\0{scope or ''}\0{shared_with}\0{content}"
-            )
-            effective_idempotency_key = "mcp:" + hashlib.sha256(
-                material.encode("utf-8")
-            ).hexdigest()
+        if not effective_idempotency_key:
+            # Derive a stable key before the first attempt so every retry of
+            # the same logical call carries the same key.  When a session token
+            # is present it is included in the material to keep per-session
+            # stores separate.  Without a session token the key is derived from
+            # the remaining call parameters so repeated observations with the
+            # same content, agent, and scope are deduplicated across retries.
+            if session_id:
+                material = (
+                    f"{agent_id}\0{session_id}\0{scope or ''}\0{shared_with}\0{content}"
+                )
+                effective_idempotency_key = "mcp:" + hashlib.sha256(
+                    material.encode("utf-8")
+                ).hexdigest()
+            else:
+                material = f"{agent_id}\0{scope or ''}\0{shared_with}\0{content}"
+                effective_idempotency_key = "mcp:req:" + hashlib.sha256(
+                    material.encode("utf-8")
+                ).hexdigest()
         # Parse shared_with from comma-separated string
         _shared_list = [s.strip() for s in shared_with.split(",") if s.strip()] if shared_with else None
         # v3.5.5 WRITE-THROUGH: route through the daemon's /remember, which does
@@ -109,6 +124,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
         daemon_owned = False
         try:
             import asyncio as _asyncio
+
             from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
             # is_daemon_running() and daemon_request() both use blocking urllib
             # against the same uvicorn server — run in threads so the MCP
@@ -173,6 +189,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
 
         try:
             import asyncio as _asyncio
+
             from superlocalmemory.mcp._daemon_proxy import choose_pool
 
             worker_meta = {
@@ -247,12 +264,14 @@ def register_core_tools(server, get_engine: Callable) -> None:
             }
 
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
+    @admits(OperationKind.RECALL)
     async def recall(
         query: str, limit: int = CANONICAL_RECALL_LIMIT, agent_id: str = "mcp_client",
         session_id: str = "", fast: bool | None = None,
         include_global: bool | None = None,
         include_shared: bool | None = None,
         window: str = "",
+        as_of: str | None = None,
     ) -> dict:
         """Search memories through hybrid retrieval, RRF fusion, and reranking.
 
@@ -286,6 +305,10 @@ def register_core_tools(server, get_engine: Callable) -> None:
         range. Accepts a relative span (``"24h"``, ``"7d"``, ``"30d"``,
         ``"1y"``) or an explicit range (``"2026-07-01..2026-07-31"``). Empty =
         no time filter.
+
+        Point-in-time: optional ``as_of`` (ISO-8601 string, e.g.
+        ``"2026-01-01T00:00:00+00:00"``) pins recall to a temporal snapshot;
+        omit or pass ``None`` for current-state recall.
         """
         # v3.6.10: resolve "mcp_client" sentinel → URL path (HTTP) or env var (stdio)
         if agent_id == "mcp_client":
@@ -342,12 +365,28 @@ def register_core_tools(server, get_engine: Callable) -> None:
             #
             # V3.4.26: WorkerPool now concurrent — parallel calls no longer
             # block behind a single threading.Lock. See worker_pool.py.
+            # Phase 4b: normalize as_of at MCP boundary. Invalid → reject.
+            # Audit P2: treat empty/whitespace as_of as ABSENT (like HTTP does),
+            # not as an invalid value — only a non-blank unparseable string is
+            # rejected.
+            if as_of is not None and str(as_of).strip():
+                from superlocalmemory.retrieval.temporal_utils import normalize_as_of
+                as_of = normalize_as_of(as_of)
+                if as_of is None:
+                    return {"success": False, "error": "invalid_as_of"}
+            else:
+                as_of = None
+
+            from superlocalmemory.core.admission import enforce_read_scope
+            _incl_global, _incl_shared = enforce_read_scope(include_global, include_shared)
+
             def _recall_via_daemon_pool():
                 pool = choose_pool()
                 return pool.recall(
                     query, limit=limit, session_id=effective_sid,
-                    fast=fast, include_global=include_global,
-                    include_shared=include_shared, window=window or None,
+                    fast=fast, include_global=_incl_global,
+                    include_shared=_incl_shared, window=window or None,
+                    as_of=as_of,
                 )
 
             result = await asyncio.to_thread(
@@ -376,11 +415,12 @@ def register_core_tools(server, get_engine: Callable) -> None:
             return {"success": False, "error": str(exc)}
 
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
-    async def search(query: str, limit: int = 10, profile_id: str = "") -> dict:
+    @admits(OperationKind.RECALL)
+    async def search(query: str, limit: int = 10) -> dict:
         """Full-text search across memories using FTS5 with BM25 ranking."""
         try:
             engine = get_engine()
-            pid = await _runtime_profile(get_engine, profile_id)
+            pid = await _runtime_profile(get_engine)
             facts = engine._db.search_facts_fts(query, pid, limit=limit)
             items = []
             for f in facts:
@@ -424,11 +464,11 @@ def register_core_tools(server, get_engine: Callable) -> None:
             return {"success": False, "error": str(exc)}
 
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
-    async def list_recent(limit: int = 20, profile_id: str = "") -> dict:
+    async def list_recent(limit: int = 20) -> dict:
         """List most recently stored memories, newest first."""
         try:
             engine = get_engine()
-            pid = await _runtime_profile(get_engine, profile_id)
+            pid = await _runtime_profile(get_engine)
             # v3.6.12 (search-2): push the limit into the query — was loading the
             # ENTIRE facts table (deserializing every 768-float embedding) just
             # to return the top N. get_all_facts preserves created_at DESC order.
@@ -522,11 +562,12 @@ def register_core_tools(server, get_engine: Callable) -> None:
             return {"success": False, "error": str(exc)}
 
     @server.tool()
-    async def build_graph(profile_id: str = "") -> dict:
+    @admits(OperationKind.CORRECT)
+    async def build_graph() -> dict:
         """Rebuild knowledge graph edges for all facts in the active profile."""
         try:
             engine = get_engine()
-            pid = await _runtime_profile(get_engine, profile_id)
+            pid = await _runtime_profile(get_engine)
             authorization = authorize_mcp_mutation(
                 engine,
                 "update",
@@ -550,6 +591,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             return {"success": False, "error": str(exc)}
 
     @server.tool()
+    @admits(OperationKind.PROFILE_SWITCH)
     async def switch_profile(profile_id: str) -> dict:
         """Switch the active memory profile. All operations scope to this profile."""
         try:
@@ -674,19 +716,22 @@ def register_core_tools(server, get_engine: Callable) -> None:
             logger.exception("switch_profile failed")
             return {"success": False, "error": str(exc)}
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def backup_status() -> dict:
         """Get backup system status, last backup time, and available backup files."""
         try:
             engine = get_engine()
             from superlocalmemory.infra.backup import BackupManager
-            bm = BackupManager(engine._config.base_dir, engine._db.db_path)
+            bm = BackupManager(
+                db_path=engine._db.db_path,
+                base_dir=engine._config.base_dir,
+            )
             return {"success": True, **bm.get_status()}
         except Exception as exc:
             logger.exception("backup_status failed")
             return {"success": False, "error": str(exc)}
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def memory_used() -> dict:
         """Get memory usage breakdown by fact type and lifecycle state."""
         try:
@@ -711,7 +756,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             logger.exception("memory_used failed")
             return {"success": False, "error": str(exc)}
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_learned_patterns(pattern_type: str = "", limit: int = 20) -> dict:
         """Get learned behavioral patterns (interests, refinements, archival habits)."""
         try:
@@ -729,6 +774,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             return {"success": False, "error": str(exc)}
 
     @server.tool()
+    @admits(OperationKind.CORRECT)
     async def correct_pattern(pattern_id: str, correction: str) -> dict:
         """Correct or annotate a learned behavioral pattern to improve retrieval."""
         try:
@@ -757,6 +803,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             return {"success": False, "error": str(exc)}
 
     @server.tool(annotations=ToolAnnotations(destructiveHint=True))
+    @admits(OperationKind.FORGET)
     async def delete_memory(fact_id: str, agent_id: str = "mcp_client") -> dict:
         """Delete a specific memory by exact fact ID.
 
@@ -823,6 +870,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             return {"success": False, "error": str(exc)}
 
     @server.tool(annotations=ToolAnnotations(idempotentHint=True))
+    @admits(OperationKind.CORRECT)
     async def update_memory(
         fact_id: str, content: str, agent_id: str = "mcp_client",
     ) -> dict:
@@ -886,12 +934,12 @@ def register_core_tools(server, get_engine: Callable) -> None:
             logger.exception("update_memory failed")
             return {"success": False, "error": str(exc)}
 
-    @server.tool()
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_attribution() -> dict:
         """Get system attribution: author, version, license, and provenance metadata."""
         return {
             "success": True,
-            "product": "SuperLocalMemory V3",
+            "product": "SuperLocalMemory V4",
             "author": "Varun Pratap Bhardwaj",
             "organization": "Qualixar",
             "license": "AGPL-3.0-or-later",

package/src/superlocalmemory/mcp/tools_evolution.py

@@ -19,6 +19,8 @@ import logging
 from typing import Callable
 
 from mcp.types import ToolAnnotations
+from superlocalmemory.core.admission import admits
+from superlocalmemory.core.operation_request import OperationKind
 from superlocalmemory.infra.data_root import state_path
 from superlocalmemory.storage.read_connection import ReadConnectionFactory
 
@@ -28,6 +30,7 @@ def register_evolution_tools(server, get_engine: Callable) -> None:
     """Register evolution MCP tools for skill evolution intelligence."""
 
     @server.tool()
+    @admits(OperationKind.EVOLVE_SKILL)
     async def evolve_skill(
         skill_name: str,
         evolution_type: str = "fix",
@@ -270,6 +273,8 @@ def register_evolution_tools(server, get_engine: Callable) -> None:
             skill_name: Specific skill name (empty = all skills)
         """
         try:
+            engine = get_engine()
+            profile_id = engine.profile_id if engine else "default"
             db_path = state_path("memory.db")
             conn = ReadConnectionFactory(db_path).open()
 
@@ -279,9 +284,9 @@ def register_evolution_tools(server, get_engine: Callable) -> None:
                     "trigger_type, generation, status, mutation_summary, "
                     "blind_verified, created_at, completed_at "
                     "FROM skill_evolution_log "
-                    "WHERE skill_name = ? OR parent_skill_id = ? "
+                    "WHERE profile_id = ? AND (skill_name = ? OR parent_skill_id = ?) "
                     "ORDER BY created_at ASC",
-                    (skill_name, skill_name),
+                    (profile_id, skill_name, skill_name),
                 ).fetchall()
             else:
                 rows = conn.execute(
@@ -289,7 +294,9 @@ def register_evolution_tools(server, get_engine: Callable) -> None:
                     "trigger_type, generation, status, mutation_summary, "
                     "blind_verified, created_at, completed_at "
                     "FROM skill_evolution_log "
+                    "WHERE profile_id = ? "
                     "ORDER BY created_at DESC LIMIT 100",
+                    (profile_id,),
                 ).fetchall()
 
             conn.close()