loop-memory 0.4.10__tar.gz → 0.4.12__tar.gz

{loop_memory-0.4.10 → loop_memory-0.4.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loop-memory
-Version: 0.4.10
+Version: 0.4.12
 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,21 @@ Dynamic: license-file
 
 ---
 
+> **What's new in 0.4.12** — **OKF bundle import** + **DB-level audit enforcement** (audit 2026-09-27). The new `loop-memory import-okf <in_dir>` (and `POST /api/import/okf`) is the symmetric counterpart to `export-okf` (0.4.9) — bring an OKF v0.2 bundle back into Loop Memory as wiki pages, with idempotent upsert on `(scope, slug)`, optional `--dry-run` and `--skip-conflicts`. Source: `thecolourfoundation/rune` HN launch (MIT, 2026-09-25) + `okf-memory/okf-agent-memory` Issues #12-#15 + `Deja-Vu` (MIT, 2026-09-24) + Google OKF v0.2 spec (Apache-2.0, 2026-09-01). The new `MemoryStore._install_audit_triggers()` installs 12 SQLite triggers on `memories` / `wiki_pages` / `relations` / `consolidation_runs` so the `audit_log` table cannot be skipped — even a raw `sqlite3` writer that bypasses the Python wrapper still appends an audit row with `actor='db_trigger'`. New `MemoryStore.list_audit_log()` reads the log; `GET /api/stats` reports `audit_log` + `audit_triggers` counts. Source: `cogstate-eng/memory-eternal v0.4.3` `enforceAudit()` pattern (MIT, 2026-09-23). 31 new regression cases. [Full CHANGELOG →](./CHANGELOG.md#0412---2026-09-27)
+
+> **What's new in 0.4.11** — **operational probes** +
+**SQLite write-contention fix** (audit 2026-09-24). New
+``GET /api/healthz`` (liveness) + ``GET /api/readyz``
+(readiness) endpoints let Kubernetes / launchd keepalive
+polls probe the serve without provisioning a Bearer token;
+``/api/readyz`` returns 503 when the SQLite store is
+unreachable. Also fixed a real concurrency bug: every
+store connection now sets ``PRAGMA busy_timeout=5000``
+(was 0 ms) so the watcher + serve + scheduler threads no
+longer fail with ``database is locked`` when the
+consolidator writes concurrently. 7 new regression cases.
+[Full CHANGELOG →](./CHANGELOG.md#0411---2026-09-24)
+
 > **What's new in 0.4.10** — **path-safety guard** for the
 five export / snapshot endpoints. ``MemoryStore`` already
 validated query / wiki content; the new

{loop_memory-0.4.10 → loop_memory-0.4.12}/README.md

@@ -22,6 +22,21 @@
 
 ---
 
+> **What's new in 0.4.12** — **OKF bundle import** + **DB-level audit enforcement** (audit 2026-09-27). The new `loop-memory import-okf <in_dir>` (and `POST /api/import/okf`) is the symmetric counterpart to `export-okf` (0.4.9) — bring an OKF v0.2 bundle back into Loop Memory as wiki pages, with idempotent upsert on `(scope, slug)`, optional `--dry-run` and `--skip-conflicts`. Source: `thecolourfoundation/rune` HN launch (MIT, 2026-09-25) + `okf-memory/okf-agent-memory` Issues #12-#15 + `Deja-Vu` (MIT, 2026-09-24) + Google OKF v0.2 spec (Apache-2.0, 2026-09-01). The new `MemoryStore._install_audit_triggers()` installs 12 SQLite triggers on `memories` / `wiki_pages` / `relations` / `consolidation_runs` so the `audit_log` table cannot be skipped — even a raw `sqlite3` writer that bypasses the Python wrapper still appends an audit row with `actor='db_trigger'`. New `MemoryStore.list_audit_log()` reads the log; `GET /api/stats` reports `audit_log` + `audit_triggers` counts. Source: `cogstate-eng/memory-eternal v0.4.3` `enforceAudit()` pattern (MIT, 2026-09-23). 31 new regression cases. [Full CHANGELOG →](./CHANGELOG.md#0412---2026-09-27)
+
+> **What's new in 0.4.11** — **operational probes** +
+**SQLite write-contention fix** (audit 2026-09-24). New
+``GET /api/healthz`` (liveness) + ``GET /api/readyz``
+(readiness) endpoints let Kubernetes / launchd keepalive
+polls probe the serve without provisioning a Bearer token;
+``/api/readyz`` returns 503 when the SQLite store is
+unreachable. Also fixed a real concurrency bug: every
+store connection now sets ``PRAGMA busy_timeout=5000``
+(was 0 ms) so the watcher + serve + scheduler threads no
+longer fail with ``database is locked`` when the
+consolidator writes concurrently. 7 new regression cases.
+[Full CHANGELOG →](./CHANGELOG.md#0411---2026-09-24)
+
 > **What's new in 0.4.10** — **path-safety guard** for the
 five export / snapshot endpoints. ``MemoryStore`` already
 validated query / wiki content; the new

{loop_memory-0.4.10 → loop_memory-0.4.12}/loop_memory/cli/commands/cognitive.py

@@ -119,6 +119,23 @@ def _build_parser() -> argparse.ArgumentParser:
     eo.add_argument("--scope", default=None,
                     help="Filter: 'global' or a single source token (e.g. codex)")
 
+    # Audit 2026-09-27: OKF v0.2 bundle import
+    # (thecolourfoundation/rune + okf-memory/okf-agent-memory Issues
+    # #12-#15 + Deja-Vu HN front-page). Symmetric counterpart to
+    # ``export-okf`` (0.4.9): bring an OKF bundle back into Loop
+    # Memory as wiki pages. Idempotent upsert on (scope, slug).
+    io = sub.add_parser(
+        "import-okf",
+        help="Import an OKF v0.2 bundle directory as wiki pages")
+    io.add_argument("in_dir",
+                    help="Bundle directory containing index.md and pages/")
+    io.add_argument("--scope", default=None,
+                    help="Scope tag for imported pages (default: bundle's index.md, then 'global')")
+    io.add_argument("--dry-run", action="store_true",
+                    help="Parse every file but do not write")
+    io.add_argument("--skip-conflicts", action="store_true",
+                    help="Don't overwrite an existing (scope, slug) row")
+
     return p
 
 
@@ -375,3 +392,32 @@ def run_export_okf(args) -> int:
     s = MemoryStore(ns.db)
     r = s.export_okf(ns.out_dir, scope_filter=ns.scope)
     return _emit(r)
+
+
+def run_import_okf(args) -> int:
+    """``loop-memory import-okf <in_dir> [--scope S] [--dry-run] [--skip-conflicts]``
+
+    Audit 2026-09-27: OKF v0.2 bundle import
+    (thecolourfoundation/rune + okf-memory/okf-agent-memory Issues
+    #12-#15 + Deja-Vu HN front-page). Returns the summary dict
+    from ``MemoryStore.import_okf`` so the caller can confirm what
+    landed where. ``--dry-run`` parses every file but writes nothing;
+    ``--skip-conflicts`` turns INSERT-vs-existing conflicts into
+    a ``skipped`` counter rather than an UPDATE.
+    """
+    import argparse as _ap
+    p = _ap.ArgumentParser(prog="loop-memory import-okf")
+    p.add_argument("in_dir")
+    p.add_argument("--scope", default=None)
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--skip-conflicts", 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)
+    r = s.import_okf(
+        ns.in_dir,
+        scope=ns.scope,
+        dry_run=ns.dry_run,
+        skip_conflicts=ns.skip_conflicts,
+    )
+    return _emit(r)

{loop_memory-0.4.10 → loop_memory-0.4.12}/loop_memory/cli/main.py

@@ -26,6 +26,7 @@ Usage:
     loop-memory export <out_dir>  # write a MEMORY.md bundle (v7)
     loop-memory export-bundle <out_dir>  # explicit v7 bundle alias
     loop-memory import <in_dir>   # re-hydrate a bundle
+    loop-memory import-okf <in_dir> [--scope S] [--dry-run] [--skip-conflicts]  # ingest an OKF v0.2 bundle as wiki pages (audit 2026-09-27)
     loop-memory fork [--branch-tag T]  # snapshot every wiki page
     loop-memory graph-edge <src> <dst> [--kind K] [--weight W]  # push a relation
     loop-memory subgraph <query>  # print a small subgraph
@@ -128,6 +129,8 @@ COMMANDS = {
     # 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,
+    # Audit 2026-09-27: OKF v0.2 bundle import (rune + okf-agent-memory #12-#15 + Deja-Vu).
+    "import-okf": cognitive_cmd.run_import_okf,
     "rules": rules_cmd.run_rules,
     "version": _run_version,
 }
@@ -172,6 +175,7 @@ COMMAND_HELP: dict[str, str] = {
     "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).",
+    "import-okf":             "loop-memory import-okf <in_dir> [--scope S] [--dry-run] [--skip-conflicts]   # ingest an OKF v0.2 bundle as wiki pages (audit 2026-09-27).",
     "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.10 → loop_memory-0.4.12}/loop_memory/serve/app.py

@@ -176,6 +176,12 @@ def create_app(store: MemoryStore, static_dir: Path | None = None, scheduler=Non
         '/api/pipeline', '/api/weekly-report', '/api/llm-audit',
         '/api/source-health', '/api/write-guard', '/api/diag',
         '/api/install-hooks', '/api/insights',
+        # Audit 2026-09-24: probes are intentionally public so a
+        # load balancer / keepalive script doesn't need a Bearer
+        # token to ask "is the process up?". The DB-touching
+        # ``/api/readyz`` only exposes a coarse health signal
+        # (UP / DOWN), no data.
+        '/api/healthz', '/api/readyz',
     ))
 
     def _is_public_path(path: str) -> bool:

{loop_memory-0.4.10 → loop_memory-0.4.12}/loop_memory/serve/routes/system.py

@@ -36,6 +36,41 @@ def register(app: FastAPI, store: MemoryStore, scheduler: Optional[Any] = None,
     """
     if static_dir is None:
         static_dir = Path(__file__).parent.parent / "static"
+    @app.get("/api/healthz")
+    def healthz():
+        """Liveness probe.
+
+        Audit 2026-09-24. Returns 200 as long as the process is
+        responsive. **Does not** touch the SQLite store — so the
+        probe cannot deadlock behind a slow writer and cannot give
+        a false negative when the DB is briefly busy. Use this for
+        ``livenessProbe`` in Kubernetes / launchd keepalive scripts.
+        """
+        return {"status": "ok", "ts": time.time()}
+
+    @app.get("/api/readyz")
+    def readyz():
+        """Readiness probe.
+
+        Audit 2026-09-24. Verifies the SQLite store is reachable AND
+        responsive (one trivial ``PRAGMA quick_check`` round-trip
+        inside a 1-second budget). Returns ``{"status": "ok"}`` on
+        success, or ``{"status": "degraded", "error": "..."}`` with
+        HTTP 503 when the DB is unhealthy. Use this for
+        ``readinessProbe`` so a degraded loop-memory is taken out of
+        a load-balancer rotation until it recovers.
+        """
+        import sqlite3 as _sq3
+        try:
+            with _sq3.connect(str(store.path), timeout=1.0) as c:
+                c.execute("PRAGMA quick_check").fetchone()
+            return {"status": "ok", "ts": time.time()}
+        except Exception as e:
+            return JSONResponse(
+                {"status": "degraded", "error": str(e)},
+                status_code=503,
+            )
+
     @app.get("/")
     def index():
         """Serve the dashboard HTML with the i18n JSONs inlined.
@@ -450,6 +485,49 @@ def register(app: FastAPI, store: MemoryStore, scheduler: Optional[Any] = None,
             raise HTTPException(500, f"export-okf failed: {e}")
         return r
 
+    @app.post("/api/import/okf")
+    def import_okf(body: dict):
+        """Audit 2026-09-27: OKF v0.2 bundle import.
+
+        Body shape::
+
+            {
+              "in_dir":         "/abs/path/to/bundle",
+              "scope":          "global",          # optional
+              "dry_run":        false,             # optional
+              "skip_conflicts": false              # optional
+            }
+
+        Walks ``<in_dir>/index.md`` + ``<in_dir>/pages/*.md`` and
+        upserts each page as a wiki row keyed on ``(scope, slug)``.
+        ``in_dir`` is validated by ``_safe_resolve_path`` (live DB
+        + system dirs are still refused; per-user temp is OK).
+        Returns the same summary dict as the CLI handler.
+        """
+        from ._shared import _safe_resolve_path as _safe_path
+        in_dir = (body.get("in_dir") or "").strip()
+        if not in_dir:
+            raise HTTPException(400, "in_dir is required")
+        scope = body.get("scope")
+        if scope is not None:
+            scope = str(scope).strip() or None
+        dry_run = bool(body.get("dry_run", False))
+        skip_conflicts = bool(body.get("skip_conflicts", False))
+        try:
+            safe_dir = _safe_path(in_dir, kind="read", live_db_path=str(store.path))
+        except ValueError as e:
+            raise HTTPException(400, str(e))
+        try:
+            r = store.import_okf(
+                safe_dir,
+                scope=scope,
+                dry_run=dry_run,
+                skip_conflicts=skip_conflicts,
+            )
+        except Exception as e:
+            raise HTTPException(500, f"import-okf failed: {e}")
+        return r
+
     @app.get("/api/recall/outline")
     def recall_outline(query: str = "", limit: int = 12,
                        include: str = "memories,wiki,entities",