harness-sdk-python 0.4.0__tar.gz → 0.4.2__tar.gz

{harness_sdk_python-0.4.0 → harness_sdk_python-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.4.0
+Version: 0.4.2
 Summary: RunManager: the harness-sdk runs subsystem for Python Statewire hosts
 Project-URL: Repository, https://github.com/assistant-ui/harness-sdk
 License-Expression: MIT

{harness_sdk_python-0.4.0 → harness_sdk_python-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "harness-sdk-python"
-version = "0.4.0"
+version = "0.4.2"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"

{harness_sdk_python-0.4.0 → harness_sdk_python-0.4.2}/src/harness_sdk/run_manager.py

@@ -6,8 +6,14 @@ Implements the full state x command matrix from runs.mdx on a single
 Commands stage entries into an intake list and schedule a drain; the drain
 reduces the whole intake into the lanes in order (pure placement), then takes
 exactly one action based on status and net effect (interrupt, dispatch, or
-continue). Late-settling commands (rewinds, stop) await a future the drain
+continue). A parked send settles at staging; run-starting commands settle at
+the executor's ``ctx.ack_messages()``; ``run/stop`` awaits a future the drain
 resolves once the in-flight run has ended.
+
+Dispatched entries leave the queue projection but are retained until the
+executor acks. A run that ends before the ack puts them back at the front of
+their lane and settles their sends accepted; edit, reload, and continue
+initiators settle rejected (``stopped`` or the failure).
 """
 
 import asyncio
@@ -90,7 +96,6 @@ class _Edit:
 @dataclass
 class _Reload:
     source_meta: dict[str, Any]
-    message_id: str
     ack: Callable[[], None]
     future: "asyncio.Future[Any]" = field(default_factory=_future)
 
@@ -102,7 +107,7 @@ class _Stop:
 
 @dataclass
 class _Continue:
-    pass
+    future: "asyncio.Future[Any]" = field(default_factory=_future)
 
 
 @dataclass
@@ -119,7 +124,6 @@ class _Rewind:
     rollback_to: Any
     ack: Callable[[], None]
     future: "asyncio.Future[Any]"
-    message_id: str | None = None
     acked: bool = False
 
 
@@ -128,6 +132,8 @@ class _Effects:
     steer_added: bool = False
     new_added: bool = False
     continue_requested: bool = False
+    staged_sends: list[tuple[str, "asyncio.Future[Any]"]] = field(default_factory=list)
+    continues: list["asyncio.Future[Any]"] = field(default_factory=list)
 
 
 class RunManager:
@@ -139,6 +145,7 @@ class RunManager:
         get_message_meta: GetMessageMeta,
         create_task: Callable[[Any], "asyncio.Task[Any]"],
         schedule: Callable[[Callable[[], None]], None],
+        leaf_message_id: str | None,
         capabilities: Iterable[str] = (),
         max_queued: int = 50,
     ) -> None:
@@ -150,6 +157,10 @@ class RunManager:
             raise ValueError("rewind-during-run requires the rewind capability")
         if max_queued < 1:
             raise ValueError("max_queued must be >= 1")
+        if leaf_message_id is not None and (
+            not isinstance(leaf_message_id, str) or leaf_message_id == ""
+        ):
+            raise ValueError("leaf_message_id must be a non-empty string or None")
         self._state = state
         self._start = start
         self._get_message_meta = get_message_meta
@@ -160,7 +171,6 @@ class RunManager:
         self._task: "asyncio.Task[Any] | None" = None
         self._ctx: "RunManager.StartContext | None" = None
         self._dispatched_ids: tuple[str, ...] = ()
-        self._reload_message_id: str | None = None
         self._dispatch_record: dict[str, Any] | None = None
         self._callers: dict[str, StatewireClientHandle] = {}
         self._intake: list[Any] = []
@@ -168,18 +178,22 @@ class RunManager:
         self._staged_stops: list["asyncio.Future[Any]"] = []
         self._stop_reason: str | None = None
         self._staged_rewinds: list[_Rewind] = []
-        self._entity_futures: dict[str, "asyncio.Future[Any]"] = {}
+        self._dispatching: list[tuple[str, dict[str, Any]]] = []
+        self._run_acked = True
+        self._leaf_confirmed = leaf_message_id
+        self._send_futures: list["asyncio.Future[Any]"] = []
         self._run_futures: list["asyncio.Future[Any]"] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
-        self._init_state()
+        self._init_state(leaf_message_id)
 
-    def _init_state(self) -> None:
+    def _init_state(self, leaf_message_id: str | None) -> None:
         # Runs state is write-only and not durable: overwrite whatever is there.
         self._state["status"] = "ready"
         self._state["error"] = None
         self._state["queue"] = []
         self._state["steerQueue"] = []
+        self._state["runLeafMessageId"] = leaf_message_id
         self._state.pop("dispatch", None)
         self._state.pop("inputRequests", None)
 
@@ -200,6 +214,9 @@ class RunManager:
     def _continue_type(self) -> str:
         return "error-continue" if self._status() == "error" else "stop-continue"
 
+    def _is_dispatching(self, message_id: str) -> bool:
+        return any(item["id"] == message_id for _, item in self._dispatching)
+
     # ─── Staging and drain ──────────────────────────────────
 
     async def _stage(self, entry: Any) -> Any:
@@ -221,15 +238,15 @@ class RunManager:
             self._staged_stops.clear()
             if isinstance(outcome, RunManager.Complete):
                 self._dispatched_ids = ()
-                self._reload_message_id = None
             if self._staged_rewinds:
                 rewind = self._staged_rewinds.pop(0)
                 self._dispatch(
                     rewind.type,
                     rewind.messages,
                     rollback_to=rewind.rollback_to,
-                    message_id=rewind.message_id,
                 )
+                for message in rewind.messages:
+                    self._callers.pop(message["id"], None)
                 rewind.ack()
                 if not rewind.future.done():
                     self._run_futures.append(rewind.future)
@@ -244,6 +261,15 @@ class RunManager:
                 if not rewind.acked:
                     rewind.ack()
                     rewind.acked = True
+        dispatching = {item["id"] for _, item in self._dispatching}
+        for message_id, future in fx.staged_sends:
+            if message_id in dispatching:
+                self._send_futures.append(future)
+            elif not future.done():
+                future.set_result(None)
+        for future in fx.continues:
+            if not future.done():
+                future.set_result(None)
 
     def _apply(self, entry: Any, fx: _Effects) -> None:
         if isinstance(entry, _Stop):
@@ -251,6 +277,7 @@ class RunManager:
             return
         if isinstance(entry, _Continue):
             fx.continue_requested = True
+            fx.continues.append(entry.future)
             return
         try:
             if isinstance(entry, _Send):
@@ -277,6 +304,8 @@ class RunManager:
         elif status in ("error", "stopped"):
             if fx.continue_requested or fx.steer_added:
                 self._dispatch(self._continue_type(), [])
+                self._run_futures.extend(fx.continues)
+                fx.continues.clear()
             elif fx.new_added and pre_empty:
                 self._pop_dispatchable()
         elif status == "input-required" and self._input_requests and len(
@@ -321,7 +350,6 @@ class RunManager:
         *,
         rollback_to: Any = _ABSENT,
         responses: Any = _ABSENT,
-        message_id: str | None = None,
     ) -> None:
         if type not in _ENTRY_TYPES:
             raise ValueError(f"invalid entry type: {type!r}")
@@ -331,22 +359,22 @@ class RunManager:
         messages = [
             {k: v for k, v in message.items() if k != "caller"} for message in messages
         ]
-        for message in messages:
-            self._callers.pop(message["id"], None)
-        self._adopt_entities(message["id"] for message in messages)
         record: dict[str, Any] = {"type": type, "messages": list(messages)}
         if rollback_to is not _ABSENT:
             record["rollbackTo"] = rollback_to
         if responses is not _ABSENT:
             record["responses"] = responses
-        if message_id is not None:
-            record["messageId"] = message_id
         self._dispatch_record = record
         self._stop_reason = None
+        self._run_acked = False
+        self._leaf_confirmed = plain(self._state["runLeafMessageId"])
         self._state["error"] = None
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
-        self._reload_message_id = message_id
+        if rollback_to is not _ABSENT:
+            self._state["runLeafMessageId"] = rollback_to
+        if messages:
+            self._state["runLeafMessageId"] = messages[-1]["id"]
         self._state["status"] = "running"
         ctx = RunManager.StartContext(
             type=type,
@@ -356,7 +384,6 @@ class RunManager:
             _manager=self,
             _rollback_to=rollback_to,
             _responses=responses,
-            _message_id=message_id,
         )
         self._ctx = ctx
         self._task = self._create_task(self._run(ctx))
@@ -377,23 +404,34 @@ class RunManager:
                     "start must return a RunManager outcome, got "
                     f"{type(outcome).__name__}"
                 )
+            if isinstance(
+                outcome, (RunManager.Complete, RunManager.InputRequired)
+            ) and (self._dispatching or not self._run_acked):
+                raise RuntimeError(
+                    "run settled without acking its messages"
+                    " (call ctx.ack_messages())"
+                )
         except Exception as exc:
             self._settle(ctx)
             message = str(exc) or type(exc).__name__
             if isinstance(exc, StatewireReject):
                 self._freeze(exc.message, exc.payload)
-                self._settle_entities(exc)
+                self._settle_initiators(exc)
             else:
                 self._freeze(message)
-                self._settle_entities(_reject("run-error", message))
+                self._settle_initiators(_reject("run-error", message))
+            self._revert_dispatching()
             self._drain()
             return
         self._settle(ctx)
-        self._settle_entities(
-            _reject("run-error", "run ended in error")
-            if isinstance(outcome, RunManager.Error)
-            else None
-        )
+        if isinstance(outcome, RunManager.Error):
+            error = _reject("run-error", "run ended in error")
+        elif isinstance(outcome, RunManager.Stop):
+            error = _reject("stopped", "run stopped before the messages-ack")
+        else:
+            error = None
+        self._settle_initiators(error)
+        self._revert_dispatching()
         self._outcome = outcome
         self._drain()
 
@@ -403,7 +441,7 @@ class RunManager:
             self._task = None
         self._dispatch_record = None
 
-    def _settle_entities(self, error: StatewireReject | None) -> None:
+    def _settle_initiators(self, error: StatewireReject | None) -> None:
         futures, self._run_futures = self._run_futures, []
         for future in futures:
             if future.done():
@@ -413,21 +451,48 @@ class RunManager:
             else:
                 future.set_exception(error)
 
-    def _adopt_entities(self, ids: Iterable[str]) -> None:
-        for id in ids:
-            future = self._entity_futures.pop(id, None)
-            if future is not None:
-                self._run_futures.append(future)
+    def _settle_sends(self) -> None:
+        futures, self._send_futures = self._send_futures, []
+        for future in futures:
+            if not future.done():
+                future.set_result(None)
+
+    def _ack_messages(self) -> None:
+        taken, self._dispatching = self._dispatching, []
+        self._run_acked = True
+        for _, item in taken:
+            self._callers.pop(item["id"], None)
+        self._leaf_confirmed = plain(self._state["runLeafMessageId"])
+        self._settle_sends()
+        self._settle_initiators(None)
+
+    def _revert_dispatching(self) -> None:
+        self._settle_sends()
+        taken, self._dispatching = self._dispatching, []
+        if not taken:
+            return
+        for lane in ("steerQueue", "queue"):
+            front = [item for l, item in taken if l == lane]
+            if front:
+                self._state[lane] = front + self._lane_items(lane)
+        ids = {item["id"] for _, item in taken}
+        self._dispatched_ids = tuple(
+            id for id in self._dispatched_ids if id not in ids
+        )
+        if plain(self._state["runLeafMessageId"]) in ids:
+            self._state["runLeafMessageId"] = self._leaf_confirmed
 
     def _pop_dispatchable(self) -> bool:
         steer = self._lane_items("steerQueue")
         if steer:
             self._state["steerQueue"] = []
+            self._dispatching = [("steerQueue", item) for item in steer]
             self._dispatch("message-send", steer)
             return True
         queue = self._lane_items("queue")
         if queue:
             self._state["queue"].pop(0)
+            self._dispatching = [("queue", queue[0])]
             self._dispatch("message-send", [queue[0]])
             return True
         return False
@@ -529,7 +594,7 @@ class RunManager:
             return
         if self._lane_of(e.anchor) is not None:
             return
-        if e.anchor in self._dispatched_ids or e.anchor == self._reload_message_id:
+        if e.anchor in self._dispatched_ids:
             return
         if e.anchor_meta is None:
             raise _reject("unknown-id", f"anchor {e.anchor} names nothing")
@@ -619,9 +684,9 @@ class RunManager:
             if e.lane == "steerQueue":
                 fx.steer_added = True
             return None
-        if e.message_id in self._dispatched_ids:
+        if e.message_id in self._dispatched_ids or self._is_dispatching(e.message_id):
             return self._park_dispatched_edit(e)
-        if e.meta is not None or e.message_id == self._reload_message_id:
+        if e.meta is not None:
             raise _reject(
                 "duplicate-id", f"message id {e.message_id} is already used"
             )
@@ -630,7 +695,7 @@ class RunManager:
         self._check_anchor(e)
         with self._caller_stamp(e.message_id, e.caller):
             self._insert_new(e.lane, e.message, e.params)
-        self._entity_futures[e.message_id] = e.future
+        fx.staged_sends.append((e.message_id, e.future))
         e.ack()
         fx.new_added = True
         if e.lane == "steerQueue":
@@ -640,7 +705,9 @@ class RunManager:
     def _apply_move(self, e: _Send, fx: _Effects) -> Any:
         current = self._lane_of(e.message_id)
         if current is None:
-            if e.message_id in self._dispatched_ids:
+            if e.message_id in self._dispatched_ids or self._is_dispatching(
+                e.message_id
+            ):
                 if e.lane == "steerQueue":
                     return None
                 raise _reject(
@@ -685,11 +752,6 @@ class RunManager:
         self._state[lane] = [
             item for item in self._lane_items(lane) if item["id"] != e.message_id
         ]
-        entity = self._entity_futures.pop(e.message_id, None)
-        if entity is not None and not entity.done():
-            entity.set_exception(
-                _reject("removed", f"message {e.message_id} was removed from the queue")
-            )
         return None
 
     def _apply_input(self, e: _Input) -> Any:
@@ -735,14 +797,6 @@ class RunManager:
 
     def _apply_reload(self, e: _Reload) -> Any:
         self._check_leaf_lanes(e.source_meta, "run/reload")
-        if (
-            self._lane_of(e.message_id) is not None
-            or e.message_id in self._dispatched_ids
-            or e.message_id == self._reload_message_id
-        ):
-            raise _reject(
-                "duplicate-id", f"message id {e.message_id} is already used"
-            )
         self._staged_rewinds.append(
             _Rewind(
                 "message-reload",
@@ -750,7 +804,6 @@ class RunManager:
                 e.source_meta["parentId"],
                 e.ack,
                 e.future,
-                message_id=e.message_id,
             )
         )
         return _PARKED
@@ -896,11 +949,6 @@ class RunManager:
         source_id = params.get("sourceId") if isinstance(params, dict) else None
         if not isinstance(source_id, str):
             raise _reject("invalid-message", "sourceId must be a string")
-        message_id = params.get("messageId")
-        if not isinstance(message_id, str) or message_id == "":
-            raise _reject("invalid-message", "messageId must be a non-empty string")
-        if await self._get_message_meta(message_id) is not None:
-            raise _reject("duplicate-id", f"message id {message_id} is already used")
         meta = await self._get_message_meta(source_id)
         if meta is None:
             raise _reject("unknown-id", f"message {source_id} is unknown")
@@ -918,7 +966,7 @@ class RunManager:
                     "capability-missing",
                     "the assistant-continuation capability is not enabled",
                 )
-        return await self._stage(_Reload(meta, message_id, ack))
+        return await self._stage(_Reload(meta, ack))
 
     async def stop(self, params: Any = None, *, ack: Callable[[], None]) -> Any:
         if params is not None and not isinstance(params, dict):
@@ -986,7 +1034,7 @@ class RunManager:
         response = self._validated_response(request["type"], params["response"])
         return await self._stage(_Input(request_id, response))
 
-    def continue_run(self) -> None:
+    async def continue_run(self, *, ack: Callable[[], None]) -> Any:
         status = self._status()
         if status not in ("error", "stopped"):
             raise _reject("wrong-state", f"run/continue is rejected in {status}")
@@ -997,8 +1045,11 @@ class RunManager:
                 "capability-missing",
                 "bare continue requires the incomplete-continuation capability",
             )
-        self._intake.append(_Continue())
+        entry = _Continue()
+        self._intake.append(entry)
+        ack()
         self._schedule(self._drain)
+        return await entry.future
 
     # ─── Outcomes and context ───────────────────────────────
 
@@ -1052,20 +1103,11 @@ class RunManager:
         _manager: "RunManager"
         _rollback_to: Any
         _responses: Any
-        _message_id: str | None
 
         @property
         def stop_reason(self) -> str | None:
             return self._manager._stop_reason
 
-        @property
-        def message_id(self) -> str:
-            if self._message_id is None:
-                raise AttributeError(
-                    "message_id is only present on message-reload entries"
-                )
-            return self._message_id
-
         @property
         def has_rollback(self) -> bool:
             return self._rollback_to is not _ABSENT
@@ -1098,13 +1140,27 @@ class RunManager:
             self._ensure_active()
             items = self._manager._lane_items("steerQueue")
             self._manager._state["steerQueue"] = []
-            for item in items:
-                self._manager._callers.pop(item["id"], None)
-            self._manager._adopt_entities(item["id"] for item in items)
+            self._manager._dispatching.extend(("steerQueue", item) for item in items)
+            if items:
+                self._manager._state["runLeafMessageId"] = items[-1]["id"]
             return tuple(
                 {k: v for k, v in item.items() if k != "caller"} for item in items
             )
 
+        def ack_messages(self) -> None:
+            self._ensure_active()
+            self._manager._ack_messages()
+
+        def set_leaf_message_id(self, message_id: str) -> None:
+            self._ensure_active()
+            if not isinstance(message_id, str) or message_id == "":
+                raise ValueError("message_id must be a non-empty string")
+            if self._manager._dispatching or not self._manager._run_acked:
+                raise RuntimeError(
+                    "ack_messages must precede set_leaf_message_id"
+                )
+            self._manager._state["runLeafMessageId"] = message_id
+
         def set_recovery_state(self, value: Any) -> None:
             self._ensure_active()
             record = self._manager._dispatch_record

{harness_sdk_python-0.4.0 → harness_sdk_python-0.4.2}/tests/run_helpers.py

@@ -15,6 +15,9 @@ class Call:
     ctx: RunManager.StartContext
     outcome: "asyncio.Future[Any]"
 
+    def ack(self) -> None:
+        self.ctx.ack_messages()
+
     def finish(self, outcome: Any) -> None:
         self.outcome.set_result(outcome)
 
@@ -40,6 +43,16 @@ class Script:
             return {"isLeaf": not self.thread}
         return self.thread.get(message_id)
 
+    def leaf_id(self) -> str | None:
+        return next(
+            (
+                id
+                for id, meta in self.thread.items()
+                if meta.get("isLeaf") and meta.get("onActiveBranch", True)
+            ),
+            None,
+        )
+
     async def next_call(self, timeout: float = 5) -> Call:
         return await asyncio.wait_for(self.calls.get(), timeout)
 
@@ -62,6 +75,7 @@ def make_host(script: Script, capabilities=(), initial_runs=None, max_queued=50)
                 get_message_meta=script.get_message_meta,
                 create_task=self.create_task,
                 schedule=self.schedule,
+                leaf_message_id=script.leaf_id(),
                 capabilities=capabilities,
                 max_queued=max_queued,
             )
@@ -92,8 +106,8 @@ def make_host(script: Script, capabilities=(), initial_runs=None, max_queued=50)
             return await self.runs.stop(params, ack=ctx.ack)
 
         @command("run/continue")
-        async def run_continue(self):
-            self.runs.continue_run()
+        async def run_continue(self, *, ctx):
+            return await self.runs.continue_run(ack=ctx.ack)
 
         @command("run/input")
         async def run_input(self, params):

{harness_sdk_python-0.4.0 → harness_sdk_python-0.4.2}/tests/test_batches.py

@@ -27,6 +27,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.finish(RunManager.Complete())
         for offset in range(3):
             assert (await drv.res(first + offset))["type"] == "accepted"
@@ -40,7 +41,7 @@ async def test_steer_and_stop_in_one_batch_nets_to_stop():
         first = await drv.batch(
             [("run/steer", add("s1")), ("run/stop", None)]
         )
-        assert (await drv.res(first, terminal=False))["type"] == "pending"
+        assert (await drv.res(first))["type"] == "accepted"
         assert (await drv.res(first + 1, terminal=False))["type"] == "pending"
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
         call.finish(RunManager.Stop(dispatch_queue=False))

{harness_sdk_python-0.4.0 → harness_sdk_python-0.4.2}/tests/test_branch_anchor.py

@@ -115,7 +115,7 @@ async def test_anchor_on_the_queued_edit_form_is_validated_never_ignored():
         assert drv.replica["queue"][0]["parts"][0]["text"] == "edited"
 
 
-async def test_reload_requires_a_message_id_and_delivers_it_on_the_start_context():
+async def test_post_reload_sends_anchor_on_the_reload_targets_parent():
     script = Script()
     script.thread.update(
         {
@@ -124,22 +124,14 @@ async def test_reload_requires_a_message_id_and_delivers_it_on_the_start_context
         }
     )
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a1"}, terminal=False),
-            "invalid-message",
-        )
-        assert_rejected(
-            await drv.command(
-                "run/reload", {"sourceId": "a1", "messageId": "u1"}, terminal=False
-            ),
-            "duplicate-id",
-        )
-        res = await drv.command(
-            "run/reload", {"sourceId": "a1", "messageId": "r9"}, terminal=False
-        )
+        res = await drv.command("run/reload", {"sourceId": "a1"}, terminal=False)
         assert res["type"] == "pending"
         call = await script.next_call()
         assert call.ctx.type == "message-reload"
-        assert call.ctx.message_id == "r9"
+        script.thread["a1"] = {
+            "parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": False
+        }
+        res = await drv.command("run/enqueue", add("m1", anchor="u1"), terminal=False)
+        assert res["type"] == "pending"
         call.finish(RunManager.Complete())
-        await drv.wait_status("ready")
+        await drv.wait_status("running")

{harness_sdk_python-0.4.0 → harness_sdk_python-0.4.2}/tests/test_caller.py

@@ -13,6 +13,7 @@ async def test_immediate_dispatch_carries_caller():
         call = await script.next_call()
         assert call.ctx.caller is not None
         assert call.ctx.caller.client_id == "c1"
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -24,6 +25,7 @@ async def test_queue_entry_projects_caller_client_id():
         await drv.command("run/enqueue", add("m2"), terminal=False)
         await drv.wait(lambda s: len(s["queue"]) == 1)
         assert drv.replica["queue"][0]["caller"] == {"clientId": "c1"}
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -34,12 +36,14 @@ async def test_caller_context_is_read_at_dispatch_time():
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
         assert (await drv.context({"user": "simon"}))["type"] == "accepted"
+        call.ack()
         call.finish(RunManager.Complete())
         dispatched = await script.next_call()
         assert dispatched.ctx.caller is not None
         assert dispatched.ctx.caller.context == {"user": "simon"}
         assert dispatched.ctx.messages[0]["id"] == "m2"
         assert "caller" not in dispatched.ctx.messages[0]
+        dispatched.ack()
         dispatched.finish(RunManager.Complete())
 
 
@@ -47,11 +51,12 @@ async def test_dispatch_without_queue_entry_has_no_caller():
     script = Script()
     async with run_host(script, capabilities=("rewind",)) as (drv, _):
         script.thread["a1"] = {"role": "assistant", "parentId": None, "isLeaf": True}
-        assert (await drv.command("run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False))[
+        assert (await drv.command("run/reload", {"sourceId": "a1"}, terminal=False))[
             "type"
         ] == "pending"
         call = await script.next_call()
         assert call.ctx.caller is None
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -65,6 +70,7 @@ async def test_take_steered_strips_the_caller_stamp():
         assert drv.replica["steerQueue"][0]["caller"] == {"clientId": "c1"}
         [taken] = call.ctx.take_steered()
         assert "caller" not in taken
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -85,6 +91,7 @@ async def test_max_queued_caps_each_lane():
         ] == "pending"
         steer_full = await drv.command("run/steer", add("s2"), terminal=False)
         assert steer_full["payload"] == {"reason": "queue-full"}
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -97,6 +104,7 @@ async def test_lane_change_into_a_full_lane_rejects():
         await drv.command("run/steer", add("s1"), terminal=False)
         moved = await drv.command("run/steer", {"messageId": "m2"}, terminal=False)
         assert moved["payload"] == {"reason": "queue-full"}
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -109,5 +117,6 @@ async def test_max_queued_below_one_rejects_at_construction():
             get_message_meta=script.get_message_meta,
             create_task=lambda coro: None,
             schedule=lambda fn: None,
+            leaf_message_id=None,
             max_queued=0,
         )