wavemind 2.2.4__tar.gz → 2.2.5__tar.gz

{wavemind-2.2.4 → wavemind-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavemind
-Version: 2.2.4
+Version: 2.2.5
 Summary: Local-first dynamic memory field with vector search and wave-field re-ranking
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/CaspianG/wavemind
@@ -543,8 +543,8 @@ Checked-in result:
 |---|---:|
 | Cluster planner | 4096 namespaces, 4 nodes, replication factor 2, node-loss availability `1.000`, zone-loss availability `1.000`, write quorum `2`. |
 | Hot cache | 2000 lookups, hit rate `0.920`, p99 lookup `0.01 ms`. |
-| Replicated runtime | 3 physical WaveMind stores, replication factor 3, write quorum 2, node-loss recall `true`, repair copied `1` missing record, p99 query-after-loss `1.16 ms`. |
-| Structured payloads | image/audio/table/event retrieval, precision@1 `1.000`, p99 `0.69 ms`. |
+| Replicated runtime | 3 physical WaveMind stores, replication factor 3, write quorum 2, node-loss recall `true`, repair copied `1` missing record, tombstone repair deleted `1` stale record, p99 query-after-loss `1.44 ms`. |
+| Structured payloads | image/audio/table/event retrieval, precision@1 `1.000`, p99 `0.75 ms`. |
 
 This profile validates routing, quorum-replicated runtime behavior, cache
 behavior, and structured payload handling. It is not a 10M-vector load test.
@@ -1041,7 +1041,7 @@ Current read:
 | LongMemEval 50-query smoke | On the first 50 non-abstention LongMemEval-S questions, WaveMind reaches `evidence_recall@5 0.920`, `precision@1 0.760`, and `MRR@5 0.827`; Chroma/Qdrant static reach `0.600`, `0.260`, and `0.385`. | This is the fast regression profile for checking current changes before rerunning the full LongMemEval profile. WaveMind wins on quality; latency still needs work. |
 | ANN/index curve | At 50000 generated 128-d vectors, NumPy exact keeps `recall@10 1.000` at `6.49 ms`; quantized int8 keeps `0.934` at `24.92 ms`; Annoy is faster at `4.92 ms` but drops to `0.730` recall; Qdrant local keeps `1.000` recall at `43.49 ms`. | Current local scale boundary is clear: quantized search needs kernel work, Annoy needs tuning/FAISS, and Qdrant should be tested in service mode for a fair production comparison. |
 | Production load | At 100000 generated 128-d vectors, service-mode Qdrant reaches `recall@10 1.000`, avg `10.28 ms`, p99 `21.26 ms`. At 1M, tuned Qdrant reaches `recall@10 0.984`, avg `116.80 ms`, p99 `209.28 ms`; an EF sweep finds `recall@10 0.977`, avg `64.76 ms`, p99 `103.77 ms` at `hnsw_ef=2048` on 30 queries. | 100k is production-grade on the tested machine. 1M recall is now strong, but p99 still needs tuning before claiming a stable sub-100 ms SLO. |
-| Scale readiness | Deterministic 1M-memory simulation validates 4096 namespace placements over 4 nodes with replication factor 2, node-loss availability `1.000`, zone-loss availability `1.000`, hot-cache hit rate `0.920`, quorum-replicated runtime recall after node loss, replica repair, and structured payload precision@1 `1.000`. | This proves routing, cache, payload, and replicated-runtime foundations. It is not a 10M-vector latency claim; real 10M latency still needs service-backed load tests on larger hardware. |
+| Scale readiness | Deterministic 1M-memory simulation validates 4096 namespace placements over 4 nodes with replication factor 2, node-loss availability `1.000`, zone-loss availability `1.000`, hot-cache hit rate `0.920`, quorum-replicated runtime recall after node loss, missing-record repair, tombstone repair, and structured payload precision@1 `1.000`. | This proves routing, cache, payload, and replicated-runtime foundations. It is not a 10M-vector latency claim; real 10M latency still needs service-backed load tests on larger hardware. |
 | Memory competitor adapters | WaveMind reaches `precision@1 0.80`, `precision@3 1.00`, stale suppression `1.00` on the small adapter profile. Mem0, Zep, and LangGraph are listed as skipped unless their real packages/services are configured. | This prevents fake competitor claims. The adapter harness is ready; real Mem0/Zep/LangGraph results still need configured installs. |
 | LongMemEval local answer generation | With the same local Ollama `qwen2.5:1.5b`, WaveMind reaches `exact_match 0.240`, `contains_answer 0.380`, `token_f1 0.333`, and `evidence_recall@5 0.920`; Chroma and Qdrant static both reach `0.120`, `0.160`, `0.170`, and `0.600`. | This is the first checked-in end-to-end answer benchmark against Chroma/Qdrant. It is still a 50-question lightweight smoke run, not a full LongMemEval leaderboard score. |
 
@@ -1213,11 +1213,12 @@ print(memory.query("support replies", namespace="tenant:a", top_k=3))
 memory.close()
 ```
 
-The runtime uses separate durable stores per node, quorum writes, quorum reads,
-merged replica results, and `repair_namespace()` for recovered replicas. It is
-the production foundation for namespace-level HA; for full consensus across
-independent network services, deploy WaveMind with Postgres/Qdrant/ops-layer
-replication.
+The runtime uses separate durable stores per node, stable replica keys, operation
+metadata, quorum writes, quorum reads, merged replica results, tombstone-aware
+delete propagation, and `repair_namespace()` for recovered replicas. It is the
+production foundation for namespace-level HA and eventual-consistency behavior;
+for full consensus across independent network services, deploy WaveMind with
+Postgres/Qdrant/ops-layer replication.
 
 Checked-in official LoCoMo retrieval result:
 

{wavemind-2.2.4 → wavemind-2.2.5}/README.md

@@ -490,8 +490,8 @@ Checked-in result:
 |---|---:|
 | Cluster planner | 4096 namespaces, 4 nodes, replication factor 2, node-loss availability `1.000`, zone-loss availability `1.000`, write quorum `2`. |
 | Hot cache | 2000 lookups, hit rate `0.920`, p99 lookup `0.01 ms`. |
-| Replicated runtime | 3 physical WaveMind stores, replication factor 3, write quorum 2, node-loss recall `true`, repair copied `1` missing record, p99 query-after-loss `1.16 ms`. |
-| Structured payloads | image/audio/table/event retrieval, precision@1 `1.000`, p99 `0.69 ms`. |
+| Replicated runtime | 3 physical WaveMind stores, replication factor 3, write quorum 2, node-loss recall `true`, repair copied `1` missing record, tombstone repair deleted `1` stale record, p99 query-after-loss `1.44 ms`. |
+| Structured payloads | image/audio/table/event retrieval, precision@1 `1.000`, p99 `0.75 ms`. |
 
 This profile validates routing, quorum-replicated runtime behavior, cache
 behavior, and structured payload handling. It is not a 10M-vector load test.
@@ -988,7 +988,7 @@ Current read:
 | LongMemEval 50-query smoke | On the first 50 non-abstention LongMemEval-S questions, WaveMind reaches `evidence_recall@5 0.920`, `precision@1 0.760`, and `MRR@5 0.827`; Chroma/Qdrant static reach `0.600`, `0.260`, and `0.385`. | This is the fast regression profile for checking current changes before rerunning the full LongMemEval profile. WaveMind wins on quality; latency still needs work. |
 | ANN/index curve | At 50000 generated 128-d vectors, NumPy exact keeps `recall@10 1.000` at `6.49 ms`; quantized int8 keeps `0.934` at `24.92 ms`; Annoy is faster at `4.92 ms` but drops to `0.730` recall; Qdrant local keeps `1.000` recall at `43.49 ms`. | Current local scale boundary is clear: quantized search needs kernel work, Annoy needs tuning/FAISS, and Qdrant should be tested in service mode for a fair production comparison. |
 | Production load | At 100000 generated 128-d vectors, service-mode Qdrant reaches `recall@10 1.000`, avg `10.28 ms`, p99 `21.26 ms`. At 1M, tuned Qdrant reaches `recall@10 0.984`, avg `116.80 ms`, p99 `209.28 ms`; an EF sweep finds `recall@10 0.977`, avg `64.76 ms`, p99 `103.77 ms` at `hnsw_ef=2048` on 30 queries. | 100k is production-grade on the tested machine. 1M recall is now strong, but p99 still needs tuning before claiming a stable sub-100 ms SLO. |
-| Scale readiness | Deterministic 1M-memory simulation validates 4096 namespace placements over 4 nodes with replication factor 2, node-loss availability `1.000`, zone-loss availability `1.000`, hot-cache hit rate `0.920`, quorum-replicated runtime recall after node loss, replica repair, and structured payload precision@1 `1.000`. | This proves routing, cache, payload, and replicated-runtime foundations. It is not a 10M-vector latency claim; real 10M latency still needs service-backed load tests on larger hardware. |
+| Scale readiness | Deterministic 1M-memory simulation validates 4096 namespace placements over 4 nodes with replication factor 2, node-loss availability `1.000`, zone-loss availability `1.000`, hot-cache hit rate `0.920`, quorum-replicated runtime recall after node loss, missing-record repair, tombstone repair, and structured payload precision@1 `1.000`. | This proves routing, cache, payload, and replicated-runtime foundations. It is not a 10M-vector latency claim; real 10M latency still needs service-backed load tests on larger hardware. |
 | Memory competitor adapters | WaveMind reaches `precision@1 0.80`, `precision@3 1.00`, stale suppression `1.00` on the small adapter profile. Mem0, Zep, and LangGraph are listed as skipped unless their real packages/services are configured. | This prevents fake competitor claims. The adapter harness is ready; real Mem0/Zep/LangGraph results still need configured installs. |
 | LongMemEval local answer generation | With the same local Ollama `qwen2.5:1.5b`, WaveMind reaches `exact_match 0.240`, `contains_answer 0.380`, `token_f1 0.333`, and `evidence_recall@5 0.920`; Chroma and Qdrant static both reach `0.120`, `0.160`, `0.170`, and `0.600`. | This is the first checked-in end-to-end answer benchmark against Chroma/Qdrant. It is still a 50-question lightweight smoke run, not a full LongMemEval leaderboard score. |
 
@@ -1160,11 +1160,12 @@ print(memory.query("support replies", namespace="tenant:a", top_k=3))
 memory.close()
 ```
 
-The runtime uses separate durable stores per node, quorum writes, quorum reads,
-merged replica results, and `repair_namespace()` for recovered replicas. It is
-the production foundation for namespace-level HA; for full consensus across
-independent network services, deploy WaveMind with Postgres/Qdrant/ops-layer
-replication.
+The runtime uses separate durable stores per node, stable replica keys, operation
+metadata, quorum writes, quorum reads, merged replica results, tombstone-aware
+delete propagation, and `repair_namespace()` for recovered replicas. It is the
+production foundation for namespace-level HA and eventual-consistency behavior;
+for full consensus across independent network services, deploy WaveMind with
+Postgres/Qdrant/ops-layer replication.
 
 Checked-in official LoCoMo retrieval result:
 

{wavemind-2.2.4 → wavemind-2.2.5}/benchmarks/scale_readiness_benchmark.py

@@ -184,6 +184,41 @@ def run_replication_runtime_profile() -> dict[str, object]:
             finally:
                 partial.close()
 
+            tombstone = ReplicatedWaveMind(
+                root_path=Path(directory) / "tombstone",
+                nodes=[
+                    {"id": "node-a", "address": "127.0.0.1:8101", "zone": "zone-a"},
+                    {"id": "node-b", "address": "127.0.0.1:8102", "zone": "zone-b"},
+                    {"id": "node-c", "address": "127.0.0.1:8103", "zone": "zone-c"},
+                ],
+                replication_factor=3,
+                width=16,
+                height=16,
+                layers=1,
+                encoder=HashingTextEncoder(vector_dim=64),
+            )
+            try:
+                tombstone_placement = tombstone.placement(namespace)
+                missed_delete = tombstone_placement.replicas[-1]
+                tombstone.remember("repair must not resurrect deleted memory", namespace=namespace)
+                tombstone.set_node_available(missed_delete, False)
+                tombstone.forget(
+                    text="repair must not resurrect deleted memory",
+                    namespace=namespace,
+                )
+                tombstone.set_node_available(missed_delete, True)
+                suppressed_before_repair = (
+                    tombstone.query("resurrect deleted memory", namespace=namespace, top_k=1)
+                    == []
+                )
+                tombstone_repair = tombstone.repair_namespace(namespace)
+                suppressed_after_repair = (
+                    tombstone.query("resurrect deleted memory", namespace=namespace, top_k=1)
+                    == []
+                )
+            finally:
+                tombstone.close()
+
             return {
                 "engine": "WaveMind replicated runtime",
                 "nodes": 3,
@@ -193,6 +228,9 @@ def run_replication_runtime_profile() -> dict[str, object]:
                 "writes": len(write.writes),
                 "recalled_after_node_loss": recalled_after_loss,
                 "repair_copied_records": repair.copied_records,
+                "tombstone_suppressed_before_repair": suppressed_before_repair,
+                "tombstone_suppressed_after_repair": suppressed_after_repair,
+                "tombstone_repair_deleted_records": tombstone_repair.deleted_records,
                 "avg_query_after_loss_ms": statistics.mean(latencies),
                 "p99_query_after_loss_ms": percentile(latencies, 99),
             }
@@ -340,6 +378,7 @@ def main() -> int:
         elif result["engine"] == "WaveMind replicated runtime":
             print(f"| replicated runtime | recalled_after_node_loss | {result['recalled_after_node_loss']} |")
             print(f"| replicated runtime | repair_copied_records | {result['repair_copied_records']} |")
+            print(f"| replicated runtime | tombstone_repair_deleted_records | {result['tombstone_repair_deleted_records']} |")
         else:
             print(f"| structured payloads | precision@1 | {result['precision_at_1']:.3f} |")
     print(f"\nWrote {args.output}")

{wavemind-2.2.4 → wavemind-2.2.5}/benchmarks/scale_readiness_results.json

@@ -14,7 +14,7 @@
       "namespaces": 4096,
       "nodes": 4,
       "replication_factor": 2,
-      "placement_ms": 62.52979999408126,
+      "placement_ms": 58.688499964773655,
       "max_replica_load": 2413,
       "min_replica_load": 1728,
       "replica_load_stdev": 316.54462560593254,
@@ -32,8 +32,8 @@
       "capacity": 512,
       "hit_rate": 0.92,
       "evictions": 0,
-      "avg_lookup_ms": 0.0015143999480642378,
-      "p99_lookup_ms": 0.006199989002197981
+      "avg_lookup_ms": 0.0016512502334080637,
+      "p99_lookup_ms": 0.005799985956400633
     },
     {
       "engine": "WaveMind replicated runtime",
@@ -44,8 +44,11 @@
       "writes": 3,
       "recalled_after_node_loss": true,
       "repair_copied_records": 1,
-      "avg_query_after_loss_ms": 0.9093000553548336,
-      "p99_query_after_loss_ms": 0.9093000553548336
+      "tombstone_suppressed_before_repair": true,
+      "tombstone_suppressed_after_repair": true,
+      "tombstone_repair_deleted_records": 1,
+      "avg_query_after_loss_ms": 1.435799989849329,
+      "p99_query_after_loss_ms": 1.435799989849329
     },
     {
       "engine": "WaveMind structured payloads",
@@ -57,8 +60,8 @@
       ],
       "queries": 4,
       "precision_at_1": 1.0,
-      "avg_latency_ms": 0.5151500226929784,
-      "p99_latency_ms": 0.7709000492468476
+      "avg_latency_ms": 0.47089999134186655,
+      "p99_latency_ms": 0.7531000301241875
     }
   ]
 }

{wavemind-2.2.4 → wavemind-2.2.5}/docker-compose.yml

@@ -4,7 +4,7 @@ services:
       context: .
       args:
         INSTALL_OPTIONAL: "false"
-    image: wavemind:2.2.4
+    image: wavemind:2.2.5
     restart: unless-stopped
     environment:
       WAVEMIND_DB: /data/wavemind.sqlite3

{wavemind-2.2.4 → wavemind-2.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wavemind"
-version = "2.2.4"
+version = "2.2.5"
 description = "Local-first dynamic memory field with vector search and wave-field re-ranking"
 readme = "README.md"
 license = "MIT"

{wavemind-2.2.4 → wavemind-2.2.5}/tests/test_replication.py

@@ -97,6 +97,98 @@ def test_replicated_wavemind_repairs_recovered_replica(tmp_path):
         memory.close()
 
 
+def test_replicated_wavemind_repair_does_not_resurrect_forgotten_memory(tmp_path):
+    memory = _cluster(tmp_path, replication_factor=3)
+    try:
+        namespace = "tenant:tombstone"
+        memory.remember("stale replicated memory should stay deleted", namespace=namespace)
+        placement = memory.placement(namespace)
+        missed_delete = placement.replicas[-1]
+
+        memory.set_node_available(missed_delete, False)
+        delete = memory.forget(
+            text="stale replicated memory should stay deleted",
+            namespace=namespace,
+        )
+        assert delete.ok
+
+        memory.set_node_available(missed_delete, True)
+        assert memory._mind(missed_delete).store.count(namespace=namespace) == 1
+        assert memory.query("stale replicated memory", namespace=namespace, top_k=1) == []
+
+        report = memory.repair_namespace(namespace)
+
+        assert report.deleted_records == 1
+        assert report.copied_records == 0
+        assert report.tombstone_keys == 1
+        assert memory._mind(missed_delete).store.count(namespace=namespace) == 0
+        assert memory.query("stale replicated memory", namespace=namespace, top_k=1) == []
+    finally:
+        memory.close()
+
+
+def test_replicated_wavemind_forget_by_id_deletes_replicas_with_different_local_ids(tmp_path):
+    memory = _cluster(tmp_path, replication_factor=3, write_quorum=2)
+    try:
+        namespace = "tenant:id-delete"
+        placement = memory.placement(namespace)
+        lagging = next(node_id for node_id in placement.replicas if node_id != placement.primary)
+        memory.set_node_available(lagging, False)
+        memory.remember("advance ids on two replicas", namespace=namespace)
+        memory.set_node_available(lagging, True)
+
+        write = memory.remember("delete this record by primary id", namespace=namespace)
+        lagging_ids = [
+            record.id
+            for record in memory._mind(lagging).store.list(namespace=namespace)
+            if record.text == "delete this record by primary id"
+        ]
+
+        assert write.primary_id is not None
+        assert lagging_ids == [1]
+        assert write.primary_id != lagging_ids[0]
+
+        delete = memory.forget(id=write.primary_id, namespace=namespace)
+
+        assert delete.ok
+        assert all(
+            result.text != "delete this record by primary id"
+            for result in memory.query("delete this record by primary id", namespace=namespace, top_k=3)
+        )
+        for node_id in placement.replicas:
+            texts = [
+                record.text
+                for record in memory._mind(node_id).store.list(namespace=namespace)
+            ]
+            assert "delete this record by primary id" not in texts
+    finally:
+        memory.close()
+
+
+def test_replicated_wavemind_stores_stable_replica_metadata(tmp_path):
+    memory = _cluster(tmp_path, replication_factor=3)
+    try:
+        namespace = "tenant:metadata"
+        write = memory.remember(
+            "metadata replicated memory",
+            namespace=namespace,
+            tags=["profile"],
+            metadata={"source": "test"},
+        )
+        keys = set()
+        operation_ids = set()
+        for node_id in write.writes:
+            records = memory._mind(node_id).store.list(namespace=namespace)
+            assert len(records) == 1
+            keys.add(records[0].metadata["_wavemind_replica_key"])
+            operation_ids.add(records[0].metadata["_wavemind_operation_id"])
+
+        assert len(keys) == 1
+        assert len(operation_ids) == 1
+    finally:
+        memory.close()
+
+
 def test_replicated_wavemind_rejects_global_db_path(tmp_path):
     with pytest.raises(ValueError, match="db_path"):
         ReplicatedWaveMind(

{wavemind-2.2.4 → wavemind-2.2.5}/tests/test_scale_readiness_benchmark.py

@@ -18,5 +18,8 @@ def test_scale_readiness_benchmark_covers_cluster_cache_and_payloads():
     assert results["WaveMind hot cache"]["hit_rate"] > 0.0
     assert results["WaveMind replicated runtime"]["recalled_after_node_loss"] is True
     assert results["WaveMind replicated runtime"]["repair_copied_records"] == 1
+    assert results["WaveMind replicated runtime"]["tombstone_suppressed_before_repair"] is True
+    assert results["WaveMind replicated runtime"]["tombstone_suppressed_after_repair"] is True
+    assert results["WaveMind replicated runtime"]["tombstone_repair_deleted_records"] == 1
     assert results["WaveMind structured payloads"]["precision_at_1"] == 1.0
     assert payload["scenario"]["simulated_memories"] == 100_000

{wavemind-2.2.4 → wavemind-2.2.5}/wavemind/__init__.py

@@ -36,7 +36,7 @@ from .storage import (
     create_memory_store,
 )
 
-__version__ = "2.2.4"
+__version__ = "2.2.5"
 
 __all__ = [
     "FieldProjector",