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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loop-memory
-Version: 0.4.6
+Version: 0.4.8
 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,37 @@ 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.8** — **L0 outline recall** +
+> **per-agent identity bootstrap**. `loop-memory recall-paths <q>`
+> (and the new `recall --outline` flag) returns only `id` +
+> `abstract` + `score` + `why` for each hit — never the full
+> body — so an agent can identify the top candidates cheaply
+> before deciding which bodies to fetch (audit 2026-09-13,
+> tigerless-labs/agent-memory v0.3.0 recall-ladder pattern).
+> `loop-memory init --agent <name>` registers an agent in the
+> new `agents` table and (with `--install-hooks`) also wires
+> the MCP + SessionStart hooks for codex/claude/hermes; the
+> index is bumped on every `install-hooks` run so a user can
+> always answer "which CLIs are wired into this store?" with
+> one SQL query (audit 2026-09-13, Mem0 CLI `init --agent`
+> pattern). Both shapes ship with HTTP routes
+> (`/api/recall/outline`, `/api/agents`, `/api/init/agent`).
+> 57 new regression cases pin both shapes. [Full
+> changelog →](CHANGELOG.md)
+>
+> **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.8}/README.md

@@ -22,15 +22,37 @@
 
 ---
 
-> **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.8** — **L0 outline recall** +
+> **per-agent identity bootstrap**. `loop-memory recall-paths <q>`
+> (and the new `recall --outline` flag) returns only `id` +
+> `abstract` + `score` + `why` for each hit — never the full
+> body — so an agent can identify the top candidates cheaply
+> before deciding which bodies to fetch (audit 2026-09-13,
+> tigerless-labs/agent-memory v0.3.0 recall-ladder pattern).
+> `loop-memory init --agent <name>` registers an agent in the
+> new `agents` table and (with `--install-hooks`) also wires
+> the MCP + SessionStart hooks for codex/claude/hermes; the
+> index is bumped on every `install-hooks` run so a user can
+> always answer "which CLIs are wired into this store?" with
+> one SQL query (audit 2026-09-13, Mem0 CLI `init --agent`
+> pattern). Both shapes ship with HTTP routes
+> (`/api/recall/outline`, `/api/agents`, `/api/init/agent`).
+> 57 new regression cases pin both shapes. [Full
+> changelog →](CHANGELOG.md)
+>
+> **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.8}/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.8}/loop_memory/cli/commands/hooks.py

@@ -46,7 +46,7 @@ def _upsert_block(text: str, block: str, marker: str) -> str:
     return "".join(lines[:start]) + block + "".join(lines[end:])
 
 
-def _install_codex(home: Path, actions: list) -> None:
+def _install_codex(home: Path, actions: list, store=None) -> None:
     codex_dir = home / ".codex"
     codex_cfg = codex_dir / "config.toml"
     # Codex's TOML schema: `hooks` is a struct (HooksToml) keyed by event
@@ -104,11 +104,13 @@ def _install_codex(home: Path, actions: list) -> None:
             except Exception: pass
             return
         actions.append(f"codex → {codex_cfg}" + ("" if parse_ok else " (unverified)"))
+        if store is not None:
+            store.register_agent("codex", hooks_installed=True)
     except Exception as e:
         actions.append(f"codex → SKIP ({e})")
 
 
-def _install_claude(home: Path, actions: list) -> None:
+def _install_claude(home: Path, actions: list, store=None) -> None:
     claude_dir = home / ".claude"
     claude_mcp = claude_dir / "mcp.json"
     claude_settings = claude_dir / "settings.json"
@@ -148,9 +150,11 @@ def _install_claude(home: Path, actions: list) -> None:
         })
     claude_settings.write_text(json.dumps(existing_s, ensure_ascii=False, indent=2), encoding="utf-8")
     actions.append(f"claude (SessionStart hook) → {claude_settings}")
+    if store is not None:
+        store.register_agent("claude", hooks_installed=True)
 
 
-def _install_hermes(home: Path, actions: list) -> None:
+def _install_hermes(home: Path, actions: list, store=None) -> None:
     hermes_dir = home / ".hermes"
     hermes_cfg = hermes_dir / "mcp.json"
     if not hermes_dir.exists():
@@ -168,6 +172,8 @@ def _install_hermes(home: Path, actions: list) -> None:
     hermes_cfg.parent.mkdir(parents=True, exist_ok=True)
     hermes_cfg.write_text(json.dumps(existing, ensure_ascii=False, indent=2), encoding="utf-8")
     actions.append(f"hermes → {hermes_cfg}")
+    if store is not None:
+        store.register_agent("hermes", hooks_installed=True)
 
 
 def _openclaw_hint(home: Path, actions: list) -> None:
@@ -200,13 +206,75 @@ def run_install_hooks(_args) -> int:
     """
     home = Path.home()
     actions: list = []
-    _install_codex(home, actions)
-    _install_claude(home, actions)
-    _install_hermes(home, actions)
+    # Audit 2026-09-13 (Mem0 CLI init --agent pattern) — record which
+    # agents we touched so the per-agent index stays accurate. The
+    # store is best-effort: if the SQLite path can't open, we fall
+    # back to "install only" so the user is never blocked by a DB
+    # hiccup during a one-line CLI install.
+    store = None
+    try:
+        from ...storage.sqlite_store import MemoryStore
+        from ...cli._common import default_db_path
+        store = MemoryStore(default_db_path())
+    except Exception:
+        store = None
+    _install_codex(home, actions, store=store)
+    _install_claude(home, actions, store=store)
+    _install_hermes(home, actions, store=store)
     _openclaw_hint(home, actions)
+    if store is not None:
+        # OpenClaw is hinted (no auto-install) so we only touch it.
+        store.touch_agent("openclaw")
     print("[loop-memory] install-hooks results:")
     for a in actions:
         print(f"  · {a}")
     print()
     print("Restart your CLI to pick up the new MCP server + hooks.")
     return 0
+
+
+
+def run_init(args) -> int:
+    """``loop-memory init --agent <name> [--install-hooks]``.
+
+    Audit 2026-09-13 (Mem0 CLI ``mem0 init --agent <name>`` pattern).
+    Registers an agent in the per-agent identity index and, when
+    ``--install-hooks`` is passed, also runs the standard
+    ``install-hooks`` flow so MCP + SessionStart hooks are written
+    for that agent's CLI client. Idempotent — re-running for the
+    same name just bumps ``last_seen_at``.
+    """
+    from ...storage.sqlite_store import MemoryStore
+    from ...cli._common import default_db_path, die
+    agent_name: str | None = None
+    install_hooks = False
+    i = 0
+    while i < len(args):
+        a = args[i]
+        if a == "--agent" and i + 1 < len(args):
+            agent_name = args[i + 1].strip()
+            i += 2
+        elif a == "--install-hooks":
+            install_hooks = True
+            i += 1
+        elif a == "--help" or a == "-h":
+            print("usage: loop-memory init --agent <name> [--install-hooks]")
+            return 0
+        elif a.startswith("--"):
+            return die(f"[loop-memory] unknown flag: {a}")
+        else:
+            return die(f"[loop-memory] unexpected positional: {a}")
+    if not agent_name:
+        return die("usage: loop-memory init --agent <name> [--install-hooks]")
+    store = MemoryStore(default_db_path())
+    rec = store.register_agent(agent_name, hooks_installed=False)
+    verb = "registered" if rec["created"] else "refreshed"
+    print(f"[loop-memory] {verb} agent {agent_name!r} (scope={rec['scope']}, "
+          f"hooks_installed={rec['hooks_installed']}, "
+          f"last_seen_at={rec['last_seen_at']:.0f}).")
+    if install_hooks:
+        # Delegate to the standard install-hooks flow so the MCP + inject
+        # hook files get written for codex/claude/hermes if any of those
+        # clients are installed.
+        run_install_hooks([])
+    return 0

{loop_memory-0.4.6 → loop_memory-0.4.8}/loop_memory/cli/commands/read.py

@@ -66,6 +66,7 @@ def run_recall(args) -> int:
     # we don't want argparse to swallow a token that happens to start
     # with "--" inside the user's query (e.g. ``recall --foo bar``).
     verbose = False
+    outline = False
     limit = 10
     qargs: list[str] = []
     i = 0
@@ -74,6 +75,12 @@ def run_recall(args) -> int:
         if a == "--verbose":
             verbose = True
             i += 1
+        elif a == "--outline":
+            # Audit 2026-09-13 (tigerless-labs/agent-memory v0.3.0) —
+            # cheap L0 list instead of full text. Sets a flag and
+            # routes the call to ``recall_paths`` below.
+            outline = True
+            i += 1
         elif a == "--limit" and i + 1 < len(args):
             try:
                 limit = int(args[i + 1])
@@ -86,10 +93,13 @@ def run_recall(args) -> int:
             qargs.append(a)
             i += 1
     if not qargs:
-        return die("usage: loop-memory recall <query> [--verbose] [--limit N]")
+        return die("usage: loop-memory recall <query> [--verbose] [--outline] [--limit N]")
     store = MemoryStore(default_db_path())
     query = " ".join(qargs)
-    r = store.recall(query, limit=limit)
+    if outline:
+        r = store.recall_paths(query, limit=limit)
+    else:
+        r = store.recall(query, limit=limit)
     has = False
     if r["wiki"]:
         has = True
@@ -97,7 +107,9 @@ def run_recall(args) -> int:
         for w in r["wiki"]:
             tag_s = "  [" + ", ".join(w.get("tags") or []) + "]" if w.get("tags") else ""
             print(f"- **{w['title']}** (`{w['slug']}`) — imp {w['importance']:.2f}{tag_s}")
-            if w.get("summary"):
+            if outline:
+                print(f"  > {w.get('abstract','')}")
+            elif w.get("summary"):
                 print(f"  > {w['summary'][:240]}")
         print()
     if r["memories"]:
@@ -111,7 +123,11 @@ def run_recall(args) -> int:
                 # render the list as a deterministic badge strip without
                 # re-sorting.
                 print(f"  why: {', '.join(m['why'])}")
-            print(f"  {m['text'][:240]}")
+            if outline:
+                # L0 outline mode: print only the short abstract.
+                print(f"  {m.get('abstract','')}")
+            else:
+                print(f"  {m['text'][:240]}")
         print()
     if r["entities"]:
         has = True
@@ -398,3 +414,65 @@ def run_inject(args) -> int:
                     out.write(f"  {text}\n")
     sys.stdout.write(out.getvalue())
     return 0
+
+
+
+def run_recall_paths(args) -> int:
+    """``loop-memory recall-paths <query> [--limit N]``.
+
+    Audit 2026-09-13 (tigerless-labs/agent-memory v0.3.0). Returns
+    only ``id`` + ``abstract`` + ``score`` + ``why`` for each hit —
+    no full text, no body. Use this when an agent needs to *decide*
+    which candidate to open; once it has picked an id, fetch the
+    body via ``GET /api/memories/{id}`` or ``GET /api/wiki/{slug}``.
+    """
+    from ...storage.sqlite_store import MemoryStore
+    if not args:
+        return die("usage: loop-memory recall-paths <query> [--limit N]")
+    limit = 12
+    qargs: list[str] = []
+    i = 0
+    while i < len(args):
+        a = args[i]
+        if a == "--limit" and i + 1 < len(args):
+            try:
+                limit = int(args[i + 1])
+            except ValueError:
+                return die(f"--limit must be an integer, got {args[i + 1]!r}")
+            i += 2
+        elif a.startswith("--"):
+            return die(f"unknown flag: {a}")
+        else:
+            qargs.append(a)
+            i += 1
+    if not qargs:
+        return die("usage: loop-memory recall-paths <query> [--limit N]")
+    store = MemoryStore(default_db_path())
+    query = " ".join(qargs)
+    r = store.recall_paths(query, limit=limit)
+    has = False
+    if r["memories"]:
+        has = True
+        print(f"## Outline (memories, {len(r['memories'])} match{'es' if len(r['memories'])!=1 else ''})")
+        for m in r["memories"]:
+            why = f"  why: {', '.join(m['why'])}" if m.get("why") else ""
+            print(f"- [{m['kind']}] score={m['score']:.2f} id={m['id']}{why}")
+            print(f"  > {m.get('abstract','')}")
+        print()
+    if r["wiki"]:
+        has = True
+        print(f"## Outline (wiki, {len(r['wiki'])} match{'es' if len(r['wiki'])!=1 else ''})")
+        for w in r["wiki"]:
+            why = f"  why: {', '.join(w['why'])}" if w.get("why") else ""
+            print(f"- score={w['score']:.2f} slug={w['slug']}{why}")
+            print(f"  > {w.get('abstract','')}")
+        print()
+    if r["entities"]:
+        has = True
+        print(f"## Outline (entities, {len(r['entities'])})")
+        for e in r["entities"]:
+            print(f"- {e['name']} _({e['entity_kind']}, w={e['weight']:.2f})_")
+        print()
+    if not has:
+        print(f"_( nothing matched {query!r})_")
+    return 0

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

@@ -118,6 +118,13 @@ 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,
+    # Audit 2026-09-13 — L0 outline recall + per-agent identity bootstrap.
+    "recall-paths": read_cmd.run_recall_paths,
+    "init": hooks_cmd.run_init,
     "rules": rules_cmd.run_rules,
     "version": _run_version,
 }
@@ -159,6 +166,13 @@ 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.",
+    # Audit 2026-09-13 — L0 outline recall (tigerless-labs/agent-memory v0.3.0).
+    "recall-paths":           "loop-memory recall-paths <query> [--limit N]   # cheap L0 outline (id+abstract+score) instead of full text (audit 2026-09-13).",
+    # Audit 2026-09-13 — per-agent identity bootstrap (Mem0 CLI init --agent pattern).
+    "init":                   "loop-memory init --agent <name> [--install-hooks]   # register an agent + (optionally) install hooks.",
     "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.8}/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.8}/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.6 → loop_memory-0.4.8}/loop_memory/serve/routes/system.py

@@ -392,6 +392,98 @@ def register(app: FastAPI, store: MemoryStore, scheduler: Optional[Any] = None,
         }
 
 
+    @app.get("/api/recall/outline")
+    def recall_outline(query: str = "", limit: int = 12,
+                       include: str = "memories,wiki,entities",
+                       bump: int = 0, source: str | None = None):
+        """Audit 2026-09-13 — L0 outline recall (tigerless-labs/agent-memory
+        v0.3.0 recall ladder pattern).
+
+        Returns the same ranked lists as ``GET /api/recall`` but each
+        hit carries only ``id`` + ``kind`` + ``abstract`` (≤80 chars)
+        + ``score`` + ``why`` -- never the full ``text`` / ``body``.
+        Use this when an agent needs to *decide* which candidate to
+        open; once it has picked an id, fetch the body via
+        ``GET /api/memories/{id}`` or ``GET /api/wiki/{slug}``.
+
+        ``bump`` defaults to 0 so the L0 listing does not inflate
+        ``recall_count`` before the agent has actually decided to read
+        the body. Set ``bump=1`` only when the agent commits to the
+        candidate set.
+        """
+        if not query:
+            raise HTTPException(status_code=400, detail="query is required")
+        wanted = tuple(s.strip() for s in include.split(",") if s.strip())
+        if not wanted:
+            wanted = ("memories", "wiki", "entities")
+        r = store.recall_paths(
+            query,
+            limit=limit,
+            include=wanted,
+            bump_signals=bool(bump),
+            source=source,
+        )
+        return {
+            "query": query,
+            "tokens": r.get("tokens", []),
+            "memories": r.get("memories", []),
+            "wiki": r.get("wiki", []),
+            "entities": r.get("entities", []),
+            "mode": "outline",
+            "source": source,
+        }
+
+
+    @app.get("/api/agents")
+    def list_agents_route():
+        """Audit 2026-09-13 — list all registered agents (Mem0 CLI
+        ``init --agent`` pattern). Each entry includes ``name``,
+        ``scope``, ``created_at``, ``last_seen_at``,
+        ``hooks_installed`` so a user can answer "which CLIs are
+        wired into this store?" with a single HTTP GET.
+        """
+        return {"agents": store.list_agents()}
+
+
+    @app.post("/api/init/agent")
+    def init_agent_route(body: dict):
+        """Audit 2026-09-13 — register (or refresh) a named agent.
+
+        Body keys (all optional except ``name``):
+          - ``name`` (str, required) — e.g. ``"codex"``, ``"claude"``,
+            ``"hermes"``, ``"openclaw"``, or a custom name.
+          - ``scope`` (str, default ``"global"``) — reserved for
+            future per-source isolation; today always ``"global"``.
+          - ``install_hooks`` (bool, default ``false``) — when true,
+            also runs the equivalent of ``install-hooks`` so MCP +
+            SessionStart files are written for codex/claude/hermes if
+            those clients are installed locally. Best-effort: a hook
+            failure does not fail the registration.
+
+        Idempotent — re-registering an existing name just bumps
+        ``last_seen_at``. Returns the persisted row.
+        """
+        if not isinstance(body, dict):
+            raise HTTPException(status_code=400, detail="body must be a JSON object")
+        name = (body.get("name") or "").strip()
+        if not name:
+            raise HTTPException(status_code=400, detail="name is required")
+        scope = (body.get("scope") or "global").strip() or "global"
+        want_hooks = bool(body.get("install_hooks", False))
+        rec = store.register_agent(name, scope=scope, hooks_installed=want_hooks)
+        if want_hooks:
+            # Best-effort: write MCP + SessionStart hooks for whatever
+            # local CLI clients the user has installed. We don't
+            # surface the per-client summary here; ``install-hooks``
+            # already prints its own summary when run from the CLI.
+            try:
+                from ...cli.commands.hooks import run_install_hooks
+                run_install_hooks([])
+            except Exception:
+                pass
+        return rec
+
+
     @app.get("/api/pipeline")
     def pipeline_dashboard_route():
         """5-stage data flow dashboard. See handlers.pipeline_dashboard."""