release: cut v0.7.3 with memory-store compatibility fixes

Author: rand

.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "rlm-claude-code",
       "source": "./",
       "description": "Recursive Language Model integration for Claude Code - Go binary hooks (~5ms startup), cross-plugin event coordination (DP/RLM), version-aware config migration, and intelligent multi-provider routing",
-      "version": "0.7.2"
+      "version": "0.7.3"
     }
   ]
 }

.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "rlm-claude-code",
   "description": "Recursive Language Model integration for Claude Code - intelligent multi-provider routing and unbounded context handling",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "author": {
     "name": "Rand",
     "url": "https://github.com/rand"

CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [0.7.3] - 2026-02-20
+
+### Added
+- Repository-level quality gate targets in `Makefile`:
+  - `make check`
+  - `make check-python`
+  - `make check-go`
+  - `make benchmark`
+  - `make benchmark-bounded`
+- Bounded benchmark execution mode for restricted environments:
+  - `tests/benchmarks/conftest.py` adds `bounded_benchmark` fixture
+  - controlled by `RLM_BENCHMARK_BOUNDED` and round/iteration env vars
+- Integration coverage for complexity-check binary contract path (`tests/integration/test_complexity_check_binary.py`)
+
+### Changed
+- Benchmark suites now use bounded-capable benchmark fixture in:
+  - `tests/benchmarks/test_phase3_benchmarks.py`
+  - `tests/benchmarks/test_verification_benchmarks.py`
+- Rich output now includes real spinner progress emission with throttling in `RLMConsole.emit_progress()` (SPEC-13.23, SPEC-13.25)
+- Auto-activation escalation now applies a conservative budget guard to keep execution in micro mode when budget is below balanced-entry threshold (SPEC-14.23)
+- Expanded explicit trace tagging and coverage for prioritized non-deferred gaps in SPEC-13/14/16/17
+
+### Fixed
+- Memory store compatibility with `rlm_core` builds that do not expose `MemoryStore.update_fields()`:
+  - field updates now use a validated SQLite compatibility path when needed
+  - node reads/queries/search in compatibility mode now use SQLite directly for consistent cross-session behavior
+  - compatibility updates checkpoint WAL and use thread-safe connection handling for parallel session flows
+
+### Verified
+- Full quality gate pass:
+  - `make check` (`3281 passed, 3 deselected`)
+  - `make benchmark-bounded` (`37 passed`)
+  - `uv run dp enforce pre-commit --policy dp-policy.json --json` (`ok=true`)
+  - `uv run dp review --json` (`ok=true`)
+  - `uv run dp verify --json` (`ok=true`)
+  - `uv run dp enforce pre-push --policy dp-policy.json --json` (`ok=true`)
+
 ## [0.7.2] - 2026-02-19
 
 ### Fixed

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rlm-claude-code"
-version = "0.7.2"
+version = "0.7.3"
 description = "Recursive Language Model integration for Claude Code"
 readme = "README.md"
 requires-python = ">=3.12"

src/__init__.py

@@ -11,7 +11,7 @@
 - User-configurable preferences and budgets
 """
 
-__version__ = "0.7.2"
+__version__ = "0.7.3"
 
 # Async execution (SPEC-08.01-08.06) - from orchestrator package
 # Core orchestration

src/memory_store.py

@@ -8,8 +8,10 @@
 
 from __future__ import annotations
 
+import json
 import os
 import sqlite3
+import threading
 import uuid
 from collections.abc import Callable
 from dataclasses import dataclass, field
@@ -201,6 +203,7 @@ def __init__(self, db_path: str | None = None):
 
         self.db_path = db_path
         self._is_memory = db_path == ":memory:"
+        self._owner_thread_id = threading.get_ident()
         self._persistent_conn: sqlite3.Connection | None = None
 
         # Python SQLite for auxiliary tables (hyperedges, confidence_updates)
@@ -216,6 +219,7 @@ def __init__(self, db_path: str | None = None):
             self._core_store = rlm_core.MemoryStore.in_memory()
         else:
             self._core_store = rlm_core.MemoryStore.open(db_path)
+        self._core_supports_update_fields = hasattr(self._core_store, "update_fields")
 
     @property
     def uses_rlm_core(self) -> bool:
@@ -388,9 +392,15 @@ def _get_connection(self) -> sqlite3.Connection:
         Returns a non-closeable wrapper around a persistent connection
         to avoid opening multiple connections that corrupt rlm_core's WAL state.
         """
-        if self._persistent_conn is not None:
+        if (
+            self._persistent_conn is not None
+            and threading.get_ident() == self._owner_thread_id
+        ):
             self._persistent_conn.row_factory = sqlite3.Row
             return _NoCloseConnection(self._persistent_conn)
+
+        # Use thread-local connections for non-owner threads to avoid sqlite
+        # thread-affinity errors when tests exercise concurrent session access.
         conn = sqlite3.connect(self.db_path)
         conn.row_factory = sqlite3.Row
         return conn
@@ -435,13 +445,51 @@ def _rfc3339_to_epoch_ms(rfc3339_str: str) -> int:
         """Convert RFC3339 timestamp string to epoch milliseconds."""
         from datetime import datetime
 
+        if isinstance(rfc3339_str, int | float):
+            return int(rfc3339_str)
         try:
             # Handle various RFC3339 formats
             dt = datetime.fromisoformat(rfc3339_str.replace("Z", "+00:00"))
             return int(dt.timestamp() * 1000)
-        except (ValueError, AttributeError):
+        except (ValueError, AttributeError, TypeError):
             return 0
 
+    @staticmethod
+    def _map_db_tier_to_str(tier_value: Any) -> str:
+        """Map integer/string DB tier representation to Python tier string."""
+        if isinstance(tier_value, int):
+            mapping = {0: "task", 1: "session", 2: "longterm", 3: "archive"}
+            return mapping.get(tier_value, "task")
+        tier_name = str(tier_value).split(".")[-1].lower()
+        return tier_name if tier_name in {"task", "session", "longterm", "archive"} else "task"
+
+    def _db_row_to_python_node(self, row: sqlite3.Row) -> Node:
+        """Convert sqlite row from nodes table to Python Node dataclass."""
+        raw_metadata = row["metadata"]
+        metadata: dict[str, Any] = {}
+        if raw_metadata:
+            try:
+                metadata = json.loads(raw_metadata)
+            except (TypeError, ValueError):
+                metadata = {}
+        provenance = metadata.pop("_provenance", None) or row["provenance_ref"]
+        confidence = row["confidence"] if row["confidence"] is not None else 0.5
+        return Node(
+            id=row["id"],
+            type=row["node_type"] if row["node_type"] in self.VALID_NODE_TYPES else "fact",
+            content=row["content"],
+            tier=self._map_db_tier_to_str(row["tier"]),
+            confidence=confidence,
+            subtype=row["subtype"],
+            embedding=row["embedding"],
+            provenance=provenance,
+            metadata=metadata,
+            created_at=self._rfc3339_to_epoch_ms(row["created_at"]),
+            updated_at=self._rfc3339_to_epoch_ms(row["updated_at"]),
+            last_accessed=self._rfc3339_to_epoch_ms(row["last_accessed"]),
+            access_count=row["access_count"] if row["access_count"] is not None else 0,
+        )
+
     def _core_node_to_python(self, node: Any) -> Node:
         """Convert rlm_core.Node to Python Node dataclass."""
         meta = node.metadata or {}
@@ -503,6 +551,16 @@ def _create_node_core(
 
     def _get_node_core(self, node_id: str) -> Node | None:
         """Get a node using rlm_core backend."""
+        if not self._core_supports_update_fields:
+            conn = self._get_connection()
+            try:
+                row = conn.execute("SELECT * FROM nodes WHERE id = ?", (node_id,)).fetchone()
+            finally:
+                conn.close()
+            if row is None:
+                return None
+            return self._db_row_to_python_node(row)
+
         try:
             result = self._core_store.get_node(node_id)
         except (ValueError, RuntimeError):
@@ -526,6 +584,29 @@ def _query_nodes_core(
         limit: int = 100,
     ) -> list[Node]:
         """Query nodes using rlm_core backend."""
+        if not self._core_supports_update_fields:
+            where_clauses: list[str] = []
+            params: list[Any] = []
+            if node_type is not None:
+                where_clauses.append("node_type = ?")
+                params.append(node_type)
+            if tier is not None:
+                where_clauses.append("tier = ?")
+                params.append(self._core_tier_to_db_value(tier))
+            where_sql = f"WHERE {' AND '.join(where_clauses)}" if where_clauses else ""
+            query = (
+                "SELECT * FROM nodes "
+                f"{where_sql} "
+                "ORDER BY updated_at DESC "
+                "LIMIT ?"
+            )
+            params.append(limit)
+            conn = self._get_connection()
+            try:
+                rows = conn.execute(query, params).fetchall()
+            finally:
+                conn.close()
+            return [self._db_row_to_python_node(row) for row in rows]
 
         if node_type is not None:
             results = self._core_store.query_by_type(self._map_node_type_to_core(node_type), limit)
@@ -550,6 +631,37 @@ def _query_nodes_core(
 
     def _search_core(self, query: str, limit: int) -> list[SearchResult]:
         """Search using rlm_core backend."""
+        if not self._core_supports_update_fields:
+            sql = """
+                SELECT
+                    n.id AS node_id,
+                    n.content AS content,
+                    n.node_type AS node_type,
+                    n.confidence AS confidence,
+                    snippet(nodes_fts, 0, '', '', '...', 10) AS snippet
+                FROM nodes_fts
+                JOIN nodes AS n ON n.rowid = nodes_fts.rowid
+                WHERE nodes_fts MATCH ?
+                ORDER BY bm25(nodes_fts)
+                LIMIT ?
+            """
+            conn = self._get_connection()
+            try:
+                rows = conn.execute(sql, (query, limit)).fetchall()
+            finally:
+                conn.close()
+            return [
+                SearchResult(
+                    node_id=row["node_id"],
+                    content=row["content"],
+                    node_type=row["node_type"],
+                    bm25_score=row["confidence"] if row["confidence"] is not None else 0.5,
+                    snippet=row["snippet"]
+                    if row["snippet"] is not None
+                    else (row["content"][:100] if len(row["content"]) > 100 else row["content"]),
+                )
+                for row in rows
+            ]
 
         results = self._core_store.search_content(query, limit)
         return [
@@ -563,6 +675,104 @@ def _search_core(self, query: str, limit: int) -> list[SearchResult]:
             for node in results
         ]
 
+    @staticmethod
+    def _now_rfc3339() -> str:
+        """Return current timestamp in RFC3339 format."""
+        from datetime import datetime
+
+        return datetime.now(UTC).isoformat(timespec="microseconds")
+
+    @staticmethod
+    def _core_tier_to_db_value(tier: Any) -> int:
+        """Map rlm_core tier enum/string/int to integer DB representation."""
+        if isinstance(tier, int):
+            if 0 <= tier <= 3:
+                return tier
+            raise ValueError(f"Invalid tier value: {tier}")
+        tier_name = str(tier).split(".")[-1].lower()
+        mapping = {
+            "task": 0,
+            "session": 1,
+            "longterm": 2,
+            "archive": 3,
+        }
+        if tier_name not in mapping:
+            raise ValueError(f"Invalid tier value: {tier}")
+        return mapping[tier_name]
+
+    def _update_core_fields_via_sql(self, node_id: str, **fields: Any) -> bool:
+        """
+        Update node fields directly in SQLite for older rlm_core builds.
+
+        This preserves full update behavior when rlm_core does not expose
+        MemoryStore.update_fields (e.g., rlm_core 0.1.x).
+        """
+        conn = self._get_connection()
+        try:
+            exists = conn.execute("SELECT 1 FROM nodes WHERE id = ?", (node_id,)).fetchone()
+            if exists is None:
+                return False
+
+            assignments: list[str] = []
+            params: list[Any] = []
+
+            if "content" in fields:
+                assignments.append("content = ?")
+                params.append(fields["content"])
+            if "confidence" in fields:
+                assignments.append("confidence = ?")
+                params.append(fields["confidence"])
+            if "tier" in fields:
+                assignments.append("tier = ?")
+                params.append(self._core_tier_to_db_value(fields["tier"]))
+            if "subtype" in fields:
+                assignments.append("subtype = ?")
+                params.append(fields["subtype"])
+            if "metadata" in fields:
+                metadata = fields["metadata"] if fields["metadata"] is not None else {}
+                assignments.append("metadata = ?")
+                params.append(json.dumps(metadata, separators=(",", ":")))
+            if "provenance_source" in fields:
+                assignments.append("provenance_source = ?")
+                params.append(fields["provenance_source"])
+            if "provenance_ref" in fields:
+                assignments.append("provenance_ref = ?")
+                params.append(fields["provenance_ref"])
+            if "last_accessed" in fields:
+                assignments.append("last_accessed = ?")
+                params.append(fields["last_accessed"])
+            if "access_count" in fields:
+                assignments.append("access_count = ?")
+                params.append(fields["access_count"])
+
+            if not assignments:
+                return True
+
+            assignments.append("updated_at = ?")
+            params.append(self._now_rfc3339())
+            params.append(node_id)
+
+            conn.execute(f"UPDATE nodes SET {', '.join(assignments)} WHERE id = ?", params)
+            conn.commit()
+            # Ensure sequential store instances see updates even if their
+            # SQLite reader configuration does not consume WAL directly.
+            try:
+                conn.execute("PRAGMA wal_checkpoint(FULL)")
+            except sqlite3.OperationalError:
+                pass
+            return True
+        finally:
+            conn.close()
+
+    def _update_core_fields(self, node_id: str, **fields: Any) -> bool:
+        """Update node fields via rlm_core API or SQL compatibility fallback."""
+        if not fields:
+            return True
+        if self._core_supports_update_fields:
+            self._core_store.update_fields(node_id, **fields)
+            return True
+        return self._update_core_fields_via_sql(node_id, **fields)
+
     # =========================================================================
     # Node CRUD Operations (SPEC-02.20-24)
     # =========================================================================
@@ -673,7 +883,7 @@ def get_node(self, node_id: str, include_archived: bool = False) -> Node | None:
             return None
         # Track access (best-effort, don't fail reads)
         try:
-            self._core_store.update_fields(
+            self._update_core_fields(
                 node_id,
                 access_count=node.access_count + 1,
             )
@@ -730,7 +940,7 @@ def update_node(self, node_id: str, **kwargs: Any) -> bool:
         if "metadata" in kwargs:
             update_kwargs["metadata"] = kwargs["metadata"]
 
-        self._core_store.update_fields(node_id, **update_kwargs)
+        self._update_core_fields(node_id, **update_kwargs)
 
         # Log tier transition if tier changed (SPEC-02.19)
         if "tier" in kwargs and kwargs["tier"] != old_tier:
@@ -1900,7 +2110,7 @@ def _set_last_accessed(self, node_id: str, timestamp: Any) -> bool:
             rfc3339 = timestamp.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%S.000000+00:00")
         else:
             rfc3339 = str(timestamp)
-        return self._core_store.update_fields(node_id, last_accessed=rfc3339)
+        return self._update_core_fields(node_id, last_accessed=rfc3339)
 
     def get_nodes_by_metadata(
         self,