luminary-memory 0.2.2__tar.gz → 0.2.3__tar.gz

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project are documented in this file. The format follows [Keep a Changelog](https://keepachangelog.com/), and the project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.2.3] - 2026-08-18
+
+### Added
+
+- **Hermes dashboard config schema** — exposes 18 luminary settings (mode, backend, recall limit, token budget, auto-recall/retain, **LLM memory curation**, **auto-maintain**, LLM endpoint, indicators) in the Hermes dashboard Provider panel. `auto_maintain` added; `ingest_llm` label corrected to "LLM memory curation".
+
+### Changed
+
+- **Balanced LLM curation** — the enricher now rejects work/task logs and meta-talk about the memory system itself, while still keeping durable facts (not over-strict). Verified: work logs → `worth_saving: false`; facts → stored.
+
 ## [0.2.2] - 2026-08-18
 
 ### Added
@@ -10,7 +20,8 @@ All notable changes to this project are documented in this file. The format foll
   - `worth_saving` — chit-chat, greetings, and trivial turns are **dropped** instead of polluting the store.
   - `summary` — kept turns are stored as concise factual summaries (e.g. `"Deploy target is the staging cluster."`) instead of raw `User: ... / Assistant: ...` transcripts.
   - `entities` / `tags` — attached for richer recall.
-- **Transparency log** — provider writes `$HERMES_HOME/luminary/luminary.log` recording initialize/recall/retain/errors.
+- **LLM store maintenance** — `MemoryClient.run_maintenance()` + provider `auto_maintain` (session-end): the LLM reviews the store and **deletes obsolete/contradicted/duplicate facts**, **updates changed ones**, and **keeps** current ones (verified: stale deploy target auto-removed).
+- **Transparency log** — provider writes `$HERMES_HOME/luminary/luminary.log` recording initialize/recall/retain/maintenance/errors.
 - **`OpenAICompatibleEnricher` User-Agent header** — required by some OpenAI-compatible gateways (e.g. Command Code 403s without it).
 
 ### Fixed

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: luminary-memory
-Version: 0.2.2
+Version: 0.2.3
 Summary: A lightweight, self-hosted memory layer for AI agents
 Project-URL: Homepage, https://github.com/alertxsto/luminary-memory
 Project-URL: Repository, https://github.com/alertxsto/luminary-memory
@@ -101,6 +101,12 @@ factual summaries (e.g. `"Deploy target is the staging cluster."`) instead of
 raw `User: ... / Assistant: ...` transcripts. One small LLM call per retained
 turn; any OpenAI-compatible endpoint works.
 
+**LLM store maintenance (optional):** set `auto_maintain: true` in the same
+config file to have the provider review the store at every session end — the
+LLM keeps current facts, updates changed ones, and deletes stale, contradicted,
+or duplicate memories, so the store never accumulates outdated or redundant
+facts.
+
 ---
 
 ## Quickstart
@@ -262,7 +268,7 @@ Contributions welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## Roadmap
 
-See [ROADMAP.md](ROADMAP.md) for the full product roadmap — v0.2.1 (Hermes memory provider), v0.3.0 (intelligence), and v1.0.0 (stable).
+See [ROADMAP.md](ROADMAP.md) for the full product roadmap — v0.2.2 (LLM memory curation & maintenance), v0.3.0 (intelligence), and v1.0.0 (stable).
 
 ---
 

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/README.md

@@ -67,6 +67,12 @@ factual summaries (e.g. `"Deploy target is the staging cluster."`) instead of
 raw `User: ... / Assistant: ...` transcripts. One small LLM call per retained
 turn; any OpenAI-compatible endpoint works.
 
+**LLM store maintenance (optional):** set `auto_maintain: true` in the same
+config file to have the provider review the store at every session end — the
+LLM keeps current facts, updates changed ones, and deletes stale, contradicted,
+or duplicate memories, so the store never accumulates outdated or redundant
+facts.
+
 ---
 
 ## Quickstart
@@ -228,7 +234,7 @@ Contributions welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## Roadmap
 
-See [ROADMAP.md](ROADMAP.md) for the full product roadmap — v0.2.1 (Hermes memory provider), v0.3.0 (intelligence), and v1.0.0 (stable).
+See [ROADMAP.md](ROADMAP.md) for the full product roadmap — v0.2.2 (LLM memory curation & maintenance), v0.3.0 (intelligence), and v1.0.0 (stable).
 
 ---
 

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/docs/api.md

@@ -14,7 +14,7 @@ pdoc --output-dir docs/api --docformat markdown src/luminary_memory
 
 ## Quick surface
 
-- `MemoryClient` — `ingest`, `ingest_batch`, `recall` (tags + snippets + planner), `search`, `get`/`update`/`delete`, `list`, `export`/`import_memories`, `run_lifecycle`, `stats`, `close`.
+- `MemoryClient` — `ingest`, `ingest_batch`, `recall` (tags + snippets + planner), `search`, `get`/`update`/`delete`, `list`, `export`/`import_memories`, `run_lifecycle`, `run_maintenance` (LLM curation), `stats`, `close`.
 - `Settings` — `LUMINARY_*` env vars, `as_dict()`.
 - `Memory`, `RecallResult` — `types.py`.
 - Subpackages `backends/`, `embeddings/`, `ingest/`, `recall/`, `lifecycle/`, `export`.

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/docs/hermes-integration.md

@@ -49,6 +49,7 @@ The provider reads `$HERMES_HOME/luminary/config.json` (created on first save wi
 | `llm_timeout` | `60` | Enricher request timeout (seconds) |
 | `recall_indicator` | `true` | Show `🌙 Luminary — recalled N memories` |
 | `retain_indicator` | `true` | Show `🌙 Luminary — memory saved` |
+| `auto_maintain` | `false` | **LLM store review at session end** — keeps/updates/deletes stale, contradicted, or duplicate facts (requires `ingest_llm`) |
 
 ### LLM memory curation (v0.2.2+)
 

luminary_memory-0.2.3/docs/lifecycle.md

@@ -0,0 +1,72 @@
+# Lifecycle
+
+Two maintenance layers keep the store lean: deterministic passes
+(`run_lifecycle()`) and LLM-driven curation (`run_maintenance()`).
+
+## `run_lifecycle()` — deterministic passes
+
+### cleanup — TTL expiry
+
+Removes memories whose `ttl_seconds` has elapsed.
+
+### consolidate — merge near-duplicates
+
+Clusters memories by Jaccard similarity (`LUMINARY_CONSOLIDATE_JACCARD_THRESHOLD`, default 0.9) and merges each cluster into a single memory — keeping the longest content, summing access counts, and unioning tags.
+
+### prune — drop low-value memories
+
+Removes memories below a minimum importance (`LUMINARY_PRUNE_MIN_IMPORTANCE`, default 0.2).
+
+## `run_maintenance()` — LLM-driven curation (v0.2.2+)
+
+Sends the store to the configured LLM enricher, which reviews every memory and
+decides **keep** / **update** / **delete**:
+
+- **delete** — obsolete, contradicted, or duplicate facts (e.g. the old
+  deploy target after it changed).
+- **update** — facts that changed, with replacement content.
+- **keep** — still-current facts.
+
+Requires an LLM enricher (set `ingest_llm: true` + `llm_*` config); no-ops
+otherwise. One LLM call per review run (all memories in a single call).
+
+```python
+client = MemoryClient(db_path="memory.db", enricher=enricher)
+print(client.run_maintenance())
+# {'reviewed': 4, 'deleted': 2, 'updated': 0}
+```
+
+### Automatic maintenance in the Hermes provider
+
+With `auto_maintain: true` in `~/.hermes/luminary/config.json` (plus
+`ingest_llm: true`), the provider runs `run_maintenance()` automatically at
+every session end:
+
+```json
+{
+  "ingest_llm": true,
+  "llm_base_url": "https://api.commandcode.ai/provider/v1",
+  "llm_model": "deepseek/deepseek-v4-flash",
+  "llm_api_key": "your-key",
+  "auto_maintain": true
+}
+```
+
+Results are recorded in the transparency log
+(`~/.hermes/luminary/luminary.log`): `maintenance {'reviewed': N, 'deleted': N, 'updated': N}`.
+
+## Scheduling
+
+Run via cron for a self-maintaining store:
+
+```cron
+0 4 * * *  /usr/local/bin/luminary-memory lifecycle
+```
+
+Or programmatically:
+
+```python
+client = MemoryClient(db_path="memory.db")
+print(client.run_lifecycle())
+client.close()
+```

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/hermes/README.md

@@ -61,6 +61,25 @@ Any OpenAI-compatible endpoint works. Costs one small LLM call per retained
 turn (temperature 0, strict JSON). If the enricher fails, the provider falls
 back to storing the turn verbatim — it never blocks.
 
+### Store maintenance (auto_maintain)
+
+With `auto_maintain: true` (plus `ingest_llm: true`), the provider also
+reviews the store at every session end — the LLM keeps current facts, updates
+changed ones, and **deletes stale, contradicted, or duplicate memories**:
+
+```json
+{
+  "ingest_llm": true,
+  "llm_base_url": "https://api.commandcode.ai/provider/v1",
+  "llm_model": "deepseek/deepseek-v4-flash",
+  "llm_api_key": "your-key",
+  "auto_maintain": true
+}
+```
+
+Results land in the transparency log:
+`maintenance {'reviewed': N, 'deleted': N, 'updated': N}`.
+
 ## Manual install (no script)
 
 ```bash

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/hermes/SKILL.md

@@ -76,6 +76,22 @@ client.list(limit=20)   # most recent first
 Use this before re-ingesting — if a fact is already stored, update instead of
 duplicating.
 
+### Store maintenance
+
+The store keeps itself clean two ways:
+
+```python
+# deterministic passes (TTL, consolidate, prune)
+client.run_lifecycle()
+
+# LLM review: keep current facts, update changed ones, delete stale/duplicates
+client.run_maintenance()   # requires an LLM enricher (ingest_llm)
+```
+
+In the Hermes provider, `auto_maintain: true` (plus `ingest_llm: true`) runs
+`run_maintenance()` automatically at every session end — no manual trigger
+needed. Results are logged to `~/.hermes/luminary/luminary.log`.
+
 ## Configuration — Tweaks
 
 Provider config lives in `~/.hermes/luminary/config.json` (auto-created,
@@ -92,6 +108,7 @@ Provider config lives in `~/.hermes/luminary/config.json` (auto-created,
 | `retain_every_n_turns` | `1` | Save every N turns (higher = fewer, batched saves) |
 | `ingest_llm` | `false` | **LLM memory curation** — drops chit-chat, stores factual summary instead of raw transcript |
 | `llm_base_url` / `llm_model` / `llm_api_key` | `""` | OpenAI-compatible enricher endpoint/model/key |
+| `auto_maintain` | `false` | **LLM store review at session end** — keeps/updates/deletes stale or duplicate facts (needs `ingest_llm`) |
 | `recall_indicator` | `true` | Show `🌙 Luminary — recalled N memories` |
 | `retain_indicator` | `true` | Show `🌙 Luminary — memory saved` |
 | `backend` | `sqlite` | `sqlite` (zero config) or `pgvector` (scale) |

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/hermes/hooks/luminary-activity/handler.py

@@ -67,21 +67,35 @@ def _recent_activity(seconds: int = 30) -> str | None:
             "FROM memories",
             (cutoff,),
         ).fetchone()
-        conn.close()
         n = int(row["n"] or 0)
         new_mem = bool(row["new_mem"])
         if n == 0:
+            conn.close()
             return None
         label = "stored" if new_mem else "recalled"
         noun = "memory" if n == 1 else "memories"
-        return f"🌙 Luminary — {n} {noun} {label}"
+        lines = [f"🌙 Luminary — {n} {noun} {label}"]
+        # Show the content of newly stored facts (transparency).
+        if new_mem:
+            new_rows = conn.execute(
+                "SELECT content FROM memories "
+                "WHERE strftime('%s', created_at) > ? "
+                "ORDER BY id DESC LIMIT 3",
+                (cutoff,),
+            ).fetchall()
+            for r in new_rows:
+                content = str(r["content"] or "").replace("\n", " ")[:90]
+                if content:
+                    lines.append(f"  • {content}")
+        conn.close()
+        return "\n".join(lines)
     except Exception:
         logging.exception("activity read failed")
         return None
 
 
-def handler(event_type: str, context: dict) -> None:
-    """Hook entry point: surface luminary activity on agent:start/end."""
+def handle(event_type: str, context: dict) -> None:
+    """Hook entry point: surface luminary activity on agent:end."""
     # Only surface on agent:end (after work), cooldown-ish: skip if store idle.
     if event_type != "agent:end":
         return

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "luminary-memory"
-version = "0.2.2"
+version = "0.2.3"
 description = "A lightweight, self-hosted memory layer for AI agents"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/src/luminary_memory/__init__.py

@@ -1,4 +1,4 @@
 from luminary_memory.api import MemoryClient
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 __all__ = ["MemoryClient", "__version__"]

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/src/luminary_memory/api.py

@@ -254,6 +254,59 @@ class MemoryClient:
 
         return run_lifecycle(self.backend, self.settings)
 
+    def run_maintenance(self, review_all: bool = True) -> dict:
+        """LLM-driven store maintenance: review memories and prune/update stale facts.
+
+        Sends the current store (or a recent slice when ``review_all`` is
+        false) to the configured LLM enricher, which decides per memory:
+        ``keep`` (unchanged), ``update`` (new content), or ``delete``
+        (obsolete/contradicted/duplicate). Applies the decisions and returns
+        a summary dict.
+
+        Requires ``ingest_llm`` (an LLM enricher); no-ops otherwise.
+        """
+        from luminary_memory.ingest.llm import _parse_enrichment_payload
+
+        if self.enricher is None or isinstance(self.enricher, NoopEnricher):
+            return {"skipped": "no LLM enricher configured (set ingest_llm)"}
+
+        memories = self.list(limit=500)
+        if not memories:
+            return {"reviewed": 0, "deleted": 0, "updated": 0}
+
+        raw = self.enricher.review_memories(memories)
+        data = _parse_enrichment_payload(raw)
+        actions = data.get("actions") or []
+        if not isinstance(actions, list):
+            return {"reviewed": len(memories), "deleted": 0, "updated": 0, "error": "bad LLM response"}
+
+        deleted = updated = 0
+        by_id = {m.id: m for m in memories}
+        for act in actions:
+            if not isinstance(act, dict):
+                continue
+            mid = act.get("id")
+            if mid not in by_id:
+                continue
+            action = act.get("action")
+            if action == "delete":
+                try:
+                    self.delete(int(mid))
+                    deleted += 1
+                except Exception:  # noqa: BLE001, S110
+                    pass
+            elif action == "update":
+                new_content = act.get("content")
+                if isinstance(new_content, str) and new_content.strip():
+                    try:
+                        m = by_id[mid]
+                        m.content = new_content.strip()
+                        self.update(m)
+                        updated += 1
+                    except Exception:  # noqa: BLE001, S110
+                        pass
+        return {"reviewed": len(memories), "deleted": deleted, "updated": updated}
+
     def export(self, path, include_embeddings: bool = True) -> dict:
         """Export all memories to *path* (versioned JSON)."""
         from luminary_memory.export import export_memories

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/src/luminary_memory/hermes/config.py

@@ -33,6 +33,7 @@ _DEFAULTS: dict = {
     "recall_indicator": True,
     "retain_indicator": True,
     "extract_on_session_end": False,
+    "auto_maintain": False,  # LLM store review on session end (needs ingest_llm)
 }
 
 

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/src/luminary_memory/hermes/config_schema.py

@@ -38,7 +38,8 @@ CONFIG_SCHEMA = ProviderConfigSchema(
         {"key": "retain_every_n_turns", "label": "Retain every N turns", "type": "number"},
         {"key": "retain_user_prefix", "label": "User prefix", "type": "text"},
         {"key": "retain_assistant_prefix", "label": "Assistant prefix", "type": "text"},
-        {"key": "ingest_llm", "label": "LLM enrichment", "type": "boolean"},
+        {"key": "ingest_llm", "label": "LLM memory curation", "type": "boolean"},
+        {"key": "auto_maintain", "label": "Auto-maintain store (LLM)", "type": "boolean"},
         {"key": "llm_base_url", "label": "LLM base URL", "type": "text"},
         {"key": "llm_model", "label": "LLM model", "type": "text"},
         {"key": "llm_timeout", "label": "LLM timeout (s)", "type": "number"},

{luminary_memory-0.2.2 → luminary_memory-0.2.3}/src/luminary_memory/hermes/provider.py

@@ -393,10 +393,16 @@ class LuminaryMemoryProvider(MemoryProvider):
         self._turn_counter = 0
 
     def on_session_end(self, messages) -> None:
-        """Flush buffered turns under the current session lineage."""
+        """Flush buffered turns; optionally run LLM store maintenance."""
         if not self._client or self._shutting_down.is_set():
             return
         self._flush_session_turns()
+        if self._config.get("auto_maintain", False) and self._config.get("ingest_llm", False):
+            try:
+                result = self._client.run_maintenance()
+                self._log.info("maintenance %s", result)
+            except Exception:
+                logging.getLogger(__name__).exception("LLM maintenance failed")
 
     def on_session_switch(self, new_session_id: str, **kwargs) -> None:
         """Flush the old session, then rebind to the new one."""

luminary_memory-0.2.3/src/luminary_memory/ingest/llm.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+
+
+@dataclass
+class EnrichedContent:
+    content: str
+    summary: str | None = None
+    entities: list[str] = field(default_factory=list)
+    tags: list[str] = field(default_factory=list)
+    worth_saving: bool = True
+
+
+class LLMEnricher:
+    def enrich(self, text: str) -> EnrichedContent:
+        raise NotImplementedError
+
+    def review_memories(self, memories: list) -> str:
+        """Return a JSON actions payload for curating *memories*.
+
+        Each memory has ``id`` and ``content``. The default implementation
+        calls :meth:`enrich`; subclasses may override for a dedicated prompt.
+        """
+        import json as _json
+
+        items = "\n".join(
+            f'- {{"id": {m.id}, "content": {_json.dumps(str(getattr(m, "content", ""))[:300])}}}'
+            for m in memories
+        )
+        prompt = (
+            "Review this memory store. For each item decide: \"keep\", \"update\" "
+            "(with replacement content), or \"delete\" (obsolete, contradicted, or "
+            "duplicate). Return STRICT JSON: {\"actions\": [{\"id\": N, \"action\": "
+            "\"keep|update|delete\", \"content\": \"new content if update\"}]}. "
+            "No extra keys, no markdown.\n\nMemories:\n" + items
+        )
+        return self.enrich(prompt).content
+
+
+class NoopEnricher(LLMEnricher):
+    def enrich(self, text: str) -> EnrichedContent:
+        return EnrichedContent(content=text)
+
+
+_FENCE_RE = re.compile(r"```(?:json)?\s*([\s\S]*?)\s*```", re.IGNORECASE)
+
+
+def _strip_fences(s: str) -> str:
+    m = _FENCE_RE.search(s)
+    return m.group(1).strip() if m else s.strip()
+
+
+def _parse_enrichment_payload(raw: str) -> dict:
+    raw = _strip_fences(raw)
+    # Try strict JSON first, then best-effort substring extraction.
+    try:
+        return json.loads(raw)
+    except Exception:  # noqa: BLE001, S110
+        pass
+    # Extract first {...} block.
+    start = raw.find("{")
+    end = raw.rfind("}")
+    if start != -1 and end != -1 and end > start:
+        try:
+            return json.loads(raw[start:end + 1])
+        except Exception:  # noqa: BLE001, S110
+            pass
+    return {}
+
+
+class OpenAICompatibleEnricher(LLMEnricher):
+    """Provider-agnostic enricher over any OpenAI-compatible chat/completions endpoint.
+
+    Uses stdlib ``urllib.request`` so no new runtime dependency is introduced.
+    Any failure (network, timeout, malformed body) returns a passthrough
+    ``EnrichedContent`` with the original text.
+    """
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        model: str | None = None,
+        timeout: int | None = None,
+    ):
+        from luminary_memory.config import Settings
+
+        s = Settings()
+        self.base_url = (base_url if base_url is not None else s.llm_base_url or "").rstrip("/")
+        self.api_key = api_key if api_key is not None else s.llm_api_key
+        self.model = model if model is not None else s.llm_model
+        self.timeout = int(timeout if timeout is not None else s.llm_timeout)
+
+    def _call_llm(self, messages: list[dict]) -> str:
+        """Call the OpenAI-compatible endpoint, return the assistant content."""
+        import urllib.request
+
+        url = f"{self.base_url}/chat/completions"
+        body = json.dumps({"model": self.model, "messages": messages, "temperature": 0}).encode()
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "luminary-memory/0.2.1",
+        }
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        req = urllib.request.Request(url, data=body, headers=headers, method="POST")
+        with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+            raw = resp.read()
+            payload = json.loads(raw.decode() if isinstance(raw, (bytes, bytearray)) else str(raw))
+            try:
+                choices = payload.get("choices") or []
+                if choices:
+                    return (choices[0].get("message") or {}).get("content") or ""
+            except Exception:  # noqa: BLE001, S110
+                pass
+            return ""
+
+    def enrich(self, text: str) -> EnrichedContent:
+        if not self.base_url:
+            return EnrichedContent(content=text)
+        try:
+            content_str = self._call_llm(
+                [
+                    {
+                        "role": "system",
+                        "content": (
+                            "You are a memory curation helper for an AI agent's long-term memory. "
+                            "Given a conversation turn (User/Assistant), decide whether it contains "
+                            "durable, useful facts worth remembering — preferences, decisions, "
+                            "environment details, project conventions, instructions. "
+                            "A fact is worth saving if it will still matter days or weeks from now. "
+                            "Do NOT save: chit-chat, greetings, trivial acknowledgements, or "
+                            "task/work logs (descriptions of what was just done — completed fixes, "
+                            "implementations, or meta-talk about the memory system itself). "
+                            "Return STRICT JSON with exactly these keys:\n"
+                            "- worth_saving (boolean): true only for durable facts; false for "
+                            "chit-chat, work logs, and one-off questions.\n"
+                            "- summary (string): if worth_saving is true, a concise factual summary "
+                            "in the same language as the turn (e.g. 'User prefers X', 'Deploy target "
+                            "is Y'). If false, an empty string.\n"
+                            "- entities (list of strings): key nouns/names mentioned. Empty if false.\n"
+                            "- tags (list of strings): 1-3 short tags. Empty if false.\n"
+                            "No extra keys, no markdown."
+                        ),
+                    },
+                    {"role": "user", "content": text},
+                ]
+            )
+            data = _parse_enrichment_payload(content_str)
+            summary = data.get("summary")
+            entities = data.get("entities") or []
+            tags = data.get("tags") or []
+            worth = data.get("worth_saving")
+            # Normalize to expected types.
+            if not isinstance(entities, list):
+                entities = []
+            if not isinstance(tags, list):
+                tags = []
+            if not isinstance(summary, str):
+                summary = None
+            return EnrichedContent(
+                content=text,
+                summary=summary if summary and summary.strip() else None,
+                entities=[str(x) for x in entities if isinstance(x, str) and x.strip()],
+                tags=[str(x).strip() for x in tags if isinstance(x, str) and x.strip()],
+                worth_saving=bool(worth) if worth is not None else True,
+            )
+        except Exception:  # noqa: BLE001 -- enrichment is best-effort
+            return EnrichedContent(content=text)
+
+    def review_memories(self, memories: list) -> str:
+        """Curate the store: return a JSON actions payload (keep/update/delete)."""
+        if not self.base_url:
+            return "{}"
+        try:
+            import json as _json
+
+            items = "\n".join(
+                f'- {{"id": {m.id}, "content": {_json.dumps(str(getattr(m, "content", ""))[:300])}}}'
+                for m in memories
+            )
+            return self._call_llm(
+                [
+                    {
+                        "role": "system",
+                        "content": (
+                            "You are a memory curator for an AI agent's long-term memory store. "
+                            "Review each memory and decide: \"keep\", \"update\" (provide new "
+                            "content), or \"delete\" (obsolete, contradicted, or duplicate). "
+                            "Return STRICT JSON: {\"actions\": [{\"id\": N, \"action\": "
+                            "\"keep|update|delete\", \"content\": \"new content if update\"}]}. "
+                            "No extra keys, no markdown."
+                        ),
+                    },
+                    {"role": "user", "content": items},
+                ]
+            )
+        except Exception:  # noqa: BLE001 -- curation is best-effort
+            return "{}"