@@ -98,8 +98,10 @@ block's `in` or to a move's `play`; a move's `while playing` starts a rule, and
 move's `after`. The palette is `mhfu_port.behaviour.KINDS`. Watch the game, in the header, reads
 the running game once a second while the tab is shown and marks each frame and trigger with how
 often the game fired its rules (`7×`; a frame lights up when its count rises): the game must run
-this port's rules as Play in game sends them, and the header says when it does not. The tab keeps
-its own docks; Findings stays open across tabs.
+this port's rules as Play in game sends them, and the header says when it does not. On a
+Signal trigger, Fire raises that signal in the running game, once Watch the game has found it: the
+rules' counts then show whether their conditions held. It is no edit and has no undo step. The tab
+keeps its own docks; Findings stays open across tabs.
 
 Effect blocks (violet) change the monster's counters and flags when their path fires. A path may
 end at an effect with nothing to play: it applies its effects, keeps its `#n` on that block, and
 
@@ -63,6 +63,7 @@
 ORDER_HINT = (
     "Right-click a block to insert one · Delete removes · drag a frame to reorder · wire in Canvas"
 )
+FIRE_TIP = "Raises {} in the running game now; the rules' counts show whether their conditions held"
 SCOPED = "Wire by dragging ports in All, Canvas"
 UNPLACED = "A rule with no move yet is checked by nothing, so it has no place to move"
 CROSSED = "; a rule moves only among its own trigger's rules, the others keep their places"
@@ -112,6 +113,12 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
             " frame up to raise it",
             on=self._add_rule,
         )
+        self.fire = kit.button(
+            "Fire",
+            tip=FIRE_TIP,
+            on=studio.act("fire in the game", self._fire),
+            icon="ph.lightning",
+        )
         self.mode = kit.Segmented(
             [(ORDER, "In order"), (CANVAS, "Canvas")],
             tip="All rules: each as a framed row in the order they are checked, or the free"
@@ -182,6 +189,7 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
                 self.hint,
                 self.mode,
                 self.add_rule,
+                self.fire,
                 self.fit,
                 self.spread,
                 self.watch,
@@ -516,8 +524,23 @@ def _marks(self) -> None:
         if self.ws.watch.lit():
             self.glow.start(round(rule_game.FLASH * 1000) + 50)
 
+    def _fire(self) -> None:
+        """Raises the scoped trigger in the running game; the game is not the document, so there
+        is no undo step."""
+        t = self._current()
+        if t is not None:
+            self.ws.fire(t)
+
     def _status(self) -> None:
-        """The header's words on the watch, and the outline's totals."""
+        """The header's words on the watch, Fire's state, and the outline's totals."""
+        t = self._current()
+        self.fire.setVisible(t is not None and t.kind in rule_game.FIRE)
+        if t is not None and t.kind in rule_game.FIRE:
+            why = self.ws.fire_blocker(t)
+            self.fire.setEnabled(why is None)
+            self.fire.setToolTip(
+                FIRE_TIP.format(triggers.title(t)) if why is None else f"Fire: {why}"
+            )
         w = self.ws.watch
         self.live.setVisible(w.on)
         self.live.setText(w.status)
 
@@ -17,8 +17,9 @@
 from typing import TYPE_CHECKING, NamedTuple
 
 from mhfu.live import brain as live
-from mhfu.live.brain import Brain
+from mhfu.live.brain import Brain, Reader
 from mhfu_port import behaviour
+from mhfu_port.behaviour import Trigger
 from mhfu_port.manifest import Manifest, ManifestError
 from ppsspp_debug import DebuggerError
 
@@ -86,6 +87,21 @@ def match(brain: Brain, m: Manifest) -> dict[int, int] | str:
     return out
 
 
+Writer = Callable[[Reader, int, Manifest, Trigger], str]
+"""Raises a trigger in the game at the brain `cfg`; says what it did."""
+
+
+def _signal(s: Reader, cfg: int, m: Manifest, t: Trigger) -> str:
+    index = behaviour.signals(m)[t.name]
+    live.fire_signal(s, cfg, index)
+    return f"raised signal {t.name} in the game (board signal {index})"
+
+
+FIRE: dict[str, Writer] = {"on_signal": _signal}
+"""What Fire can raise in the running game, by the trigger's kind, and how: the one table. A
+trigger with no entry has no Fire button."""
+
+
 class Watch:
     """The state of Watch the game: `fires` (rank to count; None when not watching or there is
     nothing to show) and `status` say what the marks show, `lit` which frames flash."""
@@ -101,6 +117,24 @@ def __init__(self, clock: Callable[[], float] = time.monotonic) -> None:
         self._asked = self._lost = float("-inf")
         self._since: int | None = None
 
+    @property
+    def cfg(self) -> int | None:
+        """Where the brain was found in this attach; None until it is."""
+        return self._cfg
+
+    def blocker(self) -> str | None:
+        """Why the game cannot be written to now: it is not watched, not running, its brain not
+        found or not these rules. None when the brain is found and runs this port's rules."""
+        if not self.on:
+            return "turn on Watch the game first: it finds the framework in the game"
+        if self.fires is None or self._cfg is None:
+            return (
+                self.status
+                if self.status != READING
+                else "Watch the game has not read the game yet"
+            )
+        return None
+
     def set(self, on: bool) -> None:
         self.on = on
         self.reset()
 
@@ -31,6 +31,7 @@
 )
 from mhfu.files import Extracted
 from mhfu_port import continuity, layout, sequence, slots
+from mhfu_port.behaviour import Trigger
 from mhfu_port.data import Data
 from mhfu_port.manifest import MOVE_ATTACKS, AttackWindow, Manifest, ManifestError, Move
 from mhfu_port.manifest import Clip as ManifestClip
@@ -2035,6 +2036,27 @@ def poll_game(self) -> bool:
         """One step of Watch the game, at most one read a second; True when the marks changed."""
         return self.watch.poll(self.manifest, self.game_running(), self._ask_brain)
 
+    def fire_blocker(self, t: Trigger) -> str | None:
+        """Why Fire cannot raise `t` in the game now; None when it can."""
+        if self.manifest is None:
+            return "no port manifest open"
+        if t.kind not in rule_game.FIRE:
+            return "nothing in the studio raises this trigger"
+        return self.watch.blocker()
+
+    def fire(self, t: Trigger) -> None:
+        """Raises `t` in the running game (`rule_game.FIRE`) at the brain Watch the game found. The
+        game is not the document: no undo step, and the status says what was done."""
+        m, cfg, why = self.manifest, self.watch.cfg, self.fire_blocker(t)
+        if why is not None or m is None or cfg is None:
+            self.message = f"not fired: {why}"
+            return
+        try:
+            with self.game_session() as s:
+                self.message = rule_game.FIRE[t.kind](s, cfg, m, t)
+        except (LookupError, OSError, ValueError, DebuggerError) as e:
+            self.message = f"not fired: {e}"
+
     def _ask_brain(self, cfg: int | None) -> Future[rule_game.Read]:
         self._pool = self._pool or ThreadPoolExecutor(1)
         return self._pool.submit(self.read_brain, self.game_session, cfg)
 
@@ -331,3 +331,23 @@ def test_poll_says_whether_the_marks_changed(game: Game, m: Manifest) -> None:
     game.show(m, [1, 2, 3])
     game.poll(m, dt=1.0)
     assert game.poll(m, dt=0.2) is False
+
+
+def test_the_game_may_be_written_to_only_when_its_brain_is_found_and_runs_these_rules(
+    game: Game, m: Manifest
+) -> None:
+    off = rg.Watch()
+    assert off.blocker() is not None and "Watch the game" in off.blocker()  # type: ignore[operator]
+    assert game.watch.blocker() == "Watch the game has not read the game yet"
+    game.poll(m, running=False)
+    assert game.watch.blocker() == rg.NO_GAME
+    game.answer = lambda: rg.Read(None, None)
+    game.poll(m, running=True, dt=1.0)
+    game.poll(m, dt=1.0)
+    assert game.watch.blocker() == rg.NOT_FOUND
+    game.watch.reset()
+    game.feed(m, [1, 2, 3])
+    assert game.watch.blocker() is None and game.watch.cfg == CFG
+    m.behaviour.blocks["b4"].params["frames"] = 31
+    game.poll(m, dt=1.0)
+    assert game.watch.blocker() == rg.OTHER_BUILD
@@ -1,10 +1,57 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 # SPDX-FileCopyrightText: 2026 sp00ktober
-"""Every Qt test: no question blocks, and the GL context comes back (root conftest)."""
+"""Every Qt test: no question blocks, and the GL context comes back (root conftest). Also the
+game as the Behaviour tab's tests fake it."""
 
+from __future__ import annotations
+
+from collections.abc import Callable
+from contextlib import AbstractContextManager
 from typing import Any
 
 import pytest
+from mhfu.live.brain import UNLIMITED, Brain, Slot
+from mhfu_port import behaviour as model
+from mhfu_port.manifest import Manifest
+from mhfu_studio.monster import rule_game as rg
+
+CFG = 0x1000
+
+
+class FakeGame:
+    """The game: it runs the rules of `m` as sent, fired `fired` times each; `calls` is where
+    each read was told the brain was."""
+
+    def __init__(self, m: Manifest) -> None:
+        self.rules = model.compile(m)
+        self.fired = [0] * len(self.rules)
+        self.ticks = 100
+        self.calls: list[int | None] = []
+        #: a read to answer with instead of the brain, and whether the game runs other rules
+        self.answer: Callable[[], rg.Read] | None = None
+        self.other_build = False
+
+    def __call__(
+        self, attach: Callable[[], AbstractContextManager[Any]], cfg: int | None
+    ) -> rg.Read:
+        self.calls.append(cfg)
+        if self.answer is not None:
+            return self.answer()
+        slots = tuple(
+            Slot(
+                k,
+                rg.kind(r.on),
+                -1 if r.signal is None else r.signal,
+                bool(r.play),
+                r.min_frames,
+                r.cooldown + (7 if self.other_build else 0),
+                n,
+                UNLIMITED,
+                0,
+            )
+            for k, (r, n) in enumerate(zip(self.rules, self.fired, strict=True))
+        )
+        return rg.Read(CFG, Brain(CFG, self.ticks, slots))
 
 
 @pytest.fixture(autouse=True)