harness-sdk-python 0.13.1__tar.gz → 0.13.3__tar.gz

{harness_sdk_python-0.13.1 → harness_sdk_python-0.13.3}/PKG-INFO

@@ -1,11 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.13.1
+Version: 0.13.3
 Summary: RunManager: the harness-sdk runs subsystem for Python Statewire hosts
 Project-URL: Repository, https://github.com/assistant-ui/harness-sdk
 License-Expression: MIT
 Requires-Python: <4.0,>=3.11
-Requires-Dist: statewire<0.7,>=0.6.0
+Requires-Dist: statewire<0.8,>=0.7.0
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.13.1 → harness_sdk_python-0.13.3}/examples/runs_app.py

@@ -107,7 +107,7 @@ class RunsHost(Statewire):
                         "content": user_text(message),
                     }
                 )
-            ctx.ack()
+            ctx.applied()
             outcome = await self.stream_turn(ctx)
             if outcome is not None:
                 return outcome
@@ -158,11 +158,11 @@ class RunsHost(Statewire):
 
     @command("run/enqueue")
     async def run_enqueue(self, params, *, ctx):
-        return await self.runs.enqueue(params, ack=ctx.ack)
+        return await self.runs.enqueue(params, applied=ctx.applied)
 
     @command("run/steer")
     async def run_steer(self, params, *, ctx):
-        return await self.runs.steer(params, ack=ctx.ack)
+        return await self.runs.steer(params, applied=ctx.applied)
 
     @command("run/dequeue")
     async def run_dequeue(self, params):
@@ -170,19 +170,19 @@ class RunsHost(Statewire):
 
     @command("run/edit")
     async def run_edit(self, params, *, ctx):
-        return await self.runs.edit(params, ack=ctx.ack)
+        return await self.runs.edit(params, applied=ctx.applied)
 
     @command("run/reload")
     async def run_reload(self, params, *, ctx):
-        return await self.runs.reload(params, ack=ctx.ack)
+        return await self.runs.reload(params, applied=ctx.applied)
 
     @command("run/stop")
     async def run_stop(self, params=None, *, ctx):
-        return await self.runs.stop(params, ack=ctx.ack)
+        return await self.runs.stop(params, applied=ctx.applied)
 
     @command("run/continue")
     async def run_continue(self, params=None, *, ctx):
-        return await self.runs.continue_run(ack=ctx.ack)
+        return await self.runs.continue_run(applied=ctx.applied)
 
     @command("run/input")
     async def run_input(self, params):

{harness_sdk_python-0.13.1 → harness_sdk_python-0.13.3}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.13.1"
+version = "0.13.3"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.11,<4.0"
-dependencies = ["statewire>=0.6.0,<0.7"]
+dependencies = ["statewire>=0.7.0,<0.8"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.13.1 → harness_sdk_python-0.13.3}/src/harness_sdk/run_manager.py

@@ -10,23 +10,23 @@ dispatchable send appends straight into ``dispatching`` — it never transits a
 queue lane — and everything staged there by the end of the drain dispatches
 as one run; in error/stop the dispatch is the continuation
 (``error-continue`` / ``stop-continue``) carrying the send's messages. Every
-initiator acks and settles accepted with its state-visible application —
-sends with their insert (lane or ``dispatching``), edit/reload/continue at
-their dispatch; ``run/stop`` awaits a future the drain resolves once the
-in-flight run has ended.
+initiator applies and settles accepted with its state-visible application:
+the verdict certifies the admission write — sends with their insert (lane
+or ``dispatching``), mid-run edit/reload with the stopping window,
+``run/stop`` with ``stopping`` — never future execution.
 
-``entry["dispatching"]`` is the dispatch record (absent between an ack and
+``entry["dispatching"]`` is the dispatch record (absent between an applied and
 the next dispatch or take): the payload the run callback receives.
-``ctx.ack()`` clears it; ``steering.take()`` may refill it — at most one
-unacked batch ever exists. Settle consumes the delivered batch, acked or not;
+``ctx.applied()`` clears it; ``steering.take()`` may refill it — at most one
+unapplied batch ever exists. Settle consumes the delivered batch, applied or not;
 steer entries still undelivered in the lane stay queued for the next run.
 
 A mid-run stop or rewind opens a stopping window on the entry:
 ``stopping: {reason}`` plus, for rewinds, the staged dispatch as
 ``nextDispatch`` — written in the same envelope as the opener's pending
 answer. On run end one envelope promotes ``nextDispatch`` into
-``dispatching`` and clears the window; a later stop/rewind supersedes the
-staged one, which settles rejected (``superseded``).
+``dispatching`` and clears the window; a later stop/rewind replaces the
+staged dispatch, whose command already settled at its admission write.
 """
 
 import asyncio
@@ -87,7 +87,7 @@ class _Send:
     message_id: str
     source_meta: dict[str, Any] | None
     meta: Any
-    ack: Callable[[], None]
+    applied: Callable[[], None]
     run_id: str = ""
     anchor: Any = _ABSENT
     anchor_meta: dict[str, Any] | None = None
@@ -107,7 +107,7 @@ class _Edit:
     source_meta: dict[str, Any]
     message: dict[str, Any]
     meta: Any
-    ack: Callable[[], None]
+    applied: Callable[[], None]
     run_id: str
     future: "asyncio.Future[Any]" = field(default_factory=_future)
 
@@ -116,7 +116,7 @@ class _Edit:
 class _Reload:
     source_meta: dict[str, Any]
     meta: Any
-    ack: Callable[[], None]
+    applied: Callable[[], None]
     run_id: str
     future: "asyncio.Future[Any]" = field(default_factory=_future)
 
@@ -145,11 +145,11 @@ class _Rewind:
     type: str
     messages: list[dict[str, Any]]
     rollback_to: Any
-    ack: Callable[[], None]
+    applied: Callable[[], None]
     future: "asyncio.Future[Any]"
     run_id: str
     root_meta: Any = None
-    acked: bool = False
+    applied_sent: bool = False
 
 
 @dataclass
@@ -209,7 +209,7 @@ class RunManager:
         self._dispatch_record: dict[str, Any] | None = None
         self._intake: list[Any] = []
         self._outcome: Any = None
-        self._staged_stops: list["asyncio.Future[Any]"] = []
+        self._stop_staged = False
         self._stop_reason: str | None = None
         self._staged_rewind: _Rewind | None = None
         self._dispatching: list[tuple[str, dict[str, Any]]] = []
@@ -354,10 +354,7 @@ class RunManager:
         for entry in entries:
             self._apply(entry, fx)
         if self._task is None:
-            for stop in self._staged_stops:
-                if not stop.done():
-                    stop.set_result(None)
-            self._staged_stops.clear()
+            self._stop_staged = False
             if isinstance(outcome, RunManager.Complete):
                 self._dispatched_ids = ()
             if self._staged_rewind is not None:
@@ -376,21 +373,19 @@ class RunManager:
                     rollback_to=rewind.rollback_to,
                     root_meta=rewind.root_meta,
                 )
-                if not rewind.acked:
-                    rewind.ack()
-                if not rewind.future.done():
-                    rewind.future.set_result(None)
+                if not rewind.applied_sent:
+                    rewind.applied()
             elif outcome is not None:
                 self._settle_outcome(outcome)
             else:
                 self._idle_action(fx)
         if self._task is not None and (
-            self._staged_stops or self._staged_rewind is not None
+            self._stop_staged or self._staged_rewind is not None
         ):
             assert self._ctx is not None
             self._ctx.stop_requested.set()
-        for future, ack, result in fx.staged_sends:
-            ack()
+        for future, applied, result in fx.staged_sends:
+            applied()
             if not future.done():
                 future.set_result(result)
         for future in fx.continues:
@@ -401,12 +396,14 @@ class RunManager:
 
     def _apply(self, entry: Any, fx: _Effects) -> None:
         if isinstance(entry, _Stop):
-            self._staged_stops.append(entry.future)
             if self._task is not None:
+                self._stop_staged = True
                 if self._staged_rewind is not None:
-                    self._supersede()
+                    self._staged_rewind = None
                     self._entry().pop("nextDispatch", None)
                 self._entry()["stopping"] = {"reason": "stop"}
+            if not entry.future.done():
+                entry.future.set_result(None)
             return
         if isinstance(entry, _Continue):
             if not fx.continue_requested:
@@ -604,11 +601,11 @@ class RunManager:
         entry.pop("dispatching", None)
         entry.pop("stopping", None)
 
-    def _ack(self) -> None:
+    def _applied(self) -> None:
         entry = self._entry()
         record = plain(entry.get("dispatching"))
         if record is None:
-            raise RuntimeError("ack() with no unacked batch")
+            raise RuntimeError("applied() with no unapplied batch")
         self._dispatching = []
         entry.pop("dispatching", None)
 
@@ -683,17 +680,7 @@ class RunManager:
             return True
         return False
 
-    def _supersede(self) -> None:
-        rewind, self._staged_rewind = self._staged_rewind, None
-        assert rewind is not None
-        if not rewind.future.done():
-            rewind.future.set_exception(
-                _reject("superseded", "a later stop/rewind replaced this command")
-            )
-
     def _stage_rewind(self, rewind: _Rewind) -> None:
-        if self._staged_rewind is not None:
-            self._supersede()
         self._staged_rewind = rewind
         if self._task is not None:
             entry = self._entry()
@@ -704,8 +691,10 @@ class RunManager:
                 rollback_to=rewind.rollback_to,
                 root_meta=rewind.root_meta,
             )
-            rewind.ack()
-            rewind.acked = True
+            rewind.applied()
+            rewind.applied_sent = True
+        if not rewind.future.done():
+            rewind.future.set_result(None)
 
     def _freeze(self, message: str, payload: Any = None) -> None:
         self._set_status("error")
@@ -952,7 +941,7 @@ class RunManager:
             if live_run_id is not None and e.anchor is not _ABSENT
             else None
         )
-        fx.staged_sends.append((e.future, e.ack, result))
+        fx.staged_sends.append((e.future, e.applied, result))
         return _PARKED
 
     def _apply_move(self, e: _Send, fx: _Effects) -> Any:
@@ -992,7 +981,7 @@ class RunManager:
                 "message-edit",
                 [self._stamped(e.message, e.meta)],
                 e.source_meta["parentId"],
-                e.ack,
+                e.applied,
                 e.future,
                 e.run_id,
             )
@@ -1047,7 +1036,7 @@ class RunManager:
                 "message-edit",
                 [self._stamped(e.message, e.meta)],
                 e.source_meta["parentId"],
-                e.ack,
+                e.applied,
                 e.future,
                 e.run_id,
             )
@@ -1060,7 +1049,7 @@ class RunManager:
                 "message-reload",
                 [],
                 e.source_meta["parentId"],
-                e.ack,
+                e.applied,
                 e.future,
                 e.run_id,
                 root_meta=e.meta,
@@ -1075,7 +1064,7 @@ class RunManager:
         lane: str,
         params: Any,
         meta: Any,
-        ack: Callable[[], None],
+        applied: Callable[[], None],
     ) -> Any:
         if not isinstance(params, dict):
             raise _reject("invalid-message", "params must be an object")
@@ -1111,7 +1100,7 @@ class RunManager:
                     message_id,
                     None,
                     None,
-                    ack,
+                    applied,
                     run_id=run_id,
                     anchor=anchor,
                     anchor_meta=anchor_meta,
@@ -1128,7 +1117,7 @@ class RunManager:
                 message["id"],
                 source_meta,
                 meta,
-                ack,
+                applied,
                 run_id=run_id,
                 anchor=anchor,
                 anchor_meta=anchor_meta,
@@ -1137,14 +1126,14 @@ class RunManager:
         )
 
     async def enqueue(
-        self, params: Any, *, meta: Any = None, ack: Callable[[], None]
+        self, params: Any, *, meta: Any = None, applied: Callable[[], None]
     ) -> Any:
-        return await self._send("queue", params, meta, ack)
+        return await self._send("queue", params, meta, applied)
 
     async def steer(
-        self, params: Any, *, meta: Any = None, ack: Callable[[], None]
+        self, params: Any, *, meta: Any = None, applied: Callable[[], None]
     ) -> Any:
-        return await self._send("steerQueue", params, meta, ack)
+        return await self._send("steerQueue", params, meta, applied)
 
     async def dequeue(self, params: Any) -> None:
         message_id = params.get("messageId") if isinstance(params, dict) else None
@@ -1163,7 +1152,7 @@ class RunManager:
             raise _reject("capability-missing", "the rewind capability is not enabled")
 
     async def edit(
-        self, params: Any, *, meta: Any = None, ack: Callable[[], None]
+        self, params: Any, *, meta: Any = None, applied: Callable[[], None]
     ) -> Any:
         self._check_rewind_gate("run/edit")
         run_id = _run_id_of(params)
@@ -1187,11 +1176,11 @@ class RunManager:
         ):
             raise _reject("duplicate-id", f"message id {message['id']} is already used")
         return await self._stage(
-            _Edit(source_id, source_meta, message, meta, ack, run_id)
+            _Edit(source_id, source_meta, message, meta, applied, run_id)
         )
 
     async def reload(
-        self, params: Any, *, meta: Any = None, ack: Callable[[], None]
+        self, params: Any, *, meta: Any = None, applied: Callable[[], None]
     ) -> Any:
         self._check_rewind_gate("run/reload")
         run_id = _run_id_of(params)
@@ -1215,9 +1204,9 @@ class RunManager:
                     "capability-missing",
                     "the assistant-continuation capability is not enabled",
                 )
-        return await self._stage(_Reload(source_meta, meta, ack, run_id))
+        return await self._stage(_Reload(source_meta, meta, applied, run_id))
 
-    async def stop(self, params: Any = None, *, ack: Callable[[], None]) -> Any:
+    async def stop(self, params: Any = None, *, applied: Callable[[], None]) -> Any:
         if params is not None and not isinstance(params, dict):
             raise _reject("invalid-message", "params must be an object")
         reason = (params or {}).get("reason", _ABSENT)
@@ -1235,7 +1224,7 @@ class RunManager:
             self._stop_reason = reason
         entry = _Stop()
         self._intake.append(entry)
-        ack()
+        applied()
         self._schedule(self._drain)
         return await entry.future
 
@@ -1285,7 +1274,7 @@ class RunManager:
         response = self._validated_response(request["type"], params["response"])
         return await self._stage(_Input(request_id, response, meta))
 
-    async def continue_run(self, *, meta: Any = None, ack: Callable[[], None]) -> Any:
+    async def continue_run(self, *, meta: Any = None, applied: Callable[[], None]) -> Any:
         status = self._status()
         if status not in ("error", "stopped"):
             raise _reject("wrong-state", f"run/continue is rejected in {status}")
@@ -1298,7 +1287,7 @@ class RunManager:
             )
         entry = _Continue(meta)
         self._intake.append(entry)
-        ack()
+        applied()
         self._schedule(self._drain)
         return await entry.future
 
@@ -1351,12 +1340,12 @@ class RunManager:
         _ctx: "RunManager.RunContext"
 
         def take(self) -> tuple[dict[str, Any], ...]:
-            """Drain the steer lane into a fresh dispatch record; requires the current batch to be acked."""
+            """Drain the steer lane into a fresh dispatch record; requires the current batch to be applied."""
             self._ctx._ensure_active()
             manager = self._ctx._manager
             entry = manager._entry()
             if plain(entry.get("dispatching")) is not None:
-                raise RuntimeError("take before the current batch is acked")
+                raise RuntimeError("take before the current batch is applied")
             items = manager._lane_items("steerQueue")
             if not items:
                 return ()
@@ -1421,10 +1410,10 @@ class RunManager:
             if self._manager._ctx is not self:
                 raise RuntimeError("this run has already settled")
 
-        def ack(self) -> None:
-            """Ack the current batch: clears the dispatch record."""
+        def applied(self) -> None:
+            """Applied the current batch: clears the dispatch record."""
             self._ensure_active()
-            self._manager._ack()
+            self._manager._applied()
 
         def set_recovery_state(self, value: Any) -> None:
             self._ensure_active()

{harness_sdk_python-0.13.1 → harness_sdk_python-0.13.3}/tests/run_helpers.py

@@ -16,8 +16,8 @@ class Call:
     ctx: RunManager.RunContext
     outcome: "asyncio.Future[Any]"
 
-    def ack(self) -> None:
-        self.ctx.ack()
+    def applied(self) -> None:
+        self.ctx.applied()
 
     def finish(self, outcome: Any) -> None:
         self.outcome.set_result(outcome)
@@ -87,11 +87,11 @@ def make_host(
 
         @command("run/enqueue")
         async def run_enqueue(self, params, *, ctx):
-            return await self.runs.enqueue(params, meta=_meta(params), ack=ctx.ack)
+            return await self.runs.enqueue(params, meta=_meta(params), applied=ctx.applied)
 
         @command("run/steer")
         async def run_steer(self, params, *, ctx):
-            return await self.runs.steer(params, meta=_meta(params), ack=ctx.ack)
+            return await self.runs.steer(params, meta=_meta(params), applied=ctx.applied)
 
         @command("run/dequeue")
         async def run_dequeue(self, params):
@@ -99,19 +99,19 @@ def make_host(
 
         @command("run/edit")
         async def run_edit(self, params, *, ctx):
-            return await self.runs.edit(params, meta=_meta(params), ack=ctx.ack)
+            return await self.runs.edit(params, meta=_meta(params), applied=ctx.applied)
 
         @command("run/reload")
         async def run_reload(self, params, *, ctx):
-            return await self.runs.reload(params, meta=_meta(params), ack=ctx.ack)
+            return await self.runs.reload(params, meta=_meta(params), applied=ctx.applied)
 
         @command("run/stop")
         async def run_stop(self, params=None, *, ctx):
-            return await self.runs.stop(params, ack=ctx.ack)
+            return await self.runs.stop(params, applied=ctx.applied)
 
         @command("run/continue")
         async def run_continue(self, params=None, *, ctx):
-            return await self.runs.continue_run(meta=_meta(params), ack=ctx.ack)
+            return await self.runs.continue_run(meta=_meta(params), applied=ctx.applied)
 
         @command("run/input")
         async def run_input(self, params):
@@ -205,7 +205,7 @@ class RunDriver:
         return await self.res(self._seq)
 
     async def res(self, seq: int, *, terminal: bool = True) -> dict[str, Any]:
-        # A payload-less accept rides only the ack; rejections and late
+        # A payload-less accept rides only the legacy ack; rejections and late
         # settles ride res.
         while True:
             entries = self._res.get(seq, [])

harness_sdk_python-0.13.1/tests/test_ack_visibility.py → harness_sdk_python-0.13.3/tests/test_applied_visibility.py

@@ -1,8 +1,8 @@
-"""Contract: acks ride visibility. A send's covering ack only rides an
+"""Contract: applied rides visibility. A send's covering applied only rides an
 envelope whose state carries the command's effect — the item in a published
 queue lane or in ``dispatching``. An idle send's insert lands in
-``dispatching`` directly, so its ack rides the dispatch envelope and the queue
-lane never holds the item; a rewind's ack rides its dispatch the same way."""
+``dispatching`` directly, so its applied rides the dispatch envelope and the queue
+lane never holds the item; a rewind's applied rides its dispatch the same way."""
 
 import copy
 
@@ -35,7 +35,7 @@ def assert_never_queued(drv, message_id):
         assert message_id not in queue_ids(state, "queue")
 
 
-async def test_idle_send_acks_with_its_dispatching_insert():
+async def test_idle_send_applies_with_its_dispatching_insert():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/enqueue", add("m1"))
@@ -44,23 +44,23 @@ async def test_idle_send_acks_with_its_dispatching_insert():
         assert dispatching_ids(covered_state(drv, seq)) == ["m1"]
         assert_never_queued(drv, "m1")
         host.live.state["messages"] = [msg("m1")]
-        call.ack()
+        call.applied()
         call.finish(RunManager.Complete())
 
 
-async def test_parked_send_acks_with_its_queue_insert():
+async def test_parked_send_applies_with_its_queue_insert():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        call.ack()
+        call.applied()
         res = await drv.command("run/enqueue", add("m2"))
         assert res["type"] == "accepted"
         assert "m2" in queue_ids(covered_state(drv, res["seq"]), "queue")
         call.finish(RunManager.Complete())
 
 
-async def test_unacked_run_end_consumes_the_direct_dispatch():
+async def test_unapplied_run_end_consumes_the_direct_dispatch():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/enqueue", add("m1"))
@@ -72,7 +72,7 @@ async def test_unacked_run_end_consumes_the_direct_dispatch():
         assert queue_ids(drv.replica, "queue") == []
 
 
-async def test_unacked_run_end_consumes_the_direct_steer_send():
+async def test_unapplied_run_end_consumes_the_direct_steer_send():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/steer", add("s1"))
@@ -85,7 +85,7 @@ async def test_unacked_run_end_consumes_the_direct_steer_send():
         assert queue_ids(drv.replica, "queue") == []
 
 
-async def test_rewind_edit_acks_with_its_dispatch():
+async def test_rewind_edit_applies_with_its_dispatch():
     script = Script()
     script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
@@ -95,6 +95,6 @@ async def test_rewind_edit_acks_with_its_dispatch():
         await drv.wait_status("running")
         assert dispatching_ids(covered_state(drv, seq)) == ["u2"]
         host.live.state["messages"] = [msg("u2")]
-        rerun.ack()
+        rerun.applied()
         rerun.finish(RunManager.Complete())
         assert (await drv.res(seq))["type"] == "accepted"

{harness_sdk_python-0.13.1 → harness_sdk_python-0.13.3}/tests/test_batches.py

@@ -25,7 +25,7 @@ async def test_multi_steer_batch_places_all_and_dispatches_once():
         assert [m["id"] for m in call.ctx.messages] == ["s1", "s2", "s3"]
         script.no_call()
         assert queue_ids(drv.replica, "steerQueue") == []
-        call.ack()
+        call.applied()
         call.finish(RunManager.Complete())
         for offset in range(3):
             assert (await drv.res(first + offset))["type"] == "accepted"
@@ -45,7 +45,7 @@ async def test_same_tick_sends_dispatch_as_one_run():
         merged = await drv.res(first + 1)
         assert merged["type"] == "accepted"
         assert merged["payload"] == {"runId": mint["runId"]}
-        call.ack()
+        call.applied()
         call.finish(RunManager.Complete())
 
 
@@ -54,35 +54,29 @@ async def test_steer_and_stop_in_one_batch_nets_to_stop():
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        call.ack()
+        call.applied()
         first = drv.batch(
             [("run/steer", add("s1")), ("run/stop", {"runId": await drv.run_id()})]
         )
         assert (await drv.res(first))["type"] == "accepted"
-        assert (await drv.res(first + 1, terminal=False))["type"] == "pending"
+        assert (await drv.res(first + 1))["type"] == "accepted"
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
         call.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(first + 1))["type"] == "accepted"
         await drv.wait_status("stopped")
         assert queue_ids(drv.replica, "steerQueue") == ["s1"]
         script.no_call()
 
 
-async def test_stop_settles_only_after_the_run_task_ends():
+async def test_stop_settles_at_the_stopping_write():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        call.ack()
-        pending = await drv.stop(terminal=False)
-        assert pending["type"] == "pending"
-        for _ in range(5):
-            await asyncio.sleep(0)
-        assert all(
-            rsp["type"] == "pending" for rsp in drv._res.get(pending["seq"], [])
-        )
+        call.applied()
+        settled = await drv.stop()
+        assert settled["type"] == "accepted"
+        assert drv.replica["status"] == "running"
         call.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(pending["seq"]))["type"] == "accepted"
         await drv.wait_status("stopped")
 
 
@@ -110,10 +104,10 @@ async def test_handler_tail_staging_decides_in_its_own_envelope():
             )
         )
         # The decide ran outside the batch segment: its ops flush in an
-        # envelope of their own, carrying the send's covering ack.
+        # envelope of their own, carrying the send's covering applied.
         assert dispatch_env.get("ack", 0) >= seq
         assert (await drv.res(seq))["type"] == "accepted"
-        call.ack()
+        call.applied()
 
 
 async def test_rewind_outranks_send_and_continue_in_one_batch():
@@ -135,7 +129,7 @@ async def test_rewind_outranks_send_and_continue_in_one_batch():
             "isLeaf": True,
             "onActiveBranch": True,
         }
-        call.ack()
+        call.applied()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         first = drv.batch(
@@ -153,7 +147,7 @@ async def test_rewind_outranks_send_and_continue_in_one_batch():
         assert (await drv.res(first + 1))["type"] == "accepted"
         assert (await drv.res(first + 2))["type"] == "accepted"
         assert queue_ids(drv.replica, "queue") == ["q1"]
-        rerun.ack()
+        rerun.applied()
         rerun.finish(RunManager.Complete())
 
 
@@ -162,7 +156,7 @@ async def test_send_outranks_the_completing_input_answer():
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        call.ack()
+        call.applied()
         request = {"type": "tool-call", "id": "r1", "toolCallId": "tc1"}
         call.finish(RunManager.InputRequired((request,)))
         await drv.wait_status("input-required")
@@ -179,6 +173,6 @@ async def test_send_outranks_the_completing_input_answer():
         script.no_call()
         assert (await drv.res(first))["type"] == "accepted"
         assert (await drv.res(first + 1))["type"] == "accepted"
-        run.ack()
+        run.applied()
         run.finish(RunManager.Complete())
         await drv.wait_status("ready")