@@ -99,8 +99,9 @@ move's `after`. The palette is `mhfu_port.behaviour.KINDS`. Watch the game, in t
 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. 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
+Signal trigger, Fire raises that signal in the running game, once Watch the game has found it; on
+Enraged or Calmed it asks the game to enrage or calm the monster. 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
@@ -111,6 +112,11 @@ back. An On signal block fires when Lua raises that name: `port:fire("name")`; `
 reads a counter or flag and `port:var("name", v)` sets it. Hunter side ticks any of front, left,
 right, behind.
 
+Enrage and Calm down are effect blocks too (`port:enrage()` and `port:calm()` do the same from
+Lua). The Natural rage box in the Behaviour tab turns the monster's own anger off, so only those
+rage it. In the Parts dock, a severable part has Severable below HP %: its cut works only once the
+monster's HP is under that percent, 0 at any HP.
+
 ## Tests
 
 `uv run pytest apps/studio` runs offscreen; the Qt tests skip without the `qt` group, and the
 
@@ -302,6 +302,23 @@ def start(p: Param, taken: Collection[str] = ()) -> object:
 # edits
 
 
+def natural_rage(m: Manifest) -> bool:
+    """Whether the monster rages by its own anger (`[behaviour] natural_rage`)."""
+    return m.behaviour.natural_rage
+
+
+def set_natural_rage(doc: Edits, on: bool) -> str:
+    """The monster's own rage on or off; off, only an Enrage block (or Lua) rages it."""
+    if natural_rage(doc.manifest) == on:
+        return f"natural rage already {'on' if on else 'off'}"
+
+    def change(m: Manifest) -> None:
+        m.behaviour.natural_rage = on
+
+    doc.edit(change)
+    return f"natural rage {'on' if on else 'off'}"
+
+
 def add_block(doc: Edits, kind: str, at: Point) -> str:
     """A block of `kind` at `at`, with valid values."""
     if kind not in KINDS:
 
@@ -137,6 +137,12 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
             on=studio.act("spread nodes", lambda: ws.edit("", self._spread)),
             icon="ph.arrows-out-simple",
         )
+        self.rage = kit.check(
+            "Natural rage",
+            tip="On: the monster rages as the game has it, when its anger builds. Off: only an"
+            " Enrage block or a script rages it.",
+            on=self._natural_rage,
+        )
         self.watch = kit.check(
             "Watch the game",
             tip="Marks every rule with how often the running game has fired it, read once a"
@@ -177,7 +183,13 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
         side = QHBoxLayout(page)
         side.setContentsMargins(10, 8, 10, 8)
         side.setSpacing(10)
-        side.addWidget(self.outline)
+        left = QWidget()
+        col = QVBoxLayout(left)
+        col.setContentsMargins(0, 0, 0, 0)
+        col.setSpacing(6)
+        col.addWidget(self.outline, 1)
+        col.addWidget(self.rage)  # not in the header: with Watch and Fire it needs 1586 px
+        side.addWidget(left)
         main = QWidget()
         side.addWidget(main, 1)
         lay = QVBoxLayout(main)
@@ -213,6 +225,13 @@ def _spread(self) -> str:
             raise ManifestError("no port manifest open")
         return graph.spread(doc)
 
+    def _natural_rage(self, on: bool) -> None:
+        doc = self.ws.doc
+        if doc is not None:
+            self.studio.act(
+                "natural rage", lambda: self.ws.edit("", lambda: graph.set_natural_rage(doc, on))
+            )()
+
     def _scoped(self, key: str) -> None:
         """A row of the outline picked: that trigger's rules, framed to fit."""
         self.ws.scope = key
@@ -596,6 +615,7 @@ def sync(self) -> None:
             for o in graph.open_rules(m):
                 self._opens.setdefault(model.trigger_key(m, o), []).append(o)
             self._scope = None
+            kit.put(self.rage, graph.natural_rage(m))
         block = self.ws.take_block()
         if block in m.behaviour.blocks:
             self._reach(block)
 
@@ -132,7 +132,16 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
             "Name", tip="Names the picked part in your manifest", on=self._name_part
         )
         self.name_row = kit.row(self.part_name, self.name_button)
-        for w in (self.summary, self.orphans, self.parts, self.name_row):
+        self.sever = kit.integer(
+            tip="The picked part can be cut off only once the monster's HP is under this percent."
+            " 0: at any HP.",
+            lo=0,
+            hi=100,
+            on=self._sever_below,
+        )
+        self.sever_form = kit.Form()
+        self.sever_form.row("Severable below HP %", self.sever)
+        for w in (self.summary, self.orphans, self.parts, self.name_row, self.sever_form):
             parts.body.addWidget(w)
         lay.addWidget(parts)
 
@@ -338,6 +347,17 @@ def run() -> None:
 
         self._act("name part", run)
 
+    def _sever_below(self, pct: int) -> None:
+        part = self.ws.selected_part
+
+        def run() -> None:
+            sess = self._session()
+            if part is not None:
+                msg = f"part {part}: cut only below {pct}% HP" if pct else f"part {part}: any HP"
+                self.ws.edit(msg, lambda: sess.set_sever_below(part, pct))
+
+        self._act("sever below", run)
+
     def _pick_volume(self, index: object) -> None:
         if isinstance(index, int):
             pick = None if self.ws.selected_volume == index else index
@@ -582,6 +602,11 @@ def _parts(
         if naming and ws.selected_part is not None:
             self.name_button.setText(f"Name part {ws.selected_part}")
             kit.put(self.part_name, ws.part_name_buf)
+        part = ws.selected_part
+        cuts = sess is not None and part is not None and sess.severable(part)
+        self.sever_form.setVisible(cuts)
+        if sess is not None and part is not None and cuts:
+            kit.put(self.sever, sess.sever_below(part) or 0)
 
     def _volumes(self, sess: PartSession | None, port: bool) -> None:
         ws = self.ws
 
@@ -154,23 +154,45 @@ def over_capacity(self) -> int:
         """Volumes that would not fit in place at runtime."""
         return 0 if self.capacity is None else max(0, len(self.m.hurtboxes) - self.capacity)
 
+    def severable(self, index: int) -> bool:
+        found = self.part(index)
+        return found is not None and found[1].severable
+
+    def sever_below(self, index: int) -> int | None:
+        found = self.part(index)
+        return None if found is None else found[1].sever_below
+
+    def set_sever_below(self, index: int, pct: int | None) -> None:
+        """The HP percent under which part `index` can be cut off; 0 or none: at any HP. The
+        loader refuses one on a part that is not severable, or a second."""
+        found = self.part(index)
+        if found is None:
+            raise ManifestError(f"part {index} has no name yet: name it first")
+        name, want = found[0], pct or None
+        if want != found[1].sever_below:
+            self.doc.edit(lambda m: setattr(m.parts[name], "sever_below", want))
+
     def name_part(
         self,
         index: int,
         name: str,
         label: str = "",
-        severable: bool = False,
+        severable: bool | None = None,
         hitzone_row: int | None = None,
     ) -> None:
-        """Name accumulator `index`, replacing its old name."""
+        """Name accumulator `index`, replacing its old name; `severable` (and its HP percent)
+        stays as it was unless given."""
         name = check_name(name)
         clash = self.m.parts.get(name)
         if clash is not None and clash.index != index:
             raise ManifestError(f"part {name!r} already names slot {clash.index}")
+        old = self.part(index)
+        flag = bool(old and old[1].severable) if severable is None else severable
+        pct = old[1].sever_below if old and flag else None
 
         def apply(m: Manifest) -> None:
             m.parts = {n: p for n, p in m.parts.items() if p.index != index}
-            m.parts[name] = Part(index, hitzone_row, severable, label)
+            m.parts[name] = Part(index, hitzone_row, flag, label, pct)
 
         self.doc.edit(apply)
 
 
@@ -97,7 +97,17 @@ def _signal(s: Reader, cfg: int, m: Manifest, t: Trigger) -> str:
     return f"raised signal {t.name} in the game (board signal {index})"
 
 
-FIRE: dict[str, Writer] = {"on_signal": _signal}
+def _enrage(s: Reader, cfg: int, m: Manifest, t: Trigger) -> str:
+    live.set_rage(s, cfg, True)
+    return "asked the game to enrage the monster; nothing happens if it already is"
+
+
+def _calm(s: Reader, cfg: int, m: Manifest, t: Trigger) -> str:
+    live.set_rage(s, cfg, False)
+    return "asked the game to calm the monster; nothing happens if it already is"
+
+
+FIRE: dict[str, Writer] = {"on_signal": _signal, "on_enraged": _enrage, "on_calmed": _calm}
 """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."""
 
 
@@ -366,12 +366,17 @@ def test_the_palette_offers_every_kind(monkeypatch: pytest.MonkeyPatch) -> None:
 def test_the_zinogre_reads(ports: Path) -> None:
     m = manifest.load(ports / "zinogre.toml")
     r = B.read(m)
-    assert len(m.behaviour.blocks) == 36 and len(r.paths) == 16
-    assert sorted(n for ns in r.priority.values() for n in ns) == list(range(1, 17))
+    assert len(m.behaviour.blocks) == 39 and len(r.paths) == 17
+    assert sorted(n for ns in r.priority.values() for n in ns) == list(range(1, 18))
     assert r.loose == [] and r.refused == {} and r.capped is None
-    assert [p.blocks[-1] for p in r.paths if p.play is None] == ["b15", "b17", "b23"]
-    assert [p.play is None for p in r.paths] == [True] * 3 + [False] * 13, "bookkeeping runs first"
+    assert [p.blocks[-1] for p in r.paths if p.play is None] == ["b15", "b17", "b23", "b39"]
+    assert [p.play is None for p in r.paths] == [True] * 4 + [False] * 13, "bookkeeping runs first"
     assert model.names(m, "var") == ["flinches", "in_combat"]
+    enrage = r.paths[3]  # while charge_up plays: 120 frames, wait 250, enrage
+    assert (enrage.blocks, enrage.during) == (("b37", "b38", "b39"), "charge_up")
+    assert m.behaviour.blocks["b39"].kind == "enrage" and B.natural_rage(m)
+    charge = r.paths[13]  # the 2nd flinch, from idle: charge up
+    assert (charge.blocks[-1], charge.play) == ("b27", "charge_up")
     assert min(b.at[0] for b in m.behaviour.blocks.values()) == model.LEFT
     assert {w.dst for w in B.wires(m) if w.dst_port == "play"} >= {"move:flinch_head"}
     assert len(B.spots(m)) == len(m.moves)
 
@@ -35,6 +35,52 @@ def test_name_part(doc):
         s.name_part(3, "left wing")
 
 
+def test_a_rename_keeps_the_part_severable(doc):
+    d = doc()
+    s = P.PartSession(d)
+    s.name_part(3, "tail", severable=True)
+    s.name_part(3, "stump")
+    assert d.manifest.parts["stump"].severable and list(d.manifest.parts) == ["stump"]
+    s.name_part(3, "tail", severable=False)
+    assert not d.manifest.parts["tail"].severable
+
+
+def test_sever_below(doc):
+    d = doc("\n[parts.tail]\nindex = 3\nseverable = true\n[parts.head]\nindex = 1\n")
+    s = P.PartSession(d)
+    assert s.severable(3) and not s.severable(1) and s.sever_below(3) is None
+    before = d.manifest
+    s.set_sever_below(3, 50)
+    assert d.manifest.parts["tail"].sever_below == 50 and s.sever_below(3) == 50
+    s.set_sever_below(3, 50)
+    d.undo()
+    assert d.manifest == before, "the same value is no second step"
+    s.set_sever_below(3, 50)
+    s.set_sever_below(3, 0)
+    assert d.manifest.parts["tail"].sever_below is None
+    s.set_sever_below(3, 25)
+    s.name_part(3, "stump")
+    assert d.manifest.parts["stump"].sever_below == 25, "a rename keeps it"
+    s.name_part(3, "stump", severable=False)
+    assert d.manifest.parts["stump"].sever_below is None
+
+
+def test_sever_below_refusals(doc):
+    d = doc("\n[parts.tail]\nindex = 3\nseverable = true\n[parts.head]\nindex = 1\n")
+    s = P.PartSession(d)
+    with pytest.raises(ManifestError, match="sever_below goes with severable"):
+        s.set_sever_below(1, 50)
+    with pytest.raises(ManifestError, match="part 5 has no name yet"):
+        s.set_sever_below(5, 50)
+    with pytest.raises(ManifestError, match="HP percent, 1..100"):
+        s.set_sever_below(3, 101)
+    s.name_part(4, "wing", severable=True)
+    s.set_sever_below(3, 50)
+    with pytest.raises(ManifestError, match="the gate holds one"):
+        s.set_sever_below(4, 30)
+    assert d.manifest.parts["wing"].sever_below is None
+
+
 def test_grid(doc):
     d = doc(GRID)
     s = P.PartSession(d)
 
@@ -10,9 +10,10 @@
 from typing import Any
 
 import pytest
-from mhfu.live.brain import UNLIMITED, Brain, Slot
+from mhfu import addresses as a
+from mhfu.live.brain import RAGE_OFF, RAGE_ON, UNLIMITED, Brain, Slot
 from mhfu_port import behaviour as model
-from mhfu_port.behaviour import Block
+from mhfu_port.behaviour import Block, Trigger
 from mhfu_port.manifest import Manifest, ManifestError
 from mhfu_studio.monster import rule_game as rg
 from mhfu_studio.monster.document import PortDocument
@@ -351,3 +352,28 @@ def test_the_game_may_be_written_to_only_when_its_brain_is_found_and_runs_these_
     m.behaviour.blocks["b4"].params["frames"] = 31
     game.poll(m, dt=1.0)
     assert game.watch.blocker() == rg.OTHER_BUILD
+
+
+class Board:
+    """A session whose memory records the bytes written."""
+
+    def __init__(self) -> None:
+        self.mem = self
+        self.writes: list[tuple[int, int]] = []
+
+    def write_u8(self, address: int, value: int) -> None:
+        self.writes.append((address, value))
+
+
+@pytest.mark.parametrize(
+    ("kind", "byte"), [("on_enraged", RAGE_ON), ("on_calmed", RAGE_OFF)], ids=["enrage", "calm"]
+)
+def test_enraged_and_calmed_write_the_boards_rage_byte(m: Manifest, kind: str, byte: int) -> None:
+    s = Board()
+    said = rg.FIRE[kind](s, CFG, m, Trigger(kind, "event", kind))  # type: ignore[arg-type]
+    assert s.writes == [(CFG + int(a.EM_BLOCK.BOARD) + int(a.EM_BOARD.RAGE), byte)]
+    assert said.startswith("asked the game to ")
+
+
+def test_fire_has_an_entry_for_a_signal_enraged_and_calmed_only() -> None:
+    assert set(rg.FIRE) == {"on_signal", "on_enraged", "on_calmed"}
@@ -338,13 +338,14 @@ def test_the_zinogre_opens(
     ws.all_view = B.CANVAS  # a loaded document starts in order
     p = make(qtbot, ws)
     m = zin.manifest
-    assert len(m.behaviour.blocks) == 36 and len(p.view._shown) == 36 + len(m.moves)
+    assert len(m.behaviour.blocks) == 39 and len(p.view._shown) == 39 + len(m.moves)
     plays = sorted(badge(p, i) for i in m.behaviour.blocks if badge(p, i))
-    assert plays == sorted(f"#{k}" for k in range(1, 17))
+    assert plays == sorted(f"#{k}" for k in range(1, 18))
     for k, path in enumerate(B.read(m).paths, 1):  # a path that plays nothing has its place too
         assert badge(p, path.blocks[-1]) == rank(k)
-    assert [badge(p, i) for i in ("b15", "b17", "b23")] == [rank(1), rank(2), rank(3)]
-    assert badge(p, "b4") == rank(4) and badge(p, "b36") == rank(16)
+    assert [badge(p, i) for i in ("b15", "b17", "b23", "b39")] == [rank(k) for k in (1, 2, 3, 4)]
+    assert badge(p, "b4") == rank(5) and badge(p, "b27") == rank(14)
+    assert badge(p, "b36") == rank(17) and p.rage.isChecked()
     assert bar_on(p, "b23").controls["counter"].get_value() == "flinches"
     assert options(p, "b15", "flag") == ["flinches", "in_combat"]
     assert all(p.view._shown[i].view.opacity() == 1.0 for i in m.behaviour.blocks)
@@ -995,6 +996,29 @@ def test_every_real_kind_draws_and_edits(
     assert doc(ws).manifest == drawn
 
 
+def test_natural_rage_starts_on(panel: BehaviourPanel) -> None:
+    assert panel.rage.isChecked() and B.natural_rage(panel.ws.manifest)
+
+
+def test_natural_rage_stays_out_of_the_header(panel: BehaviourPanel) -> None:
+    """With Watch and Fire in it the header makes the window 1586 px wide: wider than a laptop."""
+    assert panel.rage.parent() is not panel.fit.parent()
+
+
+def test_natural_rage_is_one_undo_step(panel: BehaviourPanel, ws: MonsterWorkspace) -> None:
+    before = doc(ws).manifest
+    panel.rage.click()
+    assert doc(ws).manifest.behaviour.natural_rage is False and not panel.rage.isChecked()
+    assert "off" in ws.message
+    doc(ws).undo()
+    ws.refresh()
+    panel.sync()
+    assert doc(ws).manifest == before and panel.rage.isChecked()
+    panel.rage.click()
+    panel.rage.click()
+    assert doc(ws).manifest.behaviour.natural_rage is True
+
+
 # ---- focus ----------------------------------------------------------------------------------- #