superlocalmemory 4.1.11 → 4.1.13

package/src/superlocalmemory/integrations/bounded_loops_mcp.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import hashlib
 import json
 import os
 import shutil
@@ -12,7 +13,13 @@ from copy import deepcopy
 from pathlib import Path
 from typing import Any
 
+from superlocalmemory.storage.execution_learning import (
+    VerifiedExecutionEvidence,
+    _seal_verified_execution_evidence,
+)
+
 CONTRACT_ID = "bounded-loops.dev/slm-bridge/v1"
+CONTRACT_V2_ID = "bounded-loops.dev/slm-bridge/v2"
 _OBSERVATION_TIMEOUT_SECONDS = 5.0
 _MAX_MCP_TEXT_BYTES = 2 * 1024 * 1024
 _ADVERTISEMENT = {
@@ -20,6 +27,11 @@ _ADVERTISEMENT = {
     "tool": "bl_graph_evidence",
     "operation": "observe_terminal_run",
 }
+_ADVERTISEMENT_V2 = {
+    "id": CONTRACT_V2_ID,
+    "tool": "bl_graph_execution_evidence",
+    "operation": "observe_verified_terminal_run",
+}
 
 
 class BridgeUnavailable(ValueError):
@@ -36,6 +48,37 @@ def supports_bridge(capabilities: dict[str, Any]) -> bool:
     )
 
 
+def supports_bridge_v2(capabilities: dict[str, Any]) -> bool:
+    """Negotiate the additive v2 capability without altering v1 semantics."""
+    advertised = capabilities.get("evidence_contracts")
+    return isinstance(advertised, list) and any(
+        isinstance(item, dict)
+        and all(item.get(key) == value for key, value in _ADVERTISEMENT_V2.items())
+        for item in advertised
+    )
+
+
+def _bridge_v2_payload(
+    evidence: dict[str, Any], *, profile_id: str, terminal_run: dict[str, Any]
+) -> dict[str, Any]:
+    """Bind v2 evidence to the terminal run independently enumerated this session.
+
+    A v2 producer cannot promote an arbitrary schema-shaped JSON object: the
+    evidence must agree exactly with the separately fetched terminal listing.
+    The resulting payload is sealed below before it can reach storage.
+    """
+    if evidence.get("contract") != CONTRACT_V2_ID:
+        raise BridgeUnavailable("unsupported bounded-loops execution evidence contract")
+    required_listing = ("run_ref", "run_id", "run_state", "terminal_at")
+    if any(not isinstance(terminal_run.get(field), str) for field in required_listing):
+        raise BridgeUnavailable("bounded-loops terminal listing is malformed")
+    if any(evidence.get(field) != terminal_run[field] for field in required_listing):
+        raise BridgeUnavailable("bounded-loops execution evidence does not match terminal listing")
+    payload = deepcopy(evidence)
+    payload["profile_id"] = profile_id
+    return payload
+
+
 def bridge_payload(evidence: dict[str, Any], *, profile_id: str) -> dict[str, Any]:
     """Attach active-profile identity after refusing incompatible evidence."""
     if evidence.get("contract") != CONTRACT_ID:
@@ -96,6 +139,126 @@ async def observe_terminal_runs(
     return observed
 
 
+async def observe_terminal_runs_v2(
+    call_tool: Callable[[str, dict[str, Any]], Awaitable[dict[str, Any]]], *, profile_id: str,
+    producer_identity: str,
+) -> list[VerifiedExecutionEvidence]:
+    """Collect v2 receipts only after verified local producer provenance.
+
+    The producer identity is measured by the stdio launcher, not supplied by
+    producer JSON.  The capability and terminal-listing digests record the
+    exact independently observed control-plane statements that authorized
+    each sealed payload.
+    """
+    if not isinstance(producer_identity, str) or not producer_identity:
+        raise BridgeUnavailable("bounded-loops execution producer identity is unavailable")
+    discovery = await call_tool("bl_capabilities", {})
+    if discovery.get("status") != "ok" or not supports_bridge_v2(discovery.get("capabilities", {})):
+        raise BridgeUnavailable("bounded-loops does not advertise slm-bridge/v2")
+    listing = await call_tool("bl_graph_terminal_runs", {"limit": 100})
+    if (
+        listing.get("status") != "ok"
+        or listing.get("contract") != CONTRACT_ID
+        or not isinstance(listing.get("runs"), list)
+    ):
+        raise BridgeUnavailable("bounded-loops terminal listing is unavailable")
+    capability_digest = _canonical_digest(discovery["capabilities"])
+    listing_digest = _canonical_digest(listing["runs"])
+    observed: list[VerifiedExecutionEvidence] = []
+    for run in listing["runs"][:100]:
+        if not isinstance(run, dict) or any(
+            not isinstance(run.get(field), str)
+            for field in ("run_ref", "run_id", "run_state", "terminal_at")
+        ):
+            raise BridgeUnavailable("bounded-loops terminal listing is malformed")
+        response = await call_tool("bl_graph_execution_evidence", {"run_ref": run["run_ref"]})
+        if response.get("status") == "unavailable":
+            continue
+        if response.get("status") != "ok" or not isinstance(response.get("evidence"), dict):
+            raise BridgeUnavailable("bounded-loops execution evidence response is malformed")
+        payload = _bridge_v2_payload(
+            response["evidence"], profile_id=profile_id, terminal_run=run
+        )
+        try:
+            observed.append(_seal_verified_execution_evidence(
+                payload,
+                producer_identity=producer_identity,
+                capability_digest=capability_digest,
+                terminal_listing_digest=listing_digest,
+            ))
+        except ValueError as exc:
+            raise BridgeUnavailable("bounded-loops execution evidence is invalid") from exc
+    return observed
+
+
+def _canonical_digest(value: Any) -> str:
+    """Stable audit identity for a negotiated MCP control-plane document."""
+    encoded = json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+    return "sha256:" + hashlib.sha256(encoded.encode("utf-8")).hexdigest()
+
+
+def _file_digest(path: Path, digest: hashlib._Hash) -> None:
+    """Feed one regular file into an already-bound identity hash."""
+    try:
+        with path.open("rb") as handle:
+            for chunk in iter(lambda: handle.read(64 * 1024), b""):
+                digest.update(chunk)
+    except OSError as exc:
+        raise BridgeUnavailable("bounded-loops producer source could not be identified") from exc
+
+
+def _package_source_identity(executable: Path) -> str:
+    """Digest the bounded_loops source loaded by the MCP launcher's venv.
+
+    The console script is only a shim. Its shebang identifies the interpreter
+    whose site-packages directory owns the running MCP server, so bind the
+    source files from that environment rather than whichever package happens
+    to be importable by SLM itself.
+    """
+    try:
+        first_line = executable.open("rb").readline(4096).decode("utf-8").strip()
+    except (OSError, UnicodeDecodeError) as exc:
+        raise BridgeUnavailable("bounded-loops executable has no readable interpreter") from exc
+    if not first_line.startswith("#!"):
+        raise BridgeUnavailable("bounded-loops executable has no absolute interpreter")
+    interpreter = Path(first_line[2:])
+    if not interpreter.is_absolute() or not interpreter.is_file():
+        raise BridgeUnavailable("bounded-loops executable interpreter is unavailable")
+    if interpreter.parent.name not in {"bin", "Scripts"}:
+        raise BridgeUnavailable("bounded-loops executable is not an isolated environment launcher")
+    environment = interpreter.parent.parent
+    candidates = sorted(
+        candidate.resolve(strict=True)
+        for candidate in (environment / "lib").glob("python*/site-packages/bounded_loops")
+        if candidate.is_dir() and not candidate.is_symlink()
+    )
+    if len(candidates) != 1:
+        raise BridgeUnavailable("bounded-loops package source is unavailable or ambiguous")
+    package = candidates[0]
+    digest = hashlib.sha256()
+    source_files = sorted(
+        path for path in package.rglob("*.py") if path.is_file() and not path.is_symlink()
+    )
+    if not source_files:
+        raise BridgeUnavailable("bounded-loops package source is empty")
+    for path in source_files:
+        digest.update(path.relative_to(package).as_posix().encode("utf-8"))
+        digest.update(b"\0")
+        _file_digest(path, digest)
+        digest.update(b"\0")
+    return "sha256:" + digest.hexdigest()
+
+
+def _producer_identity(executable: Path) -> str:
+    """Bind the trusted launcher and actual bounded_loops package source."""
+    digest = hashlib.sha256()
+    digest.update(b"bounded-loops-launcher\0")
+    _file_digest(executable, digest)
+    digest.update(b"\0bounded-loops-package\0")
+    digest.update(_package_source_identity(executable).encode("ascii"))
+    return "sha256:" + digest.hexdigest()
+
+
 def _assert_trusted_executable(executable: Path) -> None:
     """Raise BridgeUnavailable if executable does not pass the bridge trust checks."""
     try:
@@ -182,6 +345,58 @@ async def observe_from_stdio(*, command: str, cwd: str, profile_id: str) -> list
         raise BridgeUnavailable("bounded-loops observation timed out or could not start") from exc
 
 
+async def observe_v2_from_stdio(
+    *, command: str, cwd: str, profile_id: str
+) -> list[VerifiedExecutionEvidence]:
+    """Use the same trusted stdio boundary for additive v2 evidence."""
+    # Reuse the hardened v1 launcher while selecting only v2 after capability
+    # negotiation.  The injected helper is intentionally local to this call.
+    executable, workspace = Path(command), Path(cwd)
+    if (
+        not executable.is_absolute()
+        or not executable.is_file()
+        or not workspace.is_absolute()
+        or not workspace.is_dir()
+        or workspace.is_symlink()
+    ):
+        raise BridgeUnavailable("bounded-loops bridge requires an approved executable and workspace")
+    try:
+        executable = executable.resolve(strict=True)
+        workspace = workspace.resolve(strict=True)
+    except OSError as exc:
+        raise BridgeUnavailable("bounded-loops bridge path is unavailable") from exc
+    _assert_trusted_executable(executable)
+    producer_identity = _producer_identity(executable)
+    from mcp import ClientSession, StdioServerParameters
+    from mcp.client.stdio import stdio_client
+    try:
+        parameters = StdioServerParameters(command=str(executable), args=[], cwd=str(workspace))
+        async with stdio_client(parameters) as (read, write):
+            async with ClientSession(read, write, read_timeout_seconds=_OBSERVATION_TIMEOUT_SECONDS) as session:
+                await session.initialize()
+                async def call(name: str, arguments: dict[str, Any]) -> dict[str, Any]:
+                    result = await session.call_tool(name, arguments)
+                    texts = [item.text for item in result.content if hasattr(item, "text")]
+                    if result.is_error or len(texts) != 1 or len(texts[0].encode("utf-8")) > _MAX_MCP_TEXT_BYTES:
+                        raise BridgeUnavailable("bounded-loops returned an invalid MCP payload")
+                    payload = json.loads(texts[0])
+                    if not isinstance(payload, dict):
+                        raise BridgeUnavailable("bounded-loops returned an invalid MCP payload")
+                    return payload
+                return await asyncio.wait_for(
+                    observe_terminal_runs_v2(
+                        call,
+                        profile_id=profile_id,
+                        producer_identity=producer_identity,
+                    ),
+                    _OBSERVATION_TIMEOUT_SECONDS,
+                )
+    except BridgeUnavailable:
+        raise
+    except Exception as exc:
+        raise BridgeUnavailable("bounded-loops execution observation timed out or could not start") from exc
+
+
 async def observe_installed(*, workspace: str, profile_id: str) -> list[dict[str, Any]]:
     """Observe a user-installed producer without accepting an agent command.
 
@@ -200,3 +415,17 @@ async def observe_installed(*, workspace: str, profile_id: str) -> list[dict[str
     return await observe_from_stdio(
         command=str(Path(command).resolve()), cwd=workspace, profile_id=profile_id
     )
+
+
+async def observe_installed_v2(
+    *, workspace: str, profile_id: str
+) -> list[VerifiedExecutionEvidence]:
+    """Observe only from the installed bounded-loops MCP executable."""
+    command = shutil.which("bounded-loops-mcp")
+    if command is None or not Path(command).is_absolute():
+        raise BridgeUnavailable("bounded-loops-mcp is not installed")
+    executable = Path(command).resolve()
+    if executable.name not in {"bounded-loops-mcp", "bounded-loops-mcp.exe"}:
+        raise BridgeUnavailable("bounded-loops-mcp discovery returned an unsafe executable")
+    return await observe_v2_from_stdio(command=str(executable), cwd=workspace,
+                                       profile_id=profile_id)

package/src/superlocalmemory/learning/database.py

@@ -639,7 +639,8 @@ class LearningDatabase:
                     for row in conn.execute(
                         "SELECT name FROM sqlite_master WHERE type='table' "
                         "AND name IN ('agent_experiences', 'cognitive_turn_receipts', "
-                        "'external_evidence_receipts')"
+                        "'external_evidence_receipts', 'execution_learning_receipts', "
+                        "'execution_learning_events')"
                     )
                 }
                 if profile_id is None:

package/src/superlocalmemory/mcp/tools_active.py

@@ -318,6 +318,8 @@ def register_active_tools(server, get_engine: Callable) -> None:
         query: str = "",
         max_results: int = 10,
         max_age_days: int = 30,
+        session_id: str = "",
+        agent_id: str = "",
     ) -> dict:
         """Initialize session with relevant memory context.
 
@@ -563,18 +565,24 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 )
                 feedback_count = 0
 
-            # v3.6.9 (#35): generate a stable session_id so clients can pass it
-            # to remember() and close_session() for proper session aggregation.
-            session_id = (
+            # A gateway can serve concurrent host conversations.  An explicit
+            # host id therefore always wins; generating one is retained only
+            # for older clients that cannot supply lifecycle identity.
+            effective_session_id = session_id.strip() or (
                 f"slm-{datetime.datetime.now(datetime.timezone.utc):%Y%m%d}"
                 f"-{uuid.uuid4().hex[:8]}"
             )
+            effective_agent_id = agent_id.strip() or _get_agent_id()
+            # Backward-compatible default for legacy close_session() callers;
+            # native hosts must pass their explicit id when sessions overlap.
+            engine._last_session_id = effective_session_id
 
             _upcoming_events = _upcoming_scheduled_facts(engine, _now)
 
             return {
                 "success": True,
-                "session_id": session_id,
+                "session_id": effective_session_id,
+                "agent_id": effective_agent_id,
                 "context": context,
                 "memories": memories[:max_results],
                 "memory_count": len(memories),
@@ -623,6 +631,7 @@ def register_active_tools(server, get_engine: Callable) -> None:
     async def observe(
         content: str,
         agent_id: str | None = None,
+        session_id: str = "",
     ) -> dict:
         """Observe conversation content for automatic memory capture.
 
@@ -673,11 +682,16 @@ def register_active_tools(server, get_engine: Callable) -> None:
             # Auto-store via engine.
             # pool_store uses blocking urllib (DaemonPoolProxy) — run in
             # thread so the MCP event loop stays unblocked (#34 class).
+            from superlocalmemory.mcp.session_binding import resolve_session_id
+            effective_session_id = resolve_session_id(
+                session_id, agent_id=agent_id, allow_agent_fallback=False,
+            )
             stored = await asyncio.to_thread(
                 auto.capture,
                 content,
                 category=decision.category,
-                metadata={"agent_id": agent_id, "source": "auto-observe"},
+                metadata={"agent_id": agent_id, "session_id": effective_session_id,
+                          "source": "auto-observe"},
             )
 
             if stored:
@@ -693,6 +707,7 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 "category": decision.category,
                 "confidence": round(decision.confidence, 3),
                 "reason": decision.reason,
+                "session_id": effective_session_id,
             }
         except Exception as exc:
             logger.exception("observe failed")

package/src/superlocalmemory/mcp/tools_brain.py

@@ -20,7 +20,15 @@ from superlocalmemory.brain.truth import BrainTruthService
 from superlocalmemory.core.admission import admits
 from superlocalmemory.core.operation_request import OperationKind
 from superlocalmemory.infra.data_root import state_path
-from superlocalmemory.integrations.bounded_loops_mcp import BridgeUnavailable, observe_installed
+from superlocalmemory.integrations.bounded_loops_mcp import (
+    BridgeUnavailable,
+    observe_installed,
+    observe_installed_v2,
+)
+from superlocalmemory.storage.execution_learning import (
+    ExecutionLearningStore,
+    ExecutionLearningValidationError,
+)
 from superlocalmemory.storage.agent_experience import (
     AgentExperienceConflictError,
     AgentExperienceStore,
@@ -51,6 +59,14 @@ def _external_store_for(engine: Any) -> ExternalEvidenceStore:
     )
 
 
+def _execution_store_for(engine: Any) -> ExecutionLearningStore:
+    active_profile = engine.profile_id
+    return ExecutionLearningStore(
+        Path(state_path("learning.db")),
+        is_profile_active=lambda profile_id: profile_id == active_profile,
+    )
+
+
 def _brain_truth_for(engine: Any) -> dict[str, Any]:
     """Read the portable truth snapshot without opening an engine or a writer."""
     return BrainTruthService(
@@ -259,3 +275,24 @@ def register_brain_tools(server: Any, get_engine: Callable[[], Any]) -> None:
             "created": created,
             "control_plane": "observation_only",
         }
+
+    @server.tool()
+    @admits(OperationKind.REMEMBER)
+    async def observe_bounded_loop_execution_learning(workspace: str) -> dict[str, Any]:
+        """Ingest negotiated bridge-v2 terminal evidence into the execution plane.
+
+        The producer is reached only through the installed bounded-loops MCP
+        capability handshake.  This never writes semantic facts or preferences.
+        """
+        engine = get_engine()
+        try:
+            observed = await observe_installed_v2(workspace=workspace, profile_id=engine.profile_id)
+            store = _execution_store_for(engine)
+            created = 0
+            for payload in observed:
+                created += int(await asyncio.to_thread(store.ingest, payload))
+            return {"success": True, "durable": True, "observed": len(observed),
+                    "created": created, "control_plane": "execution_reliability_only"}
+        except (BridgeUnavailable, ExecutionLearningValidationError, ProfileAdmissionError,
+                sqlite3.Error) as exc:
+            return {"success": False, "durable": False, "error": str(exc)}

package/src/superlocalmemory/mcp/tools_learning.py

@@ -15,11 +15,14 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
 import os
+import sqlite3
 import uuid
 from datetime import datetime, timezone
+from pathlib import Path
 from typing import Callable
 
 from mcp.types import ToolAnnotations
@@ -33,6 +36,72 @@ logger = logging.getLogger(__name__)
 _MAX_SUMMARY_LEN = 500  # Truncate input/output summaries
 
 
+def settle_pending_session_outcomes(
+    memory_db_path: str | Path,
+    *,
+    profile_id: str,
+    session_id: str,
+    evidence_only: bool = False,
+) -> dict[str, int]:
+    """Finalize real pending recalls for one host-owned session.
+
+    This is deliberately a narrow adapter around ``EngagementRewardModel``:
+    it selects only pending rows belonging to the supplied active profile and
+    exact host session, then delegates every state transition and reward
+    calculation to the established finalizer.  No feedback is inferred here.
+    Repeating the call is a no-op because settled rows are not selected.
+    """
+    session_id = session_id.strip()
+    if not session_id:
+        return {"selected": 0, "settled": 0}
+
+    path = Path(memory_db_path)
+    try:
+        with sqlite3.connect(str(path), timeout=2.0) as conn:
+            rows = conn.execute(
+                "SELECT outcome_id, signals_json FROM pending_outcomes "
+                "WHERE profile_id=? AND session_id=? AND status='pending'",
+                (profile_id, session_id),
+            ).fetchall()
+    except sqlite3.Error as exc:
+        raise RuntimeError("pending outcome lookup failed") from exc
+
+    if evidence_only:
+        from superlocalmemory.learning.reward import _carries_evidence
+
+        rows = [
+            row for row in rows
+            if _carries_evidence(json.loads(row[1] or "{}"))
+        ]
+
+    if not rows:
+        return {"selected": 0, "settled": 0}
+
+    from superlocalmemory.learning.reward import EngagementRewardModel
+
+    model = EngagementRewardModel(memory_db_path=str(path))
+    try:
+        for outcome_id, _signals_json in rows:
+            # Preserve the established keyword-only finalization contract.
+            model.finalize_outcome(outcome_id=outcome_id)
+    finally:
+        model.close()
+
+    outcome_ids = [row[0] for row in rows]
+    placeholders = ",".join("?" for _ in outcome_ids)
+    try:
+        with sqlite3.connect(str(path), timeout=2.0) as conn:
+            settled = conn.execute(
+                "SELECT COUNT(*) FROM pending_outcomes "
+                "WHERE profile_id=? AND session_id=? AND status='settled' "
+                f"AND outcome_id IN ({placeholders})",
+                (profile_id, session_id, *outcome_ids),
+            ).fetchone()[0]
+    except sqlite3.Error as exc:
+        raise RuntimeError("pending outcome settlement verification failed") from exc
+    return {"selected": len(outcome_ids), "settled": int(settled)}
+
+
 def register_learning_tools(server, get_engine: Callable) -> None:
     """Register learning MCP tools for two-way intelligence."""
 
@@ -45,6 +114,9 @@ def register_learning_tools(server, get_engine: Callable) -> None:
         output_summary: str = "",
         duration_ms: int = 0,
         metadata: str = "{}",
+        session_id: str = "",
+        agent_id: str = "",
+        project_path: str = "",
     ) -> dict:
         """Log a tool usage event for behavioral learning.
 
@@ -62,8 +134,11 @@ def register_learning_tools(server, get_engine: Callable) -> None:
         """
         engine = get_engine()
         now = datetime.now(timezone.utc).isoformat()
-        session_id = os.environ.get("CLAUDE_SESSION_ID", "unknown")
-        project_path = (
+        from superlocalmemory.mcp.session_binding import resolve_session_id
+        effective_session_id = resolve_session_id(
+            session_id, agent_id=agent_id or "mcp_client", allow_agent_fallback=True,
+        )
+        effective_project_path = project_path or (
             os.environ.get("CLAUDE_PROJECT_DIR")
             or os.environ.get("PROJECT_PATH")
             or os.getcwd()
@@ -86,15 +161,59 @@ def register_learning_tools(server, get_engine: Callable) -> None:
                 "(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,
+                (effective_session_id, engine.profile_id, effective_project_path, tool_name,
                  event_type, input_clean, output_clean, duration_ms, metadata, now),
             )
             authorization.complete()
-            return {"success": True, "tool": tool_name, "event": event_type}
+            return {"success": True, "tool": tool_name, "event": event_type,
+                    "session_id": effective_session_id}
         except Exception as exc:
             logger.debug("log_tool_event failed: %s", exc)
             return {"success": False, "error": str(exc)}
 
+    @server.tool()
+    @admits(OperationKind.REMEMBER)
+    async def settle_session_outcomes(
+        session_id: str, agent_id: str = "", finalize: bool = False,
+    ) -> dict:
+        """Settle pending recall outcomes for one exact host session.
+
+        Native hosts call this after each turn and at finalization. Per-turn
+        calls settle only recalls that have actual evidence; finalization also
+        clears evidence-free pending rows. The operation never treats a hook
+        boundary itself as feedback. ``session_id`` must be explicit.
+        """
+        if not session_id or not session_id.strip():
+            return {"success": False, "error": "session_id is required"}
+        engine = get_engine()
+        try:
+            authorization = authorize_mcp_mutation(
+                engine,
+                "update",
+                mutation_source="mcp-settle-session-outcomes",
+                profile_id=engine.profile_id,
+                content_preview=agent_id[:100],
+            )
+            from superlocalmemory.hooks._outcome_common import memory_db_path
+
+            result = await asyncio.to_thread(
+                settle_pending_session_outcomes,
+                memory_db_path(),
+                profile_id=engine.profile_id,
+                session_id=session_id,
+                evidence_only=not finalize,
+            )
+            authorization.complete()
+            return {
+                "success": True,
+                "session_id": session_id.strip(),
+                "agent_id": agent_id.strip(),
+                **result,
+            }
+        except Exception as exc:
+            logger.debug("settle_session_outcomes failed: %s", exc)
+            return {"success": False, "error": str(exc)}
+
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def get_assertions(
         min_confidence: float = 0.0,

package/src/superlocalmemory/storage/_migration_internals.py

@@ -165,6 +165,7 @@ from superlocalmemory.storage.migrations import (
     M047_fisher_vectors_are_stored_like_every_other_vector as _M047,
     M048_upcoming_holds_only_what_is_upcoming as _M048,
     M049_a_schema_version_marker_is_one_row as _M049,
+    M050_execution_learning_v2 as _M050,
 )
 
 # Emit under the runner's logger name so operational log filters that key on
@@ -223,6 +224,7 @@ _MODULES = {
     _M047.NAME: _M047,
     _M048.NAME: _M048,
     _M049.NAME: _M049,
+    _M050.NAME: _M050,
 }
 
 # Exact historical DDL fingerprints whose resulting schema is intentionally

package/src/superlocalmemory/storage/_schema_version.py

@@ -21,7 +21,7 @@ import sqlite3
 from pathlib import Path
 
 #: Highest schema_version this runner can write.  Matches the trailing serial of
-#: the latest migration (M049).  Increment when adding new migrations or
+#: the latest migration (M050).  Increment when adding new migrations or
 #: table-level breaking changes.
 #:
 #: This sat at 42 while M043, M044 and M045 shipped, so for three migrations the
@@ -44,7 +44,7 @@ from pathlib import Path
 #: be additive is a silent bad write.  Those are not comparable, and judging
 #: additivity per migration is exactly the judgement that let it fall three
 #: behind.
-SUPPORTED_SCHEMA_VERSION: int = 49
+SUPPORTED_SCHEMA_VERSION: int = 50
 
 
 class SchemaVersionError(RuntimeError):