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

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/PKG-INFO

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

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

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/src/harness_sdk/run_manager.py

@@ -10,10 +10,10 @@ 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 acks 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
 the next dispatch or take): the payload the run callback receives.
@@ -25,8 +25,8 @@ 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
@@ -53,9 +53,9 @@ _CAPABILITIES = frozenset(
 )
 
 _TRIGGERS = (
-    "send-message",
-    "edit-message",
-    "reload-message",
+    "message-send",
+    "message-edit",
+    "message-reload",
     "input-resume",
     "error-continue",
     "stop-continue",
@@ -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:
@@ -378,14 +375,12 @@ class RunManager:
                 )
                 if not rewind.acked:
                     rewind.ack()
-                if not rewind.future.done():
-                    rewind.future.set_result(None)
             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()
@@ -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:
@@ -641,7 +638,7 @@ class RunManager:
 
     def _send_trigger(self) -> str:
         status = self._status()
-        return self._continue_type() if status in ("error", "stopped") else "send-message"
+        return self._continue_type() if status in ("error", "stopped") else "message-send"
 
     def _stage_dispatch(self, e: _Send) -> None:
         assert e.message is not None
@@ -673,27 +670,17 @@ class RunManager:
         if steer:
             self._entry()["steerQueue"] = []
             self._dispatching = [("steerQueue", item) for item in steer]
-            self._dispatch("send-message", steer, input_outcomes=input_outcomes)
+            self._dispatch("message-send", steer, input_outcomes=input_outcomes)
             return True
         queue = self._lane_items("queue")
         if queue:
             self._entry()["queue"].pop(0)
             self._dispatching = [("queue", queue[0])]
-            self._dispatch("send-message", [queue[0]], input_outcomes=input_outcomes)
+            self._dispatch("message-send", [queue[0]], input_outcomes=input_outcomes)
             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()
@@ -706,6 +693,8 @@ class RunManager:
             )
             rewind.ack()
             rewind.acked = True
+        if not rewind.future.done():
+            rewind.future.set_result(None)
 
     def _freeze(self, message: str, payload: Any = None) -> None:
         self._set_status("error")
@@ -989,7 +978,7 @@ class RunManager:
         self._check_anchor(e)
         self._stage_rewind(
             _Rewind(
-                "edit-message",
+                "message-edit",
                 [self._stamped(e.message, e.meta)],
                 e.source_meta["parentId"],
                 e.ack,
@@ -1044,7 +1033,7 @@ class RunManager:
             )
         self._stage_rewind(
             _Rewind(
-                "edit-message",
+                "message-edit",
                 [self._stamped(e.message, e.meta)],
                 e.source_meta["parentId"],
                 e.ack,
@@ -1057,7 +1046,7 @@ class RunManager:
     def _apply_reload(self, e: _Reload) -> Any:
         self._stage_rewind(
             _Rewind(
-                "reload-message",
+                "message-reload",
                 [],
                 e.source_meta["parentId"],
                 e.ack,

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_ack_visibility.py

@@ -91,7 +91,7 @@ async def test_rewind_edit_acks_with_its_dispatch():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         seq = drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         await drv.wait_status("running")
         assert dispatching_ids(covered_state(drv, seq)) == ["u2"]
         host.live.state["messages"] = [msg("u2")]

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_batches.py

@@ -21,7 +21,7 @@ async def test_multi_steer_batch_places_all_and_dispatches_once():
             ]
         )
         call = await script.next_call()
-        assert call.ctx.trigger == "send-message"
+        assert call.ctx.trigger == "message-send"
         assert [m["id"] for m in call.ctx.messages] == ["s1", "s2", "s3"]
         script.no_call()
         assert queue_ids(drv.replica, "steerQueue") == []
@@ -59,30 +59,24 @@ async def test_steer_and_stop_in_one_batch_nets_to_stop():
             [("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"], [])
-        )
+        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")
 
 
@@ -146,7 +140,7 @@ async def test_rewind_outranks_send_and_continue_in_one_batch():
             ]
         )
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert [m["id"] for m in rerun.ctx.messages] == ["m2"]
         script.no_call()
         assert (await drv.res(first))["type"] == "accepted"
@@ -173,7 +167,7 @@ async def test_send_outranks_the_completing_input_answer():
             ]
         )
         run = await script.next_call()
-        assert run.ctx.trigger == "send-message"
+        assert run.ctx.trigger == "message-send"
         assert [m["id"] for m in run.ctx.messages] == ["s1"]
         assert run.ctx.input_outcomes == ((request, {"output": "ok"}, None),)
         script.no_call()

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

@@ -196,7 +196,7 @@ async def test_post_reload_sends_anchor_on_the_reload_targets_parent():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         drv.post("run/reload", reload_params("a1", anchor="u1"))
         call = await script.next_call()
-        assert call.ctx.trigger == "reload-message"
+        assert call.ctx.trigger == "message-reload"
         call.ack()
         script.thread["a1"] = {
             "parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": False

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_dispatching.py

@@ -58,7 +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"] == "send-message"
+        assert drv.run["dispatching"]["trigger"] == "message-send"
         assert dispatching_ids(drv.replica) == ["m1"]
         assert queue_ids(drv.replica, "queue") == []
         assert residence(drv, "m1") == ["dispatching"]
@@ -119,7 +119,7 @@ async def test_edit_replacement_rides_dispatching_until_ack():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         seq = drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         await drv.wait_status("running")
         assert dispatching_ids(drv.replica) == ["u2"]
         host.live.state["messages"] = [msg("u2")]

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_edit_dispatched.py

@@ -19,7 +19,7 @@ async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
         await drv.wait_status("running")
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert [m["parts"][0]["text"] for m in rerun.ctx.messages] == ["edited"]
         assert rerun.ctx.has_rollback
         assert rerun.ctx.rollback_to == "p0"
@@ -54,7 +54,7 @@ async def test_edit_of_dispatched_non_leaf_stops_and_reruns(command):
         seq = drv.post(command, target(message=msg("m1", "edited")))
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert [m["parts"][0]["text"] for m in rerun.ctx.messages] == ["edited"]
         rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
@@ -72,7 +72,7 @@ async def test_edit_of_dispatched_item_with_queued_items_stops_and_reruns():
         seq = drv.post("run/enqueue", target(message=msg("m1", "edited")))
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
         assert (await drv.res(seq))["type"] == "accepted"
@@ -90,5 +90,5 @@ async def test_edit_of_dispatched_item_in_error_reruns_without_stop():
         await drv.wait_status("error")
         drv.post("run/enqueue", target(message=msg("m1", "edited")))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert rerun.ctx.rollback_to is None

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_edit_reload.py

@@ -27,7 +27,7 @@ async def test_edit_in_ready_dispatches_message_edit():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         drv.post("run/edit", edit_params("u1", msg("u2", "v2"), anchor=None))
         call = await script.next_call()
-        assert call.ctx.trigger == "edit-message"
+        assert call.ctx.trigger == "message-edit"
         assert [m["id"] for m in call.ctx.messages] == ["u2"]
         assert call.ctx.has_rollback
         assert call.ctx.rollback_to is None
@@ -71,7 +71,7 @@ async def test_deep_edit_with_queue_non_empty_reruns_and_keeps_queue():
         await drv.wait_status("error")
         drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert rerun.ctx.rollback_to is None
         assert [item["id"] for item in drv.run["queue"]] == ["m2"]
 
@@ -88,7 +88,7 @@ async def test_leaf_edit_in_error_accepted_with_queue_non_empty():
         await drv.wait_status("error")
         drv.post("run/edit", edit_params("m1", msg("u2"), anchor=None))
         call = await script.next_call()
-        assert call.ctx.trigger == "edit-message"
+        assert call.ctx.trigger == "message-edit"
         assert call.ctx.rollback_to is None
         assert [item["id"] for item in drv.run["queue"]] == ["m2"]
 
@@ -140,7 +140,7 @@ async def test_reload_dispatches_with_empty_messages():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         drv.post("run/reload", reload_params("a1", anchor="u1"))
         call = await script.next_call()
-        assert call.ctx.trigger == "reload-message"
+        assert call.ctx.trigger == "message-reload"
         assert call.ctx.messages == ()
         assert call.ctx.rollback_to == "u1"
         call.ack()
@@ -205,7 +205,7 @@ async def test_deep_reload_with_queue_non_empty_reruns_and_keeps_queue():
         await drv.wait_status("error")
         drv.post("run/reload", reload_params("a0", anchor="u0"))
         call = await script.next_call()
-        assert call.ctx.trigger == "reload-message"
+        assert call.ctx.trigger == "message-reload"
         assert call.ctx.rollback_to == "u0"
         assert [item["id"] for item in drv.run["queue"]] == ["m2"]
 
@@ -260,7 +260,7 @@ async def test_edit_anchor_assertion():
         script.no_call()
         drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
         call = await script.next_call()
-        assert call.ctx.trigger == "edit-message"
+        assert call.ctx.trigger == "message-edit"
         assert call.ctx.rollback_to is None
 
 
@@ -283,5 +283,5 @@ async def test_reload_anchor_assertion():
         script.no_call()
         drv.post("run/reload", reload_params("a1", anchor="u1"))
         call = await script.next_call()
-        assert call.ctx.trigger == "reload-message"
+        assert call.ctx.trigger == "message-reload"
         assert call.ctx.rollback_to == "u1"

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_enqueue.py

@@ -9,7 +9,7 @@ async def test_ready_add_dispatches_message_send():
     async with run_host(script) as (drv, host):
         seq = drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        assert call.ctx.trigger == "send-message"
+        assert call.ctx.trigger == "message-send"
         assert [m["id"] for m in call.ctx.messages] == ["m1"]
         assert not call.ctx.has_rollback
         await drv.wait_status("running")
@@ -31,7 +31,7 @@ async def test_running_add_becomes_queue_item():
         script.no_call()
         call.finish(RunManager.Complete())
         drain = await script.next_call()
-        assert drain.ctx.trigger == "send-message"
+        assert drain.ctx.trigger == "message-send"
         assert [m["id"] for m in drain.ctx.messages] == ["m2"]
         drain.ack()
         drain.finish(RunManager.Complete())
@@ -69,7 +69,7 @@ async def test_steer_lane_drains_first_and_whole():
         await drv.command("run/steer", add("s2"), terminal=False)
         call.finish(RunManager.Complete())
         steered = await script.next_call()
-        assert steered.ctx.trigger == "send-message"
+        assert steered.ctx.trigger == "message-send"
         assert [m["id"] for m in steered.ctx.messages] == ["s1", "s2"]
         steered.ack()
         steered.finish(RunManager.Complete())

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_input_required.py

@@ -322,7 +322,7 @@ async def test_edit_while_parked_clears_requests_and_reruns():
         await park(drv, script, [tool_call("r1")], anchor="a1")
         drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert rerun.ctx.rollback_to is None
         await drv.wait(lambda s: "inputRequests" not in run_of(s))
         rerun.ack()
@@ -337,7 +337,7 @@ async def test_reload_while_parked_clears_requests_and_reruns():
         await park(drv, script, [tool_call("r1")], anchor="a1")
         drv.post("run/reload", reload_params("a1", anchor="u1"))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "reload-message"
+        assert rerun.ctx.trigger == "message-reload"
         assert rerun.ctx.rollback_to == "u1"
         await drv.wait(lambda s: "inputRequests" not in run_of(s))
         rerun.ack()
@@ -351,7 +351,7 @@ async def test_steer_add_while_parked_abandons_input_and_dispatches():
         await park(drv, script, [tool_call("r1"), approval("r2")])
         drv.post("run/steer", add("s1"))
         run = await script.next_call()
-        assert run.ctx.trigger == "send-message"
+        assert run.ctx.trigger == "message-send"
         assert [m["id"] for m in run.ctx.messages] == ["s1"]
         assert run.ctx.input_outcomes == (
             (tool_call("r1"), None, None),
@@ -394,7 +394,7 @@ async def test_promote_to_steer_while_parked_abandons_input_and_dispatches():
         script.no_call()
         await drv.command("run/steer", target(messageId="m2"))
         run = await script.next_call()
-        assert run.ctx.trigger == "send-message"
+        assert run.ctx.trigger == "message-send"
         assert [m["id"] for m in run.ctx.messages] == ["m2"]
         assert run.ctx.input_outcomes == ((tool_call("r1"), None, None),)
         assert "inputRequests" not in drv.run
@@ -434,7 +434,7 @@ async def test_steer_add_with_partial_answers_hands_over_the_answered_subset():
         )
         drv.post("run/steer", add("s1"))
         run = await script.next_call()
-        assert run.ctx.trigger == "send-message"
+        assert run.ctx.trigger == "message-send"
         assert [m["id"] for m in run.ctx.messages] == ["s1"]
         assert run.ctx.input_outcomes == (
             (tool_call("r1"), {"output": "ok"}, None),

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_meta.py

@@ -137,7 +137,7 @@ async def test_edit_meta_rides_the_replacement_message():
             edit_params("u1", msg("u2", "v2"), anchor=None, meta={"edited": True}),
         )
         call = await script.next_call()
-        assert call.ctx.trigger == "edit-message"
+        assert call.ctx.trigger == "message-edit"
         assert call.ctx.meta("u2") == {"edited": True}
         assert "meta" not in call.ctx.messages[0]
         assert call.ctx.meta() is None
@@ -151,7 +151,7 @@ async def test_reload_meta_rides_the_start_root():
     async with run_host(script, capabilities=("rewind",)) as (drv, _):
         drv.post("run/reload", reload_params("a1", anchor="u1", meta={"retry": 1}))
         call = await script.next_call()
-        assert call.ctx.trigger == "reload-message"
+        assert call.ctx.trigger == "message-reload"
         assert call.ctx.meta() == {"retry": 1}
         call.ack()
         call.finish(RunManager.Complete())

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_outcomes.py

@@ -13,7 +13,7 @@ async def test_register_overwrites_whatever_is_in_the_state():
         "error": {"message": "old"},
         "queue": [msg("q1")],
         "steerQueue": [msg("s1")],
-        "dispatch": {"type": "send-message", "messages": [msg("m1")]},
+        "dispatch": {"type": "message-send", "messages": [msg("m1")]},
     }
     async with run_host(script, initial_runs=stale) as (drv, host):
         assert drv.replica == {"status": "ready", "runs": []}

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_prepare_hooks.py

@@ -94,7 +94,7 @@ async def test_prepare_message_applies_to_edit():
     ) as (drv, host):
         drv.post("run/edit", edit_params("u1", noisy("u2"), anchor=None))
         call = await script.next_call()
-        assert call.ctx.trigger == "edit-message"
+        assert call.ctx.trigger == "message-edit"
         assert [m["parts"] for m in call.ctx.messages] == [
             [{"type": "text", "text": "u2"}]
         ]

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_restore.py

@@ -89,7 +89,7 @@ async def test_steer_while_hydrated_abandons_input_and_dispatches():
     ):
         drv.post("run/steer", add("s1"))
         run = await script.next_call()
-        assert run.ctx.trigger == "send-message"
+        assert run.ctx.trigger == "message-send"
         assert [m["id"] for m in run.ctx.messages] == ["s1"]
         assert run.ctx.input_outcomes == ((tool_call("r1"), None, None),)
         await drv.wait_status("running")
@@ -114,7 +114,7 @@ async def test_malformed_restore_states_raise():
         ({"runs": [parked_entry(error={"message": "x"})]}, "error"),
         ({"runs": [parked_entry(error=None)]}, "error"),
         ({"runs": [parked_entry(stopping={"reason": "stop"})]}, "stopping"),
-        ({"runs": [parked_entry(nextDispatch={"trigger": "edit-message"})]}, "nextDispatch"),
+        ({"runs": [parked_entry(nextDispatch={"trigger": "message-edit"})]}, "nextDispatch"),
         ({"runs": [parked_entry(inputRequests=[])]}, "non-empty list"),
         ({"runs": [parked_entry(inputRequests=["nope"])]}, "objects"),
         (

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_rewind_during_run.py

@@ -33,7 +33,7 @@ async def test_running_leaf_edit_stops_settles_then_rewinds():
         await drv.wait_status("running")
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert [m["id"] for m in rerun.ctx.messages] == ["m2"]
         assert rerun.ctx.rollback_to is None
         rerun.ack()
@@ -50,7 +50,7 @@ async def test_running_leaf_edit_accepted_with_non_empty_queues():
         seq = drv.post("run/edit", edit_params("m1", msg("m2"), anchor=None))
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
         assert (await drv.res(seq))["type"] == "accepted"
@@ -67,7 +67,7 @@ async def test_running_leaf_reload_stops_settles_then_rewinds():
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "reload-message"
+        assert rerun.ctx.trigger == "message-reload"
         assert rerun.ctx.rollback_to == "m1"
         rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
@@ -97,7 +97,7 @@ async def test_running_non_leaf_edit_stops_settles_then_rewinds():
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert [m["id"] for m in rerun.ctx.messages] == ["m2"]
         assert rerun.ctx.rollback_to is None
         rerun.ack()
@@ -113,7 +113,7 @@ async def test_running_non_leaf_reload_stops_settles_then_rewinds():
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "reload-message"
+        assert rerun.ctx.trigger == "message-reload"
         assert rerun.ctx.rollback_to == "m1"
         rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
@@ -142,5 +142,5 @@ async def test_leaf_reload_in_error_accepted_with_non_empty_queue():
         await drv.wait_status("error")
         drv.post("run/reload", reload_params("a1", anchor="m1"))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "reload-message"
+        assert rerun.ctx.trigger == "message-reload"
         assert queue_ids(drv.replica, "queue") == ["q1"]

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_settle.py

@@ -176,7 +176,7 @@ async def test_rewind_edit_settles_at_its_dispatch():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         seq = drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert (await drv.res(seq))["type"] == "accepted"
         rerun.ack()
         rerun.finish(RunManager.Complete())

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_steer.py

@@ -9,7 +9,7 @@ async def test_ready_steer_add_dispatches_like_enqueue():
     async with run_host(script) as (drv, host):
         drv.post("run/steer", add("m1"))
         call = await script.next_call()
-        assert call.ctx.trigger == "send-message"
+        assert call.ctx.trigger == "message-send"
         assert [m["id"] for m in call.ctx.messages] == ["m1"]
 
 

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_stop_continue.py

@@ -33,7 +33,7 @@ async def test_stop_outcome_can_keep_the_queue_draining():
         await drv.stop(terminal=False)
         call.finish(RunManager.Stop(dispatch_queue=True))
         drain = await script.next_call()
-        assert drain.ctx.trigger == "send-message"
+        assert drain.ctx.trigger == "message-send"
         assert [m["id"] for m in drain.ctx.messages] == ["m2"]
         await drv.wait_status("running")
 

{harness_sdk_python-0.13.0 → harness_sdk_python-0.13.2}/tests/test_stopping_window.py

@@ -1,10 +1,10 @@
 """Contract: the stopping window. Three openers — run/stop, mid-run
 edit/reload, and the enqueue/steer edit-of-dispatched form — write
-``stopping: {reason}`` (plus the staged rewind as ``nextDispatch``) in the
-same envelope as the opener's pending answer, ``status`` staying "running".
-On run end one envelope promotes ``nextDispatch`` into ``dispatching`` and
-clears the window; a later stop/rewind supersedes the staged command, which
-settles rejected (``superseded``)."""
+``stopping: {reason}`` (plus the staged rewind as ``nextDispatch``) and
+settle accepted with that write, ``status`` staying "running". On run end
+one envelope promotes ``nextDispatch`` into ``dispatching`` and clears the
+window; a later stop/rewind replaces the staged dispatch, whose command
+already settled at its admission write."""
 
 import asyncio
 import copy
@@ -13,7 +13,6 @@ import pytest
 from run_helpers import (
     Script,
     add,
-    assert_rejected,
     edit_params,
     msg,
     queue_ids,
@@ -57,23 +56,22 @@ async def start_run(drv, script, *, parent="p0"):
     return call
 
 
-async def test_stop_opens_the_window_with_the_pending_answer():
+async def test_stop_opens_the_window_and_settles_with_its_write():
     script = Script()
     async with run_host(script) as (drv, host):
         call = await start_run(drv, script)
-        pending = await drv.stop(terminal=False)
-        assert pending["type"] == "pending"
+        settled = await drv.stop()
+        assert settled["type"] == "accepted"
         assert drv.replica["status"] == "running"
         assert drv.run["stopping"] == {"reason": "stop"}
         assert "nextDispatch" not in drv.run
         opened = next(
             state
             for env, state in states(drv)
-            if any(r["seq"] == pending["seq"] for r in env.get("res", []))
+            if any(r["seq"] == settled["seq"] for r in env.get("res", []))
         )
         assert window_of(opened) == ({"reason": "stop"}, None)
         call.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(pending["seq"]))["type"] == "accepted"
         await drv.wait_status("stopped")
         assert "stopping" not in drv.run
 
@@ -89,10 +87,10 @@ async def test_mid_run_edit_stages_the_window_and_promotes_in_one_envelope():
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
         await drv.wait(lambda s: "stopping" in (s["runs"] or [{}])[0])
         assert drv.replica["status"] == "running"
-        assert drv.run["stopping"] == {"reason": "edit-message"}
+        assert drv.run["stopping"] == {"reason": "message-edit"}
         staged = drv.run["nextDispatch"]
         assert staged == {
-            "trigger": "edit-message",
+            "trigger": "message-edit",
             "messages": [msg("m2")],
             "rollbackTo": "p0",
         }
@@ -101,12 +99,12 @@ async def test_mid_run_edit_stages_the_window_and_promotes_in_one_envelope():
             for env, state in states(drv)
             if any(r["seq"] == seq for r in env.get("res", []))
         )
-        assert window_of(opened) == ({"reason": "edit-message"}, staged)
+        assert window_of(opened) == ({"reason": "message-edit"}, staged)
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert rerun.ctx.rollback_to == "p0"
-        await drv.wait(lambda s: (s["runs"][0].get("dispatching") or {}).get("trigger") == "edit-message")
+        await drv.wait(lambda s: (s["runs"][0].get("dispatching") or {}).get("trigger") == "message-edit")
         trail = [
             (window_of(state), (state["runs"] or [{}])[0].get("dispatching"))
             for _, state in states(drv)
@@ -114,11 +112,11 @@ async def test_mid_run_edit_stages_the_window_and_promotes_in_one_envelope():
         promoted = next(
             i
             for i, (_, record) in enumerate(trail)
-            if record is not None and record["trigger"] == "edit-message"
+            if record is not None and record["trigger"] == "message-edit"
         )
         assert trail[promoted][0] == (None, None)
         assert trail[promoted][1] == staged
-        assert trail[promoted - 1][0] == ({"reason": "edit-message"}, staged)
+        assert trail[promoted - 1][0] == ({"reason": "message-edit"}, staged)
         assert (await drv.res(seq))["type"] == "accepted"
         rerun.ack()
         rerun.finish(RunManager.Complete())
@@ -134,16 +132,16 @@ async def test_mid_run_reload_stages_reason_and_empty_messages():
         call = await start_run(drv, script)
         seq = drv.post("run/reload", reload_params("a1", anchor="m1", meta={"retry": 1}))
         await drv.wait(lambda s: "stopping" in (s["runs"] or [{}])[0])
-        assert drv.run["stopping"] == {"reason": "reload-message"}
+        assert drv.run["stopping"] == {"reason": "message-reload"}
         assert drv.run["nextDispatch"] == {
-            "trigger": "reload-message",
+            "trigger": "message-reload",
             "messages": [],
             "rollbackTo": "m1",
             "rootMeta": {"retry": 1},
         }
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "reload-message"
+        assert rerun.ctx.trigger == "message-reload"
         assert rerun.ctx.meta() == {"retry": 1}
         await drv.wait(lambda s: "stopping" not in (s["runs"] or [{}])[0])
         assert drv.run["dispatching"]["rootMeta"] == {"retry": 1}
@@ -163,22 +161,22 @@ async def test_edit_of_dispatched_message_opens_the_window(command):
         seq = drv.post(command, target(message=msg("m1", "edited")))
         await drv.wait(lambda s: "stopping" in (s["runs"] or [{}])[0])
         assert drv.replica["status"] == "running"
-        assert drv.run["stopping"] == {"reason": "edit-message"}
+        assert drv.run["stopping"] == {"reason": "message-edit"}
         assert drv.run["nextDispatch"] == {
-            "trigger": "edit-message",
+            "trigger": "message-edit",
             "messages": [msg("m1", "edited")],
             "rollbackTo": "p0",
         }
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert rerun.ctx.rollback_to == "p0"
         assert (await drv.res(seq))["type"] == "accepted"
         rerun.ack()
         rerun.finish(RunManager.Complete())
 
 
-async def test_later_rewind_supersedes_the_staged_one():
+async def test_later_rewind_replaces_the_staged_dispatch():
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (
         drv,
@@ -188,20 +186,20 @@ async def test_later_rewind_supersedes_the_staged_one():
         first = drv.post("run/edit", edit_params("m1", msg("m2"), anchor="p0"))
         await drv.wait(lambda s: "nextDispatch" in (s["runs"] or [{}])[0])
         second = drv.post("run/reload", reload_params("a1", anchor="m1"))
-        assert_rejected(await drv.res(first), "superseded")
+        assert (await drv.res(first))["type"] == "accepted"
         await drv.wait(
-            lambda s: s["runs"][0]["nextDispatch"]["trigger"] == "reload-message"
+            lambda s: s["runs"][0]["nextDispatch"]["trigger"] == "message-reload"
         )
-        assert drv.run["stopping"] == {"reason": "reload-message"}
+        assert drv.run["stopping"] == {"reason": "message-reload"}
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "reload-message"
+        assert rerun.ctx.trigger == "message-reload"
         assert (await drv.res(second))["type"] == "accepted"
         rerun.ack()
         rerun.finish(RunManager.Complete())
 
 
-async def test_stop_supersedes_a_staged_rewind():
+async def test_stop_clears_a_staged_rewind():
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (
         drv,
@@ -210,12 +208,12 @@ async def test_stop_supersedes_a_staged_rewind():
         call = await start_run(drv, script)
         seq = drv.post("run/edit", edit_params("m1", msg("m2"), anchor="p0"))
         await drv.wait(lambda s: "nextDispatch" in (s["runs"] or [{}])[0])
-        pending = await drv.stop(terminal=False)
-        assert_rejected(await drv.res(seq), "superseded")
+        assert (await drv.res(seq))["type"] == "accepted"
+        settled = await drv.stop()
+        assert settled["type"] == "accepted"
         await drv.wait(lambda s: (s["runs"] or [{}])[0].get("stopping") == {"reason": "stop"})
         assert "nextDispatch" not in drv.run
         call.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(pending["seq"]))["type"] == "accepted"
         await drv.wait_status("stopped")
         script.no_call()
 
@@ -235,7 +233,7 @@ async def test_sends_during_the_window_park_in_their_lanes():
         assert queue_ids(drv.replica, "steerQueue") == ["s1"]
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "edit-message"
+        assert rerun.ctx.trigger == "message-edit"
         assert (await drv.res(seq))["type"] == "accepted"
         assert queue_ids(drv.replica, "queue") == ["q1"]
         assert queue_ids(drv.replica, "steerQueue") == ["s1"]