superlocalmemory 4.0.1 → 4.0.2

package/src/superlocalmemory/core/recall_worker.py

@@ -63,6 +63,10 @@ def _handle_recall(
     query: str, limit: int, session_id: str = "", fast: bool = False,
     include_global: bool | None = None, include_shared: bool | None = None,
     window: str | None = None,
+    as_of: str | None = None,
+    known_as_of: str | None = None,
+    valid_at: str | None = None,
+    include_unknown: bool = False,
 ) -> dict:
     engine = _get_engine()
     # v3.6.15 multi-scope: None flags let engine.recall resolve the configured
@@ -72,6 +76,10 @@ def _handle_recall(
         query, limit=limit, session_id=session_id or None, fast=bool(fast),
         include_global=include_global, include_shared=include_shared,
         window=window or None,
+        as_of=as_of or None,
+        known_as_of=known_as_of or None,
+        valid_at=valid_at or None,
+        include_unknown=include_unknown,
     )
 
     # Batch-fetch original memory text for all results. Retrieval already
@@ -322,6 +330,10 @@ def _worker_main() -> None:
                     include_global=req.get("include_global"),
                     include_shared=req.get("include_shared"),
                     window=req.get("window"),
+                    as_of=req.get("as_of"),
+                    known_as_of=req.get("known_as_of"),
+                    valid_at=req.get("valid_at"),
+                    include_unknown=bool(req.get("include_unknown", False)),
                 )
                 _respond(result)
             elif cmd == "store":

package/src/superlocalmemory/core/worker_pool.py

@@ -71,6 +71,10 @@ class WorkerPool:
         include_global: bool | None = None,
         include_shared: bool | None = None,
         window: str | None = None,
+        as_of: str | None = None,
+        known_as_of: str | None = None,
+        valid_at: str | None = None,
+        include_unknown: bool = False,
     ) -> dict:
         """Run recall in worker subprocess. Returns result dict.
 
@@ -96,6 +100,14 @@ class WorkerPool:
             msg["include_shared"] = bool(include_shared)
         if window:
             msg["window"] = window
+        if as_of:
+            msg["as_of"] = as_of
+        if known_as_of:
+            msg["known_as_of"] = known_as_of
+        if valid_at:
+            msg["valid_at"] = valid_at
+        if include_unknown:
+            msg["include_unknown"] = True
         return self._send(msg)
 
     def store(self, content: str, metadata: dict | None = None) -> dict:

package/src/superlocalmemory/hooks/hook_handlers.py

@@ -200,6 +200,22 @@ def _apply_codex_session(payload: dict) -> str:
         # Shared handlers use this neutral lifecycle identity despite its
         # historical environment-variable name.  It is never sent to a host.
         os.environ["CLAUDE_SESSION_ID"] = session_id
+        # Presence is separate from memory correctness and is deliberately
+        # fail-open.  It lets the portable Living Brain show that Codex is
+        # genuinely active, rather than pretending an installed hook is a
+        # connected client.
+        try:
+            from superlocalmemory.hooks.session_registry import (
+                mark_active,
+                resolve_active_profile,
+            )
+            mark_active(
+                session_id,
+                agent_type="codex",
+                profile_id=resolve_active_profile(),
+            )
+        except Exception:
+            pass
     return project_dir
 
 

package/src/superlocalmemory/hooks/post_tool_outcome_hook.py

@@ -35,14 +35,13 @@ from pathlib import Path
 from superlocalmemory.hooks._outcome_common import (
     emit_empty_json,
     log_perf,
-    memory_db_path as _memory_db_path_fn,
-    now_ms,
-    open_memory_db,
     read_stdin_json,
     session_state_file,
     summarize_response,
 )
-
+from superlocalmemory.hooks._outcome_common import (
+    memory_db_path as _memory_db_path_fn,
+)
 
 _HOOK_NAME = "post_tool_outcome"
 
@@ -98,8 +97,15 @@ def _inner_main() -> str:
     # S9-DASH-10: keep registry fresh on every PostToolUse so the MCP
     # server can pick up the current session even mid-turn.
     try:
-        from superlocalmemory.hooks.session_registry import mark_active
-        mark_active(session_id, agent_type="claude")
+        from superlocalmemory.hooks.session_registry import (
+            mark_active,
+            resolve_active_profile,
+        )
+        mark_active(
+            session_id,
+            agent_type="claude",
+            profile_id=resolve_active_profile(),
+        )
     except Exception:
         pass
 

package/src/superlocalmemory/hooks/session_registry.py

@@ -20,8 +20,9 @@ lost (reaper finalizes everything at neutral 0.5).
 
 **Fix (this module).** A simple file-based registry:
 
-* ``mark_active(session_id, agent_type)`` — called by hooks on every
-  prompt/tool event. Writes ``(session_id, agent_type, ts_ns, pid)``
+* ``mark_active(session_id, agent_type, profile_id)`` — called by hooks on
+  every prompt/tool event. Writes ``(session_id, agent_type, profile_id,
+  ts_ns, pid)``
   to ``~/.superlocalmemory/.active_sessions.json``.
 * ``most_recent_active(agent_type, within_seconds=60)`` — queries the
   registry for the most recently seen session of the named agent.
@@ -56,6 +57,20 @@ logger = logging.getLogger(__name__)
 
 _PRUNE_AFTER_SEC = 3600  # 1h — anything older is dead
 
+# Keep the public host vocabulary small and stable.  Callers can still use an
+# unknown value internally, but the Living Brain must not turn arbitrary hook
+# input into a new UI label or expose a host identifier verbatim.
+_PUBLIC_CLIENT_KINDS = {
+    "claude": "claude_code",
+    "claude_code": "claude_code",
+    "codex": "codex",
+    "cursor": "cursor",
+    "antigravity": "antigravity",
+    "copilot": "copilot",
+    "cli": "cli",
+    "mcp": "mcp",
+}
+
 
 def _registry_file() -> Path:
     from superlocalmemory.infra.data_root import state_path
@@ -63,6 +78,70 @@ def _registry_file() -> Path:
     return state_path(".active_sessions.json")
 
 
+def _profiles_file() -> Path:
+    """Return the profile cache updated atomically by daemon switches."""
+    from superlocalmemory.infra.data_root import state_path
+
+    return state_path("profiles.json")
+
+
+def resolve_active_profile() -> str | None:
+    """Read the canonical active profile without relying on host env wiring.
+
+    Hooks are separate host processes, so daemon-managed profile changes are
+    not reliably reflected in their environment.  The profile runtime writes
+    this compatibility cache atomically on every successful switch; using it
+    keeps ephemeral presence scoped like the durable memory stores.
+    """
+    try:
+        payload = json.loads(_profiles_file().read_text(encoding="utf-8"))
+        if not isinstance(payload, dict):
+            return None
+        modern_pointer = payload.get("active_profile")
+        legacy_pointer = payload.get("active")
+        pointer = (
+            modern_pointer.strip()
+            if isinstance(modern_pointer, str) and modern_pointer.strip()
+            else legacy_pointer.strip()
+            if isinstance(legacy_pointer, str) and legacy_pointer.strip()
+            else None
+        )
+        if pointer is None:
+            return None
+        profiles = payload.get("profiles")
+        catalog_present = "profiles" in payload
+        entries = []
+        if isinstance(profiles, list):
+            entries = [(None, profile) for profile in profiles]
+        elif isinstance(profiles, dict):
+            entries = list(profiles.items())
+        canonical: list[tuple[str, str | None]] = []
+        for key, profile in entries:
+            if not isinstance(profile, dict):
+                continue
+            profile_id = profile.get("profile_id")
+            if not isinstance(profile_id, str) or not profile_id.strip():
+                profile_id = key if isinstance(key, str) and key.strip() else None
+            name = profile.get("name")
+            if isinstance(profile_id, str) and profile_id.strip():
+                canonical.append((profile_id.strip(), name if isinstance(name, str) else None))
+        id_matches = {profile_id for profile_id, _name in canonical if profile_id == pointer}
+        if len(id_matches) == 1:
+            return id_matches.pop()
+        name_matches = {profile_id for profile_id, name in canonical if name == pointer}
+        if len(name_matches) == 1:
+            return name_matches.pop()
+        # The current runtime writes an ``active_profile`` ID even when its
+        # catalog has not been materialized yet. With no catalog at all it is
+        # the only available authority; a partially present catalog instead
+        # fails closed to avoid treating an unmapped display name as an ID.
+        if not catalog_present and isinstance(modern_pointer, str) and modern_pointer.strip():
+            return modern_pointer.strip()
+    except (OSError, TypeError, ValueError):
+        pass
+    return None
+
+
 def _now_ns() -> int:
     return time.time_ns()
 
@@ -105,6 +184,7 @@ def _prune(data: dict) -> dict:
 def mark_active(
     session_id: str,
     agent_type: str = "claude",
+    profile_id: str | None = None,
 ) -> None:
     """Record ``session_id`` keyed by the CALLING process PID.
 
@@ -122,11 +202,14 @@ def mark_active(
     try:
         data = _load()
         key = str(os.getpid())  # the IDE / hook process PID
-        data[key] = {
+        row = {
             "session_id": session_id,
             "agent_type": agent_type or "unknown",
             "ts_ns": _now_ns(),
         }
+        if isinstance(profile_id, str) and profile_id.strip():
+            row["profile_id"] = profile_id.strip()
+        data[key] = row
         data = _prune(data)
         _save(data)
     except Exception as exc:  # pragma: no cover — defensive
@@ -189,6 +272,56 @@ def most_recent_active(
         return None
 
 
+def active_client_summary(
+    profile_id: str | None = None,
+    within_seconds: int = 60,
+) -> list[dict[str, object]]:
+    """Return privacy-safe, recently active hosts for the Living Brain.
+
+    This is deliberately a *presence* signal, not durable product analytics:
+    registry entries expire within an hour and session identifiers never leave
+    the local registry.  The dashboard therefore distinguishes these active
+    clients from configured adapters, which only prove installation.
+    """
+    # Compatibility-safe default for any out-of-tree caller that used the
+    # original no-argument helper: no profile means no visibility, never a
+    # silent cross-profile aggregate.
+    if not profile_id:
+        return []
+    try:
+        cutoff_ns = _now_ns() - (max(0, int(within_seconds)) * 1_000_000_000)
+        newest_by_kind: dict[str, int] = {}
+        for row in _load().values():
+            if not isinstance(row, dict):
+                continue
+            # Entries written before profile attribution are intentionally
+            # invisible here: guessing a profile would leak client metadata.
+            if str(row.get("profile_id", "")) != profile_id:
+                continue
+            try:
+                ts_ns = int(row.get("ts_ns", 0))
+            except (TypeError, ValueError):
+                continue
+            if ts_ns < cutoff_ns:
+                continue
+            raw_kind = str(row.get("agent_type", "")).strip().lower()
+            kind = _PUBLIC_CLIENT_KINDS.get(raw_kind, "other")
+            newest_by_kind[kind] = max(newest_by_kind.get(kind, 0), ts_ns)
+        now_ns = _now_ns()
+        return [
+            {
+                "kind": kind,
+                "active": True,
+                "last_seen_seconds_ago": max(0, int((now_ns - ts_ns) / 1_000_000_000)),
+                "source": "session_registry",
+                "is_real": True,
+            }
+            for kind, ts_ns in sorted(newest_by_kind.items())
+        ]
+    except Exception:
+        return []
+
+
 def _reset_for_testing() -> None:
     """TEST-ONLY: wipe registry."""
     try:

package/src/superlocalmemory/hooks/user_prompt_hook.py

@@ -63,8 +63,15 @@ def main() -> int:
     # the MCP protocol doesn't thread the session_id through tool
     # arguments. Fail-soft — never raises on the hot path.
     try:
-        from superlocalmemory.hooks.session_registry import mark_active
-        mark_active(session_id, agent_type="claude")
+        from superlocalmemory.hooks.session_registry import (
+            mark_active,
+            resolve_active_profile,
+        )
+        mark_active(
+            session_id,
+            agent_type="claude",
+            profile_id=resolve_active_profile(),
+        )
     except Exception:
         pass
 

package/src/superlocalmemory/integrations/__init__.py

@@ -0,0 +1 @@
+"""Stable optional integration boundaries for external agent runtimes."""

package/src/superlocalmemory/integrations/bounded_loops_v051.py

@@ -0,0 +1,236 @@
+"""Read-only public-CLI adapter for bounded-loops v0.5.1 graph receipts.
+
+SLM deliberately neither imports bounded-loops nor reimplements its event-log
+grammar.  The optional, installed ``bl`` executable is the versioned protocol
+port: its public ``graph status`` command reconstructs and validates a graph
+receipt before SLM accepts the resulting projection.
+
+v0.5.1's local receipt is explicitly unverified.  Consequently every result
+from this adapter is display/observation evidence only; it cannot promote a
+memory, alter learning, or assert execution authority.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import selectors
+import shutil
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+class BoundedLoopsReceiptError(ValueError):
+    """Raised when a bounded-loops v0.5.1 receipt cannot be safely observed."""
+
+
+_VERSION = "0.5.1"
+_TIMEOUT_SECONDS = 15
+_MAX_OUTPUT_BYTES = 2 * 1024 * 1024
+_TERMINAL_STATES = frozenset({"SUCCEEDED", "FAILED", "CANCELLED"})
+
+
+@dataclass(frozen=True)
+class VerifiedBoundedLoopsReceipt:
+    """A normalized, non-promotable projection of a local v0.5.1 receipt."""
+
+    organization_id: str
+    project_id: str
+    run_id: str
+    terminal_status: str
+    receipt_digest: str
+    artifact_digests: tuple[str, ...]
+    event_count: int
+    demonstration: bool
+    trust_level: str = "local_unverified"
+    eligible_for_learning: bool = False
+
+
+def verify_v051_graph_receipt(
+    run_dir: str | Path,
+    *,
+    bl_executable: str | Path | None = None,
+) -> VerifiedBoundedLoopsReceipt:
+    """Read a v0.5.1 graph run validated by the bounded-loops public CLI.
+
+    ``run_dir`` must be an existing local directory, not a symlink.  The
+    executable is discovered from the local environment or supplied as an
+    absolute path for an explicitly configured integration.  Arguments are
+    always passed as an argv list, never through a shell.
+    """
+    directory = _safe_run_directory(run_dir)
+    executable = _resolve_v051_executable(bl_executable)
+    status = _command_json(executable, "graph", "status", "--run", str(directory), "--json")
+    return _normalize_projection(status)
+
+
+def _safe_run_directory(run_dir: str | Path) -> Path:
+    supplied = Path(run_dir)
+    if not supplied.is_absolute():
+        raise BoundedLoopsReceiptError("run directory must be an absolute path")
+    try:
+        directory = supplied.resolve(strict=True)
+    except OSError as exc:
+        raise BoundedLoopsReceiptError("run directory is unavailable") from exc
+    if supplied.is_symlink() or not directory.is_dir():
+        raise BoundedLoopsReceiptError("run directory must be a real directory")
+    return directory
+
+
+def _resolve_v051_executable(configured: str | Path | None) -> str:
+    if configured is None:
+        discovered = shutil.which("bl")
+        if discovered is None:
+            raise BoundedLoopsReceiptError("bounded-loops v0.5.1 is not installed")
+        executable = Path(discovered)
+    else:
+        executable = Path(configured)
+        if not executable.is_absolute():
+            raise BoundedLoopsReceiptError("configured bl executable must be an absolute path")
+    try:
+        resolved = executable.resolve(strict=True)
+    except OSError as exc:
+        raise BoundedLoopsReceiptError("configured bl executable is unavailable") from exc
+    if not resolved.is_file():
+        raise BoundedLoopsReceiptError("configured bl executable is not a file")
+    version = _run_command(str(resolved), "--version")
+    if version.strip() != f"bl {_VERSION}":
+        raise BoundedLoopsReceiptError("bounded-loops executable must be exactly v0.5.1")
+    return str(resolved)
+
+
+def _command_json(executable: str, *arguments: str) -> Any:
+    output = _run_command(executable, *arguments)
+    try:
+        return json.loads(output)
+    except json.JSONDecodeError as exc:
+        raise BoundedLoopsReceiptError("bounded-loops returned invalid JSON") from exc
+
+
+def _run_command(executable: str, *arguments: str) -> str:
+    try:
+        process = subprocess.Popen(
+            [executable, *arguments],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        stdout = _read_bounded_output(process)
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        raise BoundedLoopsReceiptError("bounded-loops command did not complete") from exc
+    if process.returncode != 0:
+        raise BoundedLoopsReceiptError("bounded-loops rejected the graph receipt")
+    try:
+        return stdout.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        raise BoundedLoopsReceiptError("bounded-loops response is not UTF-8") from exc
+
+
+def _read_bounded_output(process: subprocess.Popen[bytes]) -> bytes:
+    """Read both pipes incrementally and terminate output that exceeds the cap."""
+    if process.stdout is None or process.stderr is None:
+        raise BoundedLoopsReceiptError("bounded-loops command pipes are unavailable")
+    selector = selectors.DefaultSelector()
+    selector.register(process.stdout, selectors.EVENT_READ, data="stdout")
+    selector.register(process.stderr, selectors.EVENT_READ, data="stderr")
+    deadline = time.monotonic() + _TIMEOUT_SECONDS
+    stdout = bytearray()
+    total = 0
+    try:
+        while selector.get_map():
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                process.kill()
+                process.wait()
+                raise subprocess.TimeoutExpired(process.args, _TIMEOUT_SECONDS)
+            for key, _ in selector.select(remaining):
+                descriptor = (
+                    key.fileobj if isinstance(key.fileobj, int) else key.fileobj.fileno()
+                )
+                chunk = os.read(descriptor, 64 * 1024)
+                if not chunk:
+                    selector.unregister(key.fileobj)
+                    continue
+                total += len(chunk)
+                if total > _MAX_OUTPUT_BYTES:
+                    process.kill()
+                    process.wait()
+                    raise BoundedLoopsReceiptError(
+                        "bounded-loops response exceeds the import size limit"
+                    )
+                if key.data == "stdout":
+                    stdout.extend(chunk)
+        process.wait(timeout=max(0.001, deadline - time.monotonic()))
+    finally:
+        selector.close()
+        if process.poll() is None:
+            process.kill()
+            process.wait()
+    return bytes(stdout)
+
+
+def _normalize_projection(status: Any) -> VerifiedBoundedLoopsReceipt:
+    if not isinstance(status, dict):
+        raise BoundedLoopsReceiptError("bounded-loops response has an invalid shape")
+    required_strings = (
+        "organization_id", "project_id", "run_id", "run_state", "receipt_head_hash",
+    )
+    if any(not isinstance(status.get(name), str) or not status[name] for name in required_strings):
+        raise BoundedLoopsReceiptError("bounded-loops status lacks required receipt fields")
+    if status["run_state"] not in _TERMINAL_STATES:
+        raise BoundedLoopsReceiptError("bounded-loops receipt is not terminal")
+    if status.get("verified") is not False:
+        raise BoundedLoopsReceiptError("unexpected bounded-loops receipt verification state")
+    sequence = status.get("receipt_sequence")
+    if isinstance(sequence, bool) or not isinstance(sequence, int) or sequence < 1:
+        raise BoundedLoopsReceiptError("bounded-loops receipt sequence is invalid")
+    if not _is_hash(status["receipt_head_hash"]):
+        raise BoundedLoopsReceiptError("bounded-loops receipt digest is invalid")
+    artifact_digests = _projection_artifact_digests(status.get("nodes"))
+    demonstration = status.get("demonstration")
+    if not isinstance(demonstration, bool):
+        raise BoundedLoopsReceiptError("bounded-loops demonstration marker is invalid")
+    return VerifiedBoundedLoopsReceipt(
+        organization_id=status["organization_id"],
+        project_id=status["project_id"],
+        run_id=status["run_id"],
+        terminal_status=status["run_state"],
+        receipt_digest=f"sha256:{status['receipt_head_hash']}",
+        artifact_digests=artifact_digests,
+        event_count=sequence,
+        demonstration=demonstration,
+    )
+
+
+def _projection_artifact_digests(nodes: Any) -> tuple[str, ...]:
+    """Read only event-log-bound artifacts from the verified arena projection."""
+    if not isinstance(nodes, list):
+        raise BoundedLoopsReceiptError("bounded-loops status lacks node projections")
+    digests: set[str] = set()
+    for node in nodes:
+        if not isinstance(node, dict):
+            raise BoundedLoopsReceiptError("bounded-loops node projection is invalid")
+        raw_digests = node.get("artifact_digests")
+        if not isinstance(raw_digests, list) or not all(_is_digest(value) for value in raw_digests):
+            raise BoundedLoopsReceiptError("bounded-loops node artifact digests are invalid")
+        digests.update(raw_digests)
+    return tuple(sorted(digests))
+
+
+def _is_digest(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and value.startswith("sha256:")
+        and len(value) == 71
+        and all(character in "0123456789abcdef" for character in value[7:])
+    )
+
+
+def _is_hash(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and len(value) == 64
+        and all(character in "0123456789abcdef" for character in value)
+    )

package/src/superlocalmemory/learning/database.py

@@ -182,8 +182,7 @@ class LearningDatabase:
         conn = self._connect()
         try:
             row = conn.execute(
-                "SELECT COUNT(*) AS cnt FROM learning_signals "
-                "WHERE profile_id = ?",
+                "SELECT COUNT(*) AS cnt FROM learning_signals WHERE profile_id = ?",
                 (profile_id,),
             ).fetchone()
             return int(row["cnt"]) if row else 0
@@ -229,9 +228,7 @@ class LearningDatabase:
             finally:
                 conn.close()
 
-    def get_training_data(
-        self, profile_id: str, limit: int = 5000
-    ) -> list[dict[str, Any]]:
+    def get_training_data(self, profile_id: str, limit: int = 5000) -> list[dict[str, Any]]:
         """Retrieve labeled feature vectors for model training.
 
         Returns newest examples first.  Each dict contains:
@@ -292,8 +289,7 @@ class LearningDatabase:
         conn = self._connect()
         try:
             row = conn.execute(
-                "SELECT state_bytes FROM learning_model_state "
-                "WHERE profile_id = ?",
+                "SELECT state_bytes FROM learning_model_state WHERE profile_id = ?",
                 (profile_id,),
             ).fetchone()
             return bytes(row["state_bytes"]) if row else None
@@ -328,8 +324,7 @@ class LearningDatabase:
                 if existing:
                     new_value = float(existing["value"]) + value
                     conn.execute(
-                        "UPDATE engagement_metrics SET value = ?, updated_at = ? "
-                        "WHERE id = ?",
+                        "UPDATE engagement_metrics SET value = ?, updated_at = ? WHERE id = ?",
                         (new_value, self._now(), existing["id"]),
                     )
                 else:
@@ -357,8 +352,7 @@ class LearningDatabase:
         conn = self._connect()
         try:
             rows = conn.execute(
-                "SELECT metric_type, value FROM engagement_metrics "
-                "WHERE profile_id = ?",
+                "SELECT metric_type, value FROM engagement_metrics WHERE profile_id = ?",
                 (profile_id,),
             ).fetchall()
             return {row["metric_type"]: float(row["value"]) for row in rows}
@@ -378,8 +372,7 @@ class LearningDatabase:
         conn = self._connect()
         try:
             row = conn.execute(
-                "SELECT COUNT(*) AS cnt FROM learning_signals "
-                "WHERE profile_id = ?",
+                "SELECT COUNT(*) AS cnt FROM learning_signals WHERE profile_id = ?",
                 (profile_id,),
             ).fetchone()
             return int(row["cnt"]) if row else 0
@@ -580,7 +573,8 @@ class LearningDatabase:
             except sqlite3.Error as exc:
                 logger.warning(
                     "fetch_training_examples failed (m006=%s): %s",
-                    m006_applied, exc,
+                    m006_applied,
+                    exc,
                 )
                 return []
             out: list[dict] = []
@@ -602,6 +596,10 @@ class LearningDatabase:
             profile_id: If provided, only erase data for that profile.
                         If None, erase ALL learning data.
         """
+        if profile_id:
+            from superlocalmemory.storage.agent_experience import purge_profile_receipts
+
+            purge_profile_receipts(self._db_path, profile_id, close_profile=False)
         with self._lock:
             conn = self._connect()
             try:
@@ -611,6 +609,15 @@ class LearningDatabase:
                     "learning_model_state",
                     "engagement_metrics",
                 ]
+                receipt_tables = {
+                    row[0]
+                    for row in conn.execute(
+                        "SELECT name FROM sqlite_master WHERE type='table' "
+                        "AND name IN ('agent_experiences', 'cognitive_turn_receipts')"
+                    )
+                }
+                if profile_id is None:
+                    tables.extend(sorted(receipt_tables))
                 for table in tables:
                     if profile_id:
                         conn.execute(

package/src/superlocalmemory/mcp/_daemon_proxy.py

@@ -84,6 +84,9 @@ class DaemonPoolProxy:
         include_shared: bool | None = None,
         window: str | None = None,
         as_of: str | None = None,
+        known_as_of: str | None = None,
+        valid_at: str | None = None,
+        include_unknown: bool = False,
     ) -> dict[str, Any]:
         if self._unavailable:
             return self._unavailable_response()
@@ -108,6 +111,12 @@ class DaemonPoolProxy:
             _params["window"] = window
         if as_of:
             _params["as_of"] = as_of
+        if known_as_of:
+            _params["known_as_of"] = known_as_of
+        if valid_at:
+            _params["valid_at"] = valid_at
+        if include_unknown:
+            _params["include_unknown"] = "true"
         params = urllib.parse.urlencode(_params)
         try:
             from superlocalmemory.cli.daemon import daemon_request