superlocalmemory 3.7.7 → 3.8.0

package/src/superlocalmemory/infra/event_bus.py

@@ -102,13 +102,20 @@ class EventBus:
         logger.info("EventBus initialized: db=%s", self.db_path)
 
     def _init_schema(self) -> None:
-        """Create the memory_events table if it does not exist."""
+        """Create the memory_events table if it does not exist.
+
+        Self-migrates a pre-isolation DB (memory_events without profile_id) so a
+        dashboard viewing profile A never sees profile B's events. This table is
+        store-owned (created here, not by the migration runner), so the store
+        owns its upgrade. Existing rows backfill to the 'default' profile.
+        """
         conn = sqlite3.connect(str(self.db_path))
         try:
             cur = conn.cursor()
             cur.execute("""
                 CREATE TABLE IF NOT EXISTS memory_events (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    profile_id TEXT NOT NULL DEFAULT 'default',
                     event_type TEXT NOT NULL,
                     memory_id INTEGER,
                     source_agent TEXT DEFAULT 'user',
@@ -119,13 +126,42 @@ class EventBus:
                     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                 )
             """)
+            existing = {r[1] for r in cur.execute(
+                "PRAGMA table_info(memory_events)").fetchall()}
+            if "profile_id" not in existing:
+                cur.execute(
+                    "ALTER TABLE memory_events "
+                    "ADD COLUMN profile_id TEXT NOT NULL DEFAULT 'default'"
+                )
             cur.execute("CREATE INDEX IF NOT EXISTS idx_events_type ON memory_events(event_type)")
             cur.execute("CREATE INDEX IF NOT EXISTS idx_events_created ON memory_events(created_at)")
             cur.execute("CREATE INDEX IF NOT EXISTS idx_events_tier ON memory_events(tier)")
+            cur.execute("CREATE INDEX IF NOT EXISTS idx_events_profile ON memory_events(profile_id, id)")
             conn.commit()
         finally:
             conn.close()
 
+    @staticmethod
+    def _resolve_profile(profile_id: Optional[str]) -> str:
+        """Resolve the active profile for an event when not passed explicitly.
+
+        Uses the request-runtime helper (ContextVar for HTTP, else the
+        profiles.json active_profile cache that every switch keeps in sync) so
+        MCP-in-daemon and CLI emits are attributed correctly too. Lazy import
+        keeps the infra layer free of a hard server dependency; any failure
+        falls back to 'default'.
+        """
+        if profile_id:
+            return profile_id
+        try:
+            from superlocalmemory.server.routes.helpers import get_active_profile
+            resolved = get_active_profile()
+            if resolved:
+                return resolved
+        except Exception:
+            pass
+        return "default"
+
     def emit(
         self,
         event_type: str,
@@ -134,8 +170,14 @@ class EventBus:
         source_agent: str = "user",
         source_protocol: str = "internal",
         importance: int = 5,
+        profile_id: Optional[str] = None,
     ) -> Optional[int]:
-        """Emit an event to all subscribers and persist to database."""
+        """Emit an event to all subscribers and persist to database.
+
+        ``profile_id`` scopes the event to a memory profile. When omitted it is
+        resolved from the active profile so a dashboard viewing one profile
+        never sees another profile's real-time or historical events.
+        """
         if event_type not in VALID_EVENT_TYPES:
             raise ValueError(
                 f"Invalid event type: {event_type}. "
@@ -143,6 +185,7 @@ class EventBus:
             )
 
         importance = max(1, min(10, importance))
+        profile_id = self._resolve_profile(profile_id)
 
         now = datetime.now(timezone.utc).isoformat()
         with self._counter_lock:
@@ -151,6 +194,7 @@ class EventBus:
 
         event: Dict[str, Any] = {
             "seq": seq,
+            "profile_id": profile_id,
             "event_type": event_type,
             "memory_id": memory_id,
             "source_agent": source_agent,
@@ -177,18 +221,24 @@ class EventBus:
             event_type, event_id, memory_id,
         )
 
-        # Auto-prune heuristic
-        self._write_count += 1
-        if (
-            self._write_count >= 100
-            or (datetime.now() - self._last_prune).total_seconds() > 86400
-        ):
+        # Auto-prune heuristic. Decide + reset the counter atomically under the
+        # lock so concurrent emit() calls cannot both cross the threshold and
+        # double-run the prune; run the prune itself OUTSIDE the lock.
+        should_prune = False
+        with self._counter_lock:
+            self._write_count += 1
+            if (
+                self._write_count >= 100
+                or (datetime.now() - self._last_prune).total_seconds() > 86400
+            ):
+                should_prune = True
+                self._write_count = 0
+                self._last_prune = datetime.now()
+        if should_prune:
             try:
                 self.prune_events()
             except Exception:
                 pass
-            self._write_count = 0
-            self._last_prune = datetime.now()
 
         return event_id
 
@@ -202,10 +252,12 @@ class EventBus:
             try:
                 cur = conn.cursor()
                 cur.execute(
-                    "INSERT INTO memory_events (event_type, memory_id, source_agent,"
-                    " source_protocol, payload, importance, tier, created_at)"
-                    " VALUES (?, ?, ?, ?, ?, ?, 'hot', ?)",
-                    (event["event_type"], event.get("memory_id"),
+                    "INSERT INTO memory_events (profile_id, event_type, memory_id,"
+                    " source_agent, source_protocol, payload, importance, tier,"
+                    " created_at)"
+                    " VALUES (?, ?, ?, ?, ?, ?, ?, 'hot', ?)",
+                    (event.get("profile_id", "default"), event["event_type"],
+                     event.get("memory_id"),
                      event["source_agent"], event["source_protocol"],
                      json.dumps(event["payload"]), event["importance"],
                      event["timestamp"]),
@@ -253,9 +305,16 @@ class EventBus:
         since_id: Optional[int] = None,
         limit: int = 50,
         event_type: Optional[str] = None,
+        profile_id: Optional[str] = None,
     ) -> List[dict]:
-        """Get recent events from the database."""
+        """Get recent events from the database, scoped to a profile.
+
+        ``profile_id`` defaults to the active profile so callers never leak
+        another profile's events. Pass ``profile_id="*"`` to bypass scoping
+        (internal maintenance/pruning only — never a client-facing path).
+        """
         limit = min(limit, 200)
+        scope = profile_id if profile_id == "*" else self._resolve_profile(profile_id)
 
         try:
             conn = sqlite3.connect(str(self.db_path))
@@ -263,10 +322,15 @@ class EventBus:
                 cur = conn.cursor()
 
                 query = ("SELECT id, event_type, memory_id, source_agent,"
-                         " source_protocol, payload, importance, tier, created_at"
+                         " source_protocol, payload, importance, tier, created_at,"
+                         " profile_id"
                          " FROM memory_events WHERE 1=1")
                 params: List[Any] = []
 
+                if scope != "*":
+                    query += " AND profile_id = ?"
+                    params.append(scope)
+
                 if since_id is not None:
                     query += " AND id > ?"
                     params.append(since_id)
@@ -293,7 +357,7 @@ class EventBus:
                     "id": row[0], "event_type": row[1], "memory_id": row[2],
                     "source_agent": row[3], "source_protocol": row[4],
                     "payload": parsed, "importance": row[6],
-                    "tier": row[7], "timestamp": row[8],
+                    "tier": row[7], "timestamp": row[8], "profile_id": row[9],
                 })
             return events
 
@@ -306,19 +370,32 @@ class EventBus:
         with self._buffer_lock:
             return [e for e in self._buffer if e.get("seq", 0) > since_seq]
 
-    def get_event_stats(self) -> dict:
-        """Get event system statistics."""
+    def get_event_stats(self, profile_id: Optional[str] = None) -> dict:
+        """Get event system statistics, scoped to a profile.
+
+        ``profile_id`` defaults to the active profile so dashboard event
+        counts never blend across profiles.
+        """
+        scope = self._resolve_profile(profile_id)
         try:
             conn = sqlite3.connect(str(self.db_path))
             try:
                 cur = conn.cursor()
 
-                total = cur.execute("SELECT COUNT(*) FROM memory_events").fetchone()[0]
-                cur.execute("SELECT event_type, COUNT(*) FROM memory_events GROUP BY event_type")
+                total = cur.execute(
+                    "SELECT COUNT(*) FROM memory_events WHERE profile_id = ?",
+                    (scope,)).fetchone()[0]
+                cur.execute(
+                    "SELECT event_type, COUNT(*) FROM memory_events "
+                    "WHERE profile_id = ? GROUP BY event_type", (scope,))
                 by_type = dict(cur.fetchall())
-                cur.execute("SELECT tier, COUNT(*) FROM memory_events GROUP BY tier")
+                cur.execute(
+                    "SELECT tier, COUNT(*) FROM memory_events "
+                    "WHERE profile_id = ? GROUP BY tier", (scope,))
                 by_tier = dict(cur.fetchall())
-                cur.execute("SELECT COUNT(*) FROM memory_events WHERE created_at >= datetime('now', '-24 hours')")
+                cur.execute(
+                    "SELECT COUNT(*) FROM memory_events WHERE profile_id = ? "
+                    "AND created_at >= datetime('now', '-24 hours')", (scope,))
                 last_24h = cur.fetchone()[0]
             finally:
                 conn.close()
@@ -343,7 +420,13 @@ class EventBus:
         warm_hours: int = DEFAULT_WARM_HOURS,
         cold_hours: int = DEFAULT_COLD_HOURS,
     ) -> dict:
-        """Apply tiered retention policy to persisted events."""
+        """Apply tiered retention policy to persisted events.
+
+        INTENTIONALLY GLOBAL (all profiles): this is age/tier-based housekeeping
+        of the shared event log, not a per-tenant read or retention-policy
+        surface. Tenant isolation of event CONTENT is enforced on read via the
+        profile_id filter; this sweep only demotes/expires old rows by age.
+        """
         try:
             conn = sqlite3.connect(str(self.db_path))
             try:

package/src/superlocalmemory/infra/rate_limiter.py

@@ -118,6 +118,22 @@ class RateLimiter:
                 del self._requests[k]
             return len(stale)
 
+    def configure(
+        self,
+        max_requests: int | None = None,
+        window_seconds: int | None = None,
+    ) -> None:
+        """Reconfigure limits at runtime (thread-safe).
+
+        Recorded request timestamps are preserved; only the ceilings change,
+        so a raised limit takes effect immediately for the current window.
+        """
+        with self._lock:
+            if max_requests is not None:
+                self.max_requests = max(1, int(max_requests))
+            if window_seconds is not None:
+                self.window = max(1, int(window_seconds))
+
     def get_stats(self) -> dict:
         """Return a snapshot of limiter state."""
         with self._lock:
@@ -133,3 +149,80 @@ class RateLimiter:
 # ---------------------------------------------------------------------------
 write_limiter = RateLimiter(max_requests=WRITE_LIMIT, window_seconds=WINDOW_SECONDS)
 read_limiter = RateLimiter(max_requests=READ_LIMIT, window_seconds=WINDOW_SECONDS)
+
+
+# ---------------------------------------------------------------------------
+# Runtime-configurable limits (task #47) — dashboard-editable thresholds.
+#
+# The enforcement middleware builds its own limiter instances; it registers
+# them here by role so a single set_limits() call reconfigures every live
+# limiter at once (no restart). Loopback limiters derive from write/read,
+# matching the startup derivation in unified_daemon.
+# ---------------------------------------------------------------------------
+
+_MANAGED: List[Tuple[str, "RateLimiter"]] = []
+_MANAGED_LOCK = threading.Lock()
+_CURRENT: Dict[str, int] = {
+    "write": WRITE_LIMIT, "read": READ_LIMIT, "window": WINDOW_SECONDS,
+}
+
+
+def _loopback_write(write: int) -> int:
+    return max(300, int(write) * 10)
+
+
+def _loopback_read(read: int) -> int:
+    return max(2000, int(read) * 20)
+
+
+def register_managed(role: str, limiter: "RateLimiter") -> None:
+    """Register an enforcement limiter so set_limits() can reconfigure it.
+
+    role is one of: 'write', 'read', 'lb_write', 'lb_read'.
+    """
+    with _MANAGED_LOCK:
+        _MANAGED.append((role, limiter))
+
+
+def reset_managed() -> None:
+    """Drop all registered limiters (app teardown / test isolation)."""
+    with _MANAGED_LOCK:
+        _MANAGED.clear()
+
+
+def get_limits() -> Dict[str, int]:
+    """Return the current effective write/read/window limits."""
+    with _MANAGED_LOCK:
+        return dict(_CURRENT)
+
+
+def set_limits(
+    write: int | None = None,
+    read: int | None = None,
+    window: int | None = None,
+) -> Dict[str, int]:
+    """Update limits and reconfigure every registered limiter live.
+
+    Partial updates are supported (pass only what changes). Loopback
+    limiters re-derive from the new write/read. Returns the new effective
+    limits. Values are floored at 1.
+    """
+    with _MANAGED_LOCK:
+        if write is not None:
+            _CURRENT["write"] = max(1, int(write))
+        if read is not None:
+            _CURRENT["read"] = max(1, int(read))
+        if window is not None:
+            _CURRENT["window"] = max(1, int(window))
+        w, r, win = _CURRENT["write"], _CURRENT["read"], _CURRENT["window"]
+        lb_w, lb_r = _loopback_write(w), _loopback_read(r)
+        for role, limiter in _MANAGED:
+            if role == "write":
+                limiter.configure(max_requests=w, window_seconds=win)
+            elif role == "read":
+                limiter.configure(max_requests=r, window_seconds=win)
+            elif role == "lb_write":
+                limiter.configure(max_requests=lb_w, window_seconds=win)
+            elif role == "lb_read":
+                limiter.configure(max_requests=lb_r, window_seconds=win)
+        return dict(_CURRENT)

package/src/superlocalmemory/ingestion/adapter_manager.py

@@ -175,7 +175,10 @@ def stop_adapter(name: str) -> dict:
         proc.terminate()
         proc.wait(timeout=10)
     except ImportError:
-        os.kill(pid, 15)  # SIGTERM
+        # No psutil: best-effort termination. On Windows os.kill(pid, 15) maps to
+        # TerminateProcess (a hard kill, not a graceful SIGTERM) — psutil's
+        # terminate() does the same there, so behavior is equivalent either way.
+        os.kill(pid, 15)
     except Exception:
         pass
 

package/src/superlocalmemory/ingestion/credentials.py

@@ -42,7 +42,7 @@ def store_credential(service: str, key: str, value: str) -> bool:
     except Exception:
         pass
 
-    # Fallback: encrypted file with restricted permissions
+    # Fallback: restricted-permission file (0600) when no OS keychain is present
     try:
         cred_dir = _credential_dir()
         cred_dir.mkdir(parents=True, exist_ok=True)

package/src/superlocalmemory/learning/cross_project.py

@@ -65,6 +65,7 @@ TECH_CATEGORIES: dict[str, list[str]] = {
 _SCHEMA = """
 CREATE TABLE IF NOT EXISTS transferable_patterns (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
+    profile_id TEXT NOT NULL DEFAULT 'default',
     pattern_type TEXT NOT NULL DEFAULT 'preference',
     key TEXT NOT NULL,
     value TEXT NOT NULL,
@@ -75,7 +76,7 @@ CREATE TABLE IF NOT EXISTS transferable_patterns (
     contradictions TEXT DEFAULT '[]',
     first_seen TEXT,
     last_seen TEXT,
-    UNIQUE(pattern_type, key)
+    UNIQUE(profile_id, pattern_type, key)
 );
 
 CREATE TABLE IF NOT EXISTS memories (
@@ -115,25 +116,29 @@ class CrossProjectAggregator:
         # Step 2: Merge with temporal decay
         merged = self._merge_with_decay(profile_patterns)
 
-        # Step 3: Detect contradictions
+        # Step 3: Detect contradictions (scoped to the target profile)
         for key, pattern_data in merged.items():
             pattern_data["contradictions"] = self._detect_contradictions(
-                key, pattern_data
+                key, pattern_data, target_profile
             )
 
-        # Step 4: Store and return
-        self._store_patterns(merged)
+        # Step 4: Store and return (scoped to the target profile)
+        self._store_patterns(merged, target_profile)
         return [{"key": k, **v} for k, v in merged.items()]
 
-    def get_preferences(self, min_confidence: float = 0.6) -> dict[str, dict]:
-        """Retrieve stored transferable preferences above *min_confidence*."""
+    def get_preferences(
+        self,
+        profile_id: str = "default",
+        min_confidence: float = 0.6,
+    ) -> dict[str, dict]:
+        """Retrieve stored transferable preferences for *profile_id* above *min_confidence*."""
         conn = sqlite3.connect(str(self._db_path))
         conn.row_factory = sqlite3.Row
         try:
             cur = conn.execute(
                 "SELECT * FROM transferable_patterns "
-                "WHERE confidence >= ? ORDER BY confidence DESC",
-                (min_confidence,),
+                "WHERE profile_id = ? AND confidence >= ? ORDER BY confidence DESC",
+                (profile_id, min_confidence),
             )
             result: dict[str, dict] = {}
             for row in cur.fetchall():
@@ -277,18 +282,18 @@ class CrossProjectAggregator:
         }
 
     def _detect_contradictions(
-        self, pattern_key: str, pattern_data: dict
+        self, pattern_key: str, pattern_data: dict, profile_id: str = "default"
     ) -> list[str]:
         contradictions: list[str] = []
 
-        # Check stored value vs new value
+        # Check stored value vs new value, scoped to this profile.
         conn = sqlite3.connect(str(self._db_path))
         conn.row_factory = sqlite3.Row
         try:
             cur = conn.execute(
                 "SELECT value, last_seen FROM transferable_patterns "
-                "WHERE key = ? AND pattern_type = 'preference'",
-                (pattern_key,),
+                "WHERE profile_id = ? AND key = ? AND pattern_type = 'preference'",
+                (profile_id, pattern_key),
             )
             row = cur.fetchone()
             if row:
@@ -316,18 +321,21 @@ class CrossProjectAggregator:
         finally:
             conn.close()
 
-    def _store_patterns(self, merged: dict[str, dict]) -> None:
+    def _store_patterns(
+        self, merged: dict[str, dict], profile_id: str = "default"
+    ) -> None:
+        """Persist merged patterns for *profile_id*. Each profile has isolated rows."""
         conn = sqlite3.connect(str(self._db_path))
         now = datetime.now(UTC).isoformat()
         try:
             for key, data in merged.items():
                 conn.execute(
                     """INSERT INTO transferable_patterns
-                       (pattern_type, key, value, confidence, evidence_count,
-                        profiles_seen, decay_factor, contradictions,
-                        first_seen, last_seen)
-                       VALUES ('preference', ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                       ON CONFLICT(pattern_type, key) DO UPDATE SET
+                       (profile_id, pattern_type, key, value, confidence,
+                        evidence_count, profiles_seen, decay_factor,
+                        contradictions, first_seen, last_seen)
+                       VALUES (?, 'preference', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                       ON CONFLICT(profile_id, pattern_type, key) DO UPDATE SET
                            value = excluded.value,
                            confidence = excluded.confidence,
                            evidence_count = excluded.evidence_count,
@@ -337,6 +345,7 @@ class CrossProjectAggregator:
                            last_seen = excluded.last_seen
                     """,
                     (
+                        profile_id,
                         key,
                         data["value"],
                         data["confidence"],

package/src/superlocalmemory/learning/reward_proxy.py

@@ -114,8 +114,14 @@ def _tool_event_hit(
     memory_conn: sqlite3.Connection,
     played_at: datetime,
     fact_ids: list[str],
+    profile_id: str | None = None,
 ) -> bool:
-    """True iff any tool_events row references any fact_id within +30 s."""
+    """True iff any tool_events row references any fact_id within +30 s.
+
+    Tenant-scoped: without a profile predicate, one tenant's reward signal
+    would be reinforced by another tenant's tool events firing in the same
+    30 s window — cross-contaminated behavioral learning.
+    """
     if not fact_ids:
         return False
     start = played_at.isoformat(timespec="seconds")
@@ -139,12 +145,24 @@ def _tool_event_hit(
     # in Python — typically 0-few rows in a 30 s window, far cheaper than
     # N LIKE passes against a growing table. Still O(rows_in_window * len(fact_ids))
     # worst case but the constant factor is tiny (a substring check).
+    # Add the profile predicate only when tool_events actually has the column
+    # (schema varies by install).
+    scope_sql, scope_params = "", ()
+    if profile_id is not None:
+        try:
+            cols = {r[1] for r in memory_conn.execute(
+                "PRAGMA table_info(tool_events)").fetchall()}
+            if "profile_id" in cols:
+                scope_sql = " AND profile_id = ?"
+                scope_params = (profile_id,)
+        except sqlite3.Error:
+            pass
     try:
         candidate_rows = memory_conn.execute(
             "SELECT payload_json FROM tool_events "
             "WHERE occurred_at BETWEEN ? AND ? "
-            "  AND payload_json IS NOT NULL",
-            (start, end),
+            "  AND payload_json IS NOT NULL" + scope_sql,
+            (start, end, *scope_params),
         ).fetchall()
     except sqlite3.Error:
         return False
@@ -165,6 +183,7 @@ def _requery_detected(
     memory_conn: sqlite3.Connection,
     played_at: datetime,
     query_id: str,
+    profile_id: str | None = None,
 ) -> bool:
     """True iff a follow-up query within 30 s has matching NFC topic sig.
 
@@ -193,14 +212,28 @@ def _requery_detected(
     if tbl is None:
         return False
 
+    # Tenant scope (guarded — tool_events schema varies): without it, another
+    # profile's recall events in the same window count as this profile's
+    # requeries, corrupting reward attribution.
+    scope_sql, scope_params = "", ()
+    if profile_id is not None:
+        try:
+            cols = {r[1] for r in memory_conn.execute(
+                "PRAGMA table_info(tool_events)").fetchall()}
+            if "profile_id" in cols:
+                scope_sql = " AND profile_id = ?"
+                scope_params = (profile_id,)
+        except sqlite3.Error:
+            pass
+
     # Read *query* text from tool_events payload for within-window events;
     # compute topic sig on each, compare against the original query's sig.
     try:
         rows = memory_conn.execute(
             "SELECT payload_json FROM tool_events "
             "WHERE occurred_at > ? AND occurred_at <= ? "
-            "  AND tool_name = 'recall' LIMIT 20",
-            (start, end),
+            "  AND tool_name = 'recall'" + scope_sql + " LIMIT 20",
+            (start, end, *scope_params),
         ).fetchall()
     except sqlite3.Error:
         return False
@@ -212,9 +245,9 @@ def _requery_detected(
     try:
         seed_row = memory_conn.execute(
             "SELECT payload_json FROM tool_events "
-            "WHERE occurred_at <= ? AND tool_name = 'recall' "
+            "WHERE occurred_at <= ? AND tool_name = 'recall'" + scope_sql + " "
             "ORDER BY occurred_at DESC LIMIT 1",
-            (played_at.isoformat(timespec="seconds"),),
+            (played_at.isoformat(timespec="seconds"), *scope_params),
         ).fetchone()
     except sqlite3.Error:
         seed_row = None
@@ -288,12 +321,12 @@ def settle_stale_plays(
             reward: float | None = None
             kind = "default"
             if memory_conn is not None and _tool_event_hit(
-                memory_conn, played, top3,
+                memory_conn, played, top3, profile_id=str(profile_id),
             ):
                 reward = 1.0
                 kind = "proxy_position"
             elif memory_conn is not None and _requery_detected(
-                memory_conn, played, row["query_id"],
+                memory_conn, played, row["query_id"], profile_id=str(profile_id),
             ):
                 reward = 0.0
                 kind = "proxy_requery"

package/src/superlocalmemory/loops/__init__.py

@@ -0,0 +1,56 @@
+"""SuperLocalMemory bounded loops.
+
+Agent loops that stop when an independent gate passes — not when the agent
+says it is done — with the run's history persisted in SLM's durable memory.
+
+Public API::
+
+    from superlocalmemory.loops import (
+        Bounds, Rung, Status, Verdict, LapResult, Outcome,
+        run_bounded_loop, InMemoryLedger, SLMMemoryLedger, open_engine_store,
+    )
+"""
+
+from __future__ import annotations
+
+from superlocalmemory.loops.engine import run_bounded_loop
+from superlocalmemory.loops.ledger import (
+    InMemoryLedger,
+    LedgerEntry,
+    LedgerStore,
+    SLMMemoryLedger,
+    engine_backed_ledger,
+    open_engine_store,
+)
+from superlocalmemory.loops.models import (
+    Bounds,
+    LapResult,
+    Outcome,
+    Rung,
+    Status,
+    Verdict,
+)
+from superlocalmemory.loops.rules import (
+    no_progress,
+    rung_requires_approval,
+    stop_condition_met,
+)
+
+__all__ = [
+    "Bounds",
+    "Rung",
+    "Status",
+    "Verdict",
+    "LapResult",
+    "Outcome",
+    "run_bounded_loop",
+    "LedgerEntry",
+    "LedgerStore",
+    "InMemoryLedger",
+    "SLMMemoryLedger",
+    "engine_backed_ledger",
+    "open_engine_store",
+    "no_progress",
+    "rung_requires_approval",
+    "stop_condition_met",
+]