loop-memory 0.4.6__tar.gz → 0.4.7__tar.gz

{loop_memory-0.4.6 → loop_memory-0.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loop-memory
-Version: 0.4.6
+Version: 0.4.7
 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
@@ -66,15 +66,19 @@ Dynamic: license-file
 
 ---
 
-> **What's new in 0.4.6** — **memory supersession chain** + **recall
-> provenance labels**. `merge_memories()` no longer silently
-> `DELETE`s the loser — it writes an explicit `superseded_by`
-> pointer (audit 2026-08-30, Mem0 v2.0.19 Dream pattern), the new
-> `loop-memory audit-supersede` walks the chain, and every
-> `recall()` hit now carries a `why: [...]` provenance list
-> (adopted from agentmemory v1.2.0) that you can surface with
-> `loop-memory recall --verbose`. 26 new regression cases pin
-> both shapes.
+> **What's new in 0.4.7** — **per-memory lifetime stats** +
+> **portable SQLite snapshot**. `loop-memory memory-stats <id>`
+> returns a flat dict (recall_count, positive, negative, age,
+> etc.) so you can ask "is anyone still using this memory?"
+> without cracking open the SQLite file (audit 2026-09-06,
+> agentmemory v1.3.0 pattern). `loop-memory snapshot <out>` /
+> `loop-memory restore <in>` move a single-file, lossless
+> snapshot of the entire store — including recall-quality
+> signals and the supersession chain — to another machine
+> (audit 2026-09-06, codexa-memory v0.2.0 pattern). Both shapes
+> ship with HTTP routes (`/api/memories/{id}/stats`,
+> `/api/snapshot`, `/api/snapshot/restore`). 33 new regression
+> cases pin both shapes.
 > [Full changelog →](CHANGELOG.md)
 
 ---

{loop_memory-0.4.6 → loop_memory-0.4.7}/README.md

@@ -22,15 +22,19 @@
 
 ---
 
-> **What's new in 0.4.6** — **memory supersession chain** + **recall
-> provenance labels**. `merge_memories()` no longer silently
-> `DELETE`s the loser — it writes an explicit `superseded_by`
-> pointer (audit 2026-08-30, Mem0 v2.0.19 Dream pattern), the new
-> `loop-memory audit-supersede` walks the chain, and every
-> `recall()` hit now carries a `why: [...]` provenance list
-> (adopted from agentmemory v1.2.0) that you can surface with
-> `loop-memory recall --verbose`. 26 new regression cases pin
-> both shapes.
+> **What's new in 0.4.7** — **per-memory lifetime stats** +
+> **portable SQLite snapshot**. `loop-memory memory-stats <id>`
+> returns a flat dict (recall_count, positive, negative, age,
+> etc.) so you can ask "is anyone still using this memory?"
+> without cracking open the SQLite file (audit 2026-09-06,
+> agentmemory v1.3.0 pattern). `loop-memory snapshot <out>` /
+> `loop-memory restore <in>` move a single-file, lossless
+> snapshot of the entire store — including recall-quality
+> signals and the supersession chain — to another machine
+> (audit 2026-09-06, codexa-memory v0.2.0 pattern). Both shapes
+> ship with HTTP routes (`/api/memories/{id}/stats`,
+> `/api/snapshot`, `/api/snapshot/restore`). 33 new regression
+> cases pin both shapes.
 > [Full changelog →](CHANGELOG.md)
 
 ---

{loop_memory-0.4.6 → loop_memory-0.4.7}/loop_memory/cli/commands/cognitive.py

@@ -85,6 +85,29 @@ def _build_parser() -> argparse.ArgumentParser:
     rc.add_argument("--dry-run", action="store_true",
                     help="Report what would change without persisting")
 
+    # Audit 2026-09-06: per-memory lifetime stats
+    # (agentmemory v1.3.0 pattern, slimmed down).
+    ms = sub.add_parser(
+        "memory-stats",
+        help="Per-memory lifetime stats (audit 2026-09-06)")
+    ms.add_argument("memory_id",
+                    help="Memory id (or short prefix) to look up")
+    ms.add_argument("--prefix", action="store_true",
+                    help="Allow a short prefix match (first 8+ chars)")
+
+    # Audit 2026-09-06: portable SQLite snapshot
+    # (codexa-memory v0.2.0 pattern).
+    sn = sub.add_parser(
+        "snapshot",
+        help="Write a portable SQLite snapshot of the live store")
+    sn.add_argument("out_path",
+                    help="Destination .memory.sqlite file")
+    rs = sub.add_parser(
+        "restore",
+        help="Re-hydrate a portable SQLite snapshot into the live store")
+    rs.add_argument("in_path",
+                    help="Source .memory.sqlite file")
+
     return p
 
 
@@ -242,3 +265,80 @@ def run_wiki_reclassify_legacy(args: list) -> int:
         })
     summary = reclassify_legacy_pages(s, batch=ns.batch)
     return _emit(summary)
+
+
+def run_memory_stats(args: list) -> int:
+    """``loop-memory memory-stats <id> [--prefix]``
+
+    Per-memory lifetime stats (audit 2026-09-06, agentmemory v1.3.0).
+    Returns a flat dict suitable for ``jq`` and the dashboard.
+
+    With ``--prefix`` the caller can pass the first 8+ chars of the id
+    (handy in a shell pipeline where the full UUID is awkward).
+    """
+    import argparse as _ap
+    p = _ap.ArgumentParser(prog="loop-memory memory-stats")
+    p.add_argument("memory_id")
+    p.add_argument("--prefix", action="store_true")
+    p.add_argument("--db", default=os.environ.get("LOOP_MEMORY_DB", DEFAULT_DB))
+    ns = p.parse_args(args)
+    s = MemoryStore(ns.db)
+    mid = ns.memory_id.strip()
+    if not mid:
+        return _emit({"error": "memory_id is required"})
+    if ns.prefix:
+        # Resolve a prefix to a full id. The store indexes by full
+        # id so we walk a list_memories scan (cheap because prefix
+        # queries are rare / human-driven).
+        candidates = [m.id for m in s.list_memories(limit=10000)
+                      if m.id.startswith(mid)]
+        if not candidates:
+            return _emit({"error": f"no memory matches prefix {mid!r}"})
+        if len(candidates) > 1:
+            return _emit({
+                "error": f"prefix {mid!r} matches {len(candidates)} memories",
+                "candidates": candidates[:8],
+            })
+        mid = candidates[0]
+    res = s.memory_stats(mid)
+    if res is None:
+        return _emit({"error": f"memory {mid!r} not found"})
+    return _emit(res)
+
+
+def run_snapshot(args: list) -> int:
+    """``loop-memory snapshot <out_path>``
+
+    Write a portable SQLite snapshot (audit 2026-09-06,
+    codexa-memory v0.2.0). Returns a summary dict with size + table
+    counts so the caller can confirm the snapshot is sane.
+    """
+    import argparse as _ap
+    p = _ap.ArgumentParser(prog="loop-memory snapshot")
+    p.add_argument("out_path")
+    p.add_argument("--db", default=os.environ.get("LOOP_MEMORY_DB", DEFAULT_DB))
+    ns = p.parse_args(args)
+    s = MemoryStore(ns.db)
+    from ...storage.snapshot import snapshot as _snapshot
+    return _emit(_snapshot(s, ns.out_path))
+
+
+def run_restore(args: list) -> int:
+    """``loop-memory restore <in_path>``
+
+    Re-hydrate a portable SQLite snapshot (audit 2026-09-06,
+    codexa-memory v0.2.0). Returns a summary dict with table counts
+    so the caller can confirm the restore is sane. Refuses
+    wrong-magic files loudly instead of corrupting the live store.
+    """
+    import argparse as _ap
+    p = _ap.ArgumentParser(prog="loop-memory restore")
+    p.add_argument("in_path")
+    p.add_argument("--db", default=os.environ.get("LOOP_MEMORY_DB", DEFAULT_DB))
+    ns = p.parse_args(args)
+    s = MemoryStore(ns.db)
+    from ...storage.snapshot import restore as _restore
+    try:
+        return _emit(_restore(s, ns.in_path))
+    except (FileNotFoundError, ValueError) as e:
+        return _emit({"error": str(e)})

{loop_memory-0.4.6 → loop_memory-0.4.7}/loop_memory/cli/main.py

@@ -118,6 +118,10 @@ COMMANDS = {
     "subgraph": cognitive_cmd.run_subgraph,
     "graph-rebuild": cognitive_cmd.run_graph_rebuild,
     "wiki-reclassify-legacy": cognitive_cmd.run_wiki_reclassify_legacy,
+    # Audit 2026-09-06 — per-memory stats + portable snapshot.
+    "memory-stats": cognitive_cmd.run_memory_stats,
+    "snapshot": cognitive_cmd.run_snapshot,
+    "restore": cognitive_cmd.run_restore,
     "rules": rules_cmd.run_rules,
     "version": _run_version,
 }
@@ -159,6 +163,9 @@ COMMAND_HELP: dict[str, str] = {
     "subgraph":               "loop-memory subgraph <query>   # print a small subgraph.",
     "version":                "loop-memory version   # print the installed distribution version.",
     "wiki-reclassify-legacy": "loop-memory wiki-reclassify-legacy   # back-fill scope + scope_filter for H4+H5 pages.",
+    "memory-stats":           "loop-memory memory-stats <id> [--prefix]   # per-memory lifetime stats (audit 2026-09-06, agentmemory v1.3.0).",
+    "snapshot":               "loop-memory snapshot <out.memory.sqlite>   # write a portable SQLite snapshot (audit 2026-09-06, codexa-memory v0.2.0).",
+    "restore":                "loop-memory restore <in.memory.sqlite>   # re-hydrate a portable SQLite snapshot.",
     "rules":                 "loop-memory rules [--agent codex|claude|hermes|openclaw] [--write] [--force]\n  Print, or append into the agent's rule file, the three-phase memory discipline (task start / mid-task / wrap-up). Never overwrites user content.",
 }
 

{loop_memory-0.4.6 → loop_memory-0.4.7}/loop_memory/serve/routes/export.py

@@ -62,4 +62,40 @@ def register(app: FastAPI, store: MemoryStore, scheduler: Optional[Any] = None)
             raise HTTPException(500, f"import failed: {e}")
         return r.to_dict()
 
+    @app.post("/api/snapshot")
+    def snapshot_create(body: dict):
+        """Write a portable SQLite snapshot of the live store.
 
+        Body: ``{"out_path": "/path/to/file.memory.sqlite"}``. Returns
+        the summary dict from ``loop_memory.storage.snapshot.snapshot``.
+        """
+        from ...storage.snapshot import snapshot as _snapshot
+        out = (body.get("out_path") or "").strip()
+        if not out:
+            raise HTTPException(400, "out_path is required")
+        try:
+            return _snapshot(store, out)
+        except Exception as e:
+            raise HTTPException(500, f"snapshot failed: {e}")
+
+    @app.post("/api/snapshot/restore")
+    def snapshot_restore(body: dict):
+        """Re-hydrate a portable SQLite snapshot into the live store.
+
+        Body: ``{"in_path": "/path/to/file.memory.sqlite"}``. Returns
+        the summary dict from ``loop_memory.storage.snapshot.restore``.
+        Refuses wrong-magic files with a 400 so the dashboard surfaces
+        the error clearly instead of corrupting the live store.
+        """
+        from ...storage.snapshot import restore as _restore
+        in_path = (body.get("in_path") or "").strip()
+        if not in_path:
+            raise HTTPException(400, "in_path is required")
+        try:
+            return _restore(store, in_path)
+        except FileNotFoundError as e:
+            raise HTTPException(404, str(e))
+        except ValueError as e:
+            raise HTTPException(400, str(e))
+        except Exception as e:
+            raise HTTPException(500, f"restore failed: {e}")

{loop_memory-0.4.6 → loop_memory-0.4.7}/loop_memory/serve/routes/memories.py

@@ -414,6 +414,22 @@ def register(app: FastAPI, store: MemoryStore, scheduler: Optional[Any] = None)
         return {"deleted": n}
 
 
+    @app.get("/api/memories/{mid}/stats")
+    def memory_stats_route(mid: str):
+        """Per-memory lifetime stats (audit 2026-09-06).
+
+        Returns the flat dict produced by ``MemoryStore.memory_stats``
+        — see that method for the field list. 404 if the memory id
+        is unknown. The dashboard uses this to surface
+        recall / positive / negative counters alongside each memory
+        row without a second round-trip.
+        """
+        res = store.memory_stats(mid)
+        if res is None:
+            from fastapi import HTTPException
+            raise HTTPException(404, "memory not found")
+        return res
+
     @app.get("/api/memories/{mid}", name="memory_drill_down")
     def memory_drill_down(mid: str):
         """L2 drill-down for a single memory row (full text)."""

loop_memory-0.4.7/loop_memory/storage/snapshot.py

@@ -0,0 +1,231 @@
+"""Portable single-file SQLite snapshot of a :class:`MemoryStore`.
+
+Audit 2026-09-06 (codexa-memory v0.2.0). The markdown ``export-bundle``
+is Git-friendly but lossy: it drops the recall-quality signals,
+entity-mention weights, and the supersession audit trail. This module
+adds a lossless portable snapshot so a user can hand their full store
+to another machine without losing recall fidelity.
+
+The snapshot is a single ``.memory.sqlite`` file that holds the same
+schema + rows as the live store. The header row in ``schema_meta``
+records the schema version + a magic value so a future restore can
+refuse a downgrade or a file from a different project.
+
+Two operations:
+
+* :func:`snapshot` — write a single-file SQLite copy of ``store`` to
+  ``out_path``. Uses ``sqlite3.Connection.backup()`` so the live store
+  is not blocked by a long copy.
+* :func:`restore` — re-hydrate a snapshot file into ``store``. Each
+  table is copied in dependency order with ``INSERT OR REPLACE`` so
+  the operation is idempotent on the primary key. Triggers and the
+  FTS mirrors are NOT copied (they are re-created by ``_init_schema``
+  the next time the live store opens); the live store rebuilds them
+  on demand.
+
+Both operations return a small dict (rows-per-table + timing) so the
+CLI / HTTP route can surface a one-line summary to the user.
+"""
+
+from __future__ import annotations
+
+import shutil
+import sqlite3
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+from ..storage.sqlite_store import MemoryStore
+
+
+SNAPSHOT_MAGIC = "loop_memory_snapshot_v1"
+# Order matters for restore: child tables after their parents so
+# INSERT OR REPLACE never trips a FK constraint. Mirrors and triggers
+# are NOT copied (the live store rebuilds them on demand).
+_RESTORE_ORDER: list[str] = [
+    "sessions",
+    "memories",
+    "memory_signals",
+    "entities",
+    "entity_mentions",
+    "relations",
+    "wiki_pages",
+    "wiki_versions",
+    "cognitive_audit",
+    "contradiction_ignored",
+    "consolidation_runs",
+    "auth_tokens",
+    "settings",
+    "schema_meta",
+    "llm_audit",
+    "pipeline_runs",
+    "write_guard_drops",
+]
+
+
+def _list_user_tables(conn: sqlite3.Connection) -> list[str]:
+    """Names of every user table the snapshot should carry.
+
+    Excludes SQLite-internal tables (``sqlite_*``) and the FTS5
+    shadow tables (``memories_fts_data`` / ``_idx`` / ``_content``
+    / ``_config`` / ``_docsize``); the live store rebuilds the FTS
+    mirrors from the source rows via triggers when it next opens.
+    """
+    rows = conn.execute(
+        "SELECT name FROM sqlite_master "
+        "WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+    ).fetchall()
+    out: list[str] = []
+    skip_suffixes = ("_fts_data", "_fts_idx", "_fts_content",
+                     "_fts_config", "_fts_docsize")
+    for r in rows:
+        name = r["name"]
+        if any(name.endswith(suf) for suf in skip_suffixes):
+            continue
+        out.append(name)
+    return out
+
+
+def snapshot(store: MemoryStore, out_path: str | Path) -> dict[str, Any]:
+    """Write a portable SQLite snapshot of ``store`` to ``out_path``.
+
+    The file at ``out_path`` is overwritten atomically: the snapshot
+    is built in a sibling temp directory (so the WAL / -shm sidecars
+    stay scoped) and then moved into place with ``shutil.move``.
+
+    Returns a summary dict suitable for the CLI / HTTP route.
+    """
+    out = Path(out_path).expanduser().resolve()
+    out.parent.mkdir(parents=True, exist_ok=True)
+    started = time.time()
+    live_path = Path(store.path).expanduser().resolve()
+    with tempfile.TemporaryDirectory(prefix="loop-memory-snapshot-") as td:
+        tmp_dir = Path(td)
+        tmp = tmp_dir / out.name
+        if tmp.exists():
+            tmp.unlink()
+        with sqlite3.connect(live_path) as src, sqlite3.connect(tmp) as dst:
+            src.row_factory = sqlite3.Row
+            # Force the snapshot DB into rollback journal mode so
+            # the destination ends up as a single self-contained
+            # .db file (no WAL sidecar that could later confuse a
+            # reader on macOS).
+            dst.execute("PRAGMA journal_mode=DELETE")
+            src.backup(dst)
+            # Stamp the snapshot header so a future restore can
+            # refuse an obvious mismatch (wrong project, downgrade).
+            dst.execute(
+                "INSERT OR REPLACE INTO schema_meta(k, v) "
+                "VALUES ('snapshot_magic', ?), "
+                "       ('snapshot_source_schema', ?), "
+                "       ('snapshot_taken_at', ?)",
+                (SNAPSHOT_MAGIC, MemoryStore.SCHEMA_VERSION,
+                 time.time()),
+            )
+            dst.commit()
+            dst.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+            table_counts: dict[str, int] = {}
+            for name in _list_user_tables(src):
+                table_counts[name] = src.execute(
+                    f"SELECT COUNT(*) AS c FROM {name}"
+                ).fetchone()["c"]
+        if out.exists():
+            out.unlink()
+        shutil.move(str(tmp), str(out))
+    elapsed = time.time() - started
+    return {
+        "out_path": str(out),
+        "size_bytes": out.stat().st_size,
+        "elapsed_seconds": round(elapsed, 4),
+        "schema_version": MemoryStore.SCHEMA_VERSION,
+        "tables": table_counts,
+    }
+
+
+def restore(store: MemoryStore, snapshot_path: str | Path) -> dict[str, Any]:
+    """Re-hydrate ``snapshot_path`` into ``store``.
+
+    The destination store is upserted (INSERT OR REPLACE on PK) so a
+    restore on top of an existing store is a no-op for rows that
+    already match — useful when a user wants to "merge" snapshots.
+
+    A wrong-magic snapshot raises :class:`ValueError` loudly so the
+    CLI surfaces a useful error instead of silently corrupting the
+    destination store. Schema-downgrade detection is best-effort:
+    the snapshot's ``snapshot_source_schema`` is logged in the
+    summary dict for the dashboard to surface.
+
+    Returns a summary dict suitable for the CLI / HTTP route.
+    """
+    src_path = Path(snapshot_path).expanduser().resolve()
+    if not src_path.exists():
+        raise FileNotFoundError(f"snapshot not found: {src_path}")
+    started = time.time()
+    # Open our own connections (NOT the store's shared connection —
+    # same reason as snapshot() above).
+    live_path = Path(store.path).expanduser().resolve()
+    with sqlite3.connect(live_path) as dst, sqlite3.connect(src_path) as src:
+        src.row_factory = sqlite3.Row
+        try:
+            magic_row = src.execute(
+                "SELECT v FROM schema_meta WHERE k='snapshot_magic'"
+            ).fetchone()
+        except sqlite3.OperationalError:
+            raise ValueError(
+                f"{src_path} is not a loop-memory snapshot "
+                f"(no schema_meta table)"
+            ) from None
+        if magic_row is None or magic_row["v"] != SNAPSHOT_MAGIC:
+            raise ValueError(
+                f"{src_path} is not a loop-memory snapshot "
+                f"(missing or wrong snapshot_magic)"
+            )
+        version_row = src.execute(
+            "SELECT v FROM schema_meta WHERE k='snapshot_source_schema'"
+        ).fetchone()
+        source_version = version_row["v"] if version_row else "unknown"
+        counts: dict[str, int] = {}
+        snapshot_tables = _list_user_tables(src)
+        # Drop the schema_meta snapshot header on the source so it
+        # doesn't clobber the live store's own schema_meta. Also
+        # skip transient / per-install tables that don't belong in
+        # a portable bundle (auth tokens, write-guard drops, etc).
+        sanitised_tables = [
+            t for t in snapshot_tables
+            if t not in {"schema_meta", "llm_audit", "auth_tokens",
+                         "write_guard_drops"}
+        ]
+        ordered = [t for t in _RESTORE_ORDER if t in sanitised_tables]
+        extras = [t for t in sanitised_tables if t not in ordered]
+        ordered.extend(extras)
+        for name in ordered:
+            # Fetch column names via a 0-row probe (cursor.description
+            # is only populated by execute(), not by the connection).
+            probe = src.execute(f"SELECT * FROM {name} WHERE 0")
+            cols = [d[0] for d in (probe.description or [])]
+            probe.close()
+            rows = src.execute(f"SELECT * FROM {name}").fetchall()
+            if not rows:
+                counts[name] = 0
+                continue
+            placeholders = ",".join("?" for _ in cols)
+            col_list = ",".join(f'"{c}"' for c in cols)
+            dst.executemany(
+                f'INSERT OR REPLACE INTO {name} ({col_list}) '
+                f"VALUES ({placeholders})",
+                [tuple(r[c] for c in cols) for r in rows],
+            )
+            counts[name] = len(rows)
+        dst.commit()
+    elapsed = time.time() - started
+    return {
+        "snapshot_path": str(src_path),
+        "elapsed_seconds": round(elapsed, 4),
+        "source_schema_version": source_version,
+        "live_schema_version": MemoryStore.SCHEMA_VERSION,
+        "tables": counts,
+    }
+
+
+__all__ = ["snapshot", "restore", "SNAPSHOT_MAGIC"]

{loop_memory-0.4.6 → loop_memory-0.4.7}/loop_memory/storage/sqlite_store.py

@@ -896,6 +896,69 @@ class MemoryStore:
             ).fetchall()
             return [dict(r) for r in rows]
 
+    # ----- Per-memory lifetime stats (v10) ---------------------------
+
+    def memory_stats(self, mid: str) -> Dict[str, Any]:
+        """Per-memory lifetime stats (audit 2026-09-06, agentmemory v1.3.0).
+
+        Joins the memories row with its memory_signals row and
+        returns a flat dict suitable for the CLI / HTTP route / MCP
+        surface. The shape is intentionally small — one round-trip,
+        no nested objects — so it round-trips cleanly through JSON.
+
+        text is truncated to 240 chars so a 10-KB memory does
+        not blow up the response; callers who want the full text
+        use get_memory(mid).text or the drill-down endpoint.
+
+        Returns None if the memory id is unknown (the dashboard
+        surfaces this as a 404). The signal counters default to 0
+        if the memory has no memory_signals row yet.
+        """
+        mid = str(mid or "")
+        if not mid:
+            return None
+        with self._conn() as c:
+            row = c.execute(
+                """SELECT m.id, m.kind, m.text, m.importance, m.score,
+                          m.source, m.tags, m.created_at, m.updated_at,
+                          m.superseded_by, m.session_id,
+                          COALESCE(s.recall_count, 0)   AS recall_count,
+                          COALESCE(s.positive, 0)       AS positive,
+                          COALESCE(s.negative, 0)       AS negative,
+                          s.last_recalled_at,
+                          s.last_feedback_at
+                   FROM memories m
+                   LEFT JOIN memory_signals s ON s.memory_id = m.id
+                   WHERE m.id = ?""",
+                (mid,),
+            ).fetchone()
+        if row is None:
+            return None
+        text = row["text"] or ""
+        if len(text) > 240:
+            text = text[:237] + "..."
+        now = time.time()
+        age = max(0.0, now - float(row["created_at"]))
+        return {
+            "id": row["id"],
+            "kind": row["kind"],
+            "text": text,
+            "importance": row["importance"],
+            "score": row["score"],
+            "source": row["source"],
+            "tags": row["tags"],
+            "session_id": row["session_id"],
+            "created_at": row["created_at"],
+            "updated_at": row["updated_at"],
+            "superseded_by": row["superseded_by"],
+            "recall_count": row["recall_count"],
+            "positive": row["positive"],
+            "negative": row["negative"],
+            "last_recalled_at": row["last_recalled_at"],
+            "last_feedback_at": row["last_feedback_at"],
+            "age_seconds": age,
+        }
+
     # ----- Pipeline stage recording (v5) ------------------------------
 
     def start_pipeline_run(self, stage: str) -> str:

{loop_memory-0.4.6 → loop_memory-0.4.7}/loop_memory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loop-memory
-Version: 0.4.6
+Version: 0.4.7
 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
@@ -66,15 +66,19 @@ Dynamic: license-file
 
 ---
 
-> **What's new in 0.4.6** — **memory supersession chain** + **recall
-> provenance labels**. `merge_memories()` no longer silently
-> `DELETE`s the loser — it writes an explicit `superseded_by`
-> pointer (audit 2026-08-30, Mem0 v2.0.19 Dream pattern), the new
-> `loop-memory audit-supersede` walks the chain, and every
-> `recall()` hit now carries a `why: [...]` provenance list
-> (adopted from agentmemory v1.2.0) that you can surface with
-> `loop-memory recall --verbose`. 26 new regression cases pin
-> both shapes.
+> **What's new in 0.4.7** — **per-memory lifetime stats** +
+> **portable SQLite snapshot**. `loop-memory memory-stats <id>`
+> returns a flat dict (recall_count, positive, negative, age,
+> etc.) so you can ask "is anyone still using this memory?"
+> without cracking open the SQLite file (audit 2026-09-06,
+> agentmemory v1.3.0 pattern). `loop-memory snapshot <out>` /
+> `loop-memory restore <in>` move a single-file, lossless
+> snapshot of the entire store — including recall-quality
+> signals and the supersession chain — to another machine
+> (audit 2026-09-06, codexa-memory v0.2.0 pattern). Both shapes
+> ship with HTTP routes (`/api/memories/{id}/stats`,
+> `/api/snapshot`, `/api/snapshot/restore`). 33 new regression
+> cases pin both shapes.
 > [Full changelog →](CHANGELOG.md)
 
 ---

{loop_memory-0.4.6 → loop_memory-0.4.7}/loop_memory.egg-info/SOURCES.txt

@@ -80,6 +80,7 @@ loop_memory/serve/static/__init__.py
 loop_memory/serve/static/index.html
 loop_memory/storage/__init__.py
 loop_memory/storage/retrieval.py
+loop_memory/storage/snapshot.py
 loop_memory/storage/sqlite_store.py
 loop_memory/wiki/__init__.py
 loop_memory/wiki/backfill.py
@@ -91,8 +92,10 @@ tests/test_agent_memory_api.py
 tests/test_agent_memory_sdk.py
 tests/test_auth_token_rotate.py
 tests/test_cli_audit_supersede.py
+tests/test_cli_memory_stats.py
 tests/test_cli_recall_verbose.py
 tests/test_cli_rules.py
+tests/test_cli_snapshot.py
 tests/test_cli_v7.py
 tests/test_cli_version.py
 tests/test_contradictions.py
@@ -109,6 +112,7 @@ tests/test_llm_test_endpoint.py
 tests/test_loop.py
 tests/test_mcp.py
 tests/test_memories_pagination.py
+tests/test_memory_stats.py
 tests/test_openclaw_loader.py
 tests/test_package_version.py
 tests/test_recall_provenance.py
@@ -121,6 +125,7 @@ tests/test_serve_app.py
 tests/test_serve_handlers.py
 tests/test_session_order.py
 tests/test_short_query.py
+tests/test_snapshot.py
 tests/test_store.py
 tests/test_summarization.py
 tests/test_supersession_chain.py

{loop_memory-0.4.6 → loop_memory-0.4.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "loop-memory"
-version = "0.4.6"
+version = "0.4.7"
 description = "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."
 readme = "README.md"
 requires-python = ">=3.10"