wavemind 2.2.5__tar.gz → 2.2.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavemind
-Version: 2.2.5
+Version: 2.2.6
 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,13 +543,15 @@ 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, 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`. |
+| 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.33 ms`. |
+| Active-active delta sync | 2 regions, bidirectional convergence `true`, stale import suppressed after delete `true`, tombstone convergence `true`, sync `120.19 ms`. |
+| Structured payloads | image/audio/table/event retrieval, precision@1 `1.000`, p99 `0.62 ms`. |
 
 This profile validates routing, quorum-replicated runtime behavior, cache
-behavior, and structured payload handling. It is not a 10M-vector load test.
-Real 100k, 1M, and 10M latency claims should come from service-backed
-FAISS/Qdrant/pgvector load tests on production-like hardware.
+behavior, active-active namespace delta sync, and structured payload handling.
+It is not a 10M-vector load test. Real 100k, 1M, and 10M latency claims should
+come from service-backed FAISS/Qdrant/pgvector load tests on production-like
+hardware.
 
 Cluster placement planning:
 
@@ -1041,7 +1043,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, 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. |
+| 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, active-active delta sync, and structured payload precision@1 `1.000`. | This proves routing, cache, payload, replicated-runtime, and namespace-delta 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. |
 
@@ -1060,7 +1062,7 @@ Current read:
 | Production index profile | Docker-backed 50000-vector profile for persisted FAISS, Qdrant service, and PostgreSQL/pgvector HNSW. | implemented | FAISS / Qdrant service / pgvector | Keep service-mode candidate generation above `0.95` recall@10 and below 10 ms average query latency at 50000 vectors. |
 | Production load profile | 100k and 1M service-backed candidate-index checks with p95/p99 latency. | implemented | Qdrant service / pgvector HNSW / FAISS persisted | Keep 100k at recall@10 `1.000`; push 1M p99 below 100 ms with recall@10 >= 0.95. |
 | Qdrant 1M HNSW ef sweep | One 1M Qdrant collection queried with multiple `hnsw_ef` values. | implemented | Qdrant service | Repeat with 100+ queries and collection-level HNSW build parameters before claiming a stable 1M SLO. |
-| Scale readiness profile | Cluster placement, node/zone-loss simulation, quorum report, replicated runtime, hot-cache behavior, and structured/multimodal payload retrieval. | implemented | Mem0 / Zep / LangGraph persistent memory / GraphRAG target adapters | Keep quorum replication and repair green while adding larger service-backed 10M load tests. |
+| Scale readiness profile | Cluster placement, node/zone-loss simulation, quorum report, replicated runtime, active-active delta sync, hot-cache behavior, and structured/multimodal payload retrieval. | implemented | Mem0 / Zep / LangGraph persistent memory / GraphRAG target adapters | Keep quorum replication, namespace-delta sync, and repair green while adding larger service-backed 10M load tests. |
 | Memory competitor adapter profile | Dynamic-memory scenario wired for external memory frameworks. | implemented | Mem0 / Zep / LangGraph persistent memory | Report real competitor results only when their packages/services are explicitly configured. |
 | [BEIR](https://github.com/beir-cellar/beir) | Standard zero-shot information retrieval quality. | planned | Chroma / Qdrant / FAISS | Stay within 0.02 `nDCG@10` on identical embeddings. |
 | [MTEB Retrieval](https://github.com/embeddings-benchmark/mteb) | Separates encoder quality from retrieval-store quality. | planned | Chroma / Qdrant / FAISS | Prove WaveMind does not reduce same-embedding retrieval quality. |
@@ -1220,6 +1222,20 @@ 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.
 
+For multi-region active-active experiments, export and import namespace deltas:
+
+```python
+region_a.remember("Tenant A billing preference.", namespace="tenant:a")
+delta = region_a.export_namespace_delta("tenant:a")
+region_b.import_namespace_delta(delta)
+
+region_a.forget(text="Tenant A billing preference.", namespace="tenant:a")
+region_b.import_namespace_delta(region_a.export_namespace_delta("tenant:a"))
+```
+
+The delta contains active records plus tombstones. Import is idempotent and
+tombstone-aware, so a stale region export cannot resurrect a deleted memory.
+
 Checked-in official LoCoMo retrieval result:
 
 10 conversations, 5882 memory turns, 1977 evidence-labeled questions,

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

@@ -490,13 +490,15 @@ 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, 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`. |
+| 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.33 ms`. |
+| Active-active delta sync | 2 regions, bidirectional convergence `true`, stale import suppressed after delete `true`, tombstone convergence `true`, sync `120.19 ms`. |
+| Structured payloads | image/audio/table/event retrieval, precision@1 `1.000`, p99 `0.62 ms`. |
 
 This profile validates routing, quorum-replicated runtime behavior, cache
-behavior, and structured payload handling. It is not a 10M-vector load test.
-Real 100k, 1M, and 10M latency claims should come from service-backed
-FAISS/Qdrant/pgvector load tests on production-like hardware.
+behavior, active-active namespace delta sync, and structured payload handling.
+It is not a 10M-vector load test. Real 100k, 1M, and 10M latency claims should
+come from service-backed FAISS/Qdrant/pgvector load tests on production-like
+hardware.
 
 Cluster placement planning:
 
@@ -988,7 +990,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, 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. |
+| 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, active-active delta sync, and structured payload precision@1 `1.000`. | This proves routing, cache, payload, replicated-runtime, and namespace-delta 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. |
 
@@ -1007,7 +1009,7 @@ Current read:
 | Production index profile | Docker-backed 50000-vector profile for persisted FAISS, Qdrant service, and PostgreSQL/pgvector HNSW. | implemented | FAISS / Qdrant service / pgvector | Keep service-mode candidate generation above `0.95` recall@10 and below 10 ms average query latency at 50000 vectors. |
 | Production load profile | 100k and 1M service-backed candidate-index checks with p95/p99 latency. | implemented | Qdrant service / pgvector HNSW / FAISS persisted | Keep 100k at recall@10 `1.000`; push 1M p99 below 100 ms with recall@10 >= 0.95. |
 | Qdrant 1M HNSW ef sweep | One 1M Qdrant collection queried with multiple `hnsw_ef` values. | implemented | Qdrant service | Repeat with 100+ queries and collection-level HNSW build parameters before claiming a stable 1M SLO. |
-| Scale readiness profile | Cluster placement, node/zone-loss simulation, quorum report, replicated runtime, hot-cache behavior, and structured/multimodal payload retrieval. | implemented | Mem0 / Zep / LangGraph persistent memory / GraphRAG target adapters | Keep quorum replication and repair green while adding larger service-backed 10M load tests. |
+| Scale readiness profile | Cluster placement, node/zone-loss simulation, quorum report, replicated runtime, active-active delta sync, hot-cache behavior, and structured/multimodal payload retrieval. | implemented | Mem0 / Zep / LangGraph persistent memory / GraphRAG target adapters | Keep quorum replication, namespace-delta sync, and repair green while adding larger service-backed 10M load tests. |
 | Memory competitor adapter profile | Dynamic-memory scenario wired for external memory frameworks. | implemented | Mem0 / Zep / LangGraph persistent memory | Report real competitor results only when their packages/services are explicitly configured. |
 | [BEIR](https://github.com/beir-cellar/beir) | Standard zero-shot information retrieval quality. | planned | Chroma / Qdrant / FAISS | Stay within 0.02 `nDCG@10` on identical embeddings. |
 | [MTEB Retrieval](https://github.com/embeddings-benchmark/mteb) | Separates encoder quality from retrieval-store quality. | planned | Chroma / Qdrant / FAISS | Prove WaveMind does not reduce same-embedding retrieval quality. |
@@ -1167,6 +1169,20 @@ 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.
 
+For multi-region active-active experiments, export and import namespace deltas:
+
+```python
+region_a.remember("Tenant A billing preference.", namespace="tenant:a")
+delta = region_a.export_namespace_delta("tenant:a")
+region_b.import_namespace_delta(delta)
+
+region_a.forget(text="Tenant A billing preference.", namespace="tenant:a")
+region_b.import_namespace_delta(region_a.export_namespace_delta("tenant:a"))
+```
+
+The delta contains active records plus tombstones. Import is idempotent and
+tombstone-aware, so a stale region export cannot resurrect a deleted memory.
+
 Checked-in official LoCoMo retrieval result:
 
 10 conversations, 5882 memory turns, 1977 evidence-labeled questions,

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

@@ -238,6 +238,79 @@ def run_replication_runtime_profile() -> dict[str, object]:
             memory.close()
 
 
+def run_active_active_delta_profile() -> dict[str, object]:
+    with tempfile.TemporaryDirectory() as directory:
+        kwargs = {
+            "replication_factor": 3,
+            "width": 16,
+            "height": 16,
+            "layers": 1,
+            "encoder": HashingTextEncoder(vector_dim=64),
+        }
+        region_a = ReplicatedWaveMind(
+            root_path=Path(directory) / "region-a",
+            nodes=[
+                {"id": "region-a-1", "address": "127.0.0.1:8101", "zone": "zone-a"},
+                {"id": "region-a-2", "address": "127.0.0.1:8102", "zone": "zone-b"},
+                {"id": "region-a-3", "address": "127.0.0.1:8103", "zone": "zone-c"},
+            ],
+            **kwargs,
+        )
+        region_b = ReplicatedWaveMind(
+            root_path=Path(directory) / "region-b",
+            nodes=[
+                {"id": "region-b-1", "address": "127.0.0.1:8201", "zone": "zone-a"},
+                {"id": "region-b-2", "address": "127.0.0.1:8202", "zone": "zone-b"},
+                {"id": "region-b-3", "address": "127.0.0.1:8203", "zone": "zone-c"},
+            ],
+            **kwargs,
+        )
+        try:
+            namespace = "tenant:active-active"
+            region_a.remember("region a billing preference", namespace=namespace)
+            region_b.remember("region b support preference", namespace=namespace)
+            sync_started = time.perf_counter()
+            import_b = region_b.import_namespace_delta(
+                region_a.export_namespace_delta(namespace)
+            )
+            import_a = region_a.import_namespace_delta(
+                region_b.export_namespace_delta(namespace)
+            )
+            sync_ms = (time.perf_counter() - sync_started) * 1000.0
+            converged = (
+                region_a.query("support preference", namespace=namespace, top_k=1)
+                and region_b.query("billing preference", namespace=namespace, top_k=1)
+            )
+
+            stale_delta = region_b.export_namespace_delta(namespace)
+            region_a.forget(text="region a billing preference", namespace=namespace)
+            region_a.import_namespace_delta(stale_delta)
+            suppressed_stale_import = all(
+                result.text != "region a billing preference"
+                for result in region_a.query("billing preference", namespace=namespace, top_k=3)
+            )
+            tombstone_delta = region_a.export_namespace_delta(namespace)
+            tombstone_report = region_b.import_namespace_delta(tombstone_delta)
+            tombstone_converged = all(
+                result.text != "region a billing preference"
+                for result in region_b.query("billing preference", namespace=namespace, top_k=3)
+            )
+            return {
+                "engine": "WaveMind active-active delta sync",
+                "regions": 2,
+                "replication_factor_per_region": 3,
+                "records_imported": import_a.imported_records + import_b.imported_records,
+                "converged_after_bidirectional_sync": bool(converged),
+                "sync_ms": sync_ms,
+                "suppressed_stale_import_after_delete": suppressed_stale_import,
+                "tombstone_deleted_records": tombstone_report.deleted_records,
+                "tombstone_converged": tombstone_converged,
+            }
+        finally:
+            region_a.close()
+            region_b.close()
+
+
 def run_multimodal_profile() -> dict[str, object]:
     with tempfile.TemporaryDirectory() as directory:
         memory = WaveMind(
@@ -325,6 +398,7 @@ def run_benchmark(
         ),
         run_cache_profile(queries=cache_queries, capacity=cache_capacity),
         run_replication_runtime_profile(),
+        run_active_active_delta_profile(),
         run_multimodal_profile(),
     ]
     return {
@@ -337,8 +411,8 @@ def run_benchmark(
             "description": (
                 "Deterministic scale-readiness profile for cluster placement, "
                 "node/zone loss simulation, quorum-replicated runtime behavior, "
-                "hot-cache behavior, and structured payload retrieval. This is "
-                "not a 10M-vector database load test."
+                "active-active delta sync, hot-cache behavior, and structured "
+                "payload retrieval. This is not a 10M-vector database load test."
             ),
         },
         "results": results,
@@ -379,6 +453,9 @@ def main() -> int:
             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']} |")
+        elif result["engine"] == "WaveMind active-active delta sync":
+            print(f"| active-active delta | converged | {result['converged_after_bidirectional_sync']} |")
+            print(f"| active-active delta | tombstone_converged | {result['tombstone_converged']} |")
         else:
             print(f"| structured payloads | precision@1 | {result['precision_at_1']:.3f} |")
     print(f"\nWrote {args.output}")

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

@@ -5,7 +5,7 @@
     "namespace_count": 4096,
     "node_count": 4,
     "replication_factor": 2,
-    "description": "Deterministic scale-readiness profile for cluster placement, node/zone loss simulation, quorum-replicated runtime behavior, hot-cache behavior, and structured payload retrieval. This is not a 10M-vector database load test."
+    "description": "Deterministic scale-readiness profile for cluster placement, node/zone loss simulation, quorum-replicated runtime behavior, active-active delta sync, hot-cache behavior, and structured payload retrieval. This is not a 10M-vector database load test."
   },
   "results": [
     {
@@ -14,7 +14,7 @@
       "namespaces": 4096,
       "nodes": 4,
       "replication_factor": 2,
-      "placement_ms": 58.688499964773655,
+      "placement_ms": 55.97210000269115,
       "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.0016512502334080637,
-      "p99_lookup_ms": 0.005799985956400633
+      "avg_lookup_ms": 0.001386649877531454,
+      "p99_lookup_ms": 0.0026999623514711857
     },
     {
       "engine": "WaveMind replicated runtime",
@@ -47,8 +47,19 @@
       "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
+      "avg_query_after_loss_ms": 1.3324000174179673,
+      "p99_query_after_loss_ms": 1.3324000174179673
+    },
+    {
+      "engine": "WaveMind active-active delta sync",
+      "regions": 2,
+      "replication_factor_per_region": 3,
+      "records_imported": 6,
+      "converged_after_bidirectional_sync": true,
+      "sync_ms": 120.19369995687157,
+      "suppressed_stale_import_after_delete": true,
+      "tombstone_deleted_records": 3,
+      "tombstone_converged": true
     },
     {
       "engine": "WaveMind structured payloads",
@@ -60,8 +71,8 @@
       ],
       "queries": 4,
       "precision_at_1": 1.0,
-      "avg_latency_ms": 0.47089999134186655,
-      "p99_latency_ms": 0.7531000301241875
+      "avg_latency_ms": 0.4274749953765422,
+      "p99_latency_ms": 0.6231999723240733
     }
   ]
 }

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

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

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

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

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

@@ -24,6 +24,22 @@ def _cluster(tmp_path, **kwargs):
     )
 
 
+def _region(tmp_path, name: str, **kwargs):
+    return ReplicatedWaveMind(
+        root_path=tmp_path / name,
+        nodes=[
+            {"id": f"{name}-a", "address": "127.0.0.1:8101", "zone": "zone-a"},
+            {"id": f"{name}-b", "address": "127.0.0.1:8102", "zone": "zone-b"},
+            {"id": f"{name}-c", "address": "127.0.0.1:8103", "zone": "zone-c"},
+        ],
+        width=16,
+        height=16,
+        layers=1,
+        encoder=HashingTextEncoder(vector_dim=64),
+        **kwargs,
+    )
+
+
 def test_replicated_wavemind_writes_to_all_replicas_and_reads_after_node_loss(tmp_path):
     memory = _cluster(tmp_path, replication_factor=3)
     try:
@@ -189,6 +205,78 @@ def test_replicated_wavemind_stores_stable_replica_metadata(tmp_path):
         memory.close()
 
 
+def test_replicated_wavemind_namespace_delta_converges_two_regions(tmp_path):
+    region_a = _region(tmp_path, "region-a", replication_factor=3)
+    region_b = _region(tmp_path, "region-b", replication_factor=3)
+    try:
+        namespace = "tenant:active-active"
+        region_a.remember("region a remembers billing preference", namespace=namespace)
+        region_b.remember("region b remembers support preference", namespace=namespace)
+
+        report_b = region_b.import_namespace_delta(region_a.export_namespace_delta(namespace))
+        report_a = region_a.import_namespace_delta(region_b.export_namespace_delta(namespace))
+
+        assert report_b.imported_records == 3
+        assert report_a.imported_records == 3
+        assert region_a.query("support preference", namespace=namespace, top_k=1)[0].text == (
+            "region b remembers support preference"
+        )
+        assert region_b.query("billing preference", namespace=namespace, top_k=1)[0].text == (
+            "region a remembers billing preference"
+        )
+    finally:
+        region_a.close()
+        region_b.close()
+
+
+def test_replicated_wavemind_delta_import_is_idempotent(tmp_path):
+    region_a = _region(tmp_path, "region-a", replication_factor=3)
+    region_b = _region(tmp_path, "region-b", replication_factor=3)
+    try:
+        namespace = "tenant:idempotent"
+        region_a.remember("idempotent active active memory", namespace=namespace)
+        delta = region_a.export_namespace_delta(namespace)
+
+        first = region_b.import_namespace_delta(delta)
+        second = region_b.import_namespace_delta(delta)
+        placement = region_b.placement(namespace)
+
+        assert first.imported_records == 3
+        assert second.imported_records == 0
+        assert second.skipped_records == 3
+        for node_id in placement.replicas:
+            records = region_b._mind(node_id).store.list(namespace=namespace)
+            assert [record.text for record in records] == ["idempotent active active memory"]
+    finally:
+        region_a.close()
+        region_b.close()
+
+
+def test_replicated_wavemind_tombstone_delta_beats_stale_record_delta(tmp_path):
+    region_a = _region(tmp_path, "region-a", replication_factor=3)
+    region_b = _region(tmp_path, "region-b", replication_factor=3)
+    try:
+        namespace = "tenant:tombstone-delta"
+        region_a.remember("delete wins over stale region export", namespace=namespace)
+        region_b.import_namespace_delta(region_a.export_namespace_delta(namespace))
+        stale_delta = region_b.export_namespace_delta(namespace)
+
+        region_a.forget(text="delete wins over stale region export", namespace=namespace)
+        region_a.import_namespace_delta(stale_delta)
+
+        assert region_a.query("stale region export", namespace=namespace, top_k=1) == []
+
+        tombstone_delta = region_a.export_namespace_delta(namespace)
+        report = region_b.import_namespace_delta(tombstone_delta)
+
+        assert report.deleted_records == 3
+        assert report.imported_tombstones == 3
+        assert region_b.query("stale region export", namespace=namespace, top_k=1) == []
+    finally:
+        region_a.close()
+        region_b.close()
+
+
 def test_replicated_wavemind_rejects_global_db_path(tmp_path):
     with pytest.raises(ValueError, match="db_path"):
         ReplicatedWaveMind(

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

@@ -21,5 +21,9 @@ def test_scale_readiness_benchmark_covers_cluster_cache_and_payloads():
     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 active-active delta sync"]["converged_after_bidirectional_sync"] is True
+    assert results["WaveMind active-active delta sync"]["suppressed_stale_import_after_delete"] is True
+    assert results["WaveMind active-active delta sync"]["tombstone_converged"] is True
+    assert results["WaveMind active-active delta sync"]["tombstone_deleted_records"] == 3
     assert results["WaveMind structured payloads"]["precision_at_1"] == 1.0
     assert payload["scenario"]["simulated_memories"] == 100_000

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

@@ -20,6 +20,7 @@ from .multimodal import (
 )
 from .replication import (
     ReadQuorumError,
+    ReplicatedDeltaImportReport,
     ReplicatedRepairReport,
     ReplicatedWaveMind,
     ReplicatedWriteResult,
@@ -36,7 +37,7 @@ from .storage import (
     create_memory_store,
 )
 
-__version__ = "2.2.5"
+__version__ = "2.2.6"
 
 __all__ = [
     "FieldProjector",
@@ -55,6 +56,7 @@ __all__ = [
     "QueryResult",
     "ReadQuorumError",
     "RedisHotMemoryCache",
+    "ReplicatedDeltaImportReport",
     "ReplicatedRepairReport",
     "ReplicatedWaveMind",
     "ReplicatedWriteResult",