harness-sdk-python 0.36.2__tar.gz → 0.36.4__tar.gz

{harness_sdk_python-0.36.2 → harness_sdk_python-0.36.4}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.36.2
+Version: 0.36.4
 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.12
-Requires-Dist: pinned<0.16,>=0.15.1
-Requires-Dist: statewire<0.18,>=0.17.2
+Requires-Dist: pinned<0.16,>=0.15.2
+Requires-Dist: statewire<0.18,>=0.17.4
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.36.2 → harness_sdk_python-0.36.4}/examples/runs_app.py

@@ -106,7 +106,7 @@ class RunsHost(Statewire):
                         "content": user_text(message),
                     }
                 )
-            ctx.applied()
+            ctx.applied().dur()
             outcome = await self.stream_turn(ctx)
             if outcome is not None:
                 return outcome

{harness_sdk_python-0.36.2 → harness_sdk_python-0.36.4}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.36.2"
+version = "0.36.4"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.12,<4.0"
-dependencies = ["statewire>=0.17.2,<0.18", "pinned>=0.15.1,<0.16"]
+dependencies = ["statewire>=0.17.4,<0.18", "pinned>=0.15.2,<0.16"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.36.2 → harness_sdk_python-0.36.4}/src/harness_sdk/deepagents.py

@@ -146,6 +146,8 @@ class DeepagentsMessages:
             )
         self._checkpointer = checkpointer
         self._captured: dict[str, Any] | None = None
+        self._admission: Any | None = None
+        self._input_checkpoint_seen = False
         self._ephemeral: dict[str, dict[str, Any]] = {}
         self._write_lock = asyncio.Lock()
 
@@ -190,8 +192,7 @@ class DeepagentsMessages:
         self, ctx: Any
     ) -> tuple[dict[str, Any] | None, dict[str, Any]]:
         """The dispatch's langgraph (payload, config): plans the resumption, restores a rewind's window, appends the batch to the wire state, and confirms it applied."""
-        self._captured = None
-        self._thread.abandon_plan()
+        self.abandon_turn()
         config = self.config()
         if ctx.resume:
             return None, config
@@ -206,7 +207,7 @@ class DeepagentsMessages:
         turn: list[Any] = [*plan.replay]
         for message in ctx.messages:
             turn.append(self._append_user(message))
-        ctx.applied()
+        self.admit(ctx.applied())
         if plan.fork:
             if plan.checkpoint_id is not None:
                 config["configurable"]["checkpoint_id"] = plan.checkpoint_id
@@ -217,11 +218,34 @@ class DeepagentsMessages:
                 turn = [RemoveMessage(id=REMOVE_ALL_MESSAGES), *turn]
         return ({"messages": turn} if turn else None), config
 
+    def admit(self, admission: Any) -> None:
+        """Retain a visibly applied batch until its root checkpoint is saved."""
+        if self._admission is not None:
+            raise RuntimeError("previous input admission is still pending")
+        self._admission = admission
+
+    def checkpoint_saved(self, config: Any, checkpoint: Any, metadata: Any) -> None:
+        """Confirm this turn's input from a FrontierCheckpointer checkpoint callback."""
+        configurable = config["configurable"]
+        if (
+            configurable["thread_id"] == self._thread_id
+            and configurable.get("checkpoint_ns", "") == ""
+            and metadata["source"] in ("input", "loop")
+        ):
+            self._confirm_admission()
+
+    def _confirm_admission(self) -> None:
+        if self._admission is not None:
+            self._admission.dur()
+            self._admission = None
+
     def append_event(self, namespace: tuple, mode: str, event: Any) -> None:
         """Fold one ``astream`` event into the wire state; the root checkpoint stream is captured for the turn's ingest."""
         if mode == "checkpoints":
             if namespace == ():
                 self._captured = event
+                if event["metadata"]["source"] in ("input", "loop"):
+                    self._input_checkpoint_seen = True
             return
         from statewire.langgraph import append_langgraph_event
 
@@ -231,11 +255,15 @@ class DeepagentsMessages:
         """Ingest the turn's captured checkpoint and restamp; ``refetch`` discards the capture and reads the checkpointer's latest instead."""
         captured, self._captured = self._captured, None
         await deepagents_ingest(self._thread, captured, refetch=refetch)
+        if self._input_checkpoint_seen:
+            self._confirm_admission()
         self._restamp()
 
     def abandon_turn(self) -> None:
         """Discard a stream capture and any fork planned for the abandoned turn."""
         self._captured = None
+        self._admission = None
+        self._input_checkpoint_seen = False
         self._thread.abandon_plan()
 
     def append_users(self, messages: Any) -> list[dict[str, Any]]:

harness_sdk_python-0.36.4/src/harness_sdk/langgraph.py

@@ -0,0 +1,78 @@
+from typing import Any, AsyncIterator, Awaitable, Callable
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from pinned import Frontier
+
+
+class FrontierCheckpointer(BaseCheckpointSaver):
+    """Order a LangGraph saver's async writes with the owning instance's durable effects."""
+
+    def __init__(
+        self,
+        saver: BaseCheckpointSaver,
+        *,
+        frontier: Frontier,
+        on_checkpoint: Callable[[Any, Any, Any], None] | None = None,
+    ) -> None:
+        if isinstance(saver, FrontierCheckpointer):
+            raise ValueError("a checkpointer can participate in only one frontier")
+        super().__init__(serde=saver.serde)
+        self.saver = saver
+        self.frontier = frontier
+        self.on_checkpoint = on_checkpoint
+
+    @property
+    def config_specs(self):
+        return self.saver.config_specs
+
+    def get_next_version(self, current, channel):
+        return self.saver.get_next_version(current, channel)
+
+    async def _persist(self, effect: Callable[[], Awaitable[Any]]) -> Any:
+        result = None
+
+        async def write() -> None:
+            nonlocal result
+            result = await effect()
+
+        pending = write()
+        try:
+            position = self.frontier.enlist(pending)
+        except BaseException:
+            pending.close()
+            raise
+        await self.frontier.wait(position)
+        return result
+
+    async def aget_tuple(self, config):
+        await self.frontier.receipt()
+        return await self.saver.aget_tuple(config)
+
+    async def aget_delta_channel_history(self, *, config, channels):
+        await self.frontier.receipt()
+        return await self.saver.aget_delta_channel_history(config=config, channels=channels)
+
+    async def alist(
+        self, config, *, filter=None, before=None, limit=None
+    ) -> AsyncIterator[Any]:
+        await self.frontier.receipt()
+        async for checkpoint in self.saver.alist(
+            config, filter=filter, before=before, limit=limit
+        ):
+            yield checkpoint
+
+    async def aput(self, config, checkpoint, metadata, new_versions):
+        result = await self._persist(
+            lambda: self.saver.aput(config, checkpoint, metadata, new_versions)
+        )
+        if self.on_checkpoint is not None:
+            self.on_checkpoint(config, checkpoint, metadata)
+        return result
+
+    async def aput_writes(self, config, writes, task_id, task_path="") -> None:
+        await self._persist(
+            lambda: self.saver.aput_writes(config, writes, task_id, task_path)
+        )
+
+    async def adelete_thread(self, thread_id) -> None:
+        await self._persist(lambda: self.saver.adelete_thread(thread_id))

{harness_sdk_python-0.36.2 → harness_sdk_python-0.36.4}/src/harness_sdk/run_manager.py

@@ -26,9 +26,10 @@ order, then takes exactly one action based on the derived status and net
 effect (rewind > send-dispatch > continue > input-resume). Every initiator applies
 and settles accepted with its state-visible application, and every verb's
 verdict follows the admission's durable flush. ``entry["dispatching"]`` is
-the unconfirmed batch record; ``ctx.applied()`` confirms it durably,
+the visible batch record; ``ctx.applied()`` clears it at memory speed and
+returns an admission whose ``dur()`` confirms consumption behind prior frontier effects,
 ``steering.take()`` may refill it via deferred durable pops — at most one
-unconfirmed batch ever exists. Settle consumes a confirmed batch; a batch
+visibly unapplied batch exists. Admission handles retain unconfirmed batches. Settle consumes a confirmed batch; a batch
 still unconfirmed at settle returns to the front of its lanes (after a crash,
 unconfirmed taken entries re-present there on their own). A batch already
 durably confirmed redelivers in resume mode instead (``ctx.resume``): the
@@ -68,6 +69,7 @@ from dataclasses import dataclass, field
 from typing import Any, AsyncIterator, Callable, Coroutine, Iterable, Protocol
 
 from pinned import EvictionRequested
+from pinned.durability import FenceLost
 from pinned.trays import Tray, TrayDescriptor, TrayCtx, TrayMapNamespace, inbox
 from pinned.trays import persistent, persistent_outbox, persistent_queue
 from statepatch import observable
@@ -396,6 +398,7 @@ class RunManager(Tray):
         self._staged_rewind: _Rewind | None = None
         self._batch: list[tuple[str, dict[str, Any]]] = []
         self._pending_takes = 0
+        self._admissions: list[RunManager.Admission] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
         self._run_live: "RunManager.RunContext | None" = None
@@ -914,7 +917,9 @@ class RunManager(Tray):
                     "run must return a RunManager outcome, got "
                     f"{type(outcome).__name__}"
                 )
-            if isinstance(outcome, RunManager.Complete) and self.dispatching.value is not None:
+            if isinstance(outcome, RunManager.Complete) and (
+                self.dispatching.value is not None or self._admissions
+            ):
                 raise RuntimeError("run returned Complete with an unconfirmed batch")
         except EvictionRequested:
             self._advance()
@@ -1028,11 +1033,33 @@ class RunManager(Tray):
     def _settle(self, ctx: "RunManager.RunContext") -> None:
         if self._run_live is ctx:
             self._run_live = None
+        takes = self._pending_takes + sum(a._takes for a in self._admissions)
+        if takes:
+            self.steerQueue.untake(takes)
+            self._drop_dispatched(
+                message["id"]
+                for admission in self._admissions
+                if admission._takes
+                for _, message in admission._batch
+            )
+            if self._pending_takes:
+                self._drop_dispatched(message["id"] for _, message in self._batch)
+                self._batch = []
+            self._pending_takes = 0
+        self._admissions.clear()
+        recorded = self.outbox.value
+        if recorded is not None and not self.batchApplied.value:
+            item = recorded["item"]
+            self._batch = list(zip(item["lanes"], item["record"]["messages"]))
         if self._batch:
             self._drop_dispatched(item["id"] for _, item in self._batch)
             self._unstage_batch()
         else:
-            record = self.dispatching.value
+            record = (
+                recorded["item"]["record"]
+                if recorded is not None and not self.batchApplied.value
+                else self.dispatching.value
+            )
             if (
                 record is not None
                 and record["trigger"] != "steer"
@@ -1068,16 +1095,15 @@ class RunManager(Tray):
         self.dispatching.value = None
         self._finish_settle()
 
-    def _applied(self) -> None:
+    def _applied(self, ctx: "RunManager.RunContext") -> "RunManager.Admission":
         if self.dispatching.value is None:
             raise RuntimeError("applied() with no unapplied batch")
-        if self._pending_takes:
-            self.confirmedTakes.value = self.confirmedTakes.value + self._pending_takes
-            self._pending_takes = 0
-        else:
-            self.batchApplied.value = True
+        admission = RunManager.Admission(ctx, list(self._batch), self._pending_takes)
+        self._admissions.append(admission)
+        self._pending_takes = 0
         self._batch = []
         self.dispatching.value = None
+        return admission
 
     def _unstage_batch(self) -> None:
         taken, self._batch = self._batch, []
@@ -1600,6 +1626,29 @@ class RunManager(Tray):
                 for item in items
             )
 
+    @dataclass(eq=False)
+    class Admission:
+        """One visibly applied batch; ``dur()`` orders its consumption behind enlisted checkpoint writes."""
+
+        _ctx: "RunManager.RunContext"
+        _batch: list[tuple[str, dict[str, Any]]]
+        _takes: int
+        _confirmed: bool = False
+
+        def dur(self) -> None:
+            """Enlist this batch's durable consumption; idempotent until the dispatch settles."""
+            self._ctx._ensure_active()
+            if self._confirmed:
+                return
+            self._confirmed = True
+            manager = self._ctx._manager
+            while manager._admissions and manager._admissions[0]._confirmed:
+                admission = manager._admissions.pop(0)
+                if admission._takes:
+                    manager.confirmedTakes.value += admission._takes
+                else:
+                    manager.batchApplied.value = True
+
     @dataclass(frozen=True, eq=False)
     class RunContext:
         trigger: str
@@ -1691,10 +1740,10 @@ class RunManager(Tray):
             if self._manager._run_live is not self:
                 raise RuntimeError("this run has already settled")
 
-        def applied(self) -> None:
-            """Durably confirms the current batch: clears the dispatch record so settle consumes it."""
+        def applied(self) -> "RunManager.Admission":
+            """Clear the visible dispatch immediately; call the returned admission's ``dur()`` after enlisting its checkpoint."""
             self._ensure_active()
-            self._manager._applied()
+            return self._manager._applied(self)
 
 
 class RunManagerNamespace(TrayMapNamespace):
@@ -1709,6 +1758,8 @@ class RunManagerNamespace(TrayMapNamespace):
                 "(RunManager.Thread) to host @run_manager"
             )
         self._mint: "asyncio.Task[Any] | None" = None
+        self._loading: "asyncio.Task[None] | None" = None
+        self._loaded = False
         self._mounted: list[RunManager] = []
         api.state["runs"] = []
         api.state["status"] = "ready"
@@ -1725,7 +1776,103 @@ class RunManagerNamespace(TrayMapNamespace):
         tray, _minted = await self._machine(run_id, principal)
         return tray
 
+    async def _load_existing(self) -> None:
+        if self._loaded:
+            return
+        if self._loading is None:
+            self._loading = self._api.create_task(self._restore_existing())
+        await asyncio.shield(self._loading)
+
+    async def _restore_existing(self) -> None:
+        durability = self._durability()
+        try:
+            rows = await durability.store.list(
+                durability.ns, durability.id, durability.epoch, tray_ns=self._spec.name
+            )
+        except FenceLost:
+            self._api.abort()
+            raise
+        for _, run_id, marked, doc in rows:
+            await self._obtain(run_id, create=False, row=(marked, doc))
+        self._loaded = True
+
+    async def maybe_sync(
+        self,
+        *,
+        pending_inputs: Iterable[dict[str, Any]],
+        has_pending_tasks: bool,
+        principal: Any,
+        meta: Any = None,
+    ) -> bool:
+        """Import external pending work into an inactive run; return whether its state changed."""
+        if type(has_pending_tasks) is not bool:
+            raise TypeError("has_pending_tasks must be a bool")
+        requests = tuple(pending_inputs)
+        if requests:
+            RunManager.InputRequired(requests)
+        await self._load_existing()
+        if self._mint is not None:
+            await asyncio.shield(self._mint)
+        tray = self.live()
+        if tray is None:
+            if not requests and not has_pending_tasks:
+                return False
+            tray, _ = await self._machine(self._api.domain.token_hex(16), principal)
+        tray._check_run_owner(principal)
+        if (
+            tray._in_flight()
+            or tray._intake
+            or tray._batch
+            or tray.queue.value
+            or tray.steerQueue.value
+            or tray.nextDispatch.value is not None
+            or tray._staged_rewind is not None
+            or tray.outcome.value is not None
+        ):
+            return False
+        previous = {r["id"]: r for r in tray.inputRequests.value or ()}
+        synchronized = []
+        for request in requests:
+            item = {k: v for k, v in request.items() if k not in ("response", "meta")}
+            old = previous.get(request["id"], {})
+            if "response" in old:
+                item.update(response=old["response"], meta=old.get("meta"))
+            synchronized.append(item)
+        if requests:
+            if (
+                tray.inputRequests.value == synchronized
+                and tray.halted.value is None
+                and tray.error.value is None
+            ):
+                return False
+            tray.inputRequests.value = synchronized
+            tray._input_requests = [
+                {k: v for k, v in r.items() if k not in ("response", "meta")}
+                for r in synchronized
+            ]
+            tray._input_answers = {
+                r["id"]: (r["response"], r.get("meta"))
+                for r in synchronized if "response" in r
+            }
+            tray.halted.value = None
+            tray.error.value = None
+            tray._publish_status()
+            tray._schedule(tray._advance)
+            return True
+        changed = bool(tray.inputRequests.value)
+        tray._clear_input()
+        if has_pending_tasks:
+            tray._dispatch("stop-continue", [], root_meta=meta)
+            tray.batchApplied.value = True
+            tray.dispatching.value = None
+            tray._publish_status()
+            return True
+        if changed:
+            tray._publish_status()
+        return changed
+
     async def _machine(self, run_id: str, principal: Any) -> tuple[RunManager, bool]:
+        await self._load_existing()
         # No await between the live() check and the mint's publication, and no
         # lock held across storage I/O: same-tick callers await the shared mint
         # task and merge into the machine it mounts, or raise its failure.

{harness_sdk_python-0.36.2 → harness_sdk_python-0.36.4}/tests/run_helpers.py

@@ -19,7 +19,7 @@ class Call:
     outcome: "asyncio.Future[Any]"
 
     def applied(self) -> None:
-        self.ctx.applied()
+        self.ctx.applied().dur()
 
     def finish(self, outcome: Any) -> None:
         self.outcome.set_result(outcome)

{harness_sdk_python-0.36.2 → harness_sdk_python-0.36.4}/tests/test_deepagents_messages.py

@@ -46,9 +46,14 @@ class Ctx:
     has_rollback: bool = False
     rollback_to: str | None = None
     applied_count: int = 0
+    durable_count: int = 0
 
     def applied(self):
         self.applied_count += 1
+        return self
+
+    def dur(self):
+        self.durable_count += 1
 
 
 def user(id, text):
@@ -145,6 +150,7 @@ async def test_send_turn_projects_and_stamps():
     ctx = Ctx("message-send", (user("u1", "one"),))
     await turn(graph, messages, ctx)
     assert ctx.applied_count == 1
+    assert ctx.durable_count == 1
     assert ids(state) == ["u1", "a0"]
     assert [m["type"] for m in state["messages"]] == ["human", "ai"]
     assert branch(state, "a0") == {"id": 0, "siblings": [0]}
@@ -426,3 +432,79 @@ async def test_switch_branch_unknown_raises():
     _, _, _, messages, _ = await seeded()
     with pytest.raises(KeyError, match="unknown branch_id"):
         await messages.switch_branch(7)
+
+
+async def test_frontier_confirms_root_input_before_graph_execution():
+    from pinned import Frontier, InstanceDurability
+    from pinned.domain import RealDomain
+    from pinned.testing import MemoryStateStore
+
+    from harness_sdk.langgraph import FrontierCheckpointer
+
+    durability = InstanceDurability(
+        MemoryStateStore(), "threads", THREAD, 0, RealDomain()
+    )
+    boundary = Frontier(durability, lambda: None, asyncio.create_task)
+    saver = InMemorySaver()
+    callbacks = []
+    messages = None
+
+    def checkpoint_saved(config, checkpoint, metadata):
+        callbacks.append(metadata["source"])
+        messages.checkpoint_saved(config, checkpoint, metadata)
+
+    wrapper = FrontierCheckpointer(
+        saver, frontier=boundary, on_checkpoint=checkpoint_saved
+    )
+    messages, state = await booted(wrapper, MemoryCheckpointIndex())
+    ctx = Ctx("message-send", (user("u1", "one"),))
+    payload, config = await messages.plan_turn(ctx)
+    assert ctx.applied_count == 1
+    assert ctx.durable_count == 0
+    assert ids(state) == ["u1"]
+    await stream(_graph(wrapper), messages, payload, config)
+    assert ctx.durable_count == 1
+    assert callbacks[0] == "input"
+    await messages.ingest_turn()
+    assert ctx.durable_count == 1
+
+
+async def test_checkpoint_confirmation_ignores_other_threads_subgraphs_and_updates():
+    messages, _ = await booted(InMemorySaver(), MemoryCheckpointIndex())
+    ctx = Ctx("message-send", (user("u1", "one"),))
+    await messages.plan_turn(ctx)
+    for thread_id, namespace, source in (
+        ("another", "", "input"),
+        (THREAD, "child:1", "input"),
+        (THREAD, "", "update"),
+    ):
+        messages.checkpoint_saved(
+            {"configurable": {"thread_id": thread_id, "checkpoint_ns": namespace}},
+            {},
+            {"source": source},
+        )
+    assert ctx.durable_count == 0
+    messages.checkpoint_saved(
+        {"configurable": {"thread_id": THREAD}}, {}, {"source": "loop"}
+    )
+    assert ctx.durable_count == 1
+
+
+async def test_abandoned_turn_cannot_confirm_input_from_a_later_checkpoint():
+    messages, _ = await booted(InMemorySaver(), MemoryCheckpointIndex())
+    ctx = Ctx("message-send", (user("u1", "one"),))
+    await messages.plan_turn(ctx)
+    messages.abandon_turn()
+    messages.checkpoint_saved(
+        {"configurable": {"thread_id": THREAD}}, {}, {"source": "input"}
+    )
+    assert ctx.durable_count == 0
+
+
+async def test_refetch_before_input_checkpoint_does_not_confirm_new_input():
+    _, _, _, messages, _ = await seeded()
+    ctx = Ctx("message-send", (user("u3", "three"),))
+    await messages.plan_turn(ctx)
+    await messages.ingest_turn(refetch=True)
+    assert ctx.durable_count == 0
+    messages.abandon_turn()

{harness_sdk_python-0.36.2 → harness_sdk_python-0.36.4}/tests/test_fenced_postgres.py

@@ -513,7 +513,7 @@ class GraphHost(Statewire):
             if step == self.park_after:
                 self.parked.set()
                 await asyncio.Event().wait()
-        ctx.applied()
+        ctx.applied().dur()
         return RunManager.Complete()
 
 

harness_sdk_python-0.36.4/tests/test_langgraph.py

@@ -0,0 +1,170 @@
+import asyncio
+from types import SimpleNamespace
+
+import pytest
+from langgraph.checkpoint.base import empty_checkpoint
+from langgraph.checkpoint.memory import InMemorySaver
+from pinned import Frontier, InstanceDurability
+from pinned.domain import RealDomain
+from pinned.testing import MemoryStateStore
+
+from harness_sdk.langgraph import FrontierCheckpointer
+
+CONFIG = {"configurable": {"thread_id": "t", "checkpoint_ns": ""}}
+METADATA = {"source": "input", "step": -1, "parents": {}}
+
+
+def frontier(spawn=asyncio.create_task):
+    durability = InstanceDurability(MemoryStateStore(), "threads", "t", 0, RealDomain())
+    return Frontier(durability, lambda: None, spawn)
+
+
+async def test_checkpoint_and_pending_writes_obey_frontier_and_preserve_results():
+    log = []
+    gate = asyncio.Event()
+    started = asyncio.Event()
+    boundary = frontier()
+    saver = InMemorySaver()
+    checkpoint = empty_checkpoint()
+
+    async def begin():
+        log.append("begin")
+        started.set()
+        await gate.wait()
+
+    def admitted(config, saved, metadata):
+        assert config == CONFIG
+        assert saved is checkpoint
+        assert metadata is METADATA
+        log.append("checkpoint")
+        boundary.enlist(confirmation())
+
+    async def confirmation():
+        log.append("admitted")
+
+    wrapper = FrontierCheckpointer(saver, frontier=boundary, on_checkpoint=admitted)
+    boundary.enlist(begin())
+    put = asyncio.create_task(wrapper.aput(CONFIG, checkpoint, METADATA, {}))
+    await started.wait()
+    assert await saver.aget_tuple(CONFIG) is None
+    gate.set()
+    config = await put
+    await wrapper.aput_writes(config, [("messages", "hello")], "task", "path")
+    saved = await wrapper.aget_tuple(CONFIG)
+    assert saved.config == config
+    assert saved.pending_writes == [("task", "messages", "hello")]
+    assert [item.config async for item in wrapper.alist(CONFIG)] == [config]
+    assert log == ["begin", "checkpoint", "admitted"]
+    await wrapper.adelete_thread("t")
+    assert await wrapper.aget_tuple(CONFIG) is None
+
+
+async def test_failed_checkpoint_poisons_later_effects_without_acknowledging():
+    boundary = frontier()
+    confirmed = []
+    started = asyncio.Event()
+    gate = asyncio.Event()
+
+    class FailingSaver(InMemorySaver):
+        async def aput(self, *args):
+            started.set()
+            await gate.wait()
+            raise OSError("checkpoint unavailable")
+
+    wrapper = FrontierCheckpointer(
+        FailingSaver(),
+        frontier=boundary,
+        on_checkpoint=lambda *args: confirmed.append(True),
+    )
+    put = asyncio.create_task(wrapper.aput(CONFIG, empty_checkpoint(), METADATA, {}))
+    await started.wait()
+    gate.set()
+    with pytest.raises(OSError, match="checkpoint unavailable"):
+        await put
+    assert confirmed == []
+    with pytest.raises(RuntimeError, match="poisoned"):
+        await wrapper.aput_writes(CONFIG, [], "task")
+    boundary.close()
+
+
+async def test_cancelled_caller_leaves_owned_checkpoint_effect_in_frontier():
+    boundary = frontier()
+    started = asyncio.Event()
+    gate = asyncio.Event()
+    confirmed = []
+
+    class GatedSaver(InMemorySaver):
+        async def aput(self, *args):
+            started.set()
+            await gate.wait()
+            return await super().aput(*args)
+
+    saver = GatedSaver()
+    wrapper = FrontierCheckpointer(
+        saver, frontier=boundary, on_checkpoint=lambda *args: confirmed.append(True)
+    )
+    put = asyncio.create_task(wrapper.aput(CONFIG, empty_checkpoint(), METADATA, {}))
+    await started.wait()
+    put.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await put
+    gate.set()
+    await boundary.receipt()
+    assert await saver.aget_tuple(CONFIG) is not None
+    assert confirmed == []
+
+
+async def test_unstarted_effect_does_not_create_underlying_coroutine():
+    pending = []
+    calls = []
+    boundary = frontier(
+        lambda coroutine: (
+            pending.append(coroutine) or SimpleNamespace(done=lambda: False)
+        )
+    )
+
+    class TrackingSaver(InMemorySaver):
+        def aput(self, *args):
+            calls.append(True)
+            return super().aput(*args)
+
+    wrapper = FrontierCheckpointer(TrackingSaver(), frontier=boundary)
+    put = asyncio.create_task(wrapper.aput(CONFIG, empty_checkpoint(), METADATA, {}))
+    await asyncio.sleep(0)
+    put.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await put
+    boundary.close()
+    for coroutine in pending:
+        coroutine.close()
+    assert calls == []
+
+
+async def test_delta_history_uses_saver_specialization_after_frontier():
+    boundary = frontier()
+    history = {"messages": {"seed": [], "writes": []}}
+    committed = False
+
+    async def write():
+        nonlocal committed
+        committed = True
+
+    class DeltaSaver(InMemorySaver):
+        async def aget_delta_channel_history(self, *, config, channels):
+            assert committed
+            assert config == CONFIG
+            assert channels == ["messages"]
+            return history
+
+    wrapper = FrontierCheckpointer(DeltaSaver(), frontier=boundary)
+    boundary.enlist(write())
+    assert await wrapper.aget_delta_channel_history(
+        config=CONFIG, channels=["messages"]
+    ) is history
+
+
+def test_nested_frontier_checkpointers_are_rejected_before_they_can_deadlock():
+    boundary = frontier()
+    wrapper = FrontierCheckpointer(InMemorySaver(), frontier=boundary)
+    with pytest.raises(ValueError, match="only one frontier"):
+        FrontierCheckpointer(wrapper, frontier=boundary)

harness_sdk_python-0.36.4/tests/test_run_admission.py

@@ -0,0 +1,146 @@
+import asyncio
+
+import pytest
+from pinned.testing import MemoryStateStore, instance
+from run_helpers import Script, add, edit_params, make_host, msg
+from statepatch import plain
+
+from harness_sdk import RunManager
+
+
+async def enqueue(host, message_id="m1"):
+    await host.runs.enqueue(add(message_id), applied=lambda: None, auth_result=None)
+
+
+@pytest.mark.parametrize("confirmed", [False, True])
+async def test_visible_application_only_resumes_after_durable_confirmation(confirmed):
+    store = MemoryStateStore()
+    script = Script()
+    host_type = make_host(script)
+    async with instance(host_type, state_store=store) as host:
+        await enqueue(host)
+        call = await script.next_call()
+        admission = call.ctx.applied()
+        assert plain(host.state["runs"][0]["dispatching"]) is None
+        if confirmed:
+            call.ctx.set_state({"checkpoint": "c1"})
+            admission.dur()
+            admission.dur()
+        await host.frontier.wait()
+    async with instance(host_type, state_store=store):
+        replay = await script.next_call()
+        assert replay.ctx.resume is confirmed
+        if confirmed:
+            assert replay.ctx.state == {"checkpoint": "c1"}
+        else:
+            assert [m["id"] for m in replay.ctx.messages] == ["m1"]
+            replay.ctx.applied().dur()
+        replay.finish(RunManager.Complete())
+
+
+async def test_visible_application_does_not_wait_for_checkpoint_storage():
+    script = Script()
+    async with instance(make_host(script)) as host:
+        await enqueue(host)
+        call = await script.next_call()
+        admission = call.ctx.applied()
+        entered = asyncio.Event()
+        release = asyncio.Event()
+
+        async def checkpoint():
+            entered.set()
+            await release.wait()
+
+        call.ctx.enlist(checkpoint())
+        admission.dur()
+        await entered.wait()
+        receipt = asyncio.ensure_future(host.frontier.wait())
+        await asyncio.sleep(0)
+        assert not receipt.done()
+        assert plain(host.state["runs"][0]["dispatching"]) is None
+        release.set()
+        await receipt
+        call.finish(RunManager.Complete())
+
+
+async def test_delayed_handles_confirm_their_original_batches():
+    script = Script()
+    store = MemoryStateStore()
+    host_type = make_host(script)
+    async with instance(host_type, state_store=store) as host:
+        await enqueue(host)
+        call = await script.next_call()
+        first = call.ctx.applied()
+        await host.runs.steer(add("m2"), applied=lambda: None, auth_result=None)
+        assert [m["id"] for m in call.ctx.steering.take()] == ["m2"]
+        second = call.ctx.applied()
+        second.dur()
+        first.dur()
+        await host.frontier.wait()
+    async with instance(host_type, state_store=store):
+        replay = await script.next_call()
+        assert replay.ctx.resume
+        assert replay.ctx.steering.take() == ()
+        replay.finish(RunManager.Complete())
+
+
+async def test_unconfirmed_visible_steering_returns_to_its_lane_at_stop():
+    script = Script()
+    async with instance(make_host(script)) as host:
+        await enqueue(host)
+        call = await script.next_call()
+        call.ctx.applied().dur()
+        await host.runs.steer(add("m2"), applied=lambda: None, auth_result=None)
+        call.ctx.steering.take()
+        delayed = call.ctx.applied()
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        await host.runs.live().idle.wait()
+        assert [m["id"] for m in host.state["runs"][0]["steerQueue"]] == ["m2"]
+        with pytest.raises(RuntimeError, match="settled"):
+            delayed.dur()
+
+
+async def test_complete_requires_durable_consumption():
+    script = Script()
+    async with instance(make_host(script)) as host:
+        await enqueue(host)
+        call = await script.next_call()
+        call.ctx.applied()
+        call.finish(RunManager.Complete())
+        await host.runs.live().idle.wait()
+        assert host.state["status"] == "error"
+        assert [m["id"] for m in host.state["runs"][0]["queue"]] == ["m1"]
+
+
+async def test_unconfirmed_rewind_replacement_can_be_enqueued_after_stop():
+    script = Script()
+    async with instance(
+        make_host(script, capabilities=("rewind", "rewind-during-run"))
+    ) as host:
+        await enqueue(host)
+        first = await script.next_call()
+        first.applied()
+        script.thread["m1"] = {
+            "parentId": None,
+            "role": "user",
+            "isLeaf": True,
+            "onActiveBranch": True,
+        }
+        await host.runs.edit(
+            edit_params("m1", msg("m2"), anchor=None),
+            applied=lambda: None,
+            auth_result=None,
+        )
+        first.finish(RunManager.Stop(dispatch_queue=False))
+        replacement = await script.next_call()
+        replacement.ctx.applied()
+        replacement.finish(RunManager.Stop(dispatch_queue=False))
+        await host.runs.live().idle.wait()
+
+        await host.runs.enqueue(
+            add("m2", anchor="m1"), applied=lambda: None, auth_result=None
+        )
+        retry = await script.next_call()
+        assert [m["id"] for m in retry.ctx.messages] == ["m2"]
+        retry.applied()
+        retry.finish(RunManager.Complete())

harness_sdk_python-0.36.4/tests/test_run_sync.py

@@ -0,0 +1,121 @@
+import asyncio
+
+import pytest
+from pinned.testing import MemoryStateStore, instance
+from run_helpers import Script, add, make_host
+from statewire import StatewireReject
+
+from harness_sdk import RunManager
+
+R1 = {"id": "r1", "type": "interrupt", "payload": "approve"}
+R2 = {"id": "r2", "type": "interrupt", "payload": "continue"}
+
+
+async def sync(host, inputs=(), tasks=False, principal="alice", meta=None):
+    return await host.runs.maybe_sync(
+        pending_inputs=inputs, has_pending_tasks=tasks, principal=principal, meta=meta
+    )
+
+
+async def test_sync_creates_pending_requests_and_repeating_it_is_unchanged():
+    script = Script()
+    async with instance(make_host(script)) as host:
+        assert await sync(host, [R1])
+        assert host.state["status"] == "input-required"
+        run_id = host.state["runs"][0]["runId"]
+        assert not await sync(host, [R1])
+        assert host.state["runs"][0]["runId"] == run_id
+        script.no_call()
+        assert await sync(host)
+        assert host.state["status"] == "ready"
+        assert not await sync(host)
+
+
+async def test_sync_preserves_answers_to_matching_requests():
+    script = Script()
+    async with instance(make_host(script)) as host:
+        await sync(host, [R1, R2])
+        await host.runs.input(
+            {"requestId": "r1", "response": {"answer": "yes"}}, auth_result="alice"
+        )
+        assert await sync(host, [R1])
+        call = await script.next_call()
+        assert call.ctx.input_outcomes == ((R1, {"answer": "yes"}, None),)
+        call.ctx.applied().dur()
+        call.finish(RunManager.Complete())
+
+
+async def test_sync_drops_obsolete_answers_and_resumes_pending_graph_work():
+    script = Script()
+    async with instance(make_host(script)) as host:
+        await sync(host, [R1, R2])
+        await host.runs.input(
+            {"requestId": "r1", "response": {"answer": "yes"}}, auth_result="alice"
+        )
+        assert await sync(host, tasks=True, meta={"user": "alice"})
+        call = await script.next_call()
+        assert call.ctx.resume
+        assert call.ctx.meta() == {"user": "alice"}
+        assert call.ctx.input_outcomes == ()
+        call.finish(RunManager.Complete())
+
+
+async def test_sync_is_guarded_by_recorded_execution_and_ownership():
+    script = Script()
+    store = MemoryStateStore()
+    host_type = make_host(script)
+    async with instance(host_type, state_store=store) as host:
+        await sync(host, [R1])
+        with pytest.raises(StatewireReject, match="another caller"):
+            await sync(host, tasks=True, principal="mallory")
+        assert await sync(host, tasks=True)
+        await script.next_call()
+        assert not await sync(host, [R2])
+        await host.frontier.wait()
+    async with instance(host_type, state_store=store) as host:
+        assert not await sync(host, [R2])
+        call = await script.next_call()
+        assert call.ctx.resume
+        call.finish(RunManager.Complete())
+
+
+async def test_sync_during_lifespan_loads_existing_records_before_deciding():
+    script = Script()
+    store = MemoryStateStore()
+    base = make_host(script)
+    async with instance(base, state_store=store) as host:
+        await host.runs.enqueue(add("m1"), applied=lambda: None, auth_result=None)
+        await script.next_call()
+        await host.frontier.wait()
+
+    class Host(base):
+        async def lifespan(self):
+            self.state = {}
+            self.changed = await sync(self, [R1], principal=None)
+            yield
+
+    async with instance(Host, state_store=store) as host:
+        assert not host.changed
+        call = await script.next_call()
+        assert [m["id"] for m in call.ctx.messages] == ["m1"]
+        call.ctx.applied().dur()
+        call.finish(RunManager.Complete())
+
+
+async def test_concurrent_sync_calls_create_one_run():
+    script = Script()
+    async with instance(make_host(script)) as host:
+        results = await asyncio.gather(sync(host, tasks=True), sync(host, tasks=True))
+        assert sorted(results) == [False, True]
+        call = await script.next_call()
+        script.no_call()
+        call.finish(RunManager.Complete())
+
+
+async def test_empty_sync_does_not_create_a_run():
+    script = Script()
+    async with instance(make_host(script)) as host:
+        assert not await sync(host)
+        assert host.state["runs"] == []
+        with pytest.raises(TypeError, match="bool"):
+            await sync(host, tasks=1)