@@ -129,20 +129,21 @@ class InterruptTaskParams(BaseModel):
 
 # Methods whose handler must finish before the RPC responds.
 #
-# TASK_CREATE and EVENT_SEND are here because dispatching them in the background
-# loses work silently. The handlers run against Temporal: TASK_CREATE starts the
-# workflow, EVENT_SEND signals it. Backgrounding both means a caller that does
-# task/create followed by event/send can have its signal reach Temporal before
-# the workflow exists, and the signal is dropped with `workflow not found`. The
-# caller cannot tell, because the background path already answered
-# {"status": "processing"} and the handler's exception is only logged.
+# TASK_CREATE is here because its whole contract is to hand back an id for a
+# task that now exists. Its handler starts the Temporal workflow, so answering
+# before the handler runs returns an id the server cannot yet route to: a caller
+# that follows task/create with event/send can have its signal arrive first and
+# be dropped with `workflow not found`. Nothing batches task creations, so there
+# is no benefit to trade against, and start_workflow is a short RPC.
 #
-# Both handlers are short Temporal RPCs, and the caller applies its own timeout,
-# so awaiting them costs little and makes failures visible and retryable.
+# EVENT_SEND deliberately stays asynchronous. Callers send events in quick
+# succession and the workflow drains them as a batch; awaiting each send
+# serialises them and no batch ever holds more than one event. Once TASK_CREATE
+# is synchronous the workflow is addressable before any event is sent, which is
+# what the race needed.
 RPC_SYNC_METHODS = [
     RPCMethod.MESSAGE_SEND,
     RPCMethod.TASK_CREATE,
-    RPCMethod.EVENT_SEND,
 ]
 
 PARAMS_MODEL_BY_METHOD: dict[RPCMethod, type[BaseModel]] = {
 
@@ -1,18 +1,21 @@
-"""Unit tests for synchronous dispatch of ``task/create`` and ``event/send``.
+"""Unit tests for the dispatch mode of ``task/create`` and ``event/send``.
 
-Background dispatch of these two methods loses work silently. The ACP server
-used to answer ``{"status": "processing"}`` before running the handler, so a
-caller doing ``task/create`` then ``event/send`` could have its signal reach
-Temporal before the workflow existed. The signal was dropped with
-``workflow not found``, and the caller saw success either way because the
-handler's exception was raised into a background task that only logged it.
+``task/create`` hands back an id for a task that now exists, and its handler is
+what starts the Temporal workflow. Dispatching it in the background answered
+before the handler ran, so the id named a workflow the server could not yet
+route to. A caller that followed ``task/create`` with ``event/send`` could have
+its signal arrive first and be dropped with ``workflow not found``, and it saw
+success either way because the handler's exception was raised into a background
+task that only logged it.
 
-These tests pin the two properties that fix depends on:
+``event/send`` keeps its background dispatch on purpose: callers send events in
+quick succession and the workflow drains them as a batch, which awaiting each
+send would serialise. These tests pin both halves so neither is changed by
+accident:
 
-1. The response is not sent until the handler has finished, so a caller that
-   sequences two calls gets the ordering it asked for.
-2. A handler that raises produces a JSON-RPC error, so the failure is visible
-   and retryable at the client.
+1. ``task/create`` finishes its handler before responding, and surfaces a
+   handler failure as a JSON-RPC error.
+2. ``event/send`` still acknowledges immediately without waiting.
 
 ``SyncACP`` is used as the transport because it constructs with no Temporal
 connection and no network, and the dispatch under test lives in the shared
@@ -63,6 +66,14 @@ def _event() -> Event:
     )
 
 
+def _create_params() -> CreateTaskParams:
+    return CreateTaskParams(agent=_agent(), task=_task(), params=None)
+
+
+def _event_params() -> SendEventParams:
+    return SendEventParams(agent=_agent(), task=_task(), event=_event())
+
+
 class _FakeRequest:
     """The slice of ``starlette.requests.Request`` that ``_handle_jsonrpc`` uses."""
 
@@ -74,13 +85,6 @@ async def json(self) -> dict[str, Any]:
         return self._payload
 
 
-async def _dispatch(acp: SyncACP, method: RPCMethod, params: Any) -> JSONRPCResponse:
-    """Call the JSON-RPC entry point and narrow its untyped return."""
-    response = await acp._handle_jsonrpc(_FakeRequest(_rpc(method, params)))  # pyright: ignore[reportArgumentType]
-    assert isinstance(response, JSONRPCResponse)
-    return response
-
-
 def _rpc(method: RPCMethod, params: Any) -> dict[str, Any]:
     return {
         "jsonrpc": "2.0",
@@ -90,27 +94,36 @@ def _rpc(method: RPCMethod, params: Any) -> dict[str, Any]:
     }
 
 
+async def _dispatch(acp: SyncACP, method: RPCMethod, params: Any) -> JSONRPCResponse:
+    """Call the JSON-RPC entry point and narrow its untyped return."""
+    response = await acp._handle_jsonrpc(_FakeRequest(_rpc(method, params)))  # pyright: ignore[reportArgumentType]
+    assert isinstance(response, JSONRPCResponse)
+    return response
+
+
 # ---------------------------------------------------------------------------
-# Protocol
+# Which methods are synchronous
 # ---------------------------------------------------------------------------
 
 
 class TestSyncMethodSet:
-    @pytest.mark.parametrize(
-        "method",
-        [RPCMethod.MESSAGE_SEND, RPCMethod.TASK_CREATE, RPCMethod.EVENT_SEND],
-    )
+    @pytest.mark.parametrize("method", [RPCMethod.MESSAGE_SEND, RPCMethod.TASK_CREATE])
     def test_method_is_synchronous(self, method: RPCMethod) -> None:
         assert method in RPC_SYNC_METHODS
 
+    def test_event_send_stays_asynchronous(self) -> None:
+        # Batching depends on it: callers send events in quick succession and the
+        # workflow drains them together. Awaiting each send serialises them.
+        assert RPCMethod.EVENT_SEND not in RPC_SYNC_METHODS
+
 
 # ---------------------------------------------------------------------------
-# Dispatch ordering
+# task/create: handler completes before the response
 # ---------------------------------------------------------------------------
 
 
-class TestHandlerCompletesBeforeResponse:
-    async def test_task_create_awaits_handler(self) -> None:
+class TestTaskCreateAwaitsHandler:
+    async def test_handler_runs_before_response(self) -> None:
         acp = SyncACP()
         order: list[str] = []
 
@@ -121,64 +134,51 @@ async def handler(params: CreateTaskParams) -> None:
             await asyncio.sleep(0)
             order.append("handler")
 
-        response = await _dispatch(
-            acp, RPCMethod.TASK_CREATE, CreateTaskParams(agent=_agent(), task=_task(), params=None)
-        )
-        order.append("response")
-
-        assert order == ["handler", "response"]
-        assert response.error is None
-        assert response.result != {"status": "processing"}
-
-    async def test_event_send_awaits_handler(self) -> None:
-        acp = SyncACP()
-        order: list[str] = []
-
-        @acp.on_task_event_send
-        async def handler(params: SendEventParams) -> None:
-            await asyncio.sleep(0)
-            order.append("handler")
-
-        response = await _dispatch(
-            acp, RPCMethod.EVENT_SEND, SendEventParams(agent=_agent(), task=_task(), event=_event())
-        )
+        response = await _dispatch(acp, RPCMethod.TASK_CREATE, _create_params())
         order.append("response")
 
         assert order == ["handler", "response"]
         assert response.error is None
         assert response.result != {"status": "processing"}
 
-
-# ---------------------------------------------------------------------------
-# Failure visibility
-# ---------------------------------------------------------------------------
-
-
-class TestHandlerFailureReachesCaller:
-    async def test_task_create_failure_returns_error(self) -> None:
+    async def test_handler_failure_returns_error(self) -> None:
         acp = SyncACP()
 
         @acp.on_task_create
         async def handler(params: CreateTaskParams) -> None:
             raise RuntimeError("workflow not found for ID: test-task-123")
 
-        response = await _dispatch(
-            acp, RPCMethod.TASK_CREATE, CreateTaskParams(agent=_agent(), task=_task(), params=None)
-        )
+        response = await _dispatch(acp, RPCMethod.TASK_CREATE, _create_params())
 
         assert response.error is not None
         assert "workflow not found" in response.error.message
 
-    async def test_event_send_failure_returns_error(self) -> None:
+
+# ---------------------------------------------------------------------------
+# event/send: acknowledges without waiting
+# ---------------------------------------------------------------------------
+
+
+class TestEventSendIsBackgrounded:
+    async def test_response_does_not_wait_for_handler(self) -> None:
         acp = SyncACP()
+        started = asyncio.Event()
+        order: list[str] = []
 
         @acp.on_task_event_send
         async def handler(params: SendEventParams) -> None:
-            raise RuntimeError("workflow not found for ID: test-task-123")
+            await asyncio.sleep(0)
+            order.append("handler")
+            started.set()
+
+        response = await _dispatch(acp, RPCMethod.EVENT_SEND, _event_params())
+        order.append("response")
 
-        response = await _dispatch(
-            acp, RPCMethod.EVENT_SEND, SendEventParams(agent=_agent(), task=_task(), event=_event())
-        )
+        # The acknowledgment comes back before the handler has run, which is what
+        # lets a caller enqueue several events without waiting on each one.
+        assert order == ["response"]
+        assert response.result == {"status": "processing"}
 
-        assert response.error is not None
-        assert "workflow not found" in response.error.message
+        # The handler still runs, just afterwards.
+        await asyncio.wait_for(started.wait(), timeout=5)
+        assert order == ["response", "handler"]