@@ -54,6 +54,12 @@ builds the port again. Play in game holds the clip's anim on the running game's
 plays the build last injected, so a clip placed since the manifest was saved is refused until it
 is saved and injected again (`mhfu-port inject`).
 
+Used in names the moves that play a clip. Order by "Fits after the one on screen" sorts the list
+by how well each clip's first pose continues where the playing clip ends (the mean angle between
+the two poses, the body's heading left out), to find the next part of a chain: up to 10 degrees is
+good, up to 20 fair, past it poor. It rates poses only, so a part the engine blends into can score
+poor; the picker's Neighbours order lists clips by source number instead.
+
 ## A port's own moves
 
 An own move plays one clip on every body part through the framework's move player, with attacks of
@@ -74,6 +80,15 @@ moves module just built, so a new or edited move plays once the game has re-run
 A move asked while the monster has noticed the hunter but is not yet in combat waits for combat,
 so the "!" and the howl play out; Force beside the button plays it at once.
 
+Moves that hand to one another by Then are a sequence: the table groups them under the first,
+and the picked move's Sequence strip shows one chip per step. Add step after lists the clips,
+best fit after the step's clip first, and makes the one you click a new own move that follows it;
+Change clip, Remove step, Earlier, Later and Split here edit the chain, each one undo step; a
+pair move is shown but never edited here. Play sequence plays the steps back to back, each
+starting where the last stood, facing as it faced, and the Timeline's bar above the transport
+shows the steps (click one to pick it). Picking or playing anything else starts clips where
+they normally start.
+
 Under the moves are the rules (`[[rule]]`), each read as a sentence ("after the lunge for 20
 frames, within 1200, play stamp"): New rule plays the picked move once when the monster notices
 the hunter, and every field is a control, the part only for a flinch or a break, the mode only
 
@@ -11,6 +11,7 @@
 from __future__ import annotations
 
 import math
+from dataclasses import dataclass
 from typing import Protocol
 from weakref import WeakKeyDictionary
 
@@ -170,6 +171,20 @@ def travel_joints(scene: Scene) -> tuple[int, ...]:
     return leading_chain(scene.rig.parents) or root_joints(scene)
 
 
+@dataclass(frozen=True)
+class Carry:
+    """Where a step of a played sequence starts: the body turned `yaw` radians about y and moved
+    `shift` (x, z) on the ground, as the steps before it left it."""
+
+    yaw: float = 0.0
+    shift: tuple[float, float] = (0.0, 0.0)
+
+    def matrix(self) -> np.ndarray:
+        m = yaw_matrix(self.yaw)
+        m[0, 3], m[2, 3] = self.shift
+        return m
+
+
 def pose_at(
     scene: Scene,
     clip: Clip | None,
@@ -178,10 +193,12 @@ def pose_at(
     strip_root: bool = False,
     steer: Steer | None = None,
     speed: float = DEFAULT_SPEED,
+    carry: Carry | None = None,
 ) -> Pose:
-    """The rig at `frame`, turned as YAW turns while the clip plays (`yaw_at`); `strip_root`
-    holds the travel joints' location at frame 0, so the clip plays in place without dropping
-    the animal to its bind height."""
+    """The rig at `frame`, turned as YAW turns while the clip plays (`yaw_at`) and, under a
+    `carry`, where the steps before left the body; `strip_root` holds the travel joints'
+    location at frame 0, so the clip plays in place without dropping the animal to its bind
+    height."""
     if clip is None:
         return scene.bind_pose()
     curves = scene.curves(clip)
@@ -195,9 +212,34 @@ def pose_at(
     th = yaw_at(scene, clip, frame, steer, speed)
     if th:
         world = yaw_matrix(th) @ world
+    if carry is not None:
+        world = carry.matrix() @ world
     return Pose(scene.rig, float(frame), world, clip.slot)
 
 
+def carry_after(
+    scene: Scene,
+    clip: Clip,
+    frame: float,
+    then: Clip,
+    *,
+    strip_root: bool = False,
+    steer: Steer | None = None,
+    speed: float = DEFAULT_SPEED,
+    carry: Carry | None = None,
+) -> Carry:
+    """The carry that starts clip `then` where `clip` stands at `frame` (played under `steer` and
+    `carry`): facing as it faces, its first pose's root on the ground where the root is."""
+    root = travel_joints(scene)[-1]
+    end = pose_at(
+        scene, clip, frame, strip_root=strip_root, steer=steer, speed=speed, carry=carry
+    ).joints[root]
+    start = pose_at(scene, then, 0.0, strip_root=strip_root, speed=speed).joints[root]
+    yaw = (carry.yaw if carry is not None else 0.0) + yaw_at(scene, clip, frame, steer, speed)
+    turned = Carry(yaw).matrix() @ np.append(start, 1.0)
+    return Carry(yaw, (float(end[0] - turned[0]), float(end[2] - turned[2])))
+
+
 def yaw_matrix(th: float) -> np.ndarray:
     """A turn of `th` radians about y, positive the way YAW grows: +z toward +x."""
     yaw = np.eye(4)
 
@@ -25,7 +25,7 @@
 from .ground import Ground, point_cloud_geometry
 from .hitboxes import HitboxOverlay, Palette, Volume
 from .mesh import SkinnedMesh, default_pose
-from .playback import Playback, pose_at
+from .playback import Carry, Playback, pose_at
 from .skeleton import SkeletonOverlay
 
 OVERLAYS: tuple[tuple[str, Palette], ...] = (("hitboxes", "part"), ("attacks", "set"))
@@ -65,6 +65,8 @@ def __init__(self, ctx: moderngl.Context, scene: Scene) -> None:
         self.strip_root = False
         #: an own move's turn instead of the clip's
         self.steer: Steer | None = None
+        #: where the steps of a played sequence before this clip left the body
+        self.carry: Carry | None = None
 
     def pose(self, clip: Clip | None, frame: float = 0.0) -> None:
         self.clip, self.frame = clip, float(frame)
@@ -75,6 +77,7 @@ def pose(self, clip: Clip | None, frame: float = 0.0) -> None:
             strip_root=self.strip_root,
             steer=self.steer,
             speed=self.playback.speed,
+            carry=self.carry,
         )
         self.mesh.set_pose(p)  # bind included: the tail tip moves onto the tail
         self.skeleton.set_positions(p.joints)
@@ -88,7 +91,8 @@ def repose(self) -> None:
         self.pose(self.clip, self.frame)
 
     def play(self, clip: Clip | None, frame: float = 0.0) -> None:
-        """Binds `clip` to the transport, posed at `frame`."""
+        """Binds `clip` to the transport, posed at `frame`, where the clip normally starts."""
+        self.carry = None
         self.playback.set_clip(clip)
         if clip is None:
             self.pose(None)
@@ -258,6 +262,13 @@ def set_steer(self, steer: Steer | None) -> None:
             self.actor.steer = steer
             self.actor.repose()
 
+    def set_carry(self, carry: Carry | None) -> None:
+        """The port starts its clip where a played sequence's steps left it; the next clip played
+        starts where clips start."""
+        if self.actor is not None and self.actor.carry != carry:
+            self.actor.carry = carry
+            self.actor.repose()
+
     def set_pose(self, clip: Clip | None, frame: float = 0.0) -> None:
         if self.actor is not None:
             self.actor.pose(clip, frame)
 
@@ -1465,7 +1465,29 @@ def _advance_sequence(self) -> None:
         self.playing_step = None
         self._stepped = True
         if mv.after is not None:
-            self._play_step(mv.after)
+            self._play_after(mv.after)
+
+    def _play_after(self, name: str) -> None:
+        """Plays step `name` where the step on screen stands: facing as it faces, from its root."""
+        from mhfu_studio.monster.render.playback import carry_after
+
+        vp = self.vp
+        assert vp is not None and vp.actor is not None and vp.clip is not None
+        a, clip, phase = vp.actor, vp.clip, vp.playback.phase
+        was = a.steer, a.carry
+        self._play_step(name)
+        if self.playing_step == name and vp.clip is not None:
+            carry = carry_after(
+                a.scene,
+                clip,
+                phase,
+                vp.clip,
+                strip_root=a.strip_root,
+                steer=was[0],
+                speed=vp.playback.speed,
+                carry=was[1],
+            )
+            vp.set_carry(carry)
 
     def take_stepped(self) -> bool:
         """Whether the played sequence went on (or ended) since the last ask."""
 
@@ -10,7 +10,9 @@
 from mhfu_studio.monster.core.scene import Scene
 from mhfu_studio.monster.render.playback import (
     GAME_HZ,
+    Carry,
     Playback,
+    carry_after,
     leading_chain,
     pose_at,
     root_joints,
@@ -187,3 +189,24 @@ def test_own_moves_steer_the_preview() -> None:
     port = '[port]\nname = "t"\nhost_species = 75\npac = "t.bin"\n[source]\nmodel = 1\n'
     sc.attach_manifest(manifest.loads(port + "[clips.c]\nslot = 5\nturn = -45.0\n"))
     assert end_turn(sc, slot) == pytest.approx(-45.0, abs=0.1), "the manifest's turn wins"
+
+
+def test_a_carry_starts_a_clip_where_the_last_one_stood(rig: Scene) -> None:
+    from mhfu_port.manifest import Steer
+    from mhfu_studio.monster.render.playback import yaw_matrix
+
+    walk, root = rig.clip(1), travel_joints(rig)[-1]
+    fixed = Steer("fixed", angle=90.0, frames=10)
+    end = pose_at(rig, walk, 20.0, steer=fixed, speed=2.0).joints
+    c = carry_after(rig, walk, 20.0, walk, steer=fixed, speed=2.0)
+    assert c.yaw == pytest.approx(math.pi / 2) and abs(c.shift[0]) > 50.0
+    plain = pose_at(rig, walk, 0.0).joints
+    start = pose_at(rig, walk, 0.0, carry=c).joints
+    assert np.allclose(start[root][[0, 2]], end[root][[0, 2]], atol=1e-6), "from the same spot"
+    turned = (yaw_matrix(c.yaw)[:3, :3] @ (plain - plain[root]).T).T
+    assert np.allclose(start - start[root], turned, atol=1e-6), "facing the same way"
+    assert np.allclose(pose_at(rig, walk, 0.0, carry=Carry()).joints, plain)
+    again = carry_after(rig, walk, 20.0, walk, steer=fixed, speed=2.0, carry=c)
+    assert again.yaw == pytest.approx(math.pi), "the turns add up"
+    far = pose_at(rig, walk, 20.0, steer=fixed, speed=2.0, carry=c).joints[root]
+    assert np.allclose(pose_at(rig, walk, 0.0, carry=again).joints[root][[0, 2]], far[[0, 2]])
@@ -3,6 +3,7 @@
 """Sequences on screen: the Moves strip and picker, the Timeline's bar, playing a chain, the Clips
 sort, over the synthetic port."""
 
+import math
 from pathlib import Path
 from typing import Any
 
@@ -11,12 +12,16 @@
 from mhfu_port import continuity
 from mhfu_port.manifest import Clip
 from mhfu_studio.monster.clip_browser import SourceClip
+from mhfu_studio.monster.core.scene import Scene
 from mhfu_studio.monster.panels.clips import ClipsPanel
 from mhfu_studio.monster.panels.moves import MovesPanel
 from mhfu_studio.monster.panels.timeline import TimelinePanel
+from mhfu_studio.monster.render.playback import pose_at
 from mhfu_studio.monster.workspace import MonsterWorkspace
 from mhfu_studio.shell.studio import Studio
 from mhfu_studio.ui import kit
+from mhp_formats.anim import Channel, Keyframe, Track, quantize
+from mhp_formats.anim import Clip as AnimClip
 from PySide6.QtCore import QPoint, Qt
 from PySide6.QtTest import QTest
 
@@ -271,6 +276,64 @@ def test_the_timeline_follows_the_sequence(timeline: TimelinePanel, ws: MonsterW
     assert timeline.steps.picked == "a_2" and timeline.frame.text() == "frame 0.0 / 6"
 
 
+# ---- the body carried across steps ----
+
+
+@pytest.fixture
+def walking(ws: MonsterWorkspace, synthetic_pac: bytes) -> MonsterWorkspace:
+    """`ws` on a rig whose clips both walk the root 100 units forward by frame 10; a turns 90
+    degrees (fixed steer), a_2 and a_3 do not."""
+    assert ws.doc is not None
+    scene = Scene.from_bytes(synthetic_pac, "t", manifest=ws.doc.manifest)
+    track = Track([Channel(0x100, [Keyframe(0, 0), Keyframe(quantize("loc", 100.0), 10)])])
+    for c in scene.clips:
+        c.source = AnimClip([track, Track(), Track()])
+    ws.load(scene, ws.doc)
+    ws.select_move("a")
+    assert ws.set_steer(turn="fixed", angle=90.0)
+    return ws
+
+
+def test_a_sequence_carries_the_body(walking: MonsterWorkspace) -> None:
+    ws = walking
+    vp = ws.vp
+    assert vp is not None and vp.actor is not None and vp.clip is not None
+    first, speed = vp.clip, vp.playback.speed
+    ws.play_sequence()
+    assert vp.actor.carry is None, "the first step starts where clips start"
+    at = pose_at(vp.actor.scene, first, first.frames, steer=vp.actor.steer, speed=speed).joints[0]
+    ws.frame(1.0)
+    c = vp.actor.carry
+    assert ws.move == "a_2" and c is not None and c.yaw == pytest.approx(math.pi / 2)
+    start = pose_at(vp.actor.scene, vp.clip, 0.0, carry=c).joints[0]
+    assert abs(at[0]) > 90.0 and np.allclose(start, at, atol=1e-6), "from where a ended, turned"
+    ws.frame(1.0)
+    c2 = vp.actor.carry
+    assert ws.move == "a_3" and c2 is not None
+    assert c2.yaw == pytest.approx(math.pi / 2), "a_2 does not turn"
+    assert c2.shift[0] > c.shift[0] + 50.0, "and walked on from there"
+
+
+def test_anything_else_played_starts_where_clips_start(walking: MonsterWorkspace) -> None:
+    ws = walking
+    vp = ws.vp
+    assert vp is not None and vp.actor is not None
+    ws.play_sequence()
+    ws.frame(1.0)
+    assert vp.actor.carry is not None
+    ws.select_move("a_2")  # the same step, picked again
+    assert vp.actor.carry is None
+    ws.play_sequence()
+    ws.frame(1.0)
+    assert vp.actor.carry is not None
+    ws.play_slot(2)
+    assert vp.actor.carry is None
+    ws.play_sequence()
+    ws.frame(1.0)
+    ws.play_sequence()
+    assert vp.actor.carry is None, "again from the head"
+
+
 # ---- the Clips table ----