memorymaster 3.9.0__tar.gz → 3.10.0__tar.gz

{memorymaster-3.9.0 → memorymaster-3.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.9.0
+Version: 3.10.0
 Summary: Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration.
 Author: wolverin0
 License: MIT

{memorymaster-3.9.0 → memorymaster-3.10.0}/memorymaster/claim_edges.py

@@ -15,12 +15,18 @@ flag in a future patch without re-touching this module.
 """
 from __future__ import annotations
 
+import logging
 import re
 import sqlite3
 from collections import deque
 from datetime import datetime, timezone
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+
+# v3.9.1 S2 — once-per-process so the missing-table warning doesn't spam recall callers.
+_MISSING_TABLE_WARNED: bool = False
+
 __all__ = [
     "ensure_claim_edges_schema",
     "extract_edges_for_claim",
@@ -195,8 +201,20 @@ def walk_neighbors(
                         (cid,),
                     )
                     ids.update(int(r[0]) for r in cursor.fetchall())
-            except sqlite3.OperationalError:
-                # claim_edges table missing — just bail
+            except sqlite3.OperationalError as exc:
+                # v3.9.1 S2 — surface the missing-table case once per process
+                # so the user knows to bootstrap with rebuild_edges(). We
+                # still bail (returning {}) to keep the recall hook's
+                # silent-fail invariant.
+                global _MISSING_TABLE_WARNED
+                if not _MISSING_TABLE_WARNED:
+                    logger.warning(
+                        "claim_edges table missing or unreadable (%s) — F8 "
+                        "two-pass walks will return empty results until you "
+                        "run memorymaster.claim_edges.rebuild_edges(db_path).",
+                        exc,
+                    )
+                    _MISSING_TABLE_WARNED = True
                 return {}
             for n in ids:
                 if n in seen:

{memorymaster-3.9.0 → memorymaster-3.10.0}/memorymaster/context_hook.py

@@ -30,6 +30,11 @@ from memorymaster.hook_log import log_hook
 
 logger = logging.getLogger(__name__)
 
+# v3.9.1 S1 — once-per-process flags so import-failure warnings don't spam.
+_VERBATIM_IMPORT_WARNED: bool = False
+# v3.9.1 S2 — once-per-process flag for missing claim_edges table.
+_CLAIM_EDGES_MISSING_WARNED: bool = False
+
 
 # Retrieval latency instrumentation (roadmap 5.1).
 #
@@ -349,6 +354,13 @@ _RECALL_WEIGHT_DEFAULTS: dict[str, float] = {
     # legacy ranking bit-identical even when the stream is on (rows are still
     # added as candidates but contribute zero to scoring).
     "W_TWO_PASS": 0.0,
+    # W_CLOSETS (v3.10 W1, ported from MemPalace v3.3.0). When the closets
+    # stream is ON (MEMORYMASTER_RECALL_CLOSETS=1), each claim_id surfaced
+    # via ``search_closets`` gets ``closet_score = 1.0`` (constant — closets
+    # are a presence boost, not a ranked score). Default 0.0 keeps ranking
+    # bit-identical even when the stream is on. MemPalace measured R@1
+    # 0.42 → 0.58 (+38%) with regex-derived closets.
+    "W_CLOSETS": 0.0,
 }
 
 
@@ -402,6 +414,18 @@ def _two_pass_enabled() -> bool:
     return raw not in ("0", "false", "False", "no", "off", "")
 
 
+def _two_pass_use_edges() -> bool:
+    """v3.10 W2 — when the two-pass stream is on, ALSO walk claim_edges in addition to entity_aliases."""
+    raw = os.environ.get("MEMORYMASTER_RECALL_TWO_PASS_USE_EDGES", "0").strip()
+    return raw not in ("0", "false", "False", "no", "off", "")
+
+
+def _closets_enabled() -> bool:
+    """v3.10 W1 — opt-in closets stream gate."""
+    raw = os.environ.get("MEMORYMASTER_RECALL_CLOSETS", "0").strip()
+    return raw not in ("0", "false", "False", "no", "off", "")
+
+
 def _two_pass_max_neighbors() -> int:
     """Cap neighbors discovered per recall call (default 20)."""
     raw = os.environ.get("MEMORYMASTER_RECALL_TWO_PASS_MAX", "20").strip()
@@ -1143,7 +1167,20 @@ def _recall_impl(
             is_enabled as _verbatim_enabled,
             recall_verbatim,
         )
-    except Exception:  # pragma: no cover - importless path
+    except Exception as _verbatim_import_exc:  # pragma: no cover - importless path
+        # v3.9.1 S1 — surface this rather than silently using no-op lambdas.
+        # User needs to know that even if MEMORYMASTER_RECALL_VERBATIM=1 is set,
+        # the stream is unavailable because the install is incomplete or the
+        # module raised at import time. Logged at WARNING so it surfaces in
+        # default log levels but doesn't crash recall().
+        if not _VERBATIM_IMPORT_WARNED:
+            logger.warning(
+                "verbatim_recall import failed (%s) — verbatim stream is OFF "
+                "regardless of MEMORYMASTER_RECALL_VERBATIM. Reinstall "
+                "memorymaster or check the import error.",
+                _verbatim_import_exc,
+            )
+            globals()["_VERBATIM_IMPORT_WARNED"] = True
         _verbatim_enabled = lambda: False  # type: ignore[assignment]  # noqa: E731
         recall_verbatim = lambda *a, **k: []  # type: ignore[assignment]  # noqa: E731
         hit_to_synthetic_row = None  # type: ignore[assignment]
@@ -1211,30 +1248,100 @@ def _recall_impl(
                     and getattr(c, "id", None) is not None
                 ][:10]  # cap seeds so the fanout stays bounded
                 neighbor_ids = _two_pass_neighbor_ids(svc.store, seed_ids, set(seen_ids))
-                if neighbor_ids:
-                    for nid in neighbor_ids:
-                        try:
-                            claim = svc.store.get_claim(nid)
-                        except Exception:
-                            claim = None
-                        if claim is None:
-                            continue
-                        rows.append(
-                            {
-                                "claim": claim,
-                                "lexical_score": 0.0,
-                                "freshness_score": 0.0,
-                                "confidence_score": float(getattr(claim, "confidence", 0.0) or 0.0),
-                                "vector_score": 0.0,
-                                "entity_score": 0.0,
-                                "two_pass_score": 1.0,
-                                "source": "two_pass",
-                            }
-                        )
-                        seen_ids.add(nid)
+                neighbor_distances: dict[int, int] = {n: 1 for n in neighbor_ids}
+                # v3.10 W2 — also walk claim_edges (F8 structural edges)
+                # when MEMORYMASTER_RECALL_TWO_PASS_USE_EDGES=1. Distances
+                # from the structural walk OVERRIDE entity-fanout where
+                # they're shorter (closer neighbors via explicit references).
+                if _two_pass_use_edges() and seed_ids:
+                    try:
+                        from memorymaster.claim_edges import walk_neighbors as _walk_edges
+                        edge_distances = _walk_edges(db, seed_ids, max_hops=2)
+                        for nid, hops in edge_distances.items():
+                            existing = neighbor_distances.get(nid)
+                            if existing is None or hops < existing:
+                                neighbor_distances[nid] = int(hops)
+                    except Exception as exc:  # noqa: BLE001
+                        logger.debug("two_pass edges walk skipped: %s", exc)
+                for nid, hops in neighbor_distances.items():
+                    if nid in seen_ids:
+                        continue
+                    try:
+                        claim = svc.store.get_claim(nid)
+                    except Exception:
+                        claim = None
+                    if claim is None:
+                        continue
+                    # Distance-decayed score so closer neighbors weigh more.
+                    score = 1.0 / (1.0 + float(hops))
+                    rows.append(
+                        {
+                            "claim": claim,
+                            "lexical_score": 0.0,
+                            "freshness_score": 0.0,
+                            "confidence_score": float(getattr(claim, "confidence", 0.0) or 0.0),
+                            "vector_score": 0.0,
+                            "entity_score": 0.0,
+                            "two_pass_score": score,
+                            "source": "two_pass",
+                        }
+                    )
+                    seen_ids.add(nid)
             except Exception as exc:  # noqa: BLE001 — defensive
                 logger.debug("two_pass stream skipped: %s", exc)
 
+    # Closets stream (v3.10 W1, MemPalace v3.3.0). Gated on
+    # MEMORYMASTER_RECALL_CLOSETS=1. Calls search_closets(query) → for each
+    # matched wiki article, hydrates its claim_ids as new rows annotated with
+    # ``closet_score = 1.0``. When a closet-hydrated claim is already in
+    # ``rows`` we BOOST its closet_score on the existing row instead of
+    # adding a duplicate.
+    if _closets_enabled():
+        with _phase_timer(phase_ms, "closets"):
+            try:
+                from memorymaster.closets import search_closets as _search_closets
+            except Exception as exc:  # noqa: BLE001 — module may be missing
+                logger.debug("closets stream skipped (import): %s", exc)
+                _search_closets = None
+            if _search_closets is not None:
+                try:
+                    closet_hits = _search_closets(db, query, limit=5)
+                except Exception as exc:  # noqa: BLE001
+                    logger.debug("closets stream skipped (search): %s", exc)
+                    closet_hits = []
+                if closet_hits:
+                    existing_by_id: dict[int, dict] = {}
+                    for row in rows:
+                        c = row.get("claim")
+                        if c is not None and getattr(c, "id", None) is not None:
+                            existing_by_id[int(c.id)] = row
+                    for _slug, claim_ids in closet_hits:
+                        for cid in claim_ids:
+                            if cid in existing_by_id:
+                                # Boost: closet_score=1.0 is the constant signal
+                                existing_by_id[cid]["closet_score"] = 1.0
+                                continue
+                            try:
+                                claim = svc.store.get_claim(cid)
+                            except Exception:
+                                claim = None
+                            if claim is None:
+                                continue
+                            rows.append(
+                                {
+                                    "claim": claim,
+                                    "lexical_score": 0.0,
+                                    "freshness_score": 0.0,
+                                    "confidence_score": float(getattr(claim, "confidence", 0.0) or 0.0),
+                                    "vector_score": 0.0,
+                                    "entity_score": 0.0,
+                                    "closet_score": 1.0,
+                                    "source": "closets",
+                                }
+                            )
+                            seen_ids.add(cid)
+                            existing_by_id[cid] = rows[-1]
+
     if _graph_enabled():
         with _phase_timer(phase_ms, "graph"):
             # Roadmap 12.1 — distance-weighted score breaks the
@@ -1300,6 +1407,7 @@ def _recall_impl(
     # bit-identical ranking with the 5-stream baseline.
     w_graph = _recall_weight("W_GRAPH")
     w_two_pass = _recall_weight("W_TWO_PASS")
+    w_closets = _recall_weight("W_CLOSETS")
     # W_CLAIM_TYPE (v3.9.0 F1, MemPalace "Halls"-inspired). When > 0, classify
     # the query via classify_observation() and look up its inferred claim_type;
     # rows whose claim.claim_type matches get a (1 + w_claim_type) multiplier
@@ -1479,6 +1587,10 @@ def _recall_impl(
         # F5 two-pass entity-fanout stream. W_TWO_PASS=0.0 (default) makes
         # this contribute nothing even when the stream is on.
         two_pass = float(row.get("two_pass_score") or 0.0)
+        # closet_score is non-zero only when the row was added/boosted via
+        # the v3.10 W1 closets stream. W_CLOSETS=0.0 (default) makes this
+        # contribute nothing even when MEMORYMASTER_RECALL_CLOSETS=1.
+        closets = float(row.get("closet_score") or 0.0)
         base = (
             matches * w_matches
             + phrase_bonus * w_phrase
@@ -1491,6 +1603,7 @@ def _recall_impl(
             + verbatim * w_verbatim
             + graph * w_graph
             + two_pass * w_two_pass
+            + closets * w_closets
         )
         # claim_type-aware boost (v3.9.0 F1). When w_claim_type > 0 AND the
         # query was classified into a type AND this claim's claim_type matches,

{memorymaster-3.9.0 → memorymaster-3.10.0}/memorymaster.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.9.0
+Version: 3.10.0
 Summary: Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration.
 Author: wolverin0
 License: MIT

{memorymaster-3.9.0 → memorymaster-3.10.0}/memorymaster.egg-info/SOURCES.txt

@@ -191,6 +191,7 @@ tests/test_cli_ready.py
 tests/test_cli_review_queue.py
 tests/test_cli_subcommands.py
 tests/test_closets.py
+tests/test_closets_recall_integration.py
 tests/test_compact_summaries.py
 tests/test_compaction_trace.py
 tests/test_config.py
@@ -278,6 +279,7 @@ tests/test_tenant_isolation.py
 tests/test_turn_schema.py
 tests/test_two_pass_recall.py
 tests/test_v390_e2e.py
+tests/test_v391_strict_warnings.py
 tests/test_vault_exporter.py
 tests/test_vector_search.py
 tests/test_verbatim_recall.py

{memorymaster-3.9.0 → memorymaster-3.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memorymaster"
-version = "3.9.0"
+version = "3.10.0"
 description = "Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration."
 license = {text = "MIT"}
 authors = [{name = "wolverin0"}]

memorymaster-3.10.0/tests/test_closets_recall_integration.py

@@ -0,0 +1,50 @@
+"""Tests for v3.10 W1 — closets stream wired into context_hook.recall."""
+from __future__ import annotations
+
+import pytest
+
+from memorymaster import context_hook
+
+
+@pytest.fixture(autouse=True)
+def _clean_env(monkeypatch):
+    for k in [
+        "MEMORYMASTER_RECALL_CLOSETS",
+        "MEMORYMASTER_RECALL_W_CLOSETS",
+        "MEMORYMASTER_RECALL_TWO_PASS",
+        "MEMORYMASTER_RECALL_TWO_PASS_USE_EDGES",
+    ]:
+        monkeypatch.delenv(k, raising=False)
+
+
+def test_closets_disabled_by_default():
+    assert context_hook._closets_enabled() is False
+
+
+def test_closets_enabled_via_env(monkeypatch):
+    monkeypatch.setenv("MEMORYMASTER_RECALL_CLOSETS", "1")
+    assert context_hook._closets_enabled() is True
+
+
+def test_closets_disabled_for_falsy_values(monkeypatch):
+    for v in ["0", "false", "False", "no", "off", ""]:
+        monkeypatch.setenv("MEMORYMASTER_RECALL_CLOSETS", v)
+        assert context_hook._closets_enabled() is False, f"failed for {v!r}"
+
+
+def test_w_closets_default_is_zero():
+    assert context_hook._RECALL_WEIGHT_DEFAULTS["W_CLOSETS"] == 0.0
+
+
+def test_w_closets_override(monkeypatch):
+    monkeypatch.setenv("MEMORYMASTER_RECALL_W_CLOSETS", "0.4")
+    assert context_hook._recall_weight("W_CLOSETS") == 0.4
+
+
+def test_two_pass_use_edges_disabled_by_default():
+    assert context_hook._two_pass_use_edges() is False
+
+
+def test_two_pass_use_edges_enabled_via_env(monkeypatch):
+    monkeypatch.setenv("MEMORYMASTER_RECALL_TWO_PASS_USE_EDGES", "1")
+    assert context_hook._two_pass_use_edges() is True

memorymaster-3.10.0/tests/test_v391_strict_warnings.py

@@ -0,0 +1,73 @@
+"""Tests for v3.9.1 STRICT items.
+
+S1: verbatim_recall import failure now logs WARNING once.
+S2: claim_edges missing table now logs WARNING once via walk_neighbors.
+"""
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+import pytest
+
+import memorymaster.claim_edges as claim_edges_module
+
+
+def test_walker_logs_warning_when_table_missing(tmp_path, caplog):
+    """S2 — when claim_edges table doesn't exist, walk_neighbors warns once."""
+    # Reset the module-level flag so this test doesn't depend on order
+    claim_edges_module._MISSING_TABLE_WARNED = False
+    db = tmp_path / "no-edges.db"
+    sqlite3.connect(str(db)).close()  # empty DB, no claim_edges table
+    with caplog.at_level("WARNING", logger="memorymaster.claim_edges"):
+        result = claim_edges_module.walk_neighbors(db, [1, 2, 3], max_hops=2)
+    assert result == {}
+    assert any("claim_edges table missing" in r.message for r in caplog.records), \
+        f"expected missing-table warning, got records: {[r.message for r in caplog.records]}"
+
+
+def test_walker_warns_only_once_per_process(tmp_path, caplog):
+    """S2 — second + third walks against missing table don't re-spam the log."""
+    claim_edges_module._MISSING_TABLE_WARNED = False
+    db = tmp_path / "no-edges.db"
+    sqlite3.connect(str(db)).close()
+    with caplog.at_level("WARNING", logger="memorymaster.claim_edges"):
+        claim_edges_module.walk_neighbors(db, [1], max_hops=1)
+        caplog.clear()
+        claim_edges_module.walk_neighbors(db, [2], max_hops=1)
+        claim_edges_module.walk_neighbors(db, [3], max_hops=1)
+    # Second + third walks should NOT produce new warning records
+    assert not any("claim_edges table missing" in r.message for r in caplog.records), \
+        "duplicate warning surfaced — _MISSING_TABLE_WARNED gate broken"
+
+
+def test_walker_does_not_warn_when_table_exists(tmp_path, caplog):
+    """When the table is present (even if empty), no warning fires."""
+    claim_edges_module._MISSING_TABLE_WARNED = False
+    db = tmp_path / "with-edges.db"
+    conn = sqlite3.connect(str(db))
+    try:
+        claim_edges_module.ensure_claim_edges_schema(conn)
+    finally:
+        conn.close()
+    with caplog.at_level("WARNING", logger="memorymaster.claim_edges"):
+        result = claim_edges_module.walk_neighbors(db, [1, 2], max_hops=2)
+    assert result == {}  # empty table → no neighbors
+    assert not any("claim_edges table missing" in r.message for r in caplog.records)
+
+
+def test_module_exposes_warned_flag():
+    """The flag is module-level so tests + production callers can reset it."""
+    assert hasattr(claim_edges_module, "_MISSING_TABLE_WARNED")
+
+
+def test_context_hook_exposes_verbatim_warned_flag():
+    """S1 — _VERBATIM_IMPORT_WARNED gate exists so the warning is once-per-process."""
+    from memorymaster import context_hook
+    assert hasattr(context_hook, "_VERBATIM_IMPORT_WARNED")
+
+
+def test_context_hook_exposes_claim_edges_warned_flag():
+    """S2 — _CLAIM_EDGES_MISSING_WARNED was reserved on context_hook for the F8 wiring."""
+    from memorymaster import context_hook
+    assert hasattr(context_hook, "_CLAIM_EDGES_MISSING_WARNED")