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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loop-memory
-Version: 0.4.8
+Version: 0.4.9
 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,6 +66,8 @@ Dynamic: license-file
 
 ---
 
+> **What's new in 0.4.9** — **OKF v0.2 export** + **bi-temporal `as_of` recall**. `loop-memory export-okf <dir>` writes an [Open Knowledge Format](https://github.com/okf/SPEC) v0.2 bundle — one `.md` file per wiki page with YAML frontmatter + an `index.md` index — so a Loop Memory store can be handed to any OKF-aware tool (Grep, Obsidian, akitaonrails/ai-memory, okf-agent-memory, ...) without re-parsing the body (audit 2026-09-20, Google OKF v0.2 spec + akitaonrails/ai-memory 2.0 + okf-memory/okf-agent-memory, all Apache-2.0/MIT, 2026-09-01 → 2026-09-06). `loop-memory recall <q> --as-of <ISO|epoch>` answers the bi-temporal question "what did we know about this query at that moment?" — a memory written after the moment is invisible, and a superseded memory walks its chain to find whether the invalidation had happened by then (audit 2026-09-20, loomcycle v1.33-v1.49 RFCs BL/BS/BU/BV/BW, Apache-2.0). Both shapes ship with HTTP routes (`POST /api/export/okf`, `GET /api/recall?as_of=...`). 34 new regression cases pin both shapes. [Full CHANGELOG →](./CHANGELOG.md#049---2026-09-20)
+
 > **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` +

{loop_memory-0.4.8 → loop_memory-0.4.9}/README.md

@@ -22,6 +22,8 @@
 
 ---
 
+> **What's new in 0.4.9** — **OKF v0.2 export** + **bi-temporal `as_of` recall**. `loop-memory export-okf <dir>` writes an [Open Knowledge Format](https://github.com/okf/SPEC) v0.2 bundle — one `.md` file per wiki page with YAML frontmatter + an `index.md` index — so a Loop Memory store can be handed to any OKF-aware tool (Grep, Obsidian, akitaonrails/ai-memory, okf-agent-memory, ...) without re-parsing the body (audit 2026-09-20, Google OKF v0.2 spec + akitaonrails/ai-memory 2.0 + okf-memory/okf-agent-memory, all Apache-2.0/MIT, 2026-09-01 → 2026-09-06). `loop-memory recall <q> --as-of <ISO|epoch>` answers the bi-temporal question "what did we know about this query at that moment?" — a memory written after the moment is invisible, and a superseded memory walks its chain to find whether the invalidation had happened by then (audit 2026-09-20, loomcycle v1.33-v1.49 RFCs BL/BS/BU/BV/BW, Apache-2.0). Both shapes ship with HTTP routes (`POST /api/export/okf`, `GET /api/recall?as_of=...`). 34 new regression cases pin both shapes. [Full CHANGELOG →](./CHANGELOG.md#049---2026-09-20)
+
 > **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` +

{loop_memory-0.4.8 → loop_memory-0.4.9}/loop_memory/cli/commands/cognitive.py

@@ -108,6 +108,17 @@ def _build_parser() -> argparse.ArgumentParser:
     rs.add_argument("in_path",
                     help="Source .memory.sqlite file")
 
+    # Audit 2026-09-20: OKF v0.2 bundle export
+    # (akitaonrails/ai-memory 2.0 + okf-memory/okf-agent-memory +
+    # Google OKF v0.2 spec).
+    eo = sub.add_parser(
+        "export-okf",
+        help="Export wiki pages as an OKF v0.2 markdown bundle")
+    eo.add_argument("out_dir",
+                    help="Destination directory for the bundle")
+    eo.add_argument("--scope", default=None,
+                    help="Filter: 'global' or a single source token (e.g. codex)")
+
     return p
 
 
@@ -342,3 +353,25 @@ def run_restore(args: list) -> int:
         return _emit(_restore(s, ns.in_path))
     except (FileNotFoundError, ValueError) as e:
         return _emit({"error": str(e)})
+
+
+def run_export_okf(args) -> int:
+    """``loop-memory export-okf <out_dir> [--scope SCOPE]``
+
+    Audit 2026-09-20: OKF v0.2 bundle export
+    (akitaonrails/ai-memory 2.0 + okf-memory/okf-agent-memory +
+    Google OKF v0.2 spec). Returns a summary dict with the bundle
+    root + per-page list so the caller can confirm the bundle is
+    sane. ``--scope`` accepts ``global`` (only globally-scoped
+    pages) or a single source token (only pages whose scope list
+    contains the token); omit the flag to emit every page.
+    """
+    import argparse as _ap
+    p = _ap.ArgumentParser(prog="loop-memory export-okf")
+    p.add_argument("out_dir")
+    p.add_argument("--scope", default=None)
+    p.add_argument("--db", default=os.environ.get("LOOP_MEMORY_DB", DEFAULT_DB))
+    ns = p.parse_args(args)
+    s = MemoryStore(ns.db)
+    r = s.export_okf(ns.out_dir, scope_filter=ns.scope)
+    return _emit(r)

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

@@ -51,13 +51,17 @@ def run_stats(_args) -> int:
 
 
 def run_recall(args) -> int:
-    """Run ``loop-memory recall <query> [--verbose] [--limit N]``.
+    """Run ``loop-memory recall <query> [--verbose] [--outline] [--as-of T] [--limit N]``.
 
     With ``--verbose`` each memory hit is annotated with the
     ``why: [...]`` provenance labels produced by ``MemoryStore.recall``
-    (audit 2026-08-30, agentmemory v1.2.0 pattern). The wiki and
-    entity sections are unchanged — only the raw-memory block grows
-    the new line.
+    (audit 2026-08-30, agentmemory v1.2.0 pattern). ``--outline``
+    switches to the L0 list (audit 2026-09-13, tigerless-labs/
+    agent-memory v0.3.0). ``--as-of <float-or-ISO>`` enables
+    bi-temporal recall (audit 2026-09-20, loomcycle v1.33+) so a
+    caller can ask "what did we know about this query at that
+    moment?". The wiki and entity sections are unchanged — only
+    the raw-memory block grows the new line.
     """
     from ...storage.sqlite_store import MemoryStore
     if not args:
@@ -68,6 +72,7 @@ def run_recall(args) -> int:
     verbose = False
     outline = False
     limit = 10
+    as_of: float | None = None
     qargs: list[str] = []
     i = 0
     while i < len(args):
@@ -81,6 +86,24 @@ def run_recall(args) -> int:
             # routes the call to ``recall_paths`` below.
             outline = True
             i += 1
+        elif a == "--as-of" and i + 1 < len(args):
+            # Audit 2026-09-20 (loomcycle v1.33+) — bi-temporal
+            # recall: "what did we know about this query at that
+            # moment?". Accepts float epoch OR ISO-8601 string.
+            raw = args[i + 1].strip()
+            try:
+                as_of = float(raw)
+            except ValueError:
+                try:
+                    from datetime import datetime
+                    as_of = datetime.fromisoformat(
+                        raw.replace("Z", "+00:00")
+                    ).timestamp()
+                except Exception:
+                    return die(
+                        f"--as-of must be float epoch or ISO-8601; got {raw!r}"
+                    )
+            i += 2
         elif a == "--limit" and i + 1 < len(args):
             try:
                 limit = int(args[i + 1])
@@ -93,10 +116,15 @@ def run_recall(args) -> int:
             qargs.append(a)
             i += 1
     if not qargs:
-        return die("usage: loop-memory recall <query> [--verbose] [--outline] [--limit N]")
+        return die("usage: loop-memory recall <query> [--verbose] [--outline] [--as-of <ISO|epoch>] [--limit N]")
     store = MemoryStore(default_db_path())
     query = " ".join(qargs)
-    if outline:
+    if as_of is not None:
+        try:
+            r = store.recall_as_of(query, as_of, limit=limit)
+        except ValueError as e:
+            return die(str(e))
+    elif outline:
         r = store.recall_paths(query, limit=limit)
     else:
         r = store.recall(query, limit=limit)

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

@@ -125,6 +125,9 @@ COMMANDS = {
     # Audit 2026-09-13 — L0 outline recall + per-agent identity bootstrap.
     "recall-paths": read_cmd.run_recall_paths,
     "init": hooks_cmd.run_init,
+    # Audit 2026-09-20 — OKF v0.2 export (akitaonrails/ai-memory 2.0
+    # + okf-agent-memory + Google OKF spec).
+    "export-okf": cognitive_cmd.run_export_okf,
     "rules": rules_cmd.run_rules,
     "version": _run_version,
 }
@@ -158,7 +161,7 @@ COMMAND_HELP: dict[str, str] = {
     "install-hooks":          "loop-memory install-hooks   # auto-write MCP + SessionStart hooks for known clients.",
     "mcp":                    "loop-memory mcp   # stdio MCP server (for codex/claude/hermes). Requires ``[serve]`` for HTTP transport.",
     "openclaw-setup":         "loop-memory openclaw-setup   # install the openclaw/clawx auto-ingest watcher (launchd on macOS).",
-    "recall":                 "loop-memory recall <text>   # show top memories.",
+    "recall":                 "loop-memory recall <text> [--as-of <ISO|epoch>]   # show top memories (--as-of = bi-temporal recall).",
     "rescore":                "loop-memory rescore [--half-life 30]   # recompute memory scores.",
     "serve":                  "loop-memory serve [--port 7767] [--no-browser]   # start the local web UI. Requires the ``[serve]`` extra (fastapi + uvicorn).",
     "stats":                  "loop-memory stats   # counters.",
@@ -168,6 +171,7 @@ COMMAND_HELP: dict[str, str] = {
     "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).",
+    "export-okf":             "loop-memory export-okf <out_dir> [--scope S]   # write an OKF v0.2 bundle (audit 2026-09-20).",
     "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).",

{loop_memory-0.4.8 → loop_memory-0.4.9}/loop_memory/serve/routes/system.py

@@ -350,7 +350,8 @@ def register(app: FastAPI, store: MemoryStore, scheduler: Optional[Any] = None,
     @app.get("/api/recall")
     def recall(query: str, limit: int = 10, include: str = "memories,wiki,entities",
               bump: int = 1, source: str | None = None,
-              mode: str = "hybrid", level: int = 1):
+              mode: str = "hybrid", level: int = 1,
+              as_of: str | None = None):
         """Unified recall — wiki + memories + entities in one ranked stream.
 
         ``mode`` is 'hybrid' (default) for BM25+semantic+entity RRF,
@@ -363,11 +364,31 @@ def register(app: FastAPI, store: MemoryStore, scheduler: Optional[Any] = None,
         and memories whose source matches this token are boosted. The
         dashboard passes the currently-active client (codex/claude/
         hermes/openclaw); the MCP/CLI tools pass the calling client.
+
+        ``as_of`` (audit 2026-09-20, loomcycle v1.33+) enables
+        bi-temporal recall: a float epoch OR an ISO-8601 string that
+        answers "what did we know about this query at that moment?".
+        When unset (default) the call returns the latest answer
+        (preserves the pre-0.4.9 contract). When set, the call
+        routes through ``MemoryStore.recall_as_of``.
         """
         wanted = tuple(s.strip() for s in include.split(",") if s.strip())
         if not wanted:
             wanted = ("memories", "wiki", "entities")
-        if mode == "legacy" or not hasattr(store, "recall_hybrid"):
+        if as_of is not None and str(as_of).strip():
+            try:
+                r = store.recall_as_of(
+                    query,
+                    as_of,
+                    limit=limit,
+                    include=wanted,
+                    bump_signals=bool(bump),
+                    source=source,
+                )
+                recall_mode = "as_of"
+            except ValueError as e:
+                raise HTTPException(400, str(e))
+        elif mode == "legacy" or not hasattr(store, "recall_hybrid"):
             r = store.recall(
                 query,
                 limit=limit,
@@ -375,23 +396,54 @@ def register(app: FastAPI, store: MemoryStore, scheduler: Optional[Any] = None,
                 bump_signals=bool(bump),
                 source=source,
             )
+            recall_mode = mode
         else:
             r = store.recall_hybrid(
                 query, limit=limit, include=wanted,
                 bump_signals=bool(bump), source=source, level=level,
             )
+            recall_mode = mode
         return {
             "query": query,
             "tokens": r.get("tokens", []),
             "memories": r.get("memories", []),
             "wiki": r.get("wiki", []),
             "entities": r.get("entities", []),
-            "mode": mode,
+            "mode": recall_mode,
             "source": source,
             "level": level,
+            "as_of": as_of,
         }
 
 
+    @app.post("/api/export/okf")
+    def export_okf(body: dict):
+        """Audit 2026-09-20: OKF v0.2 bundle export.
+
+        Body shape::
+
+            {
+              "out_dir": "/abs/path/to/out",
+              "scope":   "global"   # optional: "global" or a source token
+            }
+
+        Writes one ``.md`` file per wiki page under
+        ``<out_dir>/pages/<slug>.md`` plus an ``index.md`` index.
+        See ``MemoryStore.export_okf`` for the field-mapping
+        contract.
+        """
+        out_dir = (body.get("out_dir") or "").strip()
+        if not out_dir:
+            raise HTTPException(400, "out_dir is required")
+        scope = body.get("scope")
+        if scope is not None:
+            scope = str(scope).strip() or None
+        try:
+            r = store.export_okf(out_dir, scope_filter=scope)
+        except Exception as e:
+            raise HTTPException(500, f"export-okf failed: {e}")
+        return r
+
     @app.get("/api/recall/outline")
     def recall_outline(query: str = "", limit: int = 12,
                        include: str = "memories,wiki,entities",