源码在 types.py:758，本体就是个 dataclass，四个字段：

# types.py:758
@dataclass(**_DC_KWARGS)
class Command(Generic[N], ToolOutputMixin):
    graph: str | None = None                       # 这条命令发给哪张图
    update: Any | None = None                      # 要应用到状态的更新
    resume: dict[str, Any] | Any | None = None     # 恢复中断用（阶段7 human-in-loop）
    goto: Send | Sequence[Send | N] | N = ()       # 下一步去哪（节点名 / Send / 它们的列表）

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

update 允许各种类型，但引擎只吃"(通道名, 值) 的二元组序列"。转换器是 _update_as_tuples，types.py:793：

# types.py:793
def _update_as_tuples(self) -> Sequence[tuple[str, Any]]:
    if isinstance(self.update, dict):
        return list(self.update.items())                       # ① dict → 直接拆成 items
    elif isinstance(self.update, (list, tuple)) and all(
        isinstance(t, tuple) and len(t) == 2 and isinstance(t[0], str)
        for t in self.update
    ):
        return self.update                                     # ② 本就是 (str, v) 列表 → 原样
    elif keys := get_cached_annotated_keys(type(self.update)):
        return get_update_as_tuples(self.update, keys)         # ③ Pydantic/dataclass → 按字段抽
    elif self.update is not None:
        return [("__root__", self.update)]                     # ④ 其它非空 → 塞进 __root__ 通道
    else:
        return []                                              # ⑤ None → 空

节点返回或用户传入的 Command，最终由 map_command 翻译成一串"通道写入"。pregel/_io.py:56：

# pregel/_io.py:56
def map_command(cmd: Command) -> Iterator[tuple[str, str, Any]]:
    if cmd.graph == Command.PARENT:
        raise InvalidUpdateError("There is no parent graph")   # ← 边界：顶层没有父图
    if cmd.goto:
        if isinstance(cmd.goto, (tuple, list)):
            sends = cmd.goto
        else:
            sends = [cmd.goto]                                 # 单个也归一成列表
        for send in sends:
            if isinstance(send, Send):
                yield (NULL_TASK_ID, TASKS, send)              # goto 是 Send → 写 TASKS 通道
            elif isinstance(send, str):
                yield (NULL_TASK_ID, f"branch:to:{send}", START)  # goto 是节点名 → 写触发通道
            else:
                raise TypeError(f"In Command.goto, expected Send/str, got {type(send).__name__}")
    if cmd.resume is not None:
        yield (NULL_TASK_ID, RESUME, cmd.resume)               # resume → 写 RESUME 通道
    if cmd.update:
        for k, v in cmd._update_as_tuples():                   # update → 每个字段写一个通道
            yield (NULL_TASK_ID, k, v)

Command 最强的能力是跨图跳转：子图里的节点可以说"我要交接给父图里的某个节点"。它靠一个特殊异常 ParentCommand 往上冒泡。errors.py:129：

# errors.py:129
class ParentCommand(GraphBubbleUp):
    args: tuple[Command]
    def __init__(self, command: Command) -> None:
        super().__init__(command)

def travel_advisor(state) -> Command[Literal["hotel_advisor"]]:
    # 分诊 agent 决定：更新一句话，然后把控制权交给酒店 agent
    return Command(
        update={"messages": [AIMessage("帮你转接酒店顾问")]},
        goto="hotel_advisor",
        graph=Command.PARENT,     # ← 跳出当前子图，交给父图里的兄弟 agent
    )

两者最终都翻译成"往 branch:to:X 通道写值"（对比 Day 14 L05 和今天 L04，你会发现落点一样）。区别只在"路由逻辑写在哪、能不能跨图"：

✋ 10 分钟动手

# 1. 读 Command 定义与 _update_as_tuples
sed -n '758,809p' libs/langgraph/langgraph/types.py

# 2. 读 map_command（Command 落地的唯一入口）
sed -n '56,79p' libs/langgraph/langgraph/pregel/_io.py

# 3. 单图内用 Command 路由
python - <<'PY'
from langgraph.graph import StateGraph, START, END
from langgraph.types import Command
from typing import TypedDict, Literal
class S(TypedDict): n: int
def a(state) -> Command[Literal["b","__end__"]]:
    return Command(update={"n": state["n"]+1},
                   goto="b" if state["n"] < 2 else END)
def b(state) -> Command[Literal["a"]]:
    return Command(update={"n": state["n"]+10}, goto="a")
g = StateGraph(S); g.add_node("a", a); g.add_node("b", b)
g.add_edge(START, "a")
print(g.compile().invoke({"n": 0}))   # 观察 a/b 互相 goto 直到 n>=2
PY