@@ -69,7 +69,8 @@ a handle for the end, which drags the clip's `turn`, or a fixed steer's angle, i
 Play in game saves, writes the port's clips and moves modules to the memory stick's `mods/lib` as
 `mhfu-port inject` does, and asks the running port to play the move by name; it refuses a move
 whose clip sits in another anim than in the saved manifest, since the game holds the build
-injected from the file. A port defined before takes a new or renamed move once its mod reloads.
+injected from the file. It writes only the modules that changed, and asks for the move from the
+moves module just built, so a new or edited move plays once the game has re-run that module.
 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.
 
 
@@ -11,7 +11,7 @@
 from typing import TYPE_CHECKING
 
 from mhfu import inject
-from mhfu_port import build, layout
+from mhfu_port import build, layout, moves
 from mhfu_port.data import Data
 from mhfu_port.manifest import Manifest
 
@@ -21,22 +21,25 @@
     from mhfu.live.session import Session
 
 
-def deploy(m: Manifest, games: Data, mods: Path) -> list[Path]:
-    """`m` built as it is, its modules written into `mods/lib`, and `mhfu_port.lua` kept in
-    step; what was written. The game re-runs a changed module."""
+def deploy(m: Manifest, games: Data, mods: Path) -> tuple[list[Path], int]:
+    """`m` built as it is, its modules written into `mods/lib` where they changed, and
+    `mhfu_port.lua` kept in step: what was written, and the build of the moves module now on the
+    stick, the one the port must run. The game re-runs a changed module."""
     from mhfu_port.cli.build import modules  # the writer `mhfu-port inject` uses
 
     out = modules(m, build.build(m, games), mods / layout.LIB, games)
     lib = runtime.sync_library(mods, runtime.library())
-    return out if lib is None else [*out, lib]
+    text = (mods / layout.LIB / moves.module_name(m)).read_text(encoding="utf-8")
+    return (out if lib is None else [*out, lib]), moves.build_of(text)
 
 
-def play_own(s: Session, name: str, force: bool = False) -> bool:
+def play_own(s: Session, name: str, force: bool = False, build: int = 0) -> bool:
     """`mhfu.live.moves.play_own`: False when no port rides the big monster or it has no own
-    move `name`; `force` plays it at once even before combat. The seam the tests fake."""
-    from mhfu.live import moves
+    move `name`; `force` plays it at once even before combat; `build` waits for that moves
+    module. The seam the tests fake."""
+    from mhfu.live import moves as live
 
-    return moves.play_own(s, name, force=force)
+    return live.play_own(s, name, force=force, build=build)
 
 
 class Running:
 
@@ -177,7 +177,7 @@ def __init__(self, data: Data | None = None, intel_root: Path | None = None) ->
         #: the running game, for Play in game
         self.game_session: Callable[[], AbstractContextManager[Session]] = clip_game.attached
         #: asks the running port for an own move (Play in game in Moves)
-        self.play_own: Callable[[Session, str, bool], bool] = move_game.play_own
+        self.play_own: Callable[[Session, str, bool, int], bool] = move_game.play_own
         self.game_running: Callable[[], bool] = move_game.Running()
         self._reset()
 
@@ -1888,9 +1888,9 @@ def play_move_in_game(self, force: bool = False) -> None:
             if clip is not None:
                 self.entry_in_game(doc.manifest.clips[clip].id)
             doc.save()
-            sent = move_game.deploy(doc.manifest, self.games(), self.mods_dir())
+            sent, build = move_game.deploy(doc.manifest, self.games(), self.mods_dir())
             with self.game_session() as s:
-                took = self.play_own(s, name, force)
+                took = self.play_own(s, name, force, build)
         except (LookupError, OSError, ValueError, DebuggerError) as e:
             self.message = f"not played in the game: {e}"
             return
@@ -1900,10 +1900,12 @@ def play_move_in_game(self, force: bool = False) -> None:
                 " own move by that name"
             )
             return
-        where = _home(sent[0].parent) if sent else "the memory stick"
-        self.message = (
-            f"{name} plays in the game; saved, {', '.join(p.name for p in sent)} sent to {where}"
+        news = (
+            f"{', '.join(p.name for p in sent)} sent to {_home(sent[0].parent)}"
+            if sent
+            else "the memory stick's modules were current"
         )
+        self.message = f"{name} plays in the game; saved, {news}"
 
 
 def _roots() -> tuple[Path | None, ...]:
 
@@ -41,8 +41,8 @@ def zinogre(
     ws.game_session = lambda: nullcontext("session")  # type: ignore[assignment,arg-type,return-value]
     ws.game_running = lambda: True
 
-    def play_own(s: Any, name: str, force: bool) -> bool:
-        assert s == "session"
+    def play_own(s: Any, name: str, force: bool, build: int) -> bool:
+        assert s == "session" and build > 0
         asked.append((name, force))
         return True
 
@@ -80,18 +80,19 @@ def test_saves_deploys_and_asks(
     assert moves.module_name(m) in ws.message
     ws.play_move_in_game(force=True)
     assert asked[-1] == (name, True)
+    assert ws.message.endswith("saved, the memory stick's modules were current")
 
 
 def test_not_taken(zinogre: MonsterWorkspace) -> None:
     name, _ = own_and_pair(zinogre)
     zinogre.select_move(name)
-    zinogre.play_own = lambda s, n, f: False
+    zinogre.play_own = lambda s, n, f, b: False
     zinogre.play_move_in_game()
     assert zinogre.message.startswith(f"the game did not take {name}: no port rides")
 
 
 def test_bridge_missing(zinogre: MonsterWorkspace) -> None:
-    def play_own(s: Any, name: str, force: bool) -> bool:
+    def play_own(s: Any, name: str, force: bool, build: int) -> bool:
         raise TimeoutError("no ack from cli_bridge.lua")
 
     zinogre.select_move(own_and_pair(zinogre)[0])
@@ -136,14 +137,27 @@ def test_moved_clip_refused(zinogre: MonsterWorkspace, asked: list[tuple[str, bo
 def test_the_seam(monkeypatch: pytest.MonkeyPatch) -> None:
     seen: list[tuple[object, ...]] = []
 
-    def play_own(s: object, name: str, **kw: bool) -> bool:
+    def play_own(s: object, name: str, **kw: object) -> bool:
         seen.append((s, name, kw))
         return True
 
     monkeypatch.setattr(live_moves, "play_own", play_own)
     assert move_game.play_own("s", "stamp") is True  # type: ignore[arg-type]
-    assert move_game.play_own("s", "stamp", force=True) is True  # type: ignore[arg-type]
-    assert seen == [("s", "stamp", {"force": False}), ("s", "stamp", {"force": True})]
+    assert move_game.play_own("s", "stamp", force=True, build=7) is True  # type: ignore[arg-type]
+    assert seen == [
+        ("s", "stamp", {"force": False, "build": 0}),
+        ("s", "stamp", {"force": True, "build": 7}),
+    ]
+
+
+def test_a_stale_module(zinogre: MonsterWorkspace) -> None:
+    def play_own(s: Any, name: str, force: bool, build: int) -> bool:
+        raise live_moves.Stale(f"the port does not run moves module build {build:08X}")
+
+    zinogre.select_move(own_and_pair(zinogre)[0])
+    zinogre.play_own = play_own
+    zinogre.play_move_in_game()
+    assert zinogre.message.startswith("not played in the game: the port does not run moves")
 
 
 def test_running_scans_at_most_every_ttl(monkeypatch: pytest.MonkeyPatch) -> None:
 
@@ -136,6 +136,13 @@ hold, enters its own move's carrier instead of `(4,x)`, and the move plays from
 frame. `force = true` plays a rule's move past the notice wait. `ports/README.md` "Moves and
 rules" has the manifest's side.
 
+## Calling the game from C
+
+C calls a game function through `mhfu_call(fn, a0, ...)` (`mhfu/call.h`, word arguments only).
+The game's VFPU code stores quads into its stack frame, which needs 16-byte alignment, and
+psp-gcc keeps frames at 8: a direct call halts the game at the first such store.
+`tests/test_engine_calls.py` refuses one.
+
 ## Tests
 
 `uv run pytest framework` compiles framework sources for the host and runs the Lua against the
 
@@ -369,8 +369,11 @@ end
 --- it starts at the monster's next AI frame, its clip on every body part, its attacks and steer
 --- as declared, and its `after` follows in C when it ends on its clip, its length or a wall.
 --- Asked while the monster's notice runs (mhfu.monster_state), it waits for combat unless
---- `opts.force`. A scripted pair move ends here. False while the seam is not live.
+--- `opts.force`. A scripted pair move ends here. False while the seam is not live; false,
+--- "stale" when `opts.build` (not 0) is not the build of the moves module the port runs.
 function Port:move(name, opts)
+  local want = opts ~= nil and opts.build or 0
+  if want ~= 0 and not (self._made and self._made.build == want) then return false, "stale" end
   local mv = self.moves[name]
   if not is_own(mv) then
     log("[port:%s] move('%s'): not an own move", self.name, tostring(name))
 
@@ -27,12 +27,12 @@ local CMD_CLEAR = 3
 local CMD_MOVE  = 4                   -- the MOVE struct in the block, on SLOT's monster
 local ARG_OWN   = 1                   -- ...or, with this ARG bit, the port's own move NAME
 local ARG_FORCE = 2                   -- ...played past the monster's notice
+local STALE     = 2                   -- RESULT: the port's moves module is not build ARG2 yet
 
 -- loaded before the tick is wrapped below, so the library's mhfu_tick is the one wrapped
 local has_port, port_lib = pcall(require, "mhfu_port")
 local PORTS = has_port and type(port_lib) == "table" and port_lib or nil
 
-local last_seq   = -1
 local g_force    = nil                 -- forced action id, or nil
 local g_ent      = nil                 -- the entity it is forced on
 local g_port     = nil                 -- the port that latches it, or nil for the own hook
@@ -117,11 +117,11 @@ end
 -- global (not local) so the chained wrapper resolves the FRESH definition after a
 -- hot-reload instead of a stale captured upvalue
 function cli_bridge_tick()
-  -- poll the command block (only act on a new seq)
+  -- poll the command block: a SEQ not yet in ACK is new, and a reload of this script finds the
+  -- ACK in the block, so it never applies a command twice
   if mhfu.read_u32(BR + CB.MAGIC) == MAGIC then
     local seq = mhfu.read_u32(BR + CB.SEQ)
-    if seq ~= last_seq then
-      last_seq = seq
+    if seq ~= mhfu.read_u32(BR + CB.ACK) then
       local cmd = mhfu.read_u32(BR + CB.CMD)
       local a0  = mhfu.read_u32(BR + CB.SLOT)
       local a1  = mhfu.read_u32(BR + CB.ARG)   -- action id / on-off
@@ -140,9 +140,12 @@ function cli_bridge_tick()
       elseif cmd == CMD_MOVE and (a1 & ARG_OWN) ~= 0 then
         local ent = entity(a0)
         local p = ent and port_of(ent)
-        local ok = p and p:move(name_at(BR + CB.NAME, CB.NAME_COUNT),
-                                { force = (a1 & ARG_FORCE) ~= 0 })
-        mhfu.write_u32(BR + CB.RESULT, ok and 1 or 0)
+        local ok, why = false, nil
+        if p then
+          ok, why = p:move(name_at(BR + CB.NAME, CB.NAME_COUNT),
+                           { force = (a1 & ARG_FORCE) ~= 0, build = mhfu.read_u32(BR + CB.ARG2) })
+        end
+        mhfu.write_u32(BR + CB.RESULT, ok and 1 or why == "stale" and STALE or 0)
       elseif cmd == CMD_MOVE then
         local ent = entity(a0)
         -- a refused move leaves the block's PENDING and STARTED as they were
 
@@ -60,10 +60,11 @@ def _move_stop(self) -> bool:
     def gate(self, slot: int) -> int:
         return self.mem.get(self.slots[slot] + GATE, 0)
 
-    def send(self, cmd: int, slot: int = 1, arg: int = 0) -> None:
+    def send(self, cmd: int, slot: int = 1, arg: int = 0, arg2: int = 0) -> None:
         """Write one command and run a tick; the script acks it."""
         self.seq += 1
         words = {CB.MAGIC: MAGIC, CB.SEQ: self.seq, CB.CMD: cmd, CB.SLOT: slot, CB.ARG: arg}
+        words[CB.ARG2] = arg2
         self.mem.update({BR + at: value for at, value in words.items()})
         self.tick()
         assert self.mem[BR + CB.ACK] == self.seq
@@ -98,6 +99,7 @@ def test_clear_releases_the_action(game):
   release = function(self) self.log[#self.log + 1] = "release" end,
   move = function(self, name, opts)
     self.log[#self.log + 1] = "move " .. name .. (opts.force and " forced" or "")
+    if opts.build ~= 0 and opts.build ~= 7 then return false, "stale" end
     return name == "stamp"
   end } } }"""
 
@@ -156,13 +158,21 @@ def test_move_plays_the_block_spec_on_the_slot(game):
 def test_own_move_by_name_through_the_port():
     game = Game(PORT_LIB % Game().slots[1])
 
-    def own(name: str, slot: int = 1, arg: int = 1) -> int:
+    def own(name: str, slot: int = 1, arg: int = 1, build: int = 0) -> int:
         raw = name.encode().ljust(CB.NAME.count or 0, b"\0")
         game.mem.update({BR + CB.NAME + i: c for i, c in enumerate(raw)})
-        game.send(MOVE, slot=slot, arg=arg)
+        game.send(MOVE, slot=slot, arg=arg, arg2=build)
         return game.mem[BR + CB.RESULT]
 
     assert (own("stamp"), own("nope"), own("stamp", slot=2), own("stamp", arg=3)) == (1, 0, 0, 1)
+    assert (own("stamp", build=7), own("stamp", build=8)) == (1, 2)
     log = game.lua.eval("package.loaded.mhfu_port.ports.zin.log")
-    assert list(log.values()) == ["move stamp", "move nope", "move stamp forced"]
+    assert list(log.values())[:3] == ["move stamp", "move nope", "move stamp forced"]
     assert game.moves == []
+
+
+def test_a_reload_applies_nothing_twice(game):
+    game.send(MOVE, slot=2)
+    game.lua.execute(SCRIPT.read_text())
+    game.tick()
+    assert game.moves == [(game.slots[2], BR + CB.MOVE)]
@@ -549,19 +549,22 @@ def test_own_moves(lua: Any, tmp_path: Path) -> None:
 function mhfu.em_moves_clear() SEAM.moves = {}; return true end
 function mhfu.em_play(ent, slot) return SEAM.moves[slot] ~= nil end
 function mhfu.em_rule(slot, r) SEAM.rules[slot] = r; return true end
-package.loaded.z_moves = { moves = { stamp = { entry = 46 } }, rules = {} }
+package.loaded.z_moves = { build = 1, moves = { stamp = { entry = 46 } }, rules = {} }
 local P = require("mhfu_port")
 P.mod("z_rig", function(P) P.define{ name = "z", species = 75 } end)
 P.ports.z.ent = ENT
 ticks(1)
 assert(not P.ports.z:move("probe"))
+assert(select(2, P.ports.z:move("stamp", { build = 2 })) == "stale")
 -- a new build's module re-ran in place: the next tick redefines the port from it and re-arms
-package.loaded.z_moves = { moves = { stamp = { entry = 46 }, probe = { entry = 47 } }, rules = {} }
+package.loaded.z_moves = {
+  build = 2, moves = { stamp = { entry = 46 }, probe = { entry = 47 } }, rules = {},
+}
 ticks(2)
 local z = P.ports.z
 assert(z.ent == ENT and count("moves module changed") == 1)
 assert(SEAM.moves[z._slot.probe].entry == 47)
-assert(z:move("probe"))
+assert(z:move("probe", { build = 2 }))
 ticks(2)
 assert(count("moves module changed") == 1, "once per new module")
 """
 
@@ -42,7 +42,7 @@ def run_build(args: argparse.Namespace) -> int:
     out: Path = args.out or Path(m.port.pac)
     written = modules(m, built, out.parent, games)
     out.write_bytes(built.pac)
-    print(f"wrote {out}, {', '.join(map(str, written))}\n{built.summary.text()}")
+    print(f"wrote {out}, {_listed(written)}\n{built.summary.text()}")
     return 0
 
 
@@ -56,14 +56,18 @@ def run_inject(args: argparse.Namespace) -> int:
     path = inject.write_relocate_bytes(
         built.pac, host, args.dir, orig=games.fu.read(host), name=m.port.pac
     )
-    print(f"wrote {path}, {', '.join(map(str, written))}\n{built.summary.text()}")
+    print(f"wrote {path}, {_listed(written)}\n{built.summary.text()}")
     return 0
 
 
+def _listed(written: list[Path]) -> str:
+    return ", ".join(map(str, written)) or "the modules unchanged"
+
+
 def modules(m: manifest.Manifest, built: Built, where: Path, games: data.Data) -> list[Path]:
-    """Write the port's clips and moves modules into `where`, each whole: the game reloads a
-    module on change. Raises `ManifestError` for a move the moves module cannot carry, before
-    either is written."""
+    """Write the port's clips and moves modules into `where`, each whole and only when it
+    changed, since the game re-runs a module that changed on disk; those written. Raises
+    `ManifestError` for a move the moves module cannot carry, before either is written."""
     known = moves.records(games.fu, m.port.host_species)
     texts = {
         layout.module_name(m): layout.lua(m, built.layout),
@@ -73,6 +77,8 @@ def modules(m: manifest.Manifest, built: Built, where: Path, games: data.Data) -
     out = []
     for name, text in texts.items():
         path = where / name
+        if path.is_file() and path.read_text(encoding="utf-8") == text:
+            continue
         tmp = path.with_name(path.name + ".tmp")
         tmp.write_text(text, encoding="utf-8")
         tmp.replace(path)