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

{harness_sdk_python-0.13.2 → 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.2
+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.2 → 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.2 → harness_sdk_python-0.13.3}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.13.2"
+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.2 → harness_sdk_python-0.13.3}/src/harness_sdk/run_manager.py

@@ -10,15 +10,15 @@ 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:
+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:
@@ -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
@@ -373,8 +373,8 @@ class RunManager:
                     rollback_to=rewind.rollback_to,
                     root_meta=rewind.root_meta,
                 )
-                if not rewind.acked:
-                    rewind.ack()
+                if not rewind.applied_sent:
+                    rewind.applied()
             elif outcome is not None:
                 self._settle_outcome(outcome)
             else:
@@ -384,8 +384,8 @@ class RunManager:
         ):
             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:
@@ -601,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)
 
@@ -691,8 +691,8 @@ 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)
 
@@ -941,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:
@@ -981,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,
             )
@@ -1036,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,
             )
@@ -1049,7 +1049,7 @@ class RunManager:
                 "message-reload",
                 [],
                 e.source_meta["parentId"],
-                e.ack,
+                e.applied,
                 e.future,
                 e.run_id,
                 root_meta=e.meta,
@@ -1064,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")
@@ -1100,7 +1100,7 @@ class RunManager:
                     message_id,
                     None,
                     None,
-                    ack,
+                    applied,
                     run_id=run_id,
                     anchor=anchor,
                     anchor_meta=anchor_meta,
@@ -1117,7 +1117,7 @@ class RunManager:
                 message["id"],
                 source_meta,
                 meta,
-                ack,
+                applied,
                 run_id=run_id,
                 anchor=anchor,
                 anchor_meta=anchor_meta,
@@ -1126,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
@@ -1152,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)
@@ -1176,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)
@@ -1204,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)
@@ -1224,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
 
@@ -1274,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}")
@@ -1287,7 +1287,7 @@ class RunManager:
             )
         entry = _Continue(meta)
         self._intake.append(entry)
-        ack()
+        applied()
         self._schedule(self._drain)
         return await entry.future
 
@@ -1340,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 ()
@@ -1410,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.2 → 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.2/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.2 → 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,7 +54,7 @@ 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()})]
         )
@@ -72,7 +72,7 @@ async def test_stop_settles_at_the_stopping_write():
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        call.ack()
+        call.applied()
         settled = await drv.stop()
         assert settled["type"] == "accepted"
         assert drv.replica["status"] == "running"
@@ -104,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():
@@ -129,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(
@@ -147,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())
 
 
@@ -156,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")
@@ -173,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")

{harness_sdk_python-0.13.2 → harness_sdk_python-0.13.3}/tests/test_branch_anchor.py

@@ -48,7 +48,7 @@ async def test_anchorless_send_targets_the_live_run():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
-        (await script.next_call()).ack()
+        (await script.next_call()).applied()
         res = await drv.command(
             "run/steer", {"runId": await drv.run_id(), "message": msg("s1")}, terminal=False
         )
@@ -60,7 +60,7 @@ async def test_null_anchor_valid_only_on_an_empty_thread():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
-        (await script.next_call()).ack()
+        (await script.next_call()).applied()
         script.thread["m1"] = {
             "parentId": None, "role": "user", "isLeaf": True, "onActiveBranch": True
         }
@@ -82,7 +82,7 @@ async def test_active_branch_anchor_accepted_off_branch_and_unknown_rejected():
     )
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1", anchor="a1"))
-        (await script.next_call()).ack()
+        (await script.next_call()).applied()
         assert_rejected(
             await drv.command("run/enqueue", add("m2", anchor="old"), terminal=False),
             "wrong-anchor",
@@ -97,7 +97,7 @@ async def test_queued_item_and_dispatched_ids_are_valid_anchors():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
-        (await script.next_call()).ack()
+        (await script.next_call()).applied()
         await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
         await drv.command("run/steer", add("s1", anchor="m2"), terminal=False)
         assert queue_ids(drv.replica, "queue") == ["m2"]
@@ -113,7 +113,7 @@ async def test_replaced_tail_anchor_rejects_after_an_edit_rewrite():
     )
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         drv.post("run/edit", edit_params("u1", msg("m2"), anchor=None))
-        (await script.next_call()).ack()
+        (await script.next_call()).applied()
         script.thread["u1"] = {
             "parentId": None, "role": "user", "isLeaf": True, "onActiveBranch": False
         }
@@ -128,7 +128,7 @@ async def test_replaced_tail_anchor_rejects_after_an_edit_rewrite():
         assert res["type"] == "pending"
 
 
-async def test_unacked_edit_crash_invalidates_the_replacement_anchor():
+async def test_unapplied_edit_crash_invalidates_the_replacement_anchor():
     script = Script()
     script.thread["u1"] = {
         "parentId": None, "role": "user", "isLeaf": True, "onActiveBranch": True
@@ -146,12 +146,12 @@ async def test_unacked_edit_crash_invalidates_the_replacement_anchor():
         assert [m["id"] for m in call.ctx.messages] == ["q1"]
 
 
-async def test_unacked_recovery_run_keeps_acked_dispatch_anchors():
+async def test_unapplied_recovery_run_keeps_applied_dispatch_anchors():
     script = Script()
     async with run_host(script, capabilities=("incomplete-continuation",)) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        call.ack()
+        call.applied()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         await drv.command("run/continue", terminal=False)
@@ -167,7 +167,7 @@ async def test_anchor_on_the_queued_edit_form_is_validated_never_ignored():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
-        (await script.next_call()).ack()
+        (await script.next_call()).applied()
         await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
         assert_rejected(
             await drv.command(
@@ -197,7 +197,7 @@ async def test_post_reload_sends_anchor_on_the_reload_targets_parent():
         drv.post("run/reload", reload_params("a1", anchor="u1"))
         call = await script.next_call()
         assert call.ctx.trigger == "message-reload"
-        call.ack()
+        call.applied()
         script.thread["a1"] = {
             "parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": False
         }