harness-sdk-python 0.3.0__tar.gz → 0.3.1__tar.gz

{harness_sdk_python-0.3.0 → harness_sdk_python-0.3.1}/.gitignore

@@ -9,6 +9,9 @@ dist-test
 .dev.vars
 *.tsbuildinfo
 .harness-runs
+*.rdb
+.source
+next-env.d.ts
 __pycache__
 .venv
 .pytest_cache

{harness_sdk_python-0.3.0 → harness_sdk_python-0.3.1}/PKG-INFO

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

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

{harness_sdk_python-0.3.0 → harness_sdk_python-0.3.1}/src/harness_sdk/run_manager.py

@@ -161,6 +161,8 @@ 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._run_futures: list["asyncio.Future[Any]"] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
         self._init_state()
@@ -217,8 +219,9 @@ class RunManager:
                 self._dispatch(
                     rewind.type, rewind.messages, rollback_to=rewind.rollback_to
                 )
+                rewind.ack()
                 if not rewind.future.done():
-                    rewind.future.set_result(None)
+                    self._run_futures.append(rewind.future)
             elif outcome is not None:
                 self._settle_outcome(outcome)
             else:
@@ -318,6 +321,7 @@ class RunManager:
         ]
         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
@@ -359,10 +363,21 @@ class RunManager:
                 )
         except Exception as exc:
             self._settle(ctx)
-            self._freeze(str(exc) or type(exc).__name__)
+            message = str(exc) or type(exc).__name__
+            if isinstance(exc, StatewireReject):
+                self._freeze(exc.message, exc.payload)
+                self._settle_entities(exc)
+            else:
+                self._freeze(message)
+                self._settle_entities(_reject("run-error", message))
             self._drain()
             return
         self._settle(ctx)
+        self._settle_entities(
+            _reject("run-error", "run ended in error")
+            if isinstance(outcome, RunManager.Error)
+            else None
+        )
         self._outcome = outcome
         self._drain()
 
@@ -372,6 +387,22 @@ class RunManager:
             self._task = None
         self._dispatch_record = None
 
+    def _settle_entities(self, error: StatewireReject | None) -> None:
+        futures, self._run_futures = self._run_futures, []
+        for future in futures:
+            if future.done():
+                continue
+            if error is None:
+                future.set_result(None)
+            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 _pop_dispatchable(self) -> bool:
         steer = self._lane_items("steerQueue")
         if steer:
@@ -385,9 +416,14 @@ class RunManager:
             return True
         return False
 
-    def _freeze(self, message: str) -> None:
+    def _freeze(self, message: str, payload: Any = None) -> None:
         self._state["status"] = "error"
-        self._state["error"] = {"message": message}
+        if isinstance(payload, dict):
+            self._state["error"] = {**payload, "message": message}
+        elif payload is not None:
+            self._state["error"] = {"message": message, "payload": payload}
+        else:
+            self._state["error"] = {"message": message}
 
     # ─── Message and placement validation ───────────────────
 
@@ -556,10 +592,12 @@ class RunManager:
             )
         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
+        e.ack()
         fx.new_added = True
         if e.lane == "steerQueue":
             fx.steer_added = True
-        return None
+        return _PARKED
 
     def _apply_move(self, e: _Send, fx: _Effects) -> Any:
         current = self._lane_of(e.message_id)
@@ -608,6 +646,11 @@ 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:
@@ -956,6 +999,7 @@ class RunManager:
             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)
             return tuple(
                 {k: v for k, v in item.items() if k != "caller"} for item in items
             )

{harness_sdk_python-0.3.0 → harness_sdk_python-0.3.1}/tests/test_batches.py

@@ -21,23 +21,26 @@ async def test_multi_steer_batch_places_all_and_dispatches_once():
             ]
         )
         for offset in range(3):
-            assert (await drv.res(first + offset))["type"] == "accepted"
+            assert (await drv.res(first + offset, terminal=False))["type"] == "pending"
         call = await script.next_call()
         assert call.ctx.type == "message-send"
         assert [m["id"] for m in call.ctx.messages] == ["s1", "s2", "s3"]
         script.no_call()
         assert queue_ids(drv.replica, "steerQueue") == []
+        call.finish(RunManager.Complete())
+        for offset in range(3):
+            assert (await drv.res(first + offset))["type"] == "accepted"
 
 
 async def test_steer_and_stop_in_one_batch_nets_to_stop():
     script = Script()
     async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
         first = await drv.batch(
             [("run/steer", {"message": msg("s1")}), ("run/stop", None)]
         )
-        assert (await drv.res(first))["type"] == "accepted"
+        assert (await drv.res(first, terminal=False))["type"] == "pending"
         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))
@@ -50,7 +53,7 @@ async def test_steer_and_stop_in_one_batch_nets_to_stop():
 async def test_stop_settles_only_after_the_run_task_ends():
     script = Script()
     async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
         pending = await drv.command("run/stop", terminal=False)
         assert pending["type"] == "pending"
@@ -75,8 +78,8 @@ class TailScript(Script):
 async def test_handler_tail_staging_decides_in_its_own_envelope():
     script = TailScript()
     async with run_host(script) as (drv, host):
-        res = await drv.command("run/enqueue", {"message": msg("m1")})
-        assert res["type"] == "accepted"
+        res = await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        assert res["type"] == "pending"
         call = await script.next_call()
         assert [m["id"] for m in call.ctx.messages] == ["m1"]
         dispatch_env = next(
@@ -88,6 +91,6 @@ async def test_handler_tail_staging_decides_in_its_own_envelope():
             )
         )
         # The decide ran outside the batch segment: its ops flush in an
-        # envelope of their own, before the command's covering ack.
-        assert "res" not in dispatch_env
-        assert dispatch_env.get("ack", 0) < res["seq"]
+        # envelope of their own, alongside the pending verdict and its ack.
+        assert dispatch_env["res"] == [{"seq": res["seq"], "type": "pending"}]
+        assert dispatch_env["ack"] >= res["seq"]

{harness_sdk_python-0.3.0 → harness_sdk_python-0.3.1}/tests/test_caller.py

@@ -7,9 +7,9 @@ from harness_sdk import RunManager
 async def test_immediate_dispatch_carries_caller():
     script = Script()
     async with run_host(script) as (drv, _):
-        assert (await drv.command("run/enqueue", {"message": msg("m1")}))[
+        assert (await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False))[
             "type"
-        ] == "accepted"
+        ] == "pending"
         call = await script.next_call()
         assert call.ctx.caller is not None
         assert call.ctx.caller.client_id == "c1"
@@ -19,9 +19,9 @@ async def test_immediate_dispatch_carries_caller():
 async def test_queue_entry_projects_caller_client_id():
     script = Script()
     async with run_host(script) as (drv, _):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
-        await drv.command("run/enqueue", {"message": msg("m2")})
+        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
         await drv.wait(lambda s: len(s["queue"]) == 1)
         assert drv.replica["queue"][0]["caller"] == {"clientId": "c1"}
         call.finish(RunManager.Complete())
@@ -30,9 +30,9 @@ async def test_queue_entry_projects_caller_client_id():
 async def test_caller_context_is_read_at_dispatch_time():
     script = Script()
     async with run_host(script) as (drv, _):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
-        await drv.command("run/enqueue", {"message": msg("m2")})
+        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
         assert (await drv.context({"user": "simon"}))["type"] == "accepted"
         call.finish(RunManager.Complete())
         dispatched = await script.next_call()
@@ -47,9 +47,9 @@ 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"}))[
+        assert (await drv.command("run/reload", {"sourceId": "a1"}, terminal=False))[
             "type"
-        ] == "accepted"
+        ] == "pending"
         call = await script.next_call()
         assert call.ctx.caller is None
         call.finish(RunManager.Complete())
@@ -58,9 +58,9 @@ async def test_dispatch_without_queue_entry_has_no_caller():
 async def test_take_steered_strips_the_caller_stamp():
     script = Script()
     async with run_host(script) as (drv, _):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
-        await drv.command("run/steer", {"message": msg("s1")})
+        await drv.command("run/steer", {"message": msg("s1")}, terminal=False)
         await drv.wait(lambda s: len(s["steerQueue"]) == 1)
         assert drv.replica["steerQueue"][0]["caller"] == {"clientId": "c1"}
         [taken] = call.ctx.take_steered()
@@ -71,19 +71,19 @@ async def test_take_steered_strips_the_caller_stamp():
 async def test_max_queued_caps_each_lane():
     script = Script()
     async with run_host(script, max_queued=1) as (drv, _):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
-        assert (await drv.command("run/enqueue", {"message": msg("m2")}))[
+        assert (await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False))[
             "type"
-        ] == "accepted"
-        full = await drv.command("run/enqueue", {"message": msg("m3")})
+        ] == "pending"
+        full = await drv.command("run/enqueue", {"message": msg("m3")}, terminal=False)
         assert full["type"] == "rejected"
         assert full["payload"] == {"reason": "queue-full"}
         # The steer lane has its own budget.
-        assert (await drv.command("run/steer", {"message": msg("s1")}))[
+        assert (await drv.command("run/steer", {"message": msg("s1")}, terminal=False))[
             "type"
-        ] == "accepted"
-        steer_full = await drv.command("run/steer", {"message": msg("s2")})
+        ] == "pending"
+        steer_full = await drv.command("run/steer", {"message": msg("s2")}, terminal=False)
         assert steer_full["payload"] == {"reason": "queue-full"}
         call.finish(RunManager.Complete())
 
@@ -91,11 +91,11 @@ async def test_max_queued_caps_each_lane():
 async def test_lane_change_into_a_full_lane_rejects():
     script = Script()
     async with run_host(script, max_queued=1) as (drv, _):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
-        await drv.command("run/enqueue", {"message": msg("m2")})
-        await drv.command("run/steer", {"message": msg("s1")})
-        moved = await drv.command("run/steer", {"messageId": "m2"})
+        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
+        await drv.command("run/steer", {"message": msg("s1")}, terminal=False)
+        moved = await drv.command("run/steer", {"messageId": "m2"}, terminal=False)
         assert moved["payload"] == {"reason": "queue-full"}
         call.finish(RunManager.Complete())
 

{harness_sdk_python-0.3.0 → harness_sdk_python-0.3.1}/tests/test_edit_dispatched.py

@@ -10,7 +10,7 @@ from harness_sdk import RunManager
 async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
         script.thread["m1"] = {"parentId": "p0", "role": "user", "isLeaf": True}
         pending = await drv.command(
@@ -25,20 +25,21 @@ async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
         assert [m["parts"][0]["text"] for m in rerun.ctx.messages] == ["edited"]
         assert rerun.ctx.has_rollback
         assert rerun.ctx.rollback_to == "p0"
+        await drv.wait_status("running")
+        rerun.finish(RunManager.Stop(dispatch_queue=False))
         settled = await drv.res(pending["seq"])
         assert settled["type"] == "accepted"
-        await drv.wait_status("running")
 
 
 @pytest.mark.parametrize("capabilities", [(), ("rewind",)])
 async def test_edit_of_dispatched_item_requires_rewind_during_run(capabilities):
     script = Script()
     async with run_host(script, capabilities=capabilities) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
         assert_rejected(
-            await drv.command("run/enqueue", {"message": msg("m1", "edited")}),
+            await drv.command("run/enqueue", {"message": msg("m1", "edited")}, terminal=False),
             "capability-missing",
         )
 
@@ -47,7 +48,7 @@ async def test_edit_of_dispatched_item_requires_rewind_during_run(capabilities):
 async def test_edit_of_dispatched_non_leaf_rejects(command):
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": False}
         assert_rejected(
@@ -58,10 +59,10 @@ async def test_edit_of_dispatched_non_leaf_rejects(command):
 async def test_edit_of_dispatched_item_with_queued_items_stops_and_reruns():
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
-        await drv.command("run/enqueue", {"message": msg("m2")})
+        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
         pending = await drv.command(
             "run/enqueue", {"message": msg("m1", "edited")}, terminal=False
         )
@@ -69,6 +70,7 @@ async def test_edit_of_dispatched_item_with_queued_items_stops_and_reruns():
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
         assert rerun.ctx.type == "message-edit"
+        rerun.finish(RunManager.Stop(dispatch_queue=False))
         assert (await drv.res(pending["seq"]))["type"] == "accepted"
         assert [item["id"] for item in drv.replica["queue"]] == ["m2"]
 
@@ -76,12 +78,12 @@ async def test_edit_of_dispatched_item_with_queued_items_stops_and_reruns():
 async def test_edit_of_dispatched_item_in_error_reruns_without_stop():
     script = Script()
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        await drv.command("run/enqueue", {"message": msg("m1", "edited")})
+        await drv.command("run/enqueue", {"message": msg("m1", "edited")}, terminal=False)
         rerun = await script.next_call()
         assert rerun.ctx.type == "message-edit"
         assert rerun.ctx.rollback_to is None

{harness_sdk_python-0.3.0 → harness_sdk_python-0.3.1}/tests/test_edit_reload.py

@@ -17,9 +17,9 @@ async def test_edit_in_ready_dispatches_message_edit():
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         res = await drv.command(
-            "run/edit", {"sourceId": "u1", "message": msg("u2", "v2")}
+            "run/edit", {"sourceId": "u1", "message": msg("u2", "v2")}, terminal=False
         )
-        assert res["type"] == "accepted"
+        assert res["type"] == "pending"
         call = await script.next_call()
         assert call.ctx.type == "message-edit"
         assert [m["id"] for m in call.ctx.messages] == ["u2"]
@@ -32,7 +32,7 @@ async def test_edit_requires_rewind():
     thread_with_turn(script)
     async with run_host(script) as (drv, host):
         assert_rejected(
-            await drv.command("run/edit", {"sourceId": "u1", "message": msg("u2")}),
+            await drv.command("run/edit", {"sourceId": "u1", "message": msg("u2")}, terminal=False),
             "capability-missing",
         )
 
@@ -41,10 +41,10 @@ async def test_edit_while_running_requires_rewind_during_run():
     script = Script()
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         await script.next_call()
         assert_rejected(
-            await drv.command("run/edit", {"sourceId": "u1", "message": msg("u2")}),
+            await drv.command("run/edit", {"sourceId": "u1", "message": msg("u2")}, terminal=False),
             "capability-missing",
         )
 
@@ -53,32 +53,32 @@ async def test_deep_edit_rejected_while_queue_non_empty():
     script = Script()
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
-        await drv.command("run/enqueue", {"message": msg("m2")})
+        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         assert_rejected(
-            await drv.command("run/edit", {"sourceId": "u1", "message": msg("u2")}),
+            await drv.command("run/edit", {"sourceId": "u1", "message": msg("u2")}, terminal=False),
             "not-leaf",
         )
         await drv.command("run/dequeue", {"messageId": "m2"})
-        res = await drv.command("run/edit", {"sourceId": "u1", "message": msg("u2")})
-        assert res["type"] == "accepted"
+        res = await drv.command("run/edit", {"sourceId": "u1", "message": msg("u2")}, terminal=False)
+        assert res["type"] == "pending"
         assert (await script.next_call()).ctx.type == "message-edit"
 
 
 async def test_leaf_edit_in_error_accepted_with_queue_non_empty():
     script = Script()
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
-        await drv.command("run/enqueue", {"message": msg("m2")})
+        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        res = await drv.command("run/edit", {"sourceId": "m1", "message": msg("u2")})
-        assert res["type"] == "accepted"
+        res = await drv.command("run/edit", {"sourceId": "m1", "message": msg("u2")}, terminal=False)
+        assert res["type"] == "pending"
         call = await script.next_call()
         assert call.ctx.type == "message-edit"
         assert call.ctx.rollback_to is None
@@ -90,15 +90,15 @@ async def test_edit_unknown_source_and_duplicate_replacement():
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         assert_rejected(
-            await drv.command("run/edit", {"sourceId": "zz", "message": msg("u2")}),
+            await drv.command("run/edit", {"sourceId": "zz", "message": msg("u2")}, terminal=False),
             "unknown-id",
         )
         assert_rejected(
-            await drv.command("run/edit", {"sourceId": "u1", "message": msg("a1")}),
+            await drv.command("run/edit", {"sourceId": "u1", "message": msg("a1")}, terminal=False),
             "duplicate-id",
         )
-        res = await drv.command("run/edit", {"sourceId": "u1", "message": msg("u1", "v2")})
-        assert res["type"] == "accepted"
+        res = await drv.command("run/edit", {"sourceId": "u1", "message": msg("u1", "v2")}, terminal=False)
+        assert res["type"] == "pending"
 
 
 async def test_edit_of_assistant_message_requires_assistant_edit():
@@ -106,7 +106,7 @@ async def test_edit_of_assistant_message_requires_assistant_edit():
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         assert_rejected(
-            await drv.command("run/edit", {"sourceId": "a1", "message": msg("u2")}),
+            await drv.command("run/edit", {"sourceId": "a1", "message": msg("u2")}, terminal=False),
             "capability-missing",
         )
     script = Script()
@@ -115,8 +115,8 @@ async def test_edit_of_assistant_message_requires_assistant_edit():
         drv,
         host,
     ):
-        res = await drv.command("run/edit", {"sourceId": "a1", "message": msg("u2")})
-        assert res["type"] == "accepted"
+        res = await drv.command("run/edit", {"sourceId": "a1", "message": msg("u2")}, terminal=False)
+        assert res["type"] == "pending"
         call = await script.next_call()
         assert call.ctx.rollback_to == "u1"
 
@@ -125,8 +125,8 @@ async def test_reload_dispatches_with_empty_messages():
     script = Script()
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        res = await drv.command("run/reload", {"sourceId": "a1"})
-        assert res["type"] == "accepted"
+        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.messages == ()
@@ -140,15 +140,15 @@ async def test_reload_rejections():
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "u1"}), "invalid-message"
+            await drv.command("run/reload", {"sourceId": "u1"}, terminal=False), "invalid-message"
         )
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "zz"}), "unknown-id"
+            await drv.command("run/reload", {"sourceId": "zz"}, terminal=False), "unknown-id"
         )
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         await script.next_call()
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a1"}), "capability-missing"
+            await drv.command("run/reload", {"sourceId": "a1"}, terminal=False), "capability-missing"
         )
 
 
@@ -157,7 +157,7 @@ async def test_reload_without_rewind_rejects():
     thread_with_turn(script)
     async with run_host(script) as (drv, host):
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a1"}), "capability-missing"
+            await drv.command("run/reload", {"sourceId": "a1"}, terminal=False), "capability-missing"
         )
 
 
@@ -170,18 +170,18 @@ async def test_reload_leaf_only_while_queue_non_empty():
         }
     )
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")})
+        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
         call = await script.next_call()
         script.thread["m1"] = {"parentId": "a0", "role": "user", "isLeaf": False}
         script.thread["a1"] = {"parentId": "m1", "role": "assistant", "isLeaf": True}
-        await drv.command("run/enqueue", {"message": msg("m2")})
+        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a0"}), "not-leaf"
+            await drv.command("run/reload", {"sourceId": "a0"}, terminal=False), "not-leaf"
         )
-        res = await drv.command("run/reload", {"sourceId": "a1"})
-        assert res["type"] == "accepted"
+        res = await drv.command("run/reload", {"sourceId": "a1"}, terminal=False)
+        assert res["type"] == "pending"
         call = await script.next_call()
         assert call.ctx.rollback_to == "m1"
 
@@ -196,12 +196,12 @@ async def test_reload_of_assistant_parented_response_needs_continuation():
     )
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a2"}), "capability-missing"
+            await drv.command("run/reload", {"sourceId": "a2"}, terminal=False), "capability-missing"
         )
     async with run_host(script, capabilities=("rewind", "assistant-continuation")) as (
         drv,
         host,
     ):
-        res = await drv.command("run/reload", {"sourceId": "a2"})
-        assert res["type"] == "accepted"
+        res = await drv.command("run/reload", {"sourceId": "a2"}, terminal=False)
+        assert res["type"] == "pending"
         assert (await script.next_call()).ctx.rollback_to == "a1"