superlocalmemory 4.0.7 → 4.0.9

package/src/superlocalmemory/integrations/bounded_loops_mcp.py

@@ -96,6 +96,29 @@ async def observe_terminal_runs(
     return observed
 
 
+def _assert_trusted_executable(executable: Path) -> None:
+    """Raise BridgeUnavailable if executable does not pass the bridge trust checks."""
+    try:
+        st = executable.stat()
+    except OSError as exc:
+        raise BridgeUnavailable("bounded-loops bridge path is unavailable") from exc
+    mode = st.st_mode
+    if not stat.S_ISREG(mode) or (
+        os.name != "nt" and mode & (stat.S_IWGRP | stat.S_IWOTH)
+    ):
+        raise BridgeUnavailable("bounded-loops executable is not a trusted regular file")
+    # Windows trust-check limitation: only S_ISREG applies on Windows.
+    # The mode-bit check above (group/other writable) and the uid/owner check
+    # below are both skipped because:
+    #   - Python's os.stat() on Windows returns emulated Unix-style mode bits
+    #     that do not reflect real ACL permissions; the check would be meaningless.
+    #   - os.geteuid() does not exist on Windows (AttributeError); st_uid is
+    #     always 0 there, so the ownership check cannot identify non-root owners.
+    # Proper Windows ownership verification requires Win32 ACL APIs (advapi32),
+    # which would introduce a heavy optional dependency.  Scoped for a future release.
+    if os.name != "nt" and st.st_uid not in {0, os.geteuid()}:
+        raise BridgeUnavailable("bounded-loops executable owner is not trusted")
+
 async def observe_from_stdio(*, command: str, cwd: str, profile_id: str) -> list[dict[str, Any]]:
     """Run one bounded, explicit MCP 2 observation; never call from recall or remember."""
     executable, workspace = Path(command), Path(cwd)
@@ -112,15 +135,9 @@ async def observe_from_stdio(*, command: str, cwd: str, profile_id: str) -> list
     try:
         executable = executable.resolve(strict=True)
         workspace = workspace.resolve(strict=True)
-        mode = executable.stat().st_mode
     except OSError as exc:
         raise BridgeUnavailable("bounded-loops bridge path is unavailable") from exc
-    if not stat.S_ISREG(mode) or (
-        os.name != "nt" and mode & (stat.S_IWGRP | stat.S_IWOTH)
-    ):
-        raise BridgeUnavailable("bounded-loops executable is not a trusted regular file")
-    if executable.stat().st_uid not in {0, os.geteuid()}:
-        raise BridgeUnavailable("bounded-loops executable owner is not trusted")
+    _assert_trusted_executable(executable)
 
     from mcp import ClientSession, StdioServerParameters
     from mcp.client.stdio import stdio_client

package/src/superlocalmemory/learning/arm_catalog.py

@@ -4,8 +4,6 @@
 
 """Static 40-arm catalog for the contextual Thompson bandit.
 
-LLD reference: ``.backup/active-brain/lld/LLD-03-contextual-bandit-and-ensemble.md``
-Section 5.1 — arm = (semantic, bm25, entity_graph, temporal,
 cross_encoder_bias) weight bundle drawn from a 7-point canonical grid.
 
 Pure-data module — zero imports from the rest of the codebase. Audit-friendly

package/src/superlocalmemory/learning/bandit.py

@@ -4,8 +4,6 @@
 
 """Contextual Thompson-sampling bandit over discrete channel-weight arms.
 
-LLD reference: ``.backup/active-brain/lld/LLD-03-contextual-bandit-and-ensemble.md``
-Sections 3 (algorithm), 5.3 (file spec), 8 (hard rules).
 
 Schema: ``bandit_arms`` + ``bandit_plays`` live in ``learning.db``, created by
 LLD-07 M005. This module NEVER defines DDL — it only READs / WRITEs.

package/src/superlocalmemory/learning/bandit_cache.py

@@ -4,8 +4,6 @@
 
 """Per-(profile, stratum) posterior LRU cache for the contextual bandit.
 
-LLD reference: ``.backup/active-brain/lld/LLD-03-contextual-bandit-and-ensemble.md``
-Section 5.2.
 
 Key design:
   - Loader runs OUTSIDE the lock so DB reads never serialise across strata.

package/src/superlocalmemory/learning/dedup_hnsw.py

@@ -28,6 +28,7 @@ from pathlib import Path
 from typing import Any, Iterable, Sequence
 
 from superlocalmemory.core.ram_lock import ram_reservation
+from superlocalmemory.storage.embedding_codec import decode_embedding
 
 logger = logging.getLogger(__name__)
 
@@ -71,19 +72,18 @@ __all__ = (
 )
 
 
-def _parse_embedding(raw: str | None) -> list[float] | None:
+def _parse_embedding(raw: bytes | str | None) -> list[float] | None:
+    """Parse an embedding from either TEXT (JSON) or BLOB (binary float32).
+
+    Returns None only when the embedding is genuinely absent (None or empty).
+    Raises ValueError for malformed data so callers can distinguish absence
+    from corruption.
+    """
     if not raw:
         return None
-    try:
-        vec = json.loads(raw)
-    except (TypeError, ValueError):
-        return None
-    if not isinstance(vec, list) or not vec:
-        return None
-    try:
-        return [float(x) for x in vec]
-    except (TypeError, ValueError):
-        return None
+    # decode_embedding raises ValueError for corrupt data; callers that want
+    # to skip a bad fact should catch ValueError explicitly, not silently.
+    return decode_embedding(raw)
 
 
 # L-P-01: vectorise ``_cosine`` via NumPy when available. NumPy cold

package/src/superlocalmemory/learning/ensemble.py

@@ -4,8 +4,6 @@
 
 """Bandit / LightGBM ensemble blender.
 
-LLD reference: ``.backup/active-brain/lld/LLD-03-contextual-bandit-and-ensemble.md``
-Section 5.4.
 
 D8 blend policy (``choose_ensemble``):
   - 0..199 signals OR model is None → ``EnsembleWeights(1.0, 0.0)`` (bandit-only).

package/src/superlocalmemory/learning/labeler.py

@@ -4,8 +4,6 @@
 
 """Integer-label mapping for LightGBM ``lambdarank`` training.
 
-LLD reference: ``.backup/active-brain/lld/LLD-02-signal-pipeline-and-lightgbm.md``
-Section 4.7 — single source of truth for outcome-reward / position → int label.
 
 Rules:
     - Labels are integers in ``[0, 4]`` (5 relevance tiers).

package/src/superlocalmemory/learning/legacy_migration.py

@@ -4,8 +4,6 @@
 
 """Legacy ``learning_feedback`` row migration — data movement only.
 
-LLD reference: ``.backup/active-brain/lld/LLD-07-schema-migrations-and-security-primitives.md``
-Section 5 (Legacy learning_feedback Migration).
 
 Hard rule H15 (LLD-06 §10): this module MUST NOT contain any schema
 DDL. All schema definitions live in

package/src/superlocalmemory/learning/model_cache.py

@@ -4,8 +4,6 @@
 
 """Active-model cache + integrity verification.
 
-LLD reference: ``.backup/active-brain/lld/LLD-02-signal-pipeline-and-lightgbm.md``
-Section 4.4 — every model load goes through here.
 
 Hard rules enforced:
     M1 — ``pickle.loads`` is FORBIDDEN on ``state_bytes``.

package/src/superlocalmemory/learning/pattern_miner.py

@@ -367,18 +367,23 @@ def _mine_channel_and_coretrieval(
                 gen += 1
 
         try:
+            # Column names must match learning.db: the table is
+            # (fact_id_a, fact_id_b, co_count). This query asked for
+            # (fact_a, fact_b, co_access_count) and therefore raised
+            # sqlite3.OperationalError on every run since it was written —
+            # caught below, logged at WARNING, and otherwise invisible. Net
+            # effect: 912 co-retrieval edges on a real store never produced a
+            # single pattern, and the Brain pane had one fewer signal with no
+            # indication anything was missing.
             coret_rows = learn_conn.execute(
-                "SELECT fact_a, fact_b, co_access_count "
+                "SELECT fact_id_a, fact_id_b, co_count "
                 "FROM co_retrieval_edges "
-                "WHERE profile_id = ? AND co_access_count >= 3 "
-                "ORDER BY co_access_count DESC LIMIT 20",
+                "WHERE profile_id = ? AND co_count >= 3 "
+                "ORDER BY co_count DESC LIMIT 20",
                 (profile_id,),
             ).fetchall()
             if coret_rows and not dry_run:
-                top_pair = (
-                    dict(coret_rows[0]).get("co_access_count", 0)
-                    if coret_rows else 0
-                )
+                top_pair = dict(coret_rows[0]).get("co_count", 0)
                 store.record_pattern(
                     profile_id=profile_id,
                     pattern_type="co_retrieval_clusters",

package/src/superlocalmemory/learning/ranker.py

@@ -4,8 +4,6 @@
 
 """3-phase adaptive ranker — from heuristic to ML.
 
-LLD reference: ``.backup/active-brain/lld/LLD-02-signal-pipeline-and-lightgbm.md``
-Sections 4.4 + 4.5.
 
 Phase 1: cross-encoder score only (cold start)
 Phase 2: heuristic boosts (some data)

package/src/superlocalmemory/learning/reward_archive.py

@@ -34,6 +34,7 @@ from pathlib import Path
 from superlocalmemory.learning.fact_outcome_joins import (
     has_recent_positive_reward,
 )
+from superlocalmemory.storage.embedding_codec import decode_embedding
 from superlocalmemory.storage.write_lock import get_write_lock
 
 logger = logging.getLogger(__name__)
@@ -113,13 +114,17 @@ def run_reward_gated_archive(
                 window_days=REWARD_WINDOW_DAYS,
             ):
                 continue
+            # Decode the embedding to list[float] so json.dumps(payload)
+            # succeeds regardless of whether the row is TEXT or BLOB.
+            # ValueError (corrupt buffer) propagates — a silent None here
+            # would archive a fact with a missing embedding, which loses data.
             to_archive.append({
                 "fid": fid,
                 "content": row["content"],
                 "canonical_entities_json": row["canonical_entities_json"],
                 "importance": row["importance"],
                 "confidence": row["confidence"],
-                "embedding": row["embedding"],
+                "embedding": decode_embedding(row["embedding"], fact_id=fid),
                 "created_at": row["created_at"],
             })
     finally:

package/src/superlocalmemory/learning/reward_proxy.py

@@ -4,8 +4,6 @@
 
 """Proxy settlement for bandit plays (v3.4.22 only).
 
-LLD reference: ``.backup/active-brain/lld/LLD-03-contextual-bandit-and-ensemble.md``
-Section 3.5 and 5.6.
 
 Replaced in v3.4.22 by ``reward_from_outcomes.py`` — DO NOT extend this
 module beyond the proxy window contract.

package/src/superlocalmemory/learning/signal_worker.py

@@ -4,8 +4,6 @@
 
 """Background signal drain worker.
 
-LLD reference: ``.backup/active-brain/lld/LLD-02-signal-pipeline-and-lightgbm.md``
-Section 4.2 — moves signal writes off the recall hot path.
 
 Contract (hard rules, enforced by tests):
     SW1 — Hot path never waits for disk.

package/src/superlocalmemory/math/fisher.py

@@ -19,7 +19,7 @@ Geodesic distance (Atkinson & Mitchell 1981, Pinele et al. 2020):
     Diagonal multivariate (product-manifold decomposition):
         d_FR(p, q) = sqrt( sum_i  d_i^2 )
 
-Bayesian variance update (NEW in Innovation Wave 4):
+Bayesian variance update (added in v3.5):
 
     V1 bug: query always received UNIFORM variance, so Fisher degenerated
     to a monotonic transform of cosine.  FIX: every fact maintains its own

package/src/superlocalmemory/math/hopfield.py

@@ -56,7 +56,10 @@ class HopfieldConfig:
     max_iterations: int = 1
     convergence_epsilon: float = 1e-6
     prefilter_threshold: int = 10_000
-    prefilter_candidates: int = 1000
+    # MUST match HopfieldConfig.prefilter_candidates in core/config.py, where the
+    # reasoning for the value is written. This stage decides final membership, so
+    # this number is a hard limit on which memories can be returned at all.
+    prefilter_candidates: int = 500
     skip_threshold: int = 100_000
     cache_ttl_seconds: float = 60.0
 

package/src/superlocalmemory/math/langevin.py

@@ -26,7 +26,7 @@ Potential function:
     - Old / unused:       gamma term raises potential -> drift to boundary
     - Important memories: delta term lowers potential -> retain near origin
 
-V1 bugs fixed in Innovation Wave 4:
+V1 bugs fixed in v3.5:
     1. Positions were computed per-recall then DISCARDED.  Now ``step()``
        and ``batch_step()`` return new positions for the caller to persist.
     2. Weight range was [0.7, 1.0] --- too narrow to change rankings.

package/src/superlocalmemory/math/sheaf.py

@@ -24,6 +24,8 @@ from typing import TYPE_CHECKING
 
 import numpy as np
 
+from superlocalmemory.storage.embedding_codec import decode_embedding
+
 if TYPE_CHECKING:
     from superlocalmemory.storage.database import DatabaseManager
     from superlocalmemory.storage.models import AtomicFact
@@ -251,7 +253,9 @@ class SheafConsistencyChecker:
         if raw is None or raw == "":
             return None
         try:
-            data = json.loads(raw) if isinstance(raw, str) else raw
-            return np.asarray(data, dtype=np.float64)
-        except (json.JSONDecodeError, TypeError, ValueError):
+            data = decode_embedding(raw, fact_id=str(fact_id))
+        except ValueError:
+            return None
+        if data is None:
             return None
+        return np.asarray(data, dtype=np.float64)

package/src/superlocalmemory/mcp/cli_fallback.py

@@ -1,6 +1,6 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
 # Licensed under AGPL-3.0-or-later - see LICENSE file
-# WP-09: MCP→CLI fallback adapter (ships INERT — DQ-2=B)
+# MCP→CLI fallback adapter (ships inert — disabled by default, no active use yet)
 
 """MCP→CLI fallback adapter for SuperLocalMemory.
 

package/src/superlocalmemory/mcp/profiles.py

@@ -14,16 +14,20 @@ Do NOT import FastMCP, MemoryEngine, or any heavy dependency here.
 from __future__ import annotations
 
 # ---------------------------------------------------------------------------
-# v3.6.14 WP-01: Named profile definitions
+# Named profile definitions (introduced in v3.6.14)
 # ---------------------------------------------------------------------------
 
-_PROFILE_CORE: frozenset[str] = frozenset({  # 16
+_PROFILE_CORE: frozenset[str] = frozenset({  # 17
     "remember", "recall", "search", "fetch", "list_recent", "update_memory", "forget",
     "session_init", "close_session",
     "slm_compress", "slm_retrieve", "slm_cache_set", "slm_cache_get", "slm_optimize_stats",
     # A client that can propose a correction must be able to inspect and
     # authenticate its review; otherwise the core lifecycle is incomplete.
     "review_correction", "list_corrections",
+    # v4.0.8: the readable summary layer (issue #113). In CORE because the
+    # natural caller is the agent holding the conversation — an assistant
+    # asked "what did I work on yesterday" should not need a power profile.
+    "get_memory_summary",
 })
 
 # Portable Brain evidence must reach the coding-host profile shipped by the
@@ -34,7 +38,7 @@ _PROFILE_BRAIN: frozenset[str] = frozenset({
     "observe_bounded_loop_evidence",
 })
 
-_PROFILE_CODE: frozenset[str] = _PROFILE_CORE | _PROFILE_BRAIN | frozenset({  # 31
+_PROFILE_CODE: frozenset[str] = _PROFILE_CORE | _PROFILE_BRAIN | frozenset({  # 32
     "build_code_graph", "get_blast_radius", "query_graph",
     "semantic_search_code", "get_review_context", "detect_changes",
     # switch_profile lets a plugin/IDE session change the active workspace over
@@ -64,8 +68,11 @@ _PROFILE_FULL: frozenset[str] = frozenset({
     "slm_compress", "slm_retrieve", "slm_cache_set", "slm_cache_get", "slm_optimize_stats",
     # v3.8.0: bounded-loop tools (CLI + /slm-loop command + MCP).
     "slm_loop_run", "slm_loop_history", "slm_loop_show",
+    # v4.0.8: readable summaries (#113). In core, so it must be in full too —
+    # full is asserted to be a superset of core.
+    "get_memory_summary",
     # prestage_context remains registered but deliberately raw-server-only.
-}) | _PROFILE_FULL_MESH  # 49
+}) | _PROFILE_FULL_MESH  # 50
 
 _PROFILE_POWER: frozenset[str] = _PROFILE_FULL | frozenset({  # 61
     "get_version", "get_mode", "health", "consistency_check", "recall_trace",

package/src/superlocalmemory/mcp/server.py

@@ -105,6 +105,11 @@ _ESSENTIAL_TOOLS: set[str] = {
     "observe_bounded_loop_evidence",
     # Update, review, and list form one core correction lifecycle.
     "review_correction", "list_corrections",
+    # v4.0.8 (#113): readable summaries. Present here as well as in the named
+    # profiles because this set is the FALLBACK surface — it must mirror
+    # ``full``, and a tool that ships in the smallest profile ("core") cannot be
+    # missing from the fallback without a client silently losing it.
+    "get_memory_summary",
     # Memory management (2)
     "forget", "run_maintenance",
     # NOTE: prestage_context IS registered (see register_prestage_tool below)
@@ -154,7 +159,7 @@ _all_tools = _os_reg.environ.get("SLM_MCP_ALL_TOOLS") == "1"
 _user_allowlist_str = _os_reg.environ.get("SLM_MCP_TOOLS", "").strip()
 
 # ---------------------------------------------------------------------------
-# v3.6.14 WP-01: Named profile definitions
+# Named profile definitions (introduced in v3.6.14)
 # Extracted to mcp/profiles.py (v3.8.0) — pure data, no side effects.
 # All names re-exported here for backward compatibility with existing tests
 # and any code that imports them from this module.
@@ -280,6 +285,8 @@ from superlocalmemory.mcp.tools_ops import register_ops_tools
 register_ops_tools(_target, get_engine)  # Wave-3: operational recovery & admin remediation
 from superlocalmemory.mcp.tools_brain import register_brain_tools
 register_brain_tools(_target, get_engine)  # v4.0.2 portable Brain receipts
+from superlocalmemory.mcp.tools_summaries import register_summary_tools
+register_summary_tools(_target, get_engine)  # v4.0.8 issue #113 summary reads
 from superlocalmemory.mcp.tools_context import register_prestage_tool
 
 

package/src/superlocalmemory/mcp/tools_active.py

@@ -255,6 +255,56 @@ def _canonical_feedback_count(profile_id: str) -> int | None:
         return None
 
 
+# How far ahead a session looks for scheduled facts, and how many it shows.
+# A session preamble is not a calendar: a long horizon or a large cap turns a
+# useful heads-up into a wall of text nobody reads.
+_SCHEDULED_HORIZON_DAYS = 14
+_SCHEDULED_LIMIT = 5
+
+
+def _upcoming_scheduled_facts(engine, now: datetime.datetime) -> list[dict]:
+    """Facts scheduled from today through the horizon, soonest first.
+
+    Bounded and index-backed, because this runs on every session start. Returns
+    an empty list on any failure: a session must still open when this query
+    cannot answer, so the caller omits the surface entirely rather than showing
+    an empty section that reads like a defect.
+
+    Selects on the stored type of the fact, which is a classification recorded at
+    write time. It is unrelated to the similarly named retrieval channel despite
+    sharing the word.
+    """
+    try:
+        db = getattr(engine, "_db", None) or getattr(engine, "db", None)
+        if db is None or not hasattr(db, "execute"):
+            return []
+        # Both 'YYYY-MM-DD' and full timestamps compare correctly as text,
+        # because ISO-8601 orders lexicographically. The upper bound is
+        # exclusive, so the horizon day itself is included.
+        start = now.date().isoformat()
+        end = (now + datetime.timedelta(days=_SCHEDULED_HORIZON_DAYS + 1)).date().isoformat()
+        rows = db.execute(
+            "SELECT fact_id, content, referenced_date"
+            " FROM atomic_facts"
+            " WHERE profile_id = ?"
+            "   AND fact_type = 'temporal'"
+            "   AND referenced_date IS NOT NULL"
+            "   AND referenced_date >= ?"
+            "   AND referenced_date < ?"
+            " ORDER BY referenced_date ASC"
+            f" LIMIT {_SCHEDULED_LIMIT}",
+            (engine.profile_id, start, end),
+        )
+        return [
+            {"fact_id": r["fact_id"], "content": r["content"],
+             "scheduled_at": r["referenced_date"]}
+            for r in rows
+        ]
+    except Exception as exc:
+        logger.warning("scheduled-fact surface failed: %s", exc)
+        return []
+
+
 def register_active_tools(server, get_engine: Callable) -> None:
     """Register 3 active memory tools on *server*."""
 
@@ -519,6 +569,8 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 f"-{uuid.uuid4().hex[:8]}"
             )
 
+            _upcoming_events = _upcoming_scheduled_facts(engine, _now)
+
             return {
                 "success": True,
                 "session_id": session_id,
@@ -553,6 +605,10 @@ def register_active_tools(server, get_engine: Callable) -> None:
                         else "trained"
                     ),
                 },
+                # Scheduled-event surface: present only when facts exist in the
+                # 14-day window. Absent means the window is empty, not an error.
+                **( {"upcoming_events": _upcoming_events}
+                    if _upcoming_events else {} ),
             }
         except Exception as exc:
             logger.exception("session_init failed")

package/src/superlocalmemory/mcp/tools_core.py

@@ -560,7 +560,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             if db_path.exists():
                 db_size_mb = round(os.path.getsize(db_path) / (1024 * 1024), 2)
 
-            # WP-02 D8: additive canonical key set — provider/base_dir/db_path added.
+            # additive canonical key set — provider/base_dir/db_path added.
             # All pre-existing keys are preserved (zero removals).
             cfg = engine._config
             return {

package/src/superlocalmemory/mcp/tools_summaries.py

@@ -0,0 +1,147 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory | https://qualixar.com
+
+"""MCP surface for the readable summary layer (issue #113).
+
+WHY THIS EXISTS
+---------------
+4.0.6 shipped the summary generators with no caller at all. 4.0.7 added
+``slm summary``, which fixed it for a person at a terminal and left agents with
+nothing — the changelog said the defect was "no command, tool or endpoint" and
+only the command was built. This is the tool half.
+
+It matters more than the CLI: the natural consumer of "what did I work on
+yesterday" is the agent holding the conversation, not a human running a command.
+
+CONTRACT
+--------
+Read-only, profile-scoped, and honest about coverage. Every response carries
+``coverage`` and ``source_fact_ids``, so a caller can tell a summary of 4% of a
+session from a summary of all of it, and can drill back to the memories it came
+from. Callers must not present a partial summary as complete; the field exists
+precisely so they do not have to guess.
+
+NOT ON THE HOT PATH. Summaries read memory.db directly and are invoked on
+demand; nothing here runs during remember or recall.
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import date, timedelta
+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.infra.data_root import state_path
+
+logger = logging.getLogger("superlocalmemory.mcp.summaries")
+
+#: Accepted values for the ``kind`` argument.
+_KINDS = ("day", "project", "session")
+
+
+def _result_payload(result: Any) -> dict[str, Any]:
+    """Shape a SummaryResult for the wire.
+
+    ``coverage`` and ``source_fact_ids`` are non-negotiable parts of the
+    response: a summary that cannot be traced back, or that hides how much it
+    covered, is the opaque generic summary issue #113 asked us not to build.
+    """
+    return {
+        "success": True,
+        "kind": result.kind,
+        "profile_id": result.profile_id,
+        "summary": result.content,
+        "coverage": result.coverage,
+        "generated_by": result.generated_by,
+        "source_fact_ids": result.source_fact_ids,
+        "source_count": len(result.source_fact_ids),
+        "metadata": result.metadata,
+    }
+
+
+def _error(message: str, **extra: Any) -> dict[str, Any]:
+    out = {"success": False, "error": message}
+    out.update(extra)
+    return out
+
+
+def register_summary_tools(server: Any, get_engine: Callable[[], Any]) -> None:
+    """Register the read-only summary tool."""
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
+    @admits(OperationKind.RECALL)
+    async def get_memory_summary(
+        kind: str = "day",
+        target: str = "",
+    ) -> dict[str, Any]:
+        """Summarise your memories: a day, a project, or one session.
+
+        Args:
+            kind: "day", "project", or "session".
+            target: For "day", an ISO date, "today" or "yesterday" (default
+                today). For "project", a directory path (default: none — supply
+                one). For "session", the session id.
+
+        Returns a summary plus ``coverage`` and ``source_fact_ids``. Coverage is
+        not decoration: session data is sparse — roughly 4% of facts carry a
+        session id — so a session summary is usually partial. Do not present a
+        partial summary as a complete record of what happened.
+
+        No language model is required; summaries are extractive unless the
+        profile runs a local or cloud model, in which case that writes them.
+        """
+        kind = (kind or "day").strip().lower()
+        if kind not in _KINDS:
+            return _error(
+                f"unknown summary kind {kind!r}; expected one of {', '.join(_KINDS)}"
+            )
+
+        engine = get_engine()
+        profile_id = getattr(engine, "profile_id", "default")
+        db_path = state_path("memory.db")
+        if not db_path.exists():
+            return _error("no memory database found", db_path=str(db_path))
+
+        # The engine's config drives Mode B/C enrichment. Passing None would
+        # silently force the extractive path for every caller regardless of
+        # mode — the exact bug the CLI shipped with in 4.0.7.
+        config = getattr(engine, "config", None)
+
+        try:
+            if kind == "day":
+                from superlocalmemory.summaries import generate_daily_reflection
+
+                day = (target or "").strip() or date.today().isoformat()
+                if day == "today":
+                    day = date.today().isoformat()
+                elif day == "yesterday":
+                    day = (date.today() - timedelta(days=1)).isoformat()
+                result = generate_daily_reflection(db_path, day, profile_id, config)
+
+            elif kind == "project":
+                from superlocalmemory.summaries import generate_project_work_log
+
+                if not (target or "").strip():
+                    return _error("kind='project' requires target=<project path>")
+                result = generate_project_work_log(
+                    db_path, target.strip(), profile_id, config,
+                )
+
+            else:  # session
+                from superlocalmemory.summaries import generate_session_summary
+
+                if not (target or "").strip():
+                    return _error("kind='session' requires target=<session id>")
+                result = generate_session_summary(
+                    db_path, target.strip(), profile_id, config,
+                )
+        except Exception as exc:
+            logger.warning("summary generation failed (%s/%s): %s", kind, target, exc)
+            return _error(f"summary generation failed: {exc}", kind=kind)
+
+        return _result_payload(result)

package/src/superlocalmemory/optimize/cache/manager.py

@@ -223,7 +223,7 @@ class CacheManager:
             tenant_id = _hashlib.sha256(tenant_id.encode()).hexdigest()
 
         if isinstance(req, ProxyRequest) and req.provider == "vertex":
-            # CRIT-2 (WP-11, LOCKED): Vertex bodies have NO model/messages/system.
+            # LOCKED: Vertex bodies have NO model/messages/system.
             # Model is in the PATH; prompts are under 'contents'; system under
             # 'systemInstruction'. Without this branch ALL Vertex requests hash to
             # ONE key → first response poisons every subsequent prompt.
@@ -701,7 +701,7 @@ def json_dumps_bytes(d: dict) -> bytes:
 
 
 # ---------------------------------------------------------------------------
-# Vertex helpers (WP-11 / CRIT-2)
+# Vertex helpers
 # ---------------------------------------------------------------------------
 
 def _vertex_project_location_from_path(path: str) -> tuple[str, str]:

package/src/superlocalmemory/optimize/compress/ccr.py

@@ -99,7 +99,7 @@ class CCRStore:
     def delete(self, ccr_id: str, *, tenant_id: str = "default") -> None:
         """Delete a CCR row by ccr_id scoped to tenant. Idempotent — never raises.
 
-        WP-10 D6: defensive infra. Deleting a non-existent ccr_id is a no-op.
+        Defensive delete — idempotent: deleting a non-existent ccr_id is a no-op.
         H-02: tenant_id guard prevents cross-tenant deletion.
         """
         try: