harness-sdk-python 0.7.0__tar.gz → 0.7.2__tar.gz

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.2}/.gitignore

@@ -21,3 +21,4 @@ __pycache__
 /d[0-9]*.md
 /doc_*.md
 apps/docs/.docs
+/.agentdoc/

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.2}/PKG-INFO

@@ -1,11 +1,17 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.7.0
+Version: 0.7.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
 Requires-Python: <4.0,>=3.11
 Requires-Dist: statewire<0.5,>=0.4.0
+Provides-Extra: deepagents
+Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
+Requires-Dist: langchain-core>=0.3; extra == 'deepagents'
+Requires-Dist: langchain-openai>=0.3; extra == 'deepagents'
+Requires-Dist: langgraph>=1.0.0; extra == 'deepagents'
+Requires-Dist: uvicorn[standard]>=0.30.0; extra == 'deepagents'
 Provides-Extra: postgres
 Requires-Dist: langgraph-checkpoint-postgres>=2.0.0; extra == 'postgres'
 Description-Content-Type: text/markdown

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "harness-sdk-python"
-version = "0.7.0"
+version = "0.7.2"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"
@@ -9,6 +9,13 @@ dependencies = ["statewire>=0.4.0,<0.5"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]
+deepagents = [
+    "deepagents>=0.6.12",
+    "langgraph>=1.0.0",
+    "langchain-core>=0.3",
+    "langchain-openai>=0.3",
+    "uvicorn[standard]>=0.30.0",
+]
 
 [project.urls]
 Repository = "https://github.com/assistant-ui/harness-sdk"

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.2}/src/harness_sdk/run_manager.py

@@ -4,16 +4,20 @@ Implements the full state x command matrix from runs.mdx on a single
 ``run(ctx)`` executor entrypoint, per the RunManager design (d4987).
 
 Commands stage entries into an intake list and schedule a drain; the drain
-reduces the whole intake into the lanes in order (pure placement), then takes
-exactly one action based on status and net effect (interrupt, dispatch, or
-continue). A parked send settles at staging; run-starting commands settle at
-the executor's ``ctx.ack_messages()``; ``run/stop`` awaits a future the drain
-resolves once the in-flight run has ended.
-
-Dispatched entries leave the queue projection but are retained until the
-executor acks. A run that ends before the ack puts them back at the front of
-their lane and settles their sends accepted; edit, reload, and continue
-initiators settle rejected (``stopped`` or the failure).
+reduces the whole intake in order, then takes exactly one action based on
+status and net effect (interrupt, dispatch, or continue). A 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. Every
+send acks and settles accepted with its state-visible insert (lane or
+``dispatching``); edit, reload, and continue initiators ack at their dispatch
+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.
 """
 
 import asyncio
@@ -130,10 +134,9 @@ class _Rewind:
 @dataclass
 class _Effects:
     steer_added: bool = False
-    new_added: bool = False
     continue_requested: bool = False
     continue_meta: Any = None
-    staged_sends: list[tuple[str, "asyncio.Future[Any]", Callable[[], None]]] = field(
+    staged_sends: list[tuple["asyncio.Future[Any]", Callable[[], None]]] = field(
         default_factory=list
     )
     continues: list["asyncio.Future[Any]"] = field(default_factory=list)
@@ -193,13 +196,8 @@ class RunManager:
         self._stop_reason: str | None = None
         self._staged_rewinds: list[_Rewind] = []
         self._dispatching: list[tuple[str, dict[str, Any]]] = []
-        # Deferred covering acks: they only ride an envelope whose state shows
-        # the command's effect (message-ack append, or the revert re-insert).
-        self._deferred_acks: dict[str, Callable[[], None]] = {}
-        self._dispatch_ack: Callable[[], None] | None = None
-        self._run_acked = True
+        self._run_acked = False
         self._leaf_confirmed: str | None = None
-        self._send_futures: list["asyncio.Future[Any]"] = []
         self._run_futures: list["asyncio.Future[Any]"] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
@@ -244,6 +242,7 @@ class RunManager:
                     "status": "ready",
                     "queue": [],
                     "steerQueue": [],
+                    "dispatching": [],
                     "error": None,
                     "runLeafMessageId": None,
                 }
@@ -293,7 +292,6 @@ class RunManager:
         entries, self._intake = self._intake, []
         outcome, self._outcome = self._outcome, None
         fx = _Effects()
-        pre_empty = not self._lane_items("steerQueue") and not self._lane_items("queue")
         for entry in entries:
             self._apply(entry, fx)
         if self._task is None:
@@ -306,31 +304,28 @@ class RunManager:
             if self._staged_rewinds:
                 rewind = self._staged_rewinds.pop(0)
                 self._clear_input()
+                if self._dispatching:
+                    self._revert_dispatching()
                 self._dispatch(
                     rewind.type,
                     rewind.messages,
                     rollback_to=rewind.rollback_to,
                     root_meta=rewind.root_meta,
                 )
-                self._dispatch_ack = rewind.ack
+                rewind.ack()
                 if not rewind.future.done():
                     self._run_futures.append(rewind.future)
             elif outcome is not None:
                 self._settle_outcome(outcome)
             else:
-                self._idle_action(fx, pre_empty)
+                self._idle_action(fx)
         if self._task is not None and (self._staged_stops or self._staged_rewinds):
             assert self._ctx is not None
             self._ctx.stop_requested.set()
-        dispatching = {item["id"] for _, item in self._dispatching}
-        for message_id, future, ack in fx.staged_sends:
-            if message_id in dispatching:
-                self._deferred_acks[message_id] = ack
-                self._send_futures.append(future)
-            else:
-                ack()
-                if not future.done():
-                    future.set_result(None)
+        for future, ack in fx.staged_sends:
+            ack()
+            if not future.done():
+                future.set_result(None)
         for future in fx.continues:
             if not future.done():
                 future.set_result(None)
@@ -365,19 +360,22 @@ class RunManager:
         if result is not _PARKED and not entry.future.done():
             entry.future.set_result(result)
 
-    def _idle_action(self, fx: _Effects, pre_empty: bool) -> None:
+    def _idle_action(self, fx: _Effects) -> None:
         status = self._status()
         if status == "ready":
-            self._pop_dispatchable()
+            if self._dispatching:
+                self._dispatch_staged()
         elif status in ("error", "stopped"):
             if fx.continue_requested or fx.steer_added:
                 self._dispatch(self._continue_type(), [], root_meta=fx.continue_meta)
                 self._run_futures.extend(fx.continues)
                 fx.continues.clear()
-            elif fx.new_added and pre_empty:
-                self._pop_dispatchable()
+            elif self._dispatching:
+                self._dispatch_staged()
         elif status == "input-required":
-            if fx.steer_added and self._lane_items("steerQueue"):
+            if self._dispatching:
+                self._dispatch_staged(input_outcomes=self._take_input_outcomes())
+            elif fx.steer_added and self._lane_items("steerQueue"):
                 self._pop_dispatchable(input_outcomes=self._take_input_outcomes())
             elif self._input_requests and len(self._input_answers) == len(
                 self._input_requests
@@ -437,6 +435,7 @@ 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)
         messages = [
             {k: v for k, v in message.items() if k != "meta"} for message in messages
         ]
@@ -450,6 +449,7 @@ class RunManager:
         self._run_acked = False
         entry = self._ensure_entry()
         self._leaf_confirmed = plain(entry["runLeafMessageId"])
+        entry["dispatching"] = dispatching
         entry["error"] = None
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
@@ -490,18 +490,14 @@ class RunManager:
                     "run must return a RunManager outcome, got "
                     f"{type(outcome).__name__}"
                 )
-            if isinstance(
-                outcome, (RunManager.Complete, RunManager.InputRequired)
-            ) and (self._dispatching or not self._run_acked):
-                raise RuntimeError(
-                    "run settled without acking its messages (call ctx.ack_messages())"
-                )
         except asyncio.CancelledError:
             await self._pull_leaf()
             self._settle(ctx)
             self._set_status("stopped")
             self._entry()["runId"] = None
-            self._settle_initiators(_reject("stopped", "run cancelled"))
+            self._settle_initiators(
+                None if self._run_acked else _reject("stopped", "run cancelled")
+            )
             self._revert_dispatching()
             self._idle.set()
             raise  # no drain, no freeze
@@ -511,16 +507,20 @@ class RunManager:
             message = str(exc) or type(exc).__name__
             if isinstance(exc, StatewireReject):
                 self._freeze(exc.message, exc.payload)
-                self._settle_initiators(exc)
+                self._settle_initiators(None if self._run_acked else exc)
             else:
                 self._freeze(message)
-                self._settle_initiators(_reject("run-error", message))
+                self._settle_initiators(
+                    None if self._run_acked else _reject("run-error", message)
+                )
             self._revert_dispatching()
             self._drain()
             return
         await self._pull_leaf()
         self._settle(ctx)
-        if isinstance(outcome, RunManager.Error):
+        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")
@@ -532,8 +532,8 @@ class RunManager:
         self._drain()
 
     async def _pull_leaf(self) -> None:
-        # An unacked end reverts instead of recording a leaf.
-        if self._dispatching or not self._run_acked:
+        # 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()
 
@@ -542,7 +542,6 @@ class RunManager:
             self._ctx = None
             self._task = None
         self._dispatch_record = None
-        self._dispatch_ack = None
 
     def _settle_initiators(self, error: StatewireReject | None) -> None:
         futures, self._run_futures = self._run_futures, []
@@ -554,45 +553,65 @@ class RunManager:
             else:
                 future.set_exception(error)
 
-    def _settle_sends(self) -> None:
-        futures, self._send_futures = self._send_futures, []
-        for future in futures:
-            if not future.done():
-                future.set_result(None)
-
     def _ack_messages(self) -> None:
-        if self._dispatch_ack is not None:
-            self._dispatch_ack()
-            self._dispatch_ack = None
-        for _, item in self._dispatching:
-            ack = self._deferred_acks.pop(item["id"], None)
-            if ack is not None:
-                ack()
         self._dispatching = []
+        self._entry()["dispatching"] = []
         self._run_acked = True
         self._leaf_confirmed = plain(self._entry()["runLeafMessageId"])
-        self._settle_sends()
-        self._settle_initiators(None)
 
     def _revert_dispatching(self) -> None:
-        self._settle_sends()
         taken, self._dispatching = self._dispatching, []
+        entry = self._ensure_entry()
+        entry["dispatching"] = []
         if not taken:
             return
-        entry = self._ensure_entry()
         for lane in ("steerQueue", "queue"):
             front = [item for taken_lane, item in taken if taken_lane == lane]
             if front:
                 entry[lane] = front + self._lane_items(lane)
-        for _, item in taken:
-            ack = self._deferred_acks.pop(item["id"], None)
-            if ack is not None:
-                ack()
         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:
+            return False
+        if self._dispatching:
+            return True
+        status = self._status()
+        if status == "ready":
+            return True
+        if status == "input-required":
+            return lane == "steerQueue"
+        if status in ("error", "stopped"):
+            return (
+                lane == "queue"
+                and not self._lane_items("queue")
+                and not self._lane_items("steerQueue")
+            )
+        return False
+
+    def _stage_dispatch(self, e: _Send) -> None:
+        assert e.message is not None
+        steer = self._lane_items("steerQueue") if e.lane == "steerQueue" else []
+        if len(self._dispatching) + len(steer) >= self._max_queued:
+            raise _reject("queue-full", f"queue is full ({self._max_queued} messages)")
+        if steer:
+            self._entry()["steerQueue"] = []
+            self._dispatching.extend(("steerQueue", item) for item in steer)
+        self._dispatching.append(("queue", self._stamped(e.message, e.meta)))
+        self._ensure_entry()["dispatching"] = [item for _, item in self._dispatching]
+
+    def _dispatch_staged(
+        self, *, input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = ()
+    ) -> None:
+        self._dispatch(
+            "message-send",
+            [item for _, item in self._dispatching],
+            input_outcomes=input_outcomes,
+        )
+
     def _pop_dispatchable(
         self, *, input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = ()
     ) -> bool:
@@ -746,7 +765,7 @@ class RunManager:
             return
         if self._lane_of(e.anchor) is not None:
             return
-        if e.anchor in self._dispatched_ids:
+        if e.anchor in self._dispatched_ids or self._is_dispatching(e.anchor):
             return
         if e.anchor_meta is None:
             raise _reject("unknown-id", f"anchor {e.anchor} names nothing")
@@ -824,11 +843,13 @@ class RunManager:
         if e.anchor is _ABSENT:
             raise _reject("invalid-message", "anchorMessageId is required")
         self._check_anchor(e)
-        self._insert_new(e.lane, e.message, e.params, e.meta)
-        fx.staged_sends.append((e.message_id, e.future, e.ack))
-        fx.new_added = True
-        if e.lane == "steerQueue":
-            fx.steer_added = True
+        if self._dispatchable(e.lane):
+            self._stage_dispatch(e)
+        else:
+            self._insert_new(e.lane, e.message, e.params, e.meta)
+            if e.lane == "steerQueue":
+                fx.steer_added = True
+        fx.staged_sends.append((e.future, e.ack))
         return _PARKED
 
     def _apply_move(self, e: _Send, fx: _Effects) -> Any:
@@ -1219,6 +1240,7 @@ class RunManager:
             entry = manager._entry()
             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"]
             self._ctx._message_meta.update(

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.2}/tests/test_ack_visibility.py

@@ -1,8 +1,8 @@
-"""Contract: settle-after-visibility. A send or rewind's covering ack only
-rides an envelope whose state carries the command's effect — the message in
-``state.messages`` (the executor appends it before ``ctx.ack_messages()``) or
-in a published queue lane. A parked send acks with its insert; a dispatched
-entry whose run ends unacked acks with the revert that re-publishes it."""
+"""Contract: acks ride visibility. A send's covering ack only rides an
+envelope whose state carries the command's effect — the item in a published
+queue lane or in ``dispatching``. An idle send's insert lands in
+``dispatching`` directly, so its ack rides the dispatch envelope and the queue
+lane never holds the item; a rewind's ack rides its dispatch the same way."""
 
 import copy
 
@@ -22,26 +22,28 @@ def covered_state(drv, seq):
     raise AssertionError(f"no envelope covers seq {seq}")
 
 
-def lane_and_message_ids(state):
+def dispatching_ids(state):
     runs = state.get("runs") or [{}]
-    return {
-        *(m["id"] for m in state.get("messages", [])),
-        *(item["id"] for item in runs[0].get("queue", [])),
-        *(item["id"] for item in runs[0].get("steerQueue", [])),
-    }
+    return [item["id"] for item in runs[0].get("dispatching", [])]
 
 
-async def test_dispatched_send_acks_with_the_message_ack_append():
+def assert_never_queued(drv, message_id):
+    state: dict = {}
+    for env in copy.deepcopy(drv.envelopes):
+        apply_ops(state, env)
+        assert message_id not in queue_ids(state, "queue")
+
+
+async def test_idle_send_acks_with_its_dispatching_insert():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        await drv.wait_status("running")
-        assert all("ack" not in env for env in drv.envelopes)
+        assert (await drv.res(seq))["type"] == "accepted"
+        assert dispatching_ids(covered_state(drv, seq)) == ["m1"]
+        assert_never_queued(drv, "m1")
         host.live.state["messages"] = [msg("m1")]
         call.ack()
-        assert (await drv.res(seq))["type"] == "accepted"
-        assert "m1" in lane_and_message_ids(covered_state(drv, seq))
         call.finish(RunManager.Complete())
 
 
@@ -57,17 +59,19 @@ async def test_parked_send_acks_with_its_queue_insert():
         call.finish(RunManager.Complete())
 
 
-async def test_unacked_run_end_acks_with_the_revert():
+async def test_unacked_run_end_reverts_the_direct_dispatch_to_the_queue():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        call.fail(RuntimeError("boom"))
         assert (await drv.res(seq))["type"] == "accepted"
-        assert "m1" in queue_ids(covered_state(drv, seq), "queue")
+        assert dispatching_ids(covered_state(drv, seq)) == ["m1"]
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        assert queue_ids(drv.replica, "queue") == ["m1"]
 
 
-async def test_rewind_edit_acks_with_the_message_ack_append():
+async def test_rewind_edit_acks_with_its_dispatch():
     script = Script()
     script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
@@ -75,9 +79,8 @@ async def test_rewind_edit_acks_with_the_message_ack_append():
         rerun = await script.next_call()
         assert rerun.ctx.trigger == "message-edit"
         await drv.wait_status("running")
-        assert all("ack" not in env for env in drv.envelopes)
+        assert dispatching_ids(covered_state(drv, seq)) == ["u2"]
         host.live.state["messages"] = [msg("u2")]
         rerun.ack()
-        assert (await drv.res(seq))["type"] == "accepted"
-        assert "u2" in lane_and_message_ids(covered_state(drv, seq))
         rerun.finish(RunManager.Complete())
+        assert (await drv.res(seq))["type"] == "accepted"

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.2}/tests/test_batches.py

@@ -31,6 +31,21 @@ async def test_multi_steer_batch_places_all_and_dispatches_once():
             assert (await drv.res(first + offset))["type"] == "accepted"
 
 
+async def test_same_tick_sends_dispatch_as_one_run():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        first = drv.batch(
+            [("run/enqueue", add("m1")), ("run/enqueue", add("m2", anchor="m1"))]
+        )
+        call = await script.next_call()
+        assert [m["id"] for m in call.ctx.messages] == ["m1", "m2"]
+        script.no_call()
+        assert (await drv.res(first))["type"] == "accepted"
+        assert (await drv.res(first + 1))["type"] == "accepted"
+        call.ack()
+        call.finish(RunManager.Complete())
+
+
 async def test_steer_and_stop_in_one_batch_nets_to_stop():
     script = Script()
     async with run_host(script) as (drv, host):
@@ -92,7 +107,7 @@ 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; the covering ack waits for the message-ack.
-        assert "ack" not in dispatch_env and "res" not in dispatch_env
-        call.ack()
+        # envelope of their own, carrying the send's covering ack.
+        assert dispatch_env.get("ack", 0) >= seq
         assert (await drv.res(seq))["type"] == "accepted"
+        call.ack()

harness_sdk_python-0.7.2/tests/test_dispatching.py

@@ -0,0 +1,123 @@
+"""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."""
+
+import copy
+
+from run_helpers import Script, add, msg, queue_ids, run_host
+
+from harness_sdk import RunManager
+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 []
+
+
+def places(state, message_id):
+    entry = (state.get("runs") or [{}])[0]
+    found = {
+        name
+        for name in ("queue", "steerQueue", "dispatching")
+        if any(item["id"] == message_id for item in entry.get(name, []))
+    }
+    if any(m["id"] == message_id for m in state.get("messages", [])):
+        found.add("messages")
+    return found
+
+
+def residence(drv, message_id):
+    """The item's place after each envelope, deduped: exactly one place per
+    envelope once it exists — the one-of-three invariant."""
+    state: dict = {}
+    trail: list[str] = []
+    for env in copy.deepcopy(drv.envelopes):
+        apply_ops(state, env)
+        found = places(state, message_id)
+        assert len(found) <= 1, found
+        if trail:
+            assert found, "item vanished between envelopes"
+        if found and (not trail or trail[-1] != next(iter(found))):
+            trail.append(next(iter(found)))
+    return trail
+
+
+async def test_idle_send_dispatches_straight_into_dispatching():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        await script.next_call()
+        await drv.wait_status("running")
+        assert dispatching_ids(drv.replica) == ["m1"]
+        assert queue_ids(drv.replica, "queue") == []
+        assert residence(drv, "m1") == ["dispatching"]
+
+
+async def test_ack_clears_dispatching_with_the_message_append():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        seq = drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        await drv.wait_status("running")
+        assert (await drv.res(seq))["type"] == "accepted"
+        host.live.state["messages"] = [msg("m1")]
+        call.ack()
+        await drv.wait(lambda s: dispatching_ids(s) == [])
+        assert residence(drv, "m1") == ["dispatching", "messages"]
+        call.finish(RunManager.Complete())
+
+
+async def test_unacked_run_end_returns_the_item_to_the_lane_front():
+    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/enqueue", add("m2"))
+        await drv.wait(lambda s: queue_ids(s, "queue") == ["m2"])
+        await drv.side("run/stop", {"runId": await drv.run_id()})
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        await drv.wait_status("stopped")
+        assert queue_ids(drv.replica, "queue") == ["m1", "m2"]
+        assert dispatching_ids(drv.replica) == []
+        assert residence(drv, "m1") == ["dispatching", "queue"]
+
+
+async def test_steering_take_moves_the_lane_into_dispatching():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        host.live.state["messages"] = [msg("m1")]
+        call.ack()
+        await drv.command("run/steer", add("s1"), terminal=False)
+        call.ctx.steering.take()
+        await drv.wait(lambda s: dispatching_ids(s) == ["s1"])
+        assert queue_ids(drv.replica, "steerQueue") == []
+        assert residence(drv, "s1") == ["steerQueue", "dispatching"]
+        host.live.state["messages"] = [msg("m1"), msg("s1")]
+        call.ack()
+        await drv.wait(lambda s: dispatching_ids(s) == [])
+        assert residence(drv, "s1") == ["steerQueue", "dispatching", "messages"]
+        call.finish(RunManager.Complete())
+
+
+async def test_edit_replacement_rides_dispatching_until_ack():
+    script = Script()
+    script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        seq = drv.post("run/edit", {"sourceId": "u1", "message": msg("u2")})
+        rerun = await script.next_call()
+        assert rerun.ctx.trigger == "message-edit"
+        await drv.wait_status("running")
+        assert dispatching_ids(drv.replica) == ["u2"]
+        host.live.state["messages"] = [msg("u2")]
+        rerun.ack()
+        await drv.wait(lambda s: dispatching_ids(s) == [])
+        assert residence(drv, "u2") == ["dispatching", "messages"]
+        rerun.finish(RunManager.Complete())
+        assert (await drv.res(seq))["type"] == "accepted"

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.2}/tests/test_facade.py

@@ -8,7 +8,7 @@ import asyncio
 
 from run_helpers import Script
 from statewire_helpers import statewire_client
-from test_assistant_transport import _PostStream, data_stream_frames
+from test_assistant_transport import _PostStream, data_stream_frames, state_ops
 
 from statewire import AssistantTransport, StatewireReject, command
 
@@ -63,13 +63,20 @@ async def test_chat_holds_until_the_entity_run_settles_then_eofs():
             assert stream.status == 200
             call = await script.next_call()
             assert call.ctx.trigger == "message-send"
+            instance = (await app.state.pinned_host.directory.get("t1")).instance
+            instance.state["messages"] = [dict(call.ctx.messages[0])]
             call.ack()
             await asyncio.sleep(0.05)
             assert stream._task is not None and not stream._task.done()
             call.finish(RunManager.Complete())
             tail = await stream.until_closed()
         frames = data_stream_frames(tail.decode())
-        assert all(prefix == "aui-state" for prefix, _ in frames)
+        assert frames and all(prefix == "aui-state" for prefix, _ in frames)
+        ops = state_ops(frames)
+        assert ops[0]["type"] == "set" and ops[0]["path"] == []
+        assert [m["id"] for m in ops[0]["value"]["messages"]] == [
+            call.ctx.messages[0]["id"]
+        ]
 
 
 async def test_chat_run_reject_is_one_error_frame_then_eof():

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.2}/tests/test_settle.py

@@ -1,10 +1,10 @@
-"""Contract: command settlement. A parked send settles accepted at staging and
-stays projected in its lane; a run-starting command's receipt and covering ack
-are held until the executor's ``ctx.ack_messages()`` publishes its messages. A
-run that ends before the ack settles then: enqueue/steer accepted, their
-entries back at the front of their lane (the covering ack riding that revert)
-and ``state.error`` carrying any failure; edit/reload/continue rejected
-(``stopped`` or the failure)."""
+"""Contract: command settlement. Every send settles accepted with its
+state-visible insert — a lane entry or a direct ``dispatching`` entry. Edit,
+reload, and continue settle when their run ends: accepted once the run has
+acked its messages, rejected (``stopped``, ``run-error``, or the failure)
+otherwise. A run that ends with unacked entries returns lane-origin items to
+the front of their lane, direct dispatches to the front of the queue, and
+lands any failure on ``state.error``."""
 
 import asyncio
 
@@ -132,15 +132,17 @@ async def test_ack_removes_the_entries_for_good():
         assert queue_ids(drv.replica, "queue") == []
 
 
-async def test_complete_without_ack_is_a_run_error():
+async def test_complete_without_ack_reverts_and_redispatches():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/enqueue", add("m1"))
         (await script.next_call()).finish(RunManager.Complete())
-        await drv.wait_status("error")
-        assert "ack_messages" in drv.run["error"]["message"]
-        assert queue_ids(drv.replica, "queue") == ["m1"]
+        redo = await script.next_call()
+        assert [m["id"] for m in redo.ctx.messages] == ["m1"]
         assert (await drv.res(seq))["type"] == "accepted"
+        redo.ack()
+        redo.finish(RunManager.Complete())
+        await drv.wait_status("ready")
 
 
 async def test_dequeue_removes_a_parked_entry():
@@ -172,7 +174,7 @@ async def test_stop_lands_while_a_steer_is_parked():
         assert queue_ids(drv.replica, "queue") == ["m1"]
 
 
-async def test_rewind_edit_settles_at_the_reruns_ack():
+async def test_rewind_edit_settles_at_the_reruns_end():
     script = Script()
     script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
@@ -180,8 +182,8 @@ async def test_rewind_edit_settles_at_the_reruns_ack():
         rerun = await script.next_call()
         assert rerun.ctx.trigger == "message-edit"
         rerun.ack()
-        assert (await drv.res(seq))["type"] == "accepted"
         rerun.finish(RunManager.Complete())
+        assert (await drv.res(seq))["type"] == "accepted"
 
 
 async def test_rewind_edit_failure_settles_with_the_payload():

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.2}/tests/test_stop_continue.py

@@ -209,6 +209,7 @@ async def test_bare_continue_with_incomplete_continuation(end, continue_type):
         assert continued.ctx.messages == ()
         assert not continued.ctx.has_rollback
         continued.ack()
+        continued.finish(RunManager.Complete())
         assert (await drv.res(res["seq"]))["type"] == "accepted"
 
 
@@ -235,6 +236,7 @@ async def test_continue_with_steer_lane_needs_no_capability():
         assert continued.ctx.trigger == "error-continue"
         assert [m["id"] for m in continued.ctx.steering.take()] == ["s1"]
         continued.ack()
+        continued.finish(RunManager.Complete())
         assert (await drv.res(res["seq"]))["type"] == "accepted"