superlocalmemory 3.7.8 → 3.8.0

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",
+]

package/src/superlocalmemory/loops/budget.py

@@ -0,0 +1,58 @@
+"""Cumulative budget accounting for a bounded-loop run.
+
+The meter tracks laps, tokens, and wall-clock time and reports when any bound
+in effect has been exceeded. It is intentionally tiny and side-effect-free
+apart from its own internal counters, and the clock is injected so tests are
+deterministic.
+"""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from superlocalmemory.loops.models import Bounds
+
+
+class BudgetMeter:
+    """Accumulate spend across laps and answer "have we gone over?".
+
+    ``now`` is a zero-argument callable returning monotonic-ish seconds
+    (``time.monotonic`` in production, a fake in tests). The start time is
+    captured at construction so wall-clock enforcement needs no globals.
+    """
+
+    def __init__(self, now: Callable[[], float]) -> None:
+        self._now = now
+        self._start = now()
+        self._tokens = 0
+
+    def spend(self, tokens: int) -> None:
+        """Record token spend for a completed lap (negative values ignored)."""
+        if tokens > 0:
+            self._tokens += tokens
+
+    def exceeded(self, lap: int, bounds: Bounds) -> tuple[bool, str]:
+        """Return ``(tripped, reason)`` for the bounds checked before a lap runs.
+
+        Checked in priority order: iteration cap, token budget, wall-clock.
+        ``lap`` is the 1-based number of the lap about to run, so exceeding
+        ``max_iterations`` is reported when the (max+1)-th lap is attempted.
+        """
+        if lap > bounds.max_iterations:
+            return True, "max-iterations"
+        # >= so a budget of N never permits an (N+1)-th lap's worth of spend:
+        # once cumulative tokens reach the ceiling, the next lap is refused.
+        if bounds.max_tokens is not None and self._tokens >= bounds.max_tokens:
+            return True, "token-budget"
+        if bounds.max_wallclock_s is not None:
+            elapsed = self._now() - self._start
+            if elapsed > bounds.max_wallclock_s:
+                return True, "wallclock"
+        return False, ""
+
+    def snapshot(self) -> dict:
+        """Point-in-time spend, suitable for a ledger entry."""
+        return {
+            "tokens": self._tokens,
+            "wallclock_s": round(self._now() - self._start, 3),
+        }

package/src/superlocalmemory/loops/engine.py

@@ -0,0 +1,164 @@
+"""The bounded-loop orchestrator.
+
+``run_bounded_loop`` executes a loop for a single goal under a fixed set of
+:class:`Bounds`. Its one non-negotiable invariant: **the independent gate
+decides when the loop is finished — never the agent.** A runner's
+``agent_claimed_done`` flag is written to the ledger for audit and is never
+read when deciding to terminate.
+
+Each lap, in strict order:
+
+1. Poll the kill switch (highest priority — checked before any work).
+2. Check the budget bounds (iteration cap, tokens, wall-clock).
+3. Run the agent's proposer for one lap.
+4. Accumulate token spend.
+5. Ask the *independent* gate for a verdict.
+6. Decide: a passing gate (plus any required approval) ends the run; an
+   exhausted no-progress window halts it; otherwise continue.
+
+Runner and gate are plain callables taking the 1-based lap number, so this
+engine carries no subprocess, sandbox, or framework machinery — SLM loops
+converge on a checkable memory/verification condition, and heavier isolation
+belongs to the standalone bounded-loops engine, not here.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+import uuid
+from datetime import datetime, timezone
+from typing import Callable, Optional
+
+from superlocalmemory.loops.budget import BudgetMeter
+from superlocalmemory.loops.ledger import InMemoryLedger, LedgerEntry, LedgerStore
+from superlocalmemory.loops.models import (
+    Bounds,
+    LapResult,
+    Outcome,
+    Rung,
+    Status,
+    Verdict,
+)
+from superlocalmemory.loops.rules import (
+    no_progress,
+    rung_requires_approval,
+    stop_condition_met,
+)
+
+RunnerFn = Callable[[int], LapResult]
+GateFn = Callable[[int], Verdict]
+ApproverFn = Callable[[Verdict], bool]
+KillSwitchFn = Callable[[], bool]
+ClockFn = Callable[[], str]
+
+_KILL_ENV = "SLM_LOOP_KILL"
+
+
+def _utc_now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _env_killed() -> bool:
+    return bool(os.environ.get(_KILL_ENV))
+
+
+def run_bounded_loop(
+    name: str,
+    *,
+    bounds: Bounds,
+    runner: RunnerFn,
+    gate: GateFn,
+    rung: Rung = Rung.L1,
+    ledger: Optional[LedgerStore] = None,
+    approver: Optional[ApproverFn] = None,
+    killswitch: Optional[KillSwitchFn] = None,
+    clock: Optional[ClockFn] = None,
+    monotonic: Optional[Callable[[], float]] = None,
+    run_id: Optional[str] = None,
+) -> Outcome:
+    """Run one bounded loop and return its :class:`Outcome`.
+
+    Only ``name``, ``bounds``, ``runner`` and ``gate`` are required. Every
+    other dependency is injected for determinism in tests; sensible defaults
+    (UTC clock, monotonic timer, env-var kill switch, in-memory ledger) apply
+    otherwise.
+    """
+    run_id = run_id or f"{name}-{uuid.uuid4().hex[:8]}"
+    ledger = ledger if ledger is not None else InMemoryLedger()
+    clock = clock or _utc_now_iso
+    monotonic = monotonic or time.monotonic
+    killswitch = killswitch or _env_killed
+    budget = BudgetMeter(monotonic)
+
+    lap_changes: list[bool] = []
+    lap = 0
+
+    def emit(decision: str, verdict: Verdict, result: LapResult | None = None) -> None:
+        ledger.record(
+            LedgerEntry(
+                run_id=run_id,
+                name=name,
+                lap=lap,
+                ts=clock(),
+                decision=decision,
+                passed=verdict.passed,
+                detail=verdict.detail,
+                # The agent's own claim is recorded for audit only — never used
+                # to terminate (see the loop invariant). Log is capped so a
+                # verbose runner can't bloat the ledger row.
+                agent_claimed_done=bool(result.agent_claimed_done) if result else False,
+                runner_log=(result.log or "")[:2000] if result else "",
+                budget=budget.snapshot(),
+            )
+        )
+
+    while True:
+        lap += 1
+
+        # 1. Kill switch — before any work (so laps reports completed laps).
+        if killswitch():
+            emit("killed", Verdict(False, "kill switch tripped"))
+            return Outcome(Status.KILLED, "killed", lap - 1, run_id)
+
+        # 2. Budget bounds — before running the agent.
+        tripped, why = budget.exceeded(lap, bounds)
+        if tripped:
+            emit("halt", Verdict(False, why))
+            return Outcome(Status.HALT, why, lap - 1, run_id)
+
+        # 3. Run the proposer for one lap.
+        try:
+            result = runner(lap)
+        except Exception as exc:  # runner failure is a terminal ERROR
+            detail = f"runner error: {type(exc).__name__}: {exc}"
+            emit("error", Verdict(False, detail))
+            return Outcome(Status.ERROR, detail, lap, run_id)
+
+        # 4. Accumulate spend.
+        budget.spend(result.tokens)
+        lap_changes.append(result.changed)
+
+        # 5. Independent gate — agent's own claim is never consulted here.
+        try:
+            verdict = gate(lap)
+        except Exception as exc:
+            detail = f"gate error: {type(exc).__name__}: {exc}"
+            emit("error", Verdict(False, detail), result)
+            return Outcome(Status.ERROR, detail, lap, run_id)
+
+        # 6. Decide.
+        if stop_condition_met(verdict):
+            if rung_requires_approval(rung, bounds):
+                granted = bool(approver(verdict)) if approver is not None else False
+                if not granted:
+                    emit("pause", verdict, result)
+                    return Outcome(Status.PAUSE, "awaiting-approval", lap, run_id)
+            emit("done", verdict, result)
+            return Outcome(Status.DONE, "gate-passed", lap, run_id)
+
+        if no_progress(lap_changes, bounds.no_progress_window):
+            emit("halt", Verdict(False, "no-progress"), result)
+            return Outcome(Status.HALT, "no-progress", lap, run_id)
+
+        emit("continue", verdict, result)