harness-sdk-python 0.7.3__tar.gz → 0.9.0__tar.gz

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.7.3
+Version: 0.9.0
 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.7.3 → harness_sdk_python-0.9.0}/pyproject.toml

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

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/src/harness_sdk/linear_thread.py

@@ -21,10 +21,6 @@ class LinearThread:
                 }
         return None
 
-    async def get_leaf_message_id(self) -> str | None:
-        items = self._messages()
-        return items[-1].get("id") if items else None
-
     async def get_message_child_id(self, parent_id: str) -> str | None:
         """The id of the first non-tool message after parent_id; None when parent_id is unknown or only tools follow."""
         items = self._messages()

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/src/harness_sdk/run_manager.py

@@ -14,10 +14,12 @@ and settle when their run ends — accepted once the run has acked its
 messages, rejected otherwise; ``run/stop`` awaits a future the drain resolves
 once the in-flight run has ended.
 
-``ctx.ack_messages()`` is bookkeeping: it clears ``dispatching`` and confirms
-``runLeafMessageId``. A run that ends with entries still in ``dispatching``
-reverts them by provenance: lane items to the front of their lane, direct
-dispatches to the front of the queue, rewind replacements dropped.
+``entry["dispatching"]`` is the dispatch record (or None): the payload the
+run callback receives. ``ctx.ack()`` clears it; ``steering.take()`` may
+refill it — at most one unacked batch ever exists. A run that ends with an
+unacked record reverts its items
+by provenance: lane items to the front of their lane, direct dispatches to
+the front of the queue, rewind replacements dropped.
 """
 
 import asyncio
@@ -51,6 +53,7 @@ _TRIGGERS = (
     "input-resume",
     "error-continue",
     "stop-continue",
+    "steer",
 )
 
 _DECISIONS = ("approve", "reject", "edit", "respond")
@@ -152,10 +155,6 @@ class RunManager:
             """Meta for a known id ({parentId, role, isLeaf, onActiveBranch}), None for an unknown one; a None id probes the root ({isLeaf})."""
             ...
 
-        async def get_leaf_message_id(self) -> str | None:
-            """The active branch's current leaf id, None while the thread is empty."""
-            ...
-
     def __init__(
         self,
         *,
@@ -197,7 +196,6 @@ class RunManager:
         self._staged_rewinds: list[_Rewind] = []
         self._dispatching: list[tuple[str, dict[str, Any]]] = []
         self._run_acked = False
-        self._leaf_confirmed: str | None = None
         self._run_futures: list["asyncio.Future[Any]"] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
@@ -219,7 +217,6 @@ class RunManager:
             "queue",
             "steerQueue",
             "runId",
-            "runLeafMessageId",
             "dispatch",
             "inputRequests",
         ):
@@ -242,9 +239,8 @@ class RunManager:
                     "status": "ready",
                     "queue": [],
                     "steerQueue": [],
-                    "dispatching": [],
+                    "dispatching": None,
                     "error": None,
-                    "runLeafMessageId": None,
                 }
             )
         return self._state["runs"][0]
@@ -435,28 +431,26 @@ class RunManager:
         if self._task is not None:
             raise RuntimeError("a run is already in flight")
         message_meta = {m["id"]: m.get("meta") for m in messages}
-        dispatching = list(messages)
+        items = list(messages)
         messages = [
             {k: v for k, v in message.items() if k != "meta"} for message in messages
         ]
-        record: dict[str, Any] = {"trigger": trigger, "messages": list(messages)}
+        record: dict[str, Any] = {"trigger": trigger, "messages": items}
         if rollback_to is not _ABSENT:
             record["rollbackTo"] = rollback_to
         if input_outcomes:
-            record["inputOutcomes"] = input_outcomes
-        self._dispatch_record = record
+            record["inputOutcomes"] = [
+                {"request": request, "response": response, "meta": meta}
+                for request, response, meta in input_outcomes
+            ]
+        self._dispatch_record = dict(record)
         self._stop_reason = None
         self._run_acked = False
         entry = self._ensure_entry()
-        self._leaf_confirmed = plain(entry["runLeafMessageId"])
-        entry["dispatching"] = dispatching
+        entry["dispatching"] = record
         entry["error"] = None
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
-        if rollback_to is not _ABSENT:
-            entry["runLeafMessageId"] = rollback_to
-        if messages:
-            entry["runLeafMessageId"] = messages[-1]["id"]
         entry["runId"] = uuid.uuid4().hex
         self._set_status("running")
         ctx = RunManager.RunContext(
@@ -491,7 +485,6 @@ class RunManager:
                     f"{type(outcome).__name__}"
                 )
         except asyncio.CancelledError:
-            await self._pull_leaf()
             self._settle(ctx)
             self._set_status("stopped")
             self._entry()["runId"] = None
@@ -502,7 +495,6 @@ class RunManager:
             self._idle.set()
             raise  # no drain, no freeze
         except Exception as exc:
-            await self._pull_leaf()
             self._settle(ctx)
             message = str(exc) or type(exc).__name__
             if isinstance(exc, StatewireReject):
@@ -516,14 +508,13 @@ class RunManager:
             self._revert_dispatching()
             self._drain()
             return
-        await self._pull_leaf()
         self._settle(ctx)
         if self._run_acked:
             error = None
         elif 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")
+            error = _reject("stopped", "run stopped before the ack")
         else:
             error = None
         self._settle_initiators(error)
@@ -531,12 +522,6 @@ class RunManager:
         self._outcome = outcome
         self._drain()
 
-    async def _pull_leaf(self) -> None:
-        # An end with unacked messages reverts instead of recording a leaf.
-        if plain(self._entry()["dispatching"]):
-            return
-        self._entry()["runLeafMessageId"] = await self._thread.get_leaf_message_id()
-
     def _settle(self, ctx: "RunManager.RunContext") -> None:
         if self._ctx is ctx:
             self._ctx = None
@@ -553,16 +538,19 @@ class RunManager:
             else:
                 future.set_exception(error)
 
-    def _ack_messages(self) -> None:
+    def _ack(self) -> None:
+        entry = self._entry()
+        record = plain(entry["dispatching"])
+        if record is None:
+            raise RuntimeError("ack() with no unacked batch")
         self._dispatching = []
-        self._entry()["dispatching"] = []
+        entry["dispatching"] = None
         self._run_acked = True
-        self._leaf_confirmed = plain(self._entry()["runLeafMessageId"])
 
     def _revert_dispatching(self) -> None:
         taken, self._dispatching = self._dispatching, []
         entry = self._ensure_entry()
-        entry["dispatching"] = []
+        entry["dispatching"] = None
         if not taken:
             return
         for lane in ("steerQueue", "queue"):
@@ -571,8 +559,6 @@ class RunManager:
                 entry[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(entry["runLeafMessageId"]) in ids:
-            entry["runLeafMessageId"] = self._leaf_confirmed
 
     def _dispatchable(self, lane: str) -> bool:
         if self._task is not None or self._staged_rewinds:
@@ -601,7 +587,10 @@ class RunManager:
             self._entry()["steerQueue"] = []
             self._dispatching.extend(("steerQueue", item) for item in steer)
         self._dispatching.append((e.lane, self._stamped(e.message, e.meta)))
-        self._ensure_entry()["dispatching"] = [item for _, item in self._dispatching]
+        self._ensure_entry()["dispatching"] = {
+            "trigger": "message-send",
+            "messages": [item for _, item in self._dispatching],
+        }
 
     def _dispatch_staged(
         self, *, input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = ()
@@ -1233,16 +1222,18 @@ class RunManager:
         _ctx: "RunManager.RunContext"
 
         def take(self) -> tuple[dict[str, Any], ...]:
-            """Drain the steer lane into this run; items leave the projection, retained until the ack."""
+            """Drain the steer lane into a fresh dispatch record; requires the current batch to be acked."""
             self._ctx._ensure_active()
             manager = self._ctx._manager
-            items = manager._lane_items("steerQueue")
             entry = manager._entry()
+            if plain(entry["dispatching"]) is not None:
+                raise RuntimeError("take before the current batch is acked")
+            items = manager._lane_items("steerQueue")
+            if not items:
+                return ()
             entry["steerQueue"] = []
             manager._dispatching.extend(("steerQueue", item) for item in items)
-            entry["dispatching"] = list(plain(entry["dispatching"])) + items
-            if items:
-                entry["runLeafMessageId"] = items[-1]["id"]
+            entry["dispatching"] = {"trigger": "steer", "messages": items}
             self._ctx._message_meta.update(
                 {item["id"]: item.get("meta") for item in items}
             )
@@ -1301,9 +1292,10 @@ class RunManager:
             if self._manager._ctx is not self:
                 raise RuntimeError("this run has already settled")
 
-        def ack_messages(self) -> None:
+        def ack(self) -> None:
+            """Ack the current batch: clears the dispatch record."""
             self._ensure_active()
-            self._manager._ack_messages()
+            self._manager._ack()
 
         def set_recovery_state(self, value: Any) -> None:
             self._ensure_active()

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/tests/run_helpers.py

@@ -16,7 +16,7 @@ class Call:
     outcome: "asyncio.Future[Any]"
 
     def ack(self) -> None:
-        self.ctx.ack_messages()
+        self.ctx.ack()
 
     def finish(self, outcome: Any) -> None:
         self.outcome.set_result(outcome)
@@ -32,7 +32,6 @@ class Script:
     def __init__(self) -> None:
         self.calls: asyncio.Queue[Call] = asyncio.Queue()
         self.thread: dict[str, dict[str, Any]] = {}
-        self.leaf: str | None = None
 
     async def run(self, ctx: RunManager.RunContext) -> Any:
         call = Call(ctx, asyncio.get_running_loop().create_future())
@@ -44,9 +43,6 @@ class Script:
             return {"isLeaf": not self.thread}
         return self.thread.get(message_id)
 
-    async def get_leaf_message_id(self) -> str | None:
-        return self.leaf
-
     async def next_call(self, timeout: float = 5) -> Call:
         return await asyncio.wait_for(self.calls.get(), timeout)
 

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/tests/test_ack_visibility.py

@@ -24,7 +24,8 @@ def covered_state(drv, seq):
 
 def dispatching_ids(state):
     runs = state.get("runs") or [{}]
-    return [item["id"] for item in runs[0].get("dispatching", [])]
+    record = runs[0].get("dispatching")
+    return [item["id"] for item in record["messages"]] if record else []
 
 
 def assert_never_queued(drv, message_id):

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/tests/test_dispatching.py

@@ -1,13 +1,14 @@
-"""Contract: replicated dispatch limbo. ``dispatching`` on the run entry is
-the current dispatch's unacked messages — queue pops, steer-lane takes, and
-rewind dispatches alike. A message item lives in exactly one of the lanes,
-``dispatching``, or the thread, and every transition is single-envelope
-atomic: dispatch moves it lane → ``dispatching``, the messages-ack clears
-``dispatching`` as the canonical message appears, and an unacked run end
-returns lane items to the front of their lane."""
+"""Contract: the replicated dispatch record. ``dispatching`` on the run entry
+is the current unacked batch — a record ``{trigger, messages, rollbackTo?,
+inputOutcomes?}`` or None. A message item lives in exactly one of the lanes,
+the record's ``messages``, or the thread, and every transition is
+single-envelope atomic: dispatch fills the record, ``ctx.ack()`` clears it as
+the canonical message appears, a steer take refills it, and an unacked run
+end returns lane items to the front of their lane."""
 
 import copy
 
+import pytest
 from run_helpers import Script, add, msg, queue_ids, run_host
 
 from harness_sdk import RunManager
@@ -16,16 +17,20 @@ from statewire_helpers import apply_ops
 
 def dispatching_ids(replica):
     runs = replica["runs"]
-    return [item["id"] for item in runs[0]["dispatching"]] if runs else []
+    record = runs[0]["dispatching"] if runs else None
+    return [item["id"] for item in record["messages"]] if record else []
 
 
 def places(state, message_id):
     entry = (state.get("runs") or [{}])[0]
     found = {
         name
-        for name in ("queue", "steerQueue", "dispatching")
+        for name in ("queue", "steerQueue")
         if any(item["id"] == message_id for item in entry.get(name, []))
     }
+    record = entry.get("dispatching")
+    if record and any(item["id"] == message_id for item in record["messages"]):
+        found.add("dispatching")
     if any(m["id"] == message_id for m in state.get("messages", [])):
         found.add("messages")
     return found
@@ -53,6 +58,7 @@ async def test_idle_send_dispatches_straight_into_dispatching():
         drv.post("run/enqueue", add("m1"))
         await script.next_call()
         await drv.wait_status("running")
+        assert drv.run["dispatching"]["trigger"] == "message-send"
         assert dispatching_ids(drv.replica) == ["m1"]
         assert queue_ids(drv.replica, "queue") == []
         assert residence(drv, "m1") == ["dispatching"]
@@ -97,6 +103,7 @@ async def test_steering_take_moves_the_lane_into_dispatching():
         await drv.command("run/steer", add("s1"), terminal=False)
         call.ctx.steering.take()
         await drv.wait(lambda s: dispatching_ids(s) == ["s1"])
+        assert drv.run["dispatching"]["trigger"] == "steer"
         assert queue_ids(drv.replica, "steerQueue") == []
         assert residence(drv, "s1") == ["steerQueue", "dispatching"]
         host.live.state["messages"] = [msg("m1"), msg("s1")]
@@ -121,3 +128,46 @@ async def test_edit_replacement_rides_dispatching_until_ack():
         assert residence(drv, "u2") == ["dispatching", "messages"]
         rerun.finish(RunManager.Complete())
         assert (await drv.res(seq))["type"] == "accepted"
+
+
+async def test_take_before_the_ack_raises():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        await drv.side("run/steer", add("s1"))
+        await drv.wait(lambda s: queue_ids(s, "steerQueue") == ["s1"])
+        with pytest.raises(RuntimeError, match="before the current batch is acked"):
+            call.ctx.steering.take()
+        call.ack()
+        assert [m["id"] for m in call.ctx.steering.take()] == ["s1"]
+        call.ack()
+        call.finish(RunManager.Complete())
+
+
+async def test_ack_with_no_unacked_batch_raises():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.ack()
+        with pytest.raises(RuntimeError, match="no unacked batch"):
+            call.ack()
+        call.finish(RunManager.Complete())
+
+
+async def test_second_take_after_the_reack_drains_the_next_batch():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.ack()
+        await drv.command("run/steer", add("s1"), terminal=False)
+        assert [m["id"] for m in call.ctx.steering.take()] == ["s1"]
+        call.ack()
+        await drv.command("run/steer", add("s2", anchor="m1"), terminal=False)
+        assert [m["id"] for m in call.ctx.steering.take()] == ["s2"]
+        await drv.wait(lambda s: dispatching_ids(s) == ["s2"])
+        assert drv.run["dispatching"]["trigger"] == "steer"
+        call.ack()
+        call.finish(RunManager.Complete())

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/tests/test_input_required.py

@@ -79,6 +79,36 @@ async def test_completing_answer_resumes_with_ordered_responses():
         await drv.wait_status("ready")
 
 
+async def test_input_outcomes_ride_the_dispatch_record_until_the_ack():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await park(drv, script, [tool_call("r1"), approval("r2")])
+        await drv.command(
+            "run/input", {"requestId": "r2", "response": {"decision": "approve"}}
+        )
+        await drv.command(
+            "run/input", {"requestId": "r1", "response": {"output": "ok"}}
+        )
+        resumed = await script.next_call()
+        await drv.wait(lambda s: run_of(s).get("dispatching") is not None)
+        assert drv.run["dispatching"] == {
+            "trigger": "input-resume",
+            "messages": [],
+            "inputOutcomes": [
+                {"request": tool_call("r1"), "response": {"output": "ok"}, "meta": None},
+                {
+                    "request": approval("r2"),
+                    "response": {"decision": "approve"},
+                    "meta": None,
+                },
+            ],
+        }
+        resumed.ack()
+        await drv.wait(lambda s: run_of(s).get("dispatching") is None)
+        resumed.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
 async def test_completing_batch_resumes_once_in_the_same_envelope():
     script = Script()
     async with run_host(script) as (drv, host):

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/tests/test_linear_thread.py

@@ -1,8 +1,8 @@
 """Contract: ``linear_thread`` projects a linear message list for RunManager —
 ``get_message_meta(None)`` probes the root (isLeaf iff empty), a known id gets
 ``{parentId, role, isLeaf, onActiveBranch}`` chained by list order, an unknown
-id gets ``None``; ``get_leaf_message_id`` is the last message's id; the extra
-``get_message_child_id`` resolves the first non-tool successor."""
+id gets ``None``; the extra ``get_message_child_id`` resolves the first
+non-tool successor."""
 
 import pytest
 
@@ -69,14 +69,6 @@ async def test_unknown_id_returns_none():
     assert await thread.get_message_meta("nope") is None
 
 
-async def test_leaf_is_the_last_message_id():
-    assert await _thread_for(THREAD).get_leaf_message_id() == "u2"
-
-
-async def test_leaf_of_an_empty_thread_is_none():
-    assert await _thread_for([]).get_leaf_message_id() is None
-
-
 async def test_child_id_skips_tool_messages():
     thread = _thread_for(
         [
@@ -109,7 +101,6 @@ async def test_reads_the_live_list():
     assert await thread.get_message_meta(None) == {"isLeaf": True}
     messages.append({"id": "u1", "type": "human"})
     assert await thread.get_message_meta(None) == {"isLeaf": False}
-    assert await thread.get_leaf_message_id() == "u1"
 
 
 def test_non_callable_messages_raises():

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/tests/test_meta.py

@@ -131,10 +131,14 @@ async def test_meta_dies_with_a_dequeued_entry():
 async def test_unacked_run_end_reprojects_entries_with_meta():
     script = Script()
     async with run_host(script) as (drv, _):
-        drv.post("run/enqueue", add("m1", meta={"clientId": "c1"}))
+        drv.batch(
+            [
+                ("run/enqueue", add("m1", meta={"clientId": "c1"})),
+                ("run/steer", add("s1", meta={"clientId": "c2"})),
+            ]
+        )
         call = await script.next_call()
-        await drv.side("run/steer", add("s1", meta={"clientId": "c2"}))
-        call.ctx.steering.take()
+        assert [m["id"] for m in call.ctx.messages] == ["m1", "s1"]
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         assert drv.run["queue"][0]["meta"] == {"clientId": "c1"}

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/tests/test_settle.py

@@ -101,10 +101,10 @@ async def test_unacked_run_end_reverts_entries_to_the_lane_front():
         await drv.wait_status("error")
         assert queue_ids(drv.replica, "queue") == ["m1", "m2"]
         assert drv.run["error"] == {"message": "boom"}
-        assert drv.run["runLeafMessageId"] is None
         await drv.command("run/steer", {"messageId": "m1"}, terminal=False)
         continued = await script.next_call()
         assert continued.ctx.trigger == "error-continue"
+        continued.ack()
         assert [m["id"] for m in continued.ctx.steering.take()] == ["m1"]
 
 
@@ -113,12 +113,14 @@ async def test_unacked_run_end_reverts_taken_steered_items():
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
+        call.ack()
         await drv.side("run/steer", add("s1"))
+        await drv.wait(lambda s: queue_ids(s, "steerQueue") == ["s1"])
         call.ctx.steering.take()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         assert queue_ids(drv.replica, "steerQueue") == ["s1"]
-        assert queue_ids(drv.replica, "queue") == ["m1"]
+        assert queue_ids(drv.replica, "queue") == []
 
 
 async def test_ack_removes_the_entries_for_good():
@@ -208,7 +210,6 @@ async def test_task_cancellation_reverts_entries_and_settles_sends():
         assert (await drv.res(seq))["type"] == "accepted"
         await drv.wait_status("stopped")
         assert queue_ids(drv.replica, "queue") == ["m1", "m2"]
-        assert drv.run["runLeafMessageId"] is None
         assert task.cancelled()
 
 

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/tests/test_steer.py

@@ -55,6 +55,7 @@ async def test_steer_add_continues_in_error_and_stop(end, continue_type):
         assert continued.ctx.messages == ()
         assert queue_ids(drv.replica, "steerQueue") == ["s1"]
         assert continued.ctx.steering.available.is_set()
+        continued.ack()
         assert [m["id"] for m in continued.ctx.steering.take()] == ["s1"]
 
 
@@ -86,6 +87,7 @@ async def test_steer_edit_continues_in_error_with_replacement():
         await drv.command("run/steer", {"message": msg("m2", "edited")}, terminal=False)
         continued = await script.next_call()
         assert continued.ctx.trigger == "error-continue"
+        continued.ack()
         taken = continued.ctx.steering.take()
         assert [m["parts"][0]["text"] for m in taken] == ["edited"]
 

{harness_sdk_python-0.7.3 → harness_sdk_python-0.9.0}/tests/test_stop_continue.py

@@ -234,6 +234,7 @@ async def test_continue_with_steer_lane_needs_no_capability():
         assert res["type"] == "pending"
         continued = await script.next_call()
         assert continued.ctx.trigger == "error-continue"
+        continued.ack()
         assert [m["id"] for m in continued.ctx.steering.take()] == ["s1"]
         continued.ack()
         continued.finish(RunManager.Complete())

harness_sdk_python-0.7.3/tests/test_run_leaf.py

@@ -1,162 +0,0 @@
-from run_helpers import Script, add, msg, run_host, run_of
-
-from harness_sdk import RunManager
-
-
-def thread_with_turn(script: Script) -> None:
-    script.thread.update(
-        {
-            "u1": {
-                "parentId": None,
-                "role": "user",
-                "isLeaf": False,
-                "onActiveBranch": True,
-            },
-            "a1": {
-                "parentId": "u1",
-                "role": "assistant",
-                "isLeaf": True,
-                "onActiveBranch": True,
-            },
-        }
-    )
-
-
-async def test_ready_state_has_no_run_entry():
-    script = Script()
-    thread_with_turn(script)
-    async with run_host(script) as (drv, host):
-        assert drv.replica["status"] == "ready"
-        assert drv.replica["runs"] == []
-
-
-async def test_enqueue_dispatch_sets_the_leaf():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        await script.next_call()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "m1")
-
-
-async def test_steer_dispatch_sets_the_leaf_to_the_last_lane_item():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.ack()
-        await drv.command("run/steer", add("s1", anchor="m1"), terminal=False)
-        await drv.command("run/steer", add("s2", anchor="s1"), terminal=False)
-        call.finish(RunManager.Complete())
-        steered = await script.next_call()
-        assert steered.ctx.messages[-1]["id"] == "s2"
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "s2")
-
-
-async def test_steering_take_sets_the_leaf():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.ack()
-        await drv.command("run/steer", add("s1", anchor="m1"), terminal=False)
-        await drv.wait(lambda s: len(run_of(s).get("steerQueue", [])) == 1)
-        call.ctx.steering.take()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "s1")
-        call.ack()
-        call.finish(RunManager.Complete())
-
-
-async def test_settle_pulls_the_thread_leaf():
-    for outcome in [
-        RunManager.Error(dispatch_queue=False),
-        RunManager.Stop(dispatch_queue=False),
-    ]:
-        script = Script()
-        async with run_host(script) as (drv, host):
-            drv.post("run/enqueue", add("m1"))
-            call = await script.next_call()
-            call.ack()
-            script.leaf = "a1"
-            call.finish(outcome)
-            await drv.wait_status("error", "stopped")
-            assert drv.run["runLeafMessageId"] == "a1"
-
-
-async def test_input_required_settle_pulls_the_thread_leaf():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.ack()
-        script.leaf = "a1"
-        call.finish(
-            RunManager.InputRequired(
-                requests=({"id": "r1", "type": "tool-call", "toolCallId": "t1"},)
-            )
-        )
-        await drv.wait_status("input-required")
-        assert drv.run["runLeafMessageId"] == "a1"
-
-
-async def test_unacked_end_reverts_instead_of_pulling():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        script.leaf = "a1"
-        call.fail(RuntimeError("boom"))
-        await drv.wait_status("error")
-        assert drv.run["runLeafMessageId"] is None
-        assert [item["id"] for item in drv.run["queue"]] == ["m1"]
-
-
-async def test_complete_clears_the_leaf_on_ready():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.ack()
-        script.leaf = "a1"
-        await drv.wait_status("running")
-        call.finish(RunManager.Complete())
-        await drv.wait_status("ready")
-        assert drv.replica["runs"] == []
-
-
-async def test_complete_with_a_queued_item_keeps_the_leaf_flowing():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.ack()
-        await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
-        script.leaf = "a1"
-        call.finish(RunManager.Complete())
-        drain = await script.next_call()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "m2")
-        drain.ack()
-        drain.finish(RunManager.Complete())
-        await drv.wait_status("ready")
-        assert drv.replica["runs"] == []
-
-
-async def test_edit_dispatch_sets_the_leaf_to_the_replacement():
-    script = Script()
-    thread_with_turn(script)
-    async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        drv.post("run/edit", {"sourceId": "u1", "message": msg("u2")})
-        await script.next_call()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "u2")
-
-
-async def test_reload_dispatch_sets_the_leaf_to_the_rollback_target():
-    script = Script()
-    thread_with_turn(script)
-    async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        drv.post("run/reload", {"sourceId": "a1"})
-        call = await script.next_call()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "u1")
-        call.ack()
-        script.leaf = "a2"
-        call.finish(RunManager.Stop(dispatch_queue=False))
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "a2")