loop-memory 0.4.2__tar.gz → 0.4.3__tar.gz

{loop_memory-0.4.2 → loop_memory-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loop-memory
-Version: 0.4.2
+Version: 0.4.3
 Summary: A general-purpose, local memory system for every AI agent you run. Loop Memory auto-captures conversations from Codex / Claude / Hermes / OpenClaw, scores them by importance × recency × usage × feedback, distils them into a curated wiki, and serves everything from a single web UI.
 Author: Loop Memory contributors <loop-memory@users.noreply.github.com>
 License-Expression: MIT
@@ -402,6 +402,15 @@ pass** over the store:
 
 Dry-run by default; pass `--apply` to commit.
 
+**Observability (since 0.4.3).** The report carries per-stage
+timings (``scan``, ``stale``, ``merge``, ``contradict``, ``apply``,
+``audit``) and an explicit ``aborted`` flag with an ``abort_reason``
+that names the stage the budget fired in. Pass
+``--deadline-seconds <N>`` (HTTP: ``POST /api/v1/cognitive/sleep``
+with ``{"deadline_seconds": N}``; SDK: ``client.cognitive_sleep(deadline_seconds=N)``)
+to bound the sweep — useful for nightly cron, where a stuck
+sweep should leave a loud trace instead of a silent spinner.
+
 ### Knowledge graph
 
 `loop-memory graph-rebuild` extracts entities from every distilled
@@ -632,6 +641,24 @@ classifier is local and makes no model or network request on a wiki write.
 
 ---
 
+### LLM env-var overrides
+
+The OpenAI-compat / Anthropic / Ollama providers (and the optional
+``openai`` adapter) honour two env-var knobs so you can pin
+distillation deterministically without touching the behaviour
+config:
+
+- ``LLM_TEMPERATURE`` — float, defaults to ``0.3`` (or the explicit
+  ``kwargs.temperature``). Invalid values are ignored with a warning.
+- ``LLM_SEED`` — int, sent as ``seed`` for OpenAI / Anthropic /
+  Ollama where supported. Omitting it preserves the existing
+  "no seed" behaviour so older call sites do not need to migrate.
+
+Both env vars are read at every ``complete()`` call, so a single
+``export LLM_SEED=42`` plus a nightly cron makes wiki distillation
+reproducible. Pinned by 11 cases in
+``tests/test_llm_providers.py::LLMEnvVarTests``.
+
 ## FAQ & troubleshooting
 
 **Q: `pip install loop-memory` succeeds but `loop-memory serve` says `ModuleNotFoundError: No module named 'fastapi'`.**

{loop_memory-0.4.2 → loop_memory-0.4.3}/README.md

@@ -358,6 +358,15 @@ pass** over the store:
 
 Dry-run by default; pass `--apply` to commit.
 
+**Observability (since 0.4.3).** The report carries per-stage
+timings (``scan``, ``stale``, ``merge``, ``contradict``, ``apply``,
+``audit``) and an explicit ``aborted`` flag with an ``abort_reason``
+that names the stage the budget fired in. Pass
+``--deadline-seconds <N>`` (HTTP: ``POST /api/v1/cognitive/sleep``
+with ``{"deadline_seconds": N}``; SDK: ``client.cognitive_sleep(deadline_seconds=N)``)
+to bound the sweep — useful for nightly cron, where a stuck
+sweep should leave a loud trace instead of a silent spinner.
+
 ### Knowledge graph
 
 `loop-memory graph-rebuild` extracts entities from every distilled
@@ -588,6 +597,24 @@ classifier is local and makes no model or network request on a wiki write.
 
 ---
 
+### LLM env-var overrides
+
+The OpenAI-compat / Anthropic / Ollama providers (and the optional
+``openai`` adapter) honour two env-var knobs so you can pin
+distillation deterministically without touching the behaviour
+config:
+
+- ``LLM_TEMPERATURE`` — float, defaults to ``0.3`` (or the explicit
+  ``kwargs.temperature``). Invalid values are ignored with a warning.
+- ``LLM_SEED`` — int, sent as ``seed`` for OpenAI / Anthropic /
+  Ollama where supported. Omitting it preserves the existing
+  "no seed" behaviour so older call sites do not need to migrate.
+
+Both env vars are read at every ``complete()`` call, so a single
+``export LLM_SEED=42`` plus a nightly cron makes wiki distillation
+reproducible. Pinned by 11 cases in
+``tests/test_llm_providers.py::LLMEnvVarTests``.
+
 ## FAQ & troubleshooting
 
 **Q: `pip install loop-memory` succeeds but `loop-memory serve` says `ModuleNotFoundError: No module named 'fastapi'`.**

{loop_memory-0.4.2 → loop_memory-0.4.3}/loop_memory/jobs/cognitive.py

@@ -34,7 +34,7 @@ import math
 import time
 from collections.abc import Iterable
 from dataclasses import dataclass, field
-from typing import Any
+from typing import Any, Callable
 
 from ..storage.sqlite_store import MemoryStore
 
@@ -105,6 +105,14 @@ class CognitiveReport:
     elapsed_ms: float = 0.0
     counts: dict[str, int] = field(default_factory=dict)
     applied: bool = False
+    # Audit 2026-08-16: per-stage timings so a stalled sweep can be
+    # attributed to a specific stage instead of returning a single
+    # opaque number. Mirrors the "fails loudly instead of quietly"
+    # convention from ``EverMind-AI/EverOS`` v1.2.3 where any stall
+    # names the table / phase it happened in.
+    stages: dict[str, float] = field(default_factory=dict)
+    aborted: bool = False
+    abort_reason: str = ""
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -113,6 +121,9 @@ class CognitiveReport:
             "counts": self.counts,
             "applied": self.applied,
             "total": len(self.actions),
+            "stages": dict(self.stages),
+            "aborted": self.aborted,
+            "abort_reason": self.abort_reason,
         }
 
 
@@ -132,6 +143,8 @@ def cognitive_sleep(
     merge_threshold: float = DEFAULT_MERGE_THRESHOLD,
     limit: int = 1000,
     record_audit: bool = True,
+    progress: Callable[[str], None] | None = None,
+    deadline_seconds: float | None = None,
 ) -> CognitiveReport:
     """Run a single cognitive sweep.
 
@@ -148,19 +161,80 @@ def cognitive_sleep(
     The sweep is bounded to ``limit`` memories per pass to keep it
     cheap; for very large stores the user can call it multiple
     times or wire it into a cron.
+
+    Audit 2026-08-16 -- observability additions
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    * ``progress``: optional ``Callable[[str], None]`` invoked once per
+      stage so the UI can render a live progress bar without polling.
+      Stage names are ``scan``, ``stale``, ``low_value``, ``merge``,
+      ``contradict``, ``apply``, ``audit``.
+    * ``deadline_seconds``: when set, the sweep checks the deadline
+      between the O(n^2) near-duplicate pairs and between
+      individual stages; if it elapses, the sweep stops with
+      ``report.aborted=True`` and ``report.abort_reason`` naming
+      the stage it stalled in. Following the
+      ``EverMind-AI/EverOS`` v1.2.3 pattern: stalls must name the
+      stage so the user can act on them, not return a silent
+      "still working…" spinner. ``report.stages`` carries the
+      per-stage elapsed_ms for the same reason.
     """
     t0 = time.time()
     actions: list[CognitiveAction] = []
     counts: dict[str, int] = {
         "stale": 0, "low_value": 0, "merge": 0, "contradict": 0, "forget": 0,
     }
+    stages: dict[str, float] = {}
+    aborted = False
+    abort_reason = ""
     now = time.time()
+    # Explicit ``is not None`` check guards against the
+    # ``0.0 == falsy`` pitfall (the same bug class Mem0 v2.0.18
+    # fixed for Oracle ``index_accuracy=0``): a caller passing
+    # ``deadline_seconds=0.0`` to mean "fail-fast / never run"
+    # would otherwise be silently downgraded to ``deadline_at=None``
+    # and the sweep would happily run past the deadline.
+    deadline_at: float | None = (
+        now + float(deadline_seconds)
+        if deadline_seconds is not None else None
+    )
+
+    def _deadline_left() -> float:
+        if deadline_at is None:
+            return float("inf")
+        return max(0.0, deadline_at - time.time())
+
+    def _tick(stage: str, stage_t0: float) -> None:
+        nonlocal aborted, abort_reason
+        stages[stage] = round((time.time() - stage_t0) * 1000, 1)
+        if progress is not None:
+            try:
+                progress(stage)
+            except Exception:  # pragma: no cover - progress is best-effort
+                log.warning("cognitive_sleep progress(%r) raised; ignoring", stage)
+        if deadline_at is not None and time.time() >= deadline_at:
+            aborted = True
+            abort_reason = f"deadline exceeded in stage {stage!r} ({stages[stage]} ms)"
+
     stale_cutoff = now - stale_days * 86400.0
 
     # ----- 1. Stale memories --------------------------------------
     # Pull every memory below the score + importance gates. We do a
     # single SQL scan to keep the pass fast.
+    scan_t0 = time.time()
     rows = store.list_memories(limit=limit)
+    _tick("scan", scan_t0)
+    if aborted:
+        return _finalize_report(actions, counts, stages, aborted, abort_reason,
+                                t0, apply, record_audit, store)
+
+    # Stages 1+2: stale gate + low-value gate share one pass over
+    # ``rows`` because both need (score, importance, created_at).
+    sl_t0 = time.time()
+    # Audit 2026-08-16: bulk-fetch signals in one query instead of
+    # one SELECT per memory -- the nightly sweep previously did
+    # ``limit`` round-trips just to read ``recall_count`` for the
+    # low-value gate.
+    signals_by_id = store.get_signals([r.id for r in rows]) if rows else {}
     for r in rows:
         score = float(r.score or 0)
         importance = float(r.importance or 0)
@@ -178,10 +252,9 @@ def cognitive_sleep(
             continue
         # Low value: never recalled, score + importance * 0.5 below
         # ``low_value`` (this is the cheap "noise from a long
-        # transcript" filter).
-        # ``list_memories`` doesn't include recall_count in the
-        # dataclass; re-fetch via the signals table.
-        signals = _signals_for(store, r.id)
+        # transcript" filter). Signals are pre-fetched in bulk above
+        # so this is now a dict lookup, not a per-row SQL hit.
+        signals = signals_by_id.get(r.id, {"recall_count": 0, "positive": 0, "negative": 0})
         if signals["recall_count"] == 0 and score + 0.5 * importance < low_value:
             counts["low_value"] += 1
             actions.append(CognitiveAction(
@@ -190,16 +263,28 @@ def cognitive_sleep(
                 reason=f"never recalled & score+0.5*importance<{low_value}",
                 score=score, payload={"importance": importance},
             ))
+    _tick("stale", sl_t0)
+    if aborted:
+        return _finalize_report(actions, counts, stages, aborted, abort_reason,
+                                t0, apply, record_audit, store)
 
     # ----- 2. Near-duplicate merges ------------------------------
     # Cheap O(n^2) on the first ``limit`` memories; good enough for
     # nightly sweeps on a store of a few thousand rows. We use the
     # ``text`` Jaccard over a small token set so the comparison
     # doesn't need embeddings.
+    merge_t0 = time.time()
     text_index = [(r.id, _token_set(r.text or "")) for r in rows]
     seen_pairs: set[tuple[str, str]] = set()
     for i in range(len(text_index)):
         for j in range(i + 1, len(text_index)):
+            # Check the deadline every 256 pairs so the cost is
+            # amortised away on large sweeps but a runaway near-
+            # duplicate loop can't escape the budget.
+            if deadline_at is not None and (j & 0xFF) == 0 and _deadline_left() <= 0:
+                aborted = True
+                abort_reason = f"deadline exceeded during near-duplicate scan (i={i}, j={j})"
+                break
             mid_i, ti = text_index[i]
             mid_j, tj = text_index[j]
             if not ti or not tj:
@@ -225,12 +310,19 @@ def cognitive_sleep(
                     reason=f"Jaccard={j_sim:.3f} ≥ {merge_threshold}",
                     score=j_sim, payload={"other_id": mid_j, "jaccard": j_sim},
                 ))
+        if aborted:
+            break
+    _tick("merge", merge_t0)
+    if aborted:
+        return _finalize_report(actions, counts, stages, aborted, abort_reason,
+                                t0, apply, record_audit, store)
 
     # ----- 3. Contradictions -------------------------------------
     # Reuse the existing wiki-page contradiction detector. It's
     # cheap (key_facts Jaccard, no LLM) and already returns the
     # matches we need.
     from .contradiction import list_contradictions
+    contr_t0 = time.time()
     try:
         contradictions = list_contradictions(store)
     except Exception as e:
@@ -252,8 +344,13 @@ def cognitive_sleep(
                     "partner_title": partner.get("title"),
                 },
             ))
+    _tick("contradict", contr_t0)
+    if aborted:
+        return _finalize_report(actions, counts, stages, aborted, abort_reason,
+                                t0, apply, record_audit, store)
 
     # ----- 4. Apply (optional) -----------------------------------
+    apply_t0 = time.time()
     if apply:
         applied_actions: list[CognitiveAction] = []
         for a in actions:
@@ -277,8 +374,10 @@ def cognitive_sleep(
                 # both". But we still mark the action as suggested
                 # so the audit trail is complete.
                 continue
+    _tick("apply", apply_t0)
 
     # ----- 5. Persist to cognitive_audit -------------------------
+    audit_t0 = time.time()
     if record_audit:
         for a in actions:
             store.record_audit(
@@ -292,12 +391,61 @@ def cognitive_sleep(
                 payload=a.payload,
             )
 
+    _tick("audit", audit_t0)
+    elapsed_ms = (time.time() - t0) * 1000
+    return CognitiveReport(
+        actions=actions,
+        elapsed_ms=round(elapsed_ms, 1),
+        counts=counts,
+        applied=bool(apply),
+        stages=stages,
+        aborted=aborted,
+        abort_reason=abort_reason,
+    )
+
+
+def _finalize_report(
+    actions: list[CognitiveAction],
+    counts: dict[str, int],
+    stages: dict[str, float],
+    aborted: bool,
+    abort_reason: str,
+    t0: float,
+    apply: bool,
+    record_audit: bool,
+    store: MemoryStore,
+) -> CognitiveReport:
+    """Build an early-return report when the deadline fires.
+
+    The early-return path still runs the audit stage for any actions
+    the sweep already collected, so a partial sweep leaves the same
+    trace a full sweep would.
+    """
+    if record_audit and actions:
+        for a in actions:
+            try:
+                store.record_audit(
+                    kind=a.kind,
+                    action=a.action,
+                    target_kind=a.target_kind,
+                    target_id=a.target_id,
+                    target_text=a.target_text,
+                    reason=a.reason,
+                    score=a.score,
+                    payload=a.payload,
+                )
+            except Exception:  # pragma: no cover - audit is best-effort
+                log.warning("record_audit on early-return failed; skipping")
+        stages["audit"] = round((time.time() - t0) * 1000, 1) - sum(stages.values())
     elapsed_ms = (time.time() - t0) * 1000
     return CognitiveReport(
         actions=actions,
         elapsed_ms=round(elapsed_ms, 1),
         counts=counts,
         applied=bool(apply),
+        stages=stages,
+        aborted=aborted,
+        abort_reason=abort_reason,
     )
 
 
@@ -306,20 +454,6 @@ def cognitive_sleep(
 # ---------------------------------------------------------------------------
 
 
-def _signals_for(store: MemoryStore, memory_id: str) -> dict[str, Any]:
-    """Return the signal row for a memory, or zeros if missing."""
-    with store._conn() as c:  # type: ignore[attr-defined]
-        row = c.execute(
-            "SELECT recall_count, positive, negative, last_recalled_at "
-            "FROM memory_signals WHERE memory_id=?",
-            (memory_id,),
-        ).fetchone()
-    if not row:
-        return {"recall_count": 0, "positive": 0, "negative": 0,
-                "last_recalled_at": None}
-    return dict(row)
-
-
 def _token_set(text: str) -> set[str]:
     """Cheap token set: lowercase + split on whitespace + punctuation.
 

loop_memory-0.4.3/loop_memory/llm/openai_adapter.py

@@ -0,0 +1,64 @@
+"""Optional OpenAI adapter.
+
+Only imported when the user has the ``openai`` package installed
+(``pip install loop-memory[openai]``). Keeps the core library
+zero-dependency.
+"""
+
+from __future__ import annotations
+
+import os
+
+from ..llm.base import ChatHistory, LLMClient
+
+
+def _env_float(name: str, default: float | None) -> float | None:
+    raw = os.environ.get(name)
+    if raw is None or raw.strip() == "":
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def _env_optional_int(name: str) -> int | None:
+    raw = os.environ.get(name)
+    if raw is None or raw.strip() == "":
+        return None
+    try:
+        return int(raw)
+    except ValueError:
+        return None
+
+
+class OpenAIClient(LLMClient):
+    def __init__(self, model: str = "gpt-4o-mini", api_key: str | None = None) -> None:
+        try:
+            from openai import OpenAI  # type: ignore
+        except ImportError as e:
+            raise RuntimeError("openai is not installed; pip install loop-memory[openai]") from e
+        self.model = model
+        self._client = OpenAI(api_key=api_key)  # type: ignore[arg-type]
+
+    def complete(self, history: ChatHistory, **kwargs) -> str:
+        msgs = [{"role": "system", "content": history.system}] if history.system else []
+        msgs += [{"role": m.role, "content": m.content} for m in history.messages]
+        temperature = _env_float(
+            "LLM_TEMPERATURE",
+            float(kwargs.get("temperature", 0.4)),
+        )
+        create_kwargs = dict(
+            model=self.model,
+            messages=msgs,
+            temperature=float(temperature if temperature is not None else 0.4),
+            max_tokens=int(kwargs.get("max_tokens", 600)),
+        )
+        seed = _env_optional_int("LLM_SEED")
+        if seed is None:
+            seed_val = kwargs.get("seed")
+            seed = int(seed_val) if seed_val is not None else None
+        if seed is not None:
+            create_kwargs["seed"] = int(seed)
+        resp = self._client.chat.completions.create(**create_kwargs)
+        return resp.choices[0].message.content or ""

{loop_memory-0.4.2 → loop_memory-0.4.3}/loop_memory/llm/providers.py

@@ -163,6 +163,41 @@ def _http_post_json(url: str, body: dict, headers: dict, timeout: float) -> dict
         raise LLMHttpError(e.code, url, err)
 
 
+def _env_float(name: str, default: float | None) -> float | None:
+    """Read a float from env, returning *default* when unset or invalid.
+
+    Used to plumb ``LLM_TEMPERATURE`` so a user can pin the consolidator
+    temperature globally without touching the behaviour config. Mirrors
+    the env-var conventions in ``topoteretes/cognee`` v1.5.0 (PR #4504)
+    while keeping the kwargs / behaviour config as the canonical knobs.
+    """
+    raw = os.environ.get(name)
+    if raw is None or raw.strip() == "":
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        log.warning("env %s=%r is not a float; ignoring", name, raw)
+        return default
+
+
+def _env_optional_int(name: str) -> int | None:
+    """Read an int from env, returning None when unset or invalid.
+
+    ``LLM_SEED`` is opt-in for providers that support it (OpenAI /
+    Anthropic / Ollama all accept ``seed``). Leaving it unset keeps the
+    pre-existing "no seed" behaviour so callers do not need to migrate.
+    """
+    raw = os.environ.get(name)
+    if raw is None or raw.strip() == "":
+        return None
+    try:
+        return int(raw)
+    except ValueError:
+        log.warning("env %s=%r is not an int; ignoring", name, raw)
+        return None
+
+
 class OpenAICompatProvider(LLMClient):
     """OpenAI-compatible chat completions client.
 
@@ -199,12 +234,22 @@ class OpenAICompatProvider(LLMClient):
             msgs.append({"role": "system", "content": history.system})
         for m in history.messages:
             msgs.append({"role": m.role, "content": m.content})
+        temperature = _env_float(
+            "LLM_TEMPERATURE",
+            float(kwargs.get("temperature", 0.3)),
+        )
         body = {
             "model": self.model,
             "messages": msgs,
-            "temperature": float(kwargs.get("temperature", 0.3)),
+            "temperature": float(temperature if temperature is not None else 0.3),
             "max_tokens": int(kwargs.get("max_tokens", 800)),
         }
+        seed = _env_optional_int("LLM_SEED")
+        if seed is None:
+            seed_val = kwargs.get("seed")
+            seed = int(seed_val) if seed_val is not None else None
+        if seed is not None:
+            body["seed"] = int(seed)
         url = self.base_url + "/chat/completions"
         headers = {"Content-Type": "application/json"}
         if self.api_key:
@@ -236,13 +281,25 @@ class AnthropicProvider(LLMClient):
                 sys_prompt += "\n" + m.content
                 continue
             msgs.append({"role": m.role, "content": m.content})
+        temperature = _env_float(
+            "LLM_TEMPERATURE",
+            float(kwargs.get("temperature", 0.3)),
+        )
         body = {
             "model": self.model,
             "system": sys_prompt or "You are a helpful assistant.",
             "messages": msgs,
             "max_tokens": int(kwargs.get("max_tokens", 800)),
-            "temperature": float(kwargs.get("temperature", 0.3)),
+            "temperature": float(temperature if temperature is not None else 0.3),
         }
+        seed = _env_optional_int("LLM_SEED")
+        if seed is None:
+            seed_val = kwargs.get("seed")
+            seed = int(seed_val) if seed_val is not None else None
+        if seed is not None:
+            # Anthropic only honours an integer seed; non-int env values
+            # are dropped at parse time above.
+            body["seed"] = int(seed)
         url = self.base_url + "/v1/messages"
         headers = {
             "Content-Type": "application/json",
@@ -274,14 +331,25 @@ class OllamaProvider(LLMClient):
             msgs.append({"role": "system", "content": history.system})
         for m in history.messages:
             msgs.append({"role": m.role, "content": m.content})
+        temperature = _env_float(
+            "LLM_TEMPERATURE",
+            float(kwargs.get("temperature", 0.3)),
+        )
+        options = {
+            "temperature": float(temperature if temperature is not None else 0.3),
+            "num_predict": int(kwargs.get("max_tokens", 800)),
+        }
+        seed = _env_optional_int("LLM_SEED")
+        if seed is None:
+            seed_val = kwargs.get("seed")
+            seed = int(seed_val) if seed_val is not None else None
+        if seed is not None:
+            options["seed"] = int(seed)
         body = {
             "model": self.model,
             "messages": msgs,
             "stream": False,
-            "options": {
-                "temperature": float(kwargs.get("temperature", 0.3)),
-                "num_predict": int(kwargs.get("max_tokens", 800)),
-            },
+            "options": options,
         }
         url = self.base_url + "/api/chat"
         data = _http_post_json(url, body, {"Content-Type": "application/json"}, self.timeout)

{loop_memory-0.4.2 → loop_memory-0.4.3}/loop_memory/sdk_extensions.py

@@ -124,6 +124,10 @@ class CognitiveReportView:
     applied: bool = False
     elapsed_ms: float = 0.0
     total: int = 0
+    # Audit 2026-08-16: per-stage timings + deadline observability.
+    stages: dict[str, float] = field(default_factory=dict)
+    aborted: bool = False
+    abort_reason: str = ""
 
     @classmethod
     def from_dict(cls, d: dict[str, Any]) -> CognitiveReportView:
@@ -133,6 +137,9 @@ class CognitiveReportView:
             applied=bool(d.get("applied", False)),
             elapsed_ms=float(d.get("elapsed_ms", 0) or 0),
             total=int(d.get("total", 0)),
+            stages=dict(d.get("stages", {})),
+            aborted=bool(d.get("aborted", False)),
+            abort_reason=str(d.get("abort_reason", "") or ""),
         )
 
 

{loop_memory-0.4.2 → loop_memory-0.4.3}/loop_memory/serve/routes/cognitive.py

@@ -28,6 +28,12 @@ def register(app: FastAPI, store: MemoryStore, scheduler: Optional[Any] = None)
     @app.post("/api/v1/cognitive/sleep")
     def v1_cognitive_sleep(body: dict):
         from ...jobs.cognitive import cognitive_sleep
+        # ``deadline_seconds`` is optional. ``None`` / missing means
+        # no deadline; an explicit ``0`` is honoured (the
+        # truthiness-vs-``is not None`` pitfall that bit
+        # ``mem0ai/mem0`` Oracle ``index_accuracy=0`` in v2.0.18
+        # is caught in ``cognitive_sleep`` itself).
+        deadline = body.get("deadline_seconds")
         rpt = cognitive_sleep(
             store,
             apply=bool(body.get("apply", False)),
@@ -38,6 +44,7 @@ def register(app: FastAPI, store: MemoryStore, scheduler: Optional[Any] = None)
             merge_threshold=float(body.get("merge_threshold", 0.92)),
             limit=int(body.get("limit", 1000)),
             record_audit=bool(body.get("record_audit", True)),
+            deadline_seconds=float(deadline) if deadline is not None else None,
         )
         return rpt.to_dict()
 

{loop_memory-0.4.2 → loop_memory-0.4.3}/loop_memory/storage/sqlite_store.py

@@ -32,7 +32,7 @@ import uuid
 # dependency on .retrieval during package import; the helpers used by
 # _hydrate_* are imported here for the same reason.
 from .retrieval import temporal_score  # noqa: E402
-from collections.abc import Iterator
+from collections.abc import Iterable, Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
 from pathlib import Path
@@ -826,6 +826,40 @@ class MemoryStore:
                 "last_recalled_at": row["last_recalled_at"],
                 "last_feedback_at": row["last_feedback_at"],
             }
+    def get_signals(self, memory_ids):
+        """Bulk fetch signals for many memory ids in a single query.
+
+        Returns a dict keyed by memory_id. Memories with no signal row
+        resolve to the same zero-shape dict as `get_signal`.
+        Used by the cognitive-sweep loop, where iterating per-id caused
+        an N+1 SQL hit on nightly runs over large stores.
+        """
+        ids = [str(x) for x in memory_ids if x]
+        empty = {
+            "recall_count": 0, "positive": 0, "negative": 0,
+            "last_recalled_at": None, "last_feedback_at": None,
+        }
+        out = {mid: dict(empty) for mid in ids}
+        if not ids:
+            return out
+        placeholders = ",".join("?" for _ in ids)
+        with self._conn() as c:
+            rows = c.execute(
+                f"SELECT memory_id, recall_count, positive, negative,"
+                f"       last_recalled_at, last_feedback_at"
+                f"  FROM memory_signals WHERE memory_id IN ({placeholders})",
+                tuple(ids),
+            ).fetchall()
+        for row in rows:
+            mid = row["memory_id"]
+            out[mid] = {
+                "recall_count": row["recall_count"] or 0,
+                "positive": row["positive"] or 0,
+                "negative": row["negative"] or 0,
+                "last_recalled_at": row["last_recalled_at"],
+                "last_feedback_at": row["last_feedback_at"],
+            }
+        return out
 
     def top_signals(self, kind: str = "recall_count", limit: int = 20) -> list[Dict[str, Any]]:
         """Top-N memories by a signal column (recall_count / positive / negative)."""