feat: trigger system for scripted events added.

29 files changed, 1567 insertions, 80 deletions

diff --git a/building_guide/conditions.md b/building_guide/conditions.md
index ea17ed6..d58b35c 100644
--- a/building_guide/conditions.md
+++ b/building_guide/conditions.md
@@ -1,6 +1,7 @@
 ## Conditions Reference
 
-Conditions are used in talk options, exit gates, on-enter scripts, and use_interactions checks.
+Conditions are used in talk options, exit gates, on-enter scripts, use_interactions
+checks, room descriptions, object descriptions, and trigger value matching.
 
 ### Simple conditions
 
diff --git a/building_guide/rooms.md b/building_guide/rooms.md
index 7028393..5a414a3 100644
--- a/building_guide/rooms.md
+++ b/building_guide/rooms.md
@@ -208,5 +208,27 @@ mobs:
 - Hazards stack with mobs: an aggressive mob in a hazardous room hits you while the room
   hazard also rolls against you.
 
+### Room triggers — scripted events when flags change
+
+A room can carry a `triggers:` block. Each trigger watches a player or world flag
+and fires a sequence of timed steps when that flag's value changes. See `triggers.md`
+for the full reference.
+
+```yaml
+triggers:
+  - on_player_flag: 1001_look_sign
+    steps:
+      - delay: 5
+        message: "The cabin shakes as the small craft touches down"
+      - delay: 5
+        message: "The pistons hiss as the rear staircase opens"
+      - set_player_flags:
+          1001_touchdown: true
+```
+
+Room triggers are scoped to the room — broadcasts go to that room, mobs spawn there,
+and the trigger only fires when the flag-setting player is in that room. For
+server-wide events, use global triggers in `data/triggers/` instead.
+
 ---
 
diff --git a/building_guide/state.md b/building_guide/state.md
index 013e62a..2e0b5cc 100644
--- a/building_guide/state.md
+++ b/building_guide/state.md
@@ -4,5 +4,10 @@
 
 **Player flags** (`set_player_flags`, checked with `player_flag`) are per-character. Quest progress, "has read the sign," "paid the toll" — these are different for each player. Saved to the character YAML and persist across logins.
 
----
+### Triggers — flag-change events
+
+Any flag change (world or player) can activate a **trigger** — a timed sequence of
+messages, broadcasts, spawns, and further flag mutations. See `triggers.md` for
+the full system. This is how you turn "player looked at the sign" into "spaceship
+landed and stairs opened."
 
diff --git a/building_guide/tips.md b/building_guide/tips.md
index 307ea1e..b4abeb9 100644
--- a/building_guide/tips.md
+++ b/building_guide/tips.md
@@ -19,3 +19,5 @@
 9. **Shared depletion vs per-drop depletion.** Use `deplete_timer` for trees — the timer counts down while being chopped and regens when left alone. Use `depletes: true` on individual drops for rocks — they deplete on first successful gather.
 
 10. **Mob wander config goes in the room YAML**, not the mob definition. This lets the same `man` wander differently in different rooms.
+
+11. **Use triggers to decouple cause and effect.** Objects set flags; triggers watch flags. This way the same "pull lever" action can spawn a boss in one room, open a door in another, and broadcast to the server — all by watching the same flag from different triggers. Room triggers keep local events local; global triggers (`data/triggers/`) handle server-wide events.
diff --git a/building_guide/triggers.md b/building_guide/triggers.md
new file mode 100644
index 0000000..fa97e3a
--- /dev/null
+++ b/building_guide/triggers.md
@@ -0,0 +1,547 @@
+## Triggers
+
+Triggers let you script a sequence of timed events that fire when a flag changes
+value. They come in two flavors:
+
+- **Room triggers** — defined in room YAML under a `triggers:` block. The room is
+  the action context (broadcasts go to that room, mobs spawn there).
+- **Global triggers** — defined in `data/triggers/<id>.yaml`. These fire regardless
+  of where the flag-setting player is, and can broadcast to all online players.
+
+A trigger watches one flag (`on_player_flag` or `on_flag`). When that flag's value
+actually changes (from unset/falsy to a truthy/new value), the trigger's steps
+begin executing. Setting a flag to the same value it already has does **not** re-fire
+the trigger.
+
+### Quick Start: Landing Sequence
+
+A player looks at a sign, setting `1001_look_sign: true`. A room trigger in the
+same room watches that flag and plays a landing sequence:
+
+```yaml
+# data/rooms/intro/1001.yaml
+triggers:
+  - on_player_flag: 1001_look_sign
+    steps:
+      - delay: 5
+        message: "The cabin shakes as the small craft touches down"
+      - delay: 5
+        message: "The pistons hiss as the rear staircase opens"
+      - set_player_flags:
+          1001_touchdown: true
+```
+
+The sign object itself is unchanged — its `on_look` simply sets the flag. The trigger
+and the object are cleanly separated:
+
+```yaml
+# data/objects/unique/1001_sign.yaml
+on_look:
+  set_player_flags:
+    1001_look_sign: true
+```
+
+This separation is deliberate. The object sets flags. The trigger watches flags.
+Any system that sets a player flag (`on_look`, talk nodes, on-enter steps, exits,
+use interactions) can activate a trigger watching that flag.
+
+---
+
+### Step Actions
+
+Each step in a trigger's `steps:` list can carry a `delay` (ticks to wait) and
+one or more actions. All actions on a step fire simultaneously when the delay
+elapses.
+
+| Field              | Scope  | Description                                                                                           |
+| ------------------ | ------ | ----------------------------------------------------------------------------------------------------- |
+| `delay`            | both   | Ticks to wait before this step fires. `0` or omitted = fire on the reach tick.                        |
+| `message`          | player | Text sent to the triggering player only. Supports `%p` (player name) and `%v` (flag value) templates. |
+| `broadcast`        | room   | Text sent to everyone in the room. Inline color tags work; `\n` prefix is added automatically.        |
+| `broadcast_global` | world  | Text sent to every online player. Useful for server-wide announcements.                               |
+| `set_flags`        | world  | Mutates world flags (shared by all players).                                                          |
+| `set_player_flags` | player | Mutates player flags (per-character). Only valid for `on_player_flag` triggers.                       |
+| `spawn_mob`        | room   | Spawns a **transient** mob from a mob definition. See Transient Mobs below.                           |
+| `despawn_mob`      | room   | Removes all trigger-spawned mobs matching the given mob ID (and optionally owner).                    |
+| `give_item`        | player | Gives an item to the player's inventory.                                                              |
+| `take_item`        | player | Removes an item from the player's inventory.                                                          |
+| `teleport`         | player | Moves the player to a room ID.                                                                        |
+| `heal`             | player | Restores hitpoints.                                                                                   |
+
+---
+
+### Room-Level Triggers
+
+Room triggers go in the room YAML under a `triggers:` list. The room is
+automatically the context for broadcasts and mob spawns.
+
+#### Example 1: Boss arena — puzzle unlocks a boss
+
+Player activates an altar (sets a player flag), triggering a boss spawn:
+
+```yaml
+# data/rooms/dungeon/boss_chamber.yaml
+triggers:
+  - on_player_flag: activated_altar
+    steps:
+      - broadcast: "The altar glows with an eerie light..."
+      - delay: 10
+        broadcast: "The ground trembles beneath your feet."
+      - delay: 20
+        broadcast: "A massive guardian emerges from the shadows!"
+      - spawn_mob:
+          id: altar_guardian
+          owner_only: true
+          despawn_on_leave: true
+          despawn_rooms: [450, 451, 452]
+```
+
+The boss is `owner_only` — only the player who triggered it can interact with it.
+It won't despawn as long as the owner stays in rooms 450, 451, or 452 (a 3-room
+boss arena). When the owner leaves those rooms, the boss begins despawning.
+
+#### Example 2: Story beat — timed cutscene after NPC conversation
+
+An NPC conversation node sets `quest_ritual: started`. A room trigger plays a
+dramatic sequence for that player:
+
+```yaml
+triggers:
+  - on_player_flag: quest_ritual
+    steps:
+      - delay: 8
+        message: "The elder begins to chant in a language you don't recognize."
+      - delay: 6
+        message: "Wisps of light swirl around the altar."
+      - delay: 4
+        message: "The ground beneath you shudders as the ritual reaches its peak."
+      - delay: 6
+        broadcast: "A blinding flash fills the chamber!"
+      - teleport: 601
+        message: "You open your eyes. You're somewhere else entirely."
+```
+
+The final step uses both `broadcast` (everyone in the ritual room sees the flash)
+and `teleport` + `message` (the triggering player is moved and sees a personal
+message).
+
+#### Example 3: World-flag room trigger — shared environmental event
+
+A player pulls a lever (sets world flag `floodgate_open`). The room trigger
+broadcasts to everyone in the dam control room:
+
+```yaml
+# data/rooms/wilderness/dam_control.yaml
+triggers:
+  - on_flag: floodgate_open
+    steps:
+      - broadcast: "Ancient gears grind as the floodgate slowly opens..."
+      - delay: 15
+        broadcast: "Water thunders through the opening!"
+      - set_flags:
+          valley_flooded: true
+```
+
+Because this watches a **world** flag (`on_flag`), it fires once globally when
+the flag is first set — not per-player. Everyone in the room sees the messages.
+
+#### Example 4: "Push button" — trigger that resets itself
+
+A player pulls a lever. The trigger fires, then clears the flag so it can be
+pulled again. This simulates a toggle without needing a separate mechanism:
+
+```yaml
+triggers:
+  - on_player_flag: lever_pulled
+    steps:
+      - broadcast: "The lever snaps back into place with a loud clunk."
+      - set_player_flags:
+          lever_pulled: false      # reset so next pull re-fires
+```
+
+---
+
+### Global Triggers
+
+Global triggers live in `data/triggers/`. They fire regardless of where the
+flag-setting player is located. Use them for server-wide events.
+
+#### Example 5: Level-up announcement
+
+When a player reaches level 99 in any skill, announce it server-wide.
+The game code sets `announce_99_skill` = the skill name (e.g. `"attack"`):
+
+```yaml
+# data/triggers/announce_99.yaml
+on_player_flag: announce_99_skill
+steps:
+  - broadcast_global: "%p has reached level 99 %v!"
+```
+
+`%p` expands to the player's name, `%v` expands to the flag value (`"attack"`,
+`"mining"`, etc.):
+
+```
+PlayerName has reached level 99 attack!
+```
+
+#### Example 6: World-first boss kill — global broadcast
+
+A boss mob's death sets world flag `world_boss_slain`. A global trigger
+announces it to everyone:
+
+```yaml
+# data/triggers/world_boss_slain.yaml
+on_flag: world_boss_slain
+steps:
+  - broadcast_global: "The Ancient One has been vanquished! The land stirs with new life."
+  - set_flags:
+      ancient_lands_access: true      # opens a zone for everyone
+```
+
+#### Example 7: Global trigger with room context
+
+A global trigger can specify a `room` for broadcasts and mob spawns. This is
+useful when a world flag should trigger effects in a specific location:
+
+```yaml
+# data/triggers/obelisk_activated.yaml
+on_flag: desert_obelisk_charged
+room: 1200
+steps:
+  - broadcast: "The obelisk hums with stored power."
+  - delay: 30
+    broadcast: "A beam of light shoots from the obelisk into the sky!"
+  - spawn_mob: obelisk_guardian
+```
+
+---
+
+### Cascading Triggers
+
+When a trigger step sets a flag, any triggers watching that flag fire immediately
+(on the next tick). This lets you chain sequences together:
+
+```yaml
+triggers:
+  - on_player_flag: phase_1_done
+    steps:
+      - broadcast: "The first seal cracks."
+      - set_player_flags:
+          phase_2_started: true       # triggers the next trigger
+
+  - on_player_flag: phase_2_started
+    steps:
+      - delay: 10
+        broadcast: "The second seal glows brighter..."
+      - delay: 10
+        spawn_mob: phase_2_adds
+```
+
+Both sequences run concurrently — phase 2's delay countdown starts on the same
+tick phase 1 completes.
+
+**Self-re-triggering is prevented.** A trigger can't fire itself again while
+its sequence is already in progress (tracked per-player per-trigger-ID). Two
+different triggers watching the same flag both fire independently.
+
+---
+
+### Transient Mobs
+
+Mobs spawned via `spawn_mob` in a trigger step are **transient** — they exist
+until killed or despawned, but do **not** respawn. They behave exactly like
+regular mobs: they can be attacked, talked to, examined, and stolen from.
+
+#### SpawnMobConfig
+
+`spawn_mob` accepts either a simple string (mob ID only) or a full config map:
+
+```yaml
+spawn_mob: altar_guardian
+
+# Equivalent to:
+spawn_mob:
+  id: altar_guardian
+```
+
+Full config:
+
+| Field              | Default      | Description                                                                                                                                   |
+| ------------------ | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| `id`               | *(required)* | Mob definition ID from `data/mobs/`.                                                                                                          |
+| `owner_only`       | `false`      | Only the triggering player can interact (attack, talk, steal). Non-owners see "They don't seem interested in you." Everyone can still `look`. |
+| `despawn_on_leave` | `false`      | If `true`, the mob despawns when the owner leaves the allowed rooms.                                                                          |
+| `despawn_rooms`    | spawn room   | Rooms the owner can be in without triggering despawn. Empty = the spawn room only.                                                            |
+| `despawn_ticks`    | `0`          | Tick countdown after owner leaves despawn_rooms. `0` = immediate removal. Owner returning resets the countdown.                               |
+
+#### Example 8: Personal boss — despawns if you leave the arena
+
+```yaml
+spawn_mob:
+  id: arena_champion
+  owner_only: true
+  despawn_on_leave: true
+  despawn_ticks: 60        # 60-tick grace period if you step out
+```
+
+#### Example 9: Persistent NPC — stays until killed
+
+```yaml
+spawn_mob:
+  id: wandering_merchant
+  # despawn_on_leave defaults to false — stays forever
+```
+
+#### Example 10: Despawning via trigger step
+
+Use `despawn_mob` in a step to remove previously spawned mobs:
+
+```yaml
+triggers:
+  - on_player_flag: puzzle_solved
+    steps:
+      - despawn_mob: puzzle_guardian       # remove the puzzle mob
+      - delay: 10
+        broadcast: "The guardian dissolves into mist."
+      - spawn_mob: boss_guardian           # spawn the real boss
+```
+
+`despawn_mob` with an owner only removes mobs spawned by that player. Without an
+owner (in world-flag triggers), it removes all matching mobs.
+
+#### Example 11: Fixed-lifetime mob
+
+A mob that exists for exactly 2 minutes regardless of owner location:
+
+```yaml
+steps:
+  - spawn_mob:
+      id: timed_challenge_mob
+      owner_only: true
+  - delay: 200                    # 200 ticks = 2 minutes
+    despawn_mob: timed_challenge_mob
+    broadcast: "The challenge ends. The mob vanishes."
+```
+
+---
+
+### Template Variables
+
+Steps that send text support these variables:
+
+| Variable | Expands to |
+|---|---|
+| `%p` | Player name (only available for `on_player_flag` triggers) |
+| `%v` | Flag value at the time the trigger fired (e.g. the skill name for level-up announcements) |
+
+```yaml
+steps:
+  - broadcast_global: "%p has completed %v!"
+  # Renders: "Alice has completed the Gauntlet!"
+```
+
+---
+
+### Value-Matching Triggers
+
+By default a trigger fires when the watched flag becomes truthy. Add `value:` to
+require a specific value:
+
+```yaml
+# Only fires when quest_stage reaches exactly 3
+triggers:
+  - on_player_flag: quest_stage
+    value: 3
+    steps:
+      - message: "Stage 3 begins — the temple doors swing open."
+      - set_flags:
+          temple_open: true
+```
+
+This enables multi-stage quests where the same flag advances through numeric
+stages, and different triggers fire at different values.
+
+```yaml
+triggers:
+  - on_player_flag: quest_stage
+    value: 1
+    steps:
+      - message: "Quest started — find the crystal shard."
+  - on_player_flag: quest_stage
+    value: 2
+    steps:
+      - message: "You found the shard — return to the elder."
+  - on_player_flag: quest_stage
+    value: 3
+    steps:
+      - message: "The ritual begins..."
+      - delay: 10
+        broadcast: "The temple hums with ancient power!"
+      - spawn_mob: crystal_guardian
+```
+
+---
+
+### Full Scenario: Multi-Room Investigation Quest
+
+A player investigates a murder scene across several rooms. Finding clues in order
+advances a numeric flag through stages. The last stage spawns a boss.
+
+**Step 1: The body — sets `investigation: 1`**
+
+```yaml
+# data/objects/unique/5001_body.yaml
+name: body
+on_look:
+  set_player_flags:
+    investigation: 1
+```
+
+**Step 2: Blood trail in room 5002** — room trigger fires on value 1
+
+```yaml
+# data/rooms/city/5002_alley.yaml
+triggers:
+  - on_player_flag: investigation
+    value: 1
+    steps:
+      - delay: 3
+        message: "You notice a trail of blood leading east..."
+      - set_player_flags:
+          investigation: 2
+```
+
+**Step 3: Broken dagger in room 5003** — room trigger fires on value 2
+
+```yaml
+# data/rooms/city/5003_warehouse.yaml
+triggers:
+  - on_player_flag: investigation
+    value: 2
+    steps:
+      - delay: 3
+        message: "A glint of metal catches your eye under a crate."
+```
+
+**Step 4: Confrontation** — room trigger fires on value 3 (set by a separate talk node), spawns boss
+
+```yaml
+# data/rooms/city/5004_docks.yaml
+triggers:
+  - on_player_flag: investigation
+    value: 3
+    steps:
+      - delay: 5
+        broadcast: "A shadow detaches itself from the warehouse wall..."
+      - delay: 5
+        broadcast: "The assassin steps into the light, blade drawn."
+      - spawn_mob:
+          id: assassin_boss
+          owner_only: true
+          despawn_on_leave: true
+          despawn_rooms: [5004]
+```
+
+The player must stay in room 5004 to fight the boss. If they flee, the boss
+despawns and the flag stays at 3 — they can't re-trigger anything because the
+flag is already at that value.
+
+---
+
+### Full Scenario: Server-Wide World Event
+
+A server event progresses through stages. A global trigger chains world flags to
+advance the event for everyone.
+
+**Phase 1 trigger:**
+
+```yaml
+# data/triggers/event_phase1.yaml
+on_flag: event_phase1_start
+steps:
+  - broadcast_global: "The sky darkens as an eclipse begins..."
+  - delay: 100
+    set_flags:
+      event_phase2_start: true
+```
+
+**Phase 2 trigger:**
+
+```yaml
+# data/triggers/event_phase2.yaml
+on_flag: event_phase2_start
+steps:
+  - broadcast_global: "Monsters pour from the shadows across the land!"
+  - delay: 300
+    set_flags:
+      event_phase3_start: true
+```
+
+**Phase 3 trigger — event ends:**
+
+```yaml
+# data/triggers/event_phase3.yaml
+on_flag: event_phase3_start
+steps:
+  - broadcast_global: "The eclipse passes. The monsters retreat."
+  - delay: 50
+    set_flags:
+      event_active: false
+```
+
+GM commands or admin tools set `event_phase1_start: true` to kick things off.
+The cascade handles the rest.
+
+---
+
+### How Flags Get Set
+
+Triggers fire whenever a flag changes — it doesn't matter *how* the flag was set.
+All of these paths activate triggers:
+
+| Source | Example |
+|---|---|
+| Object `on_look` | `look sign` sets `1001_look_sign: true` |
+| Talk node actions | NPC sets `quest_started: true` after accepting |
+| Talk option actions | Player selects a choice that sets a flag |
+| On-enter steps | Room entry sets `1001_welcome: true` |
+| Exit traversal | Walking through an exit sets `boarded_shuttle: true` |
+| Use interactions | `push button` sets `gate_open: true` |
+| Trigger steps | One trigger chain-sets a flag for another trigger |
+
+---
+
+### Trigger Firing Rules
+
+1. **Only on actual value change.** Setting `true` → `true` is a no-op. Setting
+   `1` → `2` fires if a trigger watches that flag. Setting `nil` → `true` fires.
+   Setting `true` → `false` does **not** fire (triggers activate on becoming
+   truthy, not on becoming falsy).
+
+2. **Conditions are not re-evaluated.** A trigger's steps always run once the
+   trigger fires. There is no per-step condition checking (unlike `on_enter`).
+
+3. **Per-player per-trigger-ID.** The same player can't have two instances of
+   the same trigger running simultaneously. Starting a new one replaces the old.
+
+4. **Player must be online.** Player-flag triggers only fire for connected
+   players. World-flag triggers fire regardless.
+
+5. **Room triggers check room.** Room-level triggers only fire when the
+   flag-setting player is in that room. This keeps local events local.
+
+6. **Cascading triggers run concurrently.** If trigger A sets a flag that
+   activates trigger B, both sequences advance on each tick independently.
+
+---
+
+### Validation
+
+Startup validation checks that trigger `spawn_mob.id` references an existing mob
+definition, `give_item`/`take_item` reference existing items, `teleport` and
+`despawn_rooms` reference existing rooms, and that global trigger IDs are unique.
+
+Validation does NOT check that the watched flags (`on_player_flag` / `on_flag`)
+are ever set — those are dynamic, set by runtime gameplay, and can't be statically
+verified.
diff --git a/cmd/mud/main.go b/cmd/mud/main.go
index 773d3c9..4427a7d 100644
--- a/cmd/mud/main.go
+++ b/cmd/mud/main.go
@@ -43,6 +43,8 @@ func main() {
 		g.MoveTick()
 		g.ProcessQueuedCommands()
 		g.EnterSeqTick()
+		g.TriggerSeqTick()
+		g.TransientMobTick()
 		g.World.Tick()
 		g.MobStore.Tick()
 		g.RegenTick()
diff --git a/data/rooms/intro/1001.yaml b/data/rooms/intro/1001.yaml
index fd7f2f3..df3b2ab 100644
--- a/data/rooms/intro/1001.yaml
+++ b/data/rooms/intro/1001.yaml
@@ -1,5 +1,10 @@
 name: "Inside Transport Shuttle"
-description: "A dim, windowless shuttle interior with a few uncomfortable rows of steel seats facing forward. A large framed sign hangs next to the closed cockpit door. A piston-powered staircase leads down out the back of the small craft with a smiling attendant ready to help disembark."
+description:
+  - text: "A dim, windowless shuttle interior with a few uncomfortable rows of steel seats facing forward. A large framed sign hangs next to the closed cockpit door. The piston-powered staircase is firmly closed at the rear of the craft."
+    condition:
+      player_flag: 1001_touchdown
+      not: true
+  - text: "A dim, windowless shuttle interior with a few uncomfortable rows of steel seats facing forward. A large framed sign hangs next to the closed cockpit door. A piston-powered staircase leads down out the back of the small craft with a smiling attendant ready to help disembark."
 objects:
   - id: 1001_sign
 mobs:
@@ -8,8 +13,8 @@ exits:
   down:
     room: 1002
     condition:
-      player_flag: 1001_look_sign
-    blocked_message: "The attendant points to the sign and insists you {10}look sign{/} before disembarking."
+      player_flag: 1001_touchdown
+    blocked_message: "The piston-powered staircase is firmly closed."
 on_enter:
   - condition:
       player_flag: 1001_welcome
@@ -28,3 +33,12 @@ on_enter:
       not: true
     delay: 7
     message: "{11}Type{/} {10}help newplayer{/} {11}for the new player's guide. That's it. Explore and have fun.{/}"
+triggers:
+  - on_player_flag: 1001_look_sign
+    steps:
+      - delay: 5
+        message: "The cabin shakes as the small craft touches down"
+      - delay: 5
+        message: "The pistons hiss as the rear staircase opens"
+      - set_player_flags:
+          1001_touchdown: true
diff --git a/data/triggers/announce_99.yaml b/data/triggers/announce_99.yaml
new file mode 100644
index 0000000..a6f0e9e
--- /dev/null
+++ b/data/triggers/announce_99.yaml
@@ -0,0 +1,6 @@
+# Example global trigger: announces when a player reaches level 99 in any skill.
+# The game code sets the player flag 'announce_99_skill' to the skill name
+# (e.g. "attack", "strength") when a player hits level 99.
+on_player_flag: announce_99_skill
+steps:
+  - broadcast_global: "%p has reached level 99 %v!"
diff --git a/internal/game/act_agility.go b/internal/game/act_agility.go
index 2136699..4a68580 100644
--- a/internal/game/act_agility.go
+++ b/internal/game/act_agility.go
@@ -103,7 +103,7 @@ func (g *Game) advanceObstacle(sess *net.Session, p *player.Player) {
 
 			lapKey := "agility_laps_" + courseID
 			laps := getPlayerFlagInt(p, lapKey) + 1
-			setPlayerFlag(p, lapKey, laps)
+			g.setPlayerFlag(p, lapKey, laps)
 
 			courseName := p.Action.TargetName
 			sess.WriteLine(g.colorize(sess, "broadcast",
diff --git a/internal/game/act_farm.go b/internal/game/act_farm.go
index 62e08fd..a4d96b4 100644
--- a/internal/game/act_farm.go
+++ b/internal/game/act_farm.go
@@ -41,13 +41,13 @@ func farmFlagPrefix(defID string, index int) string {
 func (g *Game) ensureFarmState(p *player.Player, prefix string) {
 	p.EnsureFlags()
 	if _, exists := p.Flags[prefix+"_seed"]; !exists {
-		p.Flags[prefix+"_weeds"] = true
-		p.Flags[prefix+"_seed"] = ""
-		p.Flags[prefix+"_stage"] = 0
-		p.Flags[prefix+"_watered"] = false
-		p.Flags[prefix+"_diseased"] = false
-		p.Flags[prefix+"_dead"] = false
-		p.Flags[prefix+"_ready"] = false
+		g.setPlayerFlag(p, prefix+"_weeds", true)
+		g.setPlayerFlag(p, prefix+"_seed", "")
+		g.setPlayerFlag(p, prefix+"_stage", 0)
+		g.setPlayerFlag(p, prefix+"_watered", false)
+		g.setPlayerFlag(p, prefix+"_diseased", false)
+		g.setPlayerFlag(p, prefix+"_dead", false)
+		g.setPlayerFlag(p, prefix+"_ready", false)
 	}
 }
 
@@ -111,8 +111,8 @@ func (g *Game) advanceFarmGrowth(sess *net.Session, p *player.Player) {
 		}
 
 		if diseased {
-			p.Flags[prefix+"_dead"] = true
-			p.Flags[prefix+"_diseased"] = false
+			g.setPlayerFlag(p, prefix+"_dead", true)
+			g.setPlayerFlag(p, prefix+"_diseased", false)
 			sess.WriteLine(g.colorize(sess, "farm_disease",
 				fmt.Sprintf("\nYour %s has died from disease!", g.seedDisplayName(sess, seedID))))
 			g.AccountStore.SaveCharacter(p)
@@ -135,23 +135,23 @@ func (g *Game) advanceFarmGrowth(sess *net.Session, p *player.Player) {
 		stage++
 
 		if stage >= maxStages {
-			p.Flags[prefix+"_stage"] = stage
-			p.Flags[prefix+"_ready"] = true
-			p.Flags[prefix+"_watered"] = false
+			g.setPlayerFlag(p, prefix+"_stage", stage)
+			g.setPlayerFlag(p, prefix+"_ready", true)
+			g.setPlayerFlag(p, prefix+"_watered", false)
 			sess.WriteLine(g.colorize(sess, "farm_grow",
 				fmt.Sprintf("\nYour %s is fully grown and ready to harvest!",
 					g.seedDisplayName(sess, seedID))))
 		} else {
 			if !watered && rand.Float64() < 0.10 {
-				p.Flags[prefix+"_stage"] = stage
-				p.Flags[prefix+"_diseased"] = true
-				p.Flags[prefix+"_watered"] = false
+				g.setPlayerFlag(p, prefix+"_stage", stage)
+				g.setPlayerFlag(p, prefix+"_diseased", true)
+				g.setPlayerFlag(p, prefix+"_watered", false)
 				sess.WriteLine(g.colorize(sess, "farm_disease",
 					fmt.Sprintf("\nYour %s has become diseased!",
 						g.seedDisplayName(sess, seedID))))
 			} else {
-				p.Flags[prefix+"_stage"] = stage
-				p.Flags[prefix+"_watered"] = false
+				g.setPlayerFlag(p, prefix+"_stage", stage)
+				g.setPlayerFlag(p, prefix+"_watered", false)
 				sess.WriteLine(g.colorize(sess, "farm_grow",
 					fmt.Sprintf("\nYour %s has grown to stage %d/%d.",
 						g.seedDisplayName(sess, seedID), stage, maxStages)))
@@ -182,13 +182,13 @@ func (g *Game) advancePlant(sess *net.Session, p *player.Player) {
 
 	g.ensureFarmState(p, prefix)
 
-	p.Flags[prefix+"_weeds"] = false
-	p.Flags[prefix+"_seed"] = seedID
-	p.Flags[prefix+"_stage"] = 0
-	p.Flags[prefix+"_watered"] = false
-	p.Flags[prefix+"_diseased"] = false
-	p.Flags[prefix+"_dead"] = false
-	p.Flags[prefix+"_ready"] = false
+	g.setPlayerFlag(p, prefix+"_weeds", false)
+	g.setPlayerFlag(p, prefix+"_seed", seedID)
+	g.setPlayerFlag(p, prefix+"_stage", 0)
+	g.setPlayerFlag(p, prefix+"_watered", false)
+	g.setPlayerFlag(p, prefix+"_diseased", false)
+	g.setPlayerFlag(p, prefix+"_dead", false)
+	g.setPlayerFlag(p, prefix+"_ready", false)
 
 	if intXP := int(xp); intXP > 0 {
 		g.awardSkillXP(sess, p, player.Farming, intXP)
@@ -280,13 +280,13 @@ func (g *Game) advanceHarvest(sess *net.Session, p *player.Player) {
 	}
 
 	g.ensureFarmState(p, prefix)
-	p.Flags[prefix+"_seed"] = ""
-	p.Flags[prefix+"_stage"] = 0
-	p.Flags[prefix+"_ready"] = false
-	p.Flags[prefix+"_watered"] = false
-	p.Flags[prefix+"_weeds"] = true
-	p.Flags[prefix+"_diseased"] = false
-	p.Flags[prefix+"_dead"] = false
+	g.setPlayerFlag(p, prefix+"_seed", "")
+	g.setPlayerFlag(p, prefix+"_stage", 0)
+	g.setPlayerFlag(p, prefix+"_ready", false)
+	g.setPlayerFlag(p, prefix+"_watered", false)
+	g.setPlayerFlag(p, prefix+"_weeds", true)
+	g.setPlayerFlag(p, prefix+"_diseased", false)
+	g.setPlayerFlag(p, prefix+"_dead", false)
 
 	g.AccountStore.SaveCharacter(p)
 
@@ -314,13 +314,13 @@ func (g *Game) advanceRake(sess *net.Session, p *player.Player) {
 	}
 	prefix := data.Prefix
 
-	p.Flags[prefix+"_weeds"] = false
-	p.Flags[prefix+"_dead"] = false
-	p.Flags[prefix+"_seed"] = ""
-	p.Flags[prefix+"_stage"] = 0
-	p.Flags[prefix+"_ready"] = false
-	p.Flags[prefix+"_diseased"] = false
-	p.Flags[prefix+"_watered"] = false
+	g.setPlayerFlag(p, prefix+"_weeds", false)
+	g.setPlayerFlag(p, prefix+"_dead", false)
+	g.setPlayerFlag(p, prefix+"_seed", "")
+	g.setPlayerFlag(p, prefix+"_stage", 0)
+	g.setPlayerFlag(p, prefix+"_ready", false)
+	g.setPlayerFlag(p, prefix+"_diseased", false)
+	g.setPlayerFlag(p, prefix+"_watered", false)
 
 	g.AccountStore.SaveCharacter(p)
 
@@ -340,7 +340,7 @@ func (g *Game) advanceWater(sess *net.Session, p *player.Player) {
 	}
 	prefix := data.Prefix
 
-	p.Flags[prefix+"_watered"] = true
+	g.setPlayerFlag(p, prefix+"_watered", true)
 
 	g.AccountStore.SaveCharacter(p)
 
@@ -361,7 +361,7 @@ func (g *Game) advanceCure(sess *net.Session, p *player.Player) {
 	prefix := data.Prefix
 
 	p.RemoveItem("plant_cure", 1)
-	p.Flags[prefix+"_diseased"] = false
+	g.setPlayerFlag(p, prefix+"_diseased", false)
 
 	g.AccountStore.SaveCharacter(p)
 
diff --git a/internal/game/act_fletch.go b/internal/game/act_fletch.go
index 78a19ad..e85f2c1 100644
--- a/internal/game/act_fletch.go
+++ b/internal/game/act_fletch.go
@@ -12,7 +12,7 @@ import (
 
 func (g *Game) startFletchAction(sess *net.Session, p *player.Player, def *item.ItemDef, count int) {
 	p.EnsureFlags()
-	p.Flags["last_fletch"] = def.ID
+	g.setPlayerFlag(p, "last_fletch", def.ID)
 	g.AccountStore.SaveCharacter(p)
 
 	if def.FirstCraft().Wait <= 0 {
diff --git a/internal/game/act_room.go b/internal/game/act_room.go
index 86c1737..fec7304 100644
--- a/internal/game/act_room.go
+++ b/internal/game/act_room.go
@@ -188,9 +188,8 @@ func (g *Game) isCharLive(name string, sess *net.Session) bool {
 func (g *Game) applyFlagMutations(p *player.Player, setFlags, setPlayerFlags map[string]any) {
 	g.Flags.SetAll(setFlags)
 	if len(setPlayerFlags) > 0 {
-		p.EnsureFlags()
 		for k, v := range setPlayerFlags {
-			p.Flags[k] = v
+			g.setPlayerFlag(p, k, v)
 		}
 	}
 }
diff --git a/internal/game/act_steal.go b/internal/game/act_steal.go
index 7371782..39df9e2 100644
--- a/internal/game/act_steal.go
+++ b/internal/game/act_steal.go
@@ -203,6 +203,10 @@ func (g *Game) startSteal(sess *net.Session, p *player.Player, targetType string
 		targetID = mob.InstanceID
 		mobInstanceID = mob.InstanceID
 
+		if mob.OwnerOnly && mob.Owner != "" && mob.Owner != p.Name {
+			sess.WriteLine("They don't seem interested in you.")
+			return
+		}
 		if stealTable == "" {
 			sess.WriteLine(fmt.Sprintf("You can't steal from the %s.", targetName))
 			return
diff --git a/internal/game/act_talk.go b/internal/game/act_talk.go
index f54290a..14361f8 100644
--- a/internal/game/act_talk.go
+++ b/internal/game/act_talk.go
@@ -14,6 +14,10 @@ import (
 )
 
 func (g *Game) startMobTalk(sess *net.Session, p *player.Player, mob *world.MobInstance) {
+	if mob.OwnerOnly && mob.Owner != "" && mob.Owner != p.Name {
+		sess.WriteLine("They ignore you.")
+		return
+	}
 	cfg := mob.TalkConfig
 	if cfg == nil {
 		sess.WriteLine("This person has nothing to say.")
@@ -267,7 +271,7 @@ func (g *Game) applyNodeAction(sess *net.Session, na *behavior.NodeAction) {
 			sess.WriteLine(fmt.Sprintf("You don't have enough Reputation. (Need %d, have %d)", na.ReputationCost, rep))
 			return
 		}
-		setPlayerFlag(p, "assassin_reputation", rep-na.ReputationCost)
+		g.setPlayerFlag(p, "assassin_reputation", rep-na.ReputationCost)
 		g.AccountStore.SaveCharacter(p)
 	}
 
@@ -275,8 +279,7 @@ func (g *Game) applyNodeAction(sess *net.Session, na *behavior.NodeAction) {
 		g.Flags.Set(k, v)
 	}
 	for k, v := range na.SetPlayerFlags {
-		p.EnsureFlags()
-		p.Flags[k] = v
+		g.setPlayerFlag(p, k, v)
 	}
 	if na.TakeItem != "" {
 		if p.HasItem(na.TakeItem) {
@@ -323,6 +326,6 @@ func (g *Game) applyNodeAction(sess *net.Session, na *behavior.NodeAction) {
 		g.processSawmill(sess, p)
 	}
 	if na.ApsNode {
-		setPlayerFlag(p, "aps_node_"+strconv.Itoa(p.RoomID), true)
+		g.setPlayerFlag(p, "aps_node_"+strconv.Itoa(p.RoomID), true)
 	}
 }
diff --git a/internal/game/cmd_craft.go b/internal/game/cmd_craft.go
index 254b938..0fe3d5b 100644
--- a/internal/game/cmd_craft.go
+++ b/internal/game/cmd_craft.go
@@ -164,7 +164,7 @@ func (g *Game) availableItems(p *player.Player, allItems []*item.ItemDef) []*ite
 
 func (g *Game) startItem(sess *net.Session, p *player.Player, def *item.ItemDef, count int, flagKey string) {
 	p.EnsureFlags()
-	p.Flags[flagKey] = def.ID
+	g.setPlayerFlag(p, flagKey, def.ID)
 	g.AccountStore.SaveCharacter(p)
 
 	g.startProductionFromItem(sess, p, def, count)
diff --git a/internal/game/combat_attack.go b/internal/game/combat_attack.go
index ee7dee8..61eb9c1 100644
--- a/internal/game/combat_attack.go
+++ b/internal/game/combat_attack.go
@@ -130,6 +130,10 @@ func (g *Game) findMob(sess *net.Session, input string, roomID int) *world.MobIn
 }
 
 func (g *Game) startCombat(sess *net.Session, p *player.Player, mob *world.MobInstance) {
+	if mob.OwnerOnly && mob.Owner != "" && mob.Owner != p.Name {
+		sess.WriteLine("They don't seem interested in you.")
+		return
+	}
 	g.cancelRest(p.Name)
 	g.cancelBgAction(p)
 
diff --git a/internal/game/combat_mob.go b/internal/game/combat_mob.go
index e06e307..5558578 100644
--- a/internal/game/combat_mob.go
+++ b/internal/game/combat_mob.go
@@ -212,10 +212,17 @@ func (g *Game) endCombat(sess *net.Session, p *player.Player, mob *world.MobInst
 			respawnTicks = engine.ToTicks(30)
 		}
 		instanceID := mob.InstanceID
-		g.Ticks.Subscribe(respawnTicks, func() bool {
-			g.respawnMob(instanceID)
-			return false
-		})
+		if mob.SpawnedByTrigger {
+			g.Ticks.Subscribe(10, func() bool {
+				g.MobStore.RemoveInstance(instanceID)
+				return false
+			})
+		} else {
+			g.Ticks.Subscribe(respawnTicks, func() bool {
+				g.respawnMob(instanceID)
+				return false
+			})
+		}
 		g.writePrompt(sess)
 	}
 }
diff --git a/internal/game/core_flags.go b/internal/game/core_flags.go
index 6595cc4..5e1c812 100644
--- a/internal/game/core_flags.go
+++ b/internal/game/core_flags.go
@@ -33,9 +33,23 @@ func getPlayerFlagString(p *player.Player, key string) string {
 	return s
 }
 
-func setPlayerFlag(p *player.Player, key string, val any) {
+func (g *Game) setPlayerFlag(p *player.Player, key string, val any) {
 	p.EnsureFlags()
+	old, existed := p.Flags[key]
 	p.Flags[key] = val
+	if !existed || !valuesEqual(old, val) {
+		g.firePlayerFlagTrigger(p, key, val)
+	}
+}
+
+func (g *Game) firePlayerFlagTrigger(p *player.Player, flagName string, flagValue any) {
+	g.charsMu.Lock()
+	sess := g.loggedInChars[p.Name]
+	g.charsMu.Unlock()
+	if sess == nil {
+		return
+	}
+	g.TriggerStore.FirePlayerInRoom(p.Name, p.RoomID, flagName, flagValue)
 }
 
 func intFromFlag(flags map[string]any, key string) int {
diff --git a/internal/game/flagstore.go b/internal/game/flagstore.go
index 2790d89..bc72c60 100644
--- a/internal/game/flagstore.go
+++ b/internal/game/flagstore.go
@@ -2,18 +2,29 @@ package game
 
 import "sync"
 
+// FlagChangeCallback is invoked when a world flag value actually changes
+// (old value differs from new, or new flag is created with a truthy value).
+type FlagChangeCallback func(name string, value any)
+
 // FlagStore holds world flags — shared mutable state visible to all players
 // (e.g. opened doors, quest state). Player-specific flags live on
 // *player.Player.Flags instead. FlagStore is safe for concurrent use.
 type FlagStore struct {
-	mu    sync.Mutex
-	flags map[string]any
+	mu        sync.Mutex
+	flags     map[string]any
+	callbacks []FlagChangeCallback
 }
 
 func NewFlagStore() *FlagStore {
 	return &FlagStore{flags: make(map[string]any)}
 }
 
+func (f *FlagStore) OnChange(cb FlagChangeCallback) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.callbacks = append(f.callbacks, cb)
+}
+
 func (f *FlagStore) Get(name string) (any, bool) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -23,15 +34,35 @@ func (f *FlagStore) Get(name string) (any, bool) {
 
 func (f *FlagStore) Set(name string, value any) {
 	f.mu.Lock()
-	defer f.mu.Unlock()
+	old, existed := f.flags[name]
 	f.flags[name] = value
+	cbs := f.callbacks
+	f.mu.Unlock()
+
+	if !existed || !valuesEqual(old, value) {
+		for _, cb := range cbs {
+			cb(name, value)
+		}
+	}
 }
 
 func (f *FlagStore) SetAll(m map[string]any) {
 	f.mu.Lock()
-	defer f.mu.Unlock()
+	changed := make(map[string]any)
 	for k, v := range m {
+		old, existed := f.flags[k]
 		f.flags[k] = v
+		if !existed || !valuesEqual(old, v) {
+			changed[k] = v
+		}
+	}
+	cbs := f.callbacks
+	f.mu.Unlock()
+
+	for k, v := range changed {
+		for _, cb := range cbs {
+			cb(k, v)
+		}
 	}
 }
 
diff --git a/internal/game/game.go b/internal/game/game.go
index 320304f..acd2924 100644
--- a/internal/game/game.go
+++ b/internal/game/game.go
@@ -52,6 +52,7 @@ type Game struct {
 	Hub              *net.Hub
 	Flags            *FlagStore
 	Combat           *combat.Tracker
+	TriggerStore     *world.TriggerStore
 	queue            *CommandQueue
 	safespot         *SafespotManager
 	ValidationConfig config.ValidationConfig
@@ -84,6 +85,7 @@ func New(dataDir string, colorConfig *config.ColorsConfig, valConfig config.Vali
 		},
 		Flags:            NewFlagStore(),
 		Combat:           combat.NewTracker(),
+		TriggerStore:     world.NewTriggerStore(),
 		queue:            NewCommandQueue(),
 		safespot:         NewSafespotManager(),
 		ValidationConfig: valConfig,
@@ -97,6 +99,7 @@ func New(dataDir string, colorConfig *config.ColorsConfig, valConfig config.Vali
 	g.LoadMods()
 	g.LoadTechs()
 	g.buildCraftIndex()
+	g.seedRoomTriggers()
 	g.ValidateAndLog()
 	return g
 }
@@ -116,6 +119,9 @@ func (g *Game) SetHub(hub *net.Hub) {
 			}
 		}
 	})
+	g.Flags.OnChange(func(name string, value any) {
+		g.TriggerStore.FireWorld(name, value)
+	})
 }
 
 func (g *Game) HandleSession(sess *net.Session, input string) {
@@ -334,6 +340,18 @@ func (g *Game) buildCraftIndex() {
 	g.CraftIndex.Build(items)
 }
 
+func (g *Game) seedRoomTriggers() {
+	g.TriggerStore.LoadGlobal(g.DataDir)
+	roomIndex := g.World.RoomIndex()
+	for id := range roomIndex {
+		room, err := g.World.LoadRoom(id)
+		if err != nil || len(room.Triggers) == 0 {
+			continue
+		}
+		g.TriggerStore.SeedRoomTriggers(id, room.Triggers)
+	}
+}
+
 type pendingDepletion struct {
 	instanceKey string
 	objDefID    string
diff --git a/internal/game/production_menu.go b/internal/game/production_menu.go
index 7181a0e..c1d9a96 100644
--- a/internal/game/production_menu.go
+++ b/internal/game/production_menu.go
@@ -258,7 +258,7 @@ func (g *Game) handleProductChoice(sess *net.Session, input string) {
 	}
 
 	p.EnsureFlags()
-	p.Flags[lastFlagKey] = sel.Item.ID
+	g.setPlayerFlag(p, lastFlagKey, sel.Item.ID)
 	g.AccountStore.SaveCharacter(p)
 
 	if background {
diff --git a/internal/game/sys_assassin.go b/internal/game/sys_assassin.go
index 1927399..720529c 100644
--- a/internal/game/sys_assassin.go
+++ b/internal/game/sys_assassin.go
@@ -51,9 +51,9 @@ func (g *Game) assignAssassinTask(sess *net.Session, p *player.Player) {
 		}
 	}
 	count := chosen.MinCount + rand.Intn(chosen.MaxCount-chosen.MinCount+1)
-	setPlayerFlag(p, "assassin_task_mob", chosen.MobID)
-	setPlayerFlag(p, "assassin_task_total", count)
-	setPlayerFlag(p, "assassin_task_remaining", count)
+	g.setPlayerFlag(p, "assassin_task_mob", chosen.MobID)
+	g.setPlayerFlag(p, "assassin_task_total", count)
+	g.setPlayerFlag(p, "assassin_task_remaining", count)
 	g.AccountStore.SaveCharacter(p)
 
 	def, err := g.MobStore.LoadDef(chosen.MobID)
@@ -79,20 +79,20 @@ func (g *Game) onAssassinKill(sess *net.Session, p *player.Player, mob *world.Mo
 		sess.WriteLine(g.colorize(sess, "xp", fmt.Sprintf("  (+%dxp asm)", xp)))
 	}
 	remaining--
-	setPlayerFlag(p, "assassin_task_remaining", remaining)
+	g.setPlayerFlag(p, "assassin_task_remaining", remaining)
 	if remaining <= 0 {
 		completed := getPlayerFlagInt(p, "assassin_tasks_completed") + 1
 		streak := getPlayerFlagInt(p, "assassin_streak") + 1
-		setPlayerFlag(p, "assassin_tasks_completed", completed)
-		setPlayerFlag(p, "assassin_streak", streak)
+		g.setPlayerFlag(p, "assassin_tasks_completed", completed)
+		g.setPlayerFlag(p, "assassin_streak", streak)
 		delete(p.Flags, "assassin_task_mob")
-		setPlayerFlag(p, "assassin_task_remaining", 0)
-		setPlayerFlag(p, "assassin_task_total", 0)
+		g.setPlayerFlag(p, "assassin_task_remaining", 0)
+		g.setPlayerFlag(p, "assassin_task_total", 0)
 		rep := 1
 		bonus := streakBonus(streak)
 		rep += bonus
 		currentRep := getPlayerFlagInt(p, "assassin_reputation")
-		setPlayerFlag(p, "assassin_reputation", currentRep+rep)
+		g.setPlayerFlag(p, "assassin_reputation", currentRep+rep)
 		sess.WriteLine(g.colorize(sess, "assassin_task", fmt.Sprintf("\n*** Assassin task complete! ***")))
 		if bonus > 0 {
 			sess.WriteLine(g.colorize(sess, "assassin_task", fmt.Sprintf("  Streak bonus! %d tasks in a row. +%d bonus reputation.", streak, bonus)))
@@ -116,11 +116,11 @@ func (g *Game) skipAssassinTask(sess *net.Session, p *player.Player) {
 		sess.WriteLine("You don't have enough Reputation to skip. (Need 30, have " + fmt.Sprint(rep) + ")")
 		return
 	}
-	setPlayerFlag(p, "assassin_reputation", rep-30)
+	g.setPlayerFlag(p, "assassin_reputation", rep-30)
 	delete(p.Flags, "assassin_task_mob")
-	setPlayerFlag(p, "assassin_task_remaining", 0)
-	setPlayerFlag(p, "assassin_task_total", 0)
-	setPlayerFlag(p, "assassin_streak", 0)
+	g.setPlayerFlag(p, "assassin_task_remaining", 0)
+	g.setPlayerFlag(p, "assassin_task_total", 0)
+	g.setPlayerFlag(p, "assassin_streak", 0)
 	g.AccountStore.SaveCharacter(p)
 }
 
@@ -135,15 +135,15 @@ func (g *Game) extendAssassinTask(sess *net.Session, p *player.Player) {
 		sess.WriteLine("You don't have an active task to extend.")
 		return
 	}
-	setPlayerFlag(p, "assassin_reputation", rep-30)
+	g.setPlayerFlag(p, "assassin_reputation", rep-30)
 	total := getPlayerFlagInt(p, "assassin_task_total")
 	remaining := getPlayerFlagInt(p, "assassin_task_remaining")
 	extension := total / 2
 	if extension < 5 {
 		extension = 5
 	}
-	setPlayerFlag(p, "assassin_task_total", total+extension)
-	setPlayerFlag(p, "assassin_task_remaining", remaining+extension)
+	g.setPlayerFlag(p, "assassin_task_total", total+extension)
+	g.setPlayerFlag(p, "assassin_task_remaining", remaining+extension)
 	g.AccountStore.SaveCharacter(p)
 
 	def, _ := g.MobStore.LoadDef(taskMob)
diff --git a/internal/game/triggers.go b/internal/game/triggers.go
new file mode 100644
index 0000000..76ce9cd
--- /dev/null
+++ b/internal/game/triggers.go
@@ -0,0 +1,291 @@
+package game
+
+import (
+	"fmt"
+	"strings"
+
+	"thehouseoficarus/internal/engine"
+	"thehouseoficarus/internal/net"
+	"thehouseoficarus/internal/player"
+	"thehouseoficarus/internal/world"
+)
+
+func (g *Game) TriggerSeqTick() {
+	g.processPlayerTriggerSequences()
+	g.processWorldTriggerSequences()
+}
+
+func (g *Game) TransientMobTick() {
+	if g.Hub == nil {
+		return
+	}
+	for _, inst := range g.MobStore.AllInstances() {
+		if inst.Owner == "" || inst.HP <= 0 {
+			continue
+		}
+		if !inst.DespawnOnLeave {
+			continue
+		}
+
+		g.charsMu.Lock()
+		ownerSess := g.loggedInChars[inst.Owner]
+		g.charsMu.Unlock()
+		if ownerSess == nil || ownerSess.Player == nil {
+			continue
+		}
+
+		ownerRoom := ownerSess.Player.RoomID
+		allowed := inst.DespawnRooms
+		if len(allowed) == 0 {
+			allowed = []int{inst.HomeRoomID}
+		}
+		inAllowed := false
+		for _, r := range allowed {
+			if ownerRoom == r {
+				inAllowed = true
+				break
+			}
+		}
+		if inAllowed {
+			inst.DespawnCounter = inst.DespawnTickCount()
+			continue
+		}
+		inst.DecrementDespawnCounter()
+		if inst.DespawnCounter <= 0 {
+			g.MobStore.RemoveInstance(inst.InstanceID)
+			for _, sess := range g.Hub.PlayersInRoom(inst.RoomID) {
+				sess.WriteLine(g.colorize(sess, "broadcast",
+					fmt.Sprintf("\n%s fades away.", mobDisplayName(inst, true))))
+			}
+		}
+	}
+}
+
+func (g *Game) processPlayerTriggerSequences() {
+	seqs := g.TriggerStore.SnapshotPlayerSeqs()
+	for _, seq := range seqs {
+		g.charsMu.Lock()
+		sess := g.loggedInChars[seq.PlayerName]
+		g.charsMu.Unlock()
+		if sess == nil || sess.Player == nil {
+			g.TriggerStore.RemovePlayerSeq(seq.PlayerName, seq.TriggerID)
+			continue
+		}
+		p := sess.Player
+		if p.RoomID != seq.RoomID {
+			continue
+		}
+
+		seq.Wait--
+		if seq.Wait > 0 {
+			continue
+		}
+
+		var jobs []world.TriggerStep
+		for len(seq.Steps) > 0 && seq.Wait <= 0 {
+			step := seq.Steps[0]
+			seq.Steps = seq.Steps[1:]
+			jobs = append(jobs, step)
+			if len(seq.Steps) > 0 {
+				seq.Wait = seq.Steps[0].Delay
+			}
+		}
+
+		for _, step := range jobs {
+			g.executeTriggerStep(sess, p, &step, seq.RoomID, seq.FlagValue)
+		}
+
+		if len(seq.Steps) == 0 {
+			g.TriggerStore.RemovePlayerSeq(seq.PlayerName, seq.TriggerID)
+			if p.RoomID == seq.RoomID && sess.State == net.StateGame {
+				g.writePrompt(sess)
+			}
+		}
+	}
+}
+
+func (g *Game) processWorldTriggerSequences() {
+	seqs := g.TriggerStore.SnapshotWorldSeqs()
+	for _, seq := range seqs {
+		seq.Wait--
+		if seq.Wait > 0 {
+			continue
+		}
+
+		var jobs []world.TriggerStep
+		for len(seq.Steps) > 0 && seq.Wait <= 0 {
+			step := seq.Steps[0]
+			seq.Steps = seq.Steps[1:]
+			jobs = append(jobs, step)
+			if len(seq.Steps) > 0 {
+				seq.Wait = seq.Steps[0].Delay
+			}
+		}
+
+		for _, step := range jobs {
+			g.executeWorldTriggerStep(&step, seq.RoomID, seq.FlagValue)
+		}
+
+		if len(seq.Steps) == 0 {
+			g.TriggerStore.RemoveWorldSeq(seq.TriggerID)
+		}
+	}
+}
+
+func (g *Game) executeTriggerStep(sess *net.Session, p *player.Player, step *world.TriggerStep, roomID int, flagValue any) {
+	if step.Message != "" {
+		msg := expandTemplate(step.Message, p.Name, flagValue)
+		sess.WriteLine(msg)
+	}
+	if step.Broadcast != "" && g.Hub != nil {
+		msg := expandTemplate(step.Broadcast, p.Name, flagValue)
+		for _, other := range g.Hub.PlayersInRoom(roomID) {
+			other.WriteLine(g.colorize(other, "broadcast", "\n"+msg))
+		}
+	}
+	if step.BroadcastGlobal != "" && g.Hub != nil {
+		msg := expandTemplate(step.BroadcastGlobal, p.Name, flagValue)
+		for _, other := range g.Hub.AllSessions() {
+			if other.Player != nil {
+				other.WriteLine(g.colorize(other, "broadcast", "\n"+msg))
+			}
+		}
+	}
+	if len(step.SetFlags) > 0 {
+		g.Flags.SetAll(step.SetFlags)
+	}
+	if len(step.SetPlayerFlags) > 0 {
+		for k, v := range step.SetPlayerFlags {
+			g.setPlayerFlag(p, k, v)
+		}
+		g.AccountStore.SaveCharacter(p)
+	}
+	if step.GiveItem != "" {
+		slot := p.FirstFreeSlot()
+		if slot == -1 {
+			sess.WriteLine("Your inventory is too full to receive that.")
+		} else {
+			p.SetInvSlot(slot, &player.InventorySlot{ItemID: step.GiveItem, Quantity: 1})
+			g.AccountStore.SaveCharacter(p)
+		}
+	}
+	if step.TakeItem != "" {
+		if p.HasItem(step.TakeItem) {
+			p.RemoveItem(step.TakeItem, 1)
+			g.AccountStore.SaveCharacter(p)
+		}
+	}
+	if step.Heal > 0 {
+		p.HP += step.Heal
+		if maxHP := p.MaxHP(); p.HP > maxHP {
+			p.HP = maxHP
+		}
+		g.AccountStore.SaveCharacter(p)
+		sess.WriteLine(fmt.Sprintf("You regain %d hitpoints.", step.Heal))
+	}
+	if step.SpawnMob != nil {
+		g.spawnTriggerMob(sess, p, step.SpawnMob, roomID)
+	}
+	if step.DespawnMob != "" {
+		g.despawnTriggerMobs(step.DespawnMob, p.Name)
+	}
+	if step.Teleport > 0 {
+		g.teleportPlayer(sess, p, step.Teleport)
+	}
+}
+
+func (g *Game) executeWorldTriggerStep(step *world.TriggerStep, roomID int, flagValue any) {
+	if step.Broadcast != "" && g.Hub != nil {
+		msg := expandTemplate(step.Broadcast, "", flagValue)
+		for _, other := range g.Hub.PlayersInRoom(roomID) {
+			other.WriteLine(g.colorize(other, "broadcast", "\n"+msg))
+		}
+	}
+	if step.BroadcastGlobal != "" && g.Hub != nil {
+		msg := expandTemplate(step.BroadcastGlobal, "", flagValue)
+		for _, other := range g.Hub.AllSessions() {
+			if other.Player != nil {
+				other.WriteLine(g.colorize(other, "broadcast", "\n"+msg))
+			}
+		}
+	}
+	if len(step.SetFlags) > 0 {
+		g.Flags.SetAll(step.SetFlags)
+	}
+	if step.SpawnMob != nil {
+		g.spawnWorldTriggerMob(step.SpawnMob, roomID)
+	}
+	if step.DespawnMob != "" {
+		g.despawnTriggerMobs(step.DespawnMob, "")
+	}
+}
+
+func (g *Game) spawnTriggerMob(sess *net.Session, p *player.Player, cfg *world.SpawnMobConfig, roomID int) {
+	if cfg.ID == "" {
+		return
+	}
+	def, err := g.MobStore.LoadDef(cfg.ID)
+	if err != nil {
+		return
+	}
+	inst := g.MobStore.SpawnTransient(def, cfg, roomID, p.Name)
+	if inst == nil {
+		return
+	}
+	inst.ResetDespawnCounter(engine.ToTicks(cfg.DespawnTicks))
+	sess.WriteLine(g.colorize(sess, "broadcast", "\n"+mobDisplayName(inst, true)+" appears!"))
+}
+
+func (g *Game) spawnWorldTriggerMob(cfg *world.SpawnMobConfig, roomID int) {
+	if cfg.ID == "" {
+		return
+	}
+	def, err := g.MobStore.LoadDef(cfg.ID)
+	if err != nil {
+		return
+	}
+	inst := g.MobStore.SpawnTransient(def, cfg, roomID, "")
+	if inst == nil {
+		return
+	}
+	inst.ResetDespawnCounter(engine.ToTicks(cfg.DespawnTicks))
+	if g.Hub != nil {
+		for _, sess := range g.Hub.PlayersInRoom(roomID) {
+			sess.WriteLine(g.colorize(sess, "broadcast",
+				"\n"+mobDisplayName(inst, true)+" appears!"))
+		}
+	}
+}
+
+func (g *Game) despawnTriggerMobs(mobID string, owner string) {
+	for _, inst := range g.MobStore.AllInstances() {
+		if inst.DefID != mobID {
+			continue
+		}
+		if owner != "" && inst.Owner != owner {
+			continue
+		}
+		if inst.HP <= 0 {
+			g.MobStore.RemoveInstance(inst.InstanceID)
+			continue
+		}
+		if g.Hub != nil {
+			for _, sess := range g.Hub.PlayersInRoom(inst.RoomID) {
+				sess.WriteLine(g.colorize(sess, "broadcast",
+					fmt.Sprintf("\n%s vanishes.", mobDisplayName(inst, true))))
+			}
+		}
+		g.MobStore.RemoveInstance(inst.InstanceID)
+	}
+}
+
+func expandTemplate(tmpl string, playerName string, flagValue any) string {
+	s := tmpl
+	if playerName != "" {
+		s = strings.ReplaceAll(s, "%p", playerName)
+	}
+	if flagValue != nil {
+		s = strings.ReplaceAll(s, "%v", fmt.Sprint(flagValue))
+	}
+	return s
+}
diff --git a/internal/validate/checks.go b/internal/validate/checks.go
index 6aa0a81..197b8d3 100644
--- a/internal/validate/checks.go
+++ b/internal/validate/checks.go
@@ -521,6 +521,74 @@ func validateCourses(s Source) []Issue {
 	return issues
 }
 
+func validateRoomTriggers(s Source) []Issue {
+	var issues []Issue
+	roomIndex := s.World.RoomIndex()
+	itemIDs := s.Items.IDSet()
+	mobIDs := s.Mobs.AllDefIDs()
+
+	for id := range roomIndex {
+		room, err := s.World.LoadRoom(id)
+		if err != nil || len(room.Triggers) == 0 {
+			continue
+		}
+		for ti, trigger := range room.Triggers {
+			prefix := fmt.Sprintf("Room %d: trigger[%d]", id, ti)
+			for si, step := range trigger.Steps {
+				stepPrefix := fmt.Sprintf("%s: step[%d]", prefix, si)
+				if step.SpawnMob != nil && step.SpawnMob.ID != "" {
+					if _, ok := mobIDs[step.SpawnMob.ID]; !ok {
+						issues = append(issues, Issue{
+							Level: "ERROR",
+							Type:  "reference",
+							Message: fmt.Sprintf("%s: spawn_mob %q does not exist",
+								stepPrefix, step.SpawnMob.ID),
+						})
+					}
+					for _, wr := range step.SpawnMob.DespawnRooms {
+						if _, ok := roomIndex[wr]; !ok {
+							issues = append(issues, Issue{
+								Level: "ERROR",
+								Type:  "reference",
+								Message: fmt.Sprintf("%s: spawn_mob despawn_rooms references nonexistent room %d",
+									stepPrefix, wr),
+							})
+						}
+					}
+				}
+				if step.GiveItem != "" && !itemIDs[step.GiveItem] {
+					issues = append(issues, Issue{
+						Level: "ERROR",
+						Type:  "reference",
+						Message: fmt.Sprintf("%s: give_item %q does not exist",
+							stepPrefix, step.GiveItem),
+					})
+				}
+				if step.TakeItem != "" && !itemIDs[step.TakeItem] {
+					issues = append(issues, Issue{
+						Level: "ERROR",
+						Type:  "reference",
+						Message: fmt.Sprintf("%s: take_item %q does not exist",
+							stepPrefix, step.TakeItem),
+					})
+				}
+				if step.Teleport > 0 {
+					if _, ok := roomIndex[step.Teleport]; !ok {
+						issues = append(issues, Issue{
+							Level: "ERROR",
+							Type:  "reference",
+							Message: fmt.Sprintf("%s: teleport to nonexistent room %d",
+								stepPrefix, step.Teleport),
+						})
+					}
+				}
+			}
+		}
+	}
+
+	return issues
+}
+
 func validateRoomWiring(s Source) []Issue {
 	var issues []Issue
 	roomIndex := s.World.RoomIndex()
diff --git a/internal/validate/validate.go b/internal/validate/validate.go
index 5557f72..3918c95 100644
--- a/internal/validate/validate.go
+++ b/internal/validate/validate.go
@@ -63,6 +63,7 @@ func Run(s Source) []Issue {
 		{"items", "item"}, {"rooms", "room"}, {"mobs", "mob"},
 		{"objects", "object"}, {"drops", "drop table"}, {"courses", "course"},
 		{"modules", "module"}, {"techs", "tech"}, {"help", "help topic"},
+		{"triggers", "trigger"},
 	} {
 		issues = append(issues, validateIDs(s.DataDir, dir.sub, dir.label)...)
 	}
@@ -75,6 +76,7 @@ func Run(s Source) []Issue {
 	issues = append(issues, validateCraftBlocks(s)...)
 	issues = append(issues, validateDropTables(s)...)
 	issues = append(issues, validateCourses(s)...)
+	issues = append(issues, validateRoomTriggers(s)...)
 	issues = append(issues, validateTechs(s)...)
 	issues = append(issues, validateRoomWiring(s)...)
 
diff --git a/internal/world/mob.go b/internal/world/mob.go
index f11d6fe..d3ea05b 100644
--- a/internal/world/mob.go
+++ b/internal/world/mob.go
@@ -127,6 +127,14 @@ type MobInstance struct {
 	CompleteMessage string
 
 	TalkConfig *behavior.TalkConfig
+
+	Owner             string
+	OwnerOnly         bool
+	SpawnedByTrigger  bool
+	DespawnOnLeave    bool
+	DespawnRooms      []int
+	DespawnTicks      float64
+	DespawnCounter    int
 }
 
 func (m *MobInstance) IsTalkable() bool { return m.TalkConfig != nil }
@@ -215,6 +223,20 @@ func (m *MobInstance) StartRegen() {
 	}
 }
 
+func (m *MobInstance) DespawnTickCount() int {
+	return m.DespawnCounter
+}
+
+func (m *MobInstance) DecrementDespawnCounter() {
+	if m.DespawnCounter > 0 {
+		m.DespawnCounter--
+	}
+}
+
+func (m *MobInstance) ResetDespawnCounter(ticks int) {
+	m.DespawnCounter = ticks
+}
+
 type MobStore struct {
 	dataDir   string
 	mu        sync.Mutex
@@ -326,6 +348,29 @@ func (s *MobStore) RollIdleDescription(inst *MobInstance) {
 	inst.WanderTickCounter = 0
 }
 
+func (s *MobStore) SpawnTransient(def *MobDef, cfg *SpawnMobConfig, roomID int, owner string) *MobInstance {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	instID := fmt.Sprintf("trigger_%s_%d_%d", cfg.ID, roomID, len(s.instances))
+	inst := NewMobInstance(def, instID, roomID, nil, 0)
+	inst.Owner = owner
+	inst.OwnerOnly = cfg.OwnerOnly
+	inst.SpawnedByTrigger = true
+	inst.DespawnOnLeave = cfg.DespawnOnLeave
+	inst.DespawnRooms = cfg.DespawnRooms
+	inst.DespawnTicks = cfg.DespawnTicks
+	inst.IdleDescription = pickIdleDescription(def.IdleDescriptions)
+	s.instances[instID] = inst
+	return inst
+}
+
+func (s *MobStore) RemoveInstance(instanceID string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	delete(s.instances, instanceID)
+}
+
 func (s *MobStore) SeedMobs(roomID int, entries []RoomMob) {
 	type defWrapper struct {
 		def *MobDef
diff --git a/internal/world/room.go b/internal/world/room.go
index 71a36ed..22e7f79 100644
--- a/internal/world/room.go
+++ b/internal/world/room.go
@@ -75,6 +75,7 @@ type Room struct {
 	Mobs        []RoomMob           `yaml:"mobs"`
 	OnEnter     []EnterStep         `yaml:"on_enter"`
 	Hazard      string              `yaml:"hazard"`
+	Triggers    []TriggerDef        `yaml:"triggers"`
 }
 
 type RoomMob struct {
diff --git a/internal/world/trigger.go b/internal/world/trigger.go
new file mode 100644
index 0000000..7c06be4
--- /dev/null
+++ b/internal/world/trigger.go
@@ -0,0 +1,61 @@
+package world
+
+import (
+	"gopkg.in/yaml.v3"
+)
+
+type TriggerDef struct {
+	ID           string        `yaml:"id"`
+	OnPlayerFlag string        `yaml:"on_player_flag"`
+	OnFlag       string        `yaml:"on_flag"`
+	Value        any           `yaml:"value"`
+	Room         int           `yaml:"room"`
+	Steps        []TriggerStep `yaml:"steps"`
+}
+
+func (t *TriggerDef) IsPlayerFlagTrigger() bool { return t.OnPlayerFlag != "" }
+
+func (t *TriggerDef) IsWorldFlagTrigger() bool { return t.OnFlag != "" }
+
+type TriggerStep struct {
+	Delay           int             `yaml:"delay"`
+	Message         string          `yaml:"message"`
+	Broadcast       string          `yaml:"broadcast"`
+	BroadcastGlobal string          `yaml:"broadcast_global"`
+	SetFlags        map[string]any  `yaml:"set_flags"`
+	SetPlayerFlags  map[string]any  `yaml:"set_player_flags"`
+	SpawnMob        *SpawnMobConfig `yaml:"spawn_mob"`
+	GiveItem        string          `yaml:"give_item"`
+	TakeItem        string          `yaml:"take_item"`
+	Teleport        int             `yaml:"teleport"`
+	Heal            int             `yaml:"heal"`
+	DespawnMob      string          `yaml:"despawn_mob"`
+}
+
+type SpawnMobConfig struct {
+	ID             string   `yaml:"id"`
+	OwnerOnly      bool     `yaml:"owner_only"`
+	DespawnOnLeave bool     `yaml:"despawn_on_leave"`
+	DespawnRooms   []int    `yaml:"despawn_rooms"`
+	DespawnTicks   float64 `yaml:"despawn_ticks"`
+}
+
+func (s *SpawnMobConfig) UnmarshalYAML(value *yaml.Node) error {
+	if value.Kind == yaml.ScalarNode {
+		var id string
+		if err := value.Decode(&id); err != nil {
+			return err
+		}
+		s.ID = id
+		return nil
+	}
+	type raw SpawnMobConfig
+	return value.Decode((*raw)(s))
+}
+
+func (t TriggerStep) IsTimed() bool {
+	return t.Delay > 0 || len(t.SetFlags) > 0 || len(t.SetPlayerFlags) > 0 ||
+		t.Message != "" || t.Broadcast != "" || t.BroadcastGlobal != "" ||
+		t.SpawnMob != nil || t.GiveItem != "" || t.TakeItem != "" ||
+		t.Teleport != 0 || t.Heal != 0 || t.DespawnMob != ""
+}
diff --git a/internal/world/trigger_store.go b/internal/world/trigger_store.go
new file mode 100644
index 0000000..f00d256
--- /dev/null
+++ b/internal/world/trigger_store.go
@@ -0,0 +1,340 @@
+package world
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"gopkg.in/yaml.v3"
+)
+
+type TriggerStore struct {
+	mu sync.Mutex
+
+	globalByPlayerFlag map[string][]*TriggerDef
+	globalByWorldFlag  map[string][]*TriggerDef
+	roomByPlayerFlag   map[int]map[string][]*TriggerDef
+	roomByWorldFlag    map[int]map[string][]*TriggerDef
+
+	playerSeqs map[string]*PlayerTriggerSeq
+	worldSeqs  map[string]*WorldTriggerSeq
+}
+
+type PlayerTriggerSeq struct {
+	PlayerName string
+	TriggerID  string
+	RoomID     int
+	Steps      []TriggerStep
+	Wait       int
+	Started    bool
+	FlagValue  any
+}
+
+type WorldTriggerSeq struct {
+	TriggerID string
+	RoomID    int
+	Steps     []TriggerStep
+	Wait      int
+	FlagValue any
+}
+
+func NewTriggerStore() *TriggerStore {
+	return &TriggerStore{
+		globalByPlayerFlag: make(map[string][]*TriggerDef),
+		globalByWorldFlag:  make(map[string][]*TriggerDef),
+		roomByPlayerFlag:   make(map[int]map[string][]*TriggerDef),
+		roomByWorldFlag:    make(map[int]map[string][]*TriggerDef),
+		playerSeqs:         make(map[string]*PlayerTriggerSeq),
+		worldSeqs:          make(map[string]*WorldTriggerSeq),
+	}
+}
+
+func (ts *TriggerStore) LoadGlobal(dataDir string) error {
+	dir := filepath.Join(dataDir, "triggers")
+	if _, err := os.Stat(dir); os.IsNotExist(err) {
+		return nil
+	}
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return err
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+		path := filepath.Join(dir, entry.Name())
+		ext := strings.ToLower(filepath.Ext(path))
+		if ext != ".yaml" && ext != ".yml" {
+			continue
+		}
+		id := strings.TrimSuffix(entry.Name(), filepath.Ext(entry.Name()))
+		data, err := os.ReadFile(path)
+		if err != nil {
+			continue
+		}
+		var trigger TriggerDef
+		if err := yaml.Unmarshal(data, &trigger); err != nil {
+			return fmt.Errorf("trigger %q: %w", path, err)
+		}
+		trigger.ID = id
+		ts.addGlobal(&trigger)
+	}
+	return nil
+}
+
+func (ts *TriggerStore) SeedRoomTriggers(roomID int, triggers []TriggerDef) {
+	if len(triggers) == 0 {
+		return
+	}
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	for i := range triggers {
+		t := &triggers[i]
+		if t.IsPlayerFlagTrigger() {
+			if ts.roomByPlayerFlag[roomID] == nil {
+				ts.roomByPlayerFlag[roomID] = make(map[string][]*TriggerDef)
+			}
+			ts.roomByPlayerFlag[roomID][t.OnPlayerFlag] = append(
+				ts.roomByPlayerFlag[roomID][t.OnPlayerFlag], t)
+		}
+		if t.IsWorldFlagTrigger() {
+			if ts.roomByWorldFlag[roomID] == nil {
+				ts.roomByWorldFlag[roomID] = make(map[string][]*TriggerDef)
+			}
+			t.Room = roomID
+			ts.roomByWorldFlag[roomID][t.OnFlag] = append(
+				ts.roomByWorldFlag[roomID][t.OnFlag], t)
+		}
+	}
+}
+
+func (ts *TriggerStore) addGlobal(t *TriggerDef) {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	if t.IsPlayerFlagTrigger() {
+		ts.globalByPlayerFlag[t.OnPlayerFlag] = append(
+			ts.globalByPlayerFlag[t.OnPlayerFlag], t)
+	}
+	if t.IsWorldFlagTrigger() {
+		ts.globalByWorldFlag[t.OnFlag] = append(
+			ts.globalByWorldFlag[t.OnFlag], t)
+	}
+}
+
+func (ts *TriggerStore) FirePlayer(playerName string, flagName string, flagValue any) []*PlayerTriggerSeq {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+
+	var started []*PlayerTriggerSeq
+
+	for _, t := range ts.globalByPlayerFlag[flagName] {
+		if !ts.valueMatches(t.Value, flagValue) {
+			continue
+		}
+		seq := ts.startPlayerSeqLocked(playerName, t, 0, flagValue)
+		if seq != nil {
+			started = append(started, seq)
+		}
+	}
+
+	return started
+}
+
+func (ts *TriggerStore) FirePlayerInRoom(playerName string, roomID int, flagName string, flagValue any) []*PlayerTriggerSeq {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+
+	var started []*PlayerTriggerSeq
+
+	for _, t := range ts.globalByPlayerFlag[flagName] {
+		if !ts.valueMatches(t.Value, flagValue) {
+			continue
+		}
+		seq := ts.startPlayerSeqLocked(playerName, t, roomID, flagValue)
+		if seq != nil {
+			started = append(started, seq)
+		}
+	}
+
+	if roomFlags, ok := ts.roomByPlayerFlag[roomID]; ok {
+		for _, t := range roomFlags[flagName] {
+			if !ts.valueMatches(t.Value, flagValue) {
+				continue
+			}
+			seq := ts.startPlayerSeqLocked(playerName, t, roomID, flagValue)
+			if seq != nil {
+				started = append(started, seq)
+			}
+		}
+	}
+
+	return started
+}
+
+func (ts *TriggerStore) FireWorld(flagName string, flagValue any) []*WorldTriggerSeq {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+
+	var started []*WorldTriggerSeq
+
+	for _, t := range ts.globalByWorldFlag[flagName] {
+		if !ts.valueMatches(t.Value, flagValue) {
+			continue
+		}
+		seq := ts.startWorldSeqLocked(t, flagValue)
+		if seq != nil {
+			started = append(started, seq)
+		}
+	}
+
+	for roomID, roomFlags := range ts.roomByWorldFlag {
+		for _, t := range roomFlags[flagName] {
+			if !ts.valueMatches(t.Value, flagValue) {
+				continue
+			}
+			if t.Room == 0 {
+				t.Room = roomID
+			}
+			seq := ts.startWorldSeqLocked(t, flagValue)
+			if seq != nil {
+				started = append(started, seq)
+			}
+		}
+	}
+
+	return started
+}
+
+func (ts *TriggerStore) startPlayerSeqLocked(playerName string, t *TriggerDef, roomID int, flagValue any) *PlayerTriggerSeq {
+	key := playerName + ":" + t.ID
+	if _, exists := ts.playerSeqs[key]; exists {
+		return nil
+	}
+	seq := &PlayerTriggerSeq{
+		PlayerName: playerName,
+		TriggerID:  t.ID,
+		RoomID:     roomID,
+		Steps:      make([]TriggerStep, len(t.Steps)),
+		FlagValue:  flagValue,
+	}
+	copy(seq.Steps, t.Steps)
+	if len(seq.Steps) > 0 {
+		seq.Wait = seq.Steps[0].Delay
+	}
+	ts.playerSeqs[key] = seq
+	return seq
+}
+
+func (ts *TriggerStore) startWorldSeqLocked(t *TriggerDef, flagValue any) *WorldTriggerSeq {
+	key := t.ID
+	if _, exists := ts.worldSeqs[key]; exists {
+		return nil
+	}
+	seq := &WorldTriggerSeq{
+		TriggerID: t.ID,
+		RoomID:    t.Room,
+		Steps:     make([]TriggerStep, len(t.Steps)),
+		FlagValue: flagValue,
+	}
+	copy(seq.Steps, t.Steps)
+	if len(seq.Steps) > 0 {
+		seq.Wait = seq.Steps[0].Delay
+	}
+	ts.worldSeqs[key] = seq
+	return seq
+}
+
+func (ts *TriggerStore) valueMatches(want, got any) bool {
+	if want == nil {
+		return true
+	}
+	return valuesEqual(want, got)
+}
+
+func (ts *TriggerStore) SnapshotPlayerSeqs() []*PlayerTriggerSeq {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	out := make([]*PlayerTriggerSeq, 0, len(ts.playerSeqs))
+	for _, s := range ts.playerSeqs {
+		out = append(out, s)
+	}
+	return out
+}
+
+func (ts *TriggerStore) SnapshotWorldSeqs() []*WorldTriggerSeq {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	out := make([]*WorldTriggerSeq, 0, len(ts.worldSeqs))
+	for _, s := range ts.worldSeqs {
+		out = append(out, s)
+	}
+	return out
+}
+
+func (ts *TriggerStore) RemovePlayerSeq(playerName, triggerID string) {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	key := playerName + ":" + triggerID
+	delete(ts.playerSeqs, key)
+}
+
+func (ts *TriggerStore) RemoveWorldSeq(triggerID string) {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	delete(ts.worldSeqs, triggerID)
+}
+
+func (ts *TriggerStore) AllGlobalTriggers() []*TriggerDef {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	var out []*TriggerDef
+	for _, triggers := range ts.globalByPlayerFlag {
+		out = append(out, triggers...)
+	}
+	for _, triggers := range ts.globalByWorldFlag {
+		out = append(out, triggers...)
+	}
+	return out
+}
+
+func valuesEqual(a, b any) bool {
+	ai, aok := numericValue(a)
+	bi, bok := numericValue(b)
+	if aok && bok {
+		return ai == bi
+	}
+	return a == b
+}
+
+func numericValue(v any) (float64, bool) {
+	switch x := v.(type) {
+	case int:
+		return float64(x), true
+	case int64:
+		return float64(x), true
+	case float64:
+		return x, true
+	}
+	return 0, false
+}
+
+func (ts *TriggerStore) AllRoomTriggers() map[int][]*TriggerDef {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	out := make(map[int][]*TriggerDef)
+	for roomID, byFlag := range ts.roomByPlayerFlag {
+		for _, triggers := range byFlag {
+			out[roomID] = append(out[roomID], triggers...)
+		}
+	}
+	for roomID, byFlag := range ts.roomByWorldFlag {
+		for _, triggers := range byFlag {
+			out[roomID] = append(out[roomID], triggers...)
+		}
+	}
+	return out
+}