geny-executor 2.65.2__tar.gz → 2.65.3__tar.gz

{geny_executor-2.65.2 → geny_executor-2.65.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: geny-executor
-Version: 2.65.2
+Version: 2.65.3
 Summary: Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor

{geny_executor-2.65.2 → geny_executor-2.65.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.65.2"
+version = "2.65.3"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "Apache-2.0"

{geny_executor-2.65.2 → geny_executor-2.65.3}/src/geny_executor/memory/_locks.py

@@ -70,7 +70,56 @@ class LoopAgnosticLock:
         # Contended: wait in a worker thread so the event loop keeps running
         # (and the current holder — possibly a coroutine on THIS loop that
         # yielded mid-critical-section — can make progress and release).
-        await asyncio.to_thread(self._lock.acquire)
+        #
+        # CANCELLATION LEAKS THE MUTEX unless it is handled here, and the
+        # leak is permanent. A worker thread blocked in ``lock.acquire()``
+        # cannot be cancelled: cancelling the *await* abandons the waiter
+        # while the thread goes on to take the lock, on behalf of a caller
+        # that no longer exists. ``__aenter__`` never returns, so
+        # ``__aexit__`` never runs, and the mutex is held forever by
+        # nobody. Every later acquirer — the turn's own memory write, the
+        # compaction kick, the conversation archiver — then parks on it,
+        # so the session stops answering until the process restarts.
+        #
+        # Production, 2026-08-11: turns were being abandoned by a
+        # host-side stall guard, and each abandonment leaked this lock, so
+        # one stall turned into every later turn stalling. Observed as
+        # three separate stacks parked in this method with no holder
+        # anywhere in the task list.
+        #
+        # So the WORKER decides what to do with the lock it just took, and
+        # decides it in the worker. Handing back via a loop callback would
+        # work only while the loop is still running — and "the loop is
+        # going away" is exactly one of the situations that cancels an
+        # acquire. ``handoff`` guards the one race that matters: the
+        # instant between the thread taking the mutex and the caller
+        # deciding it no longer wants it.
+        handoff = threading.Lock()
+        state = {"cancelled": False, "held": False}
+
+        def _take() -> bool:
+            self._lock.acquire()
+            with handoff:
+                if state["cancelled"]:
+                    self._lock.release()   # nobody is waiting for it now
+                    return False
+                state["held"] = True
+                return True
+
+        waiter = asyncio.ensure_future(asyncio.to_thread(_take))
+        try:
+            # shield: cancelling the inner task would not stop the thread,
+            # it would only hide what the thread went on to do.
+            await asyncio.shield(waiter)
+        except asyncio.CancelledError:
+            with handoff:
+                if state["held"]:
+                    # The thread already took it for us; give it straight
+                    # back, here, without needing the loop again.
+                    self._lock.release()
+                else:
+                    state["cancelled"] = True
+            raise
 
     async def __aenter__(self) -> "LoopAgnosticLock":
         await self._acquire_without_blocking_loop()

geny_executor-2.65.3/tests/unit/test_lock_cancel_leak.py

@@ -0,0 +1,153 @@
+"""A cancelled acquirer must not walk off with the lock.
+
+Production, 2026-08-11. Turns stopped answering and stayed that way
+until a restart. Three separate stacks — the turn's own memory write,
+the compaction kick, the conversation archiver — were all parked in
+``LoopAgnosticLock._acquire_without_blocking_loop``, and no task in the
+process held the lock.
+
+A worker thread blocked in ``lock.acquire()`` cannot be cancelled.
+Cancelling the *await* abandoned the waiter while the thread went on to
+take the mutex on behalf of a caller that no longer existed:
+``__aenter__`` never returned, so ``__aexit__`` never ran, and the lock
+was held forever by nobody. Every later acquirer parked behind it.
+
+The trigger was mundane and frequent — a host-side stall guard
+abandoning a slow turn. One stall leaked the lock; from then on every
+turn stalled.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+
+import pytest
+
+from geny_executor.memory._locks import LoopAgnosticLock
+
+
+async def _acquire_and_release(lock: LoopAgnosticLock) -> None:
+    async with lock:
+        pass
+
+
+@pytest.mark.asyncio
+async def test_cancelling_a_contended_acquire_does_not_strand_the_lock():
+    """The exact production shape, minimised."""
+    lock = LoopAgnosticLock()
+    holder_may_release = asyncio.Event()
+    holder_has_lock = asyncio.Event()
+
+    async def holder():
+        async with lock:
+            holder_has_lock.set()
+            await holder_may_release.wait()
+
+    h = asyncio.create_task(holder())
+    await holder_has_lock.wait()
+
+    c = asyncio.create_task(_acquire_and_release(lock))
+    await asyncio.sleep(0.05)          # let it reach the thread hop
+    c.cancel()                          # ← the stall guard, in production
+    with pytest.raises(asyncio.CancelledError):
+        await c
+
+    holder_may_release.set()
+    await h
+
+    # The lock must be free. Before the fix the worker thread took it on
+    # behalf of the cancelled contender and nothing ever released it.
+    await asyncio.wait_for(_acquire_and_release(lock), timeout=5.0)
+    assert not lock.locked()
+
+
+@pytest.mark.asyncio
+async def test_repeated_cancellations_do_not_accumulate():
+    """One leak is already fatal; ten makes sure the release path itself
+    does not go wrong under repetition."""
+    lock = LoopAgnosticLock()
+    release = asyncio.Event()
+    got_it = asyncio.Event()
+
+    async def holder():
+        async with lock:
+            got_it.set()
+            await release.wait()
+
+    h = asyncio.create_task(holder())
+    await got_it.wait()
+
+    for _ in range(10):
+        c = asyncio.create_task(_acquire_and_release(lock))
+        await asyncio.sleep(0.01)
+        c.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await c
+
+    release.set()
+    await h
+    await asyncio.wait_for(_acquire_and_release(lock), timeout=5.0)
+    assert not lock.locked()
+
+
+@pytest.mark.asyncio
+async def test_uncancelled_contention_still_works():
+    """The fix must not break what the lock is for: a contended acquirer
+    waits, then gets it, and not before."""
+    lock = LoopAgnosticLock()
+    order = []
+    release = asyncio.Event()
+    got_it = asyncio.Event()
+
+    async def holder():
+        async with lock:
+            got_it.set()
+            order.append("holder-in")
+            await release.wait()
+            order.append("holder-out")
+
+    async def waiter():
+        async with lock:
+            order.append("waiter-in")
+
+    h = asyncio.create_task(holder())
+    await got_it.wait()
+    w = asyncio.create_task(waiter())
+    await asyncio.sleep(0.05)
+    assert order == ["holder-in"], "the waiter took a held lock"
+    release.set()
+    await asyncio.wait_for(asyncio.gather(h, w), timeout=5.0)
+    assert order == ["holder-in", "holder-out", "waiter-in"]
+
+
+@pytest.mark.asyncio
+async def test_the_loop_keeps_running_while_contended():
+    """The reason for the thread hop in the first place — a contended
+    acquire must not freeze the event loop."""
+    lock = LoopAgnosticLock()
+    release = asyncio.Event()
+    got_it = asyncio.Event()
+    ticks = 0
+
+    async def ticker():
+        nonlocal ticks
+        for _ in range(5):
+            await asyncio.sleep(0.01)
+            ticks += 1
+
+    async def holder():
+        async with lock:
+            got_it.set()
+            await release.wait()
+
+    h = asyncio.create_task(holder())
+    await got_it.wait()
+    w = asyncio.create_task(_acquire_and_release(lock))
+    await ticker()
+    assert ticks == 5, "the loop stopped while an acquire was contended"
+    release.set()
+    await asyncio.wait_for(asyncio.gather(h, w), timeout=5.0)