zaxy-memory 2.4.2__tar.gz → 2.4.3__tar.gz

{zaxy_memory-2.4.2 → zaxy_memory-2.4.3}/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable Zaxy release changes are recorded here.
 
+## 2.4.3 - 2026-06-15
+
+- **`memory_checkout` no longer blocks the MCP event loop — interrupting an
+  in-flight checkout cancels cleanly instead of tearing down the server.**
+  Checkout's synchronous, CPU/IO-bound retrieval (full replay + verbatim index
+  build + packet assembly) ran directly on the asyncio event loop, so while a
+  checkout was in progress the server could not read stdin or honor the
+  client's cancellation. A killed call therefore escalated to a transport
+  teardown and the server process exited ("server crashed when I killed the
+  call"). The heavy sections now run in worker threads via `asyncio.to_thread`,
+  keeping the loop responsive so cancellation unwinds gracefully and the server
+  stays up.
+  - `handle_memory_checkout` and `_assemble_context` offload `replay`, the
+    `VerbatimIndex` build, and `build_memory_checkout` to threads.
+  - A new per-server `asyncio.Lock` serializes the off-loop checkout body,
+    preserving the prior single-flight invariant over shared session/index
+    state now that the work can overlap across awaits.
+  - No API or behavior change; same cited facts are surfaced.
+
 ## 2.4.2 - 2026-06-15
 
 - **Memory Checkout latency fix — warm `memory_checkout` ~19s → ~1.6s on a

{zaxy_memory-2.4.2 → zaxy_memory-2.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zaxy-memory
-Version: 2.4.2
+Version: 2.4.3
 Summary: Coordinator memory for auditable multi-agent projects
 Project-URL: Homepage, https://syndicalt.github.io/zaxy/
 Project-URL: Documentation, https://syndicalt.github.io/zaxy/docs/getting-started.html

{zaxy_memory-2.4.2 → zaxy_memory-2.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "zaxy-memory"
-version = "2.4.2"
+version = "2.4.3"
 description = "Coordinator memory for auditable multi-agent projects"
 readme = "README.md"
 requires-python = ">=3.11"

{zaxy_memory-2.4.2 → zaxy_memory-2.4.3}/site/index.html

@@ -62,7 +62,7 @@
     </section>
 
     <section class="proof-strip" aria-label="Project status">
-      <span>PyPI 2.4.2</span>
+      <span>PyPI 2.4.3</span>
       <span>47 MCP tools, 8-tool core profile</span>
       <span>cognitive ranking default</span>
       <span>embedded local runtime</span>
@@ -334,7 +334,7 @@ zaxy coordinate checkout --mission auth-main</code></pre>
   </main>
 
   <footer>
-    <span>Zaxy v2.4.2 - MIT</span>
+    <span>Zaxy v2.4.3 - MIT</span>
     <span><a href="README.html">README</a> <a href="docs/runbook.html">Runbook</a></span>
   </footer>
 </body>

{zaxy_memory-2.4.2 → zaxy_memory-2.4.3}/src/zaxy/mcp_server.py

@@ -1380,6 +1380,14 @@ class ZaxyMCPServer:
         # signature so any append rebuilds it (the log-signature pattern used
         # by the projection's derived read caches).
         self._fok_index_cache: dict[str, tuple[str, FeelingOfKnowingIndex]] = {}
+        # Serializes the heavy, off-loop checkout body. Checkout's retrieval
+        # (full replay + verbatim index build) is synchronous and CPU/IO-bound;
+        # it runs in a worker thread (see handle_memory_checkout) so the event
+        # loop stays free to read stdin and honor client cancellations. The lock
+        # preserves the previous "one checkout at a time" invariant that the
+        # shared session/index state was written under, now that the work can
+        # overlap across awaits.
+        self._checkout_lock = asyncio.Lock()
         self._eventloom_path = eventloom_path or settings.eventloom_path
         self.session_manager = SessionManager(base_path=self._eventloom_path)
         self.refs = MemoryRefStore(self._eventloom_path)
@@ -2870,21 +2878,30 @@ class ZaxyMCPServer:
         resolved_ref = self._resolve_checkout_ref(ref, session_id=session_id)
         checkout_session_id = resolved_ref.session_id if resolved_ref is not None else session_id
 
-        assembly, replay_events = await self._assemble_context(
-            query=query,
-            session_id=checkout_session_id,
-            replay_from_seq=replay_from_seq,
-            limit=limit,
-            max_recent_events=max_recent_events,
-            as_of_seq=resolved_ref.target_seq if resolved_ref is not None else None,
-        )
-        output = build_memory_checkout(
-            query=query,
-            assembly=_context_assembly_from_payload(assembly, replay_events=replay_events),
-            ref=resolved_ref,
-            purpose=arguments.get("purpose"),
-            now=datetime.now(UTC),
-        ).to_dict()
+        # Hold the checkout lock across the heavy retrieval/build so the
+        # synchronous, thread-offloaded sections stay serialized (preserving the
+        # prior single-flight invariant) while the event loop remains free to
+        # service stdin and cancellations. If the client cancels mid-checkout,
+        # the await points below raise CancelledError and unwind cleanly; the
+        # orphaned worker thread finishes harmlessly and the server stays up.
+        async with self._checkout_lock:
+            assembly, replay_events = await self._assemble_context(
+                query=query,
+                session_id=checkout_session_id,
+                replay_from_seq=replay_from_seq,
+                limit=limit,
+                max_recent_events=max_recent_events,
+                as_of_seq=resolved_ref.target_seq if resolved_ref is not None else None,
+            )
+            built = await asyncio.to_thread(
+                build_memory_checkout,
+                query=query,
+                assembly=_context_assembly_from_payload(assembly, replay_events=replay_events),
+                ref=resolved_ref,
+                purpose=arguments.get("purpose"),
+                now=datetime.now(UTC),
+            )
+        output = built.to_dict()
         output = apply_checkout_budget(output, max_tokens=max_tokens)
         activity = record_memory_activity(
             self._eventloom_path,
@@ -3068,7 +3085,8 @@ class ZaxyMCPServer:
         resolve citations into sealed refs and to replay diagnostics-only
         salience without an extra log scan.
         """
-        replay = self.session_manager.replay(
+        replay = await asyncio.to_thread(
+            self.session_manager.replay,
             session_id,
             from_seq=replay_from_seq,
             verify_integrity=False,
@@ -3086,9 +3104,11 @@ class ZaxyMCPServer:
         results = await router.query(query, limit=limit)
         graph_contexts = [_context_from_query_result(result) for result in results]
         verbatim_hits = (
-            VerbatimIndex.from_event_logs(
-                [self.session_manager.get(session_id).eventlog]
-            ).query(query, limit=limit)
+            await asyncio.to_thread(
+                lambda: VerbatimIndex.from_event_logs(
+                    [self.session_manager.get(session_id).eventlog]
+                ).query(query, limit=limit)
+            )
             if self.context_assembly_policy.should_query_verbatim(limit=limit)
             else []
         )

{zaxy_memory-2.4.2 → zaxy_memory-2.4.3}/tests/test_docs_site.py

@@ -102,7 +102,7 @@ def test_public_site_has_product_positioning_and_required_sections() -> None:
     assert "Eventloom source of truth" in html
     assert "Pathlight" in html
     assert "embedded LadybugDB" in html
-    assert "PyPI 2.4.2" in html
+    assert "PyPI 2.4.3" in html
     assert "Harvey LAB 10/10 tasks" in html
     assert "Harvey LAB mean 0.788" in html
     assert "Headline 500 R@5 1.000" in html