Command 定义在 types.py:759-808，是个能装多种"命令"的数据类：

# types.py:759
@dataclass(...)
class Command(Generic[N], ToolOutputMixin):
    graph: str | None = None       # 发给哪张图（None=当前，PARENT=父图）
    update: Any | None = None      # 顺便更新一下状态
    resume: dict[str, Any] | Any | None = None   # ★ 今天的主角：恢复值
    goto: Send | Sequence[Send | N] | N = ()     # 顺便跳到某节点（D15 讲过）

    PARENT: ClassVar[Literal["__parent__"]] = "__parent__"   # types.py:808

昨天 interrupt() 里那个 scratchpad 究竟是什么？定义在 _scratchpad.py:8-19，短到一屏：

# _scratchpad.py:8
@dataclasses.dataclass(**_DC_KWARGS)
class PregelScratchpad:
    step: int
    stop: int
    # call
    call_counter: Callable[[], int]
    # interrupt
    interrupt_counter: Callable[[], int]     # ① 节点里 interrupt 的编号器
    get_null_resume: Callable[[bool], Any]   # ② 取"通用恢复值"的函数
    resume: list[Any]                        # ③ 这个任务的恢复值列表
    # subgraph
    subgraph_counter: Callable[[], int]

便签本由谁填？由 _scratchpad()（_algo.py:1280）在每次准备任务时构造。它从 pending_writes（还记得吗，昨天 RESUME 就存这里）里找恢复值：

# _algo.py:1280
def _scratchpad(parent_scratchpad, pending_writes, task_id,
                namespace_hash, resume_map, step, stop):
    if len(pending_writes) > 0:
        # find global resume value  —— 找"通用恢复值"（谁都能领的那份）
        for w in pending_writes:
            if w[0] == NULL_TASK_ID and w[1] == RESUME:   # ① 特殊 task_id + RESUME
                null_resume_write = w
                break
        else:
            null_resume_write = None
        # find task-specific resume value —— 找"点名给本任务的"恢复值
        for w in pending_writes:
            if w[0] == task_id and w[1] == RESUME:        # ② 就是本 task_id 的 RESUME
                task_resume_write = w[2]
                if not isinstance(task_resume_write, list):
                    task_resume_write = [task_resume_write]
                break
        else:
            task_resume_write = []
        # find namespace and task-specific resume value  —— 按中断 id 精确映射
        if resume_map and namespace_hash in resume_map:   # ③ Command(resume={id:值})
            mapped_resume_write = resume_map[namespace_hash]
            task_resume_write.append(mapped_resume_write)
    else:
        null_resume_write = None
        task_resume_write = []

_scratchpad() 内部定义了闭包 get_null_resume（_algo.py:1320-1331），交给便签本：

# _algo.py:1320
def get_null_resume(consume: bool = False) -> Any:
    if null_resume_write is None:
        if parent_scratchpad is not None:
            return parent_scratchpad.get_null_resume(consume)   # ① 本层没有？问父层
        return None
    if consume:                                                  # ② 消费模式
        try:
            pending_writes.remove(null_resume_write)            #    从 pending 里删掉！
            return null_resume_write[2]                          #    返回值
        except ValueError:
            return None
    return null_resume_write[2]                                  # ③ 只看不消费

现在把便签本填好后，回到昨天的 interrupt() 前半段（types.py:912-925）——这次它走的是另一条路：

# types.py:912
scratchpad = conf[CONFIG_KEY_SCRATCHPAD]     # 拿到 _scratchpad() 刚填好的便签本
idx = scratchpad.interrupt_counter()          # 本 interrupt 编号
# ① 便签本里已有点名恢复值（task-specific）
if scratchpad.resume:
    if idx < len(scratchpad.resume):
        conf[CONFIG_KEY_SEND]([(RESUME, scratchpad.resume)])
        return scratchpad.resume[idx]         # 按编号取答案，直接返回！
# ② 或者有通用恢复值
v = scratchpad.get_null_resume(True)          # 消费型取值
if v is not None:
    assert len(scratchpad.resume) == idx, (scratchpad.resume, idx)
    scratchpad.resume.append(v)               # 记进便签本(下次同 idx 可复用)
    conf[CONFIG_KEY_SEND]([(RESUME, scratchpad.resume)])
    return v                                   # 返回，节点继续往下跑

最后补一个细节：为什么 interrupt_counter 是个函数而不是 self.idx += 1？看 _algo.py:1426-1439：

# _algo.py:1426
class LazyAtomicCounter:
    __slots__ = ("_counter",)
    def __init__(self) -> None:
        self._counter = None
    def __call__(self) -> int:
        if self._counter is None:
            with LAZY_ATOMIC_COUNTER_LOCK:          # 加锁，双重检查
                if self._counter is None:
                    self._counter = itertools.count(0).__next__   # 惰性建计数器
        return self._counter()                      # itertools.count 的 __next__ 是原子的

# 1. 读便签本定义与发牌逻辑
sed -n '8,19p'    libs/langgraph/langgraph/_internal/_scratchpad.py
sed -n '1280,1344p' libs/langgraph/langgraph/pregel/_algo.py
# 2. 完整跑一次"停→续"
python - <<'PY'
from langgraph.graph import StateGraph, START
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.types import interrupt, Command
from typing_extensions import TypedDict
class S(TypedDict):
    x: int
def node(s):
    ans = interrupt("确认?")
    return {"x": 1 if ans=="yes" else 0}
g=StateGraph(S); g.add_node("n",node); g.add_edge(START,"n")
app=g.compile(checkpointer=InMemorySaver())
cfg={"configurable":{"thread_id":"t1"}}
print("第一次:", list(app.stream({"x":0}, cfg)))        # 停，出 __interrupt__
print("恢复后:", list(app.stream(Command(resume="yes"), cfg)))  # 续，节点跑完
print("最终:", app.get_state(cfg).values)               # {'x': 1}
PY