N6/C2: player-initiated duels — staked, no-death PvP

`!duel @user [stake]` (+ `!adventure duel`; accept/decline/status). A staked
arena bout resolved through the auto-resolve combat engine.

The engine is asymmetric — N player-seats vs one monster-shaped enemy, no seat
for a second PC — so a duel builds each fighter as their real player Combatant
and synthesises the opponent as an enemy stat block from their sheet. That is
lopsided (player side = full kit, enemy = flat stat block), so the bout runs
BOTH orientations and decides on aggregate remaining-HP fraction, cancelling the
attacker-seat edge. To-hit stays faithful both ways (d20 + AttackBonus vs AC);
damage folds into one enemy Attack (per-hit × swings + companion-proc
expectation); DamageReduct ports over. Casters fight weapon-only in both
orientations — accepted, PvP class balance is out of scope per the plan.

Economics: both escrow the stake on accept (pool 2×stake); winner 70%, community
pot rakes 30% (a sink); exact-HP-tie draw refunds both. Stake capped at
level×€500. W/L reuses adventure_rival_records; shared 7-day pair cooldown.

Terminal fate is serialised by an atomic claim (DELETE … WHERE id=? gated on
RowsAffected==1, mirroring communityPotDebit): accept/decline/the expiry ticker
all claim first, only the winner moves euros — no stake can be both resolved and
refunded across the 24h boundary. issueDuel runs under advUserLock; accept
re-checks the challenger and builds both fighters before debiting the challenged.
Rides the 1-min eventTicker; combat golden byte-identical; suite green.

Claude-Session: https://claude.ai/code/session_017mEwUmmS7aQTP2NQXj6rUa

.env.example

@@ -1,12 +1,50 @@
 # ---- Matrix Connection ----
+# GogoBee authenticates via the MAS (Matrix Authentication Service) OAuth 2.0
+# device grant. No password/token goes here: on first run the bot prints a URL
+# + code to approve ONCE in a browser (logged in as BOT_USER_ID), then stores a
+# refresh token in DATA_DIR/mas_auth.json and refreshes silently thereafter.
+# To force re-authorization, delete data/mas_auth.json.
 HOMESERVER_URL=https://matrix.example.com
 BOT_USER_ID=@gogobee:example.com
-BOT_PASSWORD=your_password_here
 BOT_DISPLAY_NAME=GogoBee
 
+# ---- Auth mode ----
+# masdevice (default) — MAS OAuth 2.0 device grant over /sync (above).
+# appservice          — Matrix appservice: the registration's as_token is the
+#                       credential (no login/MFA/expiry, MAS-durable). The bot
+#                       runs an HTTP listener and receives events over Synapse's
+#                       transaction push instead of /sync (Synapse forbids AS
+#                       users from /sync). E2EE rides MSC3202/MSC2409 + MSC4190.
+AUTH_MODE=masdevice
+# The following are required only when AUTH_MODE=appservice:
+AS_REGISTRATION=            # path to the appservice registration YAML (as_token/hs_token/namespaces)
+AS_LISTEN_HOST=             # bind address for the transaction listener (e.g. 0.0.0.0 or a tailnet IP)
+AS_LISTEN_PORT=             # bind port; Synapse's registration url must reach host:port
+HOMESERVER_DOMAIN=          # server_name, e.g. example.com (derives the bot MXID from sender_localpart)
+
+# ---- Cross-signing (optional; both auth modes) ----
+# Controls only whether the bot shows as VERIFIED in clients — E2EE works without it.
+# Normally you set NEITHER of these. On its first start the bot mints a cross-signing
+# identity and persists the recovery key itself to DATA_DIR/cross_signing.json (0600);
+# every later start reuses that identity untouched, so users verify the bot once, ever.
+#
+# Set to 1 for exactly ONE start to throw away the published identity and mint a fresh
+# one (the bot stores the new key itself). Every user must then verify the bot again.
+# Needed only if the identity was lost, or to adopt one the bot can't re-sign.
+CROSS_SIGNING_REGENERATE=
+#
+# Imports an existing recovery key into DATA_DIR/cross_signing.json on next start.
+# Only useful to adopt an identity created before the bot persisted its own key.
+CROSS_SIGNING_RECOVERY_KEY=
+
 # Which rooms the bot posts scheduled content to (comma-separated room IDs)
 BROADCAST_ROOMS=!roomid:example.com
 
+# The daily 08:00 WOTD auto-post is disabled by default.
+# Set to true to enable it. The !wotd command and passive WOTD
+# usage tracking work regardless of this setting.
+ENABLE_WOTD_POST=false
+
 # Admins who can run admin-only commands (comma-separated Matrix user IDs)
 ADMIN_USERS=@yourmxid:example.com
 
@@ -123,3 +161,17 @@ MINIFLUX_MAX_PER_POLL=5        # max entries per feed per poll (default 5)
 RATELIMIT_WEATHER=5
 RATELIMIT_TRANSLATE=20
 RATELIMIT_CONCERTS=10
+
+# ---- Email Nag (one-shot migration helper: collect+verify missing Authentik emails over Matrix DM) ----
+FEATURE_EMAIL_NAG=             # set to "true" to enable
+EMAIL_NAG_AUTHENTIK_URL=       # e.g. https://authentik.parodia.dev
+EMAIL_NAG_AUTHENTIK_TOKEN=     # Authentik service-account token, scoped to user write
+EMAIL_NAG_RESEND_KEY=          # Resend API key (sends the verification code)
+EMAIL_NAG_MAIL_FROM=           # e.g. Parodia <noreply@mail.parodia.dev>
+EMAIL_NAG_HOME_DOMAIN=         # Matrix server name, e.g. parodia.dev (builds @user:domain)
+EMAIL_NAG_TARGETS=             # comma-separated Authentik usernames to nag (== Matrix localparts)
+EMAIL_NAG_CODE_TTL=30m         # verification code lifetime (default 30m)
+EMAIL_NAG_MAX_ATTEMPTS=5       # wrong-code attempts before restart (default 5)
+EMAIL_NAG_MAX_SENDS_PER_HOUR=5 # cap on verification emails per user per rolling hour (anti-spam, default 5)
+EMAIL_NAG_SWEEP_DELAY=2s       # delay between DMs during the startup sweep (default 2s)
+EMAIL_NAG_REPROMPT_COOLDOWN=   # re-nag non-responders whose last prompt is older than this (e.g. 72h); empty/0 = nag once

README.md

@@ -91,7 +91,14 @@ Everything is configured through environment variables or a `.env` file.
 |----------|-------------|
 | `HOMESERVER_URL` | Matrix homeserver URL, e.g. `https://matrix.org` |
 | `BOT_USER_ID` | Bot's Matrix user ID, e.g. `@gogobee:matrix.org` |
-| `BOT_PASSWORD` | Bot's Matrix password |
+
+GogoBee authenticates via the **Matrix Authentication Service (MAS) OAuth 2.0
+device grant** — no password or token in the environment. On first run it prints
+a verification URL and user code; approve it once in a browser while logged in
+as `BOT_USER_ID`. The bot then stores a refresh token in `DATA_DIR/mas_auth.json`
+and refreshes its access token silently for the life of the deployment. Delete
+`data/mas_auth.json` to force re-authorization. Requires a homeserver with MAS
+enabled (advertised via the `org.matrix.msc2965.authentication` well-known).
 
 ### Core (optional)
 

cmd/expedition-sim/main.go

@@ -3,22 +3,33 @@
 // outcomes mirror what live players hit.
 //
 // Single run:
-//   expedition-sim [-class fighter] [-level 5] [-zone goblin_warrens]
-//                  [-bank 1000] [-cap 50] [-log] [-data DIR]
+//
+//	expedition-sim [-class fighter] [-level 5] [-zone goblin_warrens]
+//	               [-bank 1000] [-cap 50] [-log] [-data DIR]
+//
+// Party run (N3/P7 — the leader is -class; followers clone it unless named):
+//
+//	expedition-sim -party 3 -level 15 -zone dragons_lair
+//	expedition-sim -party 2 -class cleric -party-classes fighter -level 16 ...
 //
 // Matrix mode (cartesian sweep over classes × levels × zones × N runs,
 // one JSON object per stdout line, log suppressed by default):
-//   expedition-sim -matrix -classes fighter,mage -levels 5,10 \
-//                  -zones goblin_warrens,wolf_den -runs 20
+//
+//	expedition-sim -matrix -classes fighter,mage -levels 5,10 \
+//	               -zones goblin_warrens,wolf_den -runs 20
 package main
 
 import (
+	"bytes"
 	"encoding/json"
 	"flag"
 	"fmt"
 	"os"
+	"os/exec"
+	"runtime"
 	"strconv"
 	"strings"
+	"sync"
 
 	"gogobee/internal/plugin"
 
@@ -32,6 +43,7 @@ func main() {
 		zone    = flag.String("zone", "goblin_warrens", "zone id (single-run mode)")
 		bank    = flag.Float64("bank", 1000, "starting coin balance — must cover outfitting")
 		cap     = flag.Int("cap", 50, "max autopilot bursts per expedition (each = up to autopilotRoomCap rooms)")
+		days    = flag.Int("days", 0, "stop after N synthetic day rollovers (0 = unbounded; the -cap safety net still applies)")
 		dataDir = flag.String("data", "", "data dir for the temp sqlite db (default: OS tempdir; ignored in matrix mode)")
 		userTag = flag.String("user", "@sim:expedition", "synthetic user id (single-run mode)")
 		logFlag = flag.Bool("log", true, "include per-row expedition log in output (single-run default true; matrix default false)")
@@ -43,10 +55,26 @@ func main() {
 		runs    = flag.Int("runs", 1, "replicates per (class,level,zone) cell (matrix mode)")
 
 		trace = flag.Bool("trace", false, "include raw per-round CombatEvent stream on the LAST combat of each expedition (boss room) — for J2 diagnostic sweeps")
+
+		petLevel = flag.Int("pet-level", 0, "attach a base housing pet at this level (1-10) to every sim character; 0 = no pet (default, matches prod char-creation)")
+
+		party        = flag.Int("party", 1, "seat a party of N (1 = solo, the historical path). Followers are invited on Day 1 and buy their own supplies")
+		partyClasses = flag.String("party-classes", "", "comma-separated classes for the N-1 followers (default: clones of -class)")
+
+		jobs = flag.Int("jobs", 0, "matrix mode — concurrent worker count (each worker is a subprocess so it gets its own sqlite). 0 = runtime.NumCPU()")
 	)
 	flag.Parse()
 
+	if *petLevel < 0 || *petLevel > 10 {
+		fail("pet-level must be 0-10, got", *petLevel)
+	}
+	if *party < 1 || *party > plugin.ExpeditionPartyMax {
+		fail("party must be 1-", plugin.ExpeditionPartyMax, ", got", *party)
+	}
+	followers := followerClasses(*class, *party, *partyClasses)
+
 	plugin.SetSimIncludeTrace(*trace)
+	plugin.SetSimPetLevel(*petLevel)
 
 	if *matrix {
 		// Matrix default: drop log to keep stdout manageable; explicit
@@ -58,14 +86,40 @@ func main() {
 				includeLog = *logFlag
 			}
 		})
-		runMatrix(*classes, *levels, *zones, *runs, *bank, *cap, includeLog)
+		runMatrix(*classes, *levels, *zones, *runs, *bank, *cap, *days, includeLog, *jobs, *trace, *petLevel, *party, *partyClasses)
 		return
 	}
 
-	runSingle(*class, *level, *zone, *userTag, *dataDir, *bank, *cap, *logFlag)
+	runSingle(*class, *level, *zone, *userTag, *dataDir, *bank, *cap, *days, *logFlag, followers)
 }
 
-func runSingle(class string, level int, zone, userTag, dataDir string, bank float64, cap int, includeLog bool) {
+// followerClasses expands -party / -party-classes into the class of each
+// follower seat. An explicit list must name every seat: a party of 3 whose
+// second follower silently defaulted to the leader's class would quietly
+// answer a different question than the one asked.
+func followerClasses(leaderClass string, party int, spec string) []string {
+	n := party - 1
+	if n == 0 {
+		if strings.TrimSpace(spec) != "" {
+			fail("-party-classes given but -party is 1")
+		}
+		return nil
+	}
+	if strings.TrimSpace(spec) == "" {
+		out := make([]string, n)
+		for i := range out {
+			out[i] = leaderClass
+		}
+		return out
+	}
+	out := splitNonEmpty(spec)
+	if len(out) != n {
+		fail(fmt.Sprintf("-party %d needs %d follower classes, got %d", party, n, len(out)))
+	}
+	return out
+}
+
+func runSingle(class string, level int, zone, userTag, dataDir string, bank float64, cap, days int, includeLog bool, followers []string) {
 	dir := dataDir
 	if dir == "" {
 		var err error
@@ -76,7 +130,7 @@ func runSingle(class string, level int, zone, userTag, dataDir string, bank floa
 		defer os.RemoveAll(dir)
 	}
 
-	res, err := runOne(dir, id.UserID(userTag), plugin.DnDClass(class), level, plugin.ZoneID(zone), bank, cap)
+	res, err := runOne(dir, id.UserID(userTag), plugin.DnDClass(class), level, plugin.ZoneID(zone), bank, cap, days, followers)
 	if err != nil {
 		if res != nil {
 			if !includeLog {
@@ -92,47 +146,133 @@ func runSingle(class string, level int, zone, userTag, dataDir string, bank floa
 	emitIndented(res)
 }
 
-func runMatrix(classes, levels, zones string, runs int, bank float64, cap int, includeLog bool) {
+// matrixJob is one (class, level, zone, replicate-index) cell of the
+// matrix sweep. Each job is run by a worker as a single-run subprocess so
+// it gets its own SQLite handle — the plugin package's db.* globals
+// preclude in-process parallelism.
+type matrixJob struct {
+	class string
+	level int
+	zone  string
+	rep   int
+}
+
+func runMatrix(classes, levels, zones string, runs int, bank float64, cap, days int, includeLog bool, jobs int, trace bool, petLevel, party int, partyClasses string) {
 	cs := splitNonEmpty(classes)
 	ls := parseLevels(levels)
 	zs := splitNonEmpty(zones)
 	if len(cs) == 0 || len(ls) == 0 || len(zs) == 0 || runs <= 0 {
 		fail("matrix mode requires non-empty -classes, -levels, -zones and runs > 0")
 	}
-	enc := json.NewEncoder(os.Stdout)
+	if jobs <= 0 {
+		jobs = runtime.NumCPU()
+	}
+	exe, err := os.Executable()
+	if err != nil {
+		fail("os.Executable:", err)
+	}
+
+	work := make([]matrixJob, 0, len(cs)*len(ls)*len(zs)*runs)
 	for _, c := range cs {
 		for _, lv := range ls {
 			for _, z := range zs {
 				for r := 0; r < runs; r++ {
-					dir, err := os.MkdirTemp("", "expedition-sim-")
-					if err != nil {
-						fail("mkdir temp:", err)
-					}
-					uid := id.UserID(fmt.Sprintf("@sim:%s-l%d-%s-%d", c, lv, z, r))
-					res, runErr := runOne(dir, uid, plugin.DnDClass(c), lv, plugin.ZoneID(z), bank, cap)
-					if res != nil && !includeLog {
-						res.Log = nil
-					}
-					if runErr != nil && res == nil {
-						// Synthesize a row so the corpus has one line per
-						// cell regardless of init failures.
-						res = &plugin.SimResult{
-							UserID:  string(uid),
-							Class:   c,
-							Level:   lv,
-							Zone:    z,
-							Outcome: "halted",
-						}
-					}
-					_ = enc.Encode(res)
-					_ = os.RemoveAll(dir)
+					work = append(work, matrixJob{class: c, level: lv, zone: z, rep: r})
 				}
 			}
 		}
 	}
+
+	workCh := make(chan matrixJob)
+	resCh := make(chan *plugin.SimResult, len(work))
+	var wg sync.WaitGroup
+	for i := 0; i < jobs; i++ {
+		wg.Add(1)
+		go matrixWorker(exe, workCh, resCh, &wg, bank, cap, days, includeLog, trace, petLevel, party, partyClasses)
+	}
+	go func() {
+		for _, j := range work {
+			workCh <- j
+		}
+		close(workCh)
+	}()
+	go func() {
+		wg.Wait()
+		close(resCh)
+	}()
+
+	enc := json.NewEncoder(os.Stdout)
+	for r := range resCh {
+		_ = enc.Encode(r)
+	}
 }
 
-func runOne(dataDir string, uid id.UserID, class plugin.DnDClass, level int, zone plugin.ZoneID, bank float64, cap int) (*plugin.SimResult, error) {
+func matrixWorker(exe string, in <-chan matrixJob, out chan<- *plugin.SimResult, wg *sync.WaitGroup, bank float64, cap, days int, includeLog, trace bool, petLevel, party int, partyClasses string) {
+	defer wg.Done()
+	for j := range in {
+		uid := fmt.Sprintf("@sim:%s-l%d-%s-%d", j.class, j.level, j.zone, j.rep)
+		dir, err := os.MkdirTemp("", "expedition-sim-")
+		if err != nil {
+			out <- &plugin.SimResult{UserID: uid, Class: j.class, Level: j.level, Zone: j.zone, Outcome: "halted"}
+			continue
+		}
+		args := []string{
+			"-class", j.class,
+			"-level", strconv.Itoa(j.level),
+			"-zone", j.zone,
+			"-bank", strconv.FormatFloat(bank, 'f', -1, 64),
+			"-cap", strconv.Itoa(cap),
+			"-days", strconv.Itoa(days),
+			"-data", dir,
+			"-user", uid,
+			fmt.Sprintf("-log=%t", includeLog),
+			fmt.Sprintf("-pet-level=%d", petLevel),
+			fmt.Sprintf("-party=%d", party),
+		}
+		// Left empty, each cell's followers clone that cell's own -class.
+		if partyClasses != "" {
+			args = append(args, "-party-classes", partyClasses)
+		}
+		if trace {
+			args = append(args, "-trace")
+		}
+		cmd := exec.Command(exe, args...)
+		var stderrBuf bytes.Buffer
+		cmd.Stderr = &stderrBuf
+		stdout, runErr := cmd.Output()
+		var res plugin.SimResult
+		jerr := json.Unmarshal(stdout, &res)
+		if jerr != nil {
+			res = plugin.SimResult{UserID: uid, Class: j.class, Level: j.level, Zone: j.zone, Outcome: "halted"}
+		}
+		if runErr != nil && res.Outcome == "" {
+			res.Outcome = "halted"
+		}
+		// Surface subprocess failures: parse error with non-empty stdout
+		// (corrupted JSON) and non-zero exits both get a stderr dump so the
+		// user sees the underlying cause instead of just a halted row.
+		if jerr != nil || runErr != nil {
+			fmt.Fprintf(os.Stderr, "sim cell %s halted: runErr=%v jerr=%v\n", uid, runErr, jerr)
+			if stderrBuf.Len() > 0 {
+				fmt.Fprintf(os.Stderr, "  child stderr:\n%s\n", stderrBuf.String())
+			}
+			if jerr != nil && len(stdout) > 0 {
+				snip := stdout
+				if len(snip) > 200 {
+					snip = snip[:200]
+				}
+				fmt.Fprintf(os.Stderr, "  child stdout (first 200B): %q\n", snip)
+			}
+		}
+		if !includeLog {
+			res.Log = nil
+		}
+		out <- &res
+		_ = os.RemoveAll(dir)
+	}
+}
+
+func runOne(dataDir string, uid id.UserID, class plugin.DnDClass, level int, zone plugin.ZoneID, bank float64, cap, days int, followers []string) (*plugin.SimResult, error) {
 	runner, err := plugin.NewSimRunner(dataDir)
 	if err != nil {
 		return nil, fmt.Errorf("init runner: %w", err)
@@ -143,7 +283,32 @@ func runOne(dataDir string, uid id.UserID, class plugin.DnDClass, level int, zon
 		return nil, fmt.Errorf("build character: %w", err)
 	}
 	runner.Euro.Credit(uid, bank, "expedition-sim bankroll")
-	return runner.RunExpedition(uid, zone, cap)
+
+	// Followers share the leader's level — a party is not a carry (the tier
+	// gate refuses an under-levelled invitee anyway) — and each buys their own
+	// loadout, so each needs their own bankroll.
+	var members []id.UserID
+	for i, fc := range followers {
+		muid := followerUserID(uid, i)
+		if _, err := runner.BuildCharacter(muid, plugin.DnDClass(fc), level); err != nil {
+			return nil, fmt.Errorf("build follower %d (%s): %w", i+1, fc, err)
+		}
+		runner.Euro.Credit(muid, bank, "expedition-sim bankroll")
+		members = append(members, muid)
+	}
+	return runner.RunPartyExpedition(uid, members, zone, cap, days)
+}
+
+// followerUserID derives a follower's Matrix id from the leader's. It must keep
+// the ":" — ResolveUser treats a colon as "this is already a full mxid" and
+// short-circuits the room-membership lookup the sim has no client for.
+func followerUserID(leader id.UserID, i int) id.UserID {
+	s := string(leader)
+	local, server, ok := strings.Cut(strings.TrimPrefix(s, "@"), ":")
+	if !ok {
+		local, server = strings.TrimPrefix(s, "@"), "sim"
+	}
+	return id.UserID(fmt.Sprintf("@%s-m%d:%s", local, i+1, server))
 }
 
 func emitIndented(res *plugin.SimResult) {

cmd/open5e-import/desc_overrides.go

@@ -129,7 +129,7 @@ var (
 	reSpaces            = regexp.MustCompile(`\s+`)
 	reOrphanMustMake    = regexp.MustCompile(`(?i)\s+must\s+(?:make|succeed on|attempt)([.,;])`)
 	reOrphanTrailingAnd = regexp.MustCompile(`(?i),?\s+and\.`)
-	descScrub = []*regexp.Regexp{
+	descScrub           = []*regexp.Regexp{
 		// Range / distance jargon.
 		regexp.MustCompile(`(?i)\s*\bwithin range\b`),
 		regexp.MustCompile(`(?i)\s*\bwithin \d+ feet(?: of [a-z ]+?)?`),

cmd/open5e-import/desc_overrides_test.go

@@ -93,11 +93,11 @@ func TestCleanDescRepairsOrphans(t *testing.T) {
 // TestStripNameParenthetical — bestiary R21 / magic-item alias names.
 func TestStripNameParenthetical(t *testing.T) {
 	cases := map[string]string{
-		"Giant Rat (Diseased)":          "Giant Rat",
-		"Deep Gnome (Svirfneblin)":      "Deep Gnome",
+		"Giant Rat (Diseased)":           "Giant Rat",
+		"Deep Gnome (Svirfneblin)":       "Deep Gnome",
 		"Stone of Good Luck (Luckstone)": "Stone of Good Luck",
-		"Ordinary Name":                 "Ordinary Name",
-		"":                              "",
+		"Ordinary Name":                  "Ordinary Name",
+		"":                               "",
 	}
 	for in, want := range cases {
 		if got := stripNameParenthetical(in); got != want {

cmd/open5e-import/main.go

@@ -88,18 +88,18 @@ func must(err error) {
 // open5eSpell is the subset of the Open5e v1 spell schema we consume. Unknown
 // fields are ignored; the vendored JSON keeps the full payload.
 type open5eSpell struct {
-	Slug                  string   `json:"slug"`
-	Name                  string   `json:"name"`
-	Desc                  string   `json:"desc"`
-	HigherLevel           string   `json:"higher_level"`
-	Range                 string   `json:"range"`
-	Material              string   `json:"material"`
-	CanBeCastAsRitual     bool     `json:"can_be_cast_as_ritual"`
-	Duration              string   `json:"duration"`
-	RequiresConcentration bool     `json:"requires_concentration"`
-	CastingTime           string   `json:"casting_time"`
-	LevelInt              int      `json:"level_int"`
-	School                string   `json:"school"`
+	Slug                  string `json:"slug"`
+	Name                  string `json:"name"`
+	Desc                  string `json:"desc"`
+	HigherLevel           string `json:"higher_level"`
+	Range                 string `json:"range"`
+	Material              string `json:"material"`
+	CanBeCastAsRitual     bool   `json:"can_be_cast_as_ritual"`
+	Duration              string `json:"duration"`
+	RequiresConcentration bool   `json:"requires_concentration"`
+	CastingTime           string `json:"casting_time"`
+	LevelInt              int    `json:"level_int"`
+	School                string `json:"school"`
 	// SpellLists is the structured class list, but the SRD dump leaves it
 	// incomplete (no paladin entries at all). DndClass is the free-text
 	// "Druid, Wizard" field and is the more complete source — mapClasses

go.mod

@@ -11,9 +11,10 @@ require (
 	github.com/joho/godotenv v1.5.1
 	github.com/olebedev/when v1.1.0
 	github.com/robfig/cron/v3 v3.0.1
+	github.com/rs/zerolog v1.35.1
 	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
-	golang.org/x/image v0.43.0
-	maunium.net/go/mautrix v0.28.0
+	golang.org/x/image v0.40.0
+	maunium.net/go/mautrix v0.28.1
 	modernc.org/sqlite v1.50.1
 )
 
@@ -21,26 +22,27 @@ require (
 	filippo.io/edwards25519 v1.2.0 // indirect
 	github.com/AlekSi/pointer v1.0.0 // indirect
 	github.com/andybalholm/cascadia v1.3.3 // indirect
+	github.com/coder/websocket v1.8.15 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-sqlite3 v1.14.44 // indirect
+	github.com/mattn/go-sqlite3 v1.14.45 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/petermattis/goid v0.0.0-20260330135022-df67b199bc81 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
-	github.com/rs/zerolog v1.35.1 // indirect
 	github.com/tidwall/gjson v1.19.0 // indirect
 	github.com/tidwall/match v1.1.1 // indirect
 	github.com/tidwall/pretty v1.2.1 // indirect
 	github.com/tidwall/sjson v1.2.5 // indirect
-	go.mau.fi/util v0.9.9 // indirect
-	golang.org/x/crypto v0.51.0 // indirect
-	golang.org/x/exp v0.0.0-20260508232706-74f9aab9d74a // indirect
-	golang.org/x/net v0.54.0 // indirect
-	golang.org/x/sys v0.44.0 // indirect
+	go.mau.fi/util v0.9.10 // indirect
+	golang.org/x/crypto v0.53.0 // indirect
+	golang.org/x/exp v0.0.0-20260611194520-c48552f49976 // indirect
+	golang.org/x/net v0.56.0 // indirect
+	golang.org/x/sys v0.46.0 // indirect
 	golang.org/x/text v0.38.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 	modernc.org/libc v1.72.3 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect

go.sum

@@ -10,6 +10,8 @@ github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kk
 github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA=
 github.com/chehsunliu/poker v0.1.0 h1:OeB4O+QROhA/DiXUhBBlkgbzCx0ZVWMpWgKNu+PX9vI=
 github.com/chehsunliu/poker v0.1.0/go.mod h1:V6K4yyDbafp0k6lUnYbwoTS/KsHSB1EWiJdEk54uB1w=
+github.com/coder/websocket v1.8.15 h1:6B2JPeOGlpff2Uz6vOEH1Vzpi0iUz20A+lPVhPHtNUA=
+github.com/coder/websocket v1.8.15/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -36,8 +38,8 @@ github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHP
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-sqlite3 v1.14.44 h1:3VSe+xafpbzsLbdr2AWlAZk9yRHiBhTBakioXaCKTF8=
-github.com/mattn/go-sqlite3 v1.14.44/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ=
+github.com/mattn/go-sqlite3 v1.14.45 h1:6KA/spDguL3KV8rnybG7ezSaE4SeMR3KC9VbUoAQaIk=
+github.com/mattn/go-sqlite3 v1.14.45/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ=
 github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
 github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/notnil/joker v0.0.0-20180219043703-3f2f69a75914 h1:xXPuFr3PVM4p6Vw3j0CP29oWYRVKO3cPZjR6D7BxggQ=
@@ -73,27 +75,27 @@ github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhso
 github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
 github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-go.mau.fi/util v0.9.9 h1:ujDeXCo07HBor5oQLyO1tHklupmqVmPgasc53d7q/NE=
-go.mau.fi/util v0.9.9/go.mod h1:pqt4Vcrt+5gcH/CgrHZg11qSx+b34o6mknGzOEA6waY=
+go.mau.fi/util v0.9.10 h1:wzvz5iDHyqDXB8vgisD4d3SzucLXNM3iNY+1O1RoHtg=
+go.mau.fi/util v0.9.10/go.mod h1:YQOxySn+ZE3qSYqNxvyX7Yi3suA8YK17PS6QqBREW7A=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
 golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/crypto v0.51.0 h1:IBPXwPfKxY7cWQZ38ZCIRPI50YLeevDLlLnyC5wRGTI=
-golang.org/x/crypto v0.51.0/go.mod h1:8AdwkbraGNABw2kOX6YFPs3WM22XqI4EXEd8g+x7Oc8=
-golang.org/x/exp v0.0.0-20260508232706-74f9aab9d74a h1:+3jdDGGB8NGb1Zktc737jlt3/A5f6UlwSzmvqUuufxw=
-golang.org/x/exp v0.0.0-20260508232706-74f9aab9d74a/go.mod h1:d2fgXJLVs4dYDHUk5lwMIfzRzSrWCfGZb0ZqeLa/Vcw=
-golang.org/x/image v0.43.0 h1:FLxcP4ec2350nTfOC8ysKtqYSIFbk/QGjw1ZHNP4tsY=
-golang.org/x/image v0.43.0/go.mod h1:rrpelvGFt+kLPAjPM4HeWPgrl0FtafueU//e5N0qk/Q=
+golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto=
+golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio=
+golang.org/x/exp v0.0.0-20260611194520-c48552f49976 h1:X8Hz2ImujgbmetVuW+w2YkyZChE3cBpZi2P158rTG9M=
+golang.org/x/exp v0.0.0-20260611194520-c48552f49976/go.mod h1:vnf4pv9iKZXY58sQE1L86zmNWJ4159e1RkcWiLCkeEY=
+golang.org/x/image v0.40.0 h1:Tw4GyDXMo+daZN1znreBRC3VayR1aLFUyUEOLUdW1a8=
+golang.org/x/image v0.40.0/go.mod h1:uIc348UZMSvS5Z65CVZ7iDPaNobNFEPeJ4kbqTOszmA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4=
-golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ=
+golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
+golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
@@ -103,8 +105,8 @@ golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w=
-golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=
+golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o=
+golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -126,8 +128,8 @@ golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.44.0 h1:ildZl3J4uzeKP07r2F++Op7E9B29JRUy+a27EibtBTQ=
-golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@@ -154,15 +156,16 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
 golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
-golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8=
-golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0=
+golang.org/x/tools v0.46.0 h1:7jTurBkPZu4moS/Uy4OQT1M+QBlsj3wejyZwsT8Z7rk=
+golang.org/x/tools v0.46.0/go.mod h1:FrD85F8l+NWL+9XWBSyVSHO6Ne4jutsfIFba7AWQ5Ys=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-maunium.net/go/mautrix v0.28.0 h1:vBakLzf8MAdfED3NzAKiMeKQbc3AQ4EAS03NC+TVMXQ=
-maunium.net/go/mautrix v0.28.0/go.mod h1:/a9A7LGaqb9B3nho4tLd28n0EPcCdwpm2dxkxkLLgh0=
+maunium.net/go/mautrix v0.28.1 h1:Hic3oDMPbLbQu1fhboTRAKZcORMjzzkjxsa+SGk60b0=
+maunium.net/go/mautrix v0.28.1/go.mod h1:mWXQNmOlrq4VTDU9f1HO03BSIswdUIyyY4wUKHqwzzY=
 modernc.org/cc/v4 v4.28.2 h1:3tQ0lf2ADtoby2EtSP+J7IE2SHwEJdP8ioR59wx7XpY=
 modernc.org/cc/v4 v4.28.2/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI=
 modernc.org/ccgo/v4 v4.34.0 h1:yRLPFZieg532OT4rp4JFNIVcquwalMX26G95WQDqwCQ=

gogobee_long_expedition_plan.md

@@ -0,0 +1,280 @@
+# Long Expeditions — multi-session plan
+
+> Goal: dungeon expeditions become real multi-day journeys (T1 ≈ 2 days → T5 ≈ 7 days). Player picks **camp supplies** at launch, then watches it play out. Camp pitch/break, elite engagement, and **boss engagement** all become autonomous. Foreground `!camp` / `!fight` survive as overrides, not the expected path.
+
+## Status @ 2026-05-28
+
+**Core track (D1–D7) — DONE.** All phases shipped; v1 of the long-expedition mechanics is live on `long-expeditions-d1`.
+
+**§6 decisions (2026-05-28) re-opened two threads** that ride after D8:
+- **D9** — T1–T3 room-count bump toward the 3–5× target band (D1 landed T1–T3 at ~2×). Sim-first: read T1/T2 day-counts from a fresh corpus *after* D8 lands.
+- **D10** — T4/T5 anchor-room variety (2nd elite + 2nd trap mid-zone). Bundle with D9 to avoid touching graphs twice.
+
+**Active work — §8 (J3 caster sim-picker):** D8-a / D8-b / D8-prereq / D8-d-diagnostic shipped; **D8-c (concentration), D8-d-fix (AC floor lift), D8-e (martial regression triage)** queued. D8 is sequentially the gate before D9/D10 — room counts only make sense once the sim accurately scores the classes that will walk through them.
+
+**Sequence:** D8-c → D8-d-fix → D8-e → D9 → D10. Re-baseline once at the end.
+
+## 1. Why the current shape is "too short"
+
+| Tier | Zones | Rooms | Real-time exit |
+|------|-------|------|----------------|
+| T1   | Goblin Warrens, Crypt Valdris       | 6–7  | usually <1 calendar day |
+| T2   | Forest Shadows, Sunken Temple       | 7–8  | usually 1 day |
+| T3   | Manor Blackspire, Underforge        | 7–9  | 1–2 days |
+| T4   | Underdark, Feywild Crossing         | 8–10 (×regions) | 2–3 days |
+| T5   | Dragon's Lair, Abyss Portal         | 9–10 (×regions) | 2–4 days |
+
+(Room counts from `internal/plugin/dnd_zone.go:70-134`; tier zones from memory `project_expedition_difficulty`.)
+
+Because the autopilot walks ~3 rooms / 2h (`expedition_autorun.go:43,53`) and boss/elite stops are manual, a player who pays attention clears T1–T3 in an evening. Briefing/recap UTC ticks fire but rarely matter — the expedition is over before "day 2" ever lands.
+
+## 2. Target shape
+
+| Tier | Target duration | New room budget (single-region) | Notes |
+|------|-----------------|---------------------------------|-------|
+| T1   | 2 days  | 12–14 | one autopilot-camp |
+| T2   | 3 days  | 16–20 | two camps |
+| T3   | 4 days  | 22–26 | three camps; threat starts to bite |
+| T4   | 5–6 days | 28–34 (split across 3–4 regions) | base camp emerges |
+| T5   | 7 days  | 36–44 (split across 3–4 regions) | full siege/temporal pressure |
+
+(Numbers are first-draft anchors; class-balance sim drives the actual dial in D7.)
+
+Duration is measured in **expedition-days advanced by autopilot camp**, not real-time UTC days. Each autopilot night-camp = day++. Real-time UTC still drives the morning briefing DM cadence, but day-count and supply burn become event-driven (camp = sleep = day++ = burn).
+
+The autopilot decides:
+- when to camp (and which camp type)
+- whether to engage elites and bosses, or to camp first and retry
+- whether to extract early on starvation/HP collapse
+
+The player decides:
+- supply pack purchases at launch (only meaningful pre-expedition choice)
+- whether to override (`!camp <kind>`, `!fight`, `!expedition extract`)
+
+## 3. Phasing
+
+Built across multiple sessions; each phase ships independently with tests and a small DM-side feedback loop.
+
+### D1 — Length + room-count rework
+**Files:** `dnd_zone.go` (per-zone Min/MaxRooms), `dnd_expedition_region.go` (multi-region region sizes), `dnd_zone_run.go:generateRoomSequence` (still terminates Entry → … → Elite → Boss, but with more Explorations).
+**Work:**
+- Re-pitch Min/MaxRooms per zone to the table in §2.
+- Multi-region zones: extend per-region room budgets so the total stays in band when summed.
+- Keep the fixed Entry / Trap / Elite / Boss anchors; only Exploration count scales.
+- Consider 2 traps + 2 elites for T4–T5 to break up the long middle (deferred decision — see §6).
+- Update existing zone graphs in `zone_graph_*.go` for the new lengths. *Auditing whether each zone has a hand-tuned graph or relies on the linear compiler is part of D1 scoping.*
+
+**Exit criteria:** `expedition-sim` shows mean-room-cleared per zone in the new band; no test fixtures hard-code old counts.
+
+### D2 — Autopilot camp scheduler
+
+**D2-a (shipped 2026-05-27):** new `expedition_autocamp.go` with pure `decideAutopilotCamp` + `pitchAutopilotCamp` + dwell-window lifecycle (`shouldSkipAutoRunForCamp`, `breakAutoCampIfDue`). Wired into `tryAutoRun`: skip while inside `minAutoCampDwell` (4h), break + walk past it, post-walk scheduler pitches HP-low rest camps and region-boss base-camp waypoints. CampState gained `AutoPitched` so auto- vs player-pitched lifetimes diverge. Day rollover is still UTC-anchored; D2-b moves it event-anchored.
+
+**D2-b (shipped 2026-05-27):** event-anchored day rollover. `dnd_expedition_cycle.go` adds `eventAnchoredCutoff` + `isEventAnchored`, splits the briefing body into `nightRolloverBurn` + `nightRolloverDrift` (+ a convenience `processNightCamp` that runs both back-to-back). For expeditions started ≥ cutoff, `deliverBriefing` skips mutators and posts a re-engagement DM; if `last_briefing_at` is older than `nightSafetyNet` (28h) it force-fires `processNightCamp` so a stalled autopilot doesn't freeze the expedition. The autopilot scheduler grew a `Night` flag — `decideAutopilotCamp` sets it when `time.Since(LastBriefingAt) ≥ nightCampWindow` (16h); `pitchAutopilotCamp` then runs the burn → camp → rest → drift sequence in one pitch. Manual `!camp <type>` runs the same flow when it's the first camp since the last rollover. Legacy UTC-anchored expeditions (start_date < cutoff) keep the original mutator flow via the same staged helpers, preserving rest-before-drift ordering through `processOvernightCamp`. Tests fence cutoff to year 9999 in `TestMain` so existing legacy assertions stand; new tests exercise the night decision, night-pitch rollover, event-anchored skip, and safety-net force.
+
+
+**Files:** new `expedition_autocamp.go`; hooks in `expedition_autorun.go:tryAutoRun`; reuse `dnd_expedition_camp.go:campPitch` / `applyCampRest`.
+**Heuristics (in priority order):**
+1. **Day-budget pacing** — pitch when rooms-walked-this-day ≥ tier-specific day-room target. Standard if room cleared, rough if not.
+2. **Resource gates** — pitch if HP < 35% of max, or supplies projected to cover <1 more day's burn (`exp.Supplies.Current < exp.Supplies.DailyBurn * harshMod`).
+3. **Post-elite breath** — auto-pitch a standard camp in the cleared elite room.
+4. **Region boss cleared in multi-region zone** — auto-pitch base camp at first eligible site.
+5. **Don't pitch when** mid-fight, in a trap/boss room, in a fork-pending state, or already camped.
+
+Auto-break already happens on move (`autoBreakCampOnMove` in `dnd_expedition_camp.go:401`). Autopilot just needs to *not* break a freshly-pitched camp by immediately walking on — gate by `time.Since(camp.EstablishedAt) > minCampDwell` (15min real-time? or simply: don't auto-walk while camped).
+
+**Day-rollover semantics change (decided event-anchored):** today, day++ happens at the 06:00 UTC briefing (`dnd_expedition_cycle.go:236`). After D2, the autopilot **night-camp pitch** is the event that fires day++, supply burn, overnight rest, and threat drift — in one atomic rollover the camp scheduler triggers. The 06:00 UTC briefing tick survives only as a re-engagement DM anchor (and a safety net: if for some reason no camp pitched in N hours, force one). Concretely:
+- Move the body of `deliverBriefing` (`dnd_expedition_cycle.go:186-`) into a `processNightCamp(exp)` helper called from the autopilot camp scheduler when it pitches a *night* camp (rough/standard/fortified — not mid-day breath stops).
+- Distinguish "night camp" (advances day) from "rest stop" (doesn't). Heuristic: a camp pitched at the end of the day-budget room count is night; one pitched purely for HP/SU recovery mid-day is a rest stop. Both apply `applyCampRest`; only night also runs supply burn + day++ + threat drift.
+- The existing UTC briefing ticker becomes: if `last_briefing_at` is older than ~20h *and* the user is active, post a "Day N — here's where you stand" re-engagement DM. It calls **no** mutators.
+- Manual `!camp <type>` from the player still does what it does today (apply rest immediately) but **also** counts as a night camp if invoked with no other camp today — keep parity with the autopilot behavior so the override doesn't accidentally stall day advancement.
+
+**Migration:** in-flight expeditions at deploy time keep their existing 06:00 UTC day++ until they end (fence by `start_date`). New expeditions use the event-anchored model.
+
+**Exit criteria:** sim shows autopilot pitches the right kind of camp at the right room with no player input; supply economy still survives a 7-day T5.
+
+### D3 — Autonomous elite + boss engagement
+**Files:** `dnd_zone_cmd.go:497-535` (the prev==RoomElite / RoomBoss branch).
+
+**Shipped 2026-05-27.** `dnd_zone_cmd.go` adds `stopBossSafety` + `bossSafetyGate(uid, exp)` (HP < 80%, supplies < daily burn, exhaustion ≥ 3 — the "active low status" interpretation). The elite/boss doorway branch drops the `prev == RoomBoss || !compact` carve-out: in compact mode bosses fall through to the same `resolveCombatRoom` path elites have used, after the gate clears. `resolveCombatRoom` selects monster + label + loot-drop by `run.CurrentRoomType()` so the same call site handles boss kills (zone.Boss bestiary, "👑 Boss — name down", boss-loot drop, elite-tier threat bump). Loss on auto-resolved boss falls through to the existing player-death narration / forceExtractExpeditionForRunLoss path — no special treatment.
+
+The walk loop (`dnd_expedition_cmd.go:717`) only breaks at the elite/boss doorway when `!compact`; compact lets the next iteration auto-resolve. `stopBossSafety` is excluded from the rooms-walked tally and its `autopilotFooter` returns "" — `res.final` already carries the held-back line.
+
+When the gate trips, `tryAutoRun` calls `pitchBossSafetyCamp(exp)` (new in `expedition_autocamp.go`): force-pitches Standard (or Rough fallback) regardless of `decideAutopilotCamp`'s HP threshold or its RoomBoss room-type block, with the same `Night` event-anchored rollover handling. Dwell expires → next tick retries the boss. Foreground `!fight` and foreground `!expedition run` are unchanged: both still stop at the boss doorway for the player who wants to watch. Sim path is unaffected — `stopBossSafety` falls into `expedition_sim.go`'s default branch (tick-a-day, retry next walk).
+
+**Open question:** do we want a "set autopilot off" toggle for players who actively want to play the boss themselves? My take: default-on, single-flag per expedition (`autopilot_engage`) settable at start or via `!expedition autopilot off`. Defer until D3 lands and we see how it reads.
+
+**Exit criteria:** sim runs a full T5 expedition launch → boss kill with zero player commands besides `!expedition start`.
+
+### D4 — DM volume + day surfaces
+The big risk: a 7-day T5 with autopilot walking, camping, fighting elites, and killing bosses will spam DMs unless we bundle. The user has already pushed back on recap chatter (`feedback_skip_recaps`).
+
+**D4-a (shipped 2026-05-27):** autopilot DM bundling. `expedition_autorun.go:tryAutoRun` now drops per-tick auto-walk DMs in compact mode. New surface rules:
+- Fork / death / run-complete still DM the walk stream — interactive + climax beats.
+- A Night=true camp pitch flushes the day as an end-of-day digest (`renderEndOfDayDigest` in new `expedition_autorun_digest.go`) followed by the camp block.
+- Boss-safety camp pitch gets a short "holding before the boss" header + camp block (walk stream dropped).
+- Non-night auto-camp (mid-day rest / base-camp waypoint) surfaces the camp block by itself.
+- Everything else — uneventful walks, preflight pauses, harvest interrupts — goes silent.
+Each successful background walk now logs a `walk` entry (`appendExpeditionLog(... "walk" ...)`) so the digest can count rooms walked from structured logs (the raw `r.stream` narration is no longer persisted across ticks). Digest groups counts of walk/harvest/interrupt and inlines threat/milestone/narrative lines for the prior day (`dayExpeditionLog` helper). `maybeAutoCamp` + `pitchBossSafetyCamp` now return the `autoCampDecision` so `tryAutoRun` can branch on `dec.Night`.
+
+**D4-b (shipped 2026-05-27):** morning re-engagement DM anchored to user activity, not 06:00 UTC. `fireExpeditionBriefings` now skips event-anchored expeditions whose `last_activity` is older than today's 06:00 UTC threshold (and we're still inside `nightSafetyNet` — stalled-autopilot force-fires still win). New `maybeDeliverDeferredBriefing` runs at the top of `AdventurePlugin.OnMessage` on every inbound message in any room: it stamps `last_activity` (so the next ticker pass sees the player as present, even from non-bot chatter) and posts the deferred briefing if one is owed (CAS-gated by today's 06:00 threshold; pre-06:00 lazy fires are suppressed to avoid double-emit with the ticker sweep that follows). Day-1 inbounds don't trigger a briefing before the first night camp has happened.
+
+**Remaining work:**
+- TwinBee voice + no-recap copy pass on the digest once the shape settles.
+
+**Exit criteria:** a 7-day T5 produces ≤ 10 DMs across the whole expedition (1 launch + 6 end-of-day + 1 boss + 1 run-complete + 1 emergency).
+
+### D5 — Supplies economics retune
+
+**D5-a (shipped 2026-05-27):** per-tier pack caps. `dnd_expedition_supplies.go` retires the global `SupplyPackStandardMax`/`SupplyPackDeluxeMax` constants in favor of `supplyPackCaps(tier) (std, dlx int)` — T1/T2: (2,1); T3: (3,1) unchanged; T4: (5,1); T5: (7,2). `SupplyPurchase.Validate` is now `Validate(tier ZoneTier)`; both call sites (`!expedition start`, `!resume`) pass the resolved zone's tier. The cap clears `DailyBurn(raw) × intendedDays × 1.3` for every tier under the §2 target durations even with harsh×3 layered on top, so a player who wants to buy for the long shape can. DailyBurn / harsh-multiplier / `phase5BDailyBurnRatePct` are unchanged here — they're a D7 lever, alongside the sim work that should unblock empirical baselining. The help text now describes the cap as "scales by zone tier"; the holiday +1 standard pack still bypasses the cap on purpose (it's a freebie on top).
+
+> **Note:** the original "Empirical (sim-driven)" path was blocked: under D2-b event-anchored expeditions, `SimRunner.TickDay` calls `deliverBriefing` → `deliverBriefingEventAnchored`, which reads `time.Now().UTC()` for its safety-net check, so synthetic ticks never advance `CurrentDay` and `DaysAtEnd` stays at 0. Re-baselining off real day-counts requires teaching the sim to drive the event-anchored rollover (D7).
+
+**D5-b (shipped 2026-05-27):** "Pick your loadout" preset prompt at launch. `!expedition start <zone>` with no pack arg now DMs a Lean / Balanced / Heavy menu (sized per zone tier via new `loadoutPurchase(tier, SupplyLoadout)` in `dnd_expedition_supplies.go`); player replies with `!expedition start <zone> lean|balanced|heavy` (short forms `l`/`b`/`h` also work). `!resume` got the same treatment. Raw `Ns Md` syntax remains the advanced override — `resolveLoadoutOrParse` in `dnd_expedition_cmd.go` tries a single-token preset first, falls back to `parseSupplyArgs`. Heavy always equals `supplyPackCaps` (the D5-a harsh×3 ceiling); Lean covers intended days at raw burn; Balanced sits between. `parseSupplyArgs("")` still returns 1 standard for any tier — it's no longer reachable from `!expedition start` (the empty path is intercepted to prompt), but the `1s` default is preserved so future callers don't get surprise zero-pack purchases. Help text updated; two existing scenario tests now pass `lean` explicitly, three new tests cover preset resolution + the prompt-vs-start guard.
+
+**D5-c (shipped 2026-05-27):** Ranger forage wired against the new caps. Audit found `SupplyForageMaxSU = 4` defined in `dnd_expedition_supplies.go` since Phase 12 E1b but never referenced — `ForagedToday` was only ever reset to `false`, never set to `true`, so the §4.2 "Ranger, WIS DC 12, 1d4 SU/day" perk had never actually granted supplies. New helper `applyRangerForage(e, c, rng)` rolls 1d4 SU once per day for Ranger characters, headroom-capped against `Supplies.Max` so a Heavy loadout doesn't overflow its purchased ceiling; non-Rangers and post-roll repeats are no-ops. Fires at the top of `nightRolloverBurn` (before the daily burn) so the +SU lands on today's bag and a "forage" log entry flows into the end-of-day digest via a new `renderEndOfDayDigest` case. No DC roll — accessibility over crunch (`feedback_accessibility_over_dnd_crunch`); the DC-12 gate would've added a fail case with no upside given the new headroom. Average +2.5 SU/day off a Ranger is a quiet Lean-loadout cushion (~1 extra day of T5 late-stage burn over a 7-day run), not a Heavy multiplier. Tests cover ranger-grants, non-ranger no-op, repeat-day no-op, headroom-cap, full-bag-still-stamps-flag, nil-safety.
+
+**Remaining work (D5-d+):**
+- DailyBurn / `phase5BDailyBurnRatePct` revisit once D7 sim measures real elapsed-day counts.
+
+**Exit criteria:** balanced loadout completes intended-duration expedition in ≥ 85% of sim runs without starvation extraction.
+
+### D6 — Player-facing surface cleanup
+
+**D6 (shipped 2026-05-27):** player-facing copy now matches the autopilot-first reality.
+- `expeditionHelpText` rewritten around the loop "pick a zone → pick a loadout → `!expedition run` watches it play out"; commands grouped into **Run an expedition** / **Mid-expedition** / **Overrides** with a one-line shape paragraph at the top.
+- `!camp` and `!fight` were already absent from the primary `!expedition` help; both are now explicitly listed under **Overrides** and framed as "autopilot covers these — only reach for them if you want manual control." `campHelpText` itself opens with the same override framing so a player who types `!camp` lands on the right mental model.
+- `expeditionCmdStatusImpl` (default `!expedition status`) now leads with **Day X / ~Y expected** (driven by new `expeditionTargetDays(tier ZoneTier)` in `dnd_expedition_supplies.go` — T1=2 → T5=7, the §2 anchor table), adds a **Rooms: N / Total in this region** line under the region marker (sourced from `getActiveZoneRun(...).CurrentRoom/TotalRooms`), and appends a **Recent:** block with the last 3 log entries (summary fallback to flavor). Supplies and threat lines unchanged; the `--debug` view is untouched.
+- No new public command surface, no schema change, no test churn (no existing test asserted on the rewritten strings); full `go test ./...` green.
+
+### D7 — Sim + class re-baseline
+
+**D7-a (shipped 2026-05-27):** `SimRunner.TickDay` now drives event-anchored expeditions. `expedition_sim.go` short-circuits when `isEventAnchored(exp)` is true: instead of calling `deliverBriefing` (whose `deliverBriefingEventAnchored` branch reads `time.Now().UTC()` and would never trip the safety-net under synthetic ticks), it runs `nightRolloverBurn` → optional `applyCampRest(Standard)` if affordable (Rough fallback, skipped on low-SU) → `nightRolloverDrift(briefAt)`. Mirrors `pitchAutopilotCamp` with `Night=true`. Production paths untouched. New `expedition_sim_test.go` covers (i) 3 ticks advancing day 1→4 with supply burn + stamped `LastBriefingAt`, and (ii) the low-SU branch where the rest is skipped but burn/drift still fire. Unblocks D5-d empirical re-baseline of `phase5BDailyBurnRatePct` and the class corpus re-run.
+
+**D7-b (shipped 2026-05-27):** `SimRunner.RunExpedition` now drives the production camp scheduler under a synthetic clock (`simWalkInterval = autoRunCooldown`, 2h per walk). After every soft-stop walk it calls `maybeAutoCamp(exp, simNow)`; `stopBossSafety` routes to `pitchBossSafetyCamp(exp, simNow)`. The helpers (`applyAutoCamp` / `applyAutoCampBossSafety`) advance `simNow` past `minAutoCampDwell` (4h) and break the auto-pitched camp via `breakAutoCampIfDue` so the next walk proceeds. `maybeAutoCamp`, `pitchAutopilotCamp`, and `pitchBossSafetyCamp` gained a `now time.Time` parameter (the only prod caller, `tryAutoRun`, still passes `time.Now().UTC()`). Effect: HP-low mid-day rests, multi-region base-camp waypoints, Night-camp rollovers, and boss-safety holds all fire under the sim — the D7-a `tickEventAnchoredRollover` shortcut is no longer used by RunExpedition (kept on TickDay for tests + the pre-cutoff legacy path). Coverage in `expedition_sim_test.go`: Night-camp day advance, HP-low mid-day rest, boss-safety force-pitch, no-op when neither trigger fires.
+
+**D7-c (shipped 2026-05-27):** `cmd/expedition-sim` gained a `-days N` flag — when set, `RunExpedition` exits with `Outcome="day_capped"` after the Nth synthetic day rollover; 0 (default) is unbounded and only the existing `-cap` walk safety net applies. `SimResult` gained `DaySnapshots []SimDaySnapshot` ({Day, HPCurrent, HPMax, Supplies, Threat, Rooms}), captured at expedition start (Day 0), after every `applyAutoCamp`/`applyAutoCampBossSafety` Night-camp rollover, and one final end-of-run entry (reads `getExpedition(mostRecentExpeditionID(...))` when the row already extracted so closed runs still close their trajectory). `RunExpedition` signature picked up the `maxDays int` parameter; sole caller is the CLI. Coverage: `TestSimRunner_CaptureDaySnapshot_PopulatesFields` exercises the helper in isolation (HP from the live character row, SU/threat/day from the live expedition, Rooms from `res.Rooms`). Unblocks empirical D5-d retune of `phase5BDailyBurnRatePct` against per-day SU draws.
+
+**D7-d (shipped 2026-05-27):** class corpus re-run + D5-d retune decision. First fixed a sim regression `expedition_sim.go` introduced by D5-b — bare `expedition start <zone>` now returns the loadout prompt instead of outfitting, so the sim was halting before persisting any expedition; harness now passes the `heavy` preset. Corpus: `sim_results/d7d_corpus.jsonl` (n=100 × 10 classes × 5 zones × L10 = 5000 runs, `heavy` preset, `-cap 300`). Analysis: `sim_results/d7d_analyze.py`. Writeup: `sim_results/d7d_findings.md`. **Key reads:** (i) leaderboard mirrors [[project_j2_sim_artifact]] — martials 78–82%, casters 21–42%, ~40pp cluster gap unchanged by long-expedition mechanics; (ii) bard/cleric trailers **not** relieved by autopilot camp pacing — cleric actually regressed at L10 (21% vs J2b L12 39%) on spell-pool richness, J3-territory; (iii) T3 hits target 4-day duration (median 3), T4 hits 5–6 days (median 5), T5 hits 5 of 7 (only 21 clears); (iv) **D5-d retune: no change.** `phase5BDailyBurnRatePct=50` + per-tier `DailyBurn` stay as-is — heavy-preset cleared runs end with 78–98% SU remaining; supply economy is not a binding constraint and players lose to HP zero, not starvation. New memory entry: [[project_d7d_baseline]].
+
+**Remaining work (D7-e+):** none in the core D7 scope. Two follow-up phases (D9 room-count bump, D10 T4/T5 anchor variety) were opened by the 2026-05-28 §6 resolution and are sequenced after D8. See §9 below.
+
+## 8. J3 caster-picker rework (next session)
+
+**Why split out:** D7-d corpus confirmed the martial/caster gap is class-roster + sim-picker driven, not autopilot/burn/pacing driven. Long-expedition mechanics are settled; the trailer fix lives in the sim picker, not the expedition shell.
+
+**D8-a (shipped 2026-05-27, this session):** quick data-layer cleanup. Bard L1 prepared list gained `thunderwave`; L2 gained `heat_metal`. Cleric L1 gained `inflict_wounds`. `shatter` overlay Classes broadened to mage/bard/sorcerer (overlay was already unioning via `mergeClassList`, so this is defensive). New `simPickSpiritualWeapon` runs before `simPickSpell` in `simPickCombatAction`: cleric with an L2 slot + spiritual_weapon prepared + `sess.Statuses.BuffSpiritProc == 0` opens the fight with it, picking up the existing `spiritWeaponStrike` per-round bonus-action attack. **Measured impact (L10, n=100/zone, heavy preset):** cleric 21.0 → 23.2% (+2.2pp), bard 34.2 → 32.8% (within noise). T3+ wall unchanged — the data fixes are correct but the picker math is what's binding. Files touched: `internal/plugin/dnd_spells_data.go:192`, `internal/plugin/dnd_spells.go:822,881,884`, `internal/plugin/expedition_sim.go:simPickCombatAction + new simPickSpiritualWeapon`. All green.
+
+**D8-b (implemented 2026-05-27, **inert** — see D8-prereq below): sim picker upcasting.** `simPickSpell` (`internal/plugin/expedition_sim.go:933`) now enumerates one candidate per available slot ≥ native for every prepared damage spell, scored via `spellExpectedDamage(sp, slotLevel, c.Level)`. Cantrips contribute a single slot-0 candidate. Tie-break: highest slot first, then highest expDmg. When the winning slot exceeds the spell's native level, the picker returns `"<id> --upcast N"` so `parseCombatCast` upcasts in the engine. Build + tests green.
+
+**Measured impact: nothing.** d8b corpus (`sim_results/d8b_corpus.jsonl`, same matrix as d7d) lands every class within ±1.5pp of the d7d baseline — bard −1.0, cleric −0.4, mage −1.2, sorcerer +1.4, warlock −0.8, druid +0.6, martials ±0.2. Pure noise band. Expected bard +5–10pp / mage+sorcerer+warlock +2–8pp never materialized.
+
+**Root cause (discovered post-corpus, this session):** `simPickSpell` is **dead code** in the current sim path. Commit `68ed8e7` ("Long expeditions D3: compact autopilot auto-resolves boss rooms") added a `!compact` gate at `dnd_expedition_cmd.go:810` so compact autopilot inline-resolves boss/elite rooms via `resolveCombatRoom` → `runZoneCombat` → `SimulateCombat` instead of returning `stopBoss/stopElite` for `autoResolveCombat` to handle. The sim uses `compact=true` (`expedition_sim.go:433`), so `autoResolveCombat` — the only caller of `simPickCombatAction`/`simPickSpell` — never fires. Verified empirically: a stderr-traced `simPickSpell` produced zero hits across full bard/cleric L10 runs.
+
+This rewrites the picker-era retrospective. **J2's `baseline_j2a_v2_all10.jsonl` (bard 40%, cleric 39%) was measured before D3, with the picker live.** d7d's L10 baseline (bard 34%, cleric 21%) was measured *after* D3, with the picker disconnected — that ~6–18pp drop is the post-D3 caster regression, not "long-expedition mechanics didn't help casters" as the d7d writeup framed it. D8-a's "+2.2pp cleric" was also noise (1σ ≈ 1.8pp on n=500).
+
+**D8-prereq (SHIPPED 2026-05-28, commit `631764b`):** split the `compact` flag in `runAutopilotWalk` / `advanceOnceWithOpts` into `compact` + `inlineBossCombat`. Production background autorun (`expedition_autorun.go:173`) passes `(true, true)` — unchanged inline auto-resolve. Sim (`expedition_sim.go:432`) passes `(true, false)` so boss/elite doorways return `stopBoss`/`stopElite` after the safety gate; `autoResolveCombat` → `simPickCombatAction` → `simPickSpell` / `simPickSpiritualWeapon` now drive boss/elite fights through the turn-based `!fight` engine. D8-b upcasting went live with the rewire. Foreground (`!expedition run`) flow unchanged (compact=false short-circuits).
+
+Also parallelized matrix mode via subprocess workers (`cmd/expedition-sim/main.go`, `-jobs` flag; defaults to NumCPU). Each worker is its own process so the plugin's global SQLite handle isn't a contention point.
+
+**Measured impact (5000-run L10 corpus, `sim_results/d8prereq_corpus.jsonl` — full diff in `sim_results/d8prereq_findings.md`):**
+
+| Class    | d7d  | d8prereq | Δ      |
+|----------|-----:|---------:|-------:|
+| cleric   | 21.0 |   46.8   | +25.8  |
+| sorcerer | 29.4 |   52.0   | +22.6  |
+| warlock  | 35.4 |   55.6   | +20.2  |
+| mage     | 36.4 |   54.2   | +17.8  |
+| druid    | 42.2 |   56.6   | +14.4  |
+| bard     | 34.2 |   46.2   | +12.0  |
+| (martials) | ~80 |   ~78    |  -2 to -4 (noise + T4/T5 turn-engine regression) |
+
+Caster/martial gap closed from ~40pp to ~22pp. T2/T3 zones are now the picker payoff (forest_shadows 75 → 99, manor_blackspire 45 → 75). **T4 caster wall persists** (every caster 0% at underdark); **T5 is universally 0%** including martials. Both require separate diagnostics — picker isn't the binding constraint past T3.
+
+**D8-c (SHIPPED 2026-05-28):** concentration-damage multiplier. `spellExpectedDamage` (`internal/plugin/dnd_class_balance.go:280`) multiplies expected damage by 3 when `sp.Concentration && sp.Effect ∈ {EffectDamageSave, EffectDamageAuto}`. `EffectDamageAttack` excluded by design — single-target attack-roll spells aren't typically concentration; hex-style cases get their lift from mods. Test: `TestSpellExpectedDamage_ConcentrationMultiplier`.
+
+**Measured impact (d8c_corpus.jsonl vs d8prereq, full diff in `sim_results/d8c_findings.md`):** every class within ±2.4pp on the leaderboard (1σ ≈ 2.2pp on n=500) — *macro-leaderboard unchanged*. Picker swap landed where expected at **T3 manor_blackspire**: bard +11pp (32→43), mage +10pp (71→81), sorcerer +9pp (60→69), druid +5pp manor + +1pp underdark. T4/T5 caster wall unchanged (still 0% for every caster except druid 0→1 underdark) — confirms [[project_d8d_diagnostic]]: past T3 the binding constraint is HP+AC, not picker quality.
+
+**Side discovery (engine modelling gap):** cleric stayed flat across all zones despite having spirit_guardians (L3, concentration, save) prepared — and warlock dropped 6pp at manor. Likely the sim's `EffectDamageSave` path resolves the AOE save *once* rather than re-ticking per round while concentration holds, so the multiplier overrates spells the engine then under-delivers on. **Filed as a separate follow-up** (concentration re-tick gap in `SimulateCombat`/turn-engine); does *not* unwind D8-c — bard/mage/sorcerer/druid picker swaps are clean and within plan. Cross-link [[project_concentration_retick_gap]] when written.
+
+**D8-d (DIAGNOSTIC SHIPPED 2026-05-28):** T4 caster wall diagnosed; no code change landed. Writeup: `sim_results/d8d_findings.md`. **Hypothesis disambiguation across cleric/bard/mage/sorcerer/warlock/druid L10 underdark (n=3–5 each):** (a) multi-region transit damage — REJECTED. All casters TPK in r1 (`underdark_surface_tunnels`) before any cross-region transit; `Combats=0` (the elite/boss session table is empty); deaths are entirely inline `SimulateCombat` mob rooms. (b) T4 attack-bonus vs caster AC — confirmed contributor. `computeAC` floor gives casters AC 11–14 vs martial 16–17; T4 standard roster (Atk +5 to +7) hits ~60–65%. (c) HP scaling — confirmed contributor. Caster HPMax 93–110 vs martial 141 (~30% gap). (d) Heal-stock — minor lever, NOT the lever. Direct experiment: bumped `simConsumableBundle` T4 from 2 → 5 Spirit Tonics, re-ran n=5 per class. Median rooms-before-TPK lifted +3–5 but 0/5 clears across every caster. Reverted. **Recommended tuning lever (next session, NOT shipped here):** lift `computeAC` class floors (cleric/druid 3 → 5, bard/warlock 1 → 3, mage/sorcerer 0 → 2) — single function, easy to revert, doesn't move the martial leaders. Validate against `d8prereq_corpus.jsonl`. Hit-dice rescale is the second option but is bigger surface area.
+
+**D8-e (TODO next session): martial T4/T5 regression triage.** Paladin -18pp T4 / fighter -6pp T4 -5pp T5 / ranger -13pp T5 — the cost of moving boss/elite fights from inline `SimulateCombat` to the turn-based `!fight` engine. Two possibilities: (1) turn-engine plays martials slightly worse than inline-sim (action economy / multiattack handling differs — see [[project_sim_multiattack_gap]]); (2) inline-sim was over-rosy and the new numbers are the real ones. Read: trace one paladin underdark run pre/post and diff damage exchanges. If turn-engine is correct, prod martial numbers were inflated and we should not "fix" the regression.
+
+**Sequence:** D8-c → D8-d → D8-e. D8-c is the smallest lever and confirms the picker model. D8-d is the highest-value (caster T4 is the next gap to close). D8-e is informational — settles whether to trust the new numbers.
+
+**Open questions for D8:**
+1. ~~D8-b upcast aggressively or conservatively?~~ **Resolved:** aggressive — the T3 lift (mage +61, warlock +65, druid +68) confirms the model.
+2. D8-c concentration-rounds factor: 3 fixed, or scale with tier (longer fights at T4/T5)? Fixed is simpler; tier-scaled is more correct.
+3. ~~Cleric T3+ cliff~~ — **partial resolution:** picker rewire took cleric T3 0% → 39%. Cleric T4 is still 0% (and so is every other caster); now subsumed by D8-d.
+
+## 4. Cross-cutting risks
+
+- **Existing in-flight expeditions** at deploy time. Either fence by `start_date` (old expeditions finish under old rules) or write a one-shot migration that retunes their room counts. Lean: fence — these are typically <2 days.
+- **The 24h zone-run inactivity timeout** (`dnd_zone_run.go:254`) — must be raised, or the autopilot must self-poke `last_action_at` per tick. With multi-day expeditions, a quiet stretch overnight is now expected.
+- **Idle reaper** (commit `0f72484`, see `expedition_autorun.go` references) — already holds streak on autopilot; verify it tolerates 5-day expeditions.
+- **Babysit perk** — `BabysitSafeRest` already upgrades Standard → Fortified at rest (`dnd_expedition_camp.go:241-245`); confirm interaction with autopilot picking Standard (no change needed; the upgrade fires inside `applyCampRest`).
+- **Multi-region travel still unwired in autopilot** (memory `project_multiregion_travel_unwired`). For T4/T5 to actually take 5–7 days, autopilot **must** auto-advance regions on region-clear. D2/D3 covers this implicitly but call it out — likely a small dedicated commit.
+- **Pet arrival** (memory `project_pet_event_reachability`) — emergence seam is at run-complete; longer expedition just delays the roll, no code change needed.
+- **Twinbee voice + secret NPC buffs** (memories `feedback_twinbee_voice`, `feedback_npc_buffs_are_secret`) — none of the new copy can break these.
+
+## 5. Schema impact
+
+Likely none. Existing columns cover it:
+- `current_day` → autopilot increments via `advanceExpeditionDay`.
+- `camp_json`, `supplies_json`, `region_state`, `threat_*` already in place.
+- One **possible** new column: `expected_days` int (set at launch from zone tier + loadout) so status/end-of-day DMs can render "Day 3/5". Cheaper to derive than store — defer.
+
+## 6. Open questions for next session
+
+1. ~~Day-advance semantics~~ — **decided 2026-05-27: event-anchored.** day++ fires on autopilot camp-pitch (autopilot night-camp = sleep = day burn + briefing). UTC clock becomes a re-engagement-DM anchor only, not a state mutator. See §3-D2 for implementation impact.
+2. ~~Boss autopilot default~~ — **decided 2026-05-28: default ON.** D3 already ships compact-mode boss auto-resolve gated by `bossSafetyGate` (HP/SU/exhaustion). No opt-out flag for now; revisit if players want manual final-blow framing.
+3. ~~Per-tier room counts: sim-first vs ship-and-refine~~ — **decided 2026-05-28: sim-first refinement in D7-d.** D1 shipped a guess; we're much closer now. Measured vs prior: T1 ~2x (7→16), T2 ~1.8x (9→19), T3 ~2x (11→35), T4 ~3x (10→46), T5 ~3x (13→47). Target band is 3–5x; T1–T3 likely want another bump but defer until the D7-d sim corpus reads day-counts. Don't churn graphs blindly.
+4. ~~Extra anchor rooms (T4/T5)~~ — **decided 2026-05-28: yes, add anchor-room variety in T4/T5.** Second elite + second trap mid-zone (not just rely on multi-region/patrols/threat). Slot into D7-d alongside the room-count retune so we don't re-touch the graphs twice.
+5. ~~Mobile/AFK / DM cadence~~ — **decided in D4-a (already shipped):** event-anchored to in-game day. Night-camp pitch flushes the day as a digest; fork/death/run-complete still DM the walk stream; mid-day rests/waypoints surface only the camp block; per-tick auto-walks silent. No real-time pacing knob.
+
+## 7. Sequence
+
+**Original D1–D7 plan (all shipped):** D1 → D2 → D3 → D5 → D4 → D6 → D7.
+
+**Current sequence (post-2026-05-28):** D8-c → D8-d-fix → D8-e → D9 → D10 → final re-baseline.
+
+| Phase | What | Blocks |
+|------|------|--------|
+| D8-c  | Concentration-damage multiplier in `spellExpectedDamage` | D8-d-fix read |
+| D8-d-fix | Lift `computeAC` caster floors (cleric/druid 3→5, bard/warlock 1→3, mage/sorcerer 0→2) | D8-e read |
+| D8-e  | Diff turn-engine vs inline-sim for paladin/fighter/ranger on T4/T5; decide whether martial regression is real or a "fix" target | D9 (need stable class baseline) |
+| D9    | T1–T3 room-count bump toward 3–5× band, sim-validated against fresh corpus | D10 |
+| D10   | T4/T5 anchor-room variety (2nd elite + 2nd trap mid-zone) | final re-baseline |
+| —     | One final L10 + L12 corpus pass to confirm tier day-counts + class spread | — |
+
+## 9. Post-§6 follow-ups (D9 / D10)
+
+### D9 — T1–T3 room-count bump
+
+**Why now:** §6 fork 3 resolved to "sim-first refinement"; D7-d corpus shows T3 hitting only median 3 days (target 4) and T1/T2 weren't even measured because the corpus only matrixed T3+. T1–T3 graphs landed at ~2× prior length in D1; target band is 3–5×.
+
+**Plan:**
+- Pull T1/T2 day-counts from a post-D8 corpus run (matrix needs to include `goblin_warrens`, `crypt_valdris`, `forest_shadows`, `sunken_temple` at L4/L6).
+- Lift graph sizes only if median days < tier target (T1=2, T2=3, T3=4). Don't churn graphs that already hit target.
+- Reuse the D1-a..e fork/anchor/merge patterns (`internal/plugin/zone_graph_*.go`); preserve existing topology — only add Exploration nodes + the second-anchor slot D10 will fill.
+- One-shot bootstrap: existing in-flight expeditions fence by `start_date` per §4 (consistent with D1 deploy).
+
+**Risk:** if D8-d-fix lifts caster T3 clears materially, day-counts move too; measure after D8 stabilizes, not before.
+
+### D10 — T4/T5 anchor-room variety
+
+**Why now:** §6 fork 4 resolved "yes". T4/T5 zones run 30–50 rooms with only one Trap + one Elite anchor; the long middle reads same-y. Bundle with D9 so we touch each `zone_graph_*.go` once.
+
+**Plan:**
+- Add a second Trap + second Elite anchor mid-zone for all T4/T5 zones (`underdark`, `feywild_crossing`, `dragons_lair`, `abyss_portal`).
+- Place the second Elite at the region-boundary spurs (good narrative justification — region-guardian rather than zone-guardian) so multi-region travel finally gets a teeth-y interrupt.
+- Place the second Trap on the long Exploration runs of fork branches, not on the merge node (keeps fork-choice loot/risk asymmetric).
+- Preserve longest-path length within current band — added anchors replace Exploration nodes, not append.
+
+**Validation:** same final corpus pass as D9. Look for boss-clear rate dipping by <5pp (anchor difficulty is intended, not punishing) and median day-count stable.
+
+### Cross-links picked up here
+- [[project_multiregion_travel_unwired]] — boss-clear → next-region auto-advance is wired (verified 2026-05-27); D10's region-boundary elites give it something to interrupt.
+- [[project_j3_caster_picker]] / [[project_d8d_diagnostic]] — D8 gates the whole sequence.
+- [[project_d8prereq_baseline]] — the corpus to diff against, not d7d.

internal/bot/appservice.go

@@ -0,0 +1,310 @@
+package bot
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/rs/zerolog"
+	"maunium.net/go/mautrix"
+	"maunium.net/go/mautrix/appservice"
+	"maunium.net/go/mautrix/crypto/cryptohelper"
+	"maunium.net/go/mautrix/event"
+	"maunium.net/go/mautrix/id"
+)
+
+// presenceHeartbeatInterval is how often the appservice re-asserts its online
+// presence. In masdevice mode the /sync long-poll refreshed presence implicitly;
+// appservice mode has no /sync, so we push presence explicitly. Synapse ties
+// "online" to recent activity and force-offlines a non-syncing user ~30s after its
+// last update (SYNC_ONLINE_TIMEOUT). A slower tick makes the bot FLAP (green right
+// after each PUT, then offline until the next) — empirically observed at 60s. So we
+// tick well under 30s to hold it continuously green. A hard crash stops the
+// heartbeat and Synapse offlines the bot within ~30s on its own.
+const presenceHeartbeatInterval = 20 * time.Second
+
+// Waits applied when an inbound event arrives before its megolm session does.
+// The short wait covers the common race (keys moments behind the event); only
+// after it lapses do we spend an m.room_key_request and wait the long one. The
+// budget bounds the whole recovery so a permanently-unreadable event can't pin a
+// goroutine forever. Mirrors cryptohelper's own 3s/22s ladder.
+const (
+	initialSessionWait    = 3 * time.Second
+	extendedSessionWait   = 22 * time.Second
+	sessionRecoveryBudget = initialSessionWait + extendedSessionWait + 30*time.Second
+)
+
+// cryptoToDeviceTypes are the to-device event types the crypto machine must see
+// to establish Olm/Megolm sessions and share/receive room keys. In /sync mode
+// the cryptohelper gets these automatically; under the appservice transaction
+// model we route each one to mach.HandleToDeviceEvent ourselves.
+var cryptoToDeviceTypes = []event.Type{
+	event.ToDeviceEncrypted,
+	event.ToDeviceRoomKey,
+	event.ToDeviceForwardedRoomKey,
+	event.ToDeviceRoomKeyRequest,
+	event.ToDeviceRoomKeyWithheld,
+	event.ToDeviceOrgMatrixRoomKeyWithheld,
+	event.ToDeviceSecretRequest,
+	event.ToDeviceSecretSend,
+	event.ToDeviceDummy,
+}
+
+// newAppserviceSession builds the appservice-mode Session: as_token auth, a
+// cryptohelper that mints the bot's device via MSC4190, and an EventProcessor
+// fed by Synapse's transaction pushes (in place of /sync). The bot is an
+// appservice user — Synapse forbids AS users from /sync, so all events, plus the
+// E2EE extensions (to-device / device lists / OTK counts), arrive over the
+// transaction API instead.
+func newAppserviceSession(cfg Config) (*Session, error) {
+	if err := os.MkdirAll(cfg.DataDir, 0o755); err != nil {
+		return nil, fmt.Errorf("create data dir: %w", err)
+	}
+	if cfg.UserID == "" {
+		return nil, fmt.Errorf("BOT_USER_ID is required")
+	}
+	if cfg.RegistrationPath == "" {
+		return nil, fmt.Errorf("AS_REGISTRATION is required in appservice mode")
+	}
+	if cfg.HomeserverDomain == "" {
+		return nil, fmt.Errorf("HOMESERVER_DOMAIN is required in appservice mode (server_name, e.g. parodia.dev)")
+	}
+	if !((&appservice.HostConfig{Hostname: cfg.ListenHost, Port: cfg.ListenPort}).IsConfigured()) {
+		return nil, fmt.Errorf("AS_LISTEN_HOST/AS_LISTEN_PORT must be set in appservice mode")
+	}
+
+	ctx := context.Background()
+
+	reg, err := appservice.LoadRegistration(cfg.RegistrationPath)
+	if err != nil {
+		return nil, fmt.Errorf("load appservice registration %q: %w", cfg.RegistrationPath, err)
+	}
+	// Gate for to-device delivery: handleTransaction only pumps to-device events
+	// when this is set (appservice/http.go). Force it on regardless of the yaml so
+	// E2EE key exchange can't silently break on a missing field.
+	reg.EphemeralEvents = true
+
+	as, err := appservice.CreateFull(appservice.CreateOpts{
+		Registration:     reg,
+		HomeserverDomain: cfg.HomeserverDomain,
+		HomeserverURL:    cfg.Homeserver,
+		HostConfig:       appservice.HostConfig{Hostname: cfg.ListenHost, Port: cfg.ListenPort},
+	})
+	if err != nil {
+		return nil, fmt.Errorf("create appservice: %w", err)
+	}
+	// Surface the HTTP listener + transaction logs (default is a silent Nop).
+	as.Log = zerolog.New(os.Stderr).With().Timestamp().Str("component", "appservice").Logger().
+		Level(zerolog.InfoLevel)
+
+	userID := id.UserID(cfg.UserID)
+	if as.BotMXID() != userID {
+		return nil, fmt.Errorf("registration sender_localpart resolves to %s but BOT_USER_ID is %s", as.BotMXID(), userID)
+	}
+
+	client := as.BotClient() // as_token auth + SetAppServiceUserID (?user_id=) assertion
+	// Assert the device via ?org.matrix.msc3202.device_id= on E2EE requests, and
+	// satisfy cryptohelper.Init's syncer check: with this set, Init permits a nil
+	// Syncer (we drive the crypto machine from transactions, not /sync). The param
+	// is only emitted once DeviceID is non-empty (url.go), so setting it now is a
+	// no-op for the whoami/device-create calls below; CreateDeviceMSC4190 re-sets it.
+	client.SetAppServiceDeviceID = true
+
+	// Validate the token + identity before we start listening.
+	whoami, err := client.Whoami(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("appservice token validation failed (whoami): %w", err)
+	}
+	if whoami.UserID != userID {
+		return nil, fmt.Errorf("appservice identity mismatch: token resolves to %s but BOT_USER_ID is %s", whoami.UserID, userID)
+	}
+	slog.Info("appservice token valid", "user_id", whoami.UserID)
+
+	// ---- E2EE via cryptohelper (MSC4190 device creation, no /login) ----
+	cryptoDBPath := filepath.Join(cfg.DataDir, "crypto.db")
+	ch, err := cryptohelper.NewCryptoHelper(client, []byte("gogobee_pickle_key"), cryptoDBPath)
+	if err != nil {
+		return nil, fmt.Errorf("init crypto helper: %w", err)
+	}
+	// MSC4190: the appservice creates/refreshes its own device via PUT /devices
+	// instead of the UIA-gated login. The crypto store persists the device ID, so
+	// restarts reuse it. LoginAs carries only the display name (never calls /login
+	// in MSC4190 mode). client.Syncer is nil here, so Init does NOT wire /sync
+	// handlers — we drive the crypto machine from transactions below instead.
+	ch.MSC4190 = true
+	ch.LoginAs = &mautrix.ReqLogin{InitialDeviceDisplayName: cfg.DisplayName}
+	if err := ch.Init(ctx); err != nil {
+		return nil, fmt.Errorf("crypto helper init (MSC4190 device create): %w", err)
+	}
+	client.Crypto = ch
+
+	// ---- Event processor: replicate the cryptohelper's /sync wiring against
+	// the appservice transaction channels ----
+	ep := appservice.NewEventProcessor(as)
+	mach := ch.Machine()
+
+	// Best-effort cross-signing bootstrap so the bot's device shows as verified to
+	// users who trust its master key. Best-effort: under MAS the key upload may be
+	// refused, which we log and ignore — E2EE still functions without it.
+	bootstrapCrossSigning(ctx, mach, cfg.DataDir)
+
+	// Crypto plumbing that /sync would otherwise carry:
+	ep.OnOTK(mach.HandleOTKCounts)
+	ep.OnDeviceList(mach.HandleDeviceLists)
+	for _, t := range cryptoToDeviceTypes {
+		ep.On(t, mach.HandleToDeviceEvent)
+	}
+
+	// Keep the client's StateStore current so outgoing sends know which rooms are
+	// encrypted and who to share keys with (no /sync backfill here), and let the
+	// crypto machine track membership for key sharing. PrependHandler so state is
+	// updated before app handlers (auto-join/moderation) run for the same event.
+	ep.PrependHandler(event.StateEncryption, func(ctx context.Context, evt *event.Event) {
+		mautrix.UpdateStateStore(ctx, as.StateStore, evt)
+	})
+	ep.PrependHandler(event.StateMember, func(ctx context.Context, evt *event.Event) {
+		mautrix.UpdateStateStore(ctx, as.StateStore, evt)
+		mach.HandleMemberEvent(ctx, evt)
+	})
+
+	// Without /sync there is no state backfill, so the client's StateStore starts
+	// empty. Before we hand off a decrypted event (whose reply may need to be
+	// encrypted), resolve the room once: mark it encrypted and populate its member
+	// list. Otherwise outbound sends go plaintext (IsEncrypted=false) and, worse,
+	// the group session is shared to nobody (GetRoomJoinedOrInvitedMembers empty)
+	// so recipients can't decrypt the bot's replies.
+	var resolved sync.Map // roomID -> struct{}, resolved once
+	resolveRoom := func(ctx context.Context, roomID id.RoomID) {
+		if _, done := resolved.LoadOrStore(roomID, struct{}{}); done {
+			return
+		}
+		var enc event.EncryptionEventContent
+		if err := client.StateEvent(ctx, roomID, event.StateEncryption, "", &enc); err == nil && enc.Algorithm != "" {
+			_ = as.StateStore.SetEncryptionEvent(ctx, roomID, &enc)
+		}
+		if members, err := client.Members(ctx, roomID); err == nil {
+			_ = as.StateStore.ReplaceCachedMembers(ctx, roomID, members.Chunk)
+		} else {
+			slog.Warn("appservice: failed to fetch room members; will retry", "room", roomID, "err", err)
+			resolved.Delete(roomID) // allow a later event to retry
+		}
+	}
+
+	// recoverSession handles an event whose megolm session we don't have yet. The
+	// keys are often merely in flight (a to-device m.room_key racing the room
+	// event), so wait briefly; if they never land, ask the sender to re-share and
+	// wait longer. Only once that fails is the event genuinely unreadable.
+	//
+	// This duplicates cryptohelper.HandleEncrypted's wait/request ladder on
+	// purpose: that path is gated on a /sync token being present in the context
+	// (mautrix.SyncTokenContextKey), which appservice transactions never carry, so
+	// wiring ch.ASEventProcessor would still leave us dropping these events.
+	//
+	// Runs detached from the transaction context, which is cancelled as soon as we
+	// ACK the transaction — long before the keys could arrive.
+	recoverSession := func(evt *event.Event) {
+		ctx, cancel := context.WithTimeout(context.Background(), sessionRecoveryBudget)
+		defer cancel()
+
+		content := evt.Content.AsEncrypted()
+		got := ch.WaitForSession(ctx, evt.RoomID, content.SenderKey, content.SessionID, initialSessionWait)
+		if !got {
+			ch.RequestSession(ctx, evt.RoomID, content.SenderKey, content.SessionID, evt.Sender, content.DeviceID)
+			got = ch.WaitForSession(ctx, evt.RoomID, content.SenderKey, content.SessionID, extendedSessionWait)
+		}
+		if !got {
+			slog.Warn("appservice: gave up decrypting event, no room key",
+				"room", evt.RoomID, "event", evt.ID, "session", content.SessionID)
+			return
+		}
+
+		decrypted, err := ch.Decrypt(ctx, evt)
+		if err != nil {
+			slog.Warn("appservice: failed to decrypt event after key request",
+				"room", evt.RoomID, "event", evt.ID, "err", err)
+			return
+		}
+		slog.Debug("appservice: recovered event after key request", "room", evt.RoomID, "event", evt.ID)
+		ep.Dispatch(ctx, decrypted)
+	}
+
+	// Decrypt inbound encrypted room events and re-dispatch the plaintext so the
+	// normal message/reaction handlers fire (mirrors cryptohelper.HandleEncrypted).
+	ep.On(event.EventEncrypted, func(ctx context.Context, evt *event.Event) {
+		resolveRoom(ctx, evt.RoomID)
+		decrypted, err := ch.Decrypt(ctx, evt)
+		if err != nil {
+			if errors.Is(err, cryptohelper.NoSessionFound) {
+				go recoverSession(evt)
+				return
+			}
+			slog.Warn("appservice: failed to decrypt event", "room", evt.RoomID, "event", evt.ID, "err", err)
+			return
+		}
+		ep.Dispatch(ctx, decrypted)
+	})
+
+	return &Session{
+		Client: client,
+		mode:   "appservice",
+		as:     as,
+		ep:     ep,
+	}, nil
+}
+
+// runAppservice starts the transaction dispatchers and the HTTP listener, then
+// blocks until ctx is cancelled.
+func (s *Session) runAppservice(ctx context.Context) error {
+	s.ep.Start(ctx)
+	s.as.Ready = true
+
+	errCh := make(chan struct{})
+	go func() {
+		s.as.Start() // blocks in ListenAndServe until Stop()
+		close(errCh)
+	}()
+
+	slog.Info("appservice listener started", "address", s.as.Host.Address())
+
+	select {
+	case <-ctx.Done():
+		return nil
+	case <-errCh:
+		return fmt.Errorf("appservice HTTP listener exited unexpectedly")
+	}
+}
+
+// runPresenceHeartbeat keeps the bot's Matrix presence "online" while the
+// appservice runs. Without /sync, nothing else refreshes presence, so it would
+// otherwise freeze at its last value. On graceful shutdown it best-effort sets
+// presence "offline"; on a hard crash the heartbeat simply stops and Synapse
+// decays the stale "online" state on its own.
+func (s *Session) runPresenceHeartbeat(ctx context.Context) {
+	setPresence := func(ctx context.Context, presence event.Presence) {
+		if err := s.Client.SetPresence(ctx, mautrix.ReqPresence{Presence: presence}); err != nil {
+			slog.Warn("appservice: set presence failed", "presence", presence, "err", err)
+		}
+	}
+
+	setPresence(ctx, event.PresenceOnline)
+
+	ticker := time.NewTicker(presenceHeartbeatInterval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			// Detach from the cancelled ctx so the final PUT still goes out.
+			offCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			setPresence(offCtx, event.PresenceOffline)
+			cancel()
+			return
+		case <-ticker.C:
+			setPresence(ctx, event.PresenceOnline)
+		}
+	}
+}

internal/bot/client.go

@@ -2,203 +2,174 @@ package bot
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"log/slog"
 	"os"
 	"path/filepath"
-
-	"gogobee/internal/util"
+	"time"
 
 	"maunium.net/go/mautrix"
 	"maunium.net/go/mautrix/crypto/cryptohelper"
 	"maunium.net/go/mautrix/id"
 )
 
-// DeviceInfo holds persisted device credentials.
-type DeviceInfo struct {
-	AccessToken string `json:"access_token"`
-	DeviceID    string `json:"device_id"`
-	UserID      string `json:"user_id"`
-}
-
 // Config holds the bot's startup configuration.
 type Config struct {
 	Homeserver  string
-	UserID      string
-	Password    string
+	UserID      string // Bot's full Matrix user ID, e.g. @twinbee:parodia.dev
 	DataDir     string
 	DisplayName string
+
+	// AuthMode selects how the bot connects to Matrix:
+	//   "masdevice" (default) — MAS OAuth 2.0 device grant + /sync (masauth.go).
+	//   "appservice"          — Matrix appservice: as_token auth + Synapse→bot
+	//                           transaction push (appservice.go). MAS-durable:
+	//                           no login, no MFA, no token expiry ever.
+	// The device-grant path is retained as an instant rollback: flip AUTH_MODE
+	// back to masdevice and restart, no rebuild.
+	AuthMode string
+
+	// ---- appservice mode only ----
+	// RegistrationPath points at the appservice registration YAML (id, as_token,
+	// hs_token, sender_localpart, namespaces). Synapse and the bot share it.
+	RegistrationPath string
+	// ListenHost/ListenPort is where the bot's HTTP listener binds to receive
+	// Synapse's transaction pushes (Synapse reaches it via the registration url).
+	ListenHost string
+	ListenPort uint16
+	// HomeserverDomain is the server_name (e.g. parodia.dev), needed to derive
+	// the bot's MXID from sender_localpart.
+	HomeserverDomain string
 }
 
-// NewClient creates and configures a mautrix client with E2EE support.
-// The cryptohelper handles:
-//   - Persistent crypto store in SQLite (device keys, sessions, cross-signing keys)
-//   - Automatic cross-signing bootstrap (self-signs the device on first run)
-//   - Automatic device trust via cross-signing (no manual verification needed)
-//   - Megolm session sharing and key exchange
-//   - Olm session management for device-to-device encryption
+// NewClient creates and configures a mautrix client authenticated against
+// Matrix Authentication Service (MAS) via the OAuth 2.0 device grant, with
+// E2EE via the cryptohelper.
 //
-// This solves the TS version's device verification issues because:
-//   1. Crypto state persists across restarts (not in-memory like fake-indexeddb)
-//   2. Cross-signing makes other devices trust this bot automatically
-//   3. The bot trusts all users' devices by default (appropriate for a bot)
-//   4. No manual emoji/SAS verification needed
+// Auth flow (see masauth.go for detail):
+//   - Discover MAS OAuth endpoints from the homeserver's well-known + OIDC docs.
+//   - If we have a persisted refresh token, refresh it for a fresh access token.
+//   - Otherwise run the device-authorization grant: print a URL + code for a
+//     human to approve ONCE in a browser (as the bot's user), then store the
+//     resulting access + refresh tokens.
+//   - A background goroutine refreshes the access token before it expires and
+//     updates the live client, so the bot runs indefinitely without re-auth.
+//
+// The bot stays a normal Matrix user (not an appservice), so /sync works — an
+// appservice user is forbidden from /sync by Synapse. E2EE is unchanged: the
+// cryptohelper persists device keys, olm/megolm sessions and cross-signing in
+// its own SQLite store, and the bot trusts all users' devices by default.
 func NewClient(cfg Config) (*mautrix.Client, error) {
 	if err := os.MkdirAll(cfg.DataDir, 0o755); err != nil {
 		return nil, fmt.Errorf("create data dir: %w", err)
 	}
+	if cfg.UserID == "" {
+		return nil, fmt.Errorf("BOT_USER_ID is required")
+	}
 
-	devicePath := filepath.Join(cfg.DataDir, "device.json")
+	ctx := context.Background()
 
-	// Try to load existing device credentials
-	device, err := loadDevice(devicePath)
+	// ---- MAS OAuth device-grant authentication ----
+	auth := newMASAuth(cfg.DataDir)
+	auth.load()
+	if err := auth.discover(cfg.Homeserver); err != nil {
+		return nil, fmt.Errorf("MAS discovery: %w", err)
+	}
+
+	if auth.refreshToken != "" {
+		// Returning start: refresh the stored token.
+		if err := auth.refresh(); err != nil {
+			return nil, fmt.Errorf("MAS token refresh failed (delete %s to re-authorize): %w",
+				filepath.Join(cfg.DataDir, "mas_auth.json"), err)
+		}
+		slog.Info("MAS auth: refreshed access token from stored session", "device_id", auth.deviceID)
+	} else {
+		// First run: register a client and run the interactive device grant.
+		if err := auth.ensureClient(cfg.DisplayName); err != nil {
+			return nil, fmt.Errorf("MAS client registration: %w", err)
+		}
+		if err := auth.deviceFlow(ctx); err != nil {
+			return nil, fmt.Errorf("MAS device authorization: %w", err)
+		}
+	}
+
+	userID := id.UserID(cfg.UserID)
+	client, err := mautrix.NewClient(cfg.Homeserver, userID, auth.token())
 	if err != nil {
-		slog.Info("no existing device found, will login fresh")
+		return nil, fmt.Errorf("create client: %w", err)
 	}
+	client.DeviceID = id.DeviceID(auth.deviceID)
 
-	var client *mautrix.Client
-
-	if device != nil {
-		// Validate existing token
-		valid, _ := util.IsTokenValid(cfg.Homeserver, device.AccessToken)
-		if valid {
-			slog.Info("existing device credentials valid", "device_id", device.DeviceID)
-			userID := id.UserID(device.UserID)
-			client, err = mautrix.NewClient(cfg.Homeserver, userID, device.AccessToken)
-			if err != nil {
-				return nil, fmt.Errorf("create client with existing token: %w", err)
-			}
-			client.DeviceID = id.DeviceID(device.DeviceID)
-		} else {
-			slog.Warn("existing device credentials invalid, logging in again")
-			device = nil
-		}
+	// Validate the token + identity before proceeding.
+	whoami, err := client.Whoami(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("token validation failed (whoami): %w", err)
 	}
-
-	if device == nil {
-		// Fresh login
-		loginResp, err := util.LoginWithPassword(cfg.Homeserver, cfg.UserID, cfg.Password, cfg.DisplayName)
-		if err != nil {
-			return nil, fmt.Errorf("login: %w", err)
-		}
-
-		userID := id.UserID(loginResp.UserID)
-		client, err = mautrix.NewClient(cfg.Homeserver, userID, loginResp.AccessToken)
-		if err != nil {
-			return nil, fmt.Errorf("create client: %w", err)
-		}
-		client.DeviceID = id.DeviceID(loginResp.DeviceID)
-
-		// Save device info
-		device = &DeviceInfo{
-			AccessToken: loginResp.AccessToken,
-			DeviceID:    loginResp.DeviceID,
-			UserID:      loginResp.UserID,
-		}
-		if err := saveDevice(devicePath, device); err != nil {
-			slog.Warn("failed to save device info", "err", err)
-		}
-
-		slog.Info("logged in successfully",
-			"user_id", loginResp.UserID,
-			"device_id", loginResp.DeviceID,
-		)
+	if whoami.UserID != userID {
+		return nil, fmt.Errorf("identity mismatch: token resolves to %s but BOT_USER_ID is %s", whoami.UserID, userID)
 	}
+	slog.Info("MAS auth: token valid", "user_id", whoami.UserID, "device_id", client.DeviceID)
 
-	// Set up E2EE via cryptohelper — stores crypto state in its own SQLite DB,
-	// separate from the main app database. Unlike the TS version which used an
-	// in-memory fake-indexeddb store that was lost on restart (causing constant
-	// re-verification), mautrix-go's cryptohelper persists everything in SQLite:
-	// device keys, olm/megolm sessions, cross-signing keys, and device trust state.
-	//
-	// We pass just the raw file path — the cryptohelper wraps it in a file: URI
-	// with _txlock=immediate internally (see cryptohelper.go line 82).
+	// ---- E2EE via cryptohelper ----
+	// The crypto store persists device keys, olm/megolm sessions, cross-signing
+	// and device trust in its own SQLite DB. The stored device ID must match the
+	// one bound to our OAuth token (device: scope); a fresh mas_auth.json is
+	// paired with a fresh crypto.db.
 	cryptoDBPath := filepath.Join(cfg.DataDir, "crypto.db")
 	ch, err := cryptohelper.NewCryptoHelper(client, []byte("gogobee_pickle_key"), cryptoDBPath)
 	if err != nil {
 		return nil, fmt.Errorf("init crypto helper: %w", err)
 	}
-
-	// LoginAs enables the cryptohelper to re-login if the token expires,
-	// and to bootstrap cross-signing on first run. Cross-signing means:
-	//   - The bot's master key signs its own device key
-	//   - Other users/devices that have verified the bot's master key
-	//     will automatically trust this device
-	//   - No interactive emoji/SAS verification needed
-	ch.LoginAs = &mautrix.ReqLogin{
-		Type: mautrix.AuthTypePassword,
-		Identifier: mautrix.UserIdentifier{
-			Type: mautrix.IdentifierTypeUser,
-			User: cfg.UserID,
-		},
-		Password:                 cfg.Password,
-		InitialDeviceDisplayName: cfg.DisplayName,
-	}
-
-	if err := ch.Init(context.Background()); err != nil {
+	// No LoginAs: we already have a token + device ID; the cryptohelper just
+	// attaches E2EE to the existing session.
+	if err := ch.Init(ctx); err != nil {
 		return nil, fmt.Errorf("crypto helper init: %w", err)
 	}
-
-	// Attach crypto helper to client
 	client.Crypto = ch
 
-	// Bootstrap cross-signing: generate keys, sign own device, sign master key.
-	// This makes the bot's device show as "verified" to other users.
+	// Best-effort cross-signing bootstrap (makes the bot's device show as
+	// verified to users who trust its master key). Not required for E2EE to
+	// function; under MAS the key upload may be refused, which we ignore.
 	mach := ch.Machine()
-	recoveryKey, _, err := mach.GenerateAndUploadCrossSigningKeys(context.Background(), func(ui *mautrix.RespUserInteractive) interface{} {
-		return map[string]interface{}{
-			"type": mautrix.AuthTypePassword,
-			"identifier": map[string]interface{}{
-				"type": mautrix.IdentifierTypeUser,
-				"user": cfg.UserID,
-			},
-			"password": cfg.Password,
-			"session":  ui.Session,
-		}
-	}, "")
-	if err != nil {
-		slog.Warn("cross-signing: key upload failed (may already exist)", "err", err)
-	} else {
-		slog.Info("cross-signing: keys uploaded", "recovery_key", recoveryKey)
-	}
+	bootstrapCrossSigning(ctx, mach, cfg.DataDir)
 
-	if err := mach.SignOwnDevice(context.Background(), mach.OwnIdentity()); err != nil {
-		slog.Warn("cross-signing: sign own device failed", "err", err)
-	} else {
-		slog.Info("cross-signing: own device signed")
-	}
-
-	if err := mach.SignOwnMasterKey(context.Background()); err != nil {
-		slog.Warn("cross-signing: sign master key failed", "err", err)
-	} else {
-		slog.Info("cross-signing: master key signed")
-	}
+	// ---- Background token refresher ----
+	// Refresh ~60s before expiry and push the new token into the live client so
+	// in-flight /sync and API calls keep authenticating.
+	go refreshLoop(context.Background(), auth, client)
 
 	slog.Info("E2EE initialized",
+		"user_id", client.UserID,
 		"device_id", client.DeviceID,
 		"crypto_store", "sqlite-persistent",
+		"auth", "mas-oauth-device-grant",
 	)
 
 	return client, nil
 }
 
-func loadDevice(path string) (*DeviceInfo, error) {
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
+// refreshLoop keeps the client's access token fresh for the life of the process.
+func refreshLoop(ctx context.Context, auth *masAuth, client *mautrix.Client) {
+	for {
+		wait := time.Until(auth.expiry()) - 60*time.Second
+		if wait < 10*time.Second {
+			wait = 10 * time.Second
+		}
+		select {
+		case <-ctx.Done():
+			return
+		case <-time.After(wait):
+		}
+		if err := auth.refresh(); err != nil {
+			slog.Error("MAS token refresh failed; retrying in 30s", "err", err)
+			select {
+			case <-ctx.Done():
+				return
+			case <-time.After(30 * time.Second):
+			}
+			continue
+		}
+		client.AccessToken = auth.token()
+		slog.Debug("MAS token refreshed", "expires_at", auth.expiry().Format(time.RFC3339))
 	}
-	var info DeviceInfo
-	if err := json.Unmarshal(data, &info); err != nil {
-		return nil, err
-	}
-	return &info, nil
-}
-
-func saveDevice(path string, info *DeviceInfo) error {
-	data, err := json.MarshalIndent(info, "", "  ")
-	if err != nil {
-		return err
-	}
-	return os.WriteFile(path, data, 0o600)
 }

internal/bot/crosssigning.go

@@ -0,0 +1,137 @@
+package bot
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"os"
+	"path/filepath"
+
+	"maunium.net/go/mautrix"
+	"maunium.net/go/mautrix/crypto"
+)
+
+// crossSigningFile is the on-disk store for the bot's cross-signing recovery key
+// (data/cross_signing.json), alongside mas_auth.json and crypto.db. The key
+// decrypts the private cross-signing keys the bot parks in SSSS, so it is the
+// only thing that lets a rebuilt crypto.db re-sign the bot's device instead of
+// minting a whole new identity and forcing everyone to re-verify.
+//
+// It is deliberately NOT logged: the screen wrapper pipes the bot's output
+// through tee, which truncates the log on every restart, so a key that only ever
+// exists in a log line is a key you lose on the next boot.
+const crossSigningFile = "cross_signing.json"
+
+type crossSigningStore struct {
+	RecoveryKey string `json:"recovery_key"`
+}
+
+func crossSigningPath(dataDir string) string {
+	return filepath.Join(dataDir, crossSigningFile)
+}
+
+// loadRecoveryKey returns the stored key, or "" when there is none.
+func loadRecoveryKey(dataDir string) string {
+	data, err := os.ReadFile(crossSigningPath(dataDir))
+	if err != nil {
+		return "" // fresh install
+	}
+	var s crossSigningStore
+	if err := json.Unmarshal(data, &s); err != nil {
+		slog.Warn("cross-signing: corrupt recovery-key store, ignoring", "path", crossSigningPath(dataDir), "err", err)
+		return ""
+	}
+	return s.RecoveryKey
+}
+
+func saveRecoveryKey(dataDir, key string) {
+	data, err := json.MarshalIndent(crossSigningStore{RecoveryKey: key}, "", "  ")
+	if err != nil {
+		slog.Error("cross-signing: marshal recovery key failed", "err", err)
+		return
+	}
+	path := crossSigningPath(dataDir)
+	if err := os.WriteFile(path, data, 0o600); err != nil {
+		slog.Error("cross-signing: could not persist recovery key; a crypto.db rebuild will need a re-verify", "path", path, "err", err)
+		return
+	}
+	slog.Info("cross-signing: recovery key persisted", "path", path)
+}
+
+// uiaSession answers a user-interactive-auth challenge with just the session ID.
+// Under MAS the key upload is either allowed outright or refused; there is no
+// password to offer.
+func uiaSession(ui *mautrix.RespUserInteractive) interface{} {
+	return map[string]interface{}{"session": ui.Session}
+}
+
+// bootstrapCrossSigning establishes the bot's cross-signing identity, which is
+// what lets clients show it as verified rather than as an unknown device. E2EE
+// works without it; only the verification badge depends on it.
+//
+// It must never mint a second identity by accident. mautrix's
+// GenerateAndUploadCrossSigningKeys is unconditional: every call generates a fresh
+// master/self/user-signing trio and overwrites the published one. Calling it on
+// each start reminted the bot's identity every boot, which is why clients kept
+// asking users to re-verify. So generate only when there is no identity to keep,
+// or when the operator explicitly asks for a reset.
+//
+// The private keys live server-side in SSSS, never in crypto.db, and mach.Load
+// does not restore them. A bot that keeps its crypto.db stays signed from its
+// first signing and needs nothing here. A bot whose crypto.db was rebuilt has a
+// brand-new device that only the recovery key can re-sign.
+//
+// Set CROSS_SIGNING_REGENERATE=1 to deliberately reset the identity (costs one
+// re-verify per user, and stores the fresh key). CROSS_SIGNING_RECOVERY_KEY
+// imports an existing key into the store, for adopting an identity created before
+// the bot persisted its own.
+func bootstrapCrossSigning(ctx context.Context, mach *crypto.OlmMachine, dataDir string) {
+	stored := loadRecoveryKey(dataDir)
+	if envKey := os.Getenv("CROSS_SIGNING_RECOVERY_KEY"); envKey != "" && envKey != stored {
+		saveRecoveryKey(dataDir, envKey)
+		stored = envKey
+	}
+
+	hasKeys, isVerified, err := mach.GetOwnVerificationStatus(ctx)
+	if err != nil {
+		slog.Warn("cross-signing: could not determine verification status, leaving identity alone", "err", err)
+		return
+	}
+	regenerate := os.Getenv("CROSS_SIGNING_REGENERATE") != ""
+
+	switch {
+	case regenerate || !hasKeys:
+		if regenerate && hasKeys {
+			slog.Warn("cross-signing: CROSS_SIGNING_REGENERATE set — replacing the published identity; every user must verify the bot once more. Unset it after this start.")
+		}
+		key, _, err := mach.GenerateAndUploadCrossSigningKeys(ctx, uiaSession, "")
+		if err != nil {
+			slog.Warn("cross-signing: key upload failed, bot will show unverified", "err", err)
+			return
+		}
+		saveRecoveryKey(dataDir, key)
+		if err := mach.SignOwnDevice(ctx, mach.OwnIdentity()); err != nil {
+			slog.Warn("cross-signing: sign own device failed", "err", err)
+		}
+		if err := mach.SignOwnMasterKey(ctx); err != nil {
+			slog.Warn("cross-signing: sign master key failed", "err", err)
+		}
+		slog.Info("cross-signing: identity created and device signed")
+
+	case isVerified:
+		slog.Info("cross-signing: identity already published and this device is signed")
+
+	case stored != "":
+		// Pulls the private keys back out of SSSS, then signs this device and the
+		// master key with them.
+		if err := mach.VerifyWithRecoveryKey(ctx, stored); err != nil {
+			slog.Warn("cross-signing: recovery-key restore failed, bot will show unverified", "err", err)
+			return
+		}
+		slog.Info("cross-signing: device re-signed from the stored recovery key")
+
+	default:
+		slog.Warn("cross-signing: this device is unsigned and no recovery key is stored, so the bot will show unverified (E2EE still works). Set CROSS_SIGNING_REGENERATE=1 once to mint a fresh identity.",
+			"store", crossSigningPath(dataDir))
+	}
+}

internal/bot/crosssigning_test.go

@@ -0,0 +1,56 @@
+package bot
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestRecoveryKeyRoundTrip(t *testing.T) {
+	dir := t.TempDir()
+	if got := loadRecoveryKey(dir); got != "" {
+		t.Fatalf("fresh install returned %q, want empty", got)
+	}
+
+	const key = "EsTd o49d mMLt 3Uf9 Gjn9 x5fv YE9H wF6n aadC q2D8 Fv7j rQ4c"
+	saveRecoveryKey(dir, key)
+	if got := loadRecoveryKey(dir); got != key {
+		t.Fatalf("loadRecoveryKey() = %q, want %q", got, key)
+	}
+}
+
+// The key is crypto material sitting next to crypto.db; it must not be readable
+// by other users on the host.
+func TestRecoveryKeyFileIsPrivate(t *testing.T) {
+	dir := t.TempDir()
+	saveRecoveryKey(dir, "some-key")
+	info, err := os.Stat(filepath.Join(dir, crossSigningFile))
+	if err != nil {
+		t.Fatalf("stat: %v", err)
+	}
+	if perm := info.Mode().Perm(); perm != 0o600 {
+		t.Fatalf("recovery key file mode = %o, want 600", perm)
+	}
+}
+
+// A corrupt store must degrade to "no key" rather than panicking or returning
+// garbage that would be fed to VerifyWithRecoveryKey.
+func TestRecoveryKeyCorruptStore(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, crossSigningFile), []byte("{not json"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if got := loadRecoveryKey(dir); got != "" {
+		t.Fatalf("corrupt store returned %q, want empty", got)
+	}
+}
+
+// Overwriting an adopted key must not leave trailing bytes from the longer value.
+func TestRecoveryKeyOverwrite(t *testing.T) {
+	dir := t.TempDir()
+	saveRecoveryKey(dir, "a-much-longer-original-recovery-key-value")
+	saveRecoveryKey(dir, "short")
+	if got := loadRecoveryKey(dir); got != "short" {
+		t.Fatalf("loadRecoveryKey() = %q, want %q", got, "short")
+	}
+}

internal/bot/dispatch.go

@@ -2,6 +2,8 @@ package bot
 
 import (
 	"log/slog"
+	"os"
+	"strings"
 	"sync"
 
 	"gogobee/internal/plugin"
@@ -9,13 +11,24 @@ import (
 
 // Registry manages plugin registration and event dispatch.
 type Registry struct {
-	mu      sync.RWMutex
-	plugins []plugin.Plugin
+	mu          sync.RWMutex
+	plugins     []plugin.Plugin
+	ignoredBots map[string]struct{}
 }
 
-// NewRegistry creates an empty plugin registry.
+// NewRegistry creates an empty plugin registry. Senders listed in the
+// IGNORED_BOTS env var (comma-separated full Matrix user IDs, e.g.
+// "@pete:parodia.dev") are dropped before any plugin sees them.
 func NewRegistry() *Registry {
-	return &Registry{}
+	ignored := make(map[string]struct{})
+	if raw := os.Getenv("IGNORED_BOTS"); raw != "" {
+		for _, u := range strings.Split(raw, ",") {
+			if u = strings.TrimSpace(u); u != "" {
+				ignored[u] = struct{}{}
+			}
+		}
+	}
+	return &Registry{ignoredBots: ignored}
 }
 
 // Register adds a plugin to the registry.
@@ -42,6 +55,9 @@ func (r *Registry) Init() error {
 
 // DispatchMessage sends a message context to all plugins in order.
 func (r *Registry) DispatchMessage(ctx plugin.MessageContext) {
+	if _, ok := r.ignoredBots[string(ctx.Sender)]; ok {
+		return
+	}
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 	for _, p := range r.plugins {
@@ -71,6 +87,9 @@ func (r *Registry) safeOnMessage(p plugin.Plugin, ctx plugin.MessageContext) {
 
 // DispatchReaction sends a reaction context to all plugins in order.
 func (r *Registry) DispatchReaction(ctx plugin.ReactionContext) {
+	if _, ok := r.ignoredBots[string(ctx.Sender)]; ok {
+		return
+	}
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 	for _, p := range r.plugins {

internal/bot/masauth.go

@@ -0,0 +1,375 @@
+package bot
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+// masAuth performs MAS (Matrix Authentication Service) OAuth 2.0 device-grant
+// authentication for the bot and keeps a valid access token available.
+//
+// Why this exists: MAS replaces Matrix's legacy password login with OAuth2. A
+// bot can't do the interactive authorization-code flow, so we use the OAuth 2.0
+// Device Authorization Grant (RFC 8628): on first run the bot prints a URL +
+// user code, a human approves the login as the bot's user ONCE in a browser,
+// and MAS returns an access token + refresh token. Thereafter the bot refreshes
+// silently forever — no password, no expiry surprises, and the bot stays a
+// normal Matrix user so /sync keeps working (unlike an appservice user, which
+// Synapse forbids from /sync).
+//
+// The refresh token is rotated by MAS on every refresh, so we persist the new
+// one each time.
+type masAuth struct {
+	http      *http.Client
+	storePath string
+	scope     string
+
+	// discovered OAuth endpoints
+	deviceEndpoint       string
+	tokenEndpoint        string
+	registrationEndpoint string
+
+	mu           sync.RWMutex
+	clientID     string
+	deviceID     string
+	accessToken  string
+	refreshToken string
+	expiresAt    time.Time
+}
+
+// masStore is the on-disk persisted state (data/mas_auth.json).
+type masStore struct {
+	ClientID     string    `json:"client_id"`
+	DeviceID     string    `json:"device_id"`
+	AccessToken  string    `json:"access_token"`
+	RefreshToken string    `json:"refresh_token"`
+	ExpiresAt    time.Time `json:"expires_at"`
+}
+
+const masScopeAPI = "urn:matrix:org.matrix.msc2967.client:api:*"
+
+func newMASAuth(dataDir string) *masAuth {
+	return &masAuth{
+		http:      &http.Client{Timeout: 30 * time.Second},
+		storePath: filepath.Join(dataDir, "mas_auth.json"),
+	}
+}
+
+func (m *masAuth) load() {
+	data, err := os.ReadFile(m.storePath)
+	if err != nil {
+		return // fresh install
+	}
+	var s masStore
+	if err := json.Unmarshal(data, &s); err != nil {
+		slog.Warn("mas_auth: corrupt store, ignoring", "err", err)
+		return
+	}
+	m.clientID = s.ClientID
+	m.deviceID = s.DeviceID
+	m.accessToken = s.AccessToken
+	m.refreshToken = s.RefreshToken
+	m.expiresAt = s.ExpiresAt
+}
+
+func (m *masAuth) save() {
+	m.mu.RLock()
+	s := masStore{
+		ClientID:     m.clientID,
+		DeviceID:     m.deviceID,
+		AccessToken:  m.accessToken,
+		RefreshToken: m.refreshToken,
+		ExpiresAt:    m.expiresAt,
+	}
+	m.mu.RUnlock()
+	data, err := json.MarshalIndent(s, "", "  ")
+	if err != nil {
+		slog.Error("mas_auth: marshal failed", "err", err)
+		return
+	}
+	if err := os.WriteFile(m.storePath, data, 0o600); err != nil {
+		slog.Error("mas_auth: write failed", "err", err)
+	}
+}
+
+func (m *masAuth) token() string {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.accessToken
+}
+
+// discover resolves the MAS OAuth endpoints from the homeserver's well-known
+// document and the issuer's OIDC discovery document.
+func (m *masAuth) discover(homeserver string) error {
+	var wk struct {
+		Auth struct {
+			Issuer string `json:"issuer"`
+		} `json:"org.matrix.msc2965.authentication"`
+	}
+	if err := m.getJSON(strings.TrimRight(homeserver, "/")+"/.well-known/matrix/client", &wk); err != nil {
+		return fmt.Errorf("fetch well-known: %w", err)
+	}
+	if wk.Auth.Issuer == "" {
+		return fmt.Errorf("homeserver does not advertise a MAS issuer (msc2965) — is MAS enabled?")
+	}
+	var oidc struct {
+		DeviceEndpoint       string `json:"device_authorization_endpoint"`
+		TokenEndpoint        string `json:"token_endpoint"`
+		RegistrationEndpoint string `json:"registration_endpoint"`
+	}
+	if err := m.getJSON(strings.TrimRight(wk.Auth.Issuer, "/")+"/.well-known/openid-configuration", &oidc); err != nil {
+		return fmt.Errorf("fetch OIDC discovery: %w", err)
+	}
+	if oidc.DeviceEndpoint == "" || oidc.TokenEndpoint == "" {
+		return fmt.Errorf("MAS issuer %q does not advertise a device/token endpoint", wk.Auth.Issuer)
+	}
+	m.deviceEndpoint = oidc.DeviceEndpoint
+	m.tokenEndpoint = oidc.TokenEndpoint
+	m.registrationEndpoint = oidc.RegistrationEndpoint
+	slog.Info("mas_auth: discovered endpoints", "issuer", wk.Auth.Issuer)
+	return nil
+}
+
+// ensureClient registers a public OAuth client via dynamic registration if we
+// don't already have a client_id persisted.
+func (m *masAuth) ensureClient(displayName string) error {
+	if m.clientID != "" {
+		return nil
+	}
+	if m.registrationEndpoint == "" {
+		return fmt.Errorf("no registration endpoint discovered")
+	}
+	body := map[string]any{
+		"client_name":                displayName + " (bot)",
+		"application_type":           "native",
+		"token_endpoint_auth_method": "none",
+		"grant_types":                []string{"urn:ietf:params:oauth:grant-type:device_code", "refresh_token"},
+		"response_types":             []string{},
+		"client_uri":                 "https://github.com/prosolis/gogobee",
+	}
+	raw, _ := json.Marshal(body)
+	resp, err := m.http.Post(m.registrationEndpoint, "application/json", strings.NewReader(string(raw)))
+	if err != nil {
+		return fmt.Errorf("client registration request: %w", err)
+	}
+	defer resp.Body.Close()
+	rb, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != 200 && resp.StatusCode != 201 {
+		return fmt.Errorf("client registration failed (HTTP %d): %s", resp.StatusCode, string(rb))
+	}
+	var out struct {
+		ClientID string `json:"client_id"`
+	}
+	if err := json.Unmarshal(rb, &out); err != nil || out.ClientID == "" {
+		return fmt.Errorf("client registration: no client_id in response: %s", string(rb))
+	}
+	m.mu.Lock()
+	m.clientID = out.ClientID
+	m.mu.Unlock()
+	m.save()
+	slog.Info("mas_auth: registered OAuth client", "client_id", out.ClientID)
+	return nil
+}
+
+// deviceFlow runs the interactive device-authorization grant. It blocks until
+// the user approves the login (or the code expires).
+func (m *masAuth) deviceFlow(ctx context.Context) error {
+	if m.deviceID == "" {
+		m.deviceID = randomDeviceID()
+	}
+	scope := masScopeAPI + " urn:matrix:org.matrix.msc2967.client:device:" + m.deviceID
+
+	form := url.Values{"client_id": {m.clientID}, "scope": {scope}}
+	var da struct {
+		DeviceCode              string `json:"device_code"`
+		UserCode                string `json:"user_code"`
+		VerificationURI         string `json:"verification_uri"`
+		VerificationURIComplete string `json:"verification_uri_complete"`
+		ExpiresIn               int    `json:"expires_in"`
+		Interval                int    `json:"interval"`
+	}
+	if err := m.postForm(m.deviceEndpoint, form, &da); err != nil {
+		return fmt.Errorf("device authorization request: %w", err)
+	}
+
+	// Surface the approval prompt prominently — the operator must act on it.
+	uri := da.VerificationURI
+	if da.VerificationURIComplete != "" {
+		uri = da.VerificationURIComplete
+	}
+	banner := fmt.Sprintf(`
+
+================= TwinBee needs you to authorize its login =================
+  Open this URL in a browser (logged in as the bot's Matrix user):
+      %s
+  and enter code:  %s
+  (expires in %d minutes)
+============================================================================
+
+`, uri, da.UserCode, da.ExpiresIn/60)
+	fmt.Print(banner)
+	slog.Warn("mas_auth: device authorization required", "verification_uri", da.VerificationURI, "user_code", da.UserCode, "expires_in_s", da.ExpiresIn)
+
+	interval := da.Interval
+	if interval <= 0 {
+		interval = 5
+	}
+	deadline := time.Now().Add(time.Duration(da.ExpiresIn) * time.Second)
+	for time.Now().Before(deadline) {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(time.Duration(interval) * time.Second):
+		}
+		pending, err := m.pollToken(url.Values{
+			"grant_type":  {"urn:ietf:params:oauth:grant-type:device_code"},
+			"device_code": {da.DeviceCode},
+			"client_id":   {m.clientID},
+		})
+		if err != nil {
+			return err
+		}
+		if !pending {
+			slog.Info("mas_auth: device authorization approved", "device_id", m.deviceID)
+			return nil
+		}
+	}
+	return fmt.Errorf("device authorization timed out (not approved within %d minutes)", da.ExpiresIn/60)
+}
+
+// pollToken hits the token endpoint. Returns pending=true if the user hasn't
+// approved yet (keep polling); on success it stores the tokens.
+func (m *masAuth) pollToken(form url.Values) (pending bool, err error) {
+	resp, err := m.http.PostForm(m.tokenEndpoint, form)
+	if err != nil {
+		return false, fmt.Errorf("token request: %w", err)
+	}
+	defer resp.Body.Close()
+	rb, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode == 200 {
+		return false, m.storeTokenResponse(rb)
+	}
+	var oerr struct {
+		Error string `json:"error"`
+	}
+	_ = json.Unmarshal(rb, &oerr)
+	switch oerr.Error {
+	case "authorization_pending":
+		return true, nil
+	case "slow_down":
+		return true, nil
+	default:
+		return false, fmt.Errorf("token endpoint error (HTTP %d): %s", resp.StatusCode, string(rb))
+	}
+}
+
+// refresh exchanges the stored refresh token for a fresh access token. MAS
+// rotates the refresh token, so we persist the new one.
+func (m *masAuth) refresh() error {
+	m.mu.RLock()
+	rt, cid := m.refreshToken, m.clientID
+	m.mu.RUnlock()
+	if rt == "" {
+		return fmt.Errorf("no refresh token")
+	}
+	resp, err := m.http.PostForm(m.tokenEndpoint, url.Values{
+		"grant_type":    {"refresh_token"},
+		"refresh_token": {rt},
+		"client_id":     {cid},
+	})
+	if err != nil {
+		return fmt.Errorf("refresh request: %w", err)
+	}
+	defer resp.Body.Close()
+	rb, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("refresh failed (HTTP %d): %s", resp.StatusCode, string(rb))
+	}
+	return m.storeTokenResponse(rb)
+}
+
+func (m *masAuth) storeTokenResponse(rb []byte) error {
+	var tr struct {
+		AccessToken  string `json:"access_token"`
+		RefreshToken string `json:"refresh_token"`
+		ExpiresIn    int    `json:"expires_in"`
+	}
+	if err := json.Unmarshal(rb, &tr); err != nil {
+		return fmt.Errorf("parse token response: %w", err)
+	}
+	if tr.AccessToken == "" {
+		return fmt.Errorf("token response missing access_token: %s", string(rb))
+	}
+	m.mu.Lock()
+	m.accessToken = tr.AccessToken
+	if tr.RefreshToken != "" {
+		m.refreshToken = tr.RefreshToken
+	}
+	ttl := tr.ExpiresIn
+	if ttl <= 0 {
+		ttl = 300
+	}
+	m.expiresAt = time.Now().Add(time.Duration(ttl) * time.Second)
+	m.mu.Unlock()
+	m.save()
+	return nil
+}
+
+func (m *masAuth) expiry() time.Time {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.expiresAt
+}
+
+// getJSON GETs a URL and decodes JSON.
+func (m *masAuth) getJSON(u string, out any) error {
+	resp, err := m.http.Get(u)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		b, _ := io.ReadAll(io.LimitReader(resp.Body, 512))
+		return fmt.Errorf("GET %s: HTTP %d: %s", u, resp.StatusCode, string(b))
+	}
+	return json.NewDecoder(resp.Body).Decode(out)
+}
+
+// postForm POSTs a form and decodes a JSON success body (200).
+func (m *masAuth) postForm(u string, form url.Values, out any) error {
+	resp, err := m.http.PostForm(u, form)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	rb, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("POST %s: HTTP %d: %s", u, resp.StatusCode, string(rb))
+	}
+	return json.Unmarshal(rb, out)
+}
+
+// randomDeviceID mirrors mautrix's device-id style: 10 uppercase letters.
+func randomDeviceID() string {
+	const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	b := make([]byte, 10)
+	if _, err := rand.Read(b); err != nil {
+		// rand.Read essentially never fails; fall back to a fixed prefix.
+		return "GOGOBEEBOT"
+	}
+	for i := range b {
+		b[i] = alphabet[int(b[i])%len(alphabet)]
+	}
+	return "GB" + string(b[:8])
+}

internal/bot/session.go

@@ -0,0 +1,140 @@
+package bot
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"sync"
+	"time"
+
+	"maunium.net/go/mautrix"
+	"maunium.net/go/mautrix/appservice"
+	"maunium.net/go/mautrix/event"
+)
+
+// Session is the bot's live Matrix connection plus its event source. It hides
+// the difference between the two transports the bot can run under:
+//
+//   - masdevice: a normal Matrix user authenticated via the MAS OAuth device
+//     grant, receiving events over /sync (mautrix DefaultSyncer).
+//   - appservice: a Synapse appservice authenticated by its as_token, receiving
+//     events pushed over the appservice transaction API (mautrix EventProcessor).
+//
+// Callers register the same three handlers (message/member/reaction) via
+// OnEventType and call Run regardless of mode; the plugin layer never knows which
+// transport is in use.
+type Session struct {
+	Client *mautrix.Client
+	mode   string
+
+	// masdevice
+	syncer *mautrix.DefaultSyncer
+
+	// appservice
+	as           *appservice.AppService
+	ep           *appservice.EventProcessor
+	presenceOnce sync.Once
+}
+
+// EventHandler matches both DefaultSyncer.OnEventType and EventProcessor.On.
+type EventHandler = func(ctx context.Context, evt *event.Event)
+
+// NewSession builds a Session for the configured auth mode. Default and
+// "masdevice" use the MAS device grant; "appservice" uses the transaction model.
+func NewSession(cfg Config) (*Session, error) {
+	switch cfg.AuthMode {
+	case "appservice":
+		return newAppserviceSession(cfg)
+	case "", "masdevice":
+		return newMASDeviceSession(cfg)
+	default:
+		return nil, fmt.Errorf("unknown AUTH_MODE %q (want appservice or masdevice)", cfg.AuthMode)
+	}
+}
+
+// newMASDeviceSession wraps the existing device-grant client (NewClient) and its
+// DefaultSyncer. This is the retained rollback path — unchanged behaviour.
+func newMASDeviceSession(cfg Config) (*Session, error) {
+	client, err := NewClient(cfg)
+	if err != nil {
+		return nil, err
+	}
+	return &Session{
+		Client: client,
+		mode:   "masdevice",
+		syncer: client.Syncer.(*mautrix.DefaultSyncer),
+	}, nil
+}
+
+// OnEventType registers a handler for the given event type against whichever
+// event source backs this session.
+func (s *Session) OnEventType(evtType event.Type, fn EventHandler) {
+	switch s.mode {
+	case "appservice":
+		s.ep.On(evtType, fn)
+	default:
+		s.syncer.OnEventType(evtType, fn)
+	}
+}
+
+// StartPresence begins actively maintaining the bot's Matrix presence, tied to
+// ctx. In appservice mode it launches the online heartbeat (runPresenceHeartbeat);
+// masdevice mode relies on the /sync long-poll's implicit presence refresh, so it
+// is a no-op there. Call this early — before the slow plugin init — so the bot
+// shows online from boot rather than only once the transaction listener starts
+// (~2min later). The presence PUT is outbound-only and needs no event handlers, so
+// starting it ahead of the listener is safe. Idempotent: extra calls do nothing.
+func (s *Session) StartPresence(ctx context.Context) {
+	if s.mode != "appservice" {
+		return
+	}
+	s.presenceOnce.Do(func() {
+		go s.runPresenceHeartbeat(ctx)
+	})
+}
+
+// Run blocks, delivering events to registered handlers, until ctx is cancelled.
+func (s *Session) Run(ctx context.Context) error {
+	switch s.mode {
+	case "appservice":
+		return s.runAppservice(ctx)
+	default:
+		return s.runSync(ctx)
+	}
+}
+
+// Stop halts the event source. Safe to call once.
+func (s *Session) Stop() {
+	switch s.mode {
+	case "appservice":
+		if s.ep != nil {
+			s.ep.Stop()
+		}
+		if s.as != nil {
+			s.as.Stop()
+		}
+	default:
+		s.Client.StopSync()
+	}
+}
+
+// runSync is the device-grant /sync loop (moved verbatim from main.go): restart
+// on transient failure, exit on context cancel.
+func (s *Session) runSync(ctx context.Context) error {
+	for {
+		err := s.Client.SyncWithContext(ctx)
+		if ctx.Err() != nil {
+			return nil // shutdown requested
+		}
+		if err != nil {
+			slog.Error("sync stopped, restarting in 5s", "err", err)
+		} else {
+			slog.Warn("sync returned without error, restarting in 5s")
+		}
+		select {
+		case <-time.After(5 * time.Second):
+		case <-ctx.Done():
+			return nil
+		}
+	}
+}

internal/db/db.go

@@ -333,6 +333,66 @@ func runMigrations(d *sql.DB) error {
 		// engages when a fork / elite / boss / supply pinch actually
 		// needs a decision. CAS-claim on this column gates re-entry.
 		`ALTER TABLE dnd_expedition ADD COLUMN last_autorun_at DATETIME`,
+		// URL link previews now post the page's og:image/twitter:image
+		// thumbnail; cache it alongside the title/description.
+		`ALTER TABLE url_cache ADD COLUMN image_url TEXT NOT NULL DEFAULT ''`,
+		// Tempering (gogobee_engagement_plan.md B1). A magic item's rarity
+		// lives on its registry definition, so an upgraded instance needs
+		// somewhere of its own to record how far it has been pushed. temper
+		// counts rarity steps above the definition's base; effective rarity
+		// is derived at the effect/render/sell boundary, never written back.
+		// DEFAULT 0 is the correct value for every pre-existing row, so this
+		// needs no bootstrap backfill.
+		`ALTER TABLE adventure_inventory ADD COLUMN temper INTEGER NOT NULL DEFAULT 0`,
+		`ALTER TABLE magic_item_equipped ADD COLUMN temper INTEGER NOT NULL DEFAULT 0`,
+		// Revisit R1 (gogobee_revisit_plan.md §R1). Until now "how far along
+		// is this run" and "which room am I standing in" were the same number,
+		// both read off len(visited_nodes). Backtracking splits them: the
+		// path index stops being monotonic, so effort gets its own counter.
+		// DEFAULT 0 is wrong for in-flight rows — bootstrapRoomsTraversed
+		// backfills them from visited_nodes.
+		`ALTER TABLE dnd_zone_run ADD COLUMN rooms_traversed INTEGER NOT NULL DEFAULT 0`,
+		// N3/P4 party combat. Every pre-existing fight is solo, and solo is
+		// exactly roster_size 1, so the DEFAULT is the correct value for every
+		// row and no bootstrap backfill is needed. The column is a read guard:
+		// loadCombatParticipants is skipped entirely when it reads 1.
+		`ALTER TABLE combat_session ADD COLUMN roster_size INTEGER NOT NULL DEFAULT 1`,
+		// N4/E1 housing vault (gogobee_engagement_plan.md §E1). A Tier-4 Estate
+		// unlocks a 10-slot vault that shelters items from sale/use. Rather than a
+		// parallel table, a stowed item keeps its identity (id, temper, everything)
+		// and flips in_vault=1; loadAdvInventory filters it back out, so a vaulted
+		// item drops out of sell/craft/combat readers as one flag change. DEFAULT 0
+		// = "in play", correct for every pre-existing row, so no bootstrap backfill.
+		`ALTER TABLE adventure_inventory ADD COLUMN in_vault INTEGER NOT NULL DEFAULT 0`,
+		// N4/E1 second pet slot (gogobee_engagement_plan.md §E1). A Tier-4 Estate
+		// unlocks a second companion. It lives in a parallel pet2_* column set
+		// rather than a rows table so the single-pet path (and its combat golden)
+		// is untouched: absent pet2_type == "no second pet", DEFAULT '' is correct
+		// for every pre-existing row, so no bootstrap backfill. Pet 2 carries only
+		// what it needs — identity, level, barding — and deliberately skips the
+		// supply-shop unlock (a pet-1 mechanic) and morning-defense flag.
+		`ALTER TABLE player_meta ADD COLUMN pet2_type TEXT NOT NULL DEFAULT ''`,
+		`ALTER TABLE player_meta ADD COLUMN pet2_name TEXT NOT NULL DEFAULT ''`,
+		`ALTER TABLE player_meta ADD COLUMN pet2_xp INTEGER NOT NULL DEFAULT 0`,
+		`ALTER TABLE player_meta ADD COLUMN pet2_level INTEGER NOT NULL DEFAULT 0`,
+		`ALTER TABLE player_meta ADD COLUMN pet2_armor_tier INTEGER NOT NULL DEFAULT 0`,
+		`ALTER TABLE player_meta ADD COLUMN pet2_flags_json TEXT NOT NULL DEFAULT '{}'`,
+		`ALTER TABLE player_meta ADD COLUMN pet2_level_10_date TEXT NOT NULL DEFAULT ''`,
+		// N5/D1 the Hollow King campaign (gogobee_engagement_plan.md §D1). Found
+		// journal pages are a bitmask (bit i == page i+1 discovered), granted one at
+		// a time from elite kills and secret rooms. A single INTEGER rather than a
+		// rows table: pages are static content, only found/not-found is per-player,
+		// and grants are an atomic bitwise-OR so a page can't be lost to a stale
+		// character save. DEFAULT 0 == "no pages found", correct for every
+		// pre-existing row, so no bootstrap backfill.
+		`ALTER TABLE player_meta ADD COLUMN journal_pages INTEGER NOT NULL DEFAULT 0`,
+		// N5/D1c the Hollow King finale (gogobee_engagement_plan.md §D1). Set once,
+		// the first time a player closes the account — the reward (unique title +
+		// one Legendary) drops only on that first clear; later rematches are
+		// flavour-only. Written by a dedicated atomic UPDATE, never the bulk
+		// character save, so a monotonic false→true flag can't be clobbered.
+		// DEFAULT 0 correct for every pre-existing row, so no bootstrap.
+		`ALTER TABLE player_meta ADD COLUMN epilogue_cleared INTEGER NOT NULL DEFAULT 0`,
 	}
 	for _, stmt := range columnMigrations {
 		if _, err := d.Exec(stmt); err != nil {
@@ -1124,6 +1184,7 @@ CREATE TABLE IF NOT EXISTS url_cache (
 	url TEXT PRIMARY KEY,
 	title TEXT DEFAULT '',
 	description TEXT DEFAULT '',
+	image_url TEXT NOT NULL DEFAULT '',
 	cached_at INTEGER DEFAULT (unixepoch())
 );
 
@@ -1351,6 +1412,21 @@ CREATE TABLE IF NOT EXISTS adventure_activity_log (
 );
 CREATE INDEX IF NOT EXISTS idx_adv_log_user ON adventure_activity_log(user_id, logged_at);
 
+-- N4/E2 item gifting. One row per gift; the sender's row count for the current
+-- UTC day enforces the daily cap (twink-funnel guard), and the full log is an
+-- audit trail. gift_day is the UTC date string the cap counts against, kept
+-- alongside given_at so the count is a plain equality match, not a range scan.
+CREATE TABLE IF NOT EXISTS adventure_gift_log (
+	id         INTEGER PRIMARY KEY AUTOINCREMENT,
+	sender     TEXT NOT NULL,
+	recipient  TEXT NOT NULL,
+	item_name  TEXT NOT NULL,
+	value      INTEGER NOT NULL DEFAULT 0,
+	gift_day   TEXT NOT NULL,
+	given_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE INDEX IF NOT EXISTS idx_adv_gift_sender_day ON adventure_gift_log(sender, gift_day);
+
 CREATE TABLE IF NOT EXISTS adventure_treasures (
 	id           INTEGER PRIMARY KEY AUTOINCREMENT,
 	user_id      TEXT NOT NULL,
@@ -1496,6 +1572,21 @@ CREATE TABLE IF NOT EXISTS arena_stats (
 	updated_at          INTEGER NOT NULL
 );
 
+-- Arena seasons (gogobee_engagement_plan.md C4). Season standings are DERIVED
+-- from arena_history.created_at, so arena_stats stays lifetime and no
+-- quarterly wipe ever runs. Only the awarded titles are archived here, one row
+-- per (season, kind) — the champion for that quarter, frozen.
+CREATE TABLE IF NOT EXISTS arena_season_titles (
+	season     TEXT NOT NULL,
+	kind       TEXT NOT NULL,          -- 'earnings' | 'streak'
+	user_id    TEXT NOT NULL,
+	value      INTEGER NOT NULL,
+	awarded_at INTEGER NOT NULL,
+	PRIMARY KEY (season, kind)
+);
+CREATE INDEX IF NOT EXISTS idx_arena_season_titles_user ON arena_season_titles(user_id);
+CREATE INDEX IF NOT EXISTS idx_arena_history_created ON arena_history(created_at);
+
 -- Rival System
 CREATE TABLE IF NOT EXISTS adventure_rival_records (
 	user_id      TEXT NOT NULL,
@@ -1519,6 +1610,20 @@ CREATE TABLE IF NOT EXISTS adventure_rival_challenges (
 );
 CREATE INDEX IF NOT EXISTS idx_rival_challenges_user ON adventure_rival_challenges(challenged_id, expires_at);
 
+-- Duels (N6/C2): player-initiated, staked, no-death combat bouts. Both stakes
+-- are escrowed while the row lives; expiry/decline refunds the challenger. W/L
+-- history reuses adventure_rival_records. No bootstrap — absent row == no duel.
+CREATE TABLE IF NOT EXISTS adventure_duel_challenges (
+	challenge_id  TEXT PRIMARY KEY,
+	challenger_id TEXT NOT NULL,
+	challenged_id TEXT NOT NULL,
+	stake         INTEGER NOT NULL,
+	expires_at    DATETIME NOT NULL,
+	created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE INDEX IF NOT EXISTS idx_duel_challenges_user ON adventure_duel_challenges(challenged_id, expires_at);
+CREATE INDEX IF NOT EXISTS idx_duel_challenges_expiry ON adventure_duel_challenges(expires_at);
+
 CREATE TABLE IF NOT EXISTS community_pot (
 	id         INTEGER PRIMARY KEY DEFAULT 1,
 	balance    INTEGER NOT NULL DEFAULT 0,
@@ -1997,6 +2102,24 @@ CREATE TABLE IF NOT EXISTS space_inviter_prompts (
 );
 CREATE INDEX IF NOT EXISTS idx_space_inviter_user ON space_inviter_prompts(user_id);
 
+-- ── Email nag — collect+verify missing Authentik emails over Matrix DM ─────
+-- One row per target user (MXID). Verified state survives restarts so the
+-- startup sweep never re-nags someone already done or mid-flow.
+CREATE TABLE IF NOT EXISTS email_nag_prompts (
+    user_id        TEXT PRIMARY KEY,   -- full MXID
+    username       TEXT NOT NULL,      -- Authentik username == Matrix localpart
+    dm_room_id     TEXT NOT NULL,
+    stage          TEXT NOT NULL,      -- awaiting_email | awaiting_code | done
+    pending_email  TEXT,
+    code           TEXT,
+    code_expires   INTEGER,
+    attempts       INTEGER NOT NULL DEFAULT 0,
+    prompt_sent_at INTEGER NOT NULL,
+    verified_email TEXT,
+    verified_at    INTEGER,
+    updated_at     INTEGER NOT NULL
+);
+
 -- ── Turn-based combat — persistent per-fight session ───────────────────────
 -- One row per manual elite/boss fight. Persists across bot restarts and
 -- player away-from-keyboard so a fight can resume (or be auto-finished by
@@ -2027,12 +2150,152 @@ CREATE TABLE IF NOT EXISTS combat_session (
     status          TEXT NOT NULL DEFAULT 'active',      -- active|won|lost|fled|expired
     started_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     last_action_at  DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    expires_at      DATETIME NOT NULL
+    expires_at      DATETIME NOT NULL,
+    -- N3/P4: seated player characters, seat 0 (this row) included. 1 == solo,
+    -- which is what every pre-N3 row is, so the DEFAULT needs no backfill. Read
+    -- as a guard: only a roster_size > 1 makes the loader touch
+    -- combat_participant, keeping the solo fight at one query.
+    roster_size     INTEGER NOT NULL DEFAULT 1
 );
 CREATE INDEX IF NOT EXISTS idx_combat_session_active
     ON combat_session(user_id, status);
 CREATE INDEX IF NOT EXISTS idx_combat_session_expiry
     ON combat_session(status, expires_at);
+
+-- ── N3/P4 — party combat: the seats a session row cannot hold ─────────────
+-- One row per party member from seat 1 up. Seat 0 is the session's own
+-- user_id/player_hp/statuses_json, so a solo fight writes no rows here and
+-- reads none: absent == solo, which is why this table needs no backfill.
+--
+-- seat:           index into the combat roster. 1..N-1; seat 0 is the session.
+-- hp / hp_max:    this member's live pool. Seat 0's lives on combat_session.
+-- statuses_json:  serialized ActorStatuses — the per-character half of the
+--                 effect state (their concentration, their debuffs, their
+--                 once-per-fight one-shots). The enemy's stance and the round
+--                 cursor are fight-scoped and stay on combat_session.
+CREATE TABLE IF NOT EXISTS combat_participant (
+    session_id      TEXT NOT NULL,
+    seat            INTEGER NOT NULL,
+    user_id         TEXT NOT NULL,
+    hp              INTEGER NOT NULL,
+    hp_max          INTEGER NOT NULL,
+    statuses_json   TEXT NOT NULL DEFAULT '{}',
+    PRIMARY KEY (session_id, seat)
+);
+CREATE INDEX IF NOT EXISTS idx_combat_participant_user
+    ON combat_participant(user_id);
+
+-- ── N3/P4 — expedition parties ────────────────────────────────────────────
+-- Membership for a co-op expedition. The leader's dnd_expedition row stays
+-- the single source of truth for the shared clock, threat, and supply pool;
+-- members reference it through here rather than owning a row of their own.
+-- A solo expedition has no rows: absent == solo, so no backfill is needed.
+--
+-- There is deliberately no party_id on dnd_expedition. The expedition_id is
+-- already the party's identity, and a second key would be a second source of
+-- truth for "who is in this party" that could disagree with this table.
+--
+-- role: 'leader' | 'member'. Exactly one leader per expedition, matching
+--       dnd_expedition.user_id; enforced in code, not by constraint (the
+--       same discipline combat_session uses for one-active-per-user).
+CREATE TABLE IF NOT EXISTS expedition_party (
+    expedition_id   TEXT NOT NULL,
+    user_id         TEXT NOT NULL,
+    role            TEXT NOT NULL DEFAULT 'member',
+    joined_at       DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (expedition_id, user_id)
+);
+CREATE INDEX IF NOT EXISTS idx_expedition_party_user
+    ON expedition_party(user_id);
+
+-- ── N3/P6b — pending party invites ────────────────────────────────────────
+-- An invite the leader has sent and the invitee has not yet answered. It is
+-- deleted on accept, on decline, and when the expedition ends; it expires on
+-- read past expeditionInviteTTL, so a forgotten invite cannot pin an
+-- expedition's autopilot forever.
+--
+-- Absent == nobody has been asked, which is true of every expedition that
+-- existed before N3, so there is nothing to backfill.
+--
+-- While any row here names an expedition, the autopilot will not walk it: the
+-- leader must not be dragged into a boss room while their friend is still
+-- reading the invite DM.
+CREATE TABLE IF NOT EXISTS expedition_invite (
+    expedition_id   TEXT NOT NULL,
+    user_id         TEXT NOT NULL,
+    invited_by      TEXT NOT NULL,
+    invited_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (expedition_id, user_id)
+);
+CREATE INDEX IF NOT EXISTS idx_expedition_invite_user
+    ON expedition_invite(user_id);
+
+-- ── N6/D3 — the Shadow: a simulated rival adventurer ──────────────────────
+-- One row per player, born lazily the first midnight after their character
+-- exists. The Shadow "runs" the same zone progression on a simulated schedule
+-- (~1.3x the player's own clear pace), advanced once per UTC day by the
+-- midnight ticker. Pure theatre: no combat, no punishment — only race
+-- pressure surfaced in the morning briefing and a payoff at each zone clear.
+--
+-- Absent == the player has no Shadow yet, which is true of every row that
+-- existed before N6, so there is nothing to backfill. The ticker mints the
+-- row on first advance. This table is deliberately NOT part of the
+-- player_meta save fan-out: the ticker owns it, so a character save can never
+-- clobber the Shadow's advance (the same isolation journal_pages earns by
+-- being grant-only, made structural here).
+--
+-- name:          the rival's proper name, seeded deterministically from the
+--                player's display name at birth.
+-- progress:      cumulative zone-units the Shadow has run (fractional, so a
+--                slow player still sees it creep between clears).
+-- zones_cleared: floor(progress) at the last advance — the committed count,
+--                stored so the next advance can tell which zones were newly
+--                finished.
+-- pending_mask:  zones (by progression index bit) the Shadow cleared before
+--                the player did — a journal page waits in each until the
+--                player clears that zone's boss.
+-- crowed_mask:   zones the player beat the Shadow to and has already been
+--                crowed a bonus for — set-once, so re-running a zone the
+--                Shadow hasn't reached can't farm the crow XP.
+-- day_counter:   the Shadow's own day count, for flavour variety.
+-- last_advanced: UTC date of the last advance; the per-day idempotency guard.
+CREATE TABLE IF NOT EXISTS adventure_shadow (
+    user_id       TEXT PRIMARY KEY,
+    name          TEXT NOT NULL,
+    progress      REAL NOT NULL DEFAULT 0,
+    zones_cleared INTEGER NOT NULL DEFAULT 0,
+    pending_mask  INTEGER NOT NULL DEFAULT 0,
+    crowed_mask   INTEGER NOT NULL DEFAULT 0,
+    day_counter   INTEGER NOT NULL DEFAULT 0,
+    last_advanced TEXT NOT NULL DEFAULT '',
+    born_at       DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- World boss (N6/C3) — the monthly communal "Siege". One event at a time is
+-- live (status='active'); the ticker resolves it at hp_current<=0 (defeated) or
+-- after ends_at (survived). History rows are retained (autoincrement id), so
+-- world_boss_contrib keys on boss_id. Deliberately its own tables, outside the
+-- player_meta save fan-out, so a character save can't clobber the shared pool.
+CREATE TABLE IF NOT EXISTS world_boss (
+    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+    name       TEXT    NOT NULL,
+    tier       INTEGER NOT NULL DEFAULT 5,
+    hp_max     INTEGER NOT NULL,
+    hp_current INTEGER NOT NULL,
+    status     TEXT    NOT NULL DEFAULT 'active',
+    starts_at  DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    ends_at    DATETIME NOT NULL,
+    resolved_at DATETIME
+);
+
+CREATE TABLE IF NOT EXISTS world_boss_contrib (
+    boss_id         INTEGER NOT NULL,
+    user_id         TEXT    NOT NULL,
+    fights          INTEGER NOT NULL DEFAULT 0,
+    damage          INTEGER NOT NULL DEFAULT 0,
+    last_fight_date TEXT    NOT NULL DEFAULT '',
+    PRIMARY KEY (boss_id, user_id)
+);
 `
 
 // SeedSchedulerDefaults inserts default scheduler jobs if they don't exist.
@@ -2041,15 +2304,15 @@ func SeedSchedulerDefaults(d *sql.DB) error {
 		name string
 		cron string
 	}{
-		{"prefetch", "5 0 * * *"},       // 00:05 daily
-		{"maintenance", "0 3 * * *"},    // 03:00 daily
-		{"wotd", "0 8 * * *"},           // 08:00 daily
-		{"holidays", "0 7 * * *"},       // 07:00 daily
-		{"releases", "0 9 * * 1"},       // 09:00 Monday
-		{"birthday_check", "0 6 * * *"}, // 06:00 daily
-		{"anime_releases", "0 10 * * *"},// 10:00 daily
-		{"movie_releases", "0 11 * * *"},// 11:00 daily
-		{"concert_digest", "0 12 * * 0"},// 12:00 Sunday
+		{"prefetch", "5 0 * * *"},        // 00:05 daily
+		{"maintenance", "0 3 * * *"},     // 03:00 daily
+		{"wotd", "0 8 * * *"},            // 08:00 daily
+		{"holidays", "0 7 * * *"},        // 07:00 daily
+		{"releases", "0 9 * * 1"},        // 09:00 Monday
+		{"birthday_check", "0 6 * * *"},  // 06:00 daily
+		{"anime_releases", "0 10 * * *"}, // 10:00 daily
+		{"movie_releases", "0 11 * * *"}, // 11:00 daily
+		{"concert_digest", "0 12 * * 0"}, // 12:00 Sunday
 	}
 
 	stmt, err := d.Prepare(`INSERT OR IGNORE INTO scheduler_config (job_name, cron_expr) VALUES (?, ?)`)

internal/plugin/achievements.go

@@ -2,6 +2,7 @@ package plugin
 
 import (
 	"database/sql"
+	"encoding/json"
 	"fmt"
 	"log/slog"
 	"strings"
@@ -1137,9 +1138,160 @@ func (p *AchievementsPlugin) buildAchievements() []achievementDef {
 				return false
 			},
 		},
+
+		// ── Expeditions ──
+		// All passive: they read the expedition rows the extract path already
+		// writes. Tier comes from the zone registry, not a column, so the
+		// checks map zone_id → Tier in Go.
+		{
+			ID: "expedition_clear_t1", Name: "Off the Porch", Description: "Cleared your first Tier 1 zone. It only gets worse from here.",
+			Emoji: "🗺️",
+			Check: func(d *sql.DB, u id.UserID) bool { return clearedAnyZoneOfTier(d, u, 1) },
+		},
+		{
+			ID: "expedition_clear_t2", Name: "Reasonably Lost", Description: "Cleared a Tier 2 zone. The map stops being a suggestion.",
+			Emoji: "🗺️",
+			Check: func(d *sql.DB, u id.UserID) bool { return clearedAnyZoneOfTier(d, u, 2) },
+		},
+		{
+			ID: "expedition_clear_t3", Name: "Deep Enough", Description: "Cleared a Tier 3 zone. Someone should have stopped you.",
+			Emoji: "🗺️",
+			Check: func(d *sql.DB, u id.UserID) bool { return clearedAnyZoneOfTier(d, u, 3) },
+		},
+		{
+			ID: "expedition_clear_t4", Name: "Past the Warnings", Description: "Cleared a Tier 4 zone. The signs were quite clear.",
+			Emoji: "🗺️",
+			Check: func(d *sql.DB, u id.UserID) bool { return clearedAnyZoneOfTier(d, u, 4) },
+		},
+		{
+			ID: "expedition_clear_t5", Name: "Where the Map Ends", Description: "Cleared a Tier 5 zone. There was nothing left to be brave about.",
+			Emoji: "🗺️",
+			Check: func(d *sql.DB, u id.UserID) bool { return clearedAnyZoneOfTier(d, u, 5) },
+		},
+		{
+			ID: "expedition_master_t1", Name: "Warren Cartography", Description: "Cleared every Tier 1 zone. Thorough.",
+			Emoji: "🧭",
+			Check: func(d *sql.DB, u id.UserID) bool { return clearedEveryZoneOfTier(d, u, 1) },
+		},
+		{
+			ID: "expedition_master_t2", Name: "No Stone Unturned", Description: "Cleared every Tier 2 zone.",
+			Emoji: "🧭",
+			Check: func(d *sql.DB, u id.UserID) bool { return clearedEveryZoneOfTier(d, u, 2) },
+		},
+		{
+			ID: "expedition_master_t3", Name: "Completionist's Limp", Description: "Cleared every Tier 3 zone. Walk it off.",
+			Emoji: "🧭",
+			Check: func(d *sql.DB, u id.UserID) bool { return clearedEveryZoneOfTier(d, u, 3) },
+		},
+		{
+			ID: "expedition_master_t4", Name: "Nowhere Left to Go Wrong", Description: "Cleared every Tier 4 zone.",
+			Emoji: "🧭",
+			Check: func(d *sql.DB, u id.UserID) bool { return clearedEveryZoneOfTier(d, u, 4) },
+		},
+		{
+			ID: "expedition_master_t5", Name: "The Long Way Down", Description: "Cleared every Tier 5 zone. Both of them. All the way.",
+			Emoji: "🧭",
+			Check: func(d *sql.DB, u id.UserID) bool { return clearedEveryZoneOfTier(d, u, 5) },
+		},
+		{
+			ID: "expedition_quiet_clear", Name: "Nobody Saw Anything", Description: "Cleared a zone without threat ever passing 50. You were never here.",
+			Emoji: "🌑",
+			Check: clearedUnderThreat50,
+		},
+		{
+			ID: "temper_legendary", Name: "Hot Enough", Description: "Tempered an item all the way to Legendary. The blacksmith needed a moment.",
+			Emoji: "🔨",
+			Check: func(d *sql.DB, u id.UserID) bool {
+				// Granted by the temper path on reaching Legendary
+				return false
+			},
+		},
 	}
 }
 
+// ── Expedition achievement helpers ──────────────────────────────────────────
+
+// clearedZoneIDs returns the zones this player has beaten outright. Boss-
+// defeated gates out extractions that merely ended in 'complete'.
+func clearedZoneIDs(d *sql.DB, userID id.UserID) map[ZoneID]bool {
+	out := map[ZoneID]bool{}
+	rows, err := d.Query(
+		`SELECT DISTINCT zone_id FROM dnd_expedition
+		 WHERE user_id = ? AND status = ? AND boss_defeated = 1`,
+		string(userID), ExpeditionStatusComplete)
+	if err != nil {
+		return out
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var z string
+		if err := rows.Scan(&z); err != nil {
+			return out
+		}
+		out[ZoneID(z)] = true
+	}
+	return out
+}
+
+func clearedAnyZoneOfTier(d *sql.DB, userID id.UserID, tier ZoneTier) bool {
+	cleared := clearedZoneIDs(d, userID)
+	for zid := range cleared {
+		if z, ok := getZone(zid); ok && z.Tier == tier {
+			return true
+		}
+	}
+	return false
+}
+
+func clearedEveryZoneOfTier(d *sql.DB, userID id.UserID, tier ZoneTier) bool {
+	cleared := clearedZoneIDs(d, userID)
+	seen := 0
+	for _, z := range allZones() {
+		if z.Tier != tier {
+			continue
+		}
+		if !cleared[z.ID] {
+			return false
+		}
+		seen++
+	}
+	return seen > 0
+}
+
+// clearedUnderThreat50 looks for a cleared expedition whose peak threat never
+// crossed 50 — the same max_threat_seen sample the Patient Zero milestone
+// reads, so the two reward the same play.
+//
+// The key's *presence* is required, not just a low value. recordMaxThreat only
+// samples on day rollover and never stores a zero, so an absent key means the
+// expedition has no threat history at all (a same-day clear) — which is not
+// evidence that threat stayed low.
+func clearedUnderThreat50(d *sql.DB, userID id.UserID) bool {
+	rows, err := d.Query(
+		`SELECT region_state FROM dnd_expedition
+		 WHERE user_id = ? AND status = ? AND boss_defeated = 1`,
+		string(userID), ExpeditionStatusComplete)
+	if err != nil {
+		return false
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var raw string
+		if err := rows.Scan(&raw); err != nil {
+			return false
+		}
+		var state map[string]any
+		if json.Unmarshal([]byte(raw), &state) != nil {
+			continue
+		}
+		peak, ok := state[regionStateMaxThreatKey].(float64)
+		if ok && int(peak) < 50 {
+			return true
+		}
+	}
+	return false
+}
+
 // statGTE checks if a user_stats column is >= threshold.
 var allowedStatColumns = map[string]bool{
 	"total_messages":     true,

internal/plugin/achievements_expedition_test.go

@@ -0,0 +1,184 @@
+package plugin
+
+import (
+	"fmt"
+	"testing"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// expeditionRowSeq gives each synthetic row a unique primary key; two rows can
+// otherwise differ only in boss_defeated.
+var expeditionRowSeq int
+
+// insertClearedExpedition writes an expedition row directly. status and
+// boss_defeated are the two gates the achievement checks read.
+func insertClearedExpedition(t *testing.T, user id.UserID, zoneID ZoneID, status string, bossDefeated int, regionState string) {
+	t.Helper()
+	expeditionRowSeq++
+	_, err := db.Get().Exec(
+		`INSERT INTO dnd_expedition (expedition_id, user_id, zone_id, status, boss_defeated, region_state)
+		 VALUES (?, ?, ?, ?, ?, ?)`,
+		fmt.Sprintf("exp-%d", expeditionRowSeq), string(user), string(zoneID), status, bossDefeated, regionState)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+// zonesOfTier lists the zone ids at a tier, straight from the registry, so the
+// test tracks content edits instead of hardcoding a zone roster.
+func zonesOfTier(tier ZoneTier) []ZoneID {
+	var out []ZoneID
+	for _, z := range allZones() {
+		if z.Tier == tier {
+			out = append(out, z.ID)
+		}
+	}
+	return out
+}
+
+func newAchievementTestDB(t *testing.T) {
+	t.Helper()
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+}
+
+func TestExpeditionClearAchievements(t *testing.T) {
+	newAchievementTestDB(t)
+	d := db.Get()
+	user := id.UserID("@clears:test.invalid")
+
+	t1 := zonesOfTier(1)
+	if len(t1) < 2 {
+		t.Skipf("tier 1 has %d zones; test wants at least 2", len(t1))
+	}
+
+	if clearedAnyZoneOfTier(d, user, 1) {
+		t.Error("clean slate reported a tier-1 clear")
+	}
+
+	// A boss-defeated complete run is the only thing that counts.
+	insertClearedExpedition(t, user, t1[0], ExpeditionStatusComplete, 1, "{}")
+	if !clearedAnyZoneOfTier(d, user, 1) {
+		t.Error("cleared tier-1 zone not detected")
+	}
+	if clearedEveryZoneOfTier(d, user, 1) {
+		t.Error("one of several tier-1 zones counted as all of them")
+	}
+	if clearedAnyZoneOfTier(d, user, 2) {
+		t.Error("a tier-1 clear leaked into tier 2")
+	}
+
+	for _, z := range t1[1:] {
+		insertClearedExpedition(t, user, z, ExpeditionStatusComplete, 1, "{}")
+	}
+	if !clearedEveryZoneOfTier(d, user, 1) {
+		t.Error("clearing every tier-1 zone did not satisfy the master check")
+	}
+}
+
+// TestExpeditionClearIgnoresUnfinishedRuns: an abandoned run, or one where the
+// player walked out without killing the boss, must not count as a clear.
+func TestExpeditionClearIgnoresUnfinishedRuns(t *testing.T) {
+	newAchievementTestDB(t)
+	d := db.Get()
+	user := id.UserID("@partial:test.invalid")
+
+	t2 := zonesOfTier(2)
+	if len(t2) == 0 {
+		t.Skip("no tier-2 zones")
+	}
+
+	insertClearedExpedition(t, user, t2[0], ExpeditionStatusAbandoned, 1, "{}")
+	if clearedAnyZoneOfTier(d, user, 2) {
+		t.Error("an abandoned expedition counted as a clear")
+	}
+
+	insertClearedExpedition(t, user, t2[0], ExpeditionStatusComplete, 0, "{}")
+	if clearedAnyZoneOfTier(d, user, 2) {
+		t.Error("a complete run with the boss alive counted as a clear")
+	}
+
+	insertClearedExpedition(t, user, t2[0], ExpeditionStatusComplete, 1, "{}")
+	if !clearedAnyZoneOfTier(d, user, 2) {
+		t.Error("a real clear was not detected")
+	}
+}
+
+// TestClearedUnderThreat50 pins the presence-vs-zero distinction. recordMaxThreat
+// samples only on day rollover and never writes a zero, so an empty region_state
+// means "no threat history", not "threat stayed at zero".
+func TestClearedUnderThreat50(t *testing.T) {
+	newAchievementTestDB(t)
+	d := db.Get()
+
+	zones := zonesOfTier(1)
+	if len(zones) == 0 {
+		t.Skip("no tier-1 zones")
+	}
+	z := zones[0]
+
+	quiet := id.UserID("@quiet:test.invalid")
+	loud := id.UserID("@loud:test.invalid")
+	sameDay := id.UserID("@sameday:test.invalid")
+
+	insertClearedExpedition(t, quiet, z, ExpeditionStatusComplete, 1, `{"max_threat_seen":30}`)
+	if !clearedUnderThreat50(d, quiet) {
+		t.Error("peak threat 30 did not satisfy the under-50 check")
+	}
+
+	insertClearedExpedition(t, loud, z, ExpeditionStatusComplete, 1, `{"max_threat_seen":60}`)
+	if clearedUnderThreat50(d, loud) {
+		t.Error("peak threat 60 satisfied the under-50 check")
+	}
+
+	insertClearedExpedition(t, sameDay, z, ExpeditionStatusComplete, 1, "{}")
+	if clearedUnderThreat50(d, sameDay) {
+		t.Error("an expedition with no threat samples was awarded the quiet clear")
+	}
+
+	// Exactly 50 is not under 50.
+	edge := id.UserID("@edge:test.invalid")
+	insertClearedExpedition(t, edge, z, ExpeditionStatusComplete, 1, `{"max_threat_seen":50}`)
+	if clearedUnderThreat50(d, edge) {
+		t.Error("peak threat of exactly 50 counted as under 50")
+	}
+}
+
+// TestExpeditionAchievementIDsRegistered guards the wiring: every expedition
+// achievement referenced by the tier helpers must exist in the registry, and a
+// tier with no zones must not ship a master achievement nobody can earn.
+func TestExpeditionAchievementIDsRegistered(t *testing.T) {
+	p := &AchievementsPlugin{}
+	defs := p.buildAchievements()
+	ids := map[string]bool{}
+	for _, a := range defs {
+		if ids[a.ID] {
+			t.Errorf("duplicate achievement id %q", a.ID)
+		}
+		ids[a.ID] = true
+	}
+
+	for tier := ZoneTier(1); tier <= 5; tier++ {
+		if len(zonesOfTier(tier)) == 0 {
+			continue
+		}
+		for _, prefix := range []string{"expedition_clear_t", "expedition_master_t"} {
+			id := prefix + string(rune('0'+tier))
+			if !ids[id] {
+				t.Errorf("tier %d has zones but %q is not registered", tier, id)
+			}
+		}
+	}
+	for _, id := range []string{"expedition_quiet_clear", "temper_legendary"} {
+		if !ids[id] {
+			t.Errorf("%q is not registered", id)
+		}
+	}
+}

internal/plugin/adv2_scenario_test.go

@@ -221,10 +221,9 @@ func TestAdv2Scenario_ExpeditionCryptValdris(t *testing.T) {
 		t.Errorf("expected outfitting to debit coins (%.2f → %.2f)", balBefore, balAfter)
 	}
 
-	// Backdate start so deliverBriefing's same-day guard passes.
-	if _, err := dbExecExpeditionBackdate(exp.ID, 24*time.Hour); err != nil {
-		t.Fatalf("backdate: %v", err)
-	}
+	// Backdate start so deliverBriefing's same-day guard passes, and to
+	// before eventAnchoredCutoff so the legacy mutator path still fires.
+	rewindToLegacyAnchor(t, exp)
 
 	// Drive 3 daily briefings — verify supply burn + day advance.
 	now := time.Date(2026, 5, 8, 6, 0, 0, 0, time.UTC)
@@ -305,7 +304,7 @@ func TestAdv2Scenario_HarvestForestShadows(t *testing.T) {
 	p := &AdventurePlugin{euro: euro}
 
 	// Forage-friendly expedition.
-	if err := p.handleDnDExpeditionCmd(MessageContext{Sender: uid}, "start forest_shadows"); err != nil {
+	if err := p.handleDnDExpeditionCmd(MessageContext{Sender: uid}, "start forest_shadows lean"); err != nil {
 		t.Fatalf("expedition start: %v", err)
 	}
 	exp, _ := getActiveExpedition(uid)

internal/plugin/adventure.go

@@ -21,13 +21,14 @@ import (
 
 type AdventurePlugin struct {
 	Base
-	euro         *EuroPlugin
-	xp           *XPPlugin
-	achievements *AchievementsPlugin
-	mu           sync.Mutex
+	euro           *EuroPlugin
+	xp             *XPPlugin
+	achievements   *AchievementsPlugin
+	mu             sync.Mutex
 	dmToPlayer     map[id.RoomID]id.UserID
 	pending        sync.Map // userID string -> *advPendingInteraction
 	userLocks      sync.Map // userID string -> *sync.Mutex
+	expLocks       sync.Map // expedition ID string -> *sync.Mutex
 	dmRemindedDate sync.Map // userID string -> "2006-01-02" date string
 	dmMenuSentAt   sync.Map // userID string -> time.Time (last time actionable menu was DM'd)
 	arenaDeadlines sync.Map // userID string -> time.Time (auto-cashout deadline)
@@ -37,8 +38,8 @@ type AdventurePlugin struct {
 	hospitalNudges sync.Map // userID string -> time.Time (when to send nudge)
 	craftResults   sync.Map // userID string -> []CraftResult (pending craft results for narrative)
 	treasureUndo   sync.Map // userID string -> *advTreasureUndoToken (10-min auto-swap reversal)
-	morningHour int
-	summaryHour int
+	morningHour    int
+	summaryHour    int
 
 	// stopCh is closed by Stop() to signal all background tickers
 	// (morning/summary/midnight/event/rival/robbie/hospital/mortgage/
@@ -70,6 +71,16 @@ func (p *AdventurePlugin) advUserLock(userID id.UserID) *sync.Mutex {
 	return val.(*sync.Mutex)
 }
 
+// advExpeditionLock returns a per-expedition mutex, for state a whole party
+// shares rather than one player. advUserLock cannot stand in: it is keyed by
+// sender, so two members racing the same expedition row take two different
+// mutexes and exclude nobody. Handlers run one goroutine per event, so any
+// read-modify-write of the shared supply pool needs this.
+func (p *AdventurePlugin) advExpeditionLock(expID string) *sync.Mutex {
+	val, _ := p.expLocks.LoadOrStore(expID, &sync.Mutex{})
+	return val.(*sync.Mutex)
+}
+
 // advDMResponseWindow is the default window for active state-holding
 // prompts (shop/blacksmith/hospital/masterwork/treasure confirms).
 // Passive overnight-tolerant prompts (pet arrival, flavor DMs) use
@@ -158,6 +169,7 @@ func (p *AdventurePlugin) Commands() []CommandDef {
 		{Name: "rest", Description: "Rest up (`short`: quick breather, 1h cooldown — `long`: full night, 24h, needs housing or inn)", Usage: "!rest short|long", Category: "Games"},
 		{Name: "arm", Description: "Ready an ability so it fires the moment your next fight starts", Usage: "!arm <ability>", Category: "Games"},
 		{Name: "roll", Description: "Roll dice (NdN+M format, e.g. 2d6+3, d20, 4d6-1)", Usage: "!roll <dice>", Category: "Games"},
+		{Name: "duel", Description: "Challenge another adventurer to a staked, no-death bout", Usage: "!duel @user [stake]", Category: "Games"},
 		{Name: "stats", Description: "Show your ability scores", Usage: "!stats", Category: "Games"},
 		{Name: "level", Description: "Show your level and XP progress", Usage: "!level", Category: "Games"},
 		{Name: "cast", Description: "Cast a spell (queues for next combat, or resolves now if out of combat)", Usage: "!cast <spell> [--upcast N] [--target @user]", Category: "Games"},
@@ -168,6 +180,10 @@ func (p *AdventurePlugin) Commands() []CommandDef {
 		{Name: "sell", Description: "Sell your hauled materials, fish, and items to Thom Krooke after an expedition (a smooth pitch can land a better price)", Usage: "!sell [list|all|<item>]", Category: "Games"},
 		{Name: "craft", Description: "Craft a discovered recipe at Thom Krooke (consumes ingredients)", Usage: "!craft [list|<recipe>]", Category: "Games"},
 		{Name: "lore", Description: "Dig through Thom Krooke's lore stacks for a new recipe (sharp minds turn up more)", Usage: "!lore", Category: "Games"},
+		{Name: "give", Description: "Gift a consumable or non-magic item to another adventurer (5% handling fee to the community pot; 3/day)", Usage: "!give <item> @user", Category: "Games"},
+		{Name: "town", Description: "Town registry — civic pride, housing street, and the pet showcase", Usage: "!town", Category: "Games"},
+		{Name: "graveyard", Description: "Recent deaths across the guild", Usage: "!graveyard", Category: "Games"},
+		{Name: "rivals", Description: "Your rival duel record, or `!rivals board` for room-wide standings", Usage: "!rivals [board]", Category: "Games"},
 	}
 }
 
@@ -177,6 +193,7 @@ func (p *AdventurePlugin) Init() error {
 	// through the L4-L5h dual-write soak (fresh deploys, restored backups).
 	bootstrapPlayerMetaFromLegacy()
 	bootstrapRestoreExpeditionStreakDecay()
+	bootstrapRoomsTraversed()
 
 	// Rehydrate DM room mappings for existing characters
 	chars, err := loadAllAdvCharacters()
@@ -220,6 +237,16 @@ func (p *AdventurePlugin) Init() error {
 	// migration walks dnd_character once at startup; idempotent via
 	// JobCompleted gate.
 	bootstrapPhase5BHPRefresh()
+	// J3 D8-d-fix: caster HP lift (casterHPMult in dnd.go). Refresh
+	// existing caster rows once at startup so the lift reaches live
+	// players without waiting for level-up.
+	bootstrapCasterHPRefresh()
+	// 2026-06-18 caster-aid: backfill default spells that postdate a
+	// character's roll (ensureSpellsForCharacter only seeds an empty book),
+	// and a one-off pet gift for an endgame player who never got the morning
+	// arrival roll. Both idempotent via JobCompleted gates.
+	bootstrapCasterSpellBackfill()
+	bootstrapGrantStarterPet()
 	// Phase R1 orphan-archive used to run here on every Init, but it
 	// over-archived: it treats any active dnd_zone_run row not linked to
 	// an active expedition as a legacy `!adventure dungeon` orphan, which
@@ -248,9 +275,13 @@ func (p *AdventurePlugin) Init() error {
 	go p.expeditionRecapTicker()
 	go p.expeditionAmbientTicker()
 	go p.expeditionAutoRunTicker()
+	go p.expeditionExtractionSweepTicker()
 
 	// Auto-cashout any arena runs left in 'awaiting' from a prior restart
 	p.arenaCleanupStaleRuns()
+	// Extractions that lapsed while the bot was down: the roster they hold is
+	// blocking those members right now, not an hour from now.
+	p.sweepLapsedExtractions(time.Now().UTC())
 
 	return nil
 }
@@ -279,6 +310,12 @@ func (p *AdventurePlugin) OnReaction(_ ReactionContext) error { return nil }
 // ── Message Dispatch ─────────────────────────────────────────────────────────
 
 func (p *AdventurePlugin) OnMessage(ctx MessageContext) error {
+	// D4-b: lazy morning briefing. When the 06:00 UTC ticker skips an idle
+	// player's event-anchored expedition, the briefing fires here on their
+	// next inbound message. Fast-paths to a no-op for users with no active
+	// expedition.
+	p.maybeDeliverDeferredBriefing(ctx.Sender, time.Now().UTC())
+
 	// 0. D&D layer commands (Phase 1 — work in rooms and DMs)
 	if p.IsCommand(ctx.Body, "setup") {
 		return p.handleDnDSetupCmd(ctx, p.GetArgs(ctx.Body, "setup"))
@@ -301,6 +338,9 @@ func (p *AdventurePlugin) OnMessage(ctx MessageContext) error {
 	if p.IsCommand(ctx.Body, "rest") {
 		return p.handleDnDRestCmd(ctx, p.GetArgs(ctx.Body, "rest"))
 	}
+	if p.IsCommand(ctx.Body, "duel") {
+		return p.handleDuelCmd(ctx, p.GetArgs(ctx.Body, "duel"))
+	}
 	if p.IsCommand(ctx.Body, "arm") {
 		return p.handleDnDArmCmd(ctx, p.GetArgs(ctx.Body, "arm"))
 	}
@@ -325,6 +365,9 @@ func (p *AdventurePlugin) OnMessage(ctx MessageContext) error {
 	if p.IsCommand(ctx.Body, "zone") {
 		return p.handleDnDZoneCmd(ctx, p.GetArgs(ctx.Body, "zone"))
 	}
+	if p.IsCommand(ctx.Body, "revisit") {
+		return p.handleRevisitCmd(ctx, p.GetArgs(ctx.Body, "revisit"))
+	}
 	if p.IsCommand(ctx.Body, "fight") {
 		return p.handleFightCmd(ctx)
 	}
@@ -381,6 +424,20 @@ func (p *AdventurePlugin) OnMessage(ctx MessageContext) error {
 	if p.IsCommand(ctx.Body, "lore") {
 		return p.handleLoreCmd(ctx)
 	}
+	if p.IsCommand(ctx.Body, "give") {
+		return p.handleGiveCmd(ctx)
+	}
+
+	// 0b. Town registries (E3) — read-only social boards (rooms and DMs)
+	if p.IsCommand(ctx.Body, "town") {
+		return p.handleTownCmd(ctx)
+	}
+	if p.IsCommand(ctx.Body, "graveyard") {
+		return p.handleGraveyardCmd(ctx)
+	}
+	if p.IsCommand(ctx.Body, "rivals") {
+		return p.handleRivalsTopCmd(ctx, p.GetArgs(ctx.Body, "rivals"))
+	}
 
 	// 1. Arena commands (work in rooms and DMs)
 	if p.IsCommand(ctx.Body, "bail") {
@@ -460,6 +517,8 @@ func (p *AdventurePlugin) dispatchCommand(ctx MessageContext) error {
 		return p.SendDM(ctx.Sender, advHelpText)
 	case lower == "rivals":
 		return p.handleRivalsCmd(ctx)
+	case lower == "duel" || strings.HasPrefix(lower, "duel "):
+		return p.handleDuelCmd(ctx, strings.TrimSpace(args[len("duel"):]))
 	case lower == "babysit" || strings.HasPrefix(lower, "babysit "):
 		return p.handleBabysitCmd(ctx, strings.TrimSpace(strings.TrimPrefix(lower, "babysit")))
 	case lower == "blacksmith" || lower == "repair":
@@ -468,6 +527,8 @@ func (p *AdventurePlugin) dispatchCommand(ctx MessageContext) error {
 		return p.handleRepairAllCmd(ctx)
 	case strings.HasPrefix(lower, "repair "):
 		return p.handleRepairSlotCmd(ctx, strings.TrimSpace(args[7:]))
+	case lower == "temper":
+		return p.handleTemperCmd(ctx)
 	case lower == "boost":
 		return p.handleBoostCmd(ctx)
 	case lower == "recipes":
@@ -476,6 +537,16 @@ func (p *AdventurePlugin) dispatchCommand(ctx MessageContext) error {
 		return p.handleMasteryCmd(ctx)
 	case lower == "treasures" || strings.HasPrefix(lower, "treasures "):
 		return p.handleTreasuresCmd(ctx, strings.TrimSpace(strings.TrimPrefix(lower, "treasures")))
+	case lower == "vault" || strings.HasPrefix(lower, "vault "):
+		return p.handleVaultCmd(ctx, strings.TrimSpace(args[len("vault"):]))
+	case lower == "journal":
+		return p.handleJournalCmd(ctx)
+	case lower == "shadow":
+		return p.handleShadowCmd(ctx)
+	case lower == "worldboss" || strings.HasPrefix(lower, "worldboss "):
+		return p.handleWorldBossCmd(ctx, strings.TrimSpace(args[len("worldboss"):]))
+	case lower == "siege" || strings.HasPrefix(lower, "siege "):
+		return p.handleWorldBossCmd(ctx, strings.TrimSpace(args[len("siege"):]))
 	}
 
 	return p.SendDM(ctx.Sender, "Unknown command. Type `!adventure help` to see available commands.")
@@ -493,18 +564,24 @@ const advHelpText = `**Adventure Commands**
 ` + "`!adventure equip-magic`" + ` — Equip magic items (curios) into your D&D slots
 ` + "`!adventure sell <item>`" + ` — Sell an inventory item (or ` + "`sell all`" + `)
 ` + "`!adventure inventory`" + ` — View your inventory
+` + "`!adventure vault`" + ` — Store items safely (Tier-4 Established home; ` + "`vault store/take <item>`" + `)
 ` + "`!adventure leaderboard`" + ` — View the leaderboard
 ` + "`!adventure respond`" + ` — Respond to a mid-day event
 ` + "`!adventure rivals`" + ` — View rival duel records
+` + "`!duel @user [stake]`" + ` — Challenge another adventurer to a staked, no-death bout (` + "`!duel accept`" + `/` + "`decline`" + `/` + "`status`" + `)
 ` + "`!adventure babysit`" + ` — Adventurer Babysitting Service
 ` + "`!adventure babysit auto`" + ` — Toggle auto-babysit (protects streaks on missed days)
 ` + "`!adventure babysit focus <skill>`" + ` — Pick the skill auto-babysit trains (mining/fishing/foraging)
 ` + "`!adventure blacksmith`" + ` — Visit the blacksmith (view repair costs)
 ` + "`!adventure repair all`" + ` — Repair all damaged equipment
 ` + "`!adventure repair <slot>`" + ` — Repair a specific slot
+` + "`!adventure temper`" + ` — Push a magic item one rarity step higher (blacksmith)
 ` + "`!adventure recipes`" + ` — List crafting recipes known at your current Foraging level
 ` + "`!adventure mastery`" + ` — Per-slot equipment mastery progress and active bonus
 ` + "`!adventure treasures`" + ` — List your treasures · ` + "`treasures lock`" + ` to refuse swaps
+` + "`!adventure journal`" + ` — Read the campaign pages you've recovered
+` + "`!adventure shadow`" + ` — See how your rival's run compares to yours
+` + "`!adventure worldboss`" + ` — The monthly Siege: one communal bout a day (` + "`fight`" + ` to join)
 ` + "`!hospital`" + ` — Visit St. Guildmore's Memorial Hospital (same-day revival when dead)
 ` + "`!thom`" + ` — Visit Thom Krooke (housing and loans)
 ` + "`!adventure help`" + ` — This message
@@ -691,7 +768,10 @@ func (p *AdventurePlugin) handleSellCmd(ctx MessageContext, args string) error {
 	} else {
 		result = p.advSellItem(ctx.Sender, args)
 	}
-	return p.SendDM(ctx.Sender, result)
+	err = p.SendDM(ctx.Sender, result)
+	// N1/A6 — a sale at Thom's is a moment the player is present and reading.
+	p.maybeFireAnchoredEvent(ctx.Sender, advEventChanceSell)
+	return err
 }
 
 func (p *AdventurePlugin) handleInventoryCmd(ctx MessageContext) error {
@@ -834,6 +914,10 @@ func (p *AdventurePlugin) resolvePendingInteraction(ctx MessageContext, interact
 		return p.resolveBlacksmithSlotChoice(ctx, interaction)
 	case "blacksmith_confirm":
 		return p.resolveBlacksmithConfirm(ctx, interaction)
+	case "temper_pick":
+		return p.resolveTemperPick(ctx, interaction)
+	case "temper_confirm":
+		return p.resolveTemperConfirm(ctx, interaction)
 	case "shop_category":
 		return p.resolveShopCategoryChoice(ctx, interaction)
 	case "shop_item":
@@ -849,11 +933,11 @@ func (p *AdventurePlugin) resolvePendingInteraction(ctx MessageContext, interact
 	case "npc_encounter":
 		return p.resolveNPCEncounter(ctx, interaction)
 	case "pet_arrival":
-		return p.resolvePetArrival(ctx)
+		return p.resolvePetArrival(ctx, interaction)
 	case "pet_type":
-		return p.resolvePetType(ctx)
+		return p.resolvePetType(ctx, interaction)
 	case "pet_name":
-		return p.resolvePetName(ctx)
+		return p.resolvePetName(ctx, interaction)
 	}
 	return nil
 }
@@ -1056,13 +1140,19 @@ func (p *AdventurePlugin) resolveRest(ctx MessageContext, char *AdventureCharact
 
 // ── Treasure Drop Check ─────────────────────────────────────────────────────
 
-func (p *AdventurePlugin) checkTreasureDrop(userID id.UserID, char *AdventureCharacter, loc *AdvLocation) {
-	drop, roll, rate := rollAdvTreasureDropDetailed(loc.Tier, userID, p.chatLevel(userID))
+// checkTreasureDrop rolls the treasure table for one earned moment. weight
+// scales the drop rate by how big that moment was (see advTreasureWeight*).
+func (p *AdventurePlugin) checkTreasureDrop(userID id.UserID, char *AdventureCharacter, loc *AdvLocation, weight float64) {
+	drop, roll, rate := rollAdvTreasureDropDetailed(loc.Tier, userID, p.chatLevel(userID), weight)
 	if drop == nil {
 		// Near-miss feedback: when the roll was within 2× of the drop rate,
 		// tell the player they almost got it. Treasure rates are 0.15–1.5%
 		// so without this signal the system feels invisible.
-		if rate > 0 && roll < rate*2 {
+		//
+		// Only for weighted moments (boss/elite/zone clear). A standard kill
+		// fires dozens of times a day on autopilot, and a near-miss DM on 3%
+		// of them turns the signal into noise.
+		if weight > 1 && rate > 0 && roll < rate*2 {
 			p.SendDM(userID, fmt.Sprintf("🎁 *Treasure: just missed* — rolled %.2f%% against %.2f%% drop chance.",
 				roll*100, rate*100))
 		}
@@ -1075,7 +1165,7 @@ func (p *AdventurePlugin) checkTreasureDrop(userID id.UserID, char *AdventureCha
 		return
 	}
 
-	if count < advMaxTreasures {
+	if count < maxTreasuresForTier(char.HouseTier) {
 		// Directly save
 		if err := advSaveTreasure(userID, drop.Def); err != nil {
 			slog.Error("adventure: failed to save treasure", "user", userID, "err", err)
@@ -1460,7 +1550,7 @@ func (p *AdventurePlugin) handleRecipesCmd(ctx MessageContext) error {
 	if err != nil {
 		return p.SendDM(ctx.Sender, "Failed to load your character.")
 	}
-	return p.SendDM(ctx.Sender, renderRecipesKnown(char.ForagingSkill))
+	return p.SendDM(ctx.Sender, renderRecipesKnown(char.ForagingSkill, homeWorkshopCraftBonus(char.HouseTier)))
 }
 
 func (p *AdventurePlugin) handleTreasuresCmd(ctx MessageContext, arg string) error {
@@ -1522,4 +1612,3 @@ func (p *AdventurePlugin) handleBoostCmd(ctx MessageContext) error {
 	advSetBoost(true)
 	return p.SendReply(ctx.RoomID, ctx.EventID, "⚡ Double XP/money boost **enabled**! All adventure XP and loot values are doubled.")
 }
-

internal/plugin/adventure_activities.go

@@ -642,7 +642,7 @@ type AdvActionResult struct {
 	FlavorKey      string
 	EquipBroken    []EquipmentSlot
 	NearDeath      bool
-	StreakBonus     int
+	StreakBonus    int
 	CombatLog      *CombatResult
 	// MasteryCrossings records equipment slots whose ActionsUsed crossed a
 	// mastery threshold (advMasteryThresholds) on this action. The caller

internal/plugin/adventure_activity_unified.go

@@ -116,12 +116,12 @@ func loadAdvDailyActivity(date string) (map[id.UserID][]AdvDailyActivity, error)
 	}
 	for rows.Next() {
 		var (
-			uid, zoneID                        string
-			visitedJSON                        string
-			totalRooms                         int
-			abandoned, bossDefeated            int
-			completedAt                        *time.Time
-			lastAction                         time.Time
+			uid, zoneID             string
+			visitedJSON             string
+			totalRooms              int
+			abandoned, bossDefeated int
+			completedAt             *time.Time
+			lastAction              time.Time
 		)
 		if err := rows.Scan(&uid, &zoneID, &visitedJSON, &totalRooms,
 			&abandoned, &bossDefeated, &completedAt, &lastAction); err != nil {

internal/plugin/adventure_arena.go

@@ -16,20 +16,20 @@ import (
 // ── Arena Run State ─────────────────────────────────────────────────────────
 
 type ArenaRun struct {
-	ID              int64
-	UserID          id.UserID
-	RoomID          id.RoomID
-	StartTier       int
-	Tier            int
-	Round           int
-	Status          string // "active", "awaiting", "completed", "dead", "cashed_out"
-	Earnings        int64  // session total (multiplied euros accumulated across completed tiers)
-	TierEarnings    int64  // current tier's raw earnings (reset each tier)
-	XPAccumulated   int    // session XP accumulator (raw, multiplied at payout)
-	RoundsSurvived  int
-	LastMonster     string
-	StartedAt       time.Time
-	EndedAt         *time.Time
+	ID             int64
+	UserID         id.UserID
+	RoomID         id.RoomID
+	StartTier      int
+	Tier           int
+	Round          int
+	Status         string // "active", "awaiting", "completed", "dead", "cashed_out"
+	Earnings       int64  // session total (multiplied euros accumulated across completed tiers)
+	TierEarnings   int64  // current tier's raw earnings (reset each tier)
+	XPAccumulated  int    // session XP accumulator (raw, multiplied at payout)
+	RoundsSurvived int
+	LastMonster    string
+	StartedAt      time.Time
+	EndedAt        *time.Time
 }
 
 // ── Command Dispatch ────────────────────────────────────────────────────────
@@ -304,13 +304,17 @@ func (p *AdventurePlugin) handleArenaStats(ctx MessageContext) error {
 	return p.SendDM(ctx.Sender, renderArenaPersonalStats(displayName, wins, losses, stats))
 }
 
+// handleArenaLeaderboard shows the current season's standings (C4). Lifetime
+// totals stay reachable via `!arena stats`.
 func (p *AdventurePlugin) handleArenaLeaderboard(ctx MessageContext) error {
-	entries, err := loadArenaLeaderboard()
+	now := time.Now().UTC()
+	start, end := arenaSeasonBounds(now)
+	entries, err := loadArenaSeasonLeaderboard(start, end)
 	if err != nil {
-		slog.Error("arena: failed to load leaderboard", "err", err)
+		slog.Error("arena: failed to load season leaderboard", "err", err)
 		return p.SendReply(ctx.RoomID, ctx.EventID, "Failed to load arena leaderboard.")
 	}
-	return p.SendReply(ctx.RoomID, ctx.EventID, renderArenaLeaderboard(entries))
+	return p.SendReply(ctx.RoomID, ctx.EventID, renderArenaLeaderboard(arenaSeasonKey(now), entries))
 }
 
 // ── Combat Resolution ───────────────────────────────────────────────────────
@@ -624,7 +628,10 @@ func (p *AdventurePlugin) arenaCompleteSession(userID id.UserID, run *ArenaRun,
 		text += fmt.Sprintf("\n\n🎉 **Combat Level %d!**", newLevel)
 	}
 
-	return p.SendDM(userID, text)
+	err := p.SendDM(userID, text)
+	// N1/A6 — cashing out is the third mid-day event anchor.
+	p.maybeFireAnchoredEvent(userID, advEventChanceArena)
+	return err
 }
 
 // arenaProcessBail handles bail payout (called from handleArenaBail or countdown).
@@ -1008,8 +1015,8 @@ func loadArenaPersonalStats(userID id.UserID) *ArenaPersonalStats {
 
 type ArenaGearSet struct {
 	Tier        int
-	SetKey      string  // DB key: "bloodied", "ironclad", etc.
-	SetName     string  // Display: "Bloodied", "Ironclad", etc.
+	SetKey      string // DB key: "bloodied", "ironclad", etc.
+	SetName     string // Display: "Bloodied", "Ironclad", etc.
 	HelmetName  string
 	Description string
 	DropRate    float64

internal/plugin/adventure_arena_bossflow_test.go

@@ -138,12 +138,12 @@ func TestArenaBossOutcome_WinSurfacesStagedLogAndBossDeath(t *testing.T) {
 
 	victoryHeadline := "🏆 **" + monster.Name + "** falls (HP " + "60" + "→" + "42" + " / 60)."
 	outcome := renderBossOutcome(BossOutcomeInputs{
-		ZoneID:          ZoneArena,
-		RunID:           "arena-stagedlog-test",
-		RoomIdx:         11,
-		Monster:         monster,
-		Result:          result,
-		PreHP:           60, PostHP: 42, MaxHP: 60,
+		ZoneID:  ZoneArena,
+		RunID:   "arena-stagedlog-test",
+		RoomIdx: 11,
+		Monster: monster,
+		Result:  result,
+		PreHP:   60, PostHP: 42, MaxHP: 60,
 		PhaseTwoAt:      arenaBossPhaseTwoAt(1),
 		Nat20s:          1,
 		Nat1s:           0,

internal/plugin/adventure_arena_render.go

@@ -126,21 +126,21 @@ func renderArenaStatus(run *ArenaRun) string {
 // ── Leaderboard ─────────────────────────────────────────────────────────────
 
 type ArenaLeaderboardEntry struct {
-	DisplayName     string
-	TotalEarnings   int64
-	HighestTier     int
+	DisplayName      string
+	TotalEarnings    int64
+	HighestTier      int
 	Tier5Completions int
-	TotalRuns       int
-	TotalDeaths     int
+	TotalRuns        int
+	TotalDeaths      int
 }
 
-func renderArenaLeaderboard(entries []ArenaLeaderboardEntry) string {
+func renderArenaLeaderboard(season string, entries []ArenaLeaderboardEntry) string {
 	if len(entries) == 0 {
-		return "⚔️ **Arena Leaderboard**\n\nNo arena runs recorded yet. Be the first."
+		return fmt.Sprintf("⚔️ **Arena Leaderboard — Season %s**\n\nNobody has entered the arena this season. Be the first.", season)
 	}
 
 	var b strings.Builder
-	b.WriteString("⚔️ **Arena Leaderboard**\n\n")
+	b.WriteString(fmt.Sprintf("⚔️ **Arena Leaderboard — Season %s**\n\n", season))
 
 	medals := []string{"🥇", "🥈", "🥉"}
 	for i, e := range entries {
@@ -157,6 +157,7 @@ func renderArenaLeaderboard(entries []ArenaLeaderboardEntry) string {
 		b.WriteString(fmt.Sprintf("%s **%s** — €%d earned | %s | %d runs | %d deaths\n",
 			prefix, e.DisplayName, e.TotalEarnings, tierLabel, e.TotalRuns, e.TotalDeaths))
 	}
+	b.WriteString("\n_Season standings. `!arena stats` for your lifetime record._")
 
 	return b.String()
 }

internal/plugin/adventure_arena_season.go

@@ -0,0 +1,235 @@
+package plugin
+
+import (
+	"database/sql"
+	"fmt"
+	"log/slog"
+	"strings"
+	"time"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// ── Arena seasons ───────────────────────────────────────────────────────────
+//
+// Quarterly standings (gogobee_engagement_plan.md C4). The plan called for a
+// quarterly *reset* of arena_stats; this derives season standings from
+// arena_history.created_at instead. Same player-visible effect — the board
+// clears every quarter — but lifetime totals survive for `!arena stats`, and
+// there is no destructive job that can fire twice or half-way.
+//
+// Season titles are archived to their own table rather than player_meta.title:
+// that column already carries the Survivalist milestone, and a season champion
+// overwriting someone's expedition title would silently destroy it.
+
+// arenaSeasonTitleKinds are the two crowns awarded per season.
+const (
+	arenaTitleEarnings = "earnings"
+	arenaTitleStreak   = "streak"
+)
+
+// arenaSeasonKey names the quarter containing t, e.g. "2026-Q3".
+func arenaSeasonKey(t time.Time) string {
+	t = t.UTC()
+	return fmt.Sprintf("%d-Q%d", t.Year(), (int(t.Month())-1)/3+1)
+}
+
+// arenaSeasonStart is the first instant of the quarter containing t.
+func arenaSeasonStart(t time.Time) time.Time {
+	t = t.UTC()
+	firstMonth := time.Month(((int(t.Month())-1)/3)*3 + 1)
+	return time.Date(t.Year(), firstMonth, 1, 0, 0, 0, 0, time.UTC)
+}
+
+// arenaSeasonBounds returns [start, end) for the quarter containing t.
+func arenaSeasonBounds(t time.Time) (time.Time, time.Time) {
+	start := arenaSeasonStart(t)
+	return start, start.AddDate(0, 3, 0)
+}
+
+// previousArenaSeason returns the key and bounds of the quarter before t's.
+func previousArenaSeason(t time.Time) (string, time.Time, time.Time) {
+	prev := arenaSeasonStart(t).AddDate(0, -1, 0) // any instant inside the prior quarter
+	start, end := arenaSeasonBounds(prev)
+	return arenaSeasonKey(prev), start, end
+}
+
+// loadArenaSeasonLeaderboard aggregates arena_history over [start, end) into
+// the same shape the lifetime board renders.
+func loadArenaSeasonLeaderboard(start, end time.Time) ([]ArenaLeaderboardEntry, error) {
+	rows, err := db.Get().Query(`
+		SELECT h.user_id, COALESCE(c.display_name, h.user_id),
+		       SUM(h.earnings),
+		       MAX(h.tier),
+		       SUM(CASE WHEN h.tier = 5 AND h.outcome = 'completed' THEN 1 ELSE 0 END),
+		       COUNT(*),
+		       SUM(CASE WHEN h.outcome = 'dead' THEN 1 ELSE 0 END)
+		FROM arena_history h
+		LEFT JOIN player_meta c ON c.user_id = h.user_id
+		WHERE h.created_at >= ? AND h.created_at < ?
+		GROUP BY h.user_id
+		ORDER BY SUM(h.earnings) DESC
+		LIMIT 10`, start.Unix(), end.Unix())
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var entries []ArenaLeaderboardEntry
+	for rows.Next() {
+		var e ArenaLeaderboardEntry
+		var uid string
+		if err := rows.Scan(&uid, &e.DisplayName, &e.TotalEarnings, &e.HighestTier,
+			&e.Tier5Completions, &e.TotalRuns, &e.TotalDeaths); err != nil {
+			return nil, err
+		}
+		entries = append(entries, e)
+	}
+	return entries, rows.Err()
+}
+
+// arenaSeasonChampion finds the single top row for a season by the given
+// metric. Returns ok=false when nobody entered the arena that quarter.
+func arenaSeasonChampion(kind string, start, end time.Time) (id.UserID, int64, bool) {
+	var metric string
+	switch kind {
+	case arenaTitleEarnings:
+		metric = "SUM(earnings)"
+	case arenaTitleStreak:
+		metric = "MAX(rounds_survived)"
+	default:
+		return "", 0, false
+	}
+
+	// Only runs that earned or survived something can crown anyone: a season of
+	// nothing but deaths at round zero should award no streak title.
+	q := fmt.Sprintf(`
+		SELECT user_id, %s AS metric
+		FROM arena_history
+		WHERE created_at >= ? AND created_at < ?
+		GROUP BY user_id
+		HAVING metric > 0
+		ORDER BY metric DESC, user_id ASC
+		LIMIT 1`, metric)
+
+	var uid string
+	var value int64
+	err := db.Get().QueryRow(q, start.Unix(), end.Unix()).Scan(&uid, &value)
+	if err == sql.ErrNoRows {
+		return "", 0, false
+	}
+	if err != nil {
+		slog.Error("arena season: champion query", "kind", kind, "err", err)
+		return "", 0, false
+	}
+	return id.UserID(uid), value, true
+}
+
+// recordArenaSeasonTitle archives a crown. Idempotent on (season, kind).
+func recordArenaSeasonTitle(season, kind string, userID id.UserID, value int64, at time.Time) error {
+	_, err := db.Get().Exec(`
+		INSERT INTO arena_season_titles (season, kind, user_id, value, awarded_at)
+		VALUES (?, ?, ?, ?, ?)
+		ON CONFLICT(season, kind) DO NOTHING`,
+		season, kind, string(userID), value, at.Unix())
+	return err
+}
+
+// loadArenaSeasonTitles returns every crown a player has ever taken.
+func loadArenaSeasonTitles(userID id.UserID) ([]string, error) {
+	rows, err := db.Get().Query(`
+		SELECT season, kind FROM arena_season_titles
+		WHERE user_id = ? ORDER BY season DESC`, string(userID))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []string
+	for rows.Next() {
+		var season, kind string
+		if err := rows.Scan(&season, &kind); err != nil {
+			return nil, err
+		}
+		out = append(out, fmt.Sprintf("%s %s", season, arenaTitleName(kind)))
+	}
+	return out, rows.Err()
+}
+
+func arenaTitleName(kind string) string {
+	switch kind {
+	case arenaTitleEarnings:
+		return "Coinlord of the Arena"
+	case arenaTitleStreak:
+		return "Longest Walk"
+	}
+	return kind
+}
+
+// ── Rollover ────────────────────────────────────────────────────────────────
+
+// arenaSeasonRollover awards the previous season's crowns exactly once, and
+// announces them. Safe to call every midnight: JobCompleted keyed on the season
+// makes it a no-op for the rest of the quarter, and a bot that was down on the
+// rollover day still catches up the next time it wakes.
+func (p *AdventurePlugin) arenaSeasonRollover(now time.Time) {
+	season, start, end := previousArenaSeason(now)
+	jobName := "arena_season_rollover"
+	if db.JobCompleted(jobName, season) {
+		return
+	}
+	// Guard against awarding a season that hasn't finished yet — only possible
+	// if a caller passes a doctored clock.
+	if !now.UTC().After(end) {
+		return
+	}
+
+	var lines []string
+	failed := false
+	for _, kind := range []string{arenaTitleEarnings, arenaTitleStreak} {
+		uid, value, ok := arenaSeasonChampion(kind, start, end)
+		if !ok {
+			continue
+		}
+		if err := recordArenaSeasonTitle(season, kind, uid, value, now); err != nil {
+			slog.Error("arena season: record title failed", "season", season, "kind", kind, "err", err)
+			failed = true
+			continue // don't announce a crown we failed to persist
+		}
+		name, _ := loadDisplayName(uid)
+		switch kind {
+		case arenaTitleEarnings:
+			lines = append(lines, fmt.Sprintf("🥇 **%s** — _%s_ (€%d earned)",
+				name, arenaTitleName(kind), value))
+		case arenaTitleStreak:
+			lines = append(lines, fmt.Sprintf("🏃 **%s** — _%s_ (%d rounds in one run)",
+				name, arenaTitleName(kind), value))
+		}
+	}
+
+	// Marking the job done is what stops the next midnight from retrying, so a
+	// crown we failed to persist must not mark it. recordArenaSeasonTitle is
+	// idempotent on (season, kind), and a past season's data is frozen, so the
+	// retry re-derives the same champions and no-ops the ones already stored.
+	if failed {
+		slog.Warn("arena season: deferring completion after title failure", "season", season)
+		return
+	}
+	db.MarkJobCompleted(jobName, season)
+	if len(lines) == 0 {
+		slog.Info("arena season: closed with no entrants", "season", season)
+		return
+	}
+	slog.Info("arena season: crowned", "season", season, "titles", len(lines))
+
+	gr := gamesRoom()
+	if gr == "" {
+		return
+	}
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("⚔️ **Arena Season %s has ended.**\n\n", season))
+	sb.WriteString(strings.Join(lines, "\n"))
+	sb.WriteString("\n\nThe board is clear. Season " + arenaSeasonKey(now) + " starts now.")
+	p.SendMessage(id.RoomID(gr), sb.String())
+}

internal/plugin/adventure_arena_season_test.go

@@ -0,0 +1,187 @@
+package plugin
+
+import (
+	"testing"
+	"time"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+func TestArenaSeasonKeyAndBounds(t *testing.T) {
+	tests := []struct {
+		when      time.Time
+		key       string
+		wantStart time.Time
+	}{
+		{time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC), "2026-Q1", time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)},
+		{time.Date(2026, 3, 31, 23, 59, 59, 0, time.UTC), "2026-Q1", time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)},
+		{time.Date(2026, 4, 1, 0, 0, 0, 0, time.UTC), "2026-Q2", time.Date(2026, 4, 1, 0, 0, 0, 0, time.UTC)},
+		{time.Date(2026, 7, 9, 12, 0, 0, 0, time.UTC), "2026-Q3", time.Date(2026, 7, 1, 0, 0, 0, 0, time.UTC)},
+		{time.Date(2026, 12, 31, 23, 0, 0, 0, time.UTC), "2026-Q4", time.Date(2026, 10, 1, 0, 0, 0, 0, time.UTC)},
+	}
+	for _, tc := range tests {
+		if got := arenaSeasonKey(tc.when); got != tc.key {
+			t.Errorf("arenaSeasonKey(%s) = %s, want %s", tc.when, got, tc.key)
+		}
+		start, end := arenaSeasonBounds(tc.when)
+		if !start.Equal(tc.wantStart) {
+			t.Errorf("season start for %s = %s, want %s", tc.when, start, tc.wantStart)
+		}
+		if !end.Equal(start.AddDate(0, 3, 0)) {
+			t.Errorf("season end for %s is not start+3mo", tc.when)
+		}
+		if !tc.when.Before(end) || tc.when.Before(start) {
+			t.Errorf("%s does not fall inside its own season bounds", tc.when)
+		}
+	}
+}
+
+// TestPreviousArenaSeasonWrapsYear pins the Q1 → prior-year-Q4 edge.
+func TestPreviousArenaSeasonWrapsYear(t *testing.T) {
+	key, start, end := previousArenaSeason(time.Date(2026, 2, 14, 0, 0, 0, 0, time.UTC))
+	if key != "2025-Q4" {
+		t.Errorf("previous season = %s, want 2025-Q4", key)
+	}
+	if !start.Equal(time.Date(2025, 10, 1, 0, 0, 0, 0, time.UTC)) {
+		t.Errorf("start = %s, want 2025-10-01", start)
+	}
+	if !end.Equal(time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)) {
+		t.Errorf("end = %s, want 2026-01-01", end)
+	}
+}
+
+func insertArenaRun(t *testing.T, user id.UserID, tier, rounds int, earnings int64, outcome string, at time.Time) {
+	t.Helper()
+	_, err := db.Get().Exec(
+		`INSERT INTO arena_history (user_id, start_tier, tier, rounds_survived, earnings, outcome, monster_name, created_at)
+		 VALUES (?, 1, ?, ?, ?, ?, 'Test Monster', ?)`,
+		string(user), tier, rounds, earnings, outcome, at.Unix())
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+// TestArenaSeasonLeaderboardWindowing: only runs inside the season window count.
+func TestArenaSeasonLeaderboardWindowing(t *testing.T) {
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+
+	inSeason := time.Date(2026, 8, 1, 0, 0, 0, 0, time.UTC)
+	start, end := arenaSeasonBounds(inSeason)
+
+	alice := id.UserID("@alice:test.invalid")
+	bob := id.UserID("@bob:test.invalid")
+
+	insertArenaRun(t, alice, 3, 4, 5000, "completed", inSeason)
+	insertArenaRun(t, alice, 5, 2, 1000, "dead", inSeason.AddDate(0, 0, 1))
+	insertArenaRun(t, bob, 2, 3, 9000, "cashed_out", inSeason)
+	// Last season — must not appear.
+	insertArenaRun(t, alice, 5, 4, 999999, "completed", start.AddDate(0, 0, -1))
+
+	entries, err := loadArenaSeasonLeaderboard(start, end)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(entries) != 2 {
+		t.Fatalf("got %d entries, want 2", len(entries))
+	}
+	// Bob out-earned Alice this season (9000 vs 6000).
+	if entries[0].DisplayName != string(bob) {
+		t.Errorf("top entry = %s, want bob", entries[0].DisplayName)
+	}
+	if entries[0].TotalEarnings != 9000 {
+		t.Errorf("bob earnings = %d, want 9000", entries[0].TotalEarnings)
+	}
+	if entries[1].TotalEarnings != 6000 {
+		t.Errorf("alice earnings = %d, want 6000 (last season's 999999 must not count)", entries[1].TotalEarnings)
+	}
+	if entries[1].TotalDeaths != 1 {
+		t.Errorf("alice deaths = %d, want 1", entries[1].TotalDeaths)
+	}
+	if entries[1].HighestTier != 5 {
+		t.Errorf("alice highest tier = %d, want 5", entries[1].HighestTier)
+	}
+}
+
+// TestArenaSeasonChampions: earnings crown goes by total, streak crown by the
+// single longest run — they can be different players.
+func TestArenaSeasonChampions(t *testing.T) {
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+
+	when := time.Date(2026, 8, 1, 0, 0, 0, 0, time.UTC)
+	start, end := arenaSeasonBounds(when)
+
+	rich := id.UserID("@rich:test.invalid")
+	tough := id.UserID("@tough:test.invalid")
+
+	insertArenaRun(t, rich, 5, 2, 50000, "cashed_out", when)
+	insertArenaRun(t, tough, 1, 12, 500, "completed", when)
+
+	uid, val, ok := arenaSeasonChampion(arenaTitleEarnings, start, end)
+	if !ok || uid != rich || val != 50000 {
+		t.Errorf("earnings champion = (%s, %d, %v), want rich/50000", uid, val, ok)
+	}
+	uid, val, ok = arenaSeasonChampion(arenaTitleStreak, start, end)
+	if !ok || uid != tough || val != 12 {
+		t.Errorf("streak champion = (%s, %d, %v), want tough/12", uid, val, ok)
+	}
+
+	// An empty season crowns nobody.
+	emptyStart, emptyEnd := arenaSeasonBounds(when.AddDate(1, 0, 0))
+	if _, _, ok := arenaSeasonChampion(arenaTitleEarnings, emptyStart, emptyEnd); ok {
+		t.Error("an empty season produced an earnings champion")
+	}
+
+	// A season of nothing but round-zero deaths crowns no streak.
+	deathsOnly := time.Date(2025, 2, 1, 0, 0, 0, 0, time.UTC)
+	dStart, dEnd := arenaSeasonBounds(deathsOnly)
+	insertArenaRun(t, tough, 1, 0, 0, "dead", deathsOnly)
+	if _, _, ok := arenaSeasonChampion(arenaTitleStreak, dStart, dEnd); ok {
+		t.Error("a season of round-zero deaths produced a streak champion")
+	}
+}
+
+// TestRecordArenaSeasonTitleIdempotent: the rollover must be safe to re-run.
+func TestRecordArenaSeasonTitleIdempotent(t *testing.T) {
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+
+	now := time.Date(2026, 7, 1, 0, 0, 0, 0, time.UTC)
+	winner := id.UserID("@winner:test.invalid")
+	usurper := id.UserID("@usurper:test.invalid")
+
+	if err := recordArenaSeasonTitle("2026-Q2", arenaTitleEarnings, winner, 100, now); err != nil {
+		t.Fatal(err)
+	}
+	// A second write for the same (season, kind) must not overwrite the crown.
+	if err := recordArenaSeasonTitle("2026-Q2", arenaTitleEarnings, usurper, 999, now); err != nil {
+		t.Fatal(err)
+	}
+
+	titles, err := loadArenaSeasonTitles(winner)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(titles) != 1 {
+		t.Fatalf("winner has %d titles, want 1", len(titles))
+	}
+	stolen, _ := loadArenaSeasonTitles(usurper)
+	if len(stolen) != 0 {
+		t.Errorf("usurper took the crown: %v", stolen)
+	}
+}

internal/plugin/adventure_arena_test.go

@@ -637,9 +637,9 @@ func TestRenderArenaPersonalStats_WithStats(t *testing.T) {
 }
 
 func TestRenderArenaLeaderboard_Empty(t *testing.T) {
-	text := renderArenaLeaderboard(nil)
-	if !strings.Contains(text, "No arena runs") {
-		t.Error("empty leaderboard should say no runs")
+	text := renderArenaLeaderboard("2026-Q3", nil)
+	if !strings.Contains(text, "Nobody has entered") {
+		t.Error("empty leaderboard should say nobody entered")
 	}
 }
 
@@ -648,7 +648,7 @@ func TestRenderArenaLeaderboard_WithEntries(t *testing.T) {
 		{DisplayName: "Alice", TotalEarnings: 100000, HighestTier: 5, Tier5Completions: 1, TotalRuns: 5, TotalDeaths: 2},
 		{DisplayName: "Bob", TotalEarnings: 50000, HighestTier: 3, TotalRuns: 10, TotalDeaths: 7},
 	}
-	text := renderArenaLeaderboard(entries)
+	text := renderArenaLeaderboard("2026-Q3", entries)
 	if !strings.Contains(text, "Alice") {
 		t.Error("leaderboard should contain Alice")
 	}

internal/plugin/adventure_babysit.go

@@ -36,22 +36,15 @@ func (p *AdventurePlugin) runBabysitDailyTrickle(char *AdventureCharacter) {
 	if !char.BabysitActive {
 		return
 	}
+	// Both companions share the sitter's attention and gain the flat trickle.
+	// (Combat only ever reads their *averaged* procs, so leveling both is not a
+	// power spike.)
 	leveled := false
-	if char.HasPet() && char.PetLevel < 10 {
-		// Bypass petGrantXP's per-action constant — we want a flat trickle.
-		char.PetXP += petXPPerBabysitDay * 100
-		for char.PetLevel < 10 {
-			needed := petXPToNextLevel(char.PetLevel) * 100
-			if char.PetXP < needed {
-				break
-			}
-			char.PetXP -= needed
-			char.PetLevel++
-			leveled = true
-		}
-		if char.PetLevel >= 10 && char.PetLevel10Date == "" {
-			char.PetLevel10Date = time.Now().UTC().Format("2006-01-02")
-		}
+	if char.HasPet() {
+		leveled = advancePetLevelsFromXP(&char.PetXP, &char.PetLevel, &char.PetLevel10Date, petXPPerBabysitDay*100) || leveled
+	}
+	if char.HasPet2() {
+		leveled = advancePetLevelsFromXP(&char.Pet2XP, &char.Pet2Level, &char.Pet2Level10Date, petXPPerBabysitDay*100) || leveled
 	}
 	outcome := "pet_care"
 	if leveled {
@@ -98,7 +91,7 @@ func (p *AdventurePlugin) handleBabysitCmd(ctx MessageContext, args string) erro
 		return p.SendDM(ctx.Sender, "🍼 **Adventurer Babysitting Service**\n\n"+
 			"Hire a babysitter to look after your camp and tend the pet while you sleep:\n"+
 			"  • Daily pet XP trickle (your pet still grows while you focus elsewhere)\n"+
-			"  • Standard camps act like fortified ones — rest deeply, no need for boss-cleared rooms\n"+
+			"  • Standard camps act like fortified ones — rest deeply, no need to have downed the zone boss\n"+
 			"  • Rival duels declined on your behalf\n\n"+
 			"`!adventure babysit week` — 7 days of service\n"+
 			"`!adventure babysit month` — 30 days of service\n"+
@@ -318,15 +311,15 @@ func renderBabysitSummary(char *AdventureCharacter, logs []babysitLogEntry) stri
 // ── Babysit Log CRUD ────────────────────────────────────────────────────────
 
 type babysitLogEntry struct {
-	ID            int64
-	UserID        id.UserID
-	LogDate       string
-	Activity      string
-	Outcome       string
-	GoldEarned    int
-	XPGained      int
-	ItemsDropped  string
-	RivalRefused  string
+	ID           int64
+	UserID       id.UserID
+	LogDate      string
+	Activity     string
+	Outcome      string
+	GoldEarned   int
+	XPGained     int
+	ItemsDropped string
+	RivalRefused string
 }
 
 func logBabysitActivity(userID id.UserID, activity, outcome string, gold, xp int, items string) {

internal/plugin/adventure_babysit_test.go

@@ -66,11 +66,11 @@ func TestRunBabysitDailyTrickle_AccumulatesAndLevels(t *testing.T) {
 	defer func() { _ = recover() }()
 
 	char := &AdventureCharacter{
-		UserID:   id.UserID("@accum:example"),
-		PetType:  "dog",
-		PetName:  "Rex",
-		PetLevel: 1, // needs 10 XP = 1000 centi-XP to L2
-		PetXP:    900,
+		UserID:        id.UserID("@accum:example"),
+		PetType:       "dog",
+		PetName:       "Rex",
+		PetLevel:      1, // needs 10 XP = 1000 centi-XP to L2
+		PetXP:         900,
 		BabysitActive: true,
 	}
 	expires := time.Now().UTC().Add(48 * time.Hour)

internal/plugin/adventure_character.go

@@ -24,32 +24,32 @@ var allSlots = []EquipmentSlot{SlotWeapon, SlotArmor, SlotHelmet, SlotBoots, Slo
 // ── Core Types ───────────────────────────────────────────────────────────────
 
 type AdventureCharacter struct {
-	UserID           id.UserID
-	DisplayName      string
-	CombatLevel      int
-	MiningSkill      int
-	ForagingSkill    int
-	FishingSkill     int // v2
-	CombatXP         int
-	MiningXP         int
-	ForagingXP       int
-	FishingXP        int // v2
-	Alive            bool
-	DeadUntil        *time.Time
-	ActionTakenToday   bool
-	HolidayActionTaken bool
-	CombatActionsUsed  int
-	HarvestActionsUsed int
-	ArenaWins          int // v2
-	ArenaLosses      int    // v2
-	InvasionScore    int    // v2
-	Title            string // v2
-	CurrentStreak    int
-	BestStreak       int
-	LastActionDate   string
-	GrudgeLocation   string
-	CreatedAt        time.Time
-	LastActiveAt     time.Time
+	UserID                  id.UserID
+	DisplayName             string
+	CombatLevel             int
+	MiningSkill             int
+	ForagingSkill           int
+	FishingSkill            int // v2
+	CombatXP                int
+	MiningXP                int
+	ForagingXP              int
+	FishingXP               int // v2
+	Alive                   bool
+	DeadUntil               *time.Time
+	ActionTakenToday        bool
+	HolidayActionTaken      bool
+	CombatActionsUsed       int
+	HarvestActionsUsed      int
+	ArenaWins               int    // v2
+	ArenaLosses             int    // v2
+	InvasionScore           int    // v2
+	Title                   string // v2
+	CurrentStreak           int
+	BestStreak              int
+	LastActionDate          string
+	GrudgeLocation          string
+	CreatedAt               time.Time
+	LastActiveAt            time.Time
 	DeathReprieveLast       *time.Time
 	MasterworkDropsReceived int
 	RivalPool               int
@@ -78,27 +78,46 @@ type AdventureCharacter struct {
 	HouseAutopay        bool
 	HouseCurrentRate    float64
 	// Pets
-	PetType             string
-	PetName             string
-	PetXP               int
-	PetLevel            int
-	PetArmorTier        int
-	PetChasedAway       bool
-	PetReactivated      bool
-	PetArrived          bool
-	MistyEncounterCount int
-	MistyDonatedCount   int
-	ThomAnimalLineFired bool
+	PetType               string
+	PetName               string
+	PetXP                 int
+	PetLevel              int
+	PetArmorTier          int
+	PetChasedAway         bool
+	PetReactivated        bool
+	PetArrived            bool
+	MistyEncounterCount   int
+	MistyDonatedCount     int
+	ThomAnimalLineFired   bool
 	PetSupplyShopUnlocked bool
-	PetLevel10Date      string
-	PetMorningDefense   bool
-	AutoBabysit         bool
-	AutoBabysitFocus    string // mining|fishing|foraging — preferred skill for auto-babysit; "" defaults to weakest
-	TreasuresLocked     bool   // when true, treasure drops at cap are refused instead of auto-swapping
-	StreakDecayed        bool
-	CraftsSucceeded     int
-	DeathSource         string // "adventure" | "arena" | "" (legacy/unknown — treated as adventure)
-	DeathLocation       string // human-readable location of last death; cleared on revive is not required
+	PetLevel10Date        string
+	PetMorningDefense     bool
+	// Second pet (N4/E1, Tier-4 Estate). A parallel slot, not a rewrite of the
+	// pet-1 fields above — see HasPet2. Carries only identity/level/barding; the
+	// morning-defense, ditch-recovery and supply-shop mechanics stay pet-1-only.
+	Pet2Type         string
+	Pet2Name         string
+	Pet2XP           int
+	Pet2Level        int
+	Pet2ArmorTier    int
+	Pet2ChasedAway   bool
+	Pet2Reactivated  bool
+	Pet2Arrived      bool
+	Pet2Level10Date  string
+	AutoBabysit      bool
+	AutoBabysitFocus string // mining|fishing|foraging — preferred skill for auto-babysit; "" defaults to weakest
+	TreasuresLocked  bool   // when true, treasure drops at cap are refused instead of auto-swapping
+	StreakDecayed    bool
+	CraftsSucceeded  int
+	DeathSource      string // "adventure" | "arena" | "" (legacy/unknown — treated as adventure)
+	DeathLocation    string // human-readable location of last death; cleared on revive is not required
+	// N5/D1 the Hollow King campaign. Bitmask of discovered journal pages (bit i
+	// == page i+1). Read-only overlay from player_meta.journal_pages; writes go
+	// through the atomic grantJournalPageDB, never the bulk character save.
+	JournalPages int64
+	// N5/D1c the finale reward-once flag. True after the first finale clear;
+	// overlay-read, written by the atomic markEpilogueClearedDB.
+	EpilogueCleared bool
 }
 
 type AdvEquipment struct {
@@ -121,6 +140,7 @@ type AdvItem struct {
 	Value       int64
 	Slot        EquipmentSlot // non-empty for MasterworkGear
 	SkillSource string        // non-empty for MasterworkGear
+	Temper      int           // rarity steps above base; magic_item rows only
 }
 
 type AdvBuff struct {
@@ -269,6 +289,11 @@ func (c *AdventureCharacter) HasPet() bool {
 	return c.PetType != "" && c.PetArrived && !c.PetChasedAway
 }
 
+// HasPet2 returns true if the player has an active second pet.
+func (c *AdventureCharacter) HasPet2() bool {
+	return c.Pet2Type != "" && c.Pet2Arrived && !c.Pet2ChasedAway
+}
+
 // HasHouse returns true if the player has purchased at least a base house.
 func (c *AdventureCharacter) HasHouse() bool {
 	return c.HouseTier > 0 || c.HouseLoanBalance > 0
@@ -311,7 +336,30 @@ func (c *AdventureCharacter) CanDoHarvest(isHoliday bool) bool {
 }
 
 func (c *AdventureCharacter) HasActedToday() bool {
-	return c.CombatActionsUsed > 0 || c.HarvestActionsUsed > 0
+	if c.CombatActionsUsed > 0 || c.HarvestActionsUsed > 0 {
+		return true
+	}
+	// DnD-side flows (expedition / zone / rest / autopilot) don't touch
+	// the legacy action counters; they credit the day via LastActionDate
+	// instead. Honor that so a player who ran an expedition all day and
+	// extracted before midnight still counts as having acted.
+	return c.LastActionDate == time.Now().UTC().Format("2006-01-02")
+}
+
+// markActedToday stamps the player's LastActionDate to today so the
+// midnight reset credits the day. Safe to call on every DnD-side action;
+// no-ops if the date is already today.
+func markActedToday(userID id.UserID) {
+	today := time.Now().UTC().Format("2006-01-02")
+	c, err := loadAdvCharacter(userID)
+	if err != nil || c == nil {
+		return
+	}
+	if c.LastActionDate == today {
+		return
+	}
+	c.LastActionDate = today
+	_ = saveAdvCharacter(c)
 }
 
 func (c *AdventureCharacter) AllActionsUsed(isHoliday bool) bool {
@@ -537,8 +585,8 @@ func saveAdvEquipment(userID id.UserID, eq *AdvEquipment) error {
 func loadAdvInventory(userID id.UserID) ([]AdvItem, error) {
 	d := db.Get()
 	rows, err := d.Query(`
-		SELECT id, name, item_type, tier, value, slot, skill_source
-		FROM adventure_inventory WHERE user_id = ?
+		SELECT id, name, item_type, tier, value, slot, skill_source, temper
+		FROM adventure_inventory WHERE user_id = ? AND in_vault = 0
 		ORDER BY tier DESC, value DESC`, string(userID))
 	if err != nil {
 		return nil, err
@@ -549,7 +597,7 @@ func loadAdvInventory(userID id.UserID) ([]AdvItem, error) {
 	for rows.Next() {
 		var it AdvItem
 		var slot string
-		if err := rows.Scan(&it.ID, &it.Name, &it.Type, &it.Tier, &it.Value, &slot, &it.SkillSource); err != nil {
+		if err := rows.Scan(&it.ID, &it.Name, &it.Type, &it.Tier, &it.Value, &slot, &it.SkillSource, &it.Temper); err != nil {
 			return nil, err
 		}
 		it.Slot = EquipmentSlot(slot)
@@ -561,9 +609,19 @@ func loadAdvInventory(userID id.UserID) ([]AdvItem, error) {
 func addAdvInventoryItem(userID id.UserID, item AdvItem) error {
 	d := db.Get()
 	_, err := d.Exec(`
-		INSERT INTO adventure_inventory (user_id, name, item_type, tier, value, slot, skill_source)
-		VALUES (?, ?, ?, ?, ?, ?, ?)`,
-		string(userID), item.Name, item.Type, item.Tier, item.Value, string(item.Slot), item.SkillSource)
+		INSERT INTO adventure_inventory (user_id, name, item_type, tier, value, slot, skill_source, temper)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+		string(userID), item.Name, item.Type, item.Tier, item.Value, string(item.Slot), item.SkillSource, item.Temper)
+	return err
+}
+
+// temperInventoryItem records a tempering step on an un-equipped magic item.
+// Tier and value move with the item's new effective rarity so it keeps sorting
+// and selling correctly.
+func temperInventoryItem(itemID int64, temper, tier int, value int64) error {
+	_, err := db.Get().Exec(
+		`UPDATE adventure_inventory SET temper = ?, tier = ?, value = ? WHERE id = ?`,
+		temper, tier, value, itemID)
 	return err
 }
 
@@ -579,7 +637,10 @@ func clearAdvInventory(userID id.UserID) ([]AdvItem, error) {
 		return nil, err
 	}
 	d := db.Get()
-	_, err = d.Exec(`DELETE FROM adventure_inventory WHERE user_id = ?`, string(userID))
+	// Delete only what loadAdvInventory returned — vaulted rows are out of play
+	// and must survive a bulk clear, or the vault's whole promise (safe from
+	// !sell all) breaks the moment any caller routes sell-all through here.
+	_, err = d.Exec(`DELETE FROM adventure_inventory WHERE user_id = ? AND in_vault = 0`, string(userID))
 	if err != nil {
 		return nil, err
 	}
@@ -589,10 +650,62 @@ func clearAdvInventory(userID id.UserID) ([]AdvItem, error) {
 func advInventoryCount(userID id.UserID) int {
 	d := db.Get()
 	var count int
-	_ = d.QueryRow(`SELECT COUNT(*) FROM adventure_inventory WHERE user_id = ?`, string(userID)).Scan(&count)
+	_ = d.QueryRow(`SELECT COUNT(*) FROM adventure_inventory WHERE user_id = ? AND in_vault = 0`, string(userID)).Scan(&count)
 	return count
 }
 
+// loadAdvVault returns the items the player has stowed in their housing vault
+// (N4/E1). These are excluded from loadAdvInventory — a vaulted item is out of
+// play (unsellable, uncraftable, unusable in combat) until it is taken back.
+func loadAdvVault(userID id.UserID) ([]AdvItem, error) {
+	d := db.Get()
+	rows, err := d.Query(`
+		SELECT id, name, item_type, tier, value, slot, skill_source, temper
+		FROM adventure_inventory WHERE user_id = ? AND in_vault = 1
+		ORDER BY tier DESC, value DESC`, string(userID))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var items []AdvItem
+	for rows.Next() {
+		var it AdvItem
+		var slot string
+		if err := rows.Scan(&it.ID, &it.Name, &it.Type, &it.Tier, &it.Value, &slot, &it.SkillSource, &it.Temper); err != nil {
+			return nil, err
+		}
+		it.Slot = EquipmentSlot(slot)
+		items = append(items, it)
+	}
+	return items, rows.Err()
+}
+
+// advVaultCount returns how many of a user's items are stowed in the vault.
+func advVaultCount(userID id.UserID) int {
+	d := db.Get()
+	var count int
+	_ = d.QueryRow(`SELECT COUNT(*) FROM adventure_inventory WHERE user_id = ? AND in_vault = 1`, string(userID)).Scan(&count)
+	return count
+}
+
+// setItemVaulted flips a single inventory row's vault flag. Scoped to the
+// owning user so a mistyped id can never move another player's item.
+func setItemVaulted(userID id.UserID, itemID int64, vaulted bool) (bool, error) {
+	v := 0
+	if vaulted {
+		v = 1
+	}
+	res, err := db.Get().Exec(
+		`UPDATE adventure_inventory SET in_vault = ? WHERE id = ? AND user_id = ?`,
+		v, itemID, string(userID))
+	if err != nil {
+		return false, err
+	}
+	n, _ := res.RowsAffected()
+	return n > 0, nil
+}
+
 func loadAllAdvCharacters() ([]AdventureCharacter, error) {
 	d := db.Get()
 	rows, err := d.Query(`SELECT user_id FROM player_meta`)

internal/plugin/adventure_consumables.go

@@ -17,26 +17,26 @@ import (
 type ConsumableEffect string
 
 const (
-	EffectHeal      ConsumableEffect = "heal"
-	EffectDefBoost  ConsumableEffect = "def_boost"
-	EffectAtkBoost  ConsumableEffect = "atk_boost"
-	EffectWard      ConsumableEffect = "ward"
+	EffectHeal       ConsumableEffect = "heal"
+	EffectDefBoost   ConsumableEffect = "def_boost"
+	EffectAtkBoost   ConsumableEffect = "atk_boost"
+	EffectWard       ConsumableEffect = "ward"
 	EffectSpeedBoost ConsumableEffect = "speed_boost"
-	EffectCritBoost ConsumableEffect = "crit_boost"
-	EffectFlatDmg   ConsumableEffect = "flat_dmg"
-	EffectSpore     ConsumableEffect = "spore"
-	EffectReflect   ConsumableEffect = "reflect"
-	EffectAutoCrit  ConsumableEffect = "auto_crit"
+	EffectCritBoost  ConsumableEffect = "crit_boost"
+	EffectFlatDmg    ConsumableEffect = "flat_dmg"
+	EffectSpore      ConsumableEffect = "spore"
+	EffectReflect    ConsumableEffect = "reflect"
+	EffectAutoCrit   ConsumableEffect = "auto_crit"
 )
 
 type ConsumableDef struct {
-	Name     string
-	Effect   ConsumableEffect
-	Value    float64 // meaning depends on effect
-	Tier     int
-	Buyable  bool
-	Price    int64
-	Slot     string // "offensive" or "defensive"
+	Name    string
+	Effect  ConsumableEffect
+	Value   float64 // meaning depends on effect
+	Tier    int
+	Buyable bool
+	Price   int64
+	Slot    string // "offensive" or "defensive"
 }
 
 // ConsumableItem is an AdvItem that has consumable properties.
@@ -234,8 +234,13 @@ func RollConsumableDrop(activity AdvActivityType, tier int) *AdvItem {
 	if rand.Float64() >= 0.15 {
 		return nil
 	}
-	name := names[rand.IntN(len(names))]
-	def := consumableDefByName(name)
+	return consumableAdvItem(consumableDefByName(names[rand.IntN(len(names))]))
+}
+
+// consumableAdvItem builds the inventory row for a consumable def. Drop-only
+// consumables carry no shop price, so their sell value falls back to a
+// per-tier baseline.
+func consumableAdvItem(def *ConsumableDef) *AdvItem {
 	if def == nil {
 		return nil
 	}
@@ -252,6 +257,23 @@ func RollConsumableDrop(activity AdvActivityType, tier int) *AdvItem {
 	}
 }
 
+// consumableCache draws n consumables from the dungeon drop pool at `tier`,
+// used by guaranteed grants (milestone caches) rather than the drop roll.
+// Tier 1 has no dungeon pool, so it yields the buyable Berry Poultice.
+func consumableCache(tier, n int) []AdvItem {
+	names := consumableDropTable[AdvActivityDungeon][tier]
+	if len(names) == 0 {
+		names = []string{"Berry Poultice"}
+	}
+	out := make([]AdvItem, 0, n)
+	for range n {
+		if item := consumableAdvItem(consumableDefByName(names[rand.IntN(len(names))])); item != nil {
+			out = append(out, *item)
+		}
+	}
+	return out
+}
+
 // BuyableConsumables returns all consumable defs that can be purchased from the shop.
 func BuyableConsumables() []ConsumableDef {
 	var result []ConsumableDef
@@ -324,15 +346,34 @@ var craftingRecipes = []CraftingRecipe{
 	{Result: "Voidstone Shard", Ingredients: []string{"Voidstone", "Mythril Ore"}, MinForaging: 30, Tier: 5},
 }
 
-// craftingSuccessRate returns the success chance for a recipe given foraging level.
-// Base rate is 50% at minimum level, +3% per 5 levels above minimum, capped at 95%.
-func craftingSuccessRate(foragingLevel, minForaging int) float64 {
+// houseTierWorkshop is the T3 "Comfortable" house that unlocks the workshop —
+// a flat craft-success bonus while crafting at home.
+const houseTierWorkshop = 3
+
+// homeWorkshopCraftBonus returns the additive craft-success bonus from a T3+
+// home workshop. Tier 1/2 and no house grant none.
+func homeWorkshopCraftBonus(houseTier int) float64 {
+	if houseTier >= houseTierWorkshop {
+		return 0.05
+	}
+	return 0
+}
+
+// craftingSuccessRate returns the success chance for a recipe given foraging
+// level. Base rate is 50% at minimum level, +3% per 5 levels above minimum,
+// capped at 95%. A T3+ home workshop adds workshopBonus on top and lifts the
+// cap to 98%, so a maxed forager still gains a little from the bench.
+func craftingSuccessRate(foragingLevel, minForaging int, workshopBonus float64) float64 {
 	base := 0.50
 	levelsAbove := foragingLevel - minForaging
 	bonus := float64(levelsAbove) / 5.0 * 0.03
-	rate := base + bonus
-	if rate > 0.95 {
-		return 0.95
+	rate := base + bonus + workshopBonus
+	cap := 0.95
+	if workshopBonus > 0 {
+		cap = 0.98
+	}
+	if rate > cap {
+		return cap
 	}
 	return rate
 }
@@ -347,7 +388,7 @@ type CraftResult struct {
 // their current foraging level, plus a teaser line for the next unlock
 // threshold. Hides exact ingredient lists for recipes the player hasn't
 // unlocked — only the count of locked recipes is shown.
-func renderRecipesKnown(foragingLevel int) string {
+func renderRecipesKnown(foragingLevel int, workshopBonus float64) string {
 	var sb strings.Builder
 	sb.WriteString(fmt.Sprintf("🧪 **Crafting Recipes** — Foraging Lv.%d\n\n", foragingLevel))
 
@@ -355,6 +396,9 @@ func renderRecipesKnown(foragingLevel int) string {
 		sb.WriteString("_Auto-crafting unlocks at Foraging Lv.10. Keep gathering._")
 		return sb.String()
 	}
+	if workshopBonus > 0 {
+		sb.WriteString(fmt.Sprintf("_🔨 Home workshop: +%.0f%% craft success._\n\n", workshopBonus*100))
+	}
 
 	// Group recipes by tier, list those known.
 	known := map[int][]CraftingRecipe{}
@@ -380,7 +424,7 @@ func renderRecipesKnown(foragingLevel int) string {
 		}
 		sb.WriteString(fmt.Sprintf("**Tier %d** (Foraging %d+)\n", tier, recipes[0].MinForaging))
 		for _, r := range recipes {
-			rate := craftingSuccessRate(foragingLevel, r.MinForaging) * 100
+			rate := craftingSuccessRate(foragingLevel, r.MinForaging, workshopBonus) * 100
 			sb.WriteString(fmt.Sprintf("  • %s — %s (%.0f%% success)\n",
 				r.Result, strings.Join(r.Ingredients, " + "), rate))
 		}
@@ -411,7 +455,7 @@ var craftXPFailure = map[int]int{1: 3, 2: 5, 3: 8, 4: 12, 5: 18}
 //
 // Side effects: grants foraging XP per attempt (success > failure) and bumps
 // the player's CraftsSucceeded counter on each success.
-func autoCraftConsumables(userID id.UserID, items []AdvItem, foragingLevel int) ([]CraftResult, []AdvItem) {
+func autoCraftConsumables(userID id.UserID, items []AdvItem, foragingLevel int, workshopBonus float64) ([]CraftResult, []AdvItem) {
 	if foragingLevel < 10 {
 		return nil, items
 	}
@@ -430,7 +474,7 @@ func autoCraftConsumables(userID id.UserID, items []AdvItem, foragingLevel int)
 			break
 		}
 
-		rate := craftingSuccessRate(foragingLevel, bestRecipe.MinForaging)
+		rate := craftingSuccessRate(foragingLevel, bestRecipe.MinForaging, workshopBonus)
 		success := rand.Float64() < rate
 
 		if success {

internal/plugin/adventure_duel.go

@@ -0,0 +1,701 @@
+package plugin
+
+// C2 — player-initiated duels (engagement plan N6).
+//
+// `!duel @user [stake]` — a staked, no-death arena bout between two real
+// characters, resolved through the auto-resolve combat engine. Both players
+// escrow the stake on accept; the winner takes 70% of the pooled 2×stake and
+// the community pot rakes the remaining 30% (a real pot sink). Records land in
+// adventure_rival_records, so one W/L history and one 7-day per-pair cooldown
+// covers both duel kinds (the bot-driven RPS rival and this).
+//
+// Why this is a wrapper and not a combat-engine change: the turn engine is an
+// N-players-vs-1-monster model — there is no seat for a second real character
+// on the enemy side (see the C2 feasibility note in the engagement plan). So a
+// duel does not seat two PCs against each other. Instead each fighter is built
+// as their real player Combatant (full kit: weapon, subclass passives, extra
+// attacks, race traits) and the *opponent* is synthesised as a monster-shaped
+// enemy stat block from their own sheet. That is asymmetric — the "player" side
+// runs its full kit while the synthesised enemy is a flat stat block — so a
+// single bout would systematically favour whoever is the attacker. The duel
+// runs the bout in BOTH orientations and decides on the aggregate HP margin,
+// which cancels that edge symmetrically. To-hit is faithful either way (both
+// sides roll d20 + AttackBonus vs AC); only damage-per-hit is folded into the
+// synthesised enemy's flat Attack. Class-vs-class PvP balance is explicitly out
+// of scope (bragging rights, capped stakes).
+
+import (
+	"fmt"
+	"math"
+	"math/rand/v2"
+	"strings"
+	"time"
+
+	"gogobee/internal/db"
+
+	"github.com/google/uuid"
+	"maunium.net/go/mautrix/id"
+)
+
+const (
+	duelMinLevel     = 3              // both duellists must be at least this level
+	duelAcceptWindow = 24 * time.Hour // an unanswered challenge expires and refunds
+	duelStakePerLvl  = 500            // stake cap = challenger level × this
+	duelMinStake     = 100            // floor so a "duel" always has something on it
+	duelWinnerPct    = 0.70           // winner's cut of the pooled 2×stake; pot rakes the rest
+)
+
+// advDuelChallenge is one outstanding duel invitation. Unlike the RPS rival
+// challenge it carries no per-round score — a combat duel resolves in a single
+// step on accept. The challenger's stake is already escrowed (debited) when the
+// row exists; the challenged player's is debited on accept.
+type advDuelChallenge struct {
+	ChallengeID  string
+	ChallengerID id.UserID
+	ChallengedID id.UserID
+	Stake        int
+	ExpiresAt    time.Time
+	CreatedAt    time.Time
+}
+
+// ── Persistence ──────────────────────────────────────────────────────────────
+
+func insertDuelChallenge(c *advDuelChallenge) {
+	db.Exec("duel: insert challenge",
+		`INSERT INTO adventure_duel_challenges
+		 (challenge_id, challenger_id, challenged_id, stake, expires_at)
+		 VALUES (?, ?, ?, ?, ?)`,
+		c.ChallengeID, string(c.ChallengerID), string(c.ChallengedID), c.Stake, c.ExpiresAt,
+	)
+}
+
+func deleteDuelChallenge(challengeID string) {
+	db.Exec("duel: delete challenge",
+		`DELETE FROM adventure_duel_challenges WHERE challenge_id = ?`, challengeID)
+}
+
+// claimDuelChallenge atomically deletes the row and reports whether THIS caller
+// is the one that removed it. It is the single serialization point for a
+// challenge's terminal fate: accept, decline and the expiry ticker all race to
+// claim it, and exactly one wins. Only the winner moves euros — that is what
+// stops a stake being both resolved and refunded across the 24h boundary, or a
+// double `!duel decline` double-refunding. Mirrors communityPotDebit's
+// RowsAffected gate.
+func claimDuelChallenge(challengeID string) bool {
+	res := db.ExecResult("duel: claim challenge",
+		`DELETE FROM adventure_duel_challenges WHERE challenge_id = ?`, challengeID)
+	if res == nil {
+		return false
+	}
+	n, _ := res.RowsAffected()
+	return n == 1
+}
+
+func scanDuelChallenge(row interface{ Scan(...any) error }) (*advDuelChallenge, error) {
+	c := &advDuelChallenge{}
+	err := row.Scan(&c.ChallengeID, &c.ChallengerID, &c.ChallengedID, &c.Stake, &c.ExpiresAt, &c.CreatedAt)
+	if err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+
+// pendingDuelForChallenged returns the live (unexpired) challenge awaiting this
+// player's answer, or nil. Expired rows are ignored here and swept by the
+// ticker, so a player is never shown a challenge they can no longer accept.
+func pendingDuelForChallenged(userID id.UserID) *advDuelChallenge {
+	c := &advDuelChallenge{}
+	err := db.Get().QueryRow(`
+		SELECT challenge_id, challenger_id, challenged_id, stake, expires_at, created_at
+		FROM adventure_duel_challenges
+		WHERE challenged_id = ? AND expires_at > CURRENT_TIMESTAMP
+		ORDER BY created_at DESC LIMIT 1`, string(userID)).Scan(
+		&c.ChallengeID, &c.ChallengerID, &c.ChallengedID, &c.Stake, &c.ExpiresAt, &c.CreatedAt)
+	if err != nil {
+		return nil
+	}
+	return c
+}
+
+// duelInvolves reports whether the player has any live challenge in flight, as
+// challenger or challenged. Used to enforce one duel at a time per player — the
+// escrow makes overlapping challenges a way to double-commit the same euros.
+func duelInvolves(userID id.UserID) bool {
+	var n int
+	db.Get().QueryRow(`
+		SELECT COUNT(*) FROM adventure_duel_challenges
+		WHERE (challenger_id = ? OR challenged_id = ?) AND expires_at > CURRENT_TIMESTAMP`,
+		string(userID), string(userID)).Scan(&n)
+	return n > 0
+}
+
+func loadExpiredDuelChallenges() []advDuelChallenge {
+	rows, err := db.Get().Query(`
+		SELECT challenge_id, challenger_id, challenged_id, stake, expires_at, created_at
+		FROM adventure_duel_challenges WHERE expires_at <= CURRENT_TIMESTAMP`)
+	if err != nil {
+		return nil
+	}
+	defer rows.Close()
+	var out []advDuelChallenge
+	for rows.Next() {
+		if c, err := scanDuelChallenge(rows); err == nil {
+			out = append(out, *c)
+		}
+	}
+	return out
+}
+
+// ── Stake / gating ───────────────────────────────────────────────────────────
+
+// duelMaxStake caps the stake at level × duelStakePerLvl so a strong player
+// can't farm a runaway pot off a weaker one, per the plan's imbalance cap.
+func duelMaxStake(level int) int { return level * duelStakePerLvl }
+
+// duelPayout splits the pooled 2×stake: the winner takes duelWinnerPct, the
+// community pot rakes the remainder. Both fighters escrowed stake, so the
+// winner's net gain is winnerShare − stake and the pot is a real sink.
+func duelPayout(stake int) (winnerShare, potShare int) {
+	pool := stake * 2
+	winnerShare = int(math.Round(float64(pool) * duelWinnerPct))
+	potShare = pool - winnerShare
+	return
+}
+
+// duelEligible reports whether a character can duel at all: alive, set up, and
+// at least duelMinLevel. Returns a player-facing reason when it can't.
+func (p *AdventurePlugin) duelEligible(char *AdventureCharacter) (int, string) {
+	if char == nil {
+		return 0, "no adventurer"
+	}
+	if !char.Alive {
+		return 0, "dead"
+	}
+	lvl := rivalLevelForUser(char)
+	if lvl < duelMinLevel {
+		return lvl, fmt.Sprintf("below level %d", duelMinLevel)
+	}
+	return lvl, ""
+}
+
+// ── Combat synthesis ─────────────────────────────────────────────────────────
+
+// buildDuelist derives a fighter's full player Combatant — the same build a
+// zone encounter uses, so weapon, subclass passives, extra attacks and race
+// traits all apply — then resets it to full health. A duel is a fresh arena
+// bout, not a continuation of a wounded expedition, so wound carry-over is
+// dropped (StartHP=0 = "enter at MaxHP"). Mood 50 is the neutral band: no
+// initiative bias, no enemy-attack tilt.
+//
+// The armed-ability slot is left empty: actively-armed one-shots (a Berserker's
+// rage) don't fire, but always-on passives (Extra Attack, Sneak Attack, Divine
+// Strike, race traits) still layer in via the class/subclass passive builders.
+func (p *AdventurePlugin) buildDuelist(userID id.UserID) (Combatant, error) {
+	var noMonster DnDMonsterTemplate
+	player, _, _, err := p.buildZoneCombatants(userID, noMonster, 1, 50, "")
+	if err != nil {
+		return Combatant{}, err
+	}
+	player.Stats.StartHP = 0
+	return player, nil
+}
+
+// duelPerHitDamage is a fighter's expected damage on a single landed hit, used
+// to size the flat Attack of their synthesised enemy stat block. It mirrors the
+// player damage path's terms that the enemy path can't express: weapon dice
+// average (or the legacy flat Attack for a weaponless build), the always-on
+// per-hit riders (Divine Strike, Sneak Attack, Hunter's Mark, rage), then the
+// multiplicative damage bonus. Crit chance and once-per-fight openers are not
+// modelled — a coarse mean is enough for a capped-stakes bout decided over two
+// orientations.
+func duelPerHitDamage(pc Combatant) float64 {
+	base := float64(pc.Stats.Attack)
+	if w := pc.Stats.Weapon; w != nil {
+		if pc.Stats.TwoHandedMode && w.HasProperty(PropVersatile) && w.VersaCount > 0 {
+			base = float64(w.VersaCount)*(float64(w.VersaSides)+1)/2 +
+				float64(pc.Stats.AbilityModForDamage) + float64(w.MagicBonus)
+		} else {
+			base = avgWeaponDamage(w, pc.Stats.AbilityModForDamage)
+		}
+	}
+	riders := float64(pc.Mods.DivineStrikePerHit)
+	riders += float64(pc.Mods.SneakAttackDie) * 3.5
+	riders += float64(pc.Mods.HuntersMarkDie) * 3.5
+	if pc.Mods.BerserkerRage {
+		riders += float64(pc.Mods.RageMeleeDmg)
+	}
+	perHit := (base + riders) * (1 + pc.Mods.DamageBonus)
+	if perHit < 1 {
+		perHit = 1
+	}
+	return perHit
+}
+
+// duelPerRoundProcDamage is the expected per-round damage from a fighter's
+// companion strikes — a Cleric's spiritual weapon and a Beastmaster's pet —
+// which land once per round on a proc roll rather than per weapon hit. The live
+// fighter rolls these natively in the engine; folding their expectation into the
+// synth enemy's round damage keeps both orientations comparable for those
+// builds (each formula is Dmg + d5, mean +3).
+func duelPerRoundProcDamage(pc Combatant) float64 {
+	dmg := pc.Mods.SpiritWeaponProc * (float64(pc.Mods.SpiritWeaponDmg) + 3)
+	dmg += pc.Mods.PetAttackProc * (float64(pc.Mods.PetAttackDmg) + 3)
+	return dmg
+}
+
+// synthDuelEnemy turns a fighter's player Combatant into the monster-shaped
+// enemy the opposite fighter faces. HP, AC and AttackBonus carry over verbatim
+// (to-hit stays faithful — the enemy rolls d20 + AttackBonus vs the attacker's
+// AC exactly as the player does). DamageReduct carries over too, so a
+// Barbarian's / Monk's flat mitigation is as tanky as the enemy as it is as the
+// live PC. Offense is the lossy term: the enemy path deals a flat Attack, so a
+// whole round — weapon swings (per-hit × (1 + extra attacks)) plus the expected
+// companion-strike damage — is folded into one enemy Attack, preserving expected
+// round damage while widening variance (a wash across the two orientations).
+//
+// Deliberately NOT modelled on the enemy side (accepted scope — the plan frames
+// duels as bragging rights and puts class-vs-class PvP balance explicitly out of
+// scope): reactive one-shots the enemy engine has no channel for — heal items,
+// wards, the Sovereign death-save, the arcane ward buffer — and spell damage,
+// which buildZoneCombatants never wires for the live caster either, so a caster
+// fights weapon-only in both orientations. Defense is dropped: the weapon-damage
+// path players use reads DamageReduct, not the enemy's Defense stat.
+func synthDuelEnemy(pc Combatant) Combatant {
+	swings := 1 + pc.Mods.ExtraAttacks
+	roundDmg := duelPerHitDamage(pc)*float64(swings) + duelPerRoundProcDamage(pc)
+	return Combatant{
+		Name:     pc.Name,
+		IsPlayer: false,
+		Stats: CombatStats{
+			MaxHP:       pc.Stats.MaxHP,
+			AC:          pc.Stats.AC,
+			AttackBonus: pc.Stats.AttackBonus,
+			Attack:      int(math.Round(roundDmg)),
+		},
+		Mods: CombatModifiers{DamageReduct: pc.Mods.DamageReduct},
+	}
+}
+
+// duelResult is the two-orientation verdict. challengerMargin/challengedMargin
+// are aggregate remaining-HP fractions across both bouts (0..2 each); the higher
+// wins. decisive is true when one fighter won both orientations outright — pure
+// narration, the margin is what decides.
+type duelResult struct {
+	challengerWins bool
+	draw           bool
+	decisive       bool
+	challengerFrac float64
+	challengedFrac float64
+}
+
+func hpFraction(end, start int) float64 {
+	if start <= 0 {
+		return 0
+	}
+	if end < 0 {
+		end = 0
+	}
+	return float64(end) / float64(start)
+}
+
+// resolveDuel runs the bout both ways and decides on the aggregate HP margin.
+// Orientation 1 seats the challenger as the live fighter against the challenged
+// player's stat block; orientation 2 swaps them. Each fighter's margin sums the
+// HP fraction they kept as the live fighter in one bout and as the stat block in
+// the other, so the attacker's-kit advantage is applied to both fighters once
+// and cancels. rng is threaded for the seeded characterization/unit tests; nil
+// is production (package-global RNG).
+func resolveDuel(challenger, challenged Combatant, rng *rand.Rand) duelResult {
+	r1 := simulateCombatWithRNG(challenger, synthDuelEnemy(challenged), defaultCombatPhases, rng)
+	r2 := simulateCombatWithRNG(challenged, synthDuelEnemy(challenger), defaultCombatPhases, rng)
+
+	cFrac := hpFraction(r1.PlayerEndHP, r1.PlayerStartHP) + hpFraction(r2.EnemyEndHP, r2.EnemyStartHP)
+	dFrac := hpFraction(r1.EnemyEndHP, r1.EnemyStartHP) + hpFraction(r2.PlayerEndHP, r2.PlayerStartHP)
+
+	res := duelResult{challengerFrac: cFrac, challengedFrac: dFrac}
+	switch {
+	case cFrac > dFrac:
+		res.challengerWins = true
+	case dFrac > cFrac:
+		res.challengerWins = false
+	default:
+		res.draw = true
+	}
+	// Decisive = the winner also took both orientations outright.
+	if !res.draw {
+		if res.challengerWins {
+			res.decisive = r1.PlayerWon && !r2.PlayerWon
+		} else {
+			res.decisive = r2.PlayerWon && !r1.PlayerWon
+		}
+	}
+	return res
+}
+
+// ── Command surface ──────────────────────────────────────────────────────────
+
+func (p *AdventurePlugin) handleDuelCmd(ctx MessageContext, args string) error {
+	args = strings.TrimSpace(args)
+	fields := strings.Fields(args)
+	if len(fields) == 0 {
+		return p.SendReply(ctx.RoomID, ctx.EventID,
+			"⚔️ **Duels** — challenge another adventurer to a staked, no-death bout.\n"+
+				"`!duel @user [stake]` — throw down · `!duel accept` / `!duel decline` · `!duel status`")
+	}
+	switch strings.ToLower(fields[0]) {
+	case "accept":
+		return p.acceptDuel(ctx)
+	case "decline":
+		return p.declineDuel(ctx)
+	case "status":
+		return p.duelStatusCmd(ctx)
+	default:
+		return p.issueDuel(ctx, fields)
+	}
+}
+
+func (p *AdventurePlugin) issueDuel(ctx MessageContext, fields []string) error {
+	targetID, ok := p.ResolveUser(fields[0], ctx.RoomID)
+	if !ok {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "Could not resolve that user. Usage: `!duel @user [stake]`")
+	}
+	if targetID == ctx.Sender {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "You can't duel yourself.")
+	}
+
+	// Serialise the one-duel gate, balance check and escrow so two rapid `!duel`
+	// from the same challenger can't both pass duelInvolves and double-debit.
+	lock := p.advUserLock(ctx.Sender)
+	lock.Lock()
+	defer lock.Unlock()
+
+	challenger, err := loadAdvCharacter(ctx.Sender)
+	if err != nil || challenger == nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "You have no adventurer. Type `!adventure` to create one.")
+	}
+	lvl, reason := p.duelEligible(challenger)
+	if reason != "" {
+		return p.SendReply(ctx.RoomID, ctx.EventID, duelIneligibleSelf(reason))
+	}
+
+	challenged, err := loadAdvCharacter(targetID)
+	if err != nil || challenged == nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, fmt.Sprintf("%s has no adventurer to duel.", p.DisplayName(targetID)))
+	}
+	if _, reason := p.duelEligible(challenged); reason != "" {
+		return p.SendReply(ctx.RoomID, ctx.EventID,
+			fmt.Sprintf("%s can't duel right now (%s).", p.DisplayName(targetID), reason))
+	}
+	if challenged.BabysitActive {
+		return p.SendReply(ctx.RoomID, ctx.EventID,
+			fmt.Sprintf("%s left word with the Babysitting Service — no duels while they're away.", p.DisplayName(targetID)))
+	}
+
+	// One duel at a time per player, either side — the escrow makes overlaps a
+	// double-commit of the same euros.
+	if duelInvolves(ctx.Sender) {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "You already have a duel in flight. Resolve it first.")
+	}
+	if duelInvolves(targetID) {
+		return p.SendReply(ctx.RoomID, ctx.EventID, fmt.Sprintf("%s already has a duel in flight.", p.DisplayName(targetID)))
+	}
+
+	// Shared 7-day per-pair cooldown across both duel kinds (records table).
+	if last := lastDuelBetween(ctx.Sender, targetID); !last.IsZero() && time.Since(last) < rivalSamePairCooldown {
+		wait := rivalSamePairCooldown - time.Since(last)
+		return p.SendReply(ctx.RoomID, ctx.EventID,
+			fmt.Sprintf("You've dueled %s too recently. Try again %s.", p.DisplayName(targetID), formatDuration(wait)))
+	}
+
+	stake, err := p.parseDuelStake(fields, lvl)
+	if err != nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, err.Error())
+	}
+	if bal := p.euro.GetBalance(ctx.Sender); int(bal) < stake {
+		return p.SendReply(ctx.RoomID, ctx.EventID,
+			fmt.Sprintf("You can't cover a €%d stake — you have €%d.", stake, int(bal)))
+	}
+
+	// Escrow the challenger's stake now (debited to nowhere; the pot/winner split
+	// redistributes it on resolution, and expiry/decline refunds it).
+	if !p.euro.Debit(ctx.Sender, float64(stake), "duel_escrow") {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "Couldn't hold your stake. Try again.")
+	}
+
+	ch := &advDuelChallenge{
+		ChallengeID:  uuid.NewString(),
+		ChallengerID: ctx.Sender,
+		ChallengedID: targetID,
+		Stake:        stake,
+		ExpiresAt:    time.Now().UTC().Add(duelAcceptWindow),
+	}
+	insertDuelChallenge(ch)
+
+	p.SendDM(targetID, fmt.Sprintf(
+		"⚔️ **%s challenges you to a duel!**\n\nStake: €%d each — winner takes 70%% of the pot.\n"+
+			"No death, no hospital bill. Just bragging rights.\n\n`!duel accept` or `!duel decline` — you have 24 hours.",
+		p.DisplayName(ctx.Sender), stake))
+
+	return p.SendReply(ctx.RoomID, ctx.EventID, fmt.Sprintf(
+		"⚔️ You throw down the gauntlet before **%s** for €%d. They have 24 hours to answer.",
+		p.DisplayName(targetID), stake))
+}
+
+// parseDuelStake reads the optional stake argument, defaulting to the cap for
+// the challenger's level and clamping into [duelMinStake, duelMaxStake].
+func (p *AdventurePlugin) parseDuelStake(fields []string, level int) (int, error) {
+	maxStake := duelMaxStake(level)
+	if len(fields) < 2 {
+		return maxStake, nil
+	}
+	raw := strings.TrimPrefix(fields[1], "€")
+	stake := 0
+	if _, err := fmt.Sscanf(raw, "%d", &stake); err != nil || stake <= 0 {
+		return 0, fmt.Errorf("that's not a valid stake. Usage: `!duel @user [stake]`")
+	}
+	if stake < duelMinStake {
+		return 0, fmt.Errorf("minimum stake is €%d", duelMinStake)
+	}
+	if stake > maxStake {
+		return 0, fmt.Errorf("your stake is capped at €%d (level %d × €%d)", maxStake, level, duelStakePerLvl)
+	}
+	return stake, nil
+}
+
+func (p *AdventurePlugin) acceptDuel(ctx MessageContext) error {
+	// Serialise a player's own accept so a double-submit can't debit twice.
+	lock := p.advUserLock(ctx.Sender)
+	lock.Lock()
+	defer lock.Unlock()
+
+	ch := pendingDuelForChallenged(ctx.Sender)
+	if ch == nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "You have no pending duel to accept.")
+	}
+	// Cheap validation first — these leave the challenge open (the player can
+	// revive/earn and retry, or decline to release the challenger's escrow).
+	challenged, err := loadAdvCharacter(ctx.Sender)
+	if err != nil || challenged == nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "You have no adventurer.")
+	}
+	if _, reason := p.duelEligible(challenged); reason != "" {
+		return p.SendReply(ctx.RoomID, ctx.EventID, duelIneligibleSelf(reason))
+	}
+	if bal := p.euro.GetBalance(ctx.Sender); int(bal) < ch.Stake {
+		return p.SendReply(ctx.RoomID, ctx.EventID,
+			fmt.Sprintf("You can't cover the €%d stake — you have €%d. `!duel decline` to back out.", ch.Stake, int(bal)))
+	}
+
+	// The challenger may have died or dropped below the gate during the 24h
+	// window. If so, cancel the duel: claim the row (so the ticker/decline can't
+	// also refund) and hand the challenger their escrow back.
+	challenger, cerr := loadAdvCharacter(ch.ChallengerID)
+	if cerr != nil || challenger == nil {
+		if claimDuelChallenge(ch.ChallengeID) {
+			p.euro.Credit(ch.ChallengerID, float64(ch.Stake), "duel_refund_challenger_gone")
+		}
+		return p.SendReply(ctx.RoomID, ctx.EventID, "Your challenger is no longer available. The duel is off.")
+	}
+	if _, reason := p.duelEligible(challenger); reason != "" {
+		if claimDuelChallenge(ch.ChallengeID) {
+			p.euro.Credit(ch.ChallengerID, float64(ch.Stake), "duel_refund_challenger_ineligible")
+			p.SendDM(ch.ChallengerID, fmt.Sprintf(
+				"⚔️ Your duel with **%s** was called off — you can't fight right now. Your €%d stake is refunded.",
+				p.DisplayName(ctx.Sender), ch.Stake))
+		}
+		return p.SendReply(ctx.RoomID, ctx.EventID,
+			fmt.Sprintf("**%s** can't duel right now (%s). The challenge is off.", p.DisplayName(ch.ChallengerID), reason))
+	}
+
+	// Build both fighters BEFORE debiting the challenged player, so the deep
+	// sheet-loading / combat code (the panic-prone part) runs while nobody but
+	// the challenger is committed. A build failure refunds only the challenger.
+	challengerC, err1 := p.buildDuelist(ch.ChallengerID)
+	challengedC, err2 := p.buildDuelist(ctx.Sender)
+	if err1 != nil || err2 != nil {
+		if claimDuelChallenge(ch.ChallengeID) {
+			p.euro.Credit(ch.ChallengerID, float64(ch.Stake), "duel_refund_error")
+		}
+		return p.SendReply(ctx.RoomID, ctx.EventID, "The duel couldn't be staged. The challenger's stake is refunded.")
+	}
+
+	// Commit: claim the row (exactly one path wins), then take the challenged
+	// player's stake. From here both stakes are held and resolution is pure
+	// arithmetic — no further build or DB read that could panic mid-payout.
+	if !claimDuelChallenge(ch.ChallengeID) {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "That duel is no longer available.")
+	}
+	if !p.euro.Debit(ctx.Sender, float64(ch.Stake), "duel_escrow") {
+		p.euro.Credit(ch.ChallengerID, float64(ch.Stake), "duel_refund_error")
+		return p.SendReply(ctx.RoomID, ctx.EventID, "Couldn't hold your stake. The duel is off.")
+	}
+
+	return p.settleDuel(ctx, ch, challengerC, challengedC)
+}
+
+func (p *AdventurePlugin) declineDuel(ctx MessageContext) error {
+	// Same lock as accept so a player's own accept/decline can't interleave; the
+	// claim is the real guard, but the lock keeps the read→claim window tight.
+	lock := p.advUserLock(ctx.Sender)
+	lock.Lock()
+	defer lock.Unlock()
+
+	ch := pendingDuelForChallenged(ctx.Sender)
+	if ch == nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "You have no pending duel to decline.")
+	}
+	if !claimDuelChallenge(ch.ChallengeID) {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "You have no pending duel to decline.")
+	}
+	p.euro.Credit(ch.ChallengerID, float64(ch.Stake), "duel_refund_declined")
+	p.SendDM(ch.ChallengerID, fmt.Sprintf(
+		"🛡️ **%s** declined your duel. Your €%d stake is refunded.", p.DisplayName(ctx.Sender), ch.Stake))
+	return p.SendReply(ctx.RoomID, ctx.EventID, "You decline the duel. No harm done.")
+}
+
+func (p *AdventurePlugin) duelStatusCmd(ctx MessageContext) error {
+	if ch := pendingDuelForChallenged(ctx.Sender); ch != nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, fmt.Sprintf(
+			"⚔️ **%s** has challenged you for €%d. `!duel accept` / `!duel decline` (expires %s).",
+			p.DisplayName(ch.ChallengerID), ch.Stake, formatDuration(time.Until(ch.ExpiresAt))))
+	}
+	// Any challenge we issued that's still pending?
+	c := &advDuelChallenge{}
+	err := db.Get().QueryRow(`
+		SELECT challenge_id, challenger_id, challenged_id, stake, expires_at, created_at
+		FROM adventure_duel_challenges
+		WHERE challenger_id = ? AND expires_at > CURRENT_TIMESTAMP
+		ORDER BY created_at DESC LIMIT 1`, string(ctx.Sender)).Scan(
+		&c.ChallengeID, &c.ChallengerID, &c.ChallengedID, &c.Stake, &c.ExpiresAt, &c.CreatedAt)
+	if err == nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, fmt.Sprintf(
+			"⚔️ You've challenged **%s** for €%d. Waiting on their answer (expires %s).",
+			p.DisplayName(c.ChallengedID), c.Stake, formatDuration(time.Until(c.ExpiresAt))))
+	}
+	return p.SendReply(ctx.RoomID, ctx.EventID, "You have no duels in flight. `!duel @user [stake]` to start one.")
+}
+
+// ── Resolution ───────────────────────────────────────────────────────────────
+
+// settleDuel resolves the two-orientation bout, splits the pooled 2×stake,
+// records the result, and DMs both players. By the time it runs the challenge
+// row is claimed, both fighters are built, and both stakes are held — so from
+// here it is pure arithmetic and message sends, nothing that can panic and
+// strand the pool. On an exact HP-margin tie both stakes are refunded.
+func (p *AdventurePlugin) settleDuel(ctx MessageContext, ch *advDuelChallenge, challengerC, challengedC Combatant) error {
+	res := resolveDuel(challengerC, challengedC, nil)
+
+	if res.draw {
+		// Exact HP-margin tie: refund both, record nothing, no cooldown burned.
+		p.euro.Credit(ch.ChallengerID, float64(ch.Stake), "duel_refund_draw")
+		p.euro.Credit(ch.ChallengedID, float64(ch.Stake), "duel_refund_draw")
+		draw := fmt.Sprintf("⚔️ **%s** and **%s** fought to a standstill. Both stakes refunded.",
+			p.DisplayName(ch.ChallengerID), p.DisplayName(ch.ChallengedID))
+		p.SendDM(ch.ChallengerID, draw)
+		p.SendDM(ch.ChallengedID, draw)
+		return p.SendReply(ctx.RoomID, ctx.EventID, draw)
+	}
+
+	winnerID, loserID := ch.ChallengedID, ch.ChallengerID
+	if res.challengerWins {
+		winnerID, loserID = ch.ChallengerID, ch.ChallengedID
+	}
+
+	winnerShare, potShare := duelPayout(ch.Stake)
+	p.euro.Credit(winnerID, float64(winnerShare), "duel_win")
+	if potShare > 0 {
+		communityPotAdd(potShare)
+		// The rake came out of a pool both funded; attribute it half each.
+		trackTaxPaid(winnerID, potShare/2)
+		trackTaxPaid(loserID, potShare-potShare/2)
+	}
+
+	upsertRivalRecord(winnerID, loserID, true)
+	upsertRivalRecord(loserID, winnerID, false)
+
+	p.announceDuel(ctx, winnerID, loserID, ch.Stake, winnerShare, potShare, res.decisive)
+	return nil
+}
+
+func (p *AdventurePlugin) announceDuel(ctx MessageContext, winnerID, loserID id.UserID, stake, winnerShare, potShare int, decisive bool) {
+	winName, loseName := p.DisplayName(winnerID), p.DisplayName(loserID)
+	flair := pickDuelFlavor(duelWinFlavor)
+	if decisive {
+		flair = pickDuelFlavor(duelDecisiveFlavor)
+	}
+
+	p.SendDM(winnerID, fmt.Sprintf(
+		"⚔️ **You beat %s!**\n\n*%s*\n\nYou take €%d (net +€%d). €%d went to the community pot.",
+		loseName, flair, winnerShare, winnerShare-stake, potShare))
+	p.SendDM(loserID, fmt.Sprintf(
+		"⚔️ **%s bested you.**\n\n*%s*\n\nYou're down €%d — but you walk away, no worse for wear.",
+		winName, pickDuelFlavor(duelLossFlavor), stake))
+
+	// Broadcast the result to the games room for bragging rights — unless the
+	// duel was accepted there, in which case the SendReply below already covers
+	// it and a second line would just be noise.
+	if gr := gamesRoom(); gr != "" && gr != ctx.RoomID {
+		verb := "defeated"
+		if decisive {
+			verb = "decisively defeated"
+		}
+		p.SendMessage(gr, fmt.Sprintf("⚔️ **%s** %s **%s** in a duel for €%d.", winName, verb, loseName, stake))
+	}
+	// Confirm in the room the challenge was accepted from too.
+	p.SendReply(ctx.RoomID, ctx.EventID, fmt.Sprintf("⚔️ **%s** wins the duel, taking €%d.", winName, winnerShare))
+}
+
+// expireDuelChallenges refunds and clears any challenge whose 24h window lapsed.
+// Rides the 1-minute event ticker (no new goroutine); only the challenger was
+// escrowed, so only they are refunded.
+func (p *AdventurePlugin) expireDuelChallenges() {
+	for _, ch := range loadExpiredDuelChallenges() {
+		// Claim before refunding: if an accept/decline already took this row at
+		// the 24h boundary, we must not also refund the challenger.
+		if !claimDuelChallenge(ch.ChallengeID) {
+			continue
+		}
+		p.euro.Credit(ch.ChallengerID, float64(ch.Stake), "duel_refund_expired")
+		p.SendDM(ch.ChallengerID, fmt.Sprintf(
+			"⌛ **%s** never answered your duel. Your €%d stake is refunded.",
+			p.DisplayName(ch.ChallengedID), ch.Stake))
+	}
+}
+
+func duelIneligibleSelf(reason string) string {
+	switch reason {
+	case "dead":
+		return "You can't duel while dead. Visit `!hospital` first."
+	case "no adventurer":
+		return "You have no adventurer. Type `!adventure` to create one."
+	default:
+		return fmt.Sprintf("You need to be at least level %d to duel.", duelMinLevel)
+	}
+}
+
+// ── Flavor ───────────────────────────────────────────────────────────────────
+
+var duelWinFlavor = []string{
+	"Steel rang, and the crowd knew its champion.",
+	"A clean finish — you left them nothing to answer with.",
+	"They fought well. You fought better.",
+}
+
+var duelDecisiveFlavor = []string{
+	"It was over before it began. Utterly one-sided.",
+	"You never gave them a foothold. A rout.",
+	"The arena barely had time to hush.",
+}
+
+var duelLossFlavor = []string{
+	"You'll want that one back. Next time.",
+	"A hard lesson — but only your pride is bleeding.",
+	"Close, in places. Not close enough.",
+}
+
+func pickDuelFlavor(pool []string) string {
+	if len(pool) == 0 {
+		return ""
+	}
+	return pool[rand.IntN(len(pool))]
+}

internal/plugin/adventure_duel_test.go

@@ -0,0 +1,274 @@
+package plugin
+
+import (
+	"math"
+	"math/rand/v2"
+	"testing"
+	"time"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+func newDuelTestDB(t *testing.T) {
+	t.Helper()
+	db.Close()
+	if err := db.Init(t.TempDir()); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+}
+
+// duelSeed builds a deterministic RNG so the two-orientation resolver is
+// reproducible across runs — the production path passes nil (global RNG).
+func duelSeed(i uint64) *rand.Rand { return rand.New(rand.NewPCG(0x1d4e11, i)) }
+
+func TestDuelPayout(t *testing.T) {
+	// Both escrow 2000 → pool 4000 → winner 70% (2800), pot 30% (1200).
+	w, pot := duelPayout(2000)
+	if w != 2800 || pot != 1200 {
+		t.Fatalf("duelPayout(2000) = (%d, %d), want (2800, 1200)", w, pot)
+	}
+	// The pot always gets exactly what the winner doesn't; nothing is minted
+	// or lost against the pooled 2×stake.
+	for _, stake := range []int{100, 137, 999, 6000} {
+		w, pot := duelPayout(stake)
+		if w+pot != stake*2 {
+			t.Errorf("duelPayout(%d): winner+pot = %d, want pool %d", stake, w+pot, stake*2)
+		}
+		if w <= pot {
+			t.Errorf("duelPayout(%d): winner %d should exceed pot %d", stake, w, pot)
+		}
+	}
+}
+
+func TestDuelMaxStake(t *testing.T) {
+	if got := duelMaxStake(5); got != 2500 {
+		t.Fatalf("duelMaxStake(5) = %d, want 2500", got)
+	}
+}
+
+func TestDuelPerHitDamage(t *testing.T) {
+	// 1d8 (avg 4.5) + ability mod 3 = 7.5 base, + Divine Strike 2 = 9.5,
+	// × (1 + 0.25 damage bonus) = 11.875.
+	pc := Combatant{
+		Stats: CombatStats{
+			Weapon:              &WeaponProfile{DamageCount: 1, DamageSides: 8},
+			AbilityModForDamage: 3,
+		},
+		Mods: CombatModifiers{DivineStrikePerHit: 2, DamageBonus: 0.25},
+	}
+	got := duelPerHitDamage(pc)
+	if math.Abs(got-11.875) > 1e-9 {
+		t.Fatalf("duelPerHitDamage = %v, want 11.875", got)
+	}
+
+	// Weaponless build falls back to the flat Attack stat.
+	bare := Combatant{Stats: CombatStats{Attack: 9}}
+	if got := duelPerHitDamage(bare); got != 9 {
+		t.Fatalf("weaponless duelPerHitDamage = %v, want 9", got)
+	}
+
+	// A build that computes to <1 is floored to 1 (a fight always deals damage).
+	weak := Combatant{Stats: CombatStats{Attack: 0}}
+	if got := duelPerHitDamage(weak); got != 1 {
+		t.Fatalf("floored duelPerHitDamage = %v, want 1", got)
+	}
+}
+
+func TestSynthDuelEnemy(t *testing.T) {
+	pc := Combatant{
+		Name:     "Aria",
+		IsPlayer: true,
+		Stats: CombatStats{
+			MaxHP:               123,
+			AC:                  17,
+			AttackBonus:         8,
+			Defense:             5,
+			Weapon:              &WeaponProfile{DamageCount: 1, DamageSides: 8},
+			AbilityModForDamage: 3,
+		},
+		Mods: CombatModifiers{ExtraAttacks: 1}, // two swings/round
+	}
+	e := synthDuelEnemy(pc)
+
+	if e.IsPlayer {
+		t.Error("synthesised enemy must not be flagged IsPlayer")
+	}
+	if e.Ability != nil {
+		t.Error("v1 synth enemy carries no MonsterAbility")
+	}
+	// HP / AC / to-hit carry over verbatim: to-hit stays faithful both ways.
+	if e.Stats.MaxHP != 123 || e.Stats.AC != 17 || e.Stats.AttackBonus != 8 {
+		t.Errorf("stat carryover wrong: got HP=%d AC=%d AB=%d", e.Stats.MaxHP, e.Stats.AC, e.Stats.AttackBonus)
+	}
+	// Damage: per-hit (7.5) × swings (2) folded into one flat Attack = 15.
+	if e.Stats.Attack != 15 {
+		t.Errorf("folded Attack = %d, want 15 (7.5 × 2 swings)", e.Stats.Attack)
+	}
+}
+
+// TestResolveDuel_StrongerWinsRegardlessOfRole pins that a clearly superior
+// build wins whether it issues or receives the challenge — the two-orientation
+// resolver must not hand the win to the attacker seat.
+func TestResolveDuel_StrongerWinsRegardlessOfRole(t *testing.T) {
+	strong := Combatant{
+		Name: "Champion", IsPlayer: true,
+		Stats: CombatStats{
+			MaxHP: 220, AC: 19, AttackBonus: 12,
+			Weapon: &WeaponProfile{DamageCount: 2, DamageSides: 8}, AbilityModForDamage: 5, WeaponProficient: true,
+		},
+	}
+	weak := Combatant{
+		Name: "Novice", IsPlayer: true,
+		Stats: CombatStats{
+			MaxHP: 45, AC: 11, AttackBonus: 3,
+			Weapon: &WeaponProfile{DamageCount: 1, DamageSides: 4}, AbilityModForDamage: 0, WeaponProficient: true,
+		},
+	}
+
+	for i := uint64(0); i < 50; i++ {
+		if r := resolveDuel(strong, weak, duelSeed(i)); r.draw || !r.challengerWins {
+			t.Fatalf("seed %d: strong-as-challenger should win, got %+v", i, r)
+		}
+		if r := resolveDuel(weak, strong, duelSeed(i)); r.draw || r.challengerWins {
+			t.Fatalf("seed %d: strong-as-challenged should win, got %+v", i, r)
+		}
+	}
+}
+
+// TestResolveDuel_IdenticalFightersAreUnbiased is the fairness guarantee that
+// justifies running both orientations: with two identical builds neither the
+// challenger nor the challenged seat may have a systematic edge. A single-
+// orientation model (attacker uses full kit, defender is a stat block) would
+// skew hard toward the challenger; the both-orientations margin cancels it.
+func TestResolveDuel_IdenticalFightersAreUnbiased(t *testing.T) {
+	fighter := Combatant{
+		Name: "Mirror", IsPlayer: true,
+		Stats: CombatStats{
+			MaxHP: 110, AC: 15, AttackBonus: 7,
+			Weapon: &WeaponProfile{DamageCount: 1, DamageSides: 8}, AbilityModForDamage: 3, WeaponProficient: true,
+		},
+	}
+
+	const n = 1200
+	challengerWins, draws := 0, 0
+	for i := uint64(0); i < n; i++ {
+		r := resolveDuel(fighter, fighter, duelSeed(i))
+		switch {
+		case r.draw:
+			draws++
+		case r.challengerWins:
+			challengerWins++
+		}
+	}
+	decided := n - draws
+	if decided == 0 {
+		t.Fatal("all identical-fighter duels drew — resolver isn't discriminating")
+	}
+	// Unbiased by construction (challenger wins iff D1 > D2 for iid D); allow a
+	// generous ±10% band so this stays a bias check, not a flaky coin-count.
+	rate := float64(challengerWins) / float64(decided)
+	if rate < 0.40 || rate > 0.60 {
+		t.Fatalf("challenger win rate %.3f over %d decided duels — systematic bias (want ~0.5)", rate, decided)
+	}
+}
+
+// TestClaimDuelChallenge pins the serialization primitive that guards every
+// euro path: exactly one caller may claim a challenge, so accept/decline/expire
+// can never both move money for the same row.
+func TestClaimDuelChallenge(t *testing.T) {
+	newDuelTestDB(t)
+	ch := &advDuelChallenge{
+		ChallengeID:  "duel-1",
+		ChallengerID: id.UserID("@a:x"),
+		ChallengedID: id.UserID("@b:x"),
+		Stake:        1000,
+		ExpiresAt:    time.Now().UTC().Add(time.Hour),
+	}
+	insertDuelChallenge(ch)
+
+	if pendingDuelForChallenged(id.UserID("@b:x")) == nil {
+		t.Fatal("challenge should be pending for the challenged player before any claim")
+	}
+	if !duelInvolves(id.UserID("@a:x")) || !duelInvolves(id.UserID("@b:x")) {
+		t.Fatal("duelInvolves should see both parties while the challenge is live")
+	}
+
+	if !claimDuelChallenge("duel-1") {
+		t.Fatal("first claim must succeed")
+	}
+	if claimDuelChallenge("duel-1") {
+		t.Fatal("second claim must fail — the row is gone, so no double refund/payout")
+	}
+	if pendingDuelForChallenged(id.UserID("@b:x")) != nil {
+		t.Fatal("claimed challenge must no longer be pending")
+	}
+}
+
+func TestLoadExpiredDuelChallenges(t *testing.T) {
+	newDuelTestDB(t)
+	insertDuelChallenge(&advDuelChallenge{
+		ChallengeID: "live", ChallengerID: "@a:x", ChallengedID: "@b:x",
+		Stake: 500, ExpiresAt: time.Now().UTC().Add(time.Hour),
+	})
+	insertDuelChallenge(&advDuelChallenge{
+		ChallengeID: "stale", ChallengerID: "@c:x", ChallengedID: "@d:x",
+		Stake: 500, ExpiresAt: time.Now().UTC().Add(-time.Hour),
+	})
+	got := loadExpiredDuelChallenges()
+	if len(got) != 1 || got[0].ChallengeID != "stale" {
+		t.Fatalf("loadExpiredDuelChallenges = %+v, want only the stale one", got)
+	}
+}
+
+// TestSynthDuelEnemy_PortsDefenseAndProcs pins the fidelity carry-overs added
+// after review: a tank's DamageReduct rides onto the synth enemy, and companion
+// procs fold their expected damage into its round Attack.
+func TestSynthDuelEnemy_PortsDefenseAndProcs(t *testing.T) {
+	pc := Combatant{
+		Stats: CombatStats{
+			MaxHP: 100, AC: 15, AttackBonus: 6,
+			Weapon: &WeaponProfile{DamageCount: 1, DamageSides: 8}, AbilityModForDamage: 2, // 6.5/hit
+		},
+		Mods: CombatModifiers{
+			DamageReduct:     0.6,                     // Barbarian-style mitigation
+			SpiritWeaponProc: 0.5, SpiritWeaponDmg: 4, // expected 0.5×(4+3)=3.5/round
+		},
+	}
+	e := synthDuelEnemy(pc)
+	if e.Mods.DamageReduct != 0.6 {
+		t.Errorf("DamageReduct not ported: got %v, want 0.6", e.Mods.DamageReduct)
+	}
+	// One swing (6.5) + proc expectation (3.5) = 10 → rounded 10.
+	if e.Stats.Attack != 10 {
+		t.Errorf("folded Attack = %d, want 10 (6.5 weapon + 3.5 proc)", e.Stats.Attack)
+	}
+}
+
+func TestParseDuelStake(t *testing.T) {
+	p := &AdventurePlugin{}
+	const level = 5 // cap = 2500
+
+	// No stake → default to the cap.
+	if got, err := p.parseDuelStake([]string{"@u"}, level); err != nil || got != 2500 {
+		t.Fatalf("default stake = (%d, %v), want (2500, nil)", got, err)
+	}
+	// Explicit in-band stake, with and without the € prefix.
+	if got, err := p.parseDuelStake([]string{"@u", "€1500"}, level); err != nil || got != 1500 {
+		t.Fatalf("€1500 stake = (%d, %v), want (1500, nil)", got, err)
+	}
+	// Over the cap is rejected.
+	if _, err := p.parseDuelStake([]string{"@u", "9999"}, level); err == nil {
+		t.Error("stake above cap should error")
+	}
+	// Below the floor is rejected.
+	if _, err := p.parseDuelStake([]string{"@u", "10"}, level); err == nil {
+		t.Error("stake below the minimum should error")
+	}
+	// Garbage is rejected.
+	if _, err := p.parseDuelStake([]string{"@u", "lots"}, level); err == nil {
+		t.Error("non-numeric stake should error")
+	}
+}

internal/plugin/adventure_events.go

@@ -23,18 +23,78 @@ type advActiveEvent struct {
 	ExpiresAt   time.Time
 }
 
-// ── In-memory schedule ───────────────────────────────────────────────────────
-// When a player acts on a given day, the next ticker iteration assigns them
-// a one-shot roll-minute 60–180 minutes in the future. At that minute, the
-// 0.5% trigger roll fires. Each player rolls at most once per UTC day.
+// ── Event anchors ────────────────────────────────────────────────────────────
+// N1/A6 — events used to roll at 0.5%/player/day from a deferred ticker slot,
+// which put one sighting in front of a daily player roughly every 200 days.
+// They now roll at moments the player is demonstrably present and reading a
+// DM: the end-of-day digest, a sale at Thom's, and an arena cashout. Each
+// player still sees at most one event per UTC day.
+//
+// The per-anchor chances below put a player who hits all three at ~1 event
+// per week; see TestAnchoredEventWeeklyRate.
+//
+// K — the three social/economic anchors miss the pure grind loop: a player who
+// only mines/forages/fishes (now automatic, done by walking) and clears
+// single-day dungeons, but never sells, never enters the arena, and never runs
+// a multi-day expedition to a Night camp, would roll for zero events. The
+// fourth anchor, ZoneClear, fires on a foreground single-day zone clear — the
+// climax DM that player *is* reading — so they get the same rough cadence.
+// Autopilot walks and mid-zone region clears deliberately do not fire it (see
+// zoneCmdAdvance / the full-clear branch of advanceOnceWithOpts). The per-day
+// slot still caps everyone at one event, so a player who happens to hit two
+// anchors in a day can't double up. This rate is the tuning knob for item K —
+// bump it if telemetry shows the grind-loop player still sees too few.
+const (
+	advEventChanceDigest    = 0.08
+	advEventChanceSell      = 0.05
+	advEventChanceArena     = 0.05
+	advEventChanceZoneClear = 0.08
+)
 
 var (
-	advEventScheduleMu  sync.Mutex
-	advEventSchedule    map[string]int  // userID -> minute-of-day for the deferred roll
-	advEventRolled      map[string]bool // userID -> already rolled today
-	advEventScheduleDay string          // "2006-01-02" the maps belong to
+	advEventFiredMu  sync.Mutex
+	advEventFired    map[string]bool // userID -> an event already fired today
+	advEventFiredDay string          // "2006-01-02" the map belongs to
 )
 
+// claimDailyEventSlot reserves today's single event slot for `userID`.
+// Returns false when the player already had one fire today.
+func claimDailyEventSlot(userID id.UserID, day string) bool {
+	advEventFiredMu.Lock()
+	defer advEventFiredMu.Unlock()
+	if advEventFiredDay != day {
+		advEventFired = make(map[string]bool)
+		advEventFiredDay = day
+	}
+	if advEventFired[string(userID)] {
+		return false
+	}
+	advEventFired[string(userID)] = true
+	return true
+}
+
+// releaseDailyEventSlot hands the slot back when the trigger bailed before
+// anything reached the player, so a later anchor the same day can still fire.
+func releaseDailyEventSlot(userID id.UserID) {
+	advEventFiredMu.Lock()
+	defer advEventFiredMu.Unlock()
+	delete(advEventFired, string(userID))
+}
+
+// maybeFireAnchoredEvent rolls `chance` at one of the A6 anchor moments and,
+// on a hit, triggers the player's one mid-day event for today.
+func (p *AdventurePlugin) maybeFireAnchoredEvent(userID id.UserID, chance float64) {
+	if rand.Float64() >= chance {
+		return
+	}
+	if !claimDailyEventSlot(userID, time.Now().UTC().Format("2006-01-02")) {
+		return
+	}
+	if !p.tryTriggerEvent(userID) {
+		releaseDailyEventSlot(userID)
+	}
+}
+
 // ── Event Ticker ─────────────────────────────────────────────────────────────
 
 func (p *AdventurePlugin) eventTicker() {
@@ -46,90 +106,53 @@ func (p *AdventurePlugin) eventTicker() {
 		case <-p.stopCh:
 			return
 		case <-ticker.C:
-			now := time.Now().UTC()
-			dateKey := now.Format("2006-01-02")
-			currentMinute := now.Hour()*60 + now.Minute()
-
 			// Expire stale pending events every tick
 			expireAdvPendingEvents()
 
 			// Auto-play any combat sessions past their 1h timeout.
 			p.reapExpiredCombatSessions()
 
-			advEventScheduleMu.Lock()
-			if advEventScheduleDay != dateKey {
-				advEventSchedule = make(map[string]int)
-				advEventRolled = make(map[string]bool)
-				advEventScheduleDay = dateKey
-			}
+			// Latch away party members onto autopilot so one absent player
+			// can't hold a co-op fight hostage (N3/P5). Solo fights are never
+			// listed — they answer to the reaper above.
+			p.nudgeStalledPartyTurns()
 
-			// Schedule deferred rolls for any newly-acted players
-			chars, err := loadAllAdvCharacters()
-			if err != nil {
-				slog.Error("adventure: events: failed to load chars", "err", err)
-				advEventScheduleMu.Unlock()
-				continue
-			}
-			for _, c := range chars {
-				uid := string(c.UserID)
-				if !c.Alive || advEventRolled[uid] {
-					continue
-				}
-				if _, scheduled := advEventSchedule[uid]; scheduled {
-					continue
-				}
-				if !c.HasActedToday() {
-					continue
-				}
-				// Assign a one-shot roll 60–180 minutes from now, capped to 23:50 UTC.
-				rollMinute := currentMinute + 60 + rand.IntN(121)
-				if rollMinute > 23*60+50 {
-					rollMinute = 23*60 + 50
-				}
-				advEventSchedule[uid] = rollMinute
-				slog.Info("adventure: event roll scheduled", "user", uid, "minute", rollMinute)
-			}
+			// Reclaim invites nobody answered (N3/P6b). Every read already
+			// filters on the TTL; this just stops the rows accumulating.
+			purgeExpiredInvites()
 
-			// Find players whose roll-minute has arrived
-			var toRoll []id.UserID
-			for uid, minute := range advEventSchedule {
-				if minute <= currentMinute && !advEventRolled[uid] {
-					toRoll = append(toRoll, id.UserID(uid))
-					advEventRolled[uid] = true
-				}
-			}
-			advEventScheduleMu.Unlock()
+			// World boss (N6/C3): auto-spawn the monthly Siege on the 1st and
+			// resolve one whose 72h window has lapsed. Own dedup inside.
+			p.worldBossTick()
 
-			for _, uid := range toRoll {
-				p.tryTriggerEvent(uid)
-			}
+			// Duels (N6/C2): refund and clear any challenge whose 24h accept
+			// window lapsed.
+			p.expireDuelChallenges()
 		}
 	}
 }
 
-func (p *AdventurePlugin) tryTriggerEvent(userID id.UserID) {
-	// Load character — must be alive and have acted today
+// tryTriggerEvent fires the player's mid-day event. Reports whether an event
+// actually reached them — a false return means the caller's daily slot was
+// never spent. The trigger roll itself lives in maybeFireAnchoredEvent.
+func (p *AdventurePlugin) tryTriggerEvent(userID id.UserID) bool {
+	// Load character — must be alive.
 	char, err := loadAdvCharacter(userID)
-	if err != nil || char == nil || !char.Alive || !char.HasActedToday() {
-		return
+	if err != nil || char == nil || !char.Alive {
+		return false
 	}
 
 	// Already has an active event?
 	active, _ := loadAdvActiveEvent(userID)
 	if active != nil {
-		return
+		return false
 	}
 
 	// Mid-fight: a turn-based session locks the run. Don't drop a random
 	// overworld event into a live fight — the player can't act on it without
 	// finishing the fight first, and the trigger DM talks over the combat feed.
 	if hasActiveCombatSession(userID) {
-		return
-	}
-
-	// 0.5% chance
-	if rand.Float64() >= 0.005 {
-		return
+		return false
 	}
 
 	// Determine today's activity for filtering
@@ -138,7 +161,7 @@ func (p *AdventurePlugin) tryTriggerEvent(userID id.UserID) {
 	// Pick an event
 	event := advPickRandomEvent(userID, activityType)
 	if event == nil {
-		return
+		return false
 	}
 
 	// Insert into DB
@@ -147,7 +170,7 @@ func (p *AdventurePlugin) tryTriggerEvent(userID id.UserID) {
 	eventID, err := insertAdvEvent(userID, event.Key, expiresAt)
 	if err != nil {
 		slog.Error("adventure: events: failed to insert event", "user", userID, "err", err)
-		return
+		return false
 	}
 
 	slog.Info("adventure: mid-day event triggered", "user", userID, "event", event.Key, "id", eventID)
@@ -170,6 +193,7 @@ func (p *AdventurePlugin) tryTriggerEvent(userID id.UserID) {
 		})
 		_ = p.SendMessage(id.RoomID(gr), roomLine)
 	}
+	return true
 }
 
 // handleEventRespond processes `!adventure respond`.

internal/plugin/adventure_events_test.go

@@ -0,0 +1,120 @@
+package plugin
+
+import (
+	"math/rand/v2"
+	"testing"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// TestAnchoredEventWeeklyRate pins the A6 rebalance: a player who reads an
+// end-of-day digest, sells at Thom's, and cashes out of the arena every day
+// should see roughly one mid-day event per week. The old 0.5%/day roll put
+// that at one per ~200 days.
+//
+// The simulation drives its own seeded RNG rather than the package-global
+// one, so it measures the policy — the chance constants and the one-event-
+// per-day cap — and never flakes on RNG ordering elsewhere in the suite.
+func TestAnchoredEventWeeklyRate(t *testing.T) {
+	anchors := []float64{advEventChanceDigest, advEventChanceSell, advEventChanceArena}
+
+	const weeks = 20000
+	rng := rand.New(rand.NewPCG(0x5EED, 0xA6))
+	events := 0
+	for range weeks {
+		for range 7 {
+			firedToday := false
+			for _, chance := range anchors {
+				if firedToday {
+					break // one event per player per UTC day
+				}
+				if rng.Float64() < chance {
+					firedToday = true
+				}
+			}
+			if firedToday {
+				events++
+			}
+		}
+	}
+
+	perWeek := float64(events) / weeks
+	if perWeek < 0.8 || perWeek > 1.5 {
+		t.Errorf("anchored events = %.3f/week, want ~1 (0.8–1.5)", perWeek)
+	}
+}
+
+// TestZoneClearAnchorRate pins item K's fourth anchor for the population the
+// other three miss: a grind-loop player who never sells, never enters the
+// arena, and never runs a multi-day expedition, but clears single-day zones.
+// Modelled at two foreground clears per active day (a plausible dungeon
+// session) they should land in the same ~1 event/week band as the fully-
+// engaged player — that is the whole point of adding the anchor. The clears/day
+// assumption and advEventChanceZoneClear are the two tuning knobs; see the K
+// note in adventure_events.go.
+func TestZoneClearAnchorRate(t *testing.T) {
+	const clearsPerDay = 2
+
+	const weeks = 20000
+	rng := rand.New(rand.NewPCG(0x5EED, 0x2C)) // "ZC"
+	events := 0
+	for range weeks {
+		for range 7 {
+			firedToday := false
+			for range clearsPerDay {
+				if firedToday {
+					break // one event per player per UTC day
+				}
+				if rng.Float64() < advEventChanceZoneClear {
+					firedToday = true
+				}
+			}
+			if firedToday {
+				events++
+			}
+		}
+	}
+
+	perWeek := float64(events) / weeks
+	if perWeek < 0.8 || perWeek > 1.5 {
+		t.Errorf("zone-clear anchor = %.3f/week, want ~1 (0.8–1.5)", perWeek)
+	}
+}
+
+// TestClaimDailyEventSlot_OnePerDay guards the cap the rate test assumes.
+func TestClaimDailyEventSlot_OnePerDay(t *testing.T) {
+	uid := id.UserID("@events-slot:example")
+	const day = "2026-07-09"
+
+	advEventFiredMu.Lock()
+	advEventFired = nil
+	advEventFiredDay = ""
+	advEventFiredMu.Unlock()
+
+	if !claimDailyEventSlot(uid, day) {
+		t.Fatal("first claim of the day should succeed")
+	}
+	if claimDailyEventSlot(uid, day) {
+		t.Error("second claim on the same day should be refused")
+	}
+	// A trigger that bailed before reaching the player hands the slot back.
+	releaseDailyEventSlot(uid)
+	if !claimDailyEventSlot(uid, day) {
+		t.Error("claim after release should succeed")
+	}
+	// A new UTC day resets everyone.
+	if !claimDailyEventSlot(uid, "2026-07-10") {
+		t.Error("claim on a new day should succeed")
+	}
+}
+
+// TestClaimDailyEventSlot_PerUser — one player's event doesn't consume another's.
+func TestClaimDailyEventSlot_PerUser(t *testing.T) {
+	const day = "2026-07-11"
+	if !claimDailyEventSlot(id.UserID("@events-a:example"), day) {
+		t.Fatal("player A should claim")
+	}
+	if !claimDailyEventSlot(id.UserID("@events-b:example"), day) {
+		t.Error("player B should claim independently of A")
+	}
+}

internal/plugin/adventure_flavor_blacksmith.go

@@ -49,6 +49,22 @@ var blacksmithArena = []string{
 	"The Arena gear gets the good tools. I don't use these for everything. Just for things that matter.",
 }
 
+var blacksmithTemperGreetings = []string{
+	"_sets aside the repair work_ You want me to make something _more_ than it is. That's different. That's the good work.",
+	"Tempering. _rolls his shoulders_ I don't repair it. I take it apart and I convince it to come back stronger. It doesn't always want to.",
+	"_wipes the counter clean with one sweep_ Put it down. Right there. Let me see what it could be instead of what it is.",
+	"Anything can be pushed further. Anything. It's just a question of what you're willing to spend and how much heat it can take before it gives in.",
+	"_eyes light up_ Oh, you've come for the real thing. Not a patch. A _change_. Show me. Show me everything you've got.",
+}
+
+var blacksmithTemperCompletion = []string{
+	"_lifts it from the quench, steam everywhere_ Feel the weight of it now. It's not the same thing you handed me. It never will be again.",
+	"_breathing hard_ It fought me. Right to the end it fought me. And now look at it. Look what it became.",
+	"There. _sets it down with enormous care_ I pushed it further than it wanted to go, and it thanked me for it. They always do.",
+	"_holds it up, turning it slowly_ I've been doing this a long time and this one still surprised me. Take it before I change my mind about giving it back.",
+	"It's still hot. It'll be hot for a while. That's what happens when you ask something to become more than it was.",
+}
+
 var blacksmithFullCondition = []string{
 	"_looks it over_ There's nothing to do here. It doesn't need me. _sounds slightly disappointed_ Come back when it does.",
 	"Full condition. You've been taking care of it. Good. I appreciate that in a person.",
@@ -63,4 +79,3 @@ var blacksmithBrokenCondition = []string{
 	"_looks at the condition, looks at you, looks back at the condition_ You know it costs more when you let it get like this. Of course you know. You just didn't care. That's fine. I care enough for both of us. It'll cost you.",
 	"This could have been avoided with regular visits. _slides the cost estimate across the counter without breaking eye contact_",
 }
-

internal/plugin/adventure_flavor_campaign.go

@@ -0,0 +1,519 @@
+package plugin
+
+import (
+	"fmt"
+	"log/slog"
+	"math/rand/v2"
+	"strings"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// The Hollow King campaign (N5/D1). A light serialized story threaded through
+// the zones by way of collectible journal pages. "The Hollow King" is already
+// the Forest Shadows (T2) boss; this frames him as a realm-spanning antagonist
+// whose fragments turn up wherever players fight elites and open secret rooms.
+//
+// The fragments are in-world found artifacts — journal entries, torn letters,
+// stone inscriptions — not TwinBee's voice. TwinBee's own reactions (D1b) obey
+// the first-person voice rules; this text does not.
+
+type journalPage struct {
+	Title string
+	Text  string
+}
+
+// journalPages is the ordered campaign. Reading the discovered pages top to
+// bottom tells the fall of a kingdom to the thing its king became. Order is the
+// story order; players find them out of sequence, which is why the viewer marks
+// gaps.
+var journalPages = []journalPage{
+	{"The Long Winter", "A crown is only a circle of gold until a man decides never to take it off. Ours decided in a winter that would not end, and the frost took its cue from him."},
+	{"The Last Physician", "The court healers were sent home one by one, each promising the king had years left. The last was not sent home. We heard him thank the king for the honour."},
+	{"On Shadows", "He stopped casting a shadow before he stopped casting a reflection. The steward struck both from the list of things a servant may notice aloud."},
+	{"The Quiet Ledger", "Grain still left the granaries; no mouths were fed. I stopped auditing the difference the night the number began to feel like a name."},
+	{"A Bargain Overheard", "Through the chapel door: the king's voice, and a second that used his own words a breath before he did. Only one of them was asking."},
+	{"The Hollowing", "They call it a coronation in the records. Those of us who carried the braziers call it what it was. A king was emptied so a crown could keep wearing him."},
+	{"The First Knights", "His honour guard did not die. That was the mercy offered and the price paid. They stand at the old gate yet, and they still salute a throne no living thing sits on."},
+	{"Letters Home, Unsent", "\"Tell mother the pay is good and the work is guarding.\" The satchel held forty such letters, every hand different, every promise the same, none of them sent."},
+	{"The Map Redrawn", "The kingdom did not fall so much as come apart at the seams — a warren here, a drowned temple there, each piece keeping a splinter of him like a tooth in a wound."},
+	{"Root and Rot", "The forest north of the manor grew wrong and grew fast. The woodsmen say the trees lean toward the ruin at dusk. The woodsmen no longer go at dusk."},
+	{"The Warren Below", "Even the goblins gave the deep tunnels to him and asked nothing back. When a scavenger yields ground for free, ask what it saw down there."},
+	{"Water That Remembers", "The temple sank in a single night with the bells still ringing. Divers say the bells ring still, slow, as if something below is counting."},
+	{"The Manor's Long Guest", "Blackspire changed hands nine times in a decade. Every deed names a different owner. Every household names the same tenant, and none will write it down."},
+	{"The Forge Unbanked", "The underforge keeps a heat with no fuel and no smith. What it makes, no one has seen leave. What it makes, we are told, was promised elsewhere long ago."},
+	{"Descent", "The deep roads were a trade route once. Now they are a throat. Everything the surface loses is swallowed the same direction, and the direction has a door at the end."},
+	{"The Bright Country", "Past the crossing the colours are too kind and the days too long. It is the most beautiful place I have run from. He is patient there; he can afford to be."},
+	{"What the Dragon Keeps", "The wyrm hoards more than gold. Deep in the lair, behind the coin, a single crown sits on no head and is guarded better than the hoard."},
+	{"The Portal's Arithmetic", "The abyss gate opens outward. Everyone assumes a door lets things in. This one was built by someone who only ever intended to leave through it."},
+	{"The Regent's Confession", "I ruled in his name for thirty years and never once saw him rule. I signed what the crown wanted signed. I am writing this so that one honest page exists."},
+	{"The Names of the Guard", "I have set down every knight's name here so that when this is read, they are grieved as men and not feared as things. It is the only rescue left to attempt."},
+	{"The Flaw in the Bargain", "The second voice took the king's life and his death both — and a thing that cannot die also cannot be finished. He is not immortal. He is unpaid, and waiting to collect."},
+	{"How to Call Him", "He answers only where his fragments gather and only to one who has gathered them. Do not do this to avenge us. Do it to end the account. Come with the whole ledger or do not come."},
+	{"The Empty Throne", "I have seen the seat at the heart of it all. It is not empty. It is occupied by the shape of a man who left, kept warm against his return."},
+	{"Last Page", "If you are reading in order, you have walked the ruin of everything he emptied to stay. One page is missing from every telling — the one you write by going in. Bring a light. He hates the light. It is the one thing he could never hollow out."},
+}
+
+// journalTotalPages is the campaign length; the drop/viewer/finale all read it
+// so the story can grow by appending to journalPages alone.
+var journalTotalPages = len(journalPages)
+
+// journalPageDropChance is the per-elite-kill probability that a page turns up.
+// Deliberately modest: 24 pages is a long-horizon collection, and secret rooms
+// (D4) grant pages on top of this. Tunable.
+const journalPageDropChance = 0.22
+
+// setJournalPageBit is the in-memory twin of grantJournalPageDB's bitwise OR —
+// the single definition of "page N lives in bit N-1". Out-of-range pages are a
+// no-op.
+func setJournalPageBit(mask int64, page int) int64 {
+	if page < 1 || page > 63 {
+		return mask
+	}
+	return mask | (int64(1) << (page - 1))
+}
+
+func journalPageFound(mask int64, page int) bool {
+	if page < 1 || page > 63 {
+		return false
+	}
+	return mask&(int64(1)<<(page-1)) != 0
+}
+
+func journalPageCount(mask int64) int {
+	n := 0
+	for i := 1; i <= journalTotalPages; i++ {
+		if journalPageFound(mask, i) {
+			n++
+		}
+	}
+	return n
+}
+
+func journalComplete(mask int64) bool {
+	return journalPageCount(mask) >= journalTotalPages
+}
+
+// pickUnfoundJournalPage returns a random not-yet-found page number, or 0 when
+// the campaign is already complete.
+func pickUnfoundJournalPage(mask int64, rng *rand.Rand) int {
+	var missing []int
+	for i := 1; i <= journalTotalPages; i++ {
+		if !journalPageFound(mask, i) {
+			missing = append(missing, i)
+		}
+	}
+	if len(missing) == 0 {
+		return 0
+	}
+	return missing[rngIntN(rng, len(missing))]
+}
+
+// maybeDropJournalPage rolls a page reward for an elite kill or secret room and,
+// on a hit, grants a random unfound page and returns its narration line. Empty
+// string means no drop (missed the roll, DB error, or campaign already
+// complete). The roll draws from the same RNG the surrounding loot rolls use
+// and never touches SimulateCombat's stream, so the combat golden is unmoved.
+func (p *AdventurePlugin) maybeDropJournalPage(userID id.UserID, rng *rand.Rand) string {
+	if rngFloat(rng) >= journalPageDropChance {
+		return ""
+	}
+	return p.grantJournalPage(userID, rng)
+}
+
+// grantJournalPage grants a random unfound page unconditionally (used by secret
+// rooms, which award a page for certain). Returns "" when already complete or on
+// error.
+func (p *AdventurePlugin) grantJournalPage(userID id.UserID, rng *rand.Rand) string {
+	mask, err := loadJournalPages(userID)
+	if err != nil {
+		return ""
+	}
+	page := pickUnfoundJournalPage(mask, rng)
+	if page == 0 {
+		return ""
+	}
+	if err := grantJournalPageDB(userID, page); err != nil {
+		return ""
+	}
+	// If the page turned up mid-expedition, drop a log beat so the end-of-day
+	// digest can have TwinBee react to it. No expedition (legacy !zone, or a
+	// secret room opened outside a run) simply means no digest to react in.
+	if exp, err := getActiveExpedition(userID); err == nil && exp != nil {
+		_ = appendExpeditionLog(exp.ID, exp.CurrentDay, "journal",
+			journalPages[page-1].Title, fmt.Sprintf("page %d", page))
+	}
+	return fmt.Sprintf("📖 A torn journal page — _%s_ (page %d of %d). See `!adventure journal`.",
+		journalPages[page-1].Title, page, journalTotalPages)
+}
+
+// --- N5/D4 secret content pass ---------------------------------------------
+//
+// Every NodeKindSecret room resolves as a no-combat treasure cache (see
+// resolveSecretRoom in dnd_zone_combat.go). Finding it — via the perception /
+// stat check on the fork, or a cross-zone key — is the reward: a guaranteed
+// journal page, a LootBias-weighted treasure roll, and a guaranteed consumable
+// cache. The flavor and the key catalog live here with the rest of the
+// campaign; the resolution mechanics live next to the other room resolvers.
+
+// secretRoomCacheCount is how many zone-tier consumables a secret room always
+// hands over, so the room pays out something visible even for a player who has
+// every page and misses the treasure roll.
+const secretRoomCacheCount = 2
+
+// crossZoneKey pairs a source secret room with the key item it grants. The key
+// is a plain inventory item; a LockKey edge in the destination zone matches its
+// lower-cased Name against lock_data.key_id (see evaluateEdgeLock). Keys persist
+// in inventory, so the unlock is permanent once earned.
+type crossZoneKey struct {
+	item       AdvItem
+	unlocksIn  ZoneID // destination zone, for the grant narration
+	unlockHint string // what the key opens, surfaced when it's granted
+}
+
+// secretRoomKeys — the two cross-zone keys (N5/D4). A Sunken Temple sigil opens
+// a sealed reliquary in Manor Blackspire; an Underforge seal opens a vault deep
+// in the Underdark throne approach. Keyed by the source secret's node ID.
+var secretRoomKeys = map[string]crossZoneKey{
+	"sunken_temple.coral_reliquary": {
+		item:       AdvItem{Name: "Sunken Sigil", Type: "key", Tier: 2},
+		unlocksIn:  ZoneManorBlackspire,
+		unlockHint: "a drowned god's mark — Blackspire has a door that remembers it",
+	},
+	"underforge.forge_vault": {
+		item:       AdvItem{Name: "Underforge Seal", Type: "key", Tier: 3},
+		unlocksIn:  ZoneUnderdark,
+		unlockHint: "the forge's own brand — something in the deep roads was promised its work",
+	},
+}
+
+// grantSecretRoomKey hands over the cross-zone key a secret room carries, if it
+// carries one and the player isn't already holding it. Idempotent: re-finding
+// the room on a later run won't stack duplicate keys. Returns the narration line
+// (empty when the room grants no key, the player already has it, or on error).
+func (p *AdventurePlugin) grantSecretRoomKey(userID id.UserID, node ZoneNode) string {
+	key, ok := secretRoomKeys[node.NodeID]
+	if !ok {
+		return ""
+	}
+	items, err := loadAdvInventory(userID)
+	if err != nil {
+		return ""
+	}
+	want := strings.ToLower(key.item.Name)
+	for _, it := range items {
+		if strings.ToLower(it.Name) == want {
+			return "" // already earned — don't stack it
+		}
+	}
+	if err := addAdvInventoryItem(userID, key.item); err != nil {
+		slog.Error("secret room: grant key", "user", userID, "key", key.item.Name, "err", err)
+		return ""
+	}
+	return fmt.Sprintf("🗝 **%s** — %s.", key.item.Name, key.unlockHint)
+}
+
+// secretRoomDiscovery is the bespoke in-world discovery line for a secret room,
+// keyed by node ID. Not TwinBee's voice — the same in-world register the journal
+// pages use. Nodes without an entry fall back to a generic line built from the
+// node label.
+var secretRoomDiscovery = map[string]string{
+	"crypt_valdris.secret_chamber":      "🔍 **A sealed chamber.** The other grave-robbers pried at the wrong wall. This one gives — Valdris kept something back even from his own tomb.",
+	"forest_shadows.sapling_shrine":     "🔍 **The Sapling Shrine.** A ring of young antlers grown from the dirt, and something votive left at the centre — an offering the King's shell never came back to claim.",
+	"sunken_temple.coral_reliquary":     "🔍 **The Coral Reliquary.** Behind a lattice of living coral, a niche the flood sealed rather than drowned. What the temple hid, it hid well.",
+	"manor_blackspire.hidden_oratory":   "🔍 **The Hidden Oratory.** A chapel with no door in the floor plan, kept for a tenant the deeds refuse to name.",
+	"manor_blackspire.sealed_reliquary": "🔍 **The Sealed Reliquary.** The drowned god's sigil bites into the lock and turns. Blackspire kept a piece of the temple's secret behind a door only the temple could open.",
+	"underforge.forge_vault":            "🔍 **The Forge Vault.** A strongroom off the unbanked heat, its ledger of commissions all addressed elsewhere and long overdue.",
+	"underdark.lost_reliquary":          "🔍 **A lost reliquary.** A shrine the deep roads swallowed whole, still lit, still waiting on a procession that stopped coming a long age ago.",
+	"underdark.sealed_forge_vault":      "🔍 **The Sealed Vault.** The Underforge's brand fits the seam, and the deep-road door gives up what the forge sent ahead — payment on the old account.",
+	"feywild_crossing.illusion_garden":  "🔍 **The Illusion Garden.** A too-kind grove that isn't there when you look straight at it. He can afford beauty here; it costs him nothing to keep.",
+	"dragons_lair.hoard_pillar":         "🔍 **A pillar of hoard.** Coin drifted to the ceiling around a single column the wyrm guards more than gold — as if something at its heart were worth more.",
+	"abyss_portal.reality_seam":         "🔍 **A seam in the real.** The gate's arithmetic frays here, and through the frayed place a hand once reached to leave a thing behind on the way out.",
+}
+
+// secretRoomDiscoveryLine returns the discovery flavor for a secret room,
+// falling back to a label-driven generic when the node has no bespoke entry.
+func secretRoomDiscoveryLine(node ZoneNode) string {
+	if line, ok := secretRoomDiscovery[node.NodeID]; ok {
+		return line
+	}
+	label := node.Label
+	if label == "" {
+		label = "a hidden room"
+	}
+	return fmt.Sprintf("🔍 **%s** — a room the others walked past. Something was left here for whoever looked closer.", label)
+}
+
+// bossEpilogues ties each zone boss's death to the Hollow King arc: a 2-3
+// sentence capstone appended to the boss-down moment. Forest of Shadows is the
+// King himself — but what falls there is a shell he shed, which is why the arc
+// (and the finale) outlives it. In-world narration, not TwinBee's voice.
+var bossEpilogues = map[ZoneID]string{
+	ZoneGoblinWarrens: "Grol dies clutching a coin no goblin minted — a king's face worn smooth by handling. Whatever paid the warren to give up its deep tunnels, it paid in a currency older than these hills.",
+	ZoneCryptValdris: "Valdris tried to cheat the grave and managed only to furnish it. In his last rattle he says a name that isn't his — _hollow, hollow_ — as if warning you of a colleague who did it better.",
+	ZoneForestShadows: "The Hollow King falls without weight, a coat slipped from its peg — and the woods do not go quiet. What you felled here was a thing he shed, not the thing he is. Somewhere, the account he owes goes on accruing.",
+	ZoneSunkenTemple: "The Aboleth's dream breaks and the drowned bells still at last. In the silence you understand what they were counting toward — and that the count did not begin with this temple, and does not end with it.",
+	ZoneManorBlackspire: "Aldric was hollowed the same way, by the same hand, and made a poor imitation: a lord kept past his death to hold a house for a guest who never came. He thanks you. It is the first thing he has meant in a century.",
+	ZoneUnderforge: "Thyrak's fires gutter out, and the half-made things on the anvils cool into what they were always going to be — regalia, and soldiers, and a crown with no head to fit. The forge was filling an order placed a long time ago.",
+	ZoneUnderdark: "Ilvaras ruled the throat that swallows everything downward, toward the door at the bottom of the world. She dies certain she served a queen. She served a direction, and the direction has a name it never told her.",
+	ZoneFeywildCrossing: "The Thornmother's garden was the loveliest cage on the road, tended for a patient guest. He can afford patience; you are learning why. She wilts, and the too-kind light dims by exactly one degree.",
+	ZoneDragonsLair: "Behind Infernax's hoard, past the last of the gold, a single crown rests on no head — guarded better than the treasure, because it was the one thing here he was ever paid to keep. The dragon dies never knowing what it was.",
+	ZoneAbyssPortal: "Belaxath guarded a door that opens outward, built by someone who only ever meant to leave through it. As the demon falls, the gate does not close. It was never meant to keep things out — only to let one thing come home.",
+}
+
+// bossEpilogueLine returns the campaign capstone for a zone boss, or "" for
+// zones with none (and for the synthetic arena, which has no ZoneID entry).
+func bossEpilogueLine(zoneID ZoneID) string {
+	return bossEpilogues[zoneID]
+}
+
+// writeBossEpilogue appends a zone's campaign capstone (if any) to a
+// victory narration. Shared by every boss-down render path — the manual
+// turn-based finishes (finishCombatSession, finishPartyWin) and the compact
+// autopilot boss resolve — so the D1b epilogue fires no matter how the boss
+// was cleared. Caller gates on "this was a boss, not an elite".
+func writeBossEpilogue(b *strings.Builder, zoneID ZoneID) {
+	if ep := bossEpilogueLine(zoneID); ep != "" {
+		b.WriteString("\n" + ep + "\n")
+	}
+}
+
+// twinBeeJournalReactions are TwinBee's morning/digest reactions to pages found
+// during the day — first-person, implicit subject, he/him, one line, curious,
+// never expository (feedback_twinbee_voice, feedback_twinbee_is_male). Picked
+// deterministically so a re-rendered digest reads the same.
+var twinBeeJournalReactions = []string{
+	"📖 Found a torn page in your kit tonight — been reading it by the fire while you sleep. This king of theirs was not a well man.",
+	"📖 Another page. Keep turning them up and I keep piecing him together, and I do not much like the shape.",
+	"📖 Read the new page twice. Whoever wrote it was frightened of something patient. I think we are walking toward it.",
+	"📖 Slipped the day's page into the others. The story's filling in at the edges, and none of the edges are kind.",
+}
+
+// twinBeeJournalReaction picks one reaction line deterministically from the day
+// and the number of pages found, so the digest is stable across re-renders.
+func twinBeeJournalReaction(day, pagesToday int) string {
+	if len(twinBeeJournalReactions) == 0 || pagesToday <= 0 {
+		return ""
+	}
+	idx := (day + pagesToday) % len(twinBeeJournalReactions)
+	if idx < 0 {
+		idx = -idx
+	}
+	return twinBeeJournalReactions[idx]
+}
+
+// handleJournalCmd renders the player's collected campaign pages.
+func (p *AdventurePlugin) handleJournalCmd(ctx MessageContext) error {
+	char, _, err := p.ensureCharacter(ctx.Sender)
+	if err != nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "Failed to load your character. Try `!adventure` to create one first.")
+	}
+	return p.SendDM(ctx.Sender, renderJournal(char.JournalPages))
+}
+
+// renderJournal builds the `!adventure journal` view: discovered pages in story
+// order, with runs of missing pages collapsed to a single "…".
+func renderJournal(mask int64) string {
+	found := journalPageCount(mask)
+	var b strings.Builder
+	b.WriteString(fmt.Sprintf("📖 **The Hollow King** — Journal (%d / %d pages)\n",
+		found, journalTotalPages))
+
+	if found == 0 {
+		b.WriteString("\nYou carry no pages yet. They surface where the realm's fragments gather — in the hands of elites, and behind doors most adventurers walk past.")
+		return b.String()
+	}
+
+	b.WriteString("\n")
+	gapOpen := false
+	for i := 1; i <= journalTotalPages; i++ {
+		if journalPageFound(mask, i) {
+			gapOpen = false
+			jp := journalPages[i-1]
+			b.WriteString(fmt.Sprintf("\n**%s. %s**\n%s\n", romanNumeral(i), jp.Title, jp.Text))
+		} else if !gapOpen {
+			gapOpen = true
+			b.WriteString("\n…\n")
+		}
+	}
+
+	if journalComplete(mask) {
+		b.WriteString("\nThe ledger is whole. Clear both Tier-5 zones and you can follow him to the end — `!expedition start epilogue`.")
+	} else {
+		b.WriteString(fmt.Sprintf("\n_%d pages still scattered._", journalTotalPages-found))
+	}
+	return b.String()
+}
+
+// romanNumeral renders 1..24 as upper-case Roman numerals for the page headers.
+// The campaign never exceeds a couple dozen pages, so a small table beats a
+// general algorithm here.
+func romanNumeral(n int) string {
+	if n < 1 || n > len(romanNumerals) {
+		return fmt.Sprintf("%d", n)
+	}
+	return romanNumerals[n-1]
+}
+
+// ── D1c: the finale ─────────────────────────────────────────────────────────
+
+// finaleTitle is the unique role awarded for the first finale clear.
+const finaleTitle = "Kingsbane"
+
+const epilogueEntryFlavor = "You bring the whole ledger to the Empty Throne. The shape kept warm against his return stirs, and stands, and is finally, fully here."
+
+// hollowKingFinaleMonster is the finale stat block: Belaxath's block — the abyss
+// boss whose gate "was meant to let one thing come home" — re-dressed as the
+// King returned in full, with HP bumped for a capstone. A variant stat block
+// with no new mechanics, per the plan. Built on the fly (not registered in
+// dndBestiary) because runZoneCombat takes the template directly, exactly as the
+// arena bosses do.
+func hollowKingFinaleMonster() DnDMonsterTemplate {
+	m := dndBestiary["boss_belaxath"]
+	m.ID = "boss_hollow_king_finale"
+	m.Name = "The Hollow King, Unhoused"
+	m.HP = int(float64(m.HP) * 1.25)
+	m.Notes = "Finale encounter — the Hollow King returned in full through the abyss gate. Variant of the Balor stat block; no new mechanics."
+	return m
+}
+
+// epilogueUnlocked gates the finale on the whole ledger plus both Tier-5 clears.
+func (p *AdventurePlugin) epilogueUnlocked(char *AdventureCharacter) (bool, string) {
+	if !journalComplete(char.JournalPages) {
+		return false, fmt.Sprintf(
+			"The trail runs cold. You've recovered **%d of %d** journal pages — find them all before you can follow him to the end. (`!adventure journal`)",
+			journalPageCount(char.JournalPages), journalTotalPages)
+	}
+	if !clearedEveryZoneOfTier(db.Get(), char.UserID, ZoneTier(5)) {
+		return false, "You hold the whole ledger, but not the standing to use it. Clear **both** Tier-5 zones — the Dragon's Lair and the Abyss Portal — then come back to the throne."
+	}
+	return true, ""
+}
+
+// handleEpilogueEncounter runs the finale: a single auto-resolved boss fight
+// against the Hollow King's true form, reached via `!expedition start epilogue`.
+// Reward drops only on the first clear (reward-once); later clears are a
+// flavour-only rematch. A loss costs a death, as any boss fight does.
+func (p *AdventurePlugin) handleEpilogueEncounter(ctx MessageContext) error {
+	char, _, err := p.ensureCharacter(ctx.Sender)
+	if err != nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "Failed to load your character. Try `!adventure` first.")
+	}
+	if !char.Alive {
+		return p.SendDM(ctx.Sender, "You're in no shape to face him. Mend at `!hospital` first.")
+	}
+	if ok, why := p.epilogueUnlocked(char); !ok {
+		return p.SendDM(ctx.Sender, why)
+	}
+	// Busy guards — the finale is a synchronous auto-resolved fight, so refuse if
+	// anything else is in flight and could collide on HP or run state.
+	if exp, _ := getActiveExpedition(ctx.Sender); exp != nil {
+		return p.SendDM(ctx.Sender, "Finish your expedition before you walk to the Empty Throne.")
+	}
+	if run, _ := getActiveZoneRun(ctx.Sender); run != nil {
+		return p.SendDM(ctx.Sender, "Finish your current zone run first.")
+	}
+	if sess, _ := getActiveCombatSession(ctx.Sender); sess != nil {
+		return p.SendDM(ctx.Sender, "You're already in a fight. Finish it first.")
+	}
+
+	monster := hollowKingFinaleMonster()
+	displayName, _ := loadDisplayName(ctx.Sender)
+	if displayName == "" {
+		displayName = "You"
+	}
+
+	preHP, _ := dndHPSnapshot(ctx.Sender)
+	result, err := p.runZoneCombat(ctx.Sender, monster, 5, bossCombatPhases, 50)
+	if err != nil {
+		slog.Error("epilogue: combat failed", "user", ctx.Sender, "err", err)
+		return p.SendDM(ctx.Sender, "Something went wrong at the throne. Try again in a moment.")
+	}
+	postHP, maxHP := dndHPSnapshot(ctx.Sender)
+	nat20s, nat1s := countNat20sAnd1s(result)
+
+	intro := fmt.Sprintf("👑 **The Empty Throne — %s** (HP %d, AC %d)\n_%s_",
+		monster.Name, monster.HP, monster.AC, epilogueEntryFlavor)
+	phases := RenderCombatLog(result, displayName, monster.Name)
+	outcome := renderBossOutcome(BossOutcomeInputs{
+		// Synthetic ZoneArena keeps twinBeeLine's deterministic pickers off any
+		// real zone's pool, exactly as the arena does.
+		ZoneID:          ZoneArena,
+		RunID:           "epilogue-" + string(ctx.Sender),
+		RoomIdx:         0,
+		Monster:         monster,
+		Result:          result,
+		PreHP:           preHP,
+		PostHP:          postHP,
+		MaxHP:           maxHP,
+		PhaseTwoAt:      0.40,
+		Nat20s:          nat20s,
+		Nat1s:           nat1s,
+		DefeatHeadline:  "💀 The Hollow King folds you into the quiet he keeps. The account goes unpaid a while longer.",
+		VictoryHeadline: fmt.Sprintf("🏆 **The Hollow King falls — and this time stays down.** You finished at **%d/%d HP**.", postHP, maxHP),
+	})
+
+	var tail string
+	if !result.PlayerWon {
+		markAdventureDead(ctx.Sender, "adventure", "the Empty Throne")
+	} else {
+		tail = p.finishEpilogueWin(ctx.Sender, char.EpilogueCleared)
+	}
+
+	_ = p.sendZoneCombatMessages(ctx.Sender, append([]string{intro}, phases...), joinLootLines(outcome, tail))
+	return nil
+}
+
+// finishEpilogueWin grants the reward on a first clear and returns the reward
+// narration; a repeat clear is flavour only. The character is reloaded before
+// the title write so runZoneCombat's post-fight HP persist isn't clobbered.
+func (p *AdventurePlugin) finishEpilogueWin(userID id.UserID, alreadyCleared bool) string {
+	if alreadyCleared {
+		return "_The throne stays empty. You came to be sure. You are sure._"
+	}
+
+	// Latch the once-only flag BEFORE handing out the Legendary + title, so a
+	// failed write (or a crash) can never leave the reward repeatable. If the
+	// latch fails, skip the grant entirely — the player re-enters uncleared and
+	// can try again, rather than pocketing a second Legendary on the retry.
+	if err := markEpilogueClearedDB(userID); err != nil {
+		slog.Error("epilogue: mark cleared failed", "user", userID, "err", err)
+		return "_The account won't quite close — the ledger jams. Try `!expedition start epilogue` again._"
+	}
+
+	var b strings.Builder
+	b.WriteString("🎖️ **The account is closed.** You are named **" + finaleTitle + "** — the one who unhoused the Hollow King.\n")
+	if mi, ok := pickMagicItemForRarity(RarityLegendary, nil); ok {
+		if line := p.dropMagicItemLoot(userID, mi, LootTierLegendary); line != "" {
+			b.WriteString(line + "\n")
+		}
+	} else {
+		slog.Error("epilogue: no legendary in registry", "user", userID)
+	}
+
+	if fresh, err := loadAdvCharacter(userID); err == nil && fresh != nil {
+		if fresh.Title != finaleTitle {
+			fresh.Title = finaleTitle
+			if err := saveAdvCharacter(fresh); err != nil {
+				slog.Error("epilogue: title save failed", "user", userID, "err", err)
+			}
+		}
+	}
+
+	if gr := gamesRoom(); gr != "" {
+		if dn, _ := loadDisplayName(userID); dn != "" {
+			p.SendMessage(id.RoomID(gr), fmt.Sprintf(
+				"👑 **%s** carried the whole ledger to the Empty Throne and closed the account. The Hollow King is ended. **%s.**",
+				dn, finaleTitle))
+		}
+	}
+	return b.String()
+}
+
+var romanNumerals = []string{
+	"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X",
+	"XI", "XII", "XIII", "XIV", "XV", "XVI", "XVII", "XVIII", "XIX", "XX",
+	"XXI", "XXII", "XXIII", "XXIV", "XXV", "XXVI", "XXVII", "XXVIII", "XXIX", "XXX",
+}

internal/plugin/adventure_flavor_campaign_test.go

@@ -0,0 +1,300 @@
+package plugin
+
+import (
+	"math/rand/v2"
+	"strings"
+	"testing"
+
+	"maunium.net/go/mautrix/id"
+)
+
+func TestJournalGrant_DBRoundTripIsAtomicOR(t *testing.T) {
+	townTestDB(t)
+	u := id.UserID("@page:test.invalid")
+
+	// No row yet → zero pages.
+	if mask, err := loadJournalPages(u); err != nil || mask != 0 {
+		t.Fatalf("fresh player: mask=%d err=%v, want 0/nil", mask, err)
+	}
+
+	// First grant creates the row (ON CONFLICT INSERT path).
+	if err := grantJournalPageDB(u, 5); err != nil {
+		t.Fatalf("grant page 5: %v", err)
+	}
+	// Second grant ORs into the existing row without clobbering the first.
+	if err := grantJournalPageDB(u, 2); err != nil {
+		t.Fatalf("grant page 2: %v", err)
+	}
+	// Re-granting a found page is idempotent.
+	if err := grantJournalPageDB(u, 5); err != nil {
+		t.Fatalf("re-grant page 5: %v", err)
+	}
+
+	mask, err := loadJournalPages(u)
+	if err != nil {
+		t.Fatalf("load: %v", err)
+	}
+	if !journalPageFound(mask, 2) || !journalPageFound(mask, 5) {
+		t.Fatalf("pages 2 and 5 should be found, mask=%b", mask)
+	}
+	if journalPageCount(mask) != 2 {
+		t.Fatalf("count=%d, want 2 (mask=%b)", journalPageCount(mask), mask)
+	}
+
+	// Overlay populates the character field the viewer reads.
+	var c AdventureCharacter
+	c.UserID = u
+	applyPlayerMetaOverlay(&c)
+	if c.JournalPages != mask {
+		t.Fatalf("overlay JournalPages=%b, want %b", c.JournalPages, mask)
+	}
+}
+
+func TestJournalCatalog_WellFormed(t *testing.T) {
+	if journalTotalPages != len(journalPages) {
+		t.Fatalf("journalTotalPages %d != len(journalPages) %d", journalTotalPages, len(journalPages))
+	}
+	if journalTotalPages < 1 || journalTotalPages > 63 {
+		t.Fatalf("journal must fit an int64 bitmask (1..63); got %d", journalTotalPages)
+	}
+	if journalTotalPages > len(romanNumerals) {
+		t.Fatalf("more pages (%d) than roman numerals (%d)", journalTotalPages, len(romanNumerals))
+	}
+	seen := map[string]bool{}
+	for i, jp := range journalPages {
+		if strings.TrimSpace(jp.Title) == "" {
+			t.Errorf("page %d has empty title", i+1)
+		}
+		if strings.TrimSpace(jp.Text) == "" {
+			t.Errorf("page %d (%q) has empty text", i+1, jp.Title)
+		}
+		if seen[jp.Title] {
+			t.Errorf("duplicate page title %q", jp.Title)
+		}
+		seen[jp.Title] = true
+	}
+}
+
+func TestJournalBitmask_GrantQueryCount(t *testing.T) {
+	var mask int64
+	if journalPageCount(mask) != 0 {
+		t.Fatalf("empty mask should count 0")
+	}
+	if journalPageFound(mask, 1) {
+		t.Fatalf("page 1 should be unfound on empty mask")
+	}
+	mask = setJournalPageBit(mask, 3)
+	mask = setJournalPageBit(mask, 1)
+	if !journalPageFound(mask, 3) || !journalPageFound(mask, 1) {
+		t.Fatalf("pages 1 and 3 should be found")
+	}
+	if journalPageFound(mask, 2) {
+		t.Fatalf("page 2 should still be unfound")
+	}
+	if got := journalPageCount(mask); got != 2 {
+		t.Fatalf("count = %d, want 2", got)
+	}
+	// Re-setting a found page is idempotent.
+	if again := setJournalPageBit(mask, 3); again != mask {
+		t.Fatalf("re-granting page 3 changed the mask")
+	}
+}
+
+func TestPickUnfoundJournalPage_ExhaustsToZero(t *testing.T) {
+	rng := rand.New(rand.NewPCG(1, 2))
+	var mask int64
+	found := map[int]bool{}
+	for i := 0; i < journalTotalPages; i++ {
+		page := pickUnfoundJournalPage(mask, rng)
+		if page < 1 || page > journalTotalPages {
+			t.Fatalf("pick %d out of range", page)
+		}
+		if found[page] {
+			t.Fatalf("pick returned already-found page %d", page)
+		}
+		found[page] = true
+		mask = setJournalPageBit(mask, page)
+	}
+	if !journalComplete(mask) {
+		t.Fatalf("mask should be complete after %d picks", journalTotalPages)
+	}
+	if page := pickUnfoundJournalPage(mask, rng); page != 0 {
+		t.Fatalf("pick on complete mask = %d, want 0", page)
+	}
+}
+
+func TestRenderJournal_EmptyPartialFull(t *testing.T) {
+	// Empty.
+	empty := renderJournal(0)
+	if !strings.Contains(empty, "0 / ") {
+		t.Errorf("empty journal should show 0 found:\n%s", empty)
+	}
+	if strings.Contains(empty, "…") {
+		t.Errorf("empty journal should not render a gap marker:\n%s", empty)
+	}
+
+	// Partial with a gap: pages 1 and 3 found, 2 missing → exactly one "…".
+	var partial int64
+	partial = setJournalPageBit(partial, 1)
+	partial = setJournalPageBit(partial, 3)
+	pv := renderJournal(partial)
+	if !strings.Contains(pv, journalPages[0].Title) || !strings.Contains(pv, journalPages[2].Title) {
+		t.Errorf("partial journal missing a found page title:\n%s", pv)
+	}
+	if strings.Contains(pv, journalPages[1].Title) {
+		t.Errorf("partial journal leaked an unfound page's text:\n%s", pv)
+	}
+	if !strings.Contains(pv, "…") {
+		t.Errorf("partial journal with a gap should render '…':\n%s", pv)
+	}
+
+	// Full: every title present, no gap, completion line.
+	var full int64
+	for i := 1; i <= journalTotalPages; i++ {
+		full = setJournalPageBit(full, i)
+	}
+	fv := renderJournal(full)
+	if strings.Contains(fv, "…") {
+		t.Errorf("complete journal should have no gaps:\n%s", fv)
+	}
+	for _, jp := range journalPages {
+		if !strings.Contains(fv, jp.Title) {
+			t.Errorf("complete journal missing page %q", jp.Title)
+		}
+	}
+	if !journalComplete(full) {
+		t.Fatalf("full mask should be complete")
+	}
+}
+
+func TestJournalDropChance_Sane(t *testing.T) {
+	if journalPageDropChance <= 0 || journalPageDropChance >= 1 {
+		t.Fatalf("drop chance %v out of (0,1)", journalPageDropChance)
+	}
+}
+
+func TestBossEpilogues_EveryRegisteredZoneHasOne(t *testing.T) {
+	for _, z := range allZones() {
+		if strings.TrimSpace(bossEpilogueLine(z.ID)) == "" {
+			t.Errorf("zone %s (%s) has no boss epilogue", z.ID, z.Display)
+		}
+	}
+	// The synthetic arena is not a campaign zone — it must have none.
+	if bossEpilogueLine(ZoneArena) != "" {
+		t.Errorf("arena should have no boss epilogue")
+	}
+	if bossEpilogueLine(ZoneID("nonexistent")) != "" {
+		t.Errorf("unknown zone should have no epilogue")
+	}
+}
+
+func TestHollowKingFinaleMonster_ClonesBelaxathWithBump(t *testing.T) {
+	base := dndBestiary["boss_belaxath"]
+	if base.ID == "" {
+		t.Fatal("boss_belaxath missing from bestiary — finale clones it")
+	}
+	m := hollowKingFinaleMonster()
+	if m.ID != "boss_hollow_king_finale" {
+		t.Errorf("finale ID = %q", m.ID)
+	}
+	if m.Name == base.Name || m.Name == "" {
+		t.Errorf("finale name should differ from Belaxath: %q", m.Name)
+	}
+	if m.HP <= base.HP {
+		t.Errorf("finale HP %d should exceed base %d (capstone bump)", m.HP, base.HP)
+	}
+	// No new mechanics: the ability and defensive profile carry over unchanged.
+	if m.Ability != base.Ability {
+		t.Errorf("finale ability pointer changed — should reuse Belaxath's, no new mechanics")
+	}
+	if m.AC != base.AC || m.CR != base.CR {
+		t.Errorf("finale AC/CR drifted from base: AC %d/%d CR %v/%v", m.AC, base.AC, m.CR, base.CR)
+	}
+}
+
+func TestEpilogueRewardOnce_FlagRoundTrip(t *testing.T) {
+	townTestDB(t)
+	u := id.UserID("@finale:test.invalid")
+
+	if got, err := loadEpilogueCleared(u); err != nil || got {
+		t.Fatalf("fresh player: cleared=%v err=%v, want false/nil", got, err)
+	}
+	if err := markEpilogueClearedDB(u); err != nil {
+		t.Fatalf("mark cleared: %v", err)
+	}
+	if got, err := loadEpilogueCleared(u); err != nil || !got {
+		t.Fatalf("after mark: cleared=%v err=%v, want true/nil", got, err)
+	}
+	// Idempotent.
+	if err := markEpilogueClearedDB(u); err != nil {
+		t.Fatalf("re-mark: %v", err)
+	}
+
+	var c AdventureCharacter
+	c.UserID = u
+	applyPlayerMetaOverlay(&c)
+	if !c.EpilogueCleared {
+		t.Fatalf("overlay did not carry EpilogueCleared")
+	}
+}
+
+func TestEpilogueUnlocked_Gates(t *testing.T) {
+	townTestDB(t)
+	p := &AdventurePlugin{}
+
+	// Incomplete journal → refused, page-count message.
+	partial := &AdventureCharacter{UserID: id.UserID("@u1:test.invalid")}
+	partial.JournalPages = setJournalPageBit(0, 1)
+	ok, why := p.epilogueUnlocked(partial)
+	if ok {
+		t.Fatalf("incomplete journal should not unlock")
+	}
+	if !strings.Contains(why, "journal pages") {
+		t.Errorf("expected page-count refusal, got: %s", why)
+	}
+
+	// Complete journal but no Tier-5 clears → refused, T5 message.
+	full := &AdventureCharacter{UserID: id.UserID("@u2:test.invalid")}
+	for i := 1; i <= journalTotalPages; i++ {
+		full.JournalPages = setJournalPageBit(full.JournalPages, i)
+	}
+	ok, why = p.epilogueUnlocked(full)
+	if ok {
+		t.Fatalf("no T5 clears should not unlock")
+	}
+	if !strings.Contains(why, "Tier-5") {
+		t.Errorf("expected Tier-5 refusal, got: %s", why)
+	}
+}
+
+func TestFinishEpilogueWin_RepeatIsFlavorOnly(t *testing.T) {
+	// The already-cleared branch is pure flavour: no reward, no client calls.
+	p := &AdventurePlugin{}
+	repeat := p.finishEpilogueWin(id.UserID("@u:test.invalid"), true)
+	if strings.Contains(repeat, finaleTitle) {
+		t.Errorf("a repeat clear must not re-award the title: %s", repeat)
+	}
+	if strings.TrimSpace(repeat) == "" {
+		t.Errorf("a repeat clear should still say something")
+	}
+}
+
+func TestTwinBeeJournalReaction_DeterministicAndGuarded(t *testing.T) {
+	if twinBeeJournalReaction(3, 0) != "" {
+		t.Errorf("zero pages should produce no reaction")
+	}
+	first := twinBeeJournalReaction(3, 2)
+	if first == "" {
+		t.Fatalf("a found page should produce a reaction")
+	}
+	if again := twinBeeJournalReaction(3, 2); again != first {
+		t.Errorf("reaction not deterministic: %q vs %q", first, again)
+	}
+	// Voice guard: TwinBee never speaks of himself in the third person
+	// (feedback_twinbee_voice). None of the pooled lines may contain "TwinBee".
+	for _, line := range twinBeeJournalReactions {
+		if strings.Contains(line, "TwinBee") {
+			t.Errorf("third-person TwinBee reference in reaction: %q", line)
+		}
+	}
+}

internal/plugin/adventure_flavor_dungeon.go

@@ -924,4 +924,4 @@ var DungeonExceptional = map[int][]string{
 			"in a dungeon. Write it down. " +
 			"The dungeon will tell this story differently.",
 	},
-}
+}

internal/plugin/adventure_flavor_npcs.go

@@ -24,6 +24,31 @@ var mistyAcceptLines = []string{
 
 const mistyDeclineLine = "She nods once and walks away. She doesn't look back."
 
+// ── Misty — Arc Beats (D2) ─────────────────────────────────────────────────
+//
+// Three deepening dialogue beats keyed to MistyEncounterCount (5 / 15 / 30),
+// prepended to the encounter opening the one time the counter lands on a
+// threshold. Fiction only: nothing here connects a donation to a combat
+// outcome — the arena effects are a hidden discovery mechanic and stay hidden.
+var mistyArcBeats = map[int]string{
+	5: "It's you again. I was hoping it would be. I know your face now -- you're one of the few who ever stops. " +
+		"Most people look right through me. You never have.",
+
+	15: "Can I tell you something? I wasn't always out here asking strangers on the road. " +
+		"I had a home once. A garden that got away from me every summer. Someone who used to wait up. " +
+		"It's gone now, all of it. But you keep reminding me there are still kind people in the world. That's not nothing.",
+
+	30: "I don't think of you as a stranger anymore. Is it strange to say that? " +
+		"I catch myself watching the road for you now -- not for the gold, though I won't pretend it doesn't help. " +
+		"Just to see you're still standing. Whatever's out there, I hope it knows better than to take you from me too.",
+}
+
+// mistyArcBeat returns the deepening dialogue for the exact encounter count at
+// which a Misty stage lands, or "" for every other encounter.
+func mistyArcBeat(encounterCount int) string {
+	return mistyArcBeats[encounterCount]
+}
+
 // ── Arina — Opening Lines ──────────────────────────────────────────────────
 
 var arinaOpenings = []string{

internal/plugin/adventure_flavor_pets.go

@@ -275,6 +275,7 @@ var PetCatDeflect = []string{
 		"Your cat is already somewhere else.\n\nIt blinks.\n\nNot at you.\n\nAt nothing.\n\n" +
 		"The way cats do.",
 }
+
 // Fires randomly in the morning DM. Cat has left something.
 // Results in a defense boost for the day.
 // The cat is proud. The cat will never stop doing this.

internal/plugin/adventure_flavor_robbie.go

@@ -40,6 +40,11 @@ var robbieMasterworkAlreadyHas = "Oh. I see you already have one of these. Excel
 var robbieAllShopGear = "Nothing fancy today but that's alright. Clean inventory is its own reward. " +
 	"Well. The €%d is the reward. The clean inventory is a bonus. Cheerio!"
 
+// robbieLeftConsumable is appended when Robbie leaves a little something on his
+// every-10th-visit (D2). Takes the item name.
+var robbieLeftConsumable = "Oh -- one more thing. I tucked a %s into your bag on the way out. " +
+	"You've had me round enough times now that it felt rude not to. For the trouble, eh? _winks_"
+
 // ── Room Announcements ───────────────────────────────────────────────────────
 
 var robbieRoomStandard = "🎩 Robbie paid %s a visit and collected %d item(s) from their inventory. " +

internal/plugin/adventure_followups_test.go

@@ -97,12 +97,12 @@ func TestAdvMasteryRowSegment(t *testing.T) {
 
 func TestAdvMasteryRollup(t *testing.T) {
 	cases := []struct {
-		name             string
-		used             map[EquipmentSlot]int
-		wantCrossed      int
-		wantMaxed        int
-		wantBonus        float64
-		wantAnyProgress  bool
+		name            string
+		used            map[EquipmentSlot]int
+		wantCrossed     int
+		wantMaxed       int
+		wantBonus       float64
+		wantAnyProgress bool
 	}{
 		{"empty", nil, 0, 0, 0, false},
 		{"sub-50 only", map[EquipmentSlot]int{SlotWeapon: 30}, 0, 0, 0, true},
@@ -240,12 +240,12 @@ func TestAdvTreasureIrreplaceable(t *testing.T) {
 
 func TestRenderCraftingTeaser_BracketBoundaries(t *testing.T) {
 	cases := []struct {
-		name             string
-		foraging         int
-		craftsSucceeded  int
-		wantEmpty        bool
-		wantContainsAny  []string // any of these (OR)
-		wantNotContains  []string
+		name            string
+		foraging        int
+		craftsSucceeded int
+		wantEmpty       bool
+		wantContainsAny []string // any of these (OR)
+		wantNotContains []string
 	}{
 		{"foraging 6 — out of pre-window", 6, 0, true, nil, nil},
 		{"foraging 7 — pre-unlock with 3 levels left, plural", 7, 0, false, []string{"3 Foraging level"}, []string{"unlocks in 1 ", "unlocks in 0"}},
@@ -297,7 +297,7 @@ func TestCraftingReminderWeekday_Spread(t *testing.T) {
 
 func TestCraftingReminderWeekday_StableWithinWeek(t *testing.T) {
 	uid := id.UserID("@stable:test")
-	mon := time.Date(2026, 5, 4, 0, 0, 0, 0, time.UTC) // Monday
+	mon := time.Date(2026, 5, 4, 0, 0, 0, 0, time.UTC)   // Monday
 	sun := time.Date(2026, 5, 10, 23, 0, 0, 0, time.UTC) // Sunday same ISO week
 	if craftingReminderWeekday(uid, mon) != craftingReminderWeekday(uid, sun) {
 		t.Error("weekday should be stable within an ISO week")

internal/plugin/adventure_gifting.go

@@ -0,0 +1,200 @@
+package plugin
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"time"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// N4/E2 item gifting. `!give <item> @user` hands a consumable or non-magic gear
+// item to another adventurer. The sender pays a 5% handling fee (of item value)
+// to the community pot — the same civic tax every payout pays — and is capped at
+// a few gifts a day so the feature can't become a twink-funnel for a fresh alt.
+// Magic items are deliberately non-giftable: attunement and the BiS economy stay
+// personal (gogobee_engagement_plan.md §E2).
+const (
+	giftDailyCap = 3
+	giftTaxRate  = 0.05
+)
+
+// giftableTypes is the allowlist of AdvItem.Type values a player may gift.
+// Everything in adventure_inventory is unequipped by definition (equipped gear
+// lives in adventure_equipment / magic_item_equipped), so "unequipped" needs no
+// separate check. Magic items ("magic_item") and raw materials are excluded.
+var giftableTypes = map[string]bool{
+	"consumable":     true,
+	"MasterworkGear": true,
+	"ArenaGear":      true,
+}
+
+// isGiftableItem reports whether an inventory item may be gifted, and a reason
+// when it may not.
+func isGiftableItem(it AdvItem) (bool, string) {
+	if it.Type == "magic_item" {
+		return false, "Magic items stay personal — attunement doesn't transfer. Try a consumable or a piece of gear."
+	}
+	if !giftableTypes[it.Type] {
+		return false, "You can only gift consumables and non-magic gear. Raw materials and treasures aren't giftable."
+	}
+	return true, ""
+}
+
+// pickGiftableItem resolves the item a `!give` query names, preferring a giftable
+// match so a non-giftable item (a magic item, raw materials) that also matches
+// can't shadow a giftable one and block the gift — the way plain findInventoryMatch
+// would, since it returns the first match across the whole inventory. Returns
+// (item, "") on success; (nil, "") when nothing matches at all; and (nil, reason)
+// when only non-giftable items match, so the caller can explain why.
+func pickGiftableItem(inv []AdvItem, query string) (*AdvItem, string) {
+	match := findInventoryMatch(inv, query)
+	if match == nil {
+		return nil, ""
+	}
+	if ok, _ := isGiftableItem(*match); ok {
+		return match, ""
+	}
+	giftables := make([]AdvItem, 0, len(inv))
+	for _, it := range inv {
+		if ok, _ := isGiftableItem(it); ok {
+			giftables = append(giftables, it)
+		}
+	}
+	if alt := findInventoryMatch(giftables, query); alt != nil {
+		return alt, ""
+	}
+	_, reason := isGiftableItem(*match)
+	return nil, reason
+}
+
+// giftCountToday returns how many gifts the sender has already sent on the given
+// UTC day. The cap is enforced against the persisted log, so a restart can't
+// reset someone's daily allowance.
+func giftCountToday(sender id.UserID, day string) int {
+	var n int
+	_ = db.Get().QueryRow(
+		`SELECT COUNT(*) FROM adventure_gift_log WHERE sender = ? AND gift_day = ?`,
+		string(sender), day).Scan(&n)
+	return n
+}
+
+// logGift records a completed gift for the daily cap and the audit trail.
+func logGift(sender, recipient id.UserID, itemName string, value int64, day string) error {
+	_, err := db.Get().Exec(
+		`INSERT INTO adventure_gift_log (sender, recipient, item_name, value, gift_day)
+		 VALUES (?, ?, ?, ?, ?)`,
+		string(sender), string(recipient), itemName, value, day)
+	return err
+}
+
+// transferInventoryItem moves one inventory row from one owner to another. Scoped
+// to the current owner so a stale id can't move a row that has already changed
+// hands, and forces in_vault=0 so a gift always lands in the recipient's active
+// pack rather than a phantom vault slot.
+func transferInventoryItem(itemID int64, from, to id.UserID) (bool, error) {
+	res, err := db.Get().Exec(
+		`UPDATE adventure_inventory SET user_id = ?, in_vault = 0 WHERE id = ? AND user_id = ?`,
+		string(to), itemID, string(from))
+	if err != nil {
+		return false, err
+	}
+	n, _ := res.RowsAffected()
+	return n > 0, nil
+}
+
+// handleGiveCmd routes `!give <item> @user`.
+func (p *AdventurePlugin) handleGiveCmd(ctx MessageContext) error {
+	args := strings.TrimSpace(p.GetArgs(ctx.Body, "give"))
+
+	// Serialize a sender's own gifts so two near-simultaneous !give commands
+	// can't both clear the daily cap or double-spend the same item row.
+	userMu := p.advUserLock(ctx.Sender)
+	userMu.Lock()
+	defer userMu.Unlock()
+
+	char, _, err := p.ensureCharacter(ctx.Sender)
+	if err != nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "Failed to load your character. Try `!adventure` to create one first.")
+	}
+	if !char.Alive {
+		return p.SendDM(ctx.Sender, "You're dead. Your things stay where they are for now.")
+	}
+
+	// The target is the trailing token; everything before it is the item name.
+	fields := strings.Fields(args)
+	if len(fields) < 2 {
+		return p.SendDM(ctx.Sender, "Usage: `!give <item> @user` — e.g. `!give Health Potion @alex`.")
+	}
+	targetRaw := fields[len(fields)-1]
+	itemQuery := strings.TrimSpace(strings.TrimSuffix(args, targetRaw))
+
+	target, ok := p.ResolveUser(targetRaw, ctx.RoomID)
+	if !ok {
+		return p.SendDM(ctx.Sender, fmt.Sprintf("Couldn't find a user matching %q. Mention them or use their exact name.", targetRaw))
+	}
+	if target == ctx.Sender {
+		return p.SendDM(ctx.Sender, "Regifting to yourself? That's just moving things around.")
+	}
+
+	// Recipient must have completed !setup.
+	rc, rerr := LoadDnDCharacter(target)
+	if rerr != nil || rc == nil || rc.PendingSetup {
+		name := p.DisplayName(target)
+		return p.SendDM(ctx.Sender, fmt.Sprintf("%s hasn't set up an adventurer yet — they need to run `!setup` before they can receive gifts.", name))
+	}
+
+	day := time.Now().UTC().Format("2006-01-02")
+	if sent := giftCountToday(ctx.Sender, day); sent >= giftDailyCap {
+		return p.SendDM(ctx.Sender, fmt.Sprintf("You've already sent %d gifts today (the daily limit). Try again tomorrow.", sent))
+	}
+
+	inv, err := loadAdvInventory(ctx.Sender)
+	if err != nil {
+		return p.SendDM(ctx.Sender, "Couldn't reach your inventory. Try again in a moment.")
+	}
+	match, reason := pickGiftableItem(inv, itemQuery)
+	if match == nil {
+		if reason == "" {
+			return p.SendDM(ctx.Sender, fmt.Sprintf("No inventory item matches %q. Check `!adventure inventory`.", itemQuery))
+		}
+		return p.SendDM(ctx.Sender, reason)
+	}
+
+	tax := int(math.Round(float64(match.Value) * giftTaxRate))
+	if tax > 0 {
+		if bal := p.euro.GetBalance(ctx.Sender); bal < float64(tax) {
+			return p.SendDM(ctx.Sender, fmt.Sprintf("Gifting **%s** carries a €%d handling fee (5%% of its value), and you only have €%.0f.", match.Name, tax, bal))
+		}
+		if !p.euro.Debit(ctx.Sender, float64(tax), "adventure_gift_tax") {
+			return p.SendDM(ctx.Sender, "Transaction failed. The economy is having a moment.")
+		}
+	}
+
+	moved, err := transferInventoryItem(match.ID, ctx.Sender, target)
+	if err != nil || !moved {
+		if tax > 0 {
+			p.euro.Credit(ctx.Sender, float64(tax), "adventure_gift_refund")
+		}
+		return p.SendDM(ctx.Sender, "Couldn't hand the item over. Nothing changed — try again in a moment.")
+	}
+	if tax > 0 {
+		communityPotAdd(tax)
+		trackTaxPaid(ctx.Sender, tax)
+	}
+	_ = logGift(ctx.Sender, target, match.Name, match.Value, day)
+
+	senderName := p.DisplayName(ctx.Sender)
+	recipName := p.DisplayName(target)
+	_ = p.SendDM(target, fmt.Sprintf("🎁 **%s** sent you **%s**! It's in your inventory now — `!adventure inventory` to take a look.", senderName, match.Name))
+
+	remaining := giftDailyCap - giftCountToday(ctx.Sender, day)
+	feeNote := ""
+	if tax > 0 {
+		feeNote = fmt.Sprintf(" (€%d handling fee to the community pot)", tax)
+	}
+	return p.SendDM(ctx.Sender, fmt.Sprintf("🎁 Sent **%s** to %s%s. %d gift(s) left today.", match.Name, recipName, feeNote, remaining))
+}

internal/plugin/adventure_gifting_test.go

@@ -0,0 +1,145 @@
+package plugin
+
+import (
+	"testing"
+
+	"maunium.net/go/mautrix/id"
+)
+
+func TestIsGiftableItem(t *testing.T) {
+	cases := []struct {
+		typ  string
+		want bool
+	}{
+		{"consumable", true},
+		{"MasterworkGear", true},
+		{"ArenaGear", true},
+		{"magic_item", false},
+		{"treasure", false},
+		{"ore", false},
+		{"card", false},
+	}
+	for _, c := range cases {
+		got, reason := isGiftableItem(AdvItem{Type: c.typ, Name: "X"})
+		if got != c.want {
+			t.Errorf("isGiftableItem(%q) = %v, want %v (reason %q)", c.typ, got, c.want, reason)
+		}
+		if !got && reason == "" {
+			t.Errorf("isGiftableItem(%q) rejected with no reason", c.typ)
+		}
+	}
+}
+
+// TestPickGiftableItem: a non-giftable item must not shadow a giftable one that
+// also matches the query.
+func TestPickGiftableItem(t *testing.T) {
+	inv := []AdvItem{
+		{ID: 1, Name: "Dragon Scale", Type: "material", Tier: 5, Value: 9000},
+		{ID: 2, Name: "Dragon Draught", Type: "consumable", Tier: 1, Value: 200},
+	}
+	// "dragon" matches the Scale first (higher tier), but the Draught is the
+	// giftable one — pick it, don't refuse.
+	got, reason := pickGiftableItem(inv, "dragon")
+	if got == nil {
+		t.Fatalf("pickGiftableItem returned nil (reason %q), want the giftable Draught", reason)
+	}
+	if got.Name != "Dragon Draught" {
+		t.Errorf("picked %q, want Dragon Draught", got.Name)
+	}
+
+	// Only a non-giftable match → refuse with a reason.
+	onlyMagic := []AdvItem{{ID: 3, Name: "Ring of Power", Type: "magic_item", Value: 5000}}
+	got, reason = pickGiftableItem(onlyMagic, "ring")
+	if got != nil || reason == "" {
+		t.Errorf("magic-only match: got=%v reason=%q, want nil with a refusal reason", got, reason)
+	}
+
+	// No match at all → nil, empty reason.
+	got, reason = pickGiftableItem(inv, "nonexistent")
+	if got != nil || reason != "" {
+		t.Errorf("no match: got=%v reason=%q, want nil/empty", got, reason)
+	}
+}
+
+// TestTransferInventoryItem: an item moves owners exactly, and a wrong-owner
+// transfer is a no-op.
+func TestTransferInventoryItem(t *testing.T) {
+	vaultTestDB(t)
+	alice := id.UserID("@alice:test.invalid")
+	bob := id.UserID("@bob:test.invalid")
+	if err := addAdvInventoryItem(alice, AdvItem{Name: "Health Potion", Type: "consumable", Tier: 1, Value: 200}); err != nil {
+		t.Fatal(err)
+	}
+	inv, _ := loadAdvInventory(alice)
+	if len(inv) != 1 {
+		t.Fatalf("setup: alice has %d items, want 1", len(inv))
+	}
+	itemID := inv[0].ID
+
+	// Wrong owner can't move it.
+	if moved, err := transferInventoryItem(itemID, bob, alice); err != nil || moved {
+		t.Fatalf("wrong-owner transfer moved=%v err=%v, want no-op", moved, err)
+	}
+
+	// Real owner moves it to bob.
+	moved, err := transferInventoryItem(itemID, alice, bob)
+	if err != nil || !moved {
+		t.Fatalf("transfer moved=%v err=%v, want success", moved, err)
+	}
+	if a, _ := loadAdvInventory(alice); len(a) != 0 {
+		t.Errorf("alice still has %d items after gifting", len(a))
+	}
+	b, _ := loadAdvInventory(bob)
+	if len(b) != 1 || b[0].Name != "Health Potion" {
+		t.Errorf("bob's inventory = %+v, want the potion", b)
+	}
+}
+
+// TestTransferUnvaultsItem: gifting a currently-vaulted item lands it in the
+// recipient's active pack, not a phantom vault slot.
+func TestTransferUnvaultsItem(t *testing.T) {
+	vaultTestDB(t)
+	alice := id.UserID("@alice2:test.invalid")
+	bob := id.UserID("@bob2:test.invalid")
+	if err := addAdvInventoryItem(alice, AdvItem{Name: "Elixir", Type: "consumable", Tier: 1, Value: 100}); err != nil {
+		t.Fatal(err)
+	}
+	inv, _ := loadAdvInventory(alice)
+	if _, err := setItemVaulted(alice, inv[0].ID, true); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := transferInventoryItem(inv[0].ID, alice, bob); err != nil {
+		t.Fatal(err)
+	}
+	// Bob sees it in active inventory (not vault).
+	if b, _ := loadAdvInventory(bob); len(b) != 1 {
+		t.Errorf("bob active inventory = %d, want 1 (item un-vaulted on gift)", len(b))
+	}
+	if bv, _ := loadAdvVault(bob); len(bv) != 0 {
+		t.Errorf("bob vault = %d, want 0", len(bv))
+	}
+}
+
+// TestGiftDailyCapCounting: logGift increments the day's count and the count is
+// day-scoped.
+func TestGiftDailyCapCounting(t *testing.T) {
+	vaultTestDB(t)
+	sender := id.UserID("@giver:test.invalid")
+	recip := id.UserID("@taker:test.invalid")
+
+	if n := giftCountToday(sender, "2026-07-10"); n != 0 {
+		t.Fatalf("initial count = %d, want 0", n)
+	}
+	for i := 0; i < giftDailyCap; i++ {
+		if err := logGift(sender, recip, "Potion", 100, "2026-07-10"); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if n := giftCountToday(sender, "2026-07-10"); n != giftDailyCap {
+		t.Errorf("count = %d, want %d", n, giftDailyCap)
+	}
+	// A different day is a fresh allowance.
+	if n := giftCountToday(sender, "2026-07-11"); n != 0 {
+		t.Errorf("next-day count = %d, want 0", n)
+	}
+}

internal/plugin/adventure_hospital.go

@@ -207,7 +207,7 @@ func (p *AdventurePlugin) handleHospitalCmd(ctx MessageContext) error {
 
 	// Store pending interaction
 	p.pending.Store(string(ctx.Sender), &advPendingInteraction{
-		Type:      "hospital_pay",
+		Type: "hospital_pay",
 		Data: &advPendingHospitalPay{
 			Cost:       afterInsurance,
 			Discounted: haggleOutcome == haggleWin,
@@ -277,7 +277,7 @@ func (p *AdventurePlugin) resolveHospitalPay(ctx MessageContext, interaction *ad
 			gr := gamesRoom()
 			if gr != "" {
 				name, _ := loadDisplayName(char.UserID)
-			p.SendMessage(gr, fmt.Sprintf(hospitalDitchAnnounce, name))
+				p.SendMessage(gr, fmt.Sprintf(hospitalDitchAnnounce, name))
 			}
 			return nil
 		}

internal/plugin/adventure_housing.go

@@ -99,12 +99,16 @@ type advPendingHouseDownPayment struct {
 
 type advPendingHouseAutopay struct{}
 
-type advPendingPetArrival struct{}
+// Slot is the pet slot the arrival conversation is filling: 1 (the first pet)
+// or 2 (the Tier-4 Estate's second companion). Zero-value 1 keeps every
+// existing single-pet interaction unchanged.
+type advPendingPetArrival struct{ Slot int }
 
-type advPendingPetType struct{}
+type advPendingPetType struct{ Slot int }
 
 type advPendingPetName struct {
 	PetType string
+	Slot    int
 }
 
 // ── Thom Krooke Greeting ───────────────────────────────────────────────────
@@ -142,6 +146,18 @@ var thomFreezePet = "Ten missed payments. I've stopped trying for now. The house
 var thomPaidOffNoPet = "Paid off. Noted. The next tier is available when you're ready. I'll be here."
 var thomPaidOffPet = "Paid off. Good. Come in when you're ready for the next tier. I've been thinking about what %s would need in a better space. I have thoughts."
 
+// thomPetTreatItem is the keepsake Thom leaves for the pet on the final
+// mortgage payoff. Inert (Type "card" like the medical-debt card): not a
+// consumable, not gear, and Robbie's sweep skips it.
+func thomPetTreatItem() AdvItem {
+	return AdvItem{
+		Name:  "Krooke's Finest Pet Treat",
+		Type:  "card",
+		Tier:  0,
+		Value: 0,
+	}
+}
+
 // thomGreeting returns an appropriate greeting based on pet state.
 func thomGreeting(char *AdventureCharacter) string {
 	if char.HasPet() && char.PetLevel >= 10 {
@@ -221,11 +237,19 @@ func thomShopView(char *AdventureCharacter, balance float64) string {
 		}
 	}
 
-	// Pet supply shop (unlocks 1 week after pet level 10)
-	if char.PetSupplyShopUnlocked && char.HasPet() {
+	// Pet supply shop (unlocks 1 week after pet level 10). The unlock is a
+	// pet-1 mechanic but covers barding for both companions. Each pet's block is
+	// gated on its own presence so a chased-away pet-1 doesn't hide pet-2's shop.
+	if char.PetSupplyShopUnlocked && (char.HasPet() || char.HasPet2()) {
 		sb.WriteString("\n---\n")
-		sb.WriteString(fmt.Sprintf("🐾 **Pet Supplies** — for %s\n\n", char.PetName))
-		sb.WriteString(petArmorShopView(char))
+		if char.HasPet() {
+			sb.WriteString(fmt.Sprintf("🐾 **Pet Supplies** — for %s\n\n", char.PetName))
+			sb.WriteString(petArmorShopView(char.PetType, char.PetArmorTier, "petbuy"))
+		}
+		if char.HasPet2() {
+			sb.WriteString(fmt.Sprintf("\n🐾 **Pet Supplies** — for %s\n\n", char.Pet2Name))
+			sb.WriteString(petArmorShopView(char.Pet2Type, char.Pet2ArmorTier, "pet2buy"))
+		}
 	}
 
 	return sb.String()
@@ -269,8 +293,11 @@ func (p *AdventurePlugin) handleThomCmd(ctx MessageContext) error {
 	case lower == "buy" || strings.HasPrefix(lower, "buy "):
 		return p.handleThomBuy(ctx, char, balance, strings.TrimSpace(strings.TrimPrefix(lower, "buy")))
 
+	case strings.HasPrefix(lower, "pet2buy "):
+		return p.petArmorBuyForSlot(ctx, strings.TrimSpace(args[8:]), 2)
+
 	case strings.HasPrefix(lower, "petbuy "):
-		return p.handlePetArmorBuy(ctx, char, strings.TrimSpace(args[7:]))
+		return p.petArmorBuyForSlot(ctx, strings.TrimSpace(args[7:]), 1)
 
 	default:
 		return p.SendDM(ctx.Sender, "Unknown command. Type `!thom` to visit Krooke Realty.")
@@ -538,11 +565,22 @@ func (p *AdventurePlugin) processMortgagePayments() {
 				freshChar.HouseLoanBalance = 0
 				freshChar.HouseMissedPayments = 0
 				_ = saveAdvCharacter(freshChar)
+				// The last house: no next tier means Thom is done with this
+				// player. A letter, and a treat in the bag if they keep a pet.
+				finalPayoff := houseNextTier(freshChar.HouseTier) == nil
+				if finalPayoff && freshChar.HasPet() {
+					_ = addAdvInventoryItem(freshChar.UserID, thomPetTreatItem())
+				}
 				userMu.Unlock()
-				// Paid off!
-				if freshChar.HasPet() {
+				switch {
+				case finalPayoff && freshChar.HasPet():
+					letter := strings.ReplaceAll(thomFinalLetterPet, "{pet}", freshChar.PetName)
+					_ = p.SendDM(freshChar.UserID, "🏠 "+letter)
+				case finalPayoff:
+					_ = p.SendDM(freshChar.UserID, "🏠 "+thomFinalLetterNoPet)
+				case freshChar.HasPet():
 					_ = p.SendDM(freshChar.UserID, fmt.Sprintf("🏠 %s", fmt.Sprintf(thomPaidOffPet, freshChar.PetName)))
-				} else {
+				default:
 					_ = p.SendDM(freshChar.UserID, fmt.Sprintf("🏠 %s", thomPaidOffNoPet))
 				}
 				continue
@@ -673,18 +711,18 @@ func petArmorDefs(petType string) []PetArmorDef {
 	return petCatArmor
 }
 
-func petArmorShopView(char *AdventureCharacter) string {
+func petArmorShopView(petType string, armorTier int, buyCmd string) string {
 	var sb strings.Builder
-	defs := petArmorDefs(char.PetType)
+	defs := petArmorDefs(petType)
 
-	if char.PetArmorTier >= 5 {
+	if armorTier >= 5 {
 		sb.WriteString("✨ Max pet armor tier reached. There is nothing left to buy.\n")
 		return sb.String()
 	}
 
 	for _, def := range defs {
-		if def.Tier <= char.PetArmorTier {
-			if def.Tier == char.PetArmorTier {
+		if def.Tier <= armorTier {
+			if def.Tier == armorTier {
 				sb.WriteString(fmt.Sprintf("🟢 %s (T%d) — Currently equipped\n", def.Name, def.Tier))
 			}
 			continue
@@ -692,11 +730,14 @@ func petArmorShopView(char *AdventureCharacter) string {
 		indicator := "⬆️"
 		sb.WriteString(fmt.Sprintf("%s %s (T%d) — €%d — +%.1f%% deflect\n", indicator, def.Name, def.Tier, def.Price, def.DeflectBonus*100))
 	}
-	sb.WriteString(fmt.Sprintf("\nTo buy: `!thom petbuy <tier>` (e.g., `!thom petbuy %d`)", char.PetArmorTier+1))
+	sb.WriteString(fmt.Sprintf("\nTo buy: `!thom %s <tier>` (e.g., `!thom %s %d`)", buyCmd, buyCmd, armorTier+1))
 	return sb.String()
 }
 
-func (p *AdventurePlugin) handlePetArmorBuy(ctx MessageContext, char *AdventureCharacter, tierStr string) error {
+// petArmorBuyForSlot buys the next barding tier for the given pet slot. The
+// supply-shop unlock is shared (a pet-1 mechanic), but each pet's armor tier is
+// tracked and purchased independently.
+func (p *AdventurePlugin) petArmorBuyForSlot(ctx MessageContext, tierStr string, slot int) error {
 	userMu := p.advUserLock(ctx.Sender)
 	userMu.Lock()
 	defer userMu.Unlock()
@@ -706,8 +747,16 @@ func (p *AdventurePlugin) handlePetArmorBuy(ctx MessageContext, char *AdventureC
 		return p.SendDM(ctx.Sender, "Failed to load your character.")
 	}
 
-	if !char.HasPet() {
-		return p.SendDM(ctx.Sender, "You don't have a pet.")
+	// Slot accessors keep the pet-1 and pet-2 field sets isolated.
+	hasPet, petType, petName, curTier := char.HasPet(), char.PetType, char.PetName, char.PetArmorTier
+	buyCmd := "petbuy"
+	if slot == 2 {
+		hasPet, petType, petName, curTier = char.HasPet2(), char.Pet2Type, char.Pet2Name, char.Pet2ArmorTier
+		buyCmd = "pet2buy"
+	}
+
+	if !hasPet {
+		return p.SendDM(ctx.Sender, "You don't have that pet.")
 	}
 	if !char.PetSupplyShopUnlocked {
 		return p.SendDM(ctx.Sender, "Pet supplies aren't available yet.")
@@ -716,19 +765,19 @@ func (p *AdventurePlugin) handlePetArmorBuy(ctx MessageContext, char *AdventureC
 	tier := 0
 	for _, c := range tierStr {
 		if c < '0' || c > '9' {
-			return p.SendDM(ctx.Sender, "Usage: `!thom petbuy <tier>`")
+			return p.SendDM(ctx.Sender, fmt.Sprintf("Usage: `!thom %s <tier>`", buyCmd))
 		}
 		tier = tier*10 + int(c-'0')
 	}
 
-	if tier != char.PetArmorTier+1 {
-		if tier <= char.PetArmorTier {
+	if tier != curTier+1 {
+		if tier <= curTier {
 			return p.SendDM(ctx.Sender, "That's not an upgrade.")
 		}
-		return p.SendDM(ctx.Sender, fmt.Sprintf("You need to buy tier %d first.", char.PetArmorTier+1))
+		return p.SendDM(ctx.Sender, fmt.Sprintf("You need to buy tier %d first.", curTier+1))
 	}
 
-	defs := petArmorDefs(char.PetType)
+	defs := petArmorDefs(petType)
 	var def *PetArmorDef
 	for i := range defs {
 		if defs[i].Tier == tier {
@@ -742,18 +791,26 @@ func (p *AdventurePlugin) handlePetArmorBuy(ctx MessageContext, char *AdventureC
 
 	balance := p.euro.GetBalance(ctx.Sender)
 	if balance < float64(def.Price) {
-		return p.SendDM(ctx.Sender, fmt.Sprintf("%s deserves better, but you can't afford €%d. Balance: €%.0f.", char.PetName, def.Price, balance))
+		return p.SendDM(ctx.Sender, fmt.Sprintf("%s deserves better, but you can't afford €%d. Balance: €%.0f.", petName, def.Price, balance))
 	}
 
-	if !p.euro.Debit(ctx.Sender, float64(def.Price), "pet_armor_"+tierStr) {
+	reason := "pet_armor_" + tierStr
+	if slot == 2 {
+		reason = "pet2_armor_" + tierStr
+	}
+	if !p.euro.Debit(ctx.Sender, float64(def.Price), reason) {
 		return p.SendDM(ctx.Sender, "Transaction failed.")
 	}
 
-	char.PetArmorTier = tier
+	if slot == 2 {
+		char.Pet2ArmorTier = tier
+	} else {
+		char.PetArmorTier = tier
+	}
 	if err := saveAdvCharacter(char); err != nil {
 		p.euro.Credit(ctx.Sender, float64(def.Price), "pet_armor_refund")
 		return p.SendDM(ctx.Sender, "Failed to save. Refunded.")
 	}
 
-	return p.SendDM(ctx.Sender, fmt.Sprintf("🐾 **%s** equipped on %s.\n\n+%.1f%% deflect bonus. %s looks... objectively better than you.", def.Name, char.PetName, def.DeflectBonus*100, char.PetName))
+	return p.SendDM(ctx.Sender, fmt.Sprintf("🐾 **%s** equipped on %s.\n\n+%.1f%% deflect bonus. %s looks... objectively better than you.", def.Name, petName, def.DeflectBonus*100, petName))
 }

internal/plugin/adventure_housing_test.go

@@ -144,10 +144,10 @@ func TestHouseHPBonus(t *testing.T) {
 		expected float64
 	}{
 		{0, 0},
-		{1, 0},     // Base house — no bonus
-		{2, 0.05},  // Livable
-		{3, 0.12},  // Comfortable
-		{4, 0.20},  // Established
+		{1, 0},    // Base house — no bonus
+		{2, 0.05}, // Livable
+		{3, 0.12}, // Comfortable
+		{4, 0.20}, // Established
 	}
 	for _, tt := range tests {
 		char := &AdventureCharacter{HouseTier: tt.tier}
@@ -285,8 +285,7 @@ func TestPetArmorDefs_BothTypes(t *testing.T) {
 }
 
 func TestPetArmorShopView_HasUpgrades(t *testing.T) {
-	char := &AdventureCharacter{PetType: "dog", PetName: "Rex", PetArrived: true, PetArmorTier: 0}
-	text := petArmorShopView(char)
+	text := petArmorShopView("dog", 0, "petbuy")
 
 	if !strings.Contains(text, "⬆️") {
 		t.Error("should show upgrade indicators")
@@ -297,8 +296,7 @@ func TestPetArmorShopView_HasUpgrades(t *testing.T) {
 }
 
 func TestPetArmorShopView_MaxTier(t *testing.T) {
-	char := &AdventureCharacter{PetType: "cat", PetName: "Luna", PetArrived: true, PetArmorTier: 5}
-	text := petArmorShopView(char)
+	text := petArmorShopView("cat", 5, "petbuy")
 
 	if !strings.Contains(text, "Max pet armor") {
 		t.Error("should show max tier message")

internal/plugin/adventure_ingredients_test.go

@@ -0,0 +1,96 @@
+package plugin
+
+import (
+	"fmt"
+	"testing"
+)
+
+// N1/A3 — every crafting ingredient must be obtainable from some live drop
+// source. Phase R retired the legacy activity loop, which orphaned
+// generateAdvLoot (reachable only from the now-uncalled resolveDungeonAction)
+// and with it every ingredient in the game. rollZoneIngredient reconnects the
+// legacy tables to zone combat; this test is the guard that keeps them
+// reachable.
+
+// liveIngredientSources returns every item name a player can obtain from the
+// loot tables zone combat draws on, keyed to the tier it drops at.
+func liveIngredientSources() map[string][]int {
+	sources := map[string][]int{}
+	for _, act := range advIngredientActivities {
+		table := advLootTable(act)
+		for tier, defs := range table {
+			for _, d := range defs {
+				sources[d.Name] = append(sources[d.Name], tier)
+			}
+		}
+	}
+	return sources
+}
+
+func TestEveryRecipeIngredientHasALiveSource(t *testing.T) {
+	sources := liveIngredientSources()
+	for _, recipe := range craftingRecipes {
+		for _, ing := range recipe.Ingredients {
+			if tiers, ok := sources[ing]; !ok || len(tiers) == 0 {
+				t.Errorf("recipe %q needs %q, which no live loot table drops",
+					recipe.Result, ing)
+			}
+		}
+	}
+}
+
+// The drop is keyed by zone tier, so an ingredient that only exists at
+// legacy tier N is only reachable in a tier-N zone. Assert each recipe is
+// completable by someone — i.e. every ingredient sits in tier 1..5.
+func TestIngredientTiersAreReachableByZoneTier(t *testing.T) {
+	sources := liveIngredientSources()
+	for _, recipe := range craftingRecipes {
+		for _, ing := range recipe.Ingredients {
+			for _, tier := range sources[ing] {
+				if tier < 1 || tier > 5 {
+					t.Errorf("%q drops at tier %d, outside the zone tier range",
+						ing, tier)
+				}
+			}
+		}
+	}
+}
+
+// Every zone tier must be able to produce an ingredient, or that tier's
+// players are cut out of crafting entirely.
+func TestRollZoneIngredient_EveryTierCanDrop(t *testing.T) {
+	for tier := 1; tier <= 5; tier++ {
+		t.Run(fmt.Sprintf("tier%d", tier), func(t *testing.T) {
+			got := false
+			for i := 0; i < 500 && !got; i++ {
+				if item := rollZoneIngredient(tier); item != nil {
+					got = true
+					if item.Tier != tier {
+						t.Errorf("tier %d drop carried tier %d", tier, item.Tier)
+					}
+					if item.Value <= 0 {
+						t.Errorf("%q dropped with value %d", item.Name, item.Value)
+					}
+				}
+			}
+			if !got {
+				t.Errorf("tier %d never dropped an ingredient in 500 rolls", tier)
+			}
+		})
+	}
+}
+
+func TestJoinLootLines_SkipsEmpties(t *testing.T) {
+	if got := joinLootLines("", ""); got != "" {
+		t.Errorf("all-empty = %q, want empty", got)
+	}
+	if got := joinLootLines("a", ""); got != "a" {
+		t.Errorf("trailing empty = %q, want %q", got, "a")
+	}
+	if got := joinLootLines("", "b"); got != "b" {
+		t.Errorf("leading empty = %q, want %q", got, "b")
+	}
+	if got := joinLootLines("a", "b"); got != "a\nb" {
+		t.Errorf("both = %q, want %q", got, "a\nb")
+	}
+}

internal/plugin/adventure_masterwork.go

@@ -15,8 +15,8 @@ import (
 type MasterworkDef struct {
 	Slot        EquipmentSlot
 	Activity    AdvActivityType
-	SkillSource string  // "mining", "fishing", "foraging"
-	Tier        int     // 1-5, matches location tier
+	SkillSource string // "mining", "fishing", "foraging"
+	Tier        int    // 1-5, matches location tier
 	Name        string
 	Description string  // character sheet / trade listing
 	DropRate    float64 // per-tier: 0.05, 0.04, 0.03, 0.02, 0.005
@@ -115,10 +115,37 @@ func masterworkDefFor(activity AdvActivityType, tier int) *MasterworkDef {
 	return nil
 }
 
+// masterworkSlotActivities are the three activity lines the catalog covers,
+// one equipment slot each: mining→weapon, fishing→armor, foraging→boots.
+var masterworkSlotActivities = []AdvActivityType{
+	AdvActivityMining, AdvActivityFishing, AdvActivityForaging,
+}
+
+// masterworkDefForZone picks a masterwork for a dungeon kill. The catalog is
+// keyed by gathering activity — there is no dungeon line — so a zone drop
+// rolls across all three slots and hands back that line's item at the zone's
+// tier. The item keeps its own SkillSource: a masterwork blade found in a
+// crypt still helps you mine.
+func masterworkDefForZone(tier int) *MasterworkDef {
+	act := masterworkSlotActivities[rand.IntN(len(masterworkSlotActivities))]
+	return masterworkDefFor(act, tier)
+}
+
 // ── Drop Flavor Text (DM) ─────────────────────────────────────────────────
 
 func masterworkDropFlavorText(activity AdvActivityType, tier int) string {
 	switch activity {
+	case AdvActivityDungeon:
+		switch {
+		case tier <= 2:
+			return "The thing you killed was carrying it, which raises the question of where it got it. You check the body for a maker's mark and find none. You check the body for anything else and find nothing. You take the gear and you do not think about the question."
+		case tier == 3:
+			return "It's propped against the wall behind the corpse, upright, deliberate. Not dropped. Placed. Someone came down here, set this down carefully, and did not come back for it. You pick it up. It fits your hand better than anything you paid for."
+		case tier == 4:
+			return "There's a pile of gear in the corner, most of it ruined, all of it belonging to people who came this far and no further. One piece is untouched. The rust stopped at its edge, as if the rust knew better. You add it to your kit and you leave the rest as you found it."
+		default:
+			return "It is the only thing in the room that isn't broken. Whatever lived here kept it, and kept it well, and cleaned it, and did not use it. You take it because you won. That is the arrangement. On the way out you do not turn around, and you tell yourself that is a choice."
+		}
 	case AdvActivityMining:
 		switch {
 		case tier <= 2:
@@ -164,9 +191,15 @@ func (p *AdventurePlugin) checkMasterworkDrop(userID id.UserID, equip map[Equipm
 		return
 	}
 
-	def := masterworkDefFor(loc.Activity, loc.Tier)
+	// Dungeons have no catalog line of their own; they roll across all three.
+	var def *MasterworkDef
+	if loc.Activity == AdvActivityDungeon {
+		def = masterworkDefForZone(loc.Tier)
+	} else {
+		def = masterworkDefFor(loc.Activity, loc.Tier)
+	}
 	if def == nil {
-		return // no masterwork available for this activity+tier (e.g. dungeon)
+		return // no masterwork available for this activity+tier
 	}
 
 	// Roll for drop (chat level rare bonus applied additively)
@@ -250,8 +283,9 @@ func (p *AdventurePlugin) checkMasterworkDrop(userID id.UserID, equip map[Equipm
 		sb.WriteString("_This doesn't come from the shop._\n\n")
 	}
 
-	// Flavor text
-	flavor := masterworkDropFlavorText(def.Activity, def.Tier)
+	// Flavor follows where the item was found, not which catalog line it came
+	// from — a dungeon drop must not open with a pickaxe.
+	flavor := masterworkDropFlavorText(loc.Activity, def.Tier)
 	if flavor != "" {
 		sb.WriteString(fmt.Sprintf("_%s_\n\n", flavor))
 	}
@@ -401,18 +435,8 @@ func (p *AdventurePlugin) handleMasterworkEquipReply(ctx MessageContext, interac
 		return p.SendDM(ctx.Sender, "Equip cancelled.")
 	}
 
-	// Parse number
-	idx := 0
-	for _, c := range reply {
-		if c >= '0' && c <= '9' {
-			idx = idx*10 + int(c-'0')
-		} else {
-			break
-		}
-	}
-	idx-- // 1-indexed to 0-indexed
-
-	if idx < 0 || idx >= len(data.Items) {
+	idx, ok := parseMenuIndex(reply, len(data.Items))
+	if !ok {
 		return p.SendDM(ctx.Sender, "Invalid selection. Reply with a number from the list, or \"cancel\".")
 	}
 
@@ -468,8 +492,33 @@ func (p *AdventurePlugin) handleMasterworkEquipConfirm(ctx MessageContext, inter
 		return p.SendDM(ctx.Sender, "Equip cancelled.")
 	}
 
+	// Serialize against the sender's own !give: MasterworkGear/ArenaGear are
+	// giftable (N4/E2), so the item captured at prompt time may have changed
+	// hands before this confirmation. The lock makes gift-vs-confirm atomic,
+	// and the re-load below refuses an item that is no longer ours — otherwise
+	// equipping the captured copy would mint a duplicate the gift already
+	// handed to the recipient.
+	userMu := p.advUserLock(ctx.Sender)
+	userMu.Lock()
+	defer userMu.Unlock()
+
 	selected := data.Item
 
+	inv, err := loadAdvInventory(ctx.Sender)
+	if err != nil {
+		return p.SendDM(ctx.Sender, "Failed to load your inventory.")
+	}
+	stillOwned := false
+	for _, it := range inv {
+		if it.ID == selected.ID {
+			stillOwned = true
+			break
+		}
+	}
+	if !stillOwned {
+		return p.SendDM(ctx.Sender, fmt.Sprintf("**%s** isn't in your inventory anymore. Equip cancelled.", selected.Name))
+	}
+
 	equip, err := loadAdvEquipment(ctx.Sender)
 	if err != nil {
 		return p.SendDM(ctx.Sender, "Failed to load equipment.")

internal/plugin/adventure_masterwork_test.go

@@ -0,0 +1,68 @@
+package plugin
+
+import (
+	"strings"
+	"testing"
+)
+
+// N1/A2 — the masterwork catalog is keyed to gathering activities, so the
+// zone-combat seam had nothing to look up. masterworkDefForZone bridges it.
+
+func TestMasterworkDefForZone_CoversEveryTier(t *testing.T) {
+	for tier := 1; tier <= 5; tier++ {
+		if def := masterworkDefForZone(tier); def == nil {
+			t.Errorf("tier %d has no masterwork def", tier)
+		} else if def.Tier != tier {
+			t.Errorf("tier %d returned a tier-%d def", tier, def.Tier)
+		}
+	}
+}
+
+// A dungeon drop must be able to land in any of the three slots — otherwise
+// zone play would only ever upgrade one piece of gear.
+func TestMasterworkDefForZone_RollsAllSlots(t *testing.T) {
+	seen := map[EquipmentSlot]bool{}
+	for i := 0; i < 300; i++ {
+		if def := masterworkDefForZone(3); def != nil {
+			seen[def.Slot] = true
+		}
+	}
+	for _, slot := range []EquipmentSlot{SlotWeapon, SlotArmor, SlotBoots} {
+		if !seen[slot] {
+			t.Errorf("slot %v never rolled in 300 draws", slot)
+		}
+	}
+}
+
+// The pre-existing lookup must keep working for the gathering activities.
+func TestMasterworkDefFor_GatheringUnchanged(t *testing.T) {
+	for _, act := range masterworkSlotActivities {
+		for tier := 1; tier <= 5; tier++ {
+			def := masterworkDefFor(act, tier)
+			if def == nil {
+				t.Fatalf("%s tier %d lost its def", act, tier)
+			}
+			if def.Activity != act {
+				t.Errorf("%s tier %d returned activity %s", act, tier, def.Activity)
+			}
+		}
+	}
+}
+
+// Flavor follows the place, not the catalog line. A crypt boss must not
+// narrate a pickaxe striking ore.
+func TestMasterworkDropFlavorText_DungeonHasItsOwnVoice(t *testing.T) {
+	gatheringWords := []string{"pickaxe", "fishing", "foraging", "vein", "ore", "branch"}
+	for tier := 1; tier <= 5; tier++ {
+		text := masterworkDropFlavorText(AdvActivityDungeon, tier)
+		if text == "" {
+			t.Fatalf("dungeon tier %d has no flavor", tier)
+		}
+		lower := strings.ToLower(text)
+		for _, w := range gatheringWords {
+			if strings.Contains(lower, w) {
+				t.Errorf("dungeon tier %d flavor leaks gathering word %q", tier, w)
+			}
+		}
+	}
+}

internal/plugin/adventure_npc_arcs_test.go

@@ -0,0 +1,91 @@
+package plugin
+
+import (
+	"strings"
+	"testing"
+)
+
+// D2 NPC arcs — pure-helper coverage. None of these touch combat, so the
+// characterization golden is unaffected; these just pin the arc thresholds,
+// gift tiers, and the keepsake shape.
+
+func TestMistyArcBeat_FiresOnlyAtThresholds(t *testing.T) {
+	want := map[int]bool{5: true, 15: true, 30: true}
+	for count := 0; count <= 40; count++ {
+		got := mistyArcBeat(count)
+		if want[count] {
+			if got == "" {
+				t.Errorf("encounter %d: expected an arc beat, got none", count)
+			}
+		} else if got != "" {
+			t.Errorf("encounter %d: expected no arc beat, got %q", count, got)
+		}
+	}
+}
+
+func TestMistyArcBeats_DoNotLeakBuffMechanics(t *testing.T) {
+	// The arena effects are a hidden discovery mechanic; arc copy must never
+	// tie a donation to a combat outcome.
+	banned := []string{"arena", "damage", "buff", "combat", "attack", "heal", "bonus"}
+	for count, beat := range mistyArcBeats {
+		lower := strings.ToLower(beat)
+		for _, b := range banned {
+			if strings.Contains(lower, b) {
+				t.Errorf("beat %d leaks mechanic word %q: %s", count, b, beat)
+			}
+		}
+	}
+}
+
+func TestRobbieGiftTier_MatchesArenaBands(t *testing.T) {
+	cases := []struct {
+		level int
+		tier  int
+	}{
+		{1, 1}, {3, 1}, {4, 2}, {7, 2}, {8, 3}, {12, 3},
+		{13, 4}, {17, 4}, {18, 5}, {20, 5},
+	}
+	for _, c := range cases {
+		if got := robbieGiftTier(c.level); got != c.tier {
+			t.Errorf("robbieGiftTier(%d) = %d, want %d", c.level, got, c.tier)
+		}
+	}
+}
+
+func TestRobbieGiftCadence(t *testing.T) {
+	// The gift lands on every 10th visit and no other.
+	for visit := 1; visit <= 35; visit++ {
+		gives := visit%robbieGiftEveryNVisits == 0
+		if gives != (visit == 10 || visit == 20 || visit == 30) {
+			t.Errorf("visit %d: unexpected gift cadence", visit)
+		}
+	}
+}
+
+func TestThomPetTreat_IsRobbieSafeKeepsake(t *testing.T) {
+	treat := thomPetTreatItem()
+	if treat.Name == "" {
+		t.Fatal("treat has no name")
+	}
+	// Robbie's sweep skips "card" items, so the keepsake survives him.
+	if treat.Type != "card" {
+		t.Errorf("treat type = %q, want card so Robbie's sweep skips it", treat.Type)
+	}
+	if treat.Value != 0 {
+		t.Errorf("treat value = %d, want 0 (inert keepsake)", treat.Value)
+	}
+	// Confirm the sweep filter actually excludes it.
+	if got := robbieQualifyingItems([]AdvItem{treat}, nil); len(got) != 0 {
+		t.Errorf("Robbie would take the treat: %+v", got)
+	}
+}
+
+func TestThomFinalLetterPet_SubstitutesPetName(t *testing.T) {
+	letter := strings.ReplaceAll(thomFinalLetterPet, "{pet}", "Biscuit")
+	if strings.Contains(letter, "{pet}") {
+		t.Error("unsubstituted {pet} placeholder remains")
+	}
+	if !strings.Contains(letter, "Biscuit") {
+		t.Error("pet name not substituted into the letter")
+	}
+}

internal/plugin/adventure_npcs.go

@@ -16,11 +16,11 @@ import (
 // ── NPC Constants ──────────────────────────────────────────────────────────
 
 const (
-	mistyCost         = 100
-	arinaCost         = 5000
-	npcCooldownDays   = 7
+	mistyCost          = 100
+	arinaCost          = 5000
+	npcCooldownDays    = 7
 	npcEncounterChance = 0.075 // 7.5%
-	npcBuffDuration   = 7 * 24 * time.Hour
+	npcBuffDuration    = 7 * 24 * time.Hour
 
 	// Arena effect chances per round
 	mistyEffectChance = 0.20 // 20%
@@ -131,6 +131,15 @@ func (p *AdventurePlugin) npcFireEncounter(userID id.UserID, npc string) {
 		return
 	}
 
+	// Don't consume the encounter — or its one-shot arc beat — if the player is
+	// already mid-interaction (shop, treasure, another NPC). Bail before
+	// touching MistyEncounterCount so a contended slot defers the whole
+	// encounter to a later fire instead of durably advancing the counter past
+	// a 5/15/30 threshold and losing that beat forever.
+	if _, occupied := p.pending.Load(string(userID)); occupied {
+		return
+	}
+
 	now := time.Now().UTC()
 
 	var opening, prompt string
@@ -141,6 +150,12 @@ func (p *AdventurePlugin) npcFireEncounter(userID id.UserID, npc string) {
 		// Pool union: legacy mistyOpenings + D&D MistyGreeting flavor.
 		mistyPool := dndMistyGreetingPool()
 		opening = mistyPool[rand.IntN(len(mistyPool))]
+		// D2 arc: a deepening beat lands the one time the counter hits a
+		// threshold (5/15/30). MistyEncounterCount only ever increments by one
+		// above, so each beat is delivered exactly once.
+		if beat := mistyArcBeat(char.MistyEncounterCount); beat != "" {
+			opening = beat + "\n\n" + opening
+		}
 		prompt = fmt.Sprintf("👤 A woman approaches you.\n\n_%s_\n\n"+
 			"Reply `yes` to give €%d, or `no` to walk away.", opening, mistyCost)
 	case "arina":
@@ -159,11 +174,6 @@ func (p *AdventurePlugin) npcFireEncounter(userID id.UserID, npc string) {
 		slog.Error("player_meta: npc last_seen dual-write failed", "user", userID, "npc", npc, "err", err)
 	}
 
-	// Don't overwrite an existing pending interaction (shop, treasure, etc.)
-	if _, occupied := p.pending.Load(string(userID)); occupied {
-		return
-	}
-
 	// Set pending interaction — NPC encounters stay valid until end of UTC day
 	endOfDay := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC).Add(24 * time.Hour)
 	p.pending.Store(string(userID), &advPendingInteraction{
@@ -337,10 +347,10 @@ func (p *AdventurePlugin) resolveArina(ctx MessageContext, char *AdventureCharac
 // Returns: extra text to append to round log, enemy HP modifier, player damage taken.
 type npcArenaResult struct {
 	Text       string
-	EnemyDmg   int   // damage dealt to enemy
-	PlayerDmg  int   // damage dealt to player
-	SniperKill bool  // enemy instant kill
-	CondRepair int   // equipment condition repair amount
+	EnemyDmg   int  // damage dealt to enemy
+	PlayerDmg  int  // damage dealt to player
+	SniperKill bool // enemy instant kill
+	CondRepair int  // equipment condition repair amount
 }
 
 func npcCheckArenaEffects(char *AdventureCharacter, monsterName string) *npcArenaResult {

internal/plugin/adventure_pet2_test.go

@@ -0,0 +1,180 @@
+package plugin
+
+import (
+	"strings"
+	"testing"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// TestDerivePlayerStats_OnePetIsByteIdentical pins that a single pet still
+// produces exactly the pre-two-pet mod values (the averaging code must reduce
+// to identity over one element, or the combat golden moves).
+func TestDerivePlayerStats_OnePetIsByteIdentical(t *testing.T) {
+	char := testChar(10)
+	char.PetType = "dog"
+	char.PetName = "Rex"
+	char.PetArrived = true
+	char.PetLevel = 6
+	char.PetArmorTier = 2
+
+	_, stats := DerivePlayerStats(char, testEquip(0), zeroBonuses(), 0, 0, false)
+
+	if stats.PetAttackProc != petAttackChance(6) {
+		t.Errorf("PetAttackProc = %v, want %v (identity over one pet)", stats.PetAttackProc, petAttackChance(6))
+	}
+	if stats.PetDeflectProc != petDeflectChance(6, 2) {
+		t.Errorf("PetDeflectProc = %v, want %v", stats.PetDeflectProc, petDeflectChance(6, 2))
+	}
+	if want := 0.01 + 6*0.005; stats.PetWhiffProc != want {
+		t.Errorf("PetWhiffProc = %v, want %v", stats.PetWhiffProc, want)
+	}
+	if stats.PetAttackDmg != 3+6 {
+		t.Errorf("PetAttackDmg = %d, want %d", stats.PetAttackDmg, 3+6)
+	}
+}
+
+// TestDerivePlayerStats_TwoEqualPetsMatchOne: two identical pets average to the
+// same procs as one — a pair is not a stat spike.
+func TestDerivePlayerStats_TwoEqualPetsMatchOne(t *testing.T) {
+	char := testChar(10)
+	char.PetType, char.PetName, char.PetArrived, char.PetLevel, char.PetArmorTier = "dog", "Rex", true, 8, 3
+	char.Pet2Type, char.Pet2Name, char.Pet2Arrived, char.Pet2Level, char.Pet2ArmorTier = "cat", "Luna", true, 8, 3
+
+	_, stats := DerivePlayerStats(char, testEquip(0), zeroBonuses(), 0, 0, false)
+
+	if stats.PetAttackProc != petAttackChance(8) {
+		t.Errorf("two L8 pets PetAttackProc = %v, want one-pet %v", stats.PetAttackProc, petAttackChance(8))
+	}
+	if stats.PetAttackDmg != 3+8 {
+		t.Errorf("two L8 pets PetAttackDmg = %d, want %d", stats.PetAttackDmg, 3+8)
+	}
+}
+
+// TestDerivePlayerStats_TwoUnequalPetsAverage: mixed levels average, never
+// exceeding the stronger pet's solo contribution.
+func TestDerivePlayerStats_TwoUnequalPetsAverage(t *testing.T) {
+	char := testChar(10)
+	char.PetType, char.PetArrived, char.PetLevel, char.PetArmorTier = "dog", true, 10, 0
+	char.Pet2Type, char.Pet2Arrived, char.Pet2Level, char.Pet2ArmorTier = "cat", true, 2, 0
+
+	_, stats := DerivePlayerStats(char, testEquip(0), zeroBonuses(), 0, 0, false)
+
+	wantAtk := (petAttackChance(10) + petAttackChance(2)) / 2
+	if stats.PetAttackProc != wantAtk {
+		t.Errorf("PetAttackProc = %v, want avg %v", stats.PetAttackProc, wantAtk)
+	}
+	// Averaged proc must sit strictly between the two pets' solo values.
+	if !(stats.PetAttackProc < petAttackChance(10) && stats.PetAttackProc > petAttackChance(2)) {
+		t.Errorf("averaged proc %v not between %v and %v", stats.PetAttackProc, petAttackChance(2), petAttackChance(10))
+	}
+	if want := 3 + (10+2+1)/2; stats.PetAttackDmg != want { // rounded avg level = 6
+		t.Errorf("PetAttackDmg = %d, want %d", stats.PetAttackDmg, want)
+	}
+}
+
+// TestDerivePlayerStats_Pet2OnlyStillContributes: if the first pet is chased
+// away but the second remains, combat still sees the second pet.
+func TestDerivePlayerStats_Pet2OnlyStillContributes(t *testing.T) {
+	char := testChar(10)
+	char.PetType, char.PetArrived, char.PetChasedAway, char.PetLevel = "dog", true, true, 5
+	char.Pet2Type, char.Pet2Arrived, char.Pet2Level = "cat", true, 4
+
+	_, stats := DerivePlayerStats(char, testEquip(0), zeroBonuses(), 0, 0, false)
+
+	if !char.HasPet() && stats.PetAttackProc != petAttackChance(4) {
+		t.Errorf("pet2-only PetAttackProc = %v, want %v", stats.PetAttackProc, petAttackChance(4))
+	}
+}
+
+// TestDerivePlayerStats_NoPetsZero: the golden's own case — no pets, no procs.
+func TestDerivePlayerStats_NoPetsZero(t *testing.T) {
+	_, stats := DerivePlayerStats(testChar(10), testEquip(0), zeroBonuses(), 0, 0, false)
+	if stats.PetAttackProc != 0 || stats.PetDeflectProc != 0 || stats.PetWhiffProc != 0 || stats.PetAttackDmg != 0 {
+		t.Errorf("petless character got pet mods: %+v", stats)
+	}
+}
+
+func TestPetShouldArrive2_Gating(t *testing.T) {
+	pet1 := PetState{Type: "dog", Arrived: true}
+	tier4 := HouseState{Tier: 4}
+	tier3 := HouseState{Tier: 3}
+
+	if petShouldArrive2(pet1, PetState{}, tier3) {
+		t.Error("second pet must not arrive below Tier 4")
+	}
+	if petShouldArrive2(PetState{}, PetState{}, tier4) {
+		t.Error("second pet needs an established first pet")
+	}
+	if petShouldArrive2(pet1, PetState{Arrived: true}, tier4) {
+		t.Error("already-arrived second pet must not re-roll")
+	}
+	if petShouldArrive2(pet1, PetState{ChasedAway: true}, tier4) {
+		t.Error("chased-away second pet does not re-arrive")
+	}
+}
+
+// TestPet2StoreRoundTrip exercises the pet2_* columns and the AdvChar mirror.
+func TestPet2StoreRoundTrip(t *testing.T) {
+	townTestDB(t)
+	user := id.UserID("@pet2:test.invalid")
+
+	char := &AdventureCharacter{UserID: user}
+	char.PetType, char.PetName, char.PetArrived, char.PetLevel = "dog", "Rex", true, 3
+	char.Pet2Type, char.Pet2Name, char.Pet2Arrived, char.Pet2Level, char.Pet2ArmorTier = "cat", "Luna", true, 5, 2
+	if err := saveAdvCharacter(char); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := loadAdvCharacter(user)
+	if err != nil || got == nil {
+		t.Fatalf("reload: %v", err)
+	}
+	if !got.HasPet2() || got.Pet2Name != "Luna" || got.Pet2Level != 5 || got.Pet2ArmorTier != 2 || got.Pet2Type != "cat" {
+		t.Fatalf("pet2 did not round-trip: %+v", got)
+	}
+	if !got.HasPet() || got.PetName != "Rex" {
+		t.Fatalf("pet1 clobbered by pet2 write: %+v", got)
+	}
+
+	// Direct slot loader agrees.
+	p2, _ := loadPet2State(user)
+	if p2.Name != "Luna" || p2.Level != 5 {
+		t.Fatalf("loadPet2State mismatch: %+v", p2)
+	}
+}
+
+// TestPetShowcase_IncludesBothSlots verifies the town showcase surfaces second
+// pets and hides a chased-away one.
+func TestPetShowcase_IncludesBothSlots(t *testing.T) {
+	townTestDB(t)
+
+	a := &AdventureCharacter{UserID: id.UserID("@a:test.invalid")}
+	a.PetType, a.PetName, a.PetArrived, a.PetLevel = "dog", "Rex", true, 4
+	a.Pet2Type, a.Pet2Name, a.Pet2Arrived, a.Pet2Level = "cat", "Luna", true, 9
+	if err := saveAdvCharacter(a); err != nil {
+		t.Fatal(err)
+	}
+	b := &AdventureCharacter{UserID: id.UserID("@b:test.invalid")}
+	b.Pet2Type, b.Pet2Name, b.Pet2Arrived, b.Pet2Level, b.Pet2ChasedAway = "dog", "Ghost", true, 7, true
+	if err := saveAdvCharacter(b); err != nil {
+		t.Fatal(err)
+	}
+
+	pets, err := loadPetShowcase(townListCap)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(pets) != 2 {
+		t.Fatalf("want 2 active pets (Rex + Luna), got %d: %+v", len(pets), pets)
+	}
+	// Sorted by level desc → Luna (9) before Rex (4).
+	if !strings.Contains(pets[0].Name, "Luna") || !strings.Contains(pets[1].Name, "Rex") {
+		t.Fatalf("showcase not level-ordered across slots: %+v", pets)
+	}
+	for _, p := range pets {
+		if strings.Contains(p.Name, "Ghost") {
+			t.Errorf("chased-away second pet should be hidden: %+v", p)
+		}
+	}
+}

internal/plugin/adventure_pets.go

@@ -31,28 +31,37 @@ func petXPToNextLevel(level int) int {
 	}
 }
 
-// petGrantXP adds XP to the pet and handles level-ups. Returns true if leveled up.
+// petGrantXP adds a per-action XP grant to the pet and handles level-ups.
+// Returns true if leveled up. Shares the level-up loop with the babysit trickle
+// via advancePetLevelsFromXP.
 func petGrantXP(pet *PetState) bool {
-	if !pet.HasPet() || pet.Level >= 10 {
+	if !pet.HasPet() {
 		return false
 	}
+	return advancePetLevelsFromXP(&pet.XP, &pet.Level, &pet.Level10Date, int(petXPPerAction*100))
+}
 
-	pet.XP += int(petXPPerAction * 100) // store as centixp for precision
+// advancePetLevelsFromXP adds centi-XP to a pet and applies any level-ups, up
+// to the level-10 cap, stamping the level-10 date on first reaching it. Shared
+// by both pet slots (the babysit trickle). Returns true if the pet leveled.
+func advancePetLevelsFromXP(xp, level *int, level10Date *string, addCentiXP int) bool {
+	if *level >= 10 {
+		return false
+	}
+	*xp += addCentiXP
 	leveled := false
-	for pet.Level < 10 {
-		needed := petXPToNextLevel(pet.Level) * 100
-		if pet.XP < needed {
+	for *level < 10 {
+		needed := petXPToNextLevel(*level) * 100
+		if *xp < needed {
 			break
 		}
-		pet.XP -= needed
-		pet.Level++
+		*xp -= needed
+		*level++
 		leveled = true
 	}
-
-	if pet.Level >= 10 && pet.Level10Date == "" {
-		pet.Level10Date = time.Now().UTC().Format("2006-01-02")
+	if *level >= 10 && *level10Date == "" {
+		*level10Date = time.Now().UTC().Format("2006-01-02")
 	}
-
 	return leveled
 }
 
@@ -206,28 +215,84 @@ func petShouldArrive(pet PetState, house HouseState) bool {
 	return rand.Float64() < 0.30
 }
 
-// petArrivalDM sends the initial "there's an animal in your house" DM.
-func (p *AdventurePlugin) petArrivalDM(userID id.UserID) {
+// petShouldArrive2 gates the SECOND companion (N4/E1). It needs a Tier-4 Estate
+// and an established first pet — the second animal wanders in to join the first,
+// not an empty house. A chased-away second pet does not re-arrive (Misty's
+// reactivation is a pet-1 mechanic).
+func petShouldArrive2(pet1, pet2 PetState, house HouseState) bool {
+	if pet2.Arrived || pet2.ChasedAway {
+		return false
+	}
+	if house.Tier < 4 {
+		return false
+	}
+	if !pet1.HasPet() {
+		return false
+	}
+	return rand.Float64() < 0.30
+}
+
+// maybeRollPetArrivalOnEmerge rolls the pet-arrival check when a player
+// surfaces from an expedition (voluntary extract, abandon, or a survived
+// forced extraction) or revives after death. The arrival roll lives on the
+// emergence seam — not the legacy 08:00 overworld morning DM — because
+// expedition players are almost never in the overworld at the scheduled hour,
+// so the morning roll never reached them. Story beat: while the player was
+// underground, an animal wandered into the empty house looking for food.
+//
+// Safe to call unconditionally on any emergence: petShouldArrive gates on
+// house tier / not-yet-arrived, and petArrivalDM won't clobber an existing
+// pending interaction.
+func (p *AdventurePlugin) maybeRollPetArrivalOnEmerge(userID id.UserID) {
+	pet, _ := loadPetState(userID)
+	house, _ := loadHouseState(userID)
+	if petShouldArrive(pet, house) {
+		p.petArrivalDM(userID, 1)
+		return
+	}
+	// A Tier-4 Estate can draw a second companion once the first is settled.
+	pet2, _ := loadPet2State(userID)
+	if petShouldArrive2(pet, pet2, house) {
+		p.petArrivalDM(userID, 2)
+	}
+}
+
+// petArrivalDM sends the initial "there's an animal in your house" DM for the
+// given slot (1 or 2).
+func (p *AdventurePlugin) petArrivalDM(userID id.UserID, slot int) {
 	// Don't overwrite an existing pending interaction
 	if _, exists := p.pending.Load(string(userID)); exists {
 		return
 	}
 
-	text := "There's an animal in your house. It looks like a...\n\n" +
+	intro := "There's an animal in your house. It looks like a..."
+	if slot == 2 {
+		intro = "There's *another* animal in your house. Your first pet seems unbothered. It looks like a..."
+	}
+	text := intro + "\n\n" +
 		"🚪 Chase it away\n" +
 		"🍖 Feed it\n\n" +
 		"Reply with `chase` or `feed`."
 
 	p.pending.Store(string(userID), &advPendingInteraction{
 		Type:      "pet_arrival",
-		Data:      &advPendingPetArrival{},
+		Data:      &advPendingPetArrival{Slot: slot},
 		ExpiresAt: time.Now().Add(advDMResponseWindowLow),
 	})
 	_ = p.SendDM(userID, text)
 }
 
+// petSlotFromData reads a Slot off any pending-pet payload, defaulting to slot 1
+// for the zero value so older/first-pet interactions are unaffected.
+func petSlotFromData(slot int) int {
+	if slot == 2 {
+		return 2
+	}
+	return 1
+}
+
 // resolvePetArrival handles the chase/feed response.
-func (p *AdventurePlugin) resolvePetArrival(ctx MessageContext) error {
+func (p *AdventurePlugin) resolvePetArrival(ctx MessageContext, interaction *advPendingInteraction) error {
 	userMu := p.advUserLock(ctx.Sender)
 	userMu.Lock()
 	defer userMu.Unlock()
@@ -237,13 +302,18 @@ func (p *AdventurePlugin) resolvePetArrival(ctx MessageContext) error {
 		return p.SendDM(ctx.Sender, "Failed to load your character.")
 	}
 
+	slot := petSlotFromData(interaction.Data.(*advPendingPetArrival).Slot)
 	reply := strings.ToLower(strings.TrimSpace(ctx.Body))
 
 	if reply == "chase" || reply == "🚪" {
-		char.PetChasedAway = true
-		char.PetReactivated = false
+		if slot == 2 {
+			char.Pet2ChasedAway = true
+			char.Pet2Reactivated = false
+		} else {
+			char.PetChasedAway = true
+			char.PetReactivated = false
+		}
 		_ = saveAdvCharacter(char)
-		_ = upsertPlayerMetaPetState(char.UserID, petStateFromAdvChar(char))
 		return p.SendDM(ctx.Sender, "You chased it away. It disappeared around the corner and didn't come back.\n\nThe house is quiet again.")
 	}
 
@@ -257,7 +327,7 @@ func (p *AdventurePlugin) resolvePetArrival(ctx MessageContext) error {
 
 		p.pending.Store(string(ctx.Sender), &advPendingInteraction{
 			Type:      "pet_type",
-			Data:      &advPendingPetType{},
+			Data:      &advPendingPetType{Slot: slot},
 			ExpiresAt: time.Now().Add(advDMResponseWindowLow),
 		})
 		return p.SendDM(ctx.Sender, text)
@@ -266,18 +336,19 @@ func (p *AdventurePlugin) resolvePetArrival(ctx MessageContext) error {
 	// Invalid response — re-prompt
 	p.pending.Store(string(ctx.Sender), &advPendingInteraction{
 		Type:      "pet_arrival",
-		Data:      &advPendingPetArrival{},
+		Data:      &advPendingPetArrival{Slot: slot},
 		ExpiresAt: time.Now().Add(advDMResponseWindowLow),
 	})
 	return p.SendDM(ctx.Sender, "Reply with `chase` or `feed`.")
 }
 
 // resolvePetType handles dog/cat selection.
-func (p *AdventurePlugin) resolvePetType(ctx MessageContext) error {
+func (p *AdventurePlugin) resolvePetType(ctx MessageContext, interaction *advPendingInteraction) error {
 	userMu := p.advUserLock(ctx.Sender)
 	userMu.Lock()
 	defer userMu.Unlock()
 
+	slot := petSlotFromData(interaction.Data.(*advPendingPetType).Slot)
 	reply := strings.ToLower(strings.TrimSpace(ctx.Body))
 
 	petType := ""
@@ -290,7 +361,7 @@ func (p *AdventurePlugin) resolvePetType(ctx MessageContext) error {
 	if petType == "" {
 		p.pending.Store(string(ctx.Sender), &advPendingInteraction{
 			Type:      "pet_type",
-			Data:      &advPendingPetType{},
+			Data:      &advPendingPetType{Slot: slot},
 			ExpiresAt: time.Now().Add(advDMResponseWindowLow),
 		})
 		return p.SendDM(ctx.Sender, "Reply with `dog` or `cat`.")
@@ -298,7 +369,7 @@ func (p *AdventurePlugin) resolvePetType(ctx MessageContext) error {
 
 	p.pending.Store(string(ctx.Sender), &advPendingInteraction{
 		Type:      "pet_name",
-		Data:      &advPendingPetName{PetType: petType},
+		Data:      &advPendingPetName{PetType: petType, Slot: slot},
 		ExpiresAt: time.Now().Add(advDMResponseWindowLow),
 	})
 
@@ -310,8 +381,11 @@ func (p *AdventurePlugin) resolvePetType(ctx MessageContext) error {
 		article, titleCase(petType)))
 }
 
-// resolvePetName handles naming the pet.
-func (p *AdventurePlugin) resolvePetName(ctx MessageContext) error {
+// resolvePetName handles naming the pet. The dispatcher (handlePendingReply)
+// has already deleted the pending interaction and passes it in, so this must
+// NOT re-load from p.pending — doing so previously made every adoption fail
+// silently (the carried PetType was lost and the save never ran).
+func (p *AdventurePlugin) resolvePetName(ctx MessageContext, interaction *advPendingInteraction) error {
 	userMu := p.advUserLock(ctx.Sender)
 	userMu.Lock()
 	defer userMu.Unlock()
@@ -321,41 +395,48 @@ func (p *AdventurePlugin) resolvePetName(ctx MessageContext) error {
 		return p.SendDM(ctx.Sender, "Failed to load your character.")
 	}
 
-	val, ok := p.pending.LoadAndDelete(string(ctx.Sender))
-	if !ok {
-		return nil
-	}
-	pi := val.(*advPendingInteraction)
-	data := pi.Data.(*advPendingPetName)
+	data := interaction.Data.(*advPendingPetName)
 
 	name := strings.TrimSpace(ctx.Body)
 	if len(name) == 0 || len(name) > 30 {
-		p.pending.Store(string(ctx.Sender), pi)
+		p.pending.Store(string(ctx.Sender), interaction)
 		return p.SendDM(ctx.Sender, "Name must be 1-30 characters. Try again.")
 	}
 	if !petNameValid.MatchString(name) {
-		p.pending.Store(string(ctx.Sender), pi)
+		p.pending.Store(string(ctx.Sender), interaction)
 		return p.SendDM(ctx.Sender, "Name can only contain letters, numbers, spaces, hyphens, and apostrophes. Try again.")
 	}
 
-	char.PetType = data.PetType
-	char.PetName = name
-	char.PetArrived = true
-	char.PetChasedAway = false
-	char.PetLevel = 1
-	char.PetXP = 0
+	if petSlotFromData(data.Slot) == 2 {
+		char.Pet2Type = data.PetType
+		char.Pet2Name = name
+		char.Pet2Arrived = true
+		char.Pet2ChasedAway = false
+		char.Pet2Level = 1
+		char.Pet2XP = 0
+	} else {
+		char.PetType = data.PetType
+		char.PetName = name
+		char.PetArrived = true
+		char.PetChasedAway = false
+		char.PetLevel = 1
+		char.PetXP = 0
+	}
 
 	if err := saveAdvCharacter(char); err != nil {
 		return p.SendDM(ctx.Sender, "Failed to save.")
 	}
-	_ = upsertPlayerMetaPetState(char.UserID, petStateFromAdvChar(char))
 
 	emoji := "🐶"
 	if data.PetType == "cat" {
 		emoji = "🐱"
 	}
-	return p.SendDM(ctx.Sender, fmt.Sprintf("%s **%s** has moved in.\n\nBreed: Massive %s.\nLevel: 1\n\n%s will join you in combat. %s will not explain their decisions.",
-		emoji, name, titleCase(data.PetType), name, name))
+	tail := fmt.Sprintf("%s will join you in combat. %s will not explain their decisions.", name, name)
+	if petSlotFromData(data.Slot) == 2 {
+		tail = fmt.Sprintf("%s fights alongside your first companion — the two share the spotlight, so together they're about as much help in a scrap as one seasoned pet. %s will not explain their decisions.", name, name)
+	}
+	return p.SendDM(ctx.Sender, fmt.Sprintf("%s **%s** has moved in.\n\nBreed: Massive %s.\nLevel: 1\n\n%s",
+		emoji, name, titleCase(data.PetType), tail))
 }
 
 // ── Morning Pet Events ─────────────────────────────────────────────────────

internal/plugin/adventure_pets_dispatch_test.go

@@ -0,0 +1,51 @@
+package plugin
+
+import (
+	"testing"
+	"time"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// TestResolvePetName_ThroughDispatcher is a regression test for the bug where
+// resolvePendingInteraction deleted the pending entry before dispatch, while
+// resolvePetName then tried to LoadAndDelete it again — always missing, so the
+// adoption silently no-op'd and no pet was ever persisted. The fix passes the
+// already-loaded interaction into resolvePetName. This test drives the real
+// dispatcher path (resolvePendingInteraction) to lock that in.
+func TestResolvePetName_ThroughDispatcher(t *testing.T) {
+	setupAuditTestDB(t)
+	uid := id.UserID("@pet-name-dispatch:example")
+	if err := createAdvCharacter(uid, "petnamer"); err != nil {
+		t.Fatal(err)
+	}
+
+	p := &AdventurePlugin{}
+	interaction := &advPendingInteraction{
+		Type:      "pet_name",
+		Data:      &advPendingPetName{PetType: "dog"},
+		ExpiresAt: time.Now().Add(time.Hour),
+	}
+	p.pending.Store(string(uid), interaction)
+
+	if err := p.resolvePendingInteraction(MessageContext{Sender: uid, Body: "Pepper"}, interaction); err != nil {
+		t.Fatal(err)
+	}
+
+	pet, err := loadPetState(uid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !pet.HasPet() {
+		t.Fatalf("expected pet to be adopted; got %+v", pet)
+	}
+	if pet.Name != "Pepper" {
+		t.Errorf("pet name = %q, want Pepper", pet.Name)
+	}
+	if pet.Type != "dog" {
+		t.Errorf("pet type = %q, want dog", pet.Type)
+	}
+	if !pet.Arrived || pet.Level != 1 {
+		t.Errorf("pet arrived=%v level=%d, want true/1", pet.Arrived, pet.Level)
+	}
+}

internal/plugin/adventure_render.go

@@ -729,12 +729,12 @@ type AdvPlayerDaySummary struct {
 	ForagingSkill int
 	FishingSkill  int
 
-	Activity       string
-	Location       string
-	Outcome        string
-	LootValue      int64
-	IsDead         bool
-	DeadUntil      string
+	Activity  string
+	Location  string
+	Outcome   string
+	LootValue int64
+	IsDead    bool
+	DeadUntil string
 	// DeadUntilHours is the integer hours-from-now until revival, used by
 	// the standout-death template's {hours} placeholder. Computed when
 	// the summary row is built; 0 if not dead or already past revival.
@@ -744,11 +744,11 @@ type AdvPlayerDaySummary struct {
 	// {duration} placeholder for templates that want precision over the
 	// rounded {hours} count.
 	DeadUntilDuration string
-	IsResting      bool
-	SummaryLine    string
-	HolidayActions int // 0 = not holiday or no action; 1 = took one; 2 = took both
-	DeathSource    string
-	DeathLocation  string
+	IsResting         bool
+	SummaryLine       string
+	HolidayActions    int // 0 = not holiday or no action; 1 = took one; 2 = took both
+	DeathSource       string
+	DeathLocation     string
 }
 
 // advPlayerHeadline renders the per-player headline for the daily report.
@@ -920,7 +920,6 @@ func renderAdvDailySummary(date string, tb *TwinBeeResult, tbRewards TwinBeeRewa
 		sb.WriteString("\n")
 	}
 
-
 	// Standout
 	if bestPlayer != nil && bestPlayer.LootValue > 0 {
 		pool := SummaryStandoutGood
@@ -984,8 +983,8 @@ func renderAdvLeaderboard(chars []AdvLeaderboardEntry) string {
 
 	// Sort by score
 	type entry struct {
-		Name  string
-		Score int
+		Name   string
+		Score  int
 		Levels string
 		Streak int
 	}
@@ -1038,8 +1037,17 @@ func renderAdvLeaderboard(chars []AdvLeaderboardEntry) string {
 // ── Treasure Discard Prompt ──────────────────────────────────────────────────
 
 func renderAdvTreasureDiscardPrompt(newTreasure *AdvTreasureDef, existing []AdvTreasureDef) string {
-	if len(TreasureInventoryCap) == 0 {
-		return "You found a treasure but your inventory is full. Reply 1, 2, or 3 to discard, or `keep`."
+	// The flavor templates below are written for the base 3-slot set. With a
+	// T3 trophy room the set can hold 4, so fall back to a plain dynamic list
+	// whenever it isn't exactly 3 — every slot has to be visible to choose it.
+	if len(TreasureInventoryCap) == 0 || len(existing) != 3 {
+		var b strings.Builder
+		fmt.Fprintf(&b, "You found **%s** but your treasure slots are full. Discard one to make room:\n", newTreasure.Name)
+		for i, ex := range existing {
+			fmt.Fprintf(&b, "%d. %s — %s\n", i+1, ex.Name, ex.InventoryDesc)
+		}
+		fmt.Fprintf(&b, "\nReply with the number to discard, or `keep` to leave the new one behind.")
+		return b.String()
 	}
 
 	// Build substitution map with existing treasure info

internal/plugin/adventure_robbie.go

@@ -164,16 +164,28 @@ func (p *AdventurePlugin) robbieVisitPlayer(userID id.UserID, displayName string
 		gaveCard = true
 	}
 
-	// Update visit count
+	// Update visit count, and every 10th visit leave a small consumable
+	// "for the trouble" (D2 NPC arc).
+	var leftGift *AdvItem
 	char, err := loadAdvCharacter(userID)
 	if err == nil {
 		char.RobbieVisitCount++
+		if char.RobbieVisitCount%robbieGiftEveryNVisits == 0 {
+			// Use the canonical DnD level (like the arena's tier gate), not the
+			// frozen legacy CombatLevel — that snapshots at 1–3 once D&D setup
+			// completes, so reading it here would peg every gift at tier 1.
+			if gifts := consumableCache(robbieGiftTier(arenaDnDLevelOrZero(userID)), 1); len(gifts) > 0 {
+				if err := addAdvInventoryItem(userID, gifts[0]); err == nil {
+					leftGift = &gifts[0]
+				}
+			}
+		}
 		_ = saveAdvCharacter(char)
 		_ = upsertPlayerMetaNPCState(userID, npcStateFromAdvChar(char))
 	}
 
 	// Send DM
-	dm := renderRobbieDM(userID, takenItems, totalPayout, masterworkTaken, gaveCard)
+	dm := renderRobbieDM(userID, takenItems, totalPayout, masterworkTaken, gaveCard, leftGift)
 	if err := p.SendDM(userID, dm); err != nil {
 		slog.Error("adventure: robbie: failed to send DM", "user", userID, "err", err)
 	}
@@ -191,10 +203,12 @@ func (p *AdventurePlugin) robbieVisitPlayer(userID id.UserID, displayName string
 func robbieQualifyingItems(inv []AdvItem, equip map[EquipmentSlot]*AdvEquipment) []AdvItem {
 	var result []AdvItem
 	for _, item := range inv {
-		// Never touch Arena gear, cards, or consumables. Consumables are a
-		// player-curated stockpile (crafted or dropped); selling them is an
-		// explicit decision the player must make themselves.
-		if item.Type == "ArenaGear" || item.Type == "card" || item.Type == "consumable" {
+		// Never touch Arena gear, cards, consumables, or keys. Consumables are
+		// a player-curated stockpile (crafted or dropped); selling them is an
+		// explicit decision the player must make themselves. Keys are cross-zone
+		// unlock tokens (N5/D4) that must persist in inventory to open their
+		// vault later — sweeping one permanently breaks that unlock.
+		if item.Type == "ArenaGear" || item.Type == "card" || item.Type == "consumable" || item.Type == "key" {
 			continue
 		}
 
@@ -243,7 +257,27 @@ func robbiePlayerHasCard(userID id.UserID) bool {
 
 // ── DM Rendering ─────────────────────────────────────────────────────────────
 
-func renderRobbieDM(userID id.UserID, items []AdvItem, total int64, mwTaken, gaveCard bool) string {
+// robbieGiftEveryNVisits is how often Robbie leaves a consumable behind.
+const robbieGiftEveryNVisits = 10
+
+// robbieGiftTier maps a player's combat level to a consumable tier, matching
+// the arena tier bands (1–3 / 4–7 / 8–12 / 13–17 / 18+).
+func robbieGiftTier(level int) int {
+	switch {
+	case level >= 18:
+		return 5
+	case level >= 13:
+		return 4
+	case level >= 8:
+		return 3
+	case level >= 4:
+		return 2
+	default:
+		return 1
+	}
+}
+
+func renderRobbieDM(userID id.UserID, items []AdvItem, total int64, mwTaken, gaveCard bool, leftGift *AdvItem) string {
 	var sb strings.Builder
 
 	// Opening
@@ -290,6 +324,12 @@ func renderRobbieDM(userID id.UserID, items []AdvItem, total int64, mwTaken, gav
 	}
 	sb.WriteString("\n\n")
 
+	// Every-10th-visit consumable (D2).
+	if leftGift != nil {
+		sb.WriteString(fmt.Sprintf(robbieLeftConsumable, leftGift.Name))
+		sb.WriteString("\n\n")
+	}
+
 	// Closing
 	closing, _ := advPickFlavor(robbieClosings, userID, "robbie_closing")
 	sb.WriteString(closing)

internal/plugin/adventure_scheduler.go

@@ -82,6 +82,12 @@ func (p *AdventurePlugin) sendMorningDMs() {
 			if err := p.SendDM(char.UserID, text); err != nil {
 				slog.Error("adventure: failed to send respawn DM", "user", char.UserID, "err", err)
 			}
+
+			// Emergence seam (death case): a player who died underground
+			// "comes home" on respawn. This is the deferred half of the
+			// emergence roll — survived extractions roll at their exit
+			// site; deaths roll here. See maybeRollPetArrivalOnEmerge.
+			p.maybeRollPetArrivalOnEmerge(char.UserID)
 		}
 
 		// Babysitting: pet-care trickle (no harvest actions; safe-rest perk
@@ -133,13 +139,12 @@ func (p *AdventurePlugin) sendMorningDMs() {
 			continue
 		}
 
-		// Pet arrival check (fires before normal morning DM)
-		house, _ := loadHouseState(char.UserID)
+		// Pet arrival no longer rolls here. The 08:00 overworld morning DM
+		// is skipped for anyone underground (expedition gate above), so it
+		// never reached expedition players. Arrival now fires on the
+		// emergence seam — see maybeRollPetArrivalOnEmerge, called from the
+		// extract/abandon/forced-extract and respawn paths.
 		pet, _ := loadPetState(char.UserID)
-		if petShouldArrive(pet, house) {
-			p.petArrivalDM(char.UserID)
-			continue
-		}
 
 		// Morning pet event
 		petEvent := petMorningEvent(pet)
@@ -384,6 +389,9 @@ func (p *AdventurePlugin) midnightTicker() {
 				slog.Error("adventure: midnight reset failed, will retry next tick", "err", err)
 				continue
 			}
+			// Close out the arena season if one just ended. Self-dedups on the
+			// season key, so this is a cheap no-op on every other night.
+			p.arenaSeasonRollover(time.Now().UTC())
 			db.MarkJobCompleted(jobName, dateKey)
 			lastRanDate = dateKey
 		}
@@ -391,7 +399,6 @@ func (p *AdventurePlugin) midnightTicker() {
 }
 
 func (p *AdventurePlugin) midnightReset() error {
-	// Send idle shame DMs to players who didn't act
 	chars, err := loadAllAdvCharacters()
 	if err != nil {
 		return fmt.Errorf("load chars: %w", err)
@@ -400,79 +407,95 @@ func (p *AdventurePlugin) midnightReset() error {
 	today := time.Now().UTC().Format("2006-01-02")
 	yesterday := time.Now().UTC().Add(-24 * time.Hour).Format("2006-01-02")
 
+	// Unified activity oracle — same source the daily report uses. Unions
+	// adventure_activity_log + dnd_zone_run + dnd_expedition_log, so
+	// background-autopilot walks, expedition extracts/completions, and any
+	// subsystem that logged a beat all count as "something happened on this
+	// player's behalf." LastActionDate alone misses the autopilot path
+	// (dnd_zone_cmd.go gates markActedToday on !compact to keep autopilot
+	// out of streak credit) — without this oracle, a player who let the
+	// autopilot run a full expedition gets shamed at midnight.
+	todayActs, _ := loadAdvDailyActivity(today)
+	yesterdayActs, _ := loadAdvDailyActivity(yesterday)
+
 	dmsSent := 0
 	for _, char := range chars {
-		if !char.HasActedToday() {
-			// If the player died today or yesterday, they couldn't act — no shame,
-			// no streak reset. This covers both currently-dead players and players
-			// who were just revived at midnight (Alive already flipped to true by
-			// the reminder loop before midnightReset runs).
-			if char.LastDeathDate == today || char.LastDeathDate == yesterday {
-				continue
-			}
+		// Advance this player's Shadow (N6/D3) once for the day, before any
+		// streak/idle branching below — the rival runs whether or not the
+		// player did, which is the whole point of the race pressure. Own table,
+		// own idempotency guard; never touches char, never fails the reset.
+		p.advanceShadow(&char)
 
-			// An active expedition — or a turn-based fight locked open across
-			// midnight — counts as activity. Both track their own action flow
-			// (zone/harvest/combat/transit/extract) and never touch the legacy
-			// CombatActionsUsed/HarvestActionsUsed counters, so HasActedToday()
-			// reports false. Treat them like the acted-today branch below:
-			// advance the streak and bail out (no idle-shame, no streak decay).
-			busy := false
-			if exp, err := getActiveExpedition(char.UserID); err != nil {
-				slog.Warn("adventure: failed to check active expedition for idle reaper", "user", char.UserID, "err", err)
-			} else if exp != nil {
-				busy = true
-			}
-			if !busy && hasActiveCombatSession(char.UserID) {
-				busy = true
-			}
-			if busy {
-				if char.LastActionDate == yesterday || char.LastActionDate == today {
-					char.CurrentStreak++
-				} else {
-					char.CurrentStreak = 1
-				}
-				if char.CurrentStreak > char.BestStreak {
-					char.BestStreak = char.CurrentStreak
-				}
-				char.LastActionDate = today
-				_ = saveAdvCharacter(&char)
-				continue
-			}
+		// Died inside the window — no shame, no streak change. Covers both
+		// currently-dead players and players revived at midnight (Alive
+		// already flipped to true by the reminder loop before this runs).
+		if char.LastDeathDate == today || char.LastDeathDate == yesterday {
+			continue
+		}
 
-			// Jitter between DMs to avoid Matrix rate limits
-			if dmsSent > 0 {
-				time.Sleep(time.Duration(1000+rand.IntN(2000)) * time.Millisecond)
-			}
-			dmsSent++
+		// Player-initiated engagement — only this credits the streak.
+		// LastActionDate is stamped at action time by markActedToday + !rest;
+		// the legacy counters get bumped by the legacy CanDo... paths.
+		engaged := char.LastActionDate == today || char.LastActionDate == yesterday ||
+			char.CombatActionsUsed > 0 || char.HarvestActionsUsed > 0
 
-			// Idle shame DM
-			text := renderAdvIdleShameDM(char.UserID)
-			if char.CurrentStreak > 0 {
-				oldStreak := char.CurrentStreak
-				char.CurrentStreak /= 2
-				char.StreakDecayed = true
-				text += fmt.Sprintf("\n\n🔥 Streak: %d → %d days", oldStreak, char.CurrentStreak)
-				if char.CurrentStreak > 0 {
-					text += " — not all is lost."
-				}
-				_ = saveAdvCharacter(&char)
-			}
-			if err := p.SendDM(char.UserID, text); err != nil {
-				slog.Error("adventure: failed to send idle shame DM", "user", char.UserID, "err", err)
-			}
-		} else {
-			// Update streak — LastActionDate was set at action time
+		if engaged {
 			if char.LastActionDate == yesterday || char.LastActionDate == today {
 				char.CurrentStreak++
 			} else {
-				// Gap in activity — start fresh
+				// Legacy-only path: counters bumped but LastActionDate stale.
+				// Without this fall-through the streak would reset to 1 every
+				// night even with continuous play.
 				char.CurrentStreak = 1
 			}
 			if char.CurrentStreak > char.BestStreak {
 				char.BestStreak = char.CurrentStreak
 			}
+			char.LastActionDate = today
 			_ = saveAdvCharacter(&char)
+			continue
+		}
+
+		// Activity happened on the player's behalf without an explicit tap —
+		// autopilot walked rooms, expedition log gained beats, a fight session
+		// is still locked open. Hold the streak: no bump, no shame, no decay.
+		// The player engaged earlier to kick this off; autopilot is a feature,
+		// not a way to game streaks, and absence of taps shouldn't strip
+		// progress they earned through real play.
+		if len(todayActs[char.UserID]) > 0 || len(yesterdayActs[char.UserID]) > 0 {
+			continue
+		}
+		// Safety net for live state the activity logs don't reflect yet
+		// (e.g. an active expedition that's been quiet today, or a combat
+		// session locked open across midnight without a log append).
+		if exp, err := getActiveExpedition(char.UserID); err != nil {
+			slog.Warn("adventure: failed to check active expedition for idle reaper", "user", char.UserID, "err", err)
+		} else if exp != nil {
+			continue
+		}
+		if hasActiveCombatSession(char.UserID) {
+			continue
+		}
+
+		// Truly idle — shame DM + streak halve.
+		if dmsSent > 0 {
+			time.Sleep(time.Duration(1000+rand.IntN(2000)) * time.Millisecond)
+		}
+		dmsSent++
+
+		text := renderAdvIdleShameDM(char.UserID)
+		if char.CurrentStreak > 0 {
+			oldStreak := char.CurrentStreak
+			char.CurrentStreak /= 2
+			char.StreakDecayed = true
+			text += fmt.Sprintf("\n\n🔥 Streak: %d → %d days", oldStreak, char.CurrentStreak)
+			if char.CurrentStreak > 0 {
+				text += " — not all is lost."
+			}
+			_ = saveAdvCharacter(&char)
+		}
+		if err := p.SendDM(char.UserID, text); err != nil {
+			slog.Error("adventure: failed to send idle shame DM", "user", char.UserID, "err", err)
 		}
 	}
 
@@ -490,6 +513,12 @@ func (p *AdventurePlugin) midnightReset() error {
 		return fmt.Errorf("reset daily actions after 3 attempts: %w", resetErr)
 	}
 
+	// Clear the one-day pet morning-defense buff so it re-rolls fresh each
+	// morning (briefing or overworld DM) instead of leaking permanently.
+	if err := resetAllPetMorningDefense(); err != nil {
+		slog.Error("adventure: failed to reset pet morning defense", "err", err)
+	}
+
 	// Prune expired buffs
 	if err := pruneAdvExpiredBuffs(); err != nil {
 		slog.Error("adventure: failed to prune expired buffs", "err", err)

internal/plugin/adventure_scheduler_test.go

@@ -0,0 +1,145 @@
+package plugin
+
+import (
+	"testing"
+	"time"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// TestMidnightReset_Branching exercises the three idle-reaper branches:
+//   - engaged: LastActionDate stamped today/yesterday → streak bumps
+//   - activity-without-tap: autopilot/background activity logged today but
+//     no LastActionDate stamp → streak holds, no shame DM, no decay
+//   - truly idle: nothing anywhere → streak halves, StreakDecayed=true
+//
+// Regression guard for the autopilot bug: a player who let the background
+// auto-run walk an expedition all day used to get shamed at midnight because
+// markActedToday is gated on !compact at dnd_zone_cmd.go.
+func TestMidnightReset_Branching(t *testing.T) {
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatalf("db.Init: %v", err)
+	}
+	t.Cleanup(db.Close)
+
+	today := time.Now().UTC().Format("2006-01-02")
+	yesterday := time.Now().UTC().Add(-24 * time.Hour).Format("2006-01-02")
+
+	mk := func(uid, lastAction string, streak int) id.UserID {
+		u := id.UserID(uid)
+		if err := createAdvCharacter(u, uid); err != nil {
+			t.Fatalf("createAdvCharacter %s: %v", uid, err)
+		}
+		c, err := loadAdvCharacter(u)
+		if err != nil {
+			t.Fatalf("load %s: %v", uid, err)
+		}
+		c.LastActionDate = lastAction
+		c.CurrentStreak = streak
+		c.BestStreak = streak
+		if err := saveAdvCharacter(c); err != nil {
+			t.Fatalf("save %s: %v", uid, err)
+		}
+		return u
+	}
+
+	engaged := mk("@engaged:example", yesterday, 5)
+	autopilot := mk("@autopilot:example", "2020-01-01", 7)
+	idle := mk("@idle:example", "2020-01-01", 8)
+
+	// Simulate autopilot activity: a legacy activity-log row dated today.
+	// loadAdvDailyActivity unions this in, so the reaper sees the player as
+	// "had activity" without their LastActionDate being current.
+	if _, err := db.Get().Exec(
+		`INSERT INTO adventure_activity_log
+		 (user_id, activity_type, location, outcome, loot_value, xp_gained, flavor_key, logged_at)
+		 VALUES (?, 'zone', 'Test Zone', 'in_progress', 0, 0, '', CURRENT_TIMESTAMP)`,
+		string(autopilot),
+	); err != nil {
+		t.Fatalf("insert activity row: %v", err)
+	}
+
+	p := &AdventurePlugin{}
+	if err := p.midnightReset(); err != nil {
+		t.Fatalf("midnightReset: %v", err)
+	}
+
+	// Engaged → streak bumped, LastActionDate restamped to today, no decay.
+	if c, _ := loadAdvCharacter(engaged); c != nil {
+		if c.CurrentStreak != 6 {
+			t.Errorf("engaged: streak = %d, want 6", c.CurrentStreak)
+		}
+		if c.LastActionDate != today {
+			t.Errorf("engaged: LastActionDate = %q, want %q", c.LastActionDate, today)
+		}
+		if c.StreakDecayed {
+			t.Error("engaged: StreakDecayed = true, want false")
+		}
+	}
+
+	// Autopilot → hold. Streak unchanged, LastActionDate stays stale, no decay.
+	if c, _ := loadAdvCharacter(autopilot); c != nil {
+		if c.CurrentStreak != 7 {
+			t.Errorf("autopilot: streak = %d, want 7 (held)", c.CurrentStreak)
+		}
+		if c.StreakDecayed {
+			t.Error("autopilot: StreakDecayed = true, want false (shamed by mistake)")
+		}
+		if c.LastActionDate == today {
+			t.Errorf("autopilot: LastActionDate restamped to today — autopilot must not credit streak via LastActionDate")
+		}
+	}
+
+	// Idle → shame DM (no-op without Matrix client) + streak halved + decay flagged.
+	if c, _ := loadAdvCharacter(idle); c != nil {
+		if c.CurrentStreak != 4 {
+			t.Errorf("idle: streak = %d, want 4 (halved from 8)", c.CurrentStreak)
+		}
+		if !c.StreakDecayed {
+			t.Error("idle: StreakDecayed = false, want true")
+		}
+	}
+}
+
+// TestMidnightReset_DeathWindowSkips: a player who died today/yesterday is
+// left untouched — no shame, no streak change, no decay flag.
+func TestMidnightReset_DeathWindowSkips(t *testing.T) {
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatalf("db.Init: %v", err)
+	}
+	t.Cleanup(db.Close)
+
+	today := time.Now().UTC().Format("2006-01-02")
+
+	u := id.UserID("@dead:example")
+	if err := createAdvCharacter(u, "dead"); err != nil {
+		t.Fatalf("createAdvCharacter: %v", err)
+	}
+	c, _ := loadAdvCharacter(u)
+	c.LastActionDate = "2020-01-01"
+	c.CurrentStreak = 10
+	c.BestStreak = 10
+	c.LastDeathDate = today
+	if err := saveAdvCharacter(c); err != nil {
+		t.Fatalf("save: %v", err)
+	}
+
+	p := &AdventurePlugin{}
+	if err := p.midnightReset(); err != nil {
+		t.Fatalf("midnightReset: %v", err)
+	}
+
+	got, _ := loadAdvCharacter(u)
+	if got.CurrentStreak != 10 {
+		t.Errorf("dead: streak = %d, want 10 (untouched)", got.CurrentStreak)
+	}
+	if got.StreakDecayed {
+		t.Error("dead: StreakDecayed = true, want false")
+	}
+}

internal/plugin/adventure_secret_room_test.go

@@ -0,0 +1,216 @@
+package plugin
+
+import (
+	"strings"
+	"testing"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// registeredSecretNodes collects every NodeKindSecret node across all
+// registered zone graphs, keyed by node ID.
+func registeredSecretNodes(t *testing.T) map[string]ZoneNode {
+	t.Helper()
+	out := map[string]ZoneNode{}
+	for _, z := range allZones() {
+		g, ok := loadZoneGraph(z.ID)
+		if !ok {
+			continue
+		}
+		for id, n := range g.Nodes {
+			if n.Kind == NodeKindSecret {
+				out[id] = n
+			}
+		}
+	}
+	return out
+}
+
+// TestSecretRoomDiscovery_EverySecretHasBespokeFlavor guards that no secret
+// node ships on the generic fallback — every one gets an authored line. Catches
+// a future secret room added without a discovery entry.
+func TestSecretRoomDiscovery_EverySecretHasBespokeFlavor(t *testing.T) {
+	for id, n := range registeredSecretNodes(t) {
+		if _, ok := secretRoomDiscovery[id]; !ok {
+			t.Errorf("secret node %q (%q) has no bespoke discovery line", id, n.Label)
+		}
+		if line := secretRoomDiscoveryLine(n); strings.TrimSpace(line) == "" {
+			t.Errorf("secret node %q produced an empty discovery line", id)
+		}
+	}
+}
+
+func TestSecretRoomDiscoveryLine_FallsBackOnUnknownNode(t *testing.T) {
+	n := ZoneNode{NodeID: "made_up.node", Kind: NodeKindSecret, Label: "Nowhere Nook"}
+	line := secretRoomDiscoveryLine(n)
+	if !strings.Contains(line, "Nowhere Nook") {
+		t.Errorf("fallback should name the node label, got: %s", line)
+	}
+}
+
+// TestSecretRoomKeys_UnlockRealDestinationEdges is the cross-zone-key
+// consistency check: every key's item Name must match a LockKey edge's key_id
+// (lower-cased) in its destination zone, and every source must be a real secret
+// room. A typo between the granted item name and the authored key_id would
+// silently make a vault permanently unreachable; this catches it.
+func TestSecretRoomKeys_UnlockRealDestinationEdges(t *testing.T) {
+	secrets := registeredSecretNodes(t)
+	for srcNode, key := range secretRoomKeys {
+		if _, ok := secrets[srcNode]; !ok {
+			t.Errorf("key source %q is not a registered secret room", srcNode)
+		}
+		g, ok := loadZoneGraph(key.unlocksIn)
+		if !ok {
+			t.Errorf("%s: destination zone %q has no graph", srcNode, key.unlocksIn)
+			continue
+		}
+		wantKeyID := strings.ToLower(key.item.Name)
+		found := false
+		for _, outs := range g.Edges {
+			for _, e := range outs {
+				if e.Lock == LockKey && strings.ToLower(lockDataString(e.LockData, "key_id")) == wantKeyID {
+					found = true
+				}
+			}
+		}
+		if !found {
+			t.Errorf("key %q (from %s) has no LockKey edge with key_id=%q in zone %q — vault unreachable",
+				key.item.Name, srcNode, wantKeyID, key.unlocksIn)
+		}
+	}
+}
+
+// TestCrossZoneKey_UnlocksWithItemNotWithout exercises the runtime lock
+// evaluation end-to-end on a real authored edge.
+func TestCrossZoneKey_UnlocksWithItemNotWithout(t *testing.T) {
+	g, ok := loadZoneGraph(ZoneManorBlackspire)
+	if !ok {
+		t.Fatal("manor graph missing")
+	}
+	var keyEdge ZoneEdge
+	for _, e := range g.outgoingEdges("manor_blackspire.upper_hall") {
+		if e.Lock == LockKey {
+			keyEdge = e
+		}
+	}
+	if keyEdge.To == "" {
+		t.Fatal("no LockKey edge off manor upper_hall")
+	}
+
+	base := edgeUnlockCtx{RunID: "r", FromNode: "manor_blackspire.upper_hall"}
+	if ok, _ := evaluateEdgeLock(keyEdge, base); ok {
+		t.Error("edge should be locked without the key in inventory")
+	}
+
+	withKey := base
+	withKey.InventoryNames = map[string]bool{"sunken sigil": true}
+	if ok, reason := evaluateEdgeLock(keyEdge, withKey); !ok {
+		t.Errorf("edge should unlock with the sigil in inventory, got locked: %s", reason)
+	}
+}
+
+// TestGrantSecretRoomKey_GrantsOnceIdempotent verifies a key-bearing secret
+// hands its key over exactly once.
+func TestGrantSecretRoomKey_GrantsOnceIdempotent(t *testing.T) {
+	townTestDB(t)
+	p := &AdventurePlugin{}
+	u := id.UserID("@keyholder:test.invalid")
+
+	node := ZoneNode{NodeID: "sunken_temple.coral_reliquary", Kind: NodeKindSecret}
+	line := p.grantSecretRoomKey(u, node)
+	if !strings.Contains(line, "Sunken Sigil") {
+		t.Fatalf("first grant should name the key, got: %q", line)
+	}
+
+	items, err := loadAdvInventory(u)
+	if err != nil {
+		t.Fatalf("load inventory: %v", err)
+	}
+	sigils := 0
+	for _, it := range items {
+		if strings.EqualFold(it.Name, "Sunken Sigil") {
+			sigils++
+		}
+	}
+	if sigils != 1 {
+		t.Fatalf("want exactly 1 Sunken Sigil, got %d", sigils)
+	}
+
+	// Second find on a later run must not stack a duplicate.
+	if again := p.grantSecretRoomKey(u, node); again != "" {
+		t.Errorf("re-finding the room should not re-grant the key, got: %q", again)
+	}
+	items, _ = loadAdvInventory(u)
+	sigils = 0
+	for _, it := range items {
+		if strings.EqualFold(it.Name, "Sunken Sigil") {
+			sigils++
+		}
+	}
+	if sigils != 1 {
+		t.Fatalf("still want exactly 1 Sunken Sigil after re-find, got %d", sigils)
+	}
+}
+
+// TestGrantSecretRoomKey_NoKeyForPlainSecret confirms a secret room that carries
+// no cross-zone key stays silent.
+func TestGrantSecretRoomKey_NoKeyForPlainSecret(t *testing.T) {
+	townTestDB(t)
+	p := &AdventurePlugin{}
+	u := id.UserID("@plain:test.invalid")
+	node := ZoneNode{NodeID: "forest_shadows.sapling_shrine", Kind: NodeKindSecret}
+	if line := p.grantSecretRoomKey(u, node); line != "" {
+		t.Errorf("plain secret should grant no key, got: %q", line)
+	}
+}
+
+// TestResolveSecretRoom_GrantsPageCacheAndKey checks the full treasure-cache
+// payout: a journal page, the consumable cache, and (for a key-bearing secret)
+// the cross-zone key — with no combat touching HP.
+func TestResolveSecretRoom_GrantsPageCacheAndKey(t *testing.T) {
+	townTestDB(t)
+	p := &AdventurePlugin{}
+	u := id.UserID("@secret:test.invalid")
+
+	zone, ok := getZone(ZoneSunkenTemple)
+	if !ok {
+		t.Fatal("sunken temple zone missing")
+	}
+	node := ZoneNode{
+		NodeID: "sunken_temple.coral_reliquary", Kind: NodeKindSecret,
+		Label:   "Coral Reliquary",
+		Content: ZoneNodeContent{LootBias: 1.8},
+	}
+	run := &DungeonRun{UserID: string(u), ZoneID: ZoneSunkenTemple, CurrentNode: node.NodeID}
+
+	out := p.resolveSecretRoom(u, run, zone, node)
+	if !strings.Contains(out, "Coral Reliquary") {
+		t.Errorf("outcome should carry the discovery line:\n%s", out)
+	}
+
+	// A journal page was granted (fresh player, nothing found yet).
+	if mask, err := loadJournalPages(u); err != nil || journalPageCount(mask) != 1 {
+		t.Fatalf("want exactly 1 journal page granted, got count=%d err=%v", journalPageCount(mask), err)
+	}
+
+	// The guaranteed cache + the cross-zone key are in inventory.
+	items, err := loadAdvInventory(u)
+	if err != nil {
+		t.Fatalf("load inventory: %v", err)
+	}
+	var caches, keys int
+	for _, it := range items {
+		switch {
+		case it.Type == "key":
+			keys++
+		case it.Type == "consumable":
+			caches++
+		}
+	}
+	if caches != secretRoomCacheCount {
+		t.Errorf("want %d cache consumables, got %d", secretRoomCacheCount, caches)
+	}
+	if keys != 1 {
+		t.Errorf("want the Sunken Sigil key granted, got %d keys", keys)
+	}
+}

internal/plugin/adventure_shadow.go

@@ -0,0 +1,432 @@
+package plugin
+
+import (
+	"database/sql"
+	"fmt"
+	"hash/fnv"
+	"log/slog"
+	"strings"
+	"time"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// The Shadow (N6/D3) — a per-player simulated rival adventurer. It "runs" the
+// same zone progression the player does, advanced once per UTC day by the
+// midnight ticker at ~1.3x the player's own long-run clear pace, so it stays
+// just ahead: a rival you can always see and always nearly catch.
+//
+// It is pure theatre. There is no Shadow combat, no punishment, no state the
+// player can lose. The only mechanics are race pressure (a morning-briefing
+// line telling you where it is relative to you) and two payoffs at each zone
+// clear: beat the Shadow to a zone and TwinBee crows a little bonus XP; let the
+// Shadow clear it first and it leaves a journal page waiting in the boss room
+// (the D1 campaign tie-in). All Shadow narration TwinBee speaks is first-person,
+// he/him, implicit-subject — the campaign voice rules (feedback_twinbee_voice,
+// feedback_twinbee_is_male). The Shadow itself is referred to as "the Shadow"
+// (or by its name); "he" in TwinBee's lines is TwinBee, never a third-person
+// "TwinBee".
+
+const (
+	// shadowPaceMultiplier keeps the Shadow just ahead: it clears at ~1.3x the
+	// player's own long-run pace.
+	shadowPaceMultiplier = 1.3
+	// shadowMinDailyStep is the floor on a day's advance, so a brand-new or idle
+	// player still watches the rival creep forward rather than sit frozen.
+	shadowMinDailyStep = 0.2
+	// shadowMaxDailyStep caps a day's advance at just under one zone, so even a
+	// prolific player never sees the Shadow clear two zones overnight.
+	shadowMaxDailyStep = 1.0
+	// shadowMaxLead caps how far ahead the Shadow may run — it is a race, not a
+	// runaway. It will never sit more than ~2.5 zones past the player's own count.
+	shadowMaxLead = 2.5
+	// shadowCrowXPPerTier scales the "you beat me here" bonus by zone tier, so a
+	// T5 crow is worth more than a T1 one. Small on purpose (lift, not a spike).
+	shadowCrowXPPerTier = 12
+)
+
+// shadowState mirrors the adventure_shadow row.
+type shadowState struct {
+	UserID       id.UserID
+	Name         string
+	Progress     float64
+	ZonesCleared int
+	PendingMask  int64
+	CrowedMask   int64
+	DayCounter   int
+	LastAdvanced string
+}
+
+// The Shadow walks zoneOrder — the design-doc order the zone registry is built
+// in — start to finish, tier 1 → 5. Bit i of a Shadow's masks is zoneOrder[i].
+
+// shadowZoneIndex returns the progression index of a zone, or -1 if it is not
+// on the path (the arena, an unknown id).
+func shadowZoneIndex(z ZoneID) int {
+	for i, id := range zoneOrder {
+		if id == z {
+			return i
+		}
+	}
+	return -1
+}
+
+func shadowSetBit(mask int64, idx int) int64 {
+	if idx < 0 || idx > 62 {
+		return mask
+	}
+	return mask | (int64(1) << idx)
+}
+
+func shadowClearBit(mask int64, idx int) int64 {
+	if idx < 0 || idx > 62 {
+		return mask
+	}
+	return mask &^ (int64(1) << idx)
+}
+
+func shadowBitSet(mask int64, idx int) bool {
+	if idx < 0 || idx > 62 {
+		return false
+	}
+	return mask&(int64(1)<<idx) != 0
+}
+
+// loadShadow reads a player's Shadow, or (nil, nil) if it hasn't been born yet.
+func loadShadow(userID id.UserID) (*shadowState, error) {
+	s := &shadowState{UserID: userID}
+	err := db.Get().QueryRow(
+		`SELECT name, progress, zones_cleared, pending_mask, crowed_mask, day_counter, last_advanced
+		   FROM adventure_shadow WHERE user_id = ?`,
+		string(userID),
+	).Scan(&s.Name, &s.Progress, &s.ZonesCleared, &s.PendingMask, &s.CrowedMask, &s.DayCounter, &s.LastAdvanced)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
+// upsertShadow persists the whole Shadow row. The ticker is the only writer, so
+// a plain last-write-wins upsert is safe — there is no concurrent mutator to
+// race (unlike the player_meta columns a character save also touches).
+func upsertShadow(s *shadowState) error {
+	_, err := db.Get().Exec(
+		`INSERT INTO adventure_shadow
+		   (user_id, name, progress, zones_cleared, pending_mask, crowed_mask, day_counter, last_advanced)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+		 ON CONFLICT(user_id) DO UPDATE SET
+		   name = excluded.name,
+		   progress = excluded.progress,
+		   zones_cleared = excluded.zones_cleared,
+		   pending_mask = excluded.pending_mask,
+		   crowed_mask = excluded.crowed_mask,
+		   day_counter = excluded.day_counter,
+		   last_advanced = excluded.last_advanced`,
+		string(s.UserID), s.Name, s.Progress, s.ZonesCleared, s.PendingMask,
+		s.CrowedMask, s.DayCounter, s.LastAdvanced,
+	)
+	return err
+}
+
+// shadowNames is the pool the rival's proper name is drawn from — cold,
+// half-familiar names for a thing that shadows you. Picked deterministically
+// from the player's own name so a given player always faces the same Shadow.
+var shadowNames = []string{
+	"Vael", "Corriss", "Mordane", "Ashen", "Locke", "Grimma", "Sable",
+	"Thane", "Wren", "Vesper", "Cael", "Orrin", "Dain", "Wraithe",
+	"Nyx", "Solenne",
+}
+
+// shadowNameFor seeds the Shadow's name from the player's display name so it is
+// stable per player and "seeded from the player's" (D3 spec). Falls back to the
+// user id when the display name is empty.
+func shadowNameFor(displayName string, userID id.UserID) string {
+	seed := strings.ToLower(strings.TrimSpace(displayName))
+	if seed == "" {
+		seed = string(userID)
+	}
+	h := fnv.New32a()
+	_, _ = h.Write([]byte(seed))
+	return shadowNames[int(h.Sum32())%len(shadowNames)]
+}
+
+// newShadow mints a fresh Shadow at the start line.
+func newShadow(userID id.UserID, displayName string) *shadowState {
+	return &shadowState{
+		UserID: userID,
+		Name:   shadowNameFor(displayName, userID),
+	}
+}
+
+// advanceShadow moves a player's Shadow forward one UTC day. Idempotent per day
+// via last_advanced, so the once-a-day midnight guard plus this makes a double
+// tick a no-op. Mints the Shadow on first call. Errors are logged and swallowed
+// — a stalled Shadow is cosmetic, and must never break the midnight reset loop.
+func (p *AdventurePlugin) advanceShadow(char *AdventureCharacter) {
+	today := time.Now().UTC().Format("2006-01-02")
+	s, err := loadShadow(char.UserID)
+	if err != nil {
+		slog.Warn("shadow: load", "user", char.UserID, "err", err)
+		return
+	}
+	if s == nil {
+		s = newShadow(char.UserID, char.DisplayName)
+	}
+	if s.LastAdvanced == today {
+		return // already advanced this UTC day
+	}
+
+	cleared := clearedZoneIDs(db.Get(), char.UserID)
+	playerCount := len(cleared)
+
+	// The player's long-run pace, in zones per day, drives the Shadow's speed.
+	// Floor it so a new/idle player still gets a creeping rival; the 1.3x keeps
+	// the Shadow just ahead; cap the daily step so it never leaps two zones.
+	step := (float64(playerCount) / float64(shadowPlayerAgeDays(char))) * shadowPaceMultiplier
+	if step < shadowMinDailyStep {
+		step = shadowMinDailyStep
+	}
+	if step > shadowMaxDailyStep {
+		step = shadowMaxDailyStep
+	}
+
+	newProg := s.Progress + step
+	// Keep it a race: never more than shadowMaxLead zones past the player's count.
+	if leadCap := float64(playerCount) + shadowMaxLead; newProg > leadCap {
+		newProg = leadCap
+	}
+	if maxProg := float64(len(zoneOrder)); newProg > maxProg {
+		newProg = maxProg
+	}
+	if newProg < s.Progress {
+		newProg = s.Progress // never regress (a lead cap that dropped below current)
+	}
+
+	// Any progression zone the Shadow newly finishes, and the player hasn't,
+	// leaves a page waiting. Compare per-zone (not by count): the Shadow walks
+	// in order while the player may clear out of order, so "did the Shadow clear
+	// zone i first" is a per-zone question.
+	newCleared := int(newProg)
+	if newCleared > len(zoneOrder) {
+		newCleared = len(zoneOrder)
+	}
+	for idx := s.ZonesCleared; idx < newCleared; idx++ {
+		if !cleared[zoneOrder[idx]] {
+			s.PendingMask = shadowSetBit(s.PendingMask, idx)
+		}
+	}
+
+	s.Progress = newProg
+	s.ZonesCleared = newCleared
+	s.DayCounter++
+	s.LastAdvanced = today
+	if err := upsertShadow(s); err != nil {
+		slog.Warn("shadow: advance upsert", "user", char.UserID, "err", err)
+	}
+}
+
+// shadowPlayerAgeDays estimates how many days the player has been adventuring,
+// clamped to at least 1 so a same-day character never divides by zero. Used as
+// the denominator of the player's pace.
+func shadowPlayerAgeDays(char *AdventureCharacter) float64 {
+	if char.CreatedAt.IsZero() {
+		return 1
+	}
+	days := time.Since(char.CreatedAt).Hours() / 24
+	if days < 1 {
+		return 1
+	}
+	return days
+}
+
+// shadowOnPlayerZoneClear is the payoff, fired when the player clears a zone's
+// boss. Three outcomes: the Shadow left a page here (pending bit) → grant the
+// page and clear the bit; the player beat the Shadow to this zone → a crow plus
+// a little bonus XP; or the Shadow already passed through with nothing owed →
+// nothing. Returns the narration line to append to the clear message ("" for
+// the silent case, or when the Shadow hasn't been born yet).
+func (p *AdventurePlugin) shadowOnPlayerZoneClear(userID id.UserID, zoneID ZoneID) string {
+	s, err := loadShadow(userID)
+	if err != nil || s == nil {
+		return ""
+	}
+	idx := shadowZoneIndex(zoneID)
+	if idx < 0 {
+		return ""
+	}
+
+	if shadowBitSet(s.PendingMask, idx) {
+		// The Shadow got here first and left a page. Grant it BEFORE retiring the
+		// debt: grantJournalPage returns "" both when the campaign is already
+		// complete and on a transient DB error, so clear the pending bit only once
+		// the page has actually landed (or the ledger is genuinely full). A
+		// transient failure then leaves the bit set and the next clear retries,
+		// rather than swallowing a page the player earned.
+		pageLine := p.grantJournalPage(userID, nil)
+		mask, _ := loadJournalPages(userID)
+		if pageLine == "" && !journalComplete(mask) {
+			slog.Warn("shadow: waiting page grant failed; leaving debt for retry",
+				"user", userID, "zone", zoneID)
+			return ""
+		}
+		s.PendingMask = shadowClearBit(s.PendingMask, idx)
+		if err := upsertShadow(s); err != nil {
+			// The page is already granted; a failed bit-clear can at worst re-grant
+			// a different unfound page on a later re-clear, which is benign (pages
+			// are collectible and the campaign self-limits). Better than losing it.
+			slog.Warn("shadow: clear pending bit", "user", userID, "zone", zoneID, "err", err)
+		}
+		if pageLine == "" {
+			// Ledger already complete — nothing to leave, but the Shadow was first.
+			return shadowBeatYouHereLine(s)
+		}
+		return shadowLeftPageLine(s) + "\n" + pageLine
+	}
+
+	// No page owed. If the Shadow hasn't reached this zone yet, the player beat
+	// it here — crow and hand over a small bonus, but only once per zone: the
+	// crowed bit makes re-running a not-yet-reached zone unable to farm the XP.
+	if int(s.Progress) <= idx && !shadowBitSet(s.CrowedMask, idx) {
+		xp := shadowCrowXP(zoneID)
+		if _, err := p.grantDnDXP(userID, xp); err != nil {
+			// Don't promise XP we didn't grant, and don't burn the crow — leave the
+			// bit unset so the next clear can crow for real.
+			slog.Warn("shadow: crow xp", "user", userID, "err", err)
+			return ""
+		}
+		s.CrowedMask = shadowSetBit(s.CrowedMask, idx)
+		if err := upsertShadow(s); err != nil {
+			slog.Warn("shadow: set crowed bit", "user", userID, "zone", zoneID, "err", err)
+		}
+		return shadowCrowLine(s, xp)
+	}
+	return ""
+}
+
+// shadowCrowXP is the bonus for beating the Shadow to a zone, scaled by tier.
+func shadowCrowXP(zoneID ZoneID) int {
+	tier := 1
+	if z, ok := getZone(zoneID); ok {
+		tier = int(z.Tier)
+	}
+	if tier < 1 {
+		tier = 1
+	}
+	return tier * shadowCrowXPPerTier
+}
+
+// shadowBriefingLine is the morning-briefing race-pressure beat: where the
+// Shadow stands relative to the player. Deterministic by day so a re-rendered
+// briefing reads the same, and silent until the Shadow has been born and has
+// something to say. TwinBee's voice.
+func (p *AdventurePlugin) shadowBriefingLine(e *Expedition) string {
+	userID := id.UserID(e.UserID)
+	s, err := loadShadow(userID)
+	if err != nil || s == nil {
+		return ""
+	}
+	playerCount := len(clearedZoneIDs(db.Get(), userID))
+	lead := s.ZonesCleared - playerCount
+	return shadowRacePressureLine(s, e.CurrentDay, lead)
+}
+
+// ── Flavour ────────────────────────────────────────────────────────────────
+//
+// TwinBee's voice: first-person, implicit subject, he/him, one line. "The
+// Shadow"/"{name}" is the rival; "I"/"we" is TwinBee and the player. Never the
+// third-person "TwinBee" (guarded by test, same as the journal reactions).
+
+// shadowAheadLines — TwinBee, the Shadow is ahead of us. Race pressure.
+var shadowAheadLines = []string{
+	"Passed the Shadow's camp at dawn — cold ashes, a day old. %s is ahead of us again.",
+	"Found %s's mark cut into a doorframe up ahead. Still warm. We're not gaining.",
+	"%s came through here already. I can smell the pitch of a torch not long snuffed.",
+	"The Shadow's been and gone. %s leaves the doors open behind, like he wants us to know.",
+}
+
+// shadowBehindLines — TwinBee, we're ahead of the Shadow. Earned swagger.
+var shadowBehindLines = []string{
+	"No sign of %s ahead — I think we're out in front for once. Let's keep it that way.",
+	"We've outpaced the Shadow. %s is somewhere behind us, eating our dust. Good.",
+	"Quiet up ahead. %s hasn't reached this deep yet. First ones through.",
+}
+
+// shadowNeckLines — TwinBee, we're level with the Shadow. Tension.
+var shadowNeckLines = []string{
+	"%s is right on our heels — or we're on his. Hard to say who's chasing who now.",
+	"Neck and neck with the Shadow. I keep catching %s at the edge of the torchlight.",
+	"%s is close. Same rooms, hours apart. Whoever clears the next zone first wins the day.",
+}
+
+// shadowRacePressureLine picks a race-pressure line by the day and the Shadow's
+// lead, deterministically. lead > 0: Shadow ahead; lead < 0: player ahead; 0:
+// level.
+func shadowRacePressureLine(s *shadowState, day, lead int) string {
+	var pool []string
+	switch {
+	case lead > 0:
+		pool = shadowAheadLines
+	case lead < 0:
+		pool = shadowBehindLines
+	default:
+		pool = shadowNeckLines
+	}
+	if len(pool) == 0 {
+		return ""
+	}
+	idx := (day + s.DayCounter) % len(pool)
+	if idx < 0 {
+		idx = -idx
+	}
+	return "👤 " + fmt.Sprintf(pool[idx], s.Name)
+}
+
+// shadowLeftPageLine prefaces the waiting journal page: the Shadow cleared this
+// zone first and left a page behind for us. TwinBee's voice.
+func shadowLeftPageLine(s *shadowState) string {
+	return fmt.Sprintf("👤 %s beat us to this one — but left a torn page pinned in the boss's lair, like a note for whoever came next.", s.Name)
+}
+
+// shadowBeatYouHereLine is the page-less acknowledgement (campaign already
+// complete): the Shadow was first, but there's nothing left to find.
+func shadowBeatYouHereLine(s *shadowState) string {
+	return fmt.Sprintf("👤 %s was here before us. Boot-prints in the dust, and nothing left to take. We know how this ends now anyway.", s.Name)
+}
+
+// shadowCrowLine is TwinBee crowing that we beat the Shadow to a zone, with the
+// bonus XP.
+func shadowCrowLine(s *shadowState, xp int) string {
+	return fmt.Sprintf("👤 First ones through — %s is still somewhere behind us. I'd crow if it wouldn't give us away. (**+%d XP**, for beating the Shadow here.)", s.Name, xp)
+}
+
+// handleShadowCmd renders the player's standing against the Shadow. A quiet
+// status view — the feature lives mostly in the briefing and at zone clears.
+func (p *AdventurePlugin) handleShadowCmd(ctx MessageContext) error {
+	s, err := loadShadow(ctx.Sender)
+	if err != nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "Couldn't read the trail just now. Try again in a moment.")
+	}
+	if s == nil {
+		return p.SendDM(ctx.Sender, "👤 No one's shadowing you yet. Clear a zone or two and someone will take an interest.")
+	}
+	playerCount := len(clearedZoneIDs(db.Get(), ctx.Sender))
+	total := len(zoneOrder)
+	var b strings.Builder
+	b.WriteString(fmt.Sprintf("👤 **The Shadow — %s**\n\n", s.Name))
+	b.WriteString(fmt.Sprintf("🏴 **%s's trail:** %d / %d zones cleared\n", s.Name, s.ZonesCleared, total))
+	b.WriteString(fmt.Sprintf("🚩 **Your trail:** %d / %d zones cleared\n", playerCount, total))
+	switch lead := s.ZonesCleared - playerCount; {
+	case lead > 0:
+		b.WriteString(fmt.Sprintf("\n_%s is **%d** ahead. Pages wait where he cleared first — take them back by clearing those zones yourself._", s.Name, lead))
+	case lead < 0:
+		b.WriteString(fmt.Sprintf("\n_You're **%d** ahead. Keep it that way._", -lead))
+	default:
+		b.WriteString("\n_Dead level. The next zone decides who's chasing whom._")
+	}
+	return p.SendDM(ctx.Sender, b.String())
+}

internal/plugin/adventure_shadow_test.go

@@ -0,0 +1,360 @@
+package plugin
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+func newShadowTestDB(t *testing.T) {
+	t.Helper()
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+}
+
+// freshChar builds a same-day character so shadowPlayerAgeDays reads 1 day.
+func freshChar(user id.UserID) *AdventureCharacter {
+	return &AdventureCharacter{
+		UserID:      user,
+		DisplayName: "Tester",
+		CreatedAt:   time.Now().UTC(),
+	}
+}
+
+func TestShadowName_DeterministicAndInPool(t *testing.T) {
+	user := id.UserID("@name:test.invalid")
+	first := shadowNameFor("Aria", user)
+	if again := shadowNameFor("Aria", user); again != first {
+		t.Errorf("name not deterministic: %q vs %q", first, again)
+	}
+	inPool := false
+	for _, n := range shadowNames {
+		if n == first {
+			inPool = true
+			break
+		}
+	}
+	if !inPool {
+		t.Errorf("generated name %q not in shadowNames pool", first)
+	}
+	// Empty display name falls back to the user id and still yields a pool name.
+	if got := shadowNameFor("", user); got == "" {
+		t.Error("empty display name produced an empty shadow name")
+	}
+}
+
+// TestShadowFlavor_NoThirdPersonTwinBee: every Shadow line TwinBee speaks obeys
+// the campaign voice rule — he never refers to himself in the third person
+// (feedback_twinbee_voice). Same guard the journal reactions carry.
+func TestShadowFlavor_NoThirdPersonTwinBee(t *testing.T) {
+	pools := [][]string{shadowAheadLines, shadowBehindLines, shadowNeckLines}
+	for _, pool := range pools {
+		for _, line := range pool {
+			if strings.Contains(line, "TwinBee") {
+				t.Errorf("third-person TwinBee in Shadow pool line: %q", line)
+			}
+			if !strings.Contains(line, "%s") {
+				t.Errorf("race-pressure line missing the name slot: %q", line)
+			}
+		}
+	}
+	s := &shadowState{Name: "Vael"}
+	rendered := []string{
+		shadowLeftPageLine(s),
+		shadowBeatYouHereLine(s),
+		shadowCrowLine(s, 24),
+		shadowRacePressureLine(s, 3, 1),
+		shadowRacePressureLine(s, 3, -1),
+		shadowRacePressureLine(s, 3, 0),
+	}
+	for _, r := range rendered {
+		if strings.Contains(r, "TwinBee") {
+			t.Errorf("third-person TwinBee in rendered Shadow line: %q", r)
+		}
+		if !strings.Contains(r, "Vael") {
+			t.Errorf("rendered line dropped the Shadow's name: %q", r)
+		}
+	}
+}
+
+func TestShadowRacePressure_Deterministic(t *testing.T) {
+	s := &shadowState{Name: "Vael", DayCounter: 2}
+	first := shadowRacePressureLine(s, 4, 1)
+	if again := shadowRacePressureLine(s, 4, 1); again != first {
+		t.Errorf("race pressure not deterministic: %q vs %q", first, again)
+	}
+	// Direction picks a different pool: ahead vs behind must differ in wording.
+	ahead := shadowRacePressureLine(s, 4, 2)
+	behind := shadowRacePressureLine(s, 4, -2)
+	if ahead == behind {
+		t.Errorf("ahead and behind produced the same line: %q", ahead)
+	}
+}
+
+func TestShadowAdvance_CreepsAndIsIdempotent(t *testing.T) {
+	newShadowTestDB(t)
+	p := &AdventurePlugin{}
+	user := id.UserID("@creep:test.invalid")
+	char := freshChar(user)
+
+	p.advanceShadow(char)
+	s, err := loadShadow(user)
+	if err != nil || s == nil {
+		t.Fatalf("shadow not born: %v", err)
+	}
+	if s.Progress <= 0 {
+		t.Errorf("a born shadow should have crept forward, got progress %v", s.Progress)
+	}
+	if s.Name == "" {
+		t.Error("born shadow has no name")
+	}
+	firstProg := s.Progress
+
+	// Second advance the same UTC day is a no-op.
+	p.advanceShadow(char)
+	s2, _ := loadShadow(user)
+	if s2.Progress != firstProg {
+		t.Errorf("same-day re-advance moved the shadow: %v -> %v", firstProg, s2.Progress)
+	}
+
+	// Roll the clock back a day and it advances again.
+	s2.LastAdvanced = time.Now().UTC().Add(-24 * time.Hour).Format("2006-01-02")
+	if err := upsertShadow(s2); err != nil {
+		t.Fatal(err)
+	}
+	p.advanceShadow(char)
+	s3, _ := loadShadow(user)
+	if s3.Progress <= firstProg {
+		t.Errorf("a new day should have advanced the shadow: %v -> %v", firstProg, s3.Progress)
+	}
+}
+
+func TestShadowAdvance_PendingBitForUnclearedZone(t *testing.T) {
+	newShadowTestDB(t)
+	p := &AdventurePlugin{}
+	user := id.UserID("@pending:test.invalid")
+	char := freshChar(user)
+
+	// Seed the shadow one step short of clearing zone 0, dated yesterday so the
+	// next advance runs. The player has cleared nothing.
+	yesterday := time.Now().UTC().Add(-24 * time.Hour).Format("2006-01-02")
+	seed := newShadow(user, char.DisplayName)
+	seed.Progress = 0.95
+	seed.LastAdvanced = yesterday
+	if err := upsertShadow(seed); err != nil {
+		t.Fatal(err)
+	}
+
+	p.advanceShadow(char)
+	s, _ := loadShadow(user)
+	if s.ZonesCleared < 1 {
+		t.Fatalf("shadow should have cleared zone 0, zones_cleared=%d prog=%v", s.ZonesCleared, s.Progress)
+	}
+	if !shadowBitSet(s.PendingMask, 0) {
+		t.Errorf("shadow cleared zone 0 before the player but left no pending page (mask=%b)", s.PendingMask)
+	}
+}
+
+func TestShadowAdvance_NoPendingWhenPlayerClearedFirst(t *testing.T) {
+	newShadowTestDB(t)
+	p := &AdventurePlugin{}
+	user := id.UserID("@nopending:test.invalid")
+	char := freshChar(user)
+
+	// Player already cleared zone 0.
+	insertClearedExpedition(t, user, zoneOrder[0], ExpeditionStatusComplete, 1, "{}")
+
+	yesterday := time.Now().UTC().Add(-24 * time.Hour).Format("2006-01-02")
+	seed := newShadow(user, char.DisplayName)
+	seed.Progress = 0.95
+	seed.LastAdvanced = yesterday
+	if err := upsertShadow(seed); err != nil {
+		t.Fatal(err)
+	}
+
+	p.advanceShadow(char)
+	s, _ := loadShadow(user)
+	if s.ZonesCleared < 1 {
+		t.Fatalf("shadow should have cleared zone 0, zones_cleared=%d", s.ZonesCleared)
+	}
+	if shadowBitSet(s.PendingMask, 0) {
+		t.Errorf("player cleared zone 0 first — no page should wait (mask=%b)", s.PendingMask)
+	}
+}
+
+func TestShadowAdvance_LeadCapKeepsItARace(t *testing.T) {
+	newShadowTestDB(t)
+	p := &AdventurePlugin{}
+	user := id.UserID("@leadcap:test.invalid")
+	char := freshChar(user) // player has cleared nothing → count 0
+
+	yesterday := time.Now().UTC().Add(-24 * time.Hour).Format("2006-01-02")
+	seed := newShadow(user, char.DisplayName)
+	seed.Progress = shadowMaxLead // already at the cap for a 0-clear player
+	seed.ZonesCleared = 2
+	seed.LastAdvanced = yesterday
+	if err := upsertShadow(seed); err != nil {
+		t.Fatal(err)
+	}
+
+	p.advanceShadow(char)
+	s, _ := loadShadow(user)
+	if s.Progress > shadowMaxLead+0.0001 {
+		t.Errorf("shadow ran past the lead cap: progress %v > %v", s.Progress, shadowMaxLead)
+	}
+}
+
+func TestShadowZoneClear_PendingGrantsWaitingPage(t *testing.T) {
+	newShadowTestDB(t)
+	p := &AdventurePlugin{}
+	user := id.UserID("@page:test.invalid")
+
+	idx := 2
+	seed := newShadow(user, "Tester")
+	seed.Progress = 5
+	seed.ZonesCleared = 5
+	seed.PendingMask = shadowSetBit(0, idx)
+	if err := upsertShadow(seed); err != nil {
+		t.Fatal(err)
+	}
+
+	line := p.shadowOnPlayerZoneClear(user, zoneOrder[idx])
+	if strings.TrimSpace(line) == "" {
+		t.Fatal("a waiting page should have produced a clear-message line")
+	}
+	if !strings.Contains(line, "page") {
+		t.Errorf("expected a journal-page grant in the line, got: %q", line)
+	}
+	// Bit cleared so a re-clear can't re-award.
+	s, _ := loadShadow(user)
+	if shadowBitSet(s.PendingMask, idx) {
+		t.Error("pending bit not cleared after the page was granted")
+	}
+	// The page actually landed.
+	if mask, _ := loadJournalPages(user); journalPageCount(mask) != 1 {
+		t.Errorf("expected exactly one journal page granted, got %d", journalPageCount(mask))
+	}
+
+	// A second clear of the same zone grants nothing more.
+	again := p.shadowOnPlayerZoneClear(user, zoneOrder[idx])
+	if again != "" {
+		t.Errorf("re-clearing a paid-out zone should be silent, got: %q", again)
+	}
+	if mask, _ := loadJournalPages(user); journalPageCount(mask) != 1 {
+		t.Errorf("re-clear granted a second page (count %d)", journalPageCount(mask))
+	}
+}
+
+func TestShadowZoneClear_PlayerFirstCrows(t *testing.T) {
+	newShadowTestDB(t)
+	p := &AdventurePlugin{}
+	user := id.UserID("@crow:test.invalid")
+
+	idx := 3
+	seed := newShadow(user, "Tester")
+	seed.Progress = 0 // shadow hasn't reached this zone
+	if err := upsertShadow(seed); err != nil {
+		t.Fatal(err)
+	}
+
+	line := p.shadowOnPlayerZoneClear(user, zoneOrder[idx])
+	if !strings.Contains(line, "XP") {
+		t.Errorf("beating the shadow should crow a bonus, got: %q", line)
+	}
+	// No page granted on a crow.
+	if mask, _ := loadJournalPages(user); journalPageCount(mask) != 0 {
+		t.Errorf("a crow should not grant a page (count %d)", journalPageCount(mask))
+	}
+	// The crowed bit is set so a re-run of the same not-yet-reached zone can't
+	// farm the XP again — second clear is silent.
+	if s, _ := loadShadow(user); !shadowBitSet(s.CrowedMask, idx) {
+		t.Error("crowed bit not set after the first crow")
+	}
+	if again := p.shadowOnPlayerZoneClear(user, zoneOrder[idx]); again != "" {
+		t.Errorf("re-clearing an already-crowed zone should be silent, got: %q", again)
+	}
+}
+
+func TestShadowZoneClear_ShadowPassedNoDebt(t *testing.T) {
+	newShadowTestDB(t)
+	p := &AdventurePlugin{}
+	user := id.UserID("@passed:test.invalid")
+
+	idx := 1
+	seed := newShadow(user, "Tester")
+	seed.Progress = 5 // well past this zone
+	seed.ZonesCleared = 5
+	seed.PendingMask = 0 // nothing owed here
+	if err := upsertShadow(seed); err != nil {
+		t.Fatal(err)
+	}
+
+	if line := p.shadowOnPlayerZoneClear(user, zoneOrder[idx]); line != "" {
+		t.Errorf("a zone the shadow passed with nothing owed should be silent, got: %q", line)
+	}
+}
+
+func TestShadowZoneClear_SilentBeforeBirth(t *testing.T) {
+	newShadowTestDB(t)
+	p := &AdventurePlugin{}
+	user := id.UserID("@unborn:test.invalid")
+	if line := p.shadowOnPlayerZoneClear(user, zoneOrder[0]); line != "" {
+		t.Errorf("no shadow yet should be silent, got: %q", line)
+	}
+}
+
+func TestShadowBriefingLine_SilentUntilBorn(t *testing.T) {
+	newShadowTestDB(t)
+	p := &AdventurePlugin{}
+	user := id.UserID("@brief:test.invalid")
+	e := &Expedition{UserID: string(user), ZoneID: zoneOrder[0], CurrentDay: 2}
+
+	if line := p.shadowBriefingLine(e); line != "" {
+		t.Errorf("no shadow should mean no briefing line, got: %q", line)
+	}
+
+	seed := newShadow(user, "Tester")
+	seed.ZonesCleared = 2
+	if err := upsertShadow(seed); err != nil {
+		t.Fatal(err)
+	}
+	if line := p.shadowBriefingLine(e); strings.TrimSpace(line) == "" {
+		t.Error("a born shadow should produce a briefing line")
+	}
+}
+
+func TestHandleShadowCmd_DMsStatus(t *testing.T) {
+	newShadowTestDB(t)
+	p := &AdventurePlugin{}
+	sink := installSink(p)
+	user := id.UserID("@cmd:test.invalid")
+
+	// Before birth: a gentle "no one's shadowing you yet".
+	if err := p.handleShadowCmd(MessageContext{Sender: user}); err != nil {
+		t.Fatal(err)
+	}
+	if dms := sink.dmsTo(user); len(dms) != 1 || !strings.Contains(dms[0], "shadowing you yet") {
+		t.Errorf("expected an unborn-shadow DM, got: %v", sink.dmsTo(user))
+	}
+
+	seed := newShadow(user, "Tester")
+	seed.ZonesCleared = 4
+	if err := upsertShadow(seed); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.handleShadowCmd(MessageContext{Sender: user}); err != nil {
+		t.Fatal(err)
+	}
+	dms := sink.dmsTo(user)
+	if len(dms) != 2 || !strings.Contains(dms[1], seed.Name) {
+		t.Errorf("expected a status DM naming the shadow, got: %v", dms)
+	}
+}

internal/plugin/adventure_shop_test.go

@@ -281,17 +281,17 @@ func TestLuigiCategoryIntros_Coverage(t *testing.T) {
 
 func TestLuigiFlavorPools_NonEmpty(t *testing.T) {
 	pools := map[string][]string{
-		"luigiGreetings":        luigiGreetings,
-		"luigiPurchaseConfirm":  luigiPurchaseConfirm,
-		"luigiTier5Confirm":     luigiTier5Confirm,
-		"luigiComboConfirm":     luigiComboConfirm,
+		"luigiGreetings":         luigiGreetings,
+		"luigiPurchaseConfirm":   luigiPurchaseConfirm,
+		"luigiTier5Confirm":      luigiTier5Confirm,
+		"luigiComboConfirm":      luigiComboConfirm,
 		"luigiInsufficientFunds": luigiInsufficientFunds,
-		"luigiBrowseTimeout":    luigiBrowseTimeout,
-		"luigiMaxedOut":         luigiMaxedOut,
-		"luigiMasterworkAck":    luigiMasterworkAck,
-		"luigiShowAllComment":   luigiShowAllComment,
-		"luigiCommentary":       luigiCommentary,
-		"luigiCancellation":     luigiCancellation,
+		"luigiBrowseTimeout":     luigiBrowseTimeout,
+		"luigiMaxedOut":          luigiMaxedOut,
+		"luigiMasterworkAck":     luigiMasterworkAck,
+		"luigiShowAllComment":    luigiShowAllComment,
+		"luigiCommentary":        luigiCommentary,
+		"luigiCancellation":      luigiCancellation,
 	}
 	for name, pool := range pools {
 		if len(pool) == 0 {

internal/plugin/adventure_temper.go

@@ -0,0 +1,410 @@
+package plugin
+
+import (
+	"fmt"
+	"log/slog"
+	"strings"
+	"time"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// ── Tempering ───────────────────────────────────────────────────────────────
+//
+// The blacksmith's endgame role: push an owned magic item one rung up the
+// rarity ladder (gogobee_engagement_plan.md B1). Rarity flows through the
+// existing scalar formulas in magic_items_gameplay.go, so tempering adds no
+// new combat math — and because it caps at Legendary it accelerates reaching
+// the existing best-in-slot ceiling rather than raising it. Every duplicate
+// drop becomes a candidate instead of vendor trash.
+//
+// Rarity itself lives on the registry definition, so a tempered instance
+// records its progress as a `temper` step count on its own row; effective
+// rarity is derived on read (see temperedItem).
+
+// temperMaterialNames are the legendary crafting materials the final rung
+// consumes. Both drop as UniqueAlways entries on their T5 zone slate, so one
+// clear of the Underforge or the Abyss Portal yields exactly one.
+var temperMaterialNames = []string{"Thyraks Core", "Portal Fragment"}
+
+// temperStepCost is what one rung costs, keyed by the *target* rarity's tier.
+// The euro costs and foraging gates mirror the crafting recipe tiers in
+// adventure_consumables.go, so the blacksmith reads as an extension of the
+// crafting ladder rather than a parallel economy.
+type temperStepCost struct {
+	Euros         int
+	MinForaging   int
+	NeedsMaterial bool
+}
+
+// Only the final rung demands a T5 material. Gating the lower rungs on one too
+// would make tempering unreachable until a player already clears T5 content —
+// which is exactly when they stop needing it.
+var temperCosts = map[int]temperStepCost{
+	2: {Euros: 10_000, MinForaging: 15},
+	3: {Euros: 25_000, MinForaging: 20},
+	4: {Euros: 60_000, MinForaging: 25},
+	5: {Euros: 150_000, MinForaging: 30, NeedsMaterial: true},
+}
+
+// temperTarget is one temperable item, from either side of the equip line.
+type temperTarget struct {
+	Equipped bool
+	Slot     DnDSlot // set when Equipped
+	InvID    int64   // set when not Equipped
+	Base     MagicItem
+	Temper   int
+}
+
+// Effective is the item as it stands today, before this temper.
+func (t temperTarget) Effective() MagicItem { return temperedItem(t.Base, t.Temper) }
+
+// NextRarity is the rung this temper would buy.
+func (t temperTarget) NextRarity() DnDRarity { return temperedRarity(t.Base.Rarity, t.Temper+1) }
+
+// cost is the price of this target's next rung.
+func (t temperTarget) cost() temperStepCost { return temperCosts[rarityLootTierNum(t.NextRarity())] }
+
+// sameItemAs reports whether other is the same physical instance, used to
+// re-find a target after a fresh reload so a concurrent equip/sell can't let a
+// stale pending confirm temper the wrong thing.
+func (t temperTarget) sameItemAs(other temperTarget) bool {
+	if t.Equipped != other.Equipped {
+		return false
+	}
+	if t.Equipped {
+		return t.Slot == other.Slot && t.Base.ID == other.Base.ID
+	}
+	return t.InvID == other.InvID
+}
+
+type advPendingTemperPick struct {
+	Targets []temperTarget
+}
+
+type advPendingTemperConfirm struct {
+	Target   temperTarget
+	Material *AdvItem // consumed on confirm; nil when the rung needs none
+}
+
+// collectTemperTargets gathers every magic item the player owns that still has
+// a rung ahead of it — worn or stowed. Potions and scrolls are excluded: they
+// carry a zero combat effect, so a rarity bump would buy nothing.
+func collectTemperTargets(userID id.UserID) ([]temperTarget, error) {
+	var out []temperTarget
+
+	equipped, err := loadEquippedMagicItems(userID)
+	if err != nil {
+		return nil, err
+	}
+	for _, ds := range dndSlotOrder {
+		e, ok := equipped[ds]
+		if !ok || e.Item.ID == "" {
+			continue
+		}
+		if temperStepsToLegendary(e.Item.Rarity, e.Temper) == 0 {
+			continue
+		}
+		out = append(out, temperTarget{Equipped: true, Slot: ds, Base: e.Item, Temper: e.Temper})
+	}
+
+	items, err := loadAdvInventory(userID)
+	if err != nil {
+		return nil, err
+	}
+	for _, it := range items {
+		if it.Type != "magic_item" {
+			continue
+		}
+		mi, ok := magicItemFromAdvItem(it)
+		if !ok || mi.Kind == MagicItemPotion || mi.Kind == MagicItemScroll {
+			continue
+		}
+		if temperStepsToLegendary(mi.Rarity, it.Temper) == 0 {
+			continue
+		}
+		out = append(out, temperTarget{InvID: it.ID, Base: mi, Temper: it.Temper})
+	}
+	return out, nil
+}
+
+// findTemperMaterial returns the first legendary material row in inventory.
+func findTemperMaterial(items []AdvItem) (AdvItem, bool) {
+	for _, it := range items {
+		for _, name := range temperMaterialNames {
+			if it.Name == name {
+				return it, true
+			}
+		}
+	}
+	return AdvItem{}, false
+}
+
+// parseMenuIndex reads a leading 1-indexed number off a menu reply and returns
+// the bounds-checked 0-indexed position. The single parser behind every "reply
+// with a number from the list" prompt — temper, magic-item equip, masterwork
+// equip. Leading whitespace and any trailing text after the digits are ignored;
+// a reply with no leading digit, or one outside [1, n], returns ok=false.
+func parseMenuIndex(reply string, n int) (int, bool) {
+	idx, parsed := 0, false
+	for _, c := range strings.TrimSpace(reply) {
+		if c < '0' || c > '9' {
+			break
+		}
+		idx = idx*10 + int(c-'0')
+		parsed = true
+	}
+	idx--
+	if !parsed || idx < 0 || idx >= n {
+		return 0, false
+	}
+	return idx, true
+}
+
+// ── Command ─────────────────────────────────────────────────────────────────
+
+func (p *AdventurePlugin) handleTemperCmd(ctx MessageContext) error {
+	char, _, err := p.ensureCharacter(ctx.Sender)
+	if err != nil {
+		return p.SendDM(ctx.Sender, "Failed to load your character.")
+	}
+
+	targets, err := collectTemperTargets(ctx.Sender)
+	if err != nil {
+		return p.SendDM(ctx.Sender, "Failed to read your curios.")
+	}
+	if len(targets) == 0 {
+		return p.SendDM(ctx.Sender,
+			"_He looks over your kit and shrugs._ Nothing here I can push any further. "+
+				"Bring me something that isn't already Legendary.")
+	}
+
+	greeting, _ := advPickFlavor(blacksmithTemperGreetings, ctx.Sender, "temper_greet")
+
+	var sb strings.Builder
+	sb.WriteString("🔨 **Tempering**\n\n")
+	sb.WriteString(greeting)
+	sb.WriteString("\n\n")
+	for i, t := range targets {
+		cur := t.Effective()
+		cost := t.cost()
+		where := "stowed"
+		if t.Equipped {
+			where = "worn — " + string(t.Slot)
+		}
+		gate := ""
+		switch {
+		case char.ForagingSkill < cost.MinForaging:
+			gate = fmt.Sprintf(" — 🔒 needs Foraging %d", cost.MinForaging)
+		case cost.NeedsMaterial:
+			gate = " — needs a legendary material"
+		}
+		sb.WriteString(fmt.Sprintf("%d. **%s** _(%s → %s)_ — €%d _(%s)_%s\n",
+			i+1, cur.Name, cur.Rarity, t.NextRarity(), cost.Euros, where, gate))
+	}
+	sb.WriteString("\nReply with a number to temper it, or \"cancel\".")
+
+	p.pending.Store(string(ctx.Sender), &advPendingInteraction{
+		Type:      "temper_pick",
+		Data:      &advPendingTemperPick{Targets: targets},
+		ExpiresAt: time.Now().Add(advDMResponseWindow),
+	})
+	return p.SendDM(ctx.Sender, sb.String())
+}
+
+func (p *AdventurePlugin) resolveTemperPick(ctx MessageContext, interaction *advPendingInteraction) error {
+	data := interaction.Data.(*advPendingTemperPick)
+	reply := strings.TrimSpace(ctx.Body)
+	if strings.EqualFold(reply, "cancel") {
+		return p.SendDM(ctx.Sender, "_The forge keeps burning._ Come back when you've decided.")
+	}
+	idx, ok := parseMenuIndex(reply, len(data.Targets))
+	if !ok {
+		p.pending.Store(string(ctx.Sender), interaction)
+		return p.SendDM(ctx.Sender, "Reply with a number from the list, or \"cancel\".")
+	}
+	return p.buildTemperConfirm(ctx.Sender, data.Targets[idx])
+}
+
+// buildTemperConfirm re-checks every gate against fresh state before quoting a
+// price, then parks a confirm. executeTemper re-checks them all again — this
+// pass exists to give the player a real error message, not to be trusted.
+func (p *AdventurePlugin) buildTemperConfirm(userID id.UserID, t temperTarget) error {
+	char, _, err := p.ensureCharacter(userID)
+	if err != nil {
+		return p.SendDM(userID, "Failed to load your character.")
+	}
+	cost := t.cost()
+	if char.ForagingSkill < cost.MinForaging {
+		return p.SendDM(userID, fmt.Sprintf(
+			"_He turns the piece over, then sets it down._ I could ruin this. Come back when you know your "+
+				"materials better — **Foraging %d**. You're at %d.", cost.MinForaging, char.ForagingSkill))
+	}
+
+	items, err := loadAdvInventory(userID)
+	if err != nil {
+		return p.SendDM(userID, "Failed to read your inventory.")
+	}
+	var material *AdvItem
+	if cost.NeedsMaterial {
+		mat, ok := findTemperMaterial(items)
+		if !ok {
+			return p.SendDM(userID, fmt.Sprintf(
+				"_He exhales through his teeth._ Legendary is a different conversation. I need a **%s** on this "+
+					"table before I touch it. They come out of the deepest places — the Underforge, the Portal.",
+				strings.Join(temperMaterialNames, "** or a **")))
+		}
+		material = &mat
+	}
+
+	if bal := p.euro.GetBalance(userID); bal < float64(cost.Euros) {
+		return p.SendDM(userID, fmt.Sprintf(
+			"_He names the price without apology._ €%d. You have €%.0f. The forge doesn't run on good intentions.",
+			cost.Euros, bal))
+	}
+
+	cur := t.Effective()
+	next := temperedItem(t.Base, t.Temper+1)
+
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("🔨 **Temper %s?**\n\n", cur.Name))
+	sb.WriteString(fmt.Sprintf("  %s _(%s)_ → %s _(%s)_\n", cur.Name, cur.Rarity, next.Name, next.Rarity))
+	sb.WriteString(fmt.Sprintf("  %s\n  ↳ %s\n\n", magicItemEffectSummary(cur), magicItemEffectSummary(next)))
+	sb.WriteString(fmt.Sprintf("  Cost: **€%d**", cost.Euros))
+	if material != nil {
+		sb.WriteString(fmt.Sprintf(" + one **%s**", material.Name))
+	}
+	sb.WriteString("\n\nReply \"yes\" to hand it over, or anything else to keep it as it is.")
+
+	p.pending.Store(string(userID), &advPendingInteraction{
+		Type:      "temper_confirm",
+		Data:      &advPendingTemperConfirm{Target: t, Material: material},
+		ExpiresAt: time.Now().Add(advDMResponseWindow),
+	})
+	return p.SendDM(userID, sb.String())
+}
+
+func (p *AdventurePlugin) resolveTemperConfirm(ctx MessageContext, interaction *advPendingInteraction) error {
+	userMu := p.advUserLock(ctx.Sender)
+	userMu.Lock()
+	defer userMu.Unlock()
+
+	data := interaction.Data.(*advPendingTemperConfirm)
+	reply := strings.ToLower(strings.TrimSpace(ctx.Body))
+	if reply != "yes" && reply != "y" && reply != "confirm" {
+		return p.SendDM(ctx.Sender, "_He nods once and turns back to the fire._ It's a good piece as it is.")
+	}
+	return p.executeTemper(ctx.Sender, data)
+}
+
+// executeTemper re-validates against fresh state, then charges and applies.
+// Order matters: the euro debit is the only atomic guard we have, so it goes
+// first; the material and the temper write both roll back onto it.
+func (p *AdventurePlugin) executeTemper(userID id.UserID, data *advPendingTemperConfirm) error {
+	char, _, err := p.ensureCharacter(userID)
+	if err != nil {
+		return p.SendDM(userID, "Failed to load your character.")
+	}
+
+	// Re-find the target. Between the confirm prompt and this reply the
+	// player may have equipped, sold, or already tempered it.
+	fresh, err := collectTemperTargets(userID)
+	if err != nil {
+		return p.SendDM(userID, "Failed to read your curios.")
+	}
+	var target temperTarget
+	found := false
+	for _, t := range fresh {
+		if t.sameItemAs(data.Target) {
+			target, found = t, true
+			break
+		}
+	}
+	if !found {
+		return p.SendDM(userID, "_He looks at the empty table._ That piece isn't here any more.")
+	}
+	if target.Temper != data.Target.Temper {
+		return p.SendDM(userID, "_He raises an eyebrow._ Someone's already been at this one. Ask me again.")
+	}
+
+	cost := target.cost()
+	if char.ForagingSkill < cost.MinForaging {
+		return p.SendDM(userID, fmt.Sprintf("You need **Foraging %d** for that.", cost.MinForaging))
+	}
+
+	// Re-locate the material by row id — a concurrent craft may have eaten it.
+	var material *AdvItem
+	if cost.NeedsMaterial {
+		items, err := loadAdvInventory(userID)
+		if err != nil {
+			return p.SendDM(userID, "Failed to read your inventory.")
+		}
+		mat, ok := findTemperMaterial(items)
+		if !ok {
+			return p.SendDM(userID, "_He taps the empty spot on the table._ The material's gone. Find another.")
+		}
+		material = &mat
+	}
+
+	if !p.euro.Debit(userID, float64(cost.Euros), "temper") {
+		return p.SendDM(userID, fmt.Sprintf("Payment failed — tempering costs €%d.", cost.Euros))
+	}
+
+	refund := func(reason string) {
+		p.euro.Credit(userID, float64(cost.Euros), "temper_refund")
+		slog.Error("temper: rolled back", "user", userID, "item", target.Base.ID, "reason", reason)
+	}
+
+	if material != nil {
+		if err := removeAdvInventoryItem(material.ID); err != nil {
+			refund("material consume failed")
+			return p.SendDM(userID, "Something went wrong at the forge. Your money is back.")
+		}
+	}
+
+	newTemper := target.Temper + 1
+	if target.Equipped {
+		err = temperEquippedItem(userID, target.Slot, newTemper)
+	} else {
+		bumped := temperedItem(target.Base, newTemper)
+		err = temperInventoryItem(target.InvID, newTemper, rarityLootTierNum(bumped.Rarity), int64(bumped.Value))
+	}
+	if err != nil {
+		refund("temper write failed")
+		if material != nil {
+			if rbErr := addAdvInventoryItem(userID, *material); rbErr != nil {
+				slog.Error("temper: material rollback failed",
+					"user", userID, "material", material.Name, "err", rbErr)
+			}
+		}
+		return p.SendDM(userID, "Something went wrong at the forge. Your money is back.")
+	}
+
+	result := temperedItem(target.Base, newTemper)
+	line, _ := advPickFlavor(blacksmithTemperCompletion, userID, "temper_done")
+
+	var sb strings.Builder
+	sb.WriteString(line)
+	sb.WriteString(fmt.Sprintf("\n\n🔨 **%s** is now **%s**.\n%s\n",
+		result.Name, result.Rarity, magicItemEffectSummary(result)))
+	if remaining := temperStepsToLegendary(target.Base.Rarity, newTemper); remaining > 0 {
+		sb.WriteString(fmt.Sprintf("\n_%d more temper%s would make it Legendary._",
+			remaining, pluralS(remaining)))
+	}
+	if err := p.SendDM(userID, sb.String()); err != nil {
+		return err
+	}
+
+	if result.Rarity == RarityLegendary {
+		if p.achievements != nil {
+			p.achievements.GrantAchievement(userID, "temper_legendary")
+		}
+		if gr := gamesRoom(); gr != "" {
+			displayName, _ := loadDisplayName(userID)
+			p.SendMessage(id.RoomID(gr), fmt.Sprintf(
+				"🔨 The forge in town ran hot all night. **%s** walked out with a **Legendary %s**.",
+				displayName, result.Name))
+		}
+	}
+	return nil
+}

internal/plugin/adventure_temper_test.go

@@ -0,0 +1,355 @@
+package plugin
+
+import (
+	"testing"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// TestTemperLadderWalk pins the rung order and the Legendary clamp. VeryRare
+// must fold onto Epic — it shares Epic's tier and power scalar, so treating it
+// as its own rung would sell a step that changes no number.
+func TestTemperLadderWalk(t *testing.T) {
+	tests := []struct {
+		base  DnDRarity
+		steps int
+		want  DnDRarity
+	}{
+		{RarityCommon, 0, RarityCommon},
+		{RarityCommon, 1, RarityUncommon},
+		{RarityCommon, 4, RarityLegendary},
+		{RarityCommon, 99, RarityLegendary}, // clamp, never past the ceiling
+		{RarityRare, 1, RarityEpic},
+		{RarityEpic, 1, RarityLegendary},
+		{RarityLegendary, 1, RarityLegendary},
+		{RarityVeryRare, 0, RarityVeryRare}, // untempered items keep their label
+		{RarityVeryRare, 1, RarityLegendary},
+		{RarityUncommon, -1, RarityUncommon}, // negative steps are inert
+	}
+	for _, tc := range tests {
+		if got := temperedRarity(tc.base, tc.steps); got != tc.want {
+			t.Errorf("temperedRarity(%s, %d) = %s, want %s", tc.base, tc.steps, got, tc.want)
+		}
+	}
+}
+
+func TestTemperStepsToLegendary(t *testing.T) {
+	tests := []struct {
+		base  DnDRarity
+		steps int
+		want  int
+	}{
+		{RarityCommon, 0, 4},
+		{RarityCommon, 2, 2},
+		{RarityCommon, 4, 0},
+		{RarityCommon, 10, 0},
+		{RarityVeryRare, 0, 1}, // folds onto Epic, one rung short
+		{RarityLegendary, 0, 0},
+	}
+	for _, tc := range tests {
+		if got := temperStepsToLegendary(tc.base, tc.steps); got != tc.want {
+			t.Errorf("temperStepsToLegendary(%s, %d) = %d, want %d", tc.base, tc.steps, got, tc.want)
+		}
+	}
+}
+
+// TestTemperCostsCoverEveryRung guards against a ladder edit that leaves a rung
+// priced at the zero value — a free temper.
+func TestTemperCostsCoverEveryRung(t *testing.T) {
+	for rung := 1; rung < len(temperLadder); rung++ {
+		target := temperLadder[rung]
+		cost, ok := temperCosts[rarityLootTierNum(target)]
+		if !ok {
+			t.Fatalf("no temper cost for target rarity %s", target)
+		}
+		if cost.Euros <= 0 || cost.MinForaging <= 0 {
+			t.Errorf("temper to %s is free: %+v", target, cost)
+		}
+	}
+	// Only the Legendary rung consumes a material.
+	for tier, cost := range temperCosts {
+		if want := tier == 5; cost.NeedsMaterial != want {
+			t.Errorf("tier %d NeedsMaterial = %v, want %v", tier, cost.NeedsMaterial, want)
+		}
+	}
+}
+
+// TestTemperedItemScalesPowerAndValue asserts a tempered item is exactly an
+// item of its effective rarity — the whole point of B1 is that rarity flows
+// through the existing scalar formulas with no new combat math.
+func TestTemperedItemScalesPowerAndValue(t *testing.T) {
+	base := MagicItem{ID: "x", Name: "Thing", Kind: MagicItemWeapon, Rarity: RarityRare, Value: 300}
+
+	if got := temperedItem(base, 0); got != base {
+		t.Errorf("temper 0 mutated the item: %+v", got)
+	}
+
+	up := temperedItem(base, 1)
+	if up.Rarity != RarityEpic {
+		t.Fatalf("rarity = %s, want Epic", up.Rarity)
+	}
+	// Value tracks the power axis: Rare=3 → Epic=4.
+	if wantVal := int(300 * (rarityPowerScalar(RarityEpic) / rarityPowerScalar(RarityRare))); up.Value != wantVal {
+		t.Errorf("value = %d, want %d", up.Value, wantVal)
+	}
+	// A tempered Epic must fight exactly like a native Epic. (Its Value is
+	// deliberately higher than a native Epic definition's — value tracks the
+	// power axis, and the player paid to move it there.)
+	native := base
+	native.Rarity = RarityEpic
+	if magicItemEffectFor(up) != magicItemEffectFor(native) {
+		t.Errorf("tempered effect diverges from native Epic effect")
+	}
+	// Base must be untouched — temperedItem takes a copy.
+	if base.Rarity != RarityRare || base.Value != 300 {
+		t.Errorf("temperedItem mutated its argument: %+v", base)
+	}
+}
+
+// TestTemperNeverDoubleBumps is the invariant the whole design hangs on: the
+// stored row keeps BASE rarity plus a step count, so loading and re-saving an
+// item any number of times must not compound the upgrade.
+func TestTemperNeverDoubleBumps(t *testing.T) {
+	base := MagicItem{ID: "x", Name: "Thing", Kind: MagicItemWeapon, Rarity: RarityCommon, Value: 100}
+	e := EquippedMagicItem{Item: base, Temper: 2}
+
+	first := e.Effective()
+	// Simulate a load→save→load cycle: Item stays base, Temper stays put.
+	again := EquippedMagicItem{Item: e.Item, Temper: e.Temper}.Effective()
+	if first != again {
+		t.Errorf("round-trip changed the item: %+v vs %+v", first, again)
+	}
+	if e.Item.Rarity != RarityCommon {
+		t.Errorf("Effective() mutated the stored base rarity to %s", e.Item.Rarity)
+	}
+	if first.Rarity != RarityRare {
+		t.Errorf("Common + 2 tempers = %s, want Rare", first.Rarity)
+	}
+}
+
+// TestTemperSurvivesEquipRoundTrip: a tempered item that gets swapped back to
+// inventory must carry its temper with it, priced at its effective rarity.
+// This is the path resolveMagicEquipReply takes on a slot swap.
+func TestTemperSurvivesEquipRoundTrip(t *testing.T) {
+	base := MagicItem{ID: "x", Name: "Thing", Kind: MagicItemWeapon, Rarity: RarityCommon, Value: 100}
+
+	back := magicItemSellAt(base, 3)
+	if back.Temper != 3 {
+		t.Errorf("swap-back lost temper: %d", back.Temper)
+	}
+	if back.Tier != rarityLootTierNum(RarityEpic) {
+		t.Errorf("swap-back tier = %d, want Epic tier", back.Tier)
+	}
+	if back.Value <= int64(base.Value) {
+		t.Errorf("swap-back value %d not scaled up from %d", back.Value, base.Value)
+	}
+	// An untempered sell must be byte-identical to the old behaviour.
+	if magicItemSellAt(base, 0) != magicItemSell(base) {
+		t.Errorf("magicItemSellAt(_, 0) diverges from magicItemSell")
+	}
+}
+
+// TestTemperPersistence exercises the two DB writes: an equipped item's temper
+// and a stowed item's temper both survive a reload, and loadEquippedMagicItems
+// hands back a base-rarity Item with the step count beside it.
+func TestTemperPersistence(t *testing.T) {
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+
+	user := id.UserID("@temper:test.invalid")
+
+	var item MagicItem
+	for _, mi := range magicItemRegistry {
+		if mi.Slot != "" && mi.Rarity == RarityCommon {
+			item = mi
+			break
+		}
+	}
+	if item.ID == "" {
+		for _, mi := range magicItemRegistry {
+			if mi.Slot != "" && temperStepsToLegendary(mi.Rarity, 0) > 0 {
+				item = mi
+				break
+			}
+		}
+	}
+	if item.ID == "" {
+		t.Skip("no slotted sub-Legendary item in registry")
+	}
+
+	if err := equipMagicItem(user, item.Slot, item.ID, false, 0); err != nil {
+		t.Fatal(err)
+	}
+	if err := temperEquippedItem(user, item.Slot, 1); err != nil {
+		t.Fatal(err)
+	}
+	equipped, err := loadEquippedMagicItems(user)
+	if err != nil {
+		t.Fatal(err)
+	}
+	e := equipped[item.Slot]
+	if e.Temper != 1 {
+		t.Fatalf("equipped temper = %d, want 1", e.Temper)
+	}
+	if e.Item.Rarity != item.Rarity {
+		t.Errorf("stored Item.Rarity = %s, want the untouched base %s", e.Item.Rarity, item.Rarity)
+	}
+	if want := temperedRarity(item.Rarity, 1); e.Effective().Rarity != want {
+		t.Errorf("Effective().Rarity = %s, want %s", e.Effective().Rarity, want)
+	}
+
+	// Stowed side: a fresh inventory row defaults to temper 0, then bumps.
+	inv := AdvItem{Name: item.Name, Type: "magic_item", Tier: 1, Value: 100,
+		SkillSource: "magic_item:" + item.ID}
+	if err := addAdvInventoryItem(user, inv); err != nil {
+		t.Fatal(err)
+	}
+	items, err := loadAdvInventory(user)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(items) != 1 || items[0].Temper != 0 {
+		t.Fatalf("fresh inventory row should default to temper 0, got %+v", items)
+	}
+	bumped := temperedItem(item, 2)
+	if err := temperInventoryItem(items[0].ID, 2, rarityLootTierNum(bumped.Rarity), int64(bumped.Value)); err != nil {
+		t.Fatal(err)
+	}
+	items, _ = loadAdvInventory(user)
+	if items[0].Temper != 2 {
+		t.Errorf("inventory temper = %d, want 2", items[0].Temper)
+	}
+	if items[0].Tier != rarityLootTierNum(bumped.Rarity) {
+		t.Errorf("inventory tier = %d, want %d", items[0].Tier, rarityLootTierNum(bumped.Rarity))
+	}
+}
+
+// TestCollectTemperTargetsFiltering: Legendary items and consumable-kind magic
+// items (potions/scrolls, whose combat effect is zero) are not offerable.
+func TestCollectTemperTargetsFiltering(t *testing.T) {
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+
+	user := id.UserID("@filter:test.invalid")
+
+	var legendary, potion, upgradable MagicItem
+	for _, mi := range magicItemRegistry {
+		if legendary.ID == "" && mi.Rarity == RarityLegendary && mi.Slot != "" {
+			legendary = mi
+		}
+		if potion.ID == "" && (mi.Kind == MagicItemPotion || mi.Kind == MagicItemScroll) {
+			potion = mi
+		}
+		if upgradable.ID == "" && mi.Slot != "" && mi.Kind == MagicItemWeapon &&
+			temperStepsToLegendary(mi.Rarity, 0) > 0 {
+			upgradable = mi
+		}
+	}
+
+	add := func(mi MagicItem) {
+		if mi.ID == "" {
+			return
+		}
+		if err := addAdvInventoryItem(user, AdvItem{
+			Name: mi.Name, Type: "magic_item", Tier: rarityLootTierNum(mi.Rarity),
+			Value: int64(mi.Value), SkillSource: "magic_item:" + mi.ID,
+		}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	add(legendary)
+	add(potion)
+	add(upgradable)
+
+	targets, err := collectTemperTargets(user)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, tg := range targets {
+		if legendary.ID != "" && tg.Base.ID == legendary.ID {
+			t.Errorf("Legendary %s offered for tempering", legendary.Name)
+		}
+		if potion.ID != "" && tg.Base.ID == potion.ID {
+			t.Errorf("consumable %s offered for tempering", potion.Name)
+		}
+	}
+	if upgradable.ID != "" {
+		found := false
+		for _, tg := range targets {
+			if tg.Base.ID == upgradable.ID {
+				found = true
+			}
+		}
+		if !found {
+			t.Errorf("upgradable %s (%s) was not offered", upgradable.Name, upgradable.Rarity)
+		}
+	}
+}
+
+// TestTemperMaterialsAreObtainable guards the economy: every material name the
+// final rung demands must actually drop from some zone's loot slate. If a slate
+// is renamed, tempering to Legendary silently becomes impossible.
+func TestTemperMaterialsAreObtainable(t *testing.T) {
+	live := map[string]bool{}
+	for _, zone := range allZones() {
+		for _, entry := range zone.Loot {
+			live[titleCaseUnderscored(entry.ItemID)] = true
+		}
+	}
+	for _, name := range temperMaterialNames {
+		if !live[name] {
+			t.Errorf("temper material %q drops from no zone loot slate", name)
+		}
+	}
+}
+
+// TestFindTemperMaterial picks the first material regardless of which one.
+func TestFindTemperMaterial(t *testing.T) {
+	if _, ok := findTemperMaterial(nil); ok {
+		t.Error("found a material in an empty inventory")
+	}
+	if _, ok := findTemperMaterial([]AdvItem{{Name: "Iron Ore"}}); ok {
+		t.Error("Iron Ore accepted as a legendary material")
+	}
+	for _, name := range temperMaterialNames {
+		got, ok := findTemperMaterial([]AdvItem{{Name: "Iron Ore"}, {ID: 7, Name: name}})
+		if !ok || got.ID != 7 {
+			t.Errorf("did not find material %q", name)
+		}
+	}
+}
+
+func TestParseTemperIndex(t *testing.T) {
+	tests := []struct {
+		in     string
+		n      int
+		want   int
+		wantOK bool
+	}{
+		{"1", 3, 0, true},
+		{"3", 3, 2, true},
+		{" 2 ", 3, 1, true},
+		{"2. Thing", 3, 1, true},
+		{"0", 3, 0, false},
+		{"4", 3, 0, false},
+		{"", 3, 0, false},
+		{"cancel", 3, 0, false},
+	}
+	for _, tc := range tests {
+		got, ok := parseMenuIndex(tc.in, tc.n)
+		if ok != tc.wantOK || (ok && got != tc.want) {
+			t.Errorf("parseMenuIndex(%q, %d) = (%d, %v), want (%d, %v)",
+				tc.in, tc.n, got, ok, tc.want, tc.wantOK)
+		}
+	}
+}

internal/plugin/adventure_test.go

@@ -231,13 +231,13 @@ func TestCalculateAdvProbabilities_BetterGearReducesDeath(t *testing.T) {
 
 func TestAdvEffectiveSkill(t *testing.T) {
 	char := &AdventureCharacter{
-		CombatLevel:  10,
-		MiningSkill:  15,
+		CombatLevel:   10,
+		MiningSkill:   15,
 		ForagingSkill: 20,
 	}
 	bonuses := &AdvBonusSummary{
-		CombatBonus:  5,
-		MiningBonus:  3,
+		CombatBonus:   5,
+		MiningBonus:   3,
 		ForagingBonus: 0,
 	}
 

internal/plugin/adventure_town.go

@@ -0,0 +1,487 @@
+package plugin
+
+import (
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"gogobee/internal/db"
+)
+
+// E3 — Surfacing the buried social data. Three read-only registries that
+// render data the game already stores: !town (civic pride + housing + pets),
+// !graveyard (recent deaths), and !rivals board (room-wide duel standings).
+//
+// Leak-check (gogobee_engagement_plan.md §E3): the civic-pride board ranks
+// tax_ledger.total_paid, which is dominated by gambling/shop/arena rake and
+// carries ZERO Misty/Arina donation signal — those debits never touch
+// tax_ledger (adventure_npcs.go routes them through euro.Debit with their own
+// reason strings, counters live in player_meta.misty_*/arina_* columns). So no
+// board here can let a player correlate donations with the hidden NPC buffs.
+
+const (
+	// townCivicBoardLimit caps the civic-pride board.
+	townCivicBoardLimit = 10
+	// townListCap caps the housing/pet showcase lists.
+	townListCap = 15
+	// graveyardLimit caps the graveyard.
+	graveyardLimit = 12
+	// rivalsBoardLimit caps the room-wide rivalry standings.
+	rivalsBoardLimit = 10
+)
+
+// ── Civic pride ──────────────────────────────────────────────────────────────
+
+type civicEntry struct {
+	Name      string
+	TotalPaid int64
+}
+
+// loadCivicPrideBoard returns the top contributors to the community pot by
+// lifetime tax paid. Safe to rank — see the leak-check note above.
+func loadCivicPrideBoard(limit int) ([]civicEntry, error) {
+	rows, err := db.Get().Query(
+		`SELECT COALESCE(NULLIF(c.display_name, ''), t.user_id), t.total_paid
+		   FROM tax_ledger t
+		   LEFT JOIN player_meta c ON c.user_id = t.user_id
+		  WHERE t.total_paid > 0
+		  ORDER BY t.total_paid DESC
+		  LIMIT ?`, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []civicEntry
+	for rows.Next() {
+		var e civicEntry
+		if err := rows.Scan(&e.Name, &e.TotalPaid); err != nil {
+			return nil, err
+		}
+		out = append(out, e)
+	}
+	return out, rows.Err()
+}
+
+// ── Housing street ───────────────────────────────────────────────────────────
+
+type housingEntry struct {
+	Name string
+	Tier int
+}
+
+// loadHousingStreet returns everyone who owns a house, best homes first.
+func loadHousingStreet(limit int) ([]housingEntry, error) {
+	rows, err := db.Get().Query(
+		`SELECT COALESCE(NULLIF(display_name, ''), user_id), house_tier
+		   FROM player_meta
+		  WHERE house_tier > 0
+		  ORDER BY house_tier DESC, display_name
+		  LIMIT ?`, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []housingEntry
+	for rows.Next() {
+		var e housingEntry
+		if err := rows.Scan(&e.Name, &e.Tier); err != nil {
+			return nil, err
+		}
+		out = append(out, e)
+	}
+	return out, rows.Err()
+}
+
+// ── Pet showcase ─────────────────────────────────────────────────────────────
+
+type petShowcaseEntry struct {
+	Name      string
+	Type      string
+	Level     int
+	ArmorName string
+}
+
+// loadPetShowcase returns every active pet — both slots — across all players,
+// highest level first. The arrived/chased flags live in the *_flags_json
+// columns, so they're decoded in Go rather than in SQL.
+func loadPetShowcase(limit int) ([]petShowcaseEntry, error) {
+	rows, err := db.Get().Query(
+		`SELECT COALESCE(NULLIF(display_name, ''), user_id),
+		        pet_name, pet_type, pet_level, pet_armor_tier, pet_flags_json,
+		        pet2_name, pet2_type, pet2_level, pet2_armor_tier, pet2_flags_json
+		   FROM player_meta
+		  WHERE pet_type != '' OR pet2_type != ''`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []petShowcaseEntry
+	for rows.Next() {
+		var (
+			owner                         string
+			petName, petType, flagsRaw    string
+			level, armorTier              int
+			pet2Name, pet2Type, flags2Raw string
+			pet2Level, pet2Armor          int
+		)
+		if err := rows.Scan(&owner, &petName, &petType, &level, &armorTier, &flagsRaw,
+			&pet2Name, &pet2Type, &pet2Level, &pet2Armor, &flags2Raw); err != nil {
+			return nil, err
+		}
+		if e, ok := showcaseEntryFor(owner, petName, petType, level, armorTier, flagsRaw); ok {
+			out = append(out, e)
+		}
+		if e, ok := showcaseEntryFor(owner, pet2Name, pet2Type, pet2Level, pet2Armor, flags2Raw); ok {
+			out = append(out, e)
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	sort.SliceStable(out, func(i, j int) bool {
+		if out[i].Level != out[j].Level {
+			return out[i].Level > out[j].Level
+		}
+		return out[i].Name < out[j].Name
+	})
+	if len(out) > limit {
+		out = out[:limit]
+	}
+	return out, nil
+}
+
+// showcaseEntryFor builds a showcase entry for one pet slot, returning ok=false
+// if the slot is empty or its pet was chased away.
+func showcaseEntryFor(owner, petName, petType string, level, armorTier int, flagsRaw string) (petShowcaseEntry, bool) {
+	if petType == "" {
+		return petShowcaseEntry{}, false
+	}
+	var flags petFlagsJSON
+	if flagsRaw != "" {
+		_ = json.Unmarshal([]byte(flagsRaw), &flags)
+	}
+	if !flags.Arrived || flags.ChasedAway {
+		return petShowcaseEntry{}, false
+	}
+	return petShowcaseEntry{
+		Name:      firstNonEmpty(petName, "an unnamed companion") + " (" + owner + ")",
+		Type:      petType,
+		Level:     level,
+		ArmorName: petArmorName(petType, armorTier),
+	}, true
+}
+
+// petArmorName maps a pet's armor tier to its barding name, or "" for none.
+func petArmorName(petType string, tier int) string {
+	if tier <= 0 {
+		return ""
+	}
+	for _, a := range petArmorDefs(petType) {
+		if a.Tier == tier {
+			return a.Name
+		}
+	}
+	return ""
+}
+
+// ── Graveyard ────────────────────────────────────────────────────────────────
+
+type graveEntry struct {
+	Name          string
+	Source        string // "adventure" | "arena" | ""
+	Location      string
+	LastDeathDate string // "2006-01-02"
+	StillDown     bool   // alive == 0 (inside the 6h respawn window)
+}
+
+// loadGraveyard returns the most recent deaths across all players. Deaths are
+// day-granularity (last_death_date), so ordering falls back to dead_until for
+// the still-in-the-ground; a revived player keeps their last_death_date but
+// clears dead_until.
+func loadGraveyard(limit int) ([]graveEntry, error) {
+	rows, err := db.Get().Query(
+		`SELECT COALESCE(NULLIF(display_name, ''), user_id),
+		        alive, death_source, death_location, last_death_date, dead_until
+		   FROM player_meta
+		  WHERE last_death_date != ''
+		  ORDER BY last_death_date DESC, dead_until DESC
+		  LIMIT ?`, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []graveEntry
+	for rows.Next() {
+		var (
+			e         graveEntry
+			aliveInt  int
+			deadUntil sql.NullTime
+		)
+		if err := rows.Scan(&e.Name, &aliveInt, &e.Source, &e.Location, &e.LastDeathDate, &deadUntil); err != nil {
+			return nil, err
+		}
+		e.StillDown = aliveInt == 0
+		out = append(out, e)
+	}
+	return out, rows.Err()
+}
+
+// ── Rivals board ─────────────────────────────────────────────────────────────
+
+type rivalBoardEntry struct {
+	Name       string
+	Wins       int
+	Losses     int
+	LastDuelAt *time.Time
+}
+
+// loadRivalsBoard aggregates adventure_rival_records into room-wide standings.
+// The table is a directed per-pair ledger written from both duellists' sides,
+// so summing a user_id's rows gives that player's total record.
+func loadRivalsBoard(limit int) ([]rivalBoardEntry, error) {
+	rows, err := db.Get().Query(
+		`SELECT COALESCE(NULLIF(c.display_name, ''), r.user_id),
+		        SUM(r.wins), SUM(r.losses), MAX(r.last_duel_at)
+		   FROM adventure_rival_records r
+		   LEFT JOIN player_meta c ON c.user_id = r.user_id
+		  GROUP BY r.user_id
+		  ORDER BY SUM(r.wins) DESC, SUM(r.losses) ASC
+		  LIMIT ?`, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []rivalBoardEntry
+	for rows.Next() {
+		var (
+			e        rivalBoardEntry
+			lastDuel sql.NullString
+		)
+		if err := rows.Scan(&e.Name, &e.Wins, &e.Losses, &lastDuel); err != nil {
+			return nil, err
+		}
+		// MAX() over a DATETIME column loses SQLite's type affinity and comes
+		// back as text, so parse it by hand rather than scanning a NullTime.
+		if lastDuel.Valid {
+			if t, ok := parseSQLiteTime(lastDuel.String); ok {
+				e.LastDuelAt = &t
+			}
+		}
+		out = append(out, e)
+	}
+	return out, rows.Err()
+}
+
+// ── Rendering (client-free, unit-testable) ───────────────────────────────────
+
+func renderTownRegistry(civic []civicEntry, houses []housingEntry, pets []petShowcaseEntry) string {
+	var sb strings.Builder
+	sb.WriteString("🏛️ **The Town Registry**\n\n")
+
+	sb.WriteString("**Civic Pride** — the guild's most generous coffers-fillers\n")
+	if len(civic) == 0 {
+		sb.WriteString("  _The collection plate is empty. Tragic._\n")
+	} else {
+		for i, e := range civic {
+			sb.WriteString(fmt.Sprintf("  %2d. %-18s %s\n", i+1, truncName(e.Name, 18), fmtEuro(e.TotalPaid)))
+		}
+	}
+	sb.WriteString("\n")
+
+	sb.WriteString("**Housing Street** — who's put down roots\n")
+	if len(houses) == 0 {
+		sb.WriteString("  _Not a single deed on file. A town of drifters._\n")
+	} else {
+		for _, e := range houses {
+			tierName := "a house"
+			if def := houseTierByTier(e.Tier); def != nil {
+				tierName = def.Name
+			}
+			sb.WriteString(fmt.Sprintf("  %-18s  %s\n", truncName(e.Name, 18), tierName))
+		}
+	}
+	sb.WriteString("\n")
+
+	sb.WriteString("**Pet Showcase** — the good companions\n")
+	if len(pets) == 0 {
+		sb.WriteString("  _No pets in town. Somebody adopt something._\n")
+	} else {
+		for _, e := range pets {
+			line := fmt.Sprintf("  %-30s  L%d %s", truncName(e.Name, 30), e.Level, e.Type)
+			if e.ArmorName != "" {
+				line += " · " + e.ArmorName
+			}
+			sb.WriteString(line + "\n")
+		}
+	}
+
+	return strings.TrimRight(sb.String(), "\n")
+}
+
+func renderGraveyard(deaths []graveEntry, now time.Time) string {
+	var sb strings.Builder
+	sb.WriteString("⚰️ **St. Guildmore's Memorial Garden**\n")
+	sb.WriteString("_The groundskeeper tips his hat. \"They gave their all. Well — they gave enough.\"_\n\n")
+
+	if len(deaths) == 0 {
+		sb.WriteString("_Nobody's died lately. The garden's quiet. Enjoy it while it lasts._")
+		return sb.String()
+	}
+
+	for _, e := range deaths {
+		place := e.Location
+		if place == "" {
+			place = "parts unknown"
+		}
+		verb := "fell"
+		if e.Source == "arena" {
+			verb = "fell in the arena"
+		}
+		when := humanizeDeathDate(e.LastDeathDate, now)
+		line := fmt.Sprintf("  ⚰️ **%s** — %s at %s (%s)", truncName(e.Name, 24), verb, place, when)
+		if e.StillDown {
+			line += " · _still resting_"
+		} else {
+			line += " · _back on their feet_"
+		}
+		sb.WriteString(line + "\n")
+	}
+
+	return strings.TrimRight(sb.String(), "\n")
+}
+
+func renderRivalsBoard(board []rivalBoardEntry, now time.Time) string {
+	var sb strings.Builder
+	sb.WriteString("⚔️ **Rivalry Standings** — duels across the guild\n\n")
+
+	if len(board) == 0 {
+		sb.WriteString("_No duels on record. A suspiciously peaceful town._")
+		return sb.String()
+	}
+
+	for i, e := range board {
+		last := "—"
+		if e.LastDuelAt != nil {
+			last = humanizeDaysAgo(*e.LastDuelAt, now)
+		}
+		sb.WriteString(fmt.Sprintf("  %2d. %-18s %dW - %dL   last duel: %s\n",
+			i+1, truncName(e.Name, 18), e.Wins, e.Losses, last))
+	}
+
+	return strings.TrimRight(sb.String(), "\n")
+}
+
+// ── Small render helpers ─────────────────────────────────────────────────────
+
+func truncName(s string, max int) string {
+	r := []rune(s)
+	if len(r) <= max {
+		return s
+	}
+	if max <= 1 {
+		return string(r[:max])
+	}
+	return string(r[:max-1]) + "…"
+}
+
+func firstNonEmpty(s, fallback string) string {
+	if strings.TrimSpace(s) == "" {
+		return fallback
+	}
+	return s
+}
+
+// parseSQLiteTime parses a SQLite CURRENT_TIMESTAMP string ("2006-01-02
+// 15:04:05", UTC), tolerating an RFC3339 variant. Aggregates like MAX() strip
+// the column's type affinity so the driver hands back text.
+func parseSQLiteTime(s string) (time.Time, bool) {
+	for _, layout := range []string{"2006-01-02 15:04:05", time.RFC3339} {
+		if t, err := time.Parse(layout, s); err == nil {
+			return t.UTC(), true
+		}
+	}
+	return time.Time{}, false
+}
+
+// humanizeDaysAgo renders a duel/event time as "today" / "1 day ago" / "N days
+// ago", matching the inline style in handleRivalsCmd.
+func humanizeDaysAgo(t, now time.Time) string {
+	days := int(now.Sub(t).Hours() / 24)
+	switch {
+	case days <= 0:
+		return "today"
+	case days == 1:
+		return "1 day ago"
+	default:
+		return fmt.Sprintf("%d days ago", days)
+	}
+}
+
+// humanizeDeathDate renders a "2006-01-02" death date relative to now. Falls
+// back to the raw string if it doesn't parse.
+func humanizeDeathDate(dateStr string, now time.Time) string {
+	t, err := time.Parse("2006-01-02", dateStr)
+	if err != nil {
+		if dateStr == "" {
+			return "some time ago"
+		}
+		return dateStr
+	}
+	days := int(now.UTC().Truncate(24*time.Hour).Sub(t).Hours() / 24)
+	switch {
+	case days <= 0:
+		return "today"
+	case days == 1:
+		return "yesterday"
+	default:
+		return fmt.Sprintf("%d days ago", days)
+	}
+}
+
+// ── Handlers ─────────────────────────────────────────────────────────────────
+
+func (p *AdventurePlugin) handleTownCmd(ctx MessageContext) error {
+	civic, err := loadCivicPrideBoard(townCivicBoardLimit)
+	if err != nil {
+		return err
+	}
+	houses, err := loadHousingStreet(townListCap)
+	if err != nil {
+		return err
+	}
+	pets, err := loadPetShowcase(townListCap)
+	if err != nil {
+		return err
+	}
+	return p.SendReply(ctx.RoomID, ctx.EventID, renderTownRegistry(civic, houses, pets))
+}
+
+func (p *AdventurePlugin) handleGraveyardCmd(ctx MessageContext) error {
+	deaths, err := loadGraveyard(graveyardLimit)
+	if err != nil {
+		return err
+	}
+	return p.SendReply(ctx.RoomID, ctx.EventID, renderGraveyard(deaths, time.Now().UTC()))
+}
+
+// handleRivalsTopCmd routes the top-level !rivals command: "!rivals board" is
+// the room-wide standings; anything else defers to the per-user record view.
+func (p *AdventurePlugin) handleRivalsTopCmd(ctx MessageContext, args string) error {
+	if strings.EqualFold(strings.TrimSpace(args), "board") {
+		board, err := loadRivalsBoard(rivalsBoardLimit)
+		if err != nil {
+			return err
+		}
+		return p.SendReply(ctx.RoomID, ctx.EventID, renderRivalsBoard(board, time.Now().UTC()))
+	}
+	return p.handleRivalsCmd(ctx)
+}

internal/plugin/adventure_town_test.go

@@ -0,0 +1,234 @@
+package plugin
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+func townTestDB(t *testing.T) {
+	t.Helper()
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+}
+
+// TestTownLoaders_ExerciseRealSchema seeds each source table and runs every
+// loader against a real DB, catching column typos / GROUP BY errors that the
+// pure render tests can't.
+func TestTownLoaders_ExerciseRealSchema(t *testing.T) {
+	townTestDB(t)
+
+	alice := id.UserID("@alice:test.invalid")
+	bob := id.UserID("@bob:test.invalid")
+
+	if err := upsertPlayerMetaDisplayName(alice, "Alice"); err != nil {
+		t.Fatal(err)
+	}
+	if err := upsertPlayerMetaDisplayName(bob, "Bob"); err != nil {
+		t.Fatal(err)
+	}
+
+	// Civic pride.
+	trackTaxPaid(alice, 5000)
+	trackTaxPaid(bob, 100)
+	civic, err := loadCivicPrideBoard(townCivicBoardLimit)
+	if err != nil {
+		t.Fatalf("loadCivicPrideBoard: %v", err)
+	}
+	if len(civic) != 2 || civic[0].Name != "Alice" || civic[0].TotalPaid != 5000 {
+		t.Fatalf("civic board wrong: %+v", civic)
+	}
+
+	// Housing street.
+	if err := upsertPlayerMetaHouseState(alice, HouseState{Tier: 4}); err != nil {
+		t.Fatal(err)
+	}
+	if err := upsertPlayerMetaHouseState(bob, HouseState{Tier: 1}); err != nil {
+		t.Fatal(err)
+	}
+	houses, err := loadHousingStreet(townListCap)
+	if err != nil {
+		t.Fatalf("loadHousingStreet: %v", err)
+	}
+	if len(houses) != 2 || houses[0].Tier != 4 {
+		t.Fatalf("housing street wrong: %+v", houses)
+	}
+
+	// Pet showcase — only arrived, non-chased pets appear.
+	if err := upsertPlayerMetaPetState(alice, PetState{Type: "dog", Name: "Rex", Level: 5, ArmorTier: 2, Arrived: true}); err != nil {
+		t.Fatal(err)
+	}
+	if err := upsertPlayerMetaPetState(bob, PetState{Type: "cat", Name: "Ghost", Level: 3, Arrived: true, ChasedAway: true}); err != nil {
+		t.Fatal(err)
+	}
+	pets, err := loadPetShowcase(townListCap)
+	if err != nil {
+		t.Fatalf("loadPetShowcase: %v", err)
+	}
+	if len(pets) != 1 || !strings.Contains(pets[0].Name, "Rex") || pets[0].ArmorName != "Chain Dog Barding" {
+		t.Fatalf("pet showcase wrong (chased-away pet should be hidden): %+v", pets)
+	}
+
+	// Graveyard.
+	deadUntil := time.Now().Add(6 * time.Hour).UTC()
+	if err := upsertPlayerMetaDeathState(alice, DeathState{
+		Alive: false, DeadUntil: &deadUntil, LastDeathDate: "2026-07-10",
+		DeathSource: "arena", DeathLocation: "the Colosseum",
+	}); err != nil {
+		t.Fatal(err)
+	}
+	graves, err := loadGraveyard(graveyardLimit)
+	if err != nil {
+		t.Fatalf("loadGraveyard: %v", err)
+	}
+	if len(graves) != 1 || graves[0].Name != "Alice" || !graves[0].StillDown || graves[0].Source != "arena" {
+		t.Fatalf("graveyard wrong: %+v", graves)
+	}
+
+	// Rivals board — directed pair ledger summed per user.
+	upsertRivalRecord(alice, bob, true)
+	upsertRivalRecord(alice, bob, true)
+	upsertRivalRecord(bob, alice, false)
+	board, err := loadRivalsBoard(rivalsBoardLimit)
+	if err != nil {
+		t.Fatalf("loadRivalsBoard: %v", err)
+	}
+	if len(board) != 2 || board[0].Name != "Alice" || board[0].Wins != 2 {
+		t.Fatalf("rivals board wrong: %+v", board)
+	}
+}
+
+func TestRenderTownRegistry_AllThreeBoards(t *testing.T) {
+	civic := []civicEntry{{Name: "Alice", TotalPaid: 1234567}, {Name: "Bob", TotalPaid: 500}}
+	houses := []housingEntry{{Name: "Alice", Tier: 4}, {Name: "Bob", Tier: 1}}
+	pets := []petShowcaseEntry{{Name: "Rex (Alice)", Type: "dog", Level: 7, ArmorName: "Plate Dog Barding"}}
+
+	out := renderTownRegistry(civic, houses, pets)
+
+	for _, want := range []string{
+		"Civic Pride", "€1,234,567", "Alice",
+		"Housing Street", "Established", "Base House",
+		"Pet Showcase", "Rex (Alice)", "L7 dog", "Plate Dog Barding",
+	} {
+		if !strings.Contains(out, want) {
+			t.Errorf("town registry missing %q\n---\n%s", want, out)
+		}
+	}
+}
+
+func TestRenderTownRegistry_EmptyBoardsDontPanic(t *testing.T) {
+	out := renderTownRegistry(nil, nil, nil)
+	for _, want := range []string{"Civic Pride", "Housing Street", "Pet Showcase"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("empty registry missing header %q", want)
+		}
+	}
+}
+
+func TestPetArmorName(t *testing.T) {
+	if got := petArmorName("dog", 0); got != "" {
+		t.Errorf("tier 0 should be no armor, got %q", got)
+	}
+	if got := petArmorName("dog", 3); got != "Plate Dog Barding" {
+		t.Errorf("dog tier 3 = %q, want Plate Dog Barding", got)
+	}
+	if got := petArmorName("cat", 5); got != "Dragonscale Cat Armor" {
+		t.Errorf("cat tier 5 = %q, want Dragonscale Cat Armor", got)
+	}
+	if got := petArmorName("dog", 99); got != "" {
+		t.Errorf("out-of-range tier should be empty, got %q", got)
+	}
+}
+
+func TestRenderGraveyard_StillDownVsRecovered(t *testing.T) {
+	now := time.Date(2026, 7, 10, 12, 0, 0, 0, time.UTC)
+	deaths := []graveEntry{
+		{Name: "Alice", Source: "arena", Location: "the Colosseum", LastDeathDate: "2026-07-10", StillDown: true},
+		{Name: "Bob", Source: "adventure", Location: "", LastDeathDate: "2026-07-08", StillDown: false},
+	}
+	out := renderGraveyard(deaths, now)
+
+	if !strings.Contains(out, "fell in the arena") {
+		t.Errorf("arena death should read distinctly\n%s", out)
+	}
+	if !strings.Contains(out, "parts unknown") {
+		t.Errorf("blank location should fall back\n%s", out)
+	}
+	if !strings.Contains(out, "still resting") {
+		t.Errorf("Alice is still down\n%s", out)
+	}
+	if !strings.Contains(out, "back on their feet") {
+		t.Errorf("Bob has recovered\n%s", out)
+	}
+	if !strings.Contains(out, "today") || !strings.Contains(out, "2 days ago") {
+		t.Errorf("relative dates missing\n%s", out)
+	}
+}
+
+func TestRenderGraveyard_Empty(t *testing.T) {
+	out := renderGraveyard(nil, time.Now())
+	if !strings.Contains(out, "garden's quiet") {
+		t.Errorf("empty graveyard should be flavored\n%s", out)
+	}
+}
+
+func TestRenderRivalsBoard_OrdersAndFormats(t *testing.T) {
+	now := time.Date(2026, 7, 10, 12, 0, 0, 0, time.UTC)
+	yesterday := now.Add(-24 * time.Hour)
+	board := []rivalBoardEntry{
+		{Name: "Alice", Wins: 9, Losses: 2, LastDuelAt: &yesterday},
+		{Name: "Bob", Wins: 3, Losses: 5, LastDuelAt: nil},
+	}
+	out := renderRivalsBoard(board, now)
+
+	if !strings.Contains(out, "9W - 2L") {
+		t.Errorf("Alice's record missing\n%s", out)
+	}
+	if !strings.Contains(out, "1 day ago") {
+		t.Errorf("relative last-duel missing\n%s", out)
+	}
+	if !strings.Contains(out, "last duel: —") {
+		t.Errorf("Bob has no recorded duel time\n%s", out)
+	}
+	// Alice ranks above Bob.
+	if strings.Index(out, "Alice") > strings.Index(out, "Bob") {
+		t.Errorf("board should be ordered by wins\n%s", out)
+	}
+}
+
+func TestHumanizeDeathDate(t *testing.T) {
+	now := time.Date(2026, 7, 10, 6, 0, 0, 0, time.UTC)
+	cases := map[string]string{
+		"2026-07-10": "today",
+		"2026-07-09": "yesterday",
+		"2026-07-05": "5 days ago",
+		"":           "some time ago",
+		"garbage":    "garbage",
+	}
+	for in, want := range cases {
+		if got := humanizeDeathDate(in, now); got != want {
+			t.Errorf("humanizeDeathDate(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+func TestTruncName(t *testing.T) {
+	if got := truncName("short", 18); got != "short" {
+		t.Errorf("short name unchanged, got %q", got)
+	}
+	long := truncName("this-is-a-very-long-display-name", 10)
+	if len([]rune(long)) != 10 {
+		t.Errorf("truncated to %d runes, want 10: %q", len([]rune(long)), long)
+	}
+	if !strings.HasSuffix(long, "…") {
+		t.Errorf("truncated name should end with ellipsis: %q", long)
+	}
+}

internal/plugin/adventure_treasure.go

@@ -50,6 +50,26 @@ var advTreasureDropRates = map[int]float64{
 
 const advMaxTreasures = 3
 
+// houseTierTrophyRoom is the T3 "Comfortable" house that unlocks the trophy
+// room — a fourth treasure slot.
+const houseTierTrophyRoom = 3
+
+// maxTreasuresForTier returns how many treasures a player may hold. The base
+// cap is 3; a T3+ house adds the trophy-room slot for a 4th.
+//
+// The extra slot is a housing perk, but HouseTier is only ever written upward
+// (purchase paths; there is no foreclosure/downgrade that writes it back down),
+// so a player can only ever hold a 4th treasure while tier>=3. There is
+// therefore no reachable state where a held treasure must be revoked at
+// bonus-computation time, and the cap is enforced only at the save gate.
+func maxTreasuresForTier(houseTier int) int {
+	n := advMaxTreasures
+	if houseTier >= houseTierTrophyRoom {
+		n++
+	}
+	return n
+}
+
 // ── Treasure Definitions ─────────────────────────────────────────────────────
 
 var advAllTreasures = map[int][]AdvTreasureDef{
@@ -246,12 +266,17 @@ var advAllTreasures = map[int][]AdvTreasureDef{
 // and the effective drop rate, so callers can surface near-miss feedback
 // ("rolled 1.8% vs 1.5% chance — just missed"). Players never see treasure
 // math otherwise, which makes rare drops feel mythical.
-func rollAdvTreasureDropDetailed(tier int, userID id.UserID, chatLevel int) (drop *AdvTreasureDrop, roll, rate float64) {
+//
+// weight scales the base rate for the moment that produced the roll: a boss
+// kill is worth more than a corridor skirmish. The chat-level bonus is added
+// after scaling so it stays a flat contribution rather than being multiplied
+// up alongside it.
+func rollAdvTreasureDropDetailed(tier int, userID id.UserID, chatLevel int, weight float64) (drop *AdvTreasureDrop, roll, rate float64) {
 	r, ok := advTreasureDropRates[tier]
 	if !ok {
 		return nil, 0, 0
 	}
-	rate = r + chatLevelRareBonus(chatLevel)
+	rate = r*weight + chatLevelRareBonus(chatLevel)
 	roll = rand.Float64()
 
 	if roll >= rate {
@@ -283,7 +308,7 @@ func rollAdvTreasureDropDetailed(tier int, userID id.UserID, chatLevel int) (dro
 // rollAdvTreasureDrop is the legacy single-return variant used by call sites
 // that don't surface near-miss feedback (auto-babysit, twinbee shares).
 func rollAdvTreasureDrop(tier int, userID id.UserID, chatLevel int) *AdvTreasureDrop {
-	d, _, _ := rollAdvTreasureDropDetailed(tier, userID, chatLevel)
+	d, _, _ := rollAdvTreasureDropDetailed(tier, userID, chatLevel, 1)
 	return d
 }
 

internal/plugin/adventure_treasure_test.go

@@ -0,0 +1,91 @@
+package plugin
+
+import (
+	"testing"
+
+	"gogobee/internal/db"
+)
+
+// N1/A1 — treasure drops were orphaned by the Phase R transition and now
+// hang off zone combat. The weight is what makes that safe: expedition
+// combat rolls far more often than the one-a-day legacy activity the base
+// rates were tuned for, so only boss/elite moments get a multiplier.
+
+func TestAdvTreasureDropRate_ScalesWithWeight(t *testing.T) {
+	// A roll under the (weighted) rate reaches the duplicate check, which
+	// reads the treasure table.
+	if err := db.Init(t.TempDir()); err != nil {
+		t.Fatalf("db.Init: %v", err)
+	}
+	const user = "@weight:example.org"
+	base := advTreasureDropRates[1]
+
+	cases := []struct {
+		name   string
+		weight float64
+		want   float64
+	}{
+		{"standard kill", advTreasureWeightStandard, base},
+		{"elite doubles", advTreasureWeightElite, base * 2},
+		{"boss quadruples", advTreasureWeightBoss, base * 4},
+		{"zone clear is one bonus roll", advTreasureWeightZoneClear, base},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			_, _, rate := rollAdvTreasureDropDetailed(1, user, 0, c.weight)
+			if rate != c.want {
+				t.Fatalf("rate for weight %v = %v, want %v", c.weight, rate, c.want)
+			}
+		})
+	}
+}
+
+func TestAdvTreasureDropRate_ZeroWeightNeverDrops(t *testing.T) {
+	for i := 0; i < 200; i++ {
+		drop, _, rate := rollAdvTreasureDropDetailed(1, "@zero:example.org", 0, 0)
+		if drop != nil || rate != 0 {
+			t.Fatalf("weight 0 produced drop=%v rate=%v", drop, rate)
+		}
+	}
+}
+
+// A forced roll must actually yield a treasure — this is the "the seam is
+// live again" assertion. A weight above 1/rate drives the effective rate
+// past 1.0, so every roll lands on the drop path.
+func TestAdvTreasureDropDetailed_ForcedRollGrantsTreasure(t *testing.T) {
+	if err := db.Init(t.TempDir()); err != nil {
+		t.Fatalf("db.Init: %v", err)
+	}
+
+	drop, _, _ := rollAdvTreasureDropDetailed(1, "@forced:example.org", 0, 1000)
+	if drop == nil || drop.Def == nil {
+		t.Fatal("forced roll produced no treasure")
+	}
+	if drop.Def.Tier != 1 {
+		t.Fatalf("tier-1 roll produced a tier-%d treasure", drop.Def.Tier)
+	}
+}
+
+// The treasure and masterwork systems predate zones and speak AdvLocation.
+func TestAdvLocForZone(t *testing.T) {
+	loc := advLocForZone(ZoneGoblinWarrens)
+	if loc.Activity != AdvActivityDungeon {
+		t.Errorf("activity = %q, want dungeon", loc.Activity)
+	}
+	if want := zoneTierFromID(ZoneGoblinWarrens); loc.Tier != want {
+		t.Errorf("tier = %d, want %d", loc.Tier, want)
+	}
+	if loc.Name == "" || loc.Name == string(ZoneGoblinWarrens) {
+		t.Errorf("name = %q, want the zone's display name", loc.Name)
+	}
+}
+
+// TestMaxTreasuresForTier pins the T3 "trophy room" 4th slot: the base cap is
+// 3, and only a tier-3+ home lifts it to 4.
+func TestMaxTreasuresForTier(t *testing.T) {
+	for tier, want := range map[int]int{0: 3, 1: 3, 2: 3, 3: 4, 4: 4} {
+		if got := maxTreasuresForTier(tier); got != want {
+			t.Errorf("maxTreasuresForTier(%d) = %d, want %d", tier, got, want)
+		}
+	}
+}

internal/plugin/adventure_twinbee.go

@@ -40,7 +40,7 @@ func twinBeeMaxTier() int {
 		if !c.Alive {
 			continue
 		}
-		combined := dndLevelForUser(c.UserID) + c.MiningSkill + c.ForagingSkill + c.FishingSkill
+		combined := combinedAdvLevel(&c)
 		if combined > bestLevel {
 			bestLevel = combined
 		}
@@ -283,7 +283,7 @@ func (p *AdventurePlugin) distributeTwinBeeRewards(result *TwinBeeResult) TwinBe
 		weight := 4 // minimum (level 1 in all 4 skills)
 		for _, c := range chars {
 			if c.UserID == uid {
-				weight = dndLevelForUser(c.UserID) + c.MiningSkill + c.ForagingSkill + c.FishingSkill
+				weight = combinedAdvLevel(&c)
 				if weight < 4 {
 					weight = 4
 				}
@@ -322,11 +322,11 @@ func (p *AdventurePlugin) distributeTwinBeeRewards(result *TwinBeeResult) TwinBe
 // ── TwinBee Gifts (Temporary Buffs) ──────────────────────────────────────────
 
 type twinBeeGiftDef struct {
-	BuffType  string
-	BuffName  string
-	Modifier  float64
-	Duration  time.Duration
-	Flavor    string
+	BuffType string
+	BuffName string
+	Modifier float64
+	Duration time.Duration
+	Flavor   string
 }
 
 var twinBeeGifts = []twinBeeGiftDef{

internal/plugin/adventure_vault.go

@@ -0,0 +1,133 @@
+package plugin
+
+import (
+	"fmt"
+	"strings"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// N4/E1 — the Tier-4 "Established" home unlocks a vault: a fixed pool of slots
+// that shelters items from `!sell all`, crafting, and combat consumption. It is
+// pure storage — a vaulted item drops out of every play surface (loadAdvInventory
+// filters it) until it is taken back — and the plumbing E2 gifting builds on.
+const (
+	vaultCapacity     = 10 // slots an Established home provides
+	vaultMinHouseTier = 4  // Tier 4 "Established" gates the vault
+)
+
+// vaultUnlocked reports whether the character's house tier grants a vault, and a
+// player-facing refusal line when it does not.
+func vaultUnlocked(char *AdventureCharacter) (bool, string) {
+	if char.HouseTier >= vaultMinHouseTier {
+		return true, ""
+	}
+	return false, "🔒 A vault comes with an **Established** home (Tier 4). Upgrade your house at `!thom` to unlock " +
+		fmt.Sprintf("%d slots of protected storage — vaulted items are safe from `!sell all` and never spent in combat.", vaultCapacity)
+}
+
+// handleVaultCmd routes `!adventure vault [store|take] <item>`. The reply-building
+// core is client-free (renderVault / vaultStoreItem / vaultTakeItem) so it is
+// unit-testable without a Matrix stub; the handler only loads the character and
+// sends the result.
+func (p *AdventurePlugin) handleVaultCmd(ctx MessageContext, args string) error {
+	char, _, err := p.ensureCharacter(ctx.Sender)
+	if err != nil {
+		return p.SendReply(ctx.RoomID, ctx.EventID, "Failed to load your character. Try `!adventure` to create one first.")
+	}
+	if !char.Alive {
+		return p.SendDM(ctx.Sender, "You're dead. The vault stays locked.")
+	}
+	if ok, refusal := vaultUnlocked(char); !ok {
+		return p.SendDM(ctx.Sender, refusal)
+	}
+
+	lower := strings.ToLower(strings.TrimSpace(args))
+	var reply string
+	switch {
+	case lower == "" || lower == "list":
+		reply = renderVault(ctx.Sender)
+	case strings.HasPrefix(lower, "store "):
+		// Serialize a player's own store/take so two near-simultaneous stores
+		// can't both pass the capacity check and overfill the vault.
+		userMu := p.advUserLock(ctx.Sender)
+		userMu.Lock()
+		reply = vaultStoreItem(ctx.Sender, strings.TrimSpace(args[len("store "):]))
+		userMu.Unlock()
+	case strings.HasPrefix(lower, "take "):
+		userMu := p.advUserLock(ctx.Sender)
+		userMu.Lock()
+		reply = vaultTakeItem(ctx.Sender, strings.TrimSpace(args[len("take "):]))
+		userMu.Unlock()
+	default:
+		reply = "Usage: `!adventure vault` to view · `!adventure vault store <item>` · `!adventure vault take <item>`."
+	}
+	return p.SendDM(ctx.Sender, reply)
+}
+
+// renderVault shows what is stowed and how many slots remain.
+func renderVault(userID id.UserID) string {
+	items, err := loadAdvVault(userID)
+	if err != nil {
+		return "The vault door won't budge. Try again in a moment."
+	}
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("🏛️ **Your Vault** — %d / %d slots\n\n", len(items), vaultCapacity))
+	if len(items) == 0 {
+		sb.WriteString("Empty. `!adventure vault store <item>` to shelter something from sale or use.")
+		return sb.String()
+	}
+	for _, it := range items {
+		name := it.Name
+		if it.Temper > 0 {
+			name = fmt.Sprintf("%s +%d", name, it.Temper)
+		}
+		sb.WriteString(fmt.Sprintf("• %s — €%d\n", name, it.Value))
+	}
+	sb.WriteString("\n`!adventure vault take <item>` to bring one back into play.")
+	return sb.String()
+}
+
+// vaultStoreItem moves one matching inventory item into the vault. Guards the
+// capacity and reports the fresh slot count so the player never has to re-list.
+func vaultStoreItem(userID id.UserID, query string) string {
+	if query == "" {
+		return "Store what? `!adventure vault store <item>`."
+	}
+	if advVaultCount(userID) >= vaultCapacity {
+		return fmt.Sprintf("The vault is full (%d / %d). Take something out first with `!adventure vault take <item>`.", vaultCapacity, vaultCapacity)
+	}
+	items, err := loadAdvInventory(userID)
+	if err != nil {
+		return "Couldn't reach your inventory. Try again in a moment."
+	}
+	match := findInventoryMatch(items, query)
+	if match == nil {
+		return fmt.Sprintf("No inventory item matches %q. Check `!adventure inventory`.", query)
+	}
+	moved, err := setItemVaulted(userID, match.ID, true)
+	if err != nil || !moved {
+		return "Couldn't stow that item. Try again in a moment."
+	}
+	return fmt.Sprintf("🏛️ Stowed **%s** in the vault. %d / %d slots used.", match.Name, advVaultCount(userID), vaultCapacity)
+}
+
+// vaultTakeItem returns one matching vaulted item to the active inventory.
+func vaultTakeItem(userID id.UserID, query string) string {
+	if query == "" {
+		return "Take what? `!adventure vault take <item>`."
+	}
+	items, err := loadAdvVault(userID)
+	if err != nil {
+		return "The vault door won't budge. Try again in a moment."
+	}
+	match := findInventoryMatch(items, query)
+	if match == nil {
+		return fmt.Sprintf("Nothing in the vault matches %q. Check `!adventure vault`.", query)
+	}
+	moved, err := setItemVaulted(userID, match.ID, false)
+	if err != nil || !moved {
+		return "Couldn't retrieve that item. Try again in a moment."
+	}
+	return fmt.Sprintf("Took **%s** out of the vault and back into your pack. %d / %d slots used.", match.Name, advVaultCount(userID), vaultCapacity)
+}

internal/plugin/adventure_vault_test.go

@@ -0,0 +1,138 @@
+package plugin
+
+import (
+	"strings"
+	"testing"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+func vaultTestDB(t *testing.T) {
+	t.Helper()
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+}
+
+func seedVaultItem(t *testing.T, user id.UserID, name string, value int64) {
+	t.Helper()
+	if err := addAdvInventoryItem(user, AdvItem{Name: name, Type: "treasure", Tier: 3, Value: value}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// TestVaultStoreTakeRoundTrip: an item vaulted leaves the active inventory and
+// joins the vault; taken back, it reverses exactly.
+func TestVaultStoreTakeRoundTrip(t *testing.T) {
+	vaultTestDB(t)
+	user := id.UserID("@vault:test.invalid")
+	seedVaultItem(t, user, "Jeweled Crown", 5000)
+
+	if got := vaultStoreItem(user, "crown"); !strings.Contains(got, "Stowed") {
+		t.Fatalf("store reply = %q, want a stow confirmation", got)
+	}
+
+	inv, _ := loadAdvInventory(user)
+	if len(inv) != 0 {
+		t.Fatalf("active inventory = %d items, want 0 (item is vaulted)", len(inv))
+	}
+	vault, _ := loadAdvVault(user)
+	if len(vault) != 1 || vault[0].Name != "Jeweled Crown" {
+		t.Fatalf("vault = %+v, want the crown", vault)
+	}
+
+	if got := vaultTakeItem(user, "crown"); !strings.Contains(got, "back into your pack") {
+		t.Fatalf("take reply = %q, want a retrieval confirmation", got)
+	}
+	inv, _ = loadAdvInventory(user)
+	if len(inv) != 1 {
+		t.Fatalf("active inventory = %d items, want 1 after take", len(inv))
+	}
+	if n := advVaultCount(user); n != 0 {
+		t.Fatalf("vault count = %d, want 0", n)
+	}
+}
+
+// TestVaultCapacity: the 10th item stores, the 11th is refused, and the refusal
+// leaves the item in the active inventory.
+func TestVaultCapacity(t *testing.T) {
+	vaultTestDB(t)
+	user := id.UserID("@vaultcap:test.invalid")
+	for i := 0; i < vaultCapacity; i++ {
+		seedVaultItem(t, user, "Gem", 100)
+		if got := vaultStoreItem(user, "Gem"); !strings.Contains(got, "Stowed") {
+			t.Fatalf("store %d reply = %q, want success", i, got)
+		}
+	}
+	if n := advVaultCount(user); n != vaultCapacity {
+		t.Fatalf("vault count = %d, want %d", n, vaultCapacity)
+	}
+
+	seedVaultItem(t, user, "Overflow Gem", 100)
+	got := vaultStoreItem(user, "Overflow Gem")
+	if !strings.Contains(got, "full") {
+		t.Fatalf("11th store reply = %q, want a full-vault refusal", got)
+	}
+	// The refused item is still in play.
+	inv, _ := loadAdvInventory(user)
+	if len(inv) != 1 || inv[0].Name != "Overflow Gem" {
+		t.Fatalf("active inventory = %+v, want the overflow gem left in play", inv)
+	}
+}
+
+// TestVaultShieldsFromSellAll: `!sell all` liquidates loadAdvInventory, which a
+// vaulted item is no longer part of — the whole point of the vault.
+func TestVaultShieldsFromSellAll(t *testing.T) {
+	vaultTestDB(t)
+	user := id.UserID("@vaultsell:test.invalid")
+	seedVaultItem(t, user, "Heirloom", 9000)
+	seedVaultItem(t, user, "Junk", 5)
+
+	if got := vaultStoreItem(user, "Heirloom"); !strings.Contains(got, "Stowed") {
+		t.Fatalf("store reply = %q", got)
+	}
+	// What sell-all would consume:
+	sellable, _ := loadAdvInventory(user)
+	if len(sellable) != 1 || sellable[0].Name != "Junk" {
+		t.Fatalf("sellable inventory = %+v, want only Junk (heirloom sheltered)", sellable)
+	}
+}
+
+// TestVaultGate: below Tier 4 the vault is locked; at Tier 4 it opens.
+func TestVaultGate(t *testing.T) {
+	locked := &AdventureCharacter{HouseTier: 3}
+	if ok, msg := vaultUnlocked(locked); ok || msg == "" {
+		t.Fatalf("tier 3: ok=%v msg=%q, want locked with a refusal", ok, msg)
+	}
+	open := &AdventureCharacter{HouseTier: 4}
+	if ok, msg := vaultUnlocked(open); !ok || msg != "" {
+		t.Fatalf("tier 4: ok=%v msg=%q, want unlocked", ok, msg)
+	}
+}
+
+// TestSetItemVaultedIsOwnerScoped: another user's id cannot be flipped.
+func TestSetItemVaultedIsOwnerScoped(t *testing.T) {
+	vaultTestDB(t)
+	owner := id.UserID("@owner:test.invalid")
+	intruder := id.UserID("@intruder:test.invalid")
+	seedVaultItem(t, owner, "Relic", 1000)
+	items, _ := loadAdvInventory(owner)
+	if len(items) != 1 {
+		t.Fatalf("setup: owner inventory = %d, want 1", len(items))
+	}
+	moved, err := setItemVaulted(intruder, items[0].ID, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if moved {
+		t.Fatalf("intruder moved the owner's item; want no-op")
+	}
+	if advVaultCount(owner) != 0 {
+		t.Fatalf("owner's item was vaulted by an intruder")
+	}
+}

internal/plugin/adventure_well_rested.go

@@ -0,0 +1,110 @@
+package plugin
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Well-rested — a long rest taken at a home of tier 2+ grants a temporary buff
+// that lasts until the next long rest. Renting a room at Thom Krooke's inn does
+// not: the perk exists to give owning (and upgrading) a house a payoff the inn
+// can't match, and it turns the dead T3/T4 prestige tiers into something worth
+// buying.
+//
+// Two halves, both scaling with house tier (2 < 3 < 4):
+//   - wellRestedTempHP: a temporary hit-point cushion, layered above MaxHP for
+//     the day's fights via applyDnDHPScaling; and
+//   - wellRestedSlotBonus: bonus spell slots folded into the caster's pool at
+//     their highest available slot level.
+//
+// The tuning below is deliberately generous toward casters, who trail on
+// spell-pool richness — the bonus slots are the substantive reward and the
+// temp HP is a lighter feel-good cushion. All values are tunable.
+//
+// Nothing here is a secret discovery mechanic (cf. Misty/Arina), so the rest
+// message surfaces exactly what was granted.
+
+// homeRestTempHPPct maps house tier → temp-HP fraction of MaxHP.
+func homeRestTempHPPct(houseTier int) float64 {
+	switch {
+	case houseTier >= 4:
+		return 0.16
+	case houseTier >= 3:
+		return 0.12
+	case houseTier >= 2:
+		return 0.08
+	default:
+		return 0
+	}
+}
+
+// homeRestBonusSlots maps house tier → number of bonus spell slots.
+func homeRestBonusSlots(houseTier int) int {
+	switch {
+	case houseTier >= 4:
+		return 3
+	case houseTier >= 3:
+		return 2
+	case houseTier >= 2:
+		return 1
+	default:
+		return 0
+	}
+}
+
+// wellRestedTempHP returns the temporary HP granted by a home long rest at the
+// given house tier. Tier 1 and the inn grant none. Always at least 1 when the
+// tier qualifies, so a low-HP character still sees the buff.
+func wellRestedTempHP(hpMax, houseTier int) int {
+	pct := homeRestTempHPPct(houseTier)
+	if pct <= 0 {
+		return 0
+	}
+	hp := int(float64(hpMax) * pct)
+	if hp < 1 {
+		hp = 1
+	}
+	return hp
+}
+
+// wellRestedSlotBonus returns the temporary bonus spell slots granted by a home
+// long rest, placed entirely at the caster's highest available slot level (the
+// most valuable, and one a caster is guaranteed to have). Tier 1, the inn, and
+// non-casters (empty pool) grant none.
+func wellRestedSlotBonus(houseTier int, pool map[int]int) map[int]int {
+	n := homeRestBonusSlots(houseTier)
+	if n == 0 || len(pool) == 0 {
+		return nil
+	}
+	highest := 0
+	for lvl := range pool {
+		if lvl > highest {
+			highest = lvl
+		}
+	}
+	if highest == 0 {
+		return nil
+	}
+	return map[int]int{highest: n}
+}
+
+// wellRestedSummary renders the player-facing description of a granted buff,
+// e.g. "+18 temp HP, +2 level-5 spell slots". Returns "" when nothing was
+// granted (tier 1, the inn, or a non-caster with no temp HP).
+func wellRestedSummary(tempHP int, slotBonus map[int]int) string {
+	var bits []string
+	if tempHP > 0 {
+		bits = append(bits, fmt.Sprintf("+%d temp HP", tempHP))
+	}
+	for lvl, n := range slotBonus {
+		if n <= 0 {
+			continue
+		}
+		plural := ""
+		if n != 1 {
+			plural = "s"
+		}
+		bits = append(bits, fmt.Sprintf("+%d level-%d spell slot%s", n, lvl, plural))
+	}
+	return strings.Join(bits, ", ")
+}

internal/plugin/adventure_well_rested_test.go

@@ -0,0 +1,192 @@
+package plugin
+
+import (
+	"testing"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+func TestWellRestedTempHP_ByTier(t *testing.T) {
+	cases := []struct {
+		tier, hpMax, want int
+	}{
+		{0, 100, 0},  // no house
+		{1, 100, 0},  // tier-1 shack: nothing
+		{2, 100, 8},  // 8%
+		{3, 100, 12}, // 12%
+		{4, 100, 16}, // 16%
+		{2, 3, 1},    // rounds to <1 → floored to 1
+	}
+	for _, c := range cases {
+		if got := wellRestedTempHP(c.hpMax, c.tier); got != c.want {
+			t.Errorf("wellRestedTempHP(hpMax=%d, tier=%d) = %d, want %d", c.hpMax, c.tier, got, c.want)
+		}
+	}
+}
+
+func TestWellRestedSlotBonus_PlacesAtHighestLevel(t *testing.T) {
+	pool := map[int]int{1: 4, 2: 3, 3: 2} // highest available = 3
+
+	if got := wellRestedSlotBonus(1, pool); got != nil {
+		t.Errorf("tier 1 → %v, want nil", got)
+	}
+	if got := wellRestedSlotBonus(0, pool); got != nil {
+		t.Errorf("tier 0 → %v, want nil", got)
+	}
+	if got := wellRestedSlotBonus(3, nil); got != nil {
+		t.Errorf("non-caster (nil pool) → %v, want nil", got)
+	}
+
+	for tier, wantN := range map[int]int{2: 1, 3: 2, 4: 3} {
+		got := wellRestedSlotBonus(tier, pool)
+		if len(got) != 1 || got[3] != wantN {
+			t.Errorf("tier %d → %v, want {3: %d}", tier, got, wantN)
+		}
+	}
+}
+
+func TestApplyDnDHPScaling_TempHPCushion(t *testing.T) {
+	// Golden-safety: TempHP==0 must leave a full-HP character untouched
+	// (StartHP stays 0 = "enter at MaxHP", MaxHP unchanged).
+	stats := CombatStats{MaxHP: 100, HPBonus: 10}
+	full := &DnDCharacter{HPMax: 100, HPCurrent: 100, TempHP: 0}
+	applyDnDHPScaling(&stats, full)
+	if stats.MaxHP != 100 || stats.StartHP != 0 {
+		t.Fatalf("TempHP=0 full HP: MaxHP=%d StartHP=%d, want 100/0", stats.MaxHP, stats.StartHP)
+	}
+
+	// Full HP + cushion: MaxHP grows by TempHP, StartHP stays the sentinel so
+	// combat enters at the bumped max (full + cushion).
+	stats = CombatStats{MaxHP: 100, HPBonus: 10}
+	rested := &DnDCharacter{HPMax: 100, HPCurrent: 100, TempHP: 15}
+	applyDnDHPScaling(&stats, rested)
+	if stats.MaxHP != 115 || stats.StartHP != 0 {
+		t.Fatalf("full HP + cushion: MaxHP=%d StartHP=%d, want 115/0", stats.MaxHP, stats.StartHP)
+	}
+
+	// Wounded + cushion: entry HP is current + gear bonus + cushion, MaxHP grows.
+	stats = CombatStats{MaxHP: 100, HPBonus: 10}
+	wounded := &DnDCharacter{HPMax: 100, HPCurrent: 40, TempHP: 15}
+	applyDnDHPScaling(&stats, wounded)
+	if stats.MaxHP != 115 || stats.StartHP != 65 { // 40 + 10 + 15
+		t.Fatalf("wounded + cushion: MaxHP=%d StartHP=%d, want 115/65", stats.MaxHP, stats.StartHP)
+	}
+}
+
+func TestApplyLongRestSpellSlots_GrantAndExpiry(t *testing.T) {
+	if err := db.Init(t.TempDir()); err != nil {
+		t.Fatalf("db.Init: %v", err)
+	}
+	t.Cleanup(db.Close)
+
+	uid := id.UserID("@rested_caster:example")
+	c := &DnDCharacter{
+		UserID: uid, Race: RaceHuman, Class: ClassCleric, Level: 5,
+		STR: 10, DEX: 12, CON: 14, INT: 10, WIS: 16, CHA: 10,
+	}
+	c.HPMax = computeMaxHP(c.Class, abilityModifier(c.CON), c.Level)
+	c.HPCurrent = c.HPMax
+	if err := SaveDnDCharacter(c); err != nil {
+		t.Fatalf("SaveDnDCharacter: %v", err)
+	}
+	if err := setSpellSlotsForCharacter(c); err != nil {
+		t.Fatalf("setSpellSlotsForCharacter: %v", err)
+	}
+
+	base, _ := getSpellSlots(uid)
+	if len(base) == 0 {
+		t.Fatal("cleric L5 should have a base slot pool")
+	}
+	highest := 0
+	for lvl := range base {
+		if lvl > highest {
+			highest = lvl
+		}
+	}
+
+	// Home rest at tier 4 → +3 at highest level, used reset to 0.
+	bonus, err := applyLongRestSpellSlots(c, 4)
+	if err != nil {
+		t.Fatalf("applyLongRestSpellSlots(tier4): %v", err)
+	}
+	if bonus[highest] != 3 {
+		t.Fatalf("tier-4 bonus = %v, want {%d: 3}", bonus, highest)
+	}
+	after, _ := getSpellSlots(uid)
+	if after[highest][0] != base[highest][0]+3 {
+		t.Errorf("highest total = %d, want base+3 = %d", after[highest][0], base[highest][0]+3)
+	}
+	for lvl, pair := range after {
+		if pair[1] != 0 {
+			t.Errorf("slot L%d used = %d after rest, want 0", lvl, pair[1])
+		}
+	}
+
+	// Next rest at the inn (tier 0) → bonus expires, totals back to base.
+	if _, err := applyLongRestSpellSlots(c, 0); err != nil {
+		t.Fatalf("applyLongRestSpellSlots(tier0): %v", err)
+	}
+	reset, _ := getSpellSlots(uid)
+	for lvl, pair := range reset {
+		if pair[0] != base[lvl][0] {
+			t.Errorf("L%d total = %d after expiry, want base %d", lvl, pair[0], base[lvl][0])
+		}
+	}
+
+	// Tier-1 house grants nothing.
+	if bonus, _ := applyLongRestSpellSlots(c, 1); bonus != nil {
+		t.Errorf("tier-1 bonus = %v, want nil", bonus)
+	}
+}
+
+func TestApplyLongRestSpellSlots_NonCaster(t *testing.T) {
+	if err := db.Init(t.TempDir()); err != nil {
+		t.Fatalf("db.Init: %v", err)
+	}
+	t.Cleanup(db.Close)
+
+	uid := id.UserID("@rested_fighter:example")
+	c := &DnDCharacter{UserID: uid, Race: RaceHuman, Class: ClassFighter, Level: 5, CON: 14}
+	c.HPMax = computeMaxHP(c.Class, abilityModifier(c.CON), c.Level)
+	c.HPCurrent = c.HPMax
+	if err := SaveDnDCharacter(c); err != nil {
+		t.Fatalf("SaveDnDCharacter: %v", err)
+	}
+
+	bonus, err := applyLongRestSpellSlots(c, 4)
+	if err != nil {
+		t.Fatalf("applyLongRestSpellSlots: %v", err)
+	}
+	if bonus != nil {
+		t.Errorf("non-caster bonus = %v, want nil", bonus)
+	}
+	if slots, _ := getSpellSlots(uid); len(slots) != 0 {
+		t.Errorf("non-caster has %d slot rows, want 0", len(slots))
+	}
+}
+
+// TestHomeWorkshop pins the T3 workshop craft bonus and its effect on the
+// success-rate cap.
+func TestHomeWorkshop(t *testing.T) {
+	for tier, want := range map[int]float64{0: 0, 1: 0, 2: 0, 3: 0.05, 4: 0.05} {
+		if got := homeWorkshopCraftBonus(tier); got != want {
+			t.Errorf("homeWorkshopCraftBonus(%d) = %.2f, want %.2f", tier, got, want)
+		}
+	}
+	// No workshop: base cap holds at 0.95 for a maxed forager.
+	if got := craftingSuccessRate(100, 1, 0); got != 0.95 {
+		t.Errorf("maxed forager, no workshop = %.3f, want 0.95", got)
+	}
+	// Workshop lifts the cap to 0.98.
+	if got := craftingSuccessRate(100, 1, 0.05); got != 0.98 {
+		t.Errorf("maxed forager, workshop = %.3f, want 0.98", got)
+	}
+	// Mid-level forager gets the flat +5% added below the cap.
+	base := craftingSuccessRate(15, 10, 0)
+	withShop := craftingSuccessRate(15, 10, 0.05)
+	if diff := withShop - base; diff < 0.049 || diff > 0.051 {
+		t.Errorf("workshop delta = %.3f, want ~0.05", diff)
+	}
+}

internal/plugin/adventure_worldboss.go

@@ -0,0 +1,784 @@
+package plugin
+
+import (
+	"database/sql"
+	"fmt"
+	"hash/fnv"
+	"log/slog"
+	"sort"
+	"strings"
+	"time"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// World boss (N6/C3) — the monthly communal "Siege". A named boss camps outside
+// town for a fixed window with a single shared HP pool. Every player gets one
+// bout per day against it (an arena-style fight through runZoneCombat); the
+// damage they deal is subtracted from the shared pool whether the individual
+// bout is won or lost. The pool falling to zero defeats the boss; the window
+// lapsing with the pool still up means the boss survives and loots the town.
+//
+// Economy (decisions locked 2026-07-10): a defeat pays every contributor from a
+// freshly minted bounty scaled by fights fought (not damage — accessibility),
+// plus a consumable cache and one low-rate treasure roll each; a survival debits
+// the community pot as a tribute (a sink the economy wants). The bout itself
+// costs real HP the way the arena does — no restore — but never permadeaths.
+//
+// The event lives in its own tables (world_boss / world_boss_contrib), outside
+// the saveAdvCharacter fan-out, so a character save can never clobber the shared
+// pool — the same structural isolation adventure_shadow earns.
+
+const (
+	// worldBossWindow is how long the boss camps outside town once it spawns.
+	worldBossWindow = 72 * time.Hour
+	// worldBossPresenceDays is the any-chat presence lookback used to size the
+	// boss to the community that will actually fight it
+	// (feedback_presence_is_any_chat).
+	worldBossPresenceDays = 14
+	// worldBossMinTier floors the boss tier — the Siege is always a serious
+	// fight, never a T1/T2 pushover, even for a low-level town.
+	worldBossMinTier = 3
+	// worldBossBoutsPerPlayer sizes the shared pool: expected full-damage bouts
+	// to fell the boss ≈ activePlayers × this. Higher = a longer siege that needs
+	// more of the town to turn up. Tunable; watch prod turnout.
+	worldBossBoutsPerPlayer = 2.0
+	// worldBossMinBouts / worldBossMaxBouts clamp the pool so a near-empty town
+	// still gets a beatable boss and a huge town doesn't get an unkillable one.
+	worldBossMinBouts = 4
+	worldBossMaxBouts = 60
+	// worldBossDefeatBaseEuro is the minted bounty a single fight earns a
+	// contributor on a defeat; total payout = base × fights fought.
+	worldBossDefeatBaseEuro = 1500
+	// worldBossTributePct is the fraction of the community pot the boss loots on
+	// a survival — a visible pot sink.
+	worldBossTributePct = 0.20
+	// worldBossTreasureWeight is the (low) weight of the single treasure roll each
+	// contributor gets on a defeat.
+	worldBossTreasureWeight = advTreasureWeightElite
+	// worldBossCacheSize is how many tier consumables each contributor is handed
+	// on a defeat.
+	worldBossCacheSize = 2
+)
+
+// worldBossState mirrors an active world_boss row.
+type worldBossState struct {
+	ID        int64
+	Name      string
+	Tier      int
+	HPMax     int
+	HPCurrent int
+	Status    string // active | defeated | survived
+	StartsAt  time.Time
+	EndsAt    time.Time
+}
+
+// worldBossContrib mirrors a world_boss_contrib row — one player's tally against
+// one boss.
+type worldBossContrib struct {
+	BossID        int64
+	UserID        id.UserID
+	Fights        int
+	Damage        int
+	LastFightDate string
+}
+
+// worldBossNames is the pool a Siege boss is named from — big, ancient,
+// town-threatening things. Picked deterministically per event so a given month's
+// boss reads the same to everyone.
+var worldBossNames = []string{
+	"Gorloth the Sunderer", "The Ashen Wyrm", "Kravok, Maw of the Deep",
+	"Nyxaris the Devouring", "The Iron Colossus", "Ssath'ra, Coil of Ruin",
+	"Ymirok the Frostbound", "The Hollow Leviathan", "Dravmaug, Ender of Walls",
+	"The Bone Cathedral", "Vornath the Insatiable", "The Screaming Tide",
+}
+
+// worldBossNameFor picks a stable boss name from an event key (the spawn month),
+// so the same Siege always reads by the same name.
+func worldBossNameFor(eventKey string) string {
+	h := fnv.New32a()
+	_, _ = h.Write([]byte(eventKey))
+	return worldBossNames[int(h.Sum32())%len(worldBossNames)]
+}
+
+// ── Persistence ──────────────────────────────────────────────────────────────
+
+func scanWorldBoss(row interface{ Scan(...any) error }) (*worldBossState, error) {
+	b := &worldBossState{}
+	err := row.Scan(&b.ID, &b.Name, &b.Tier, &b.HPMax, &b.HPCurrent, &b.Status, &b.StartsAt, &b.EndsAt)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+// loadActiveWorldBoss returns the live Siege, or (nil, nil) if none is camped.
+func loadActiveWorldBoss() (*worldBossState, error) {
+	b, err := scanWorldBoss(db.Get().QueryRow(
+		`SELECT id, name, tier, hp_max, hp_current, status, starts_at, ends_at
+		   FROM world_boss WHERE status = 'active' ORDER BY id DESC LIMIT 1`))
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+// loadWorldBoss reads one boss by id (history included). (nil, nil) if absent.
+func loadWorldBoss(bossID int64) (*worldBossState, error) {
+	b, err := scanWorldBoss(db.Get().QueryRow(
+		`SELECT id, name, tier, hp_max, hp_current, status, starts_at, ends_at
+		   FROM world_boss WHERE id = ?`, bossID))
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+// insertWorldBoss writes a fresh active boss and returns its id.
+func insertWorldBoss(name string, tier, hpMax int, startsAt, endsAt time.Time) (int64, error) {
+	res, err := db.Get().Exec(
+		`INSERT INTO world_boss (name, tier, hp_max, hp_current, status, starts_at, ends_at)
+		 VALUES (?, ?, ?, ?, 'active', ?, ?)`,
+		name, tier, hpMax, hpMax, startsAt, endsAt)
+	if err != nil {
+		return 0, err
+	}
+	return res.LastInsertId()
+}
+
+// applyWorldBossDamage subtracts damage from the shared pool atomically, clamped
+// at zero, only while the boss is still active. Returns the pool's new value and
+// whether the pool is now down (killed). The UPDATE and the re-read are separate
+// statements, so two concurrent killers can BOTH observe killed=true — that is
+// fine: resolveWorldBossDefeated dedupes on the status='active' guard in
+// setWorldBossStatus, so only one payout ever fires. killed is just "should the
+// caller attempt resolution".
+func applyWorldBossDamage(bossID int64, dmg int) (remaining int, killed bool, err error) {
+	if dmg < 0 {
+		dmg = 0
+	}
+	_, err = db.Get().Exec(
+		`UPDATE world_boss SET hp_current = MAX(0, hp_current - ?)
+		   WHERE id = ? AND status = 'active'`, dmg, bossID)
+	if err != nil {
+		return 0, false, err
+	}
+	b, err := loadWorldBoss(bossID)
+	if err != nil || b == nil {
+		return 0, false, err
+	}
+	return b.HPCurrent, b.HPCurrent <= 0 && b.Status == "active", nil
+}
+
+// setWorldBossStatus closes out a boss (defeated | survived) and stamps
+// resolved_at. Guarded on status='active' so a double resolution is a no-op.
+func setWorldBossStatus(bossID int64, status string) (bool, error) {
+	res, err := db.Get().Exec(
+		`UPDATE world_boss SET status = ?, resolved_at = CURRENT_TIMESTAMP
+		   WHERE id = ? AND status = 'active'`, status, bossID)
+	if err != nil {
+		return false, err
+	}
+	n, _ := res.RowsAffected()
+	return n == 1, nil
+}
+
+// upsertWorldBossContrib bumps a player's tally against a boss.
+func upsertWorldBossContrib(bossID int64, userID id.UserID, dmg int, dateKey string) error {
+	_, err := db.Get().Exec(
+		`INSERT INTO world_boss_contrib (boss_id, user_id, fights, damage, last_fight_date)
+		 VALUES (?, ?, 1, ?, ?)
+		 ON CONFLICT(boss_id, user_id) DO UPDATE SET
+		   fights = fights + 1,
+		   damage = damage + excluded.damage,
+		   last_fight_date = excluded.last_fight_date`,
+		bossID, string(userID), dmg, dateKey)
+	return err
+}
+
+// loadWorldBossContrib reads one player's tally, or (nil, nil) if they haven't
+// fought this boss.
+func loadWorldBossContrib(bossID int64, userID id.UserID) (*worldBossContrib, error) {
+	c := &worldBossContrib{BossID: bossID, UserID: userID}
+	err := db.Get().QueryRow(
+		`SELECT fights, damage, last_fight_date FROM world_boss_contrib
+		   WHERE boss_id = ? AND user_id = ?`, bossID, string(userID)).
+		Scan(&c.Fights, &c.Damage, &c.LastFightDate)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+
+// loadWorldBossContribs reads every contributor to a boss, ordered by fights
+// desc then damage desc (the board order).
+func loadWorldBossContribs(bossID int64) ([]worldBossContrib, error) {
+	rows, err := db.Get().Query(
+		`SELECT user_id, fights, damage, last_fight_date FROM world_boss_contrib
+		   WHERE boss_id = ? ORDER BY fights DESC, damage DESC`, bossID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []worldBossContrib
+	for rows.Next() {
+		c := worldBossContrib{BossID: bossID}
+		var uid string
+		if err := rows.Scan(&uid, &c.Fights, &c.Damage, &c.LastFightDate); err != nil {
+			return nil, err
+		}
+		c.UserID = id.UserID(uid)
+		out = append(out, c)
+	}
+	return out, rows.Err()
+}
+
+// ── Scaling ──────────────────────────────────────────────────────────────────
+
+// activePlayerIDs returns the user ids that have chatted (any message, not just
+// commands) in the last `days` days — the any-chat presence signal
+// (feedback_presence_is_any_chat), read off the streaks plugin's daily_activity
+// table.
+func activePlayerIDs(days int) ([]id.UserID, error) {
+	cutoff := time.Now().UTC().AddDate(0, 0, -days).Format("2006-01-02")
+	rows, err := db.Get().Query(
+		`SELECT DISTINCT user_id FROM daily_activity WHERE date >= ?`, cutoff)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []id.UserID
+	for rows.Next() {
+		var uid string
+		if err := rows.Scan(&uid); err != nil {
+			return nil, err
+		}
+		out = append(out, id.UserID(uid))
+	}
+	return out, rows.Err()
+}
+
+// combinedAdvLevel is the same "how strong is this adventurer" reducer TwinBee
+// uses — combat level plus the three gathering skills.
+func combinedAdvLevel(c *AdventureCharacter) int {
+	return dndLevelForUser(c.UserID) + c.MiningSkill + c.ForagingSkill + c.FishingSkill
+}
+
+// medianInt returns the median of a sorted-or-not int slice (0 for empty).
+func medianInt(xs []int) int {
+	if len(xs) == 0 {
+		return 0
+	}
+	s := append([]int(nil), xs...)
+	sort.Ints(s)
+	mid := len(s) / 2
+	if len(s)%2 == 1 {
+		return s[mid]
+	}
+	return (s[mid-1] + s[mid]) / 2
+}
+
+// tierForCombinedLevel buckets a combined adventure level to a zone tier, floored
+// at worldBossMinTier. Same thresholds as twinBeeMaxTier (combined 12 → T4,
+// 21 → T5), applied here to the median rather than the max.
+func tierForCombinedLevel(level int) int {
+	switch {
+	case level >= 21:
+		return 5
+	case level >= 12:
+		return 4
+	default:
+		return worldBossMinTier
+	}
+}
+
+// groupInt renders an int with thousands separators (no currency symbol),
+// reusing fmtEuro's grouping.
+func groupInt(n int) string {
+	return strings.TrimPrefix(fmtEuro(n), "€")
+}
+
+// worldBossSpawnPlan computes the boss's tier and pool HP from the players active
+// in the presence window. Returns the tier, HP, and the active-player count that
+// drove the sizing (0 players ⇒ a floor boss so a manual spawn still works).
+func worldBossSpawnPlan() (tier, hpMax, activeN int) {
+	ids, err := activePlayerIDs(worldBossPresenceDays)
+	if err != nil {
+		slog.Warn("worldboss: active player lookup failed", "err", err)
+	}
+	active := make(map[id.UserID]bool, len(ids))
+	for _, uid := range ids {
+		active[uid] = true
+	}
+	chars, err := loadAllAdvCharacters()
+	if err != nil {
+		slog.Warn("worldboss: char load failed", "err", err)
+	}
+	var levels []int
+	for i := range chars {
+		c := &chars[i]
+		if !active[c.UserID] || !c.Alive {
+			continue
+		}
+		levels = append(levels, combinedAdvLevel(c))
+	}
+	activeN = len(levels)
+	tier = tierForCombinedLevel(medianInt(levels))
+
+	bouts := int(float64(max(activeN, 1)) * worldBossBoutsPerPlayer)
+	if bouts < worldBossMinBouts {
+		bouts = worldBossMinBouts
+	}
+	if bouts > worldBossMaxBouts {
+		bouts = worldBossMaxBouts
+	}
+	perBout, _, _, _, _ := arenaTierBaseStats(tier)
+	hpMax = perBout * bouts
+	return tier, hpMax, activeN
+}
+
+// worldBossTemplate builds the disposable per-bout enemy stat block. The shared
+// pool lives in world_boss.hp_current; this template is just the thing a single
+// player swings at, so its own HP is the arena tier's boss HP — beatable in a
+// bout, which lets a strong player land a full boss's worth of damage on the
+// pool.
+func worldBossTemplate(name string, tier int) DnDMonsterTemplate {
+	hp, ac, atk, ab, cr := arenaTierBaseStats(tier)
+	return DnDMonsterTemplate{
+		ID:          fmt.Sprintf("worldboss_t%d", tier),
+		Name:        name,
+		CR:          cr,
+		HP:          hp,
+		AC:          ac,
+		Attack:      atk,
+		AttackBonus: ab,
+		Speed:       12,
+		BlockRate:   0.05,
+		XPValue:     arenaTiers[tier-1].BattleXP * 5,
+		Notes:       "the Siege",
+	}
+}
+
+// ── Lifecycle ────────────────────────────────────────────────────────────────
+
+// spawnWorldBoss mints a fresh Siege and announces it. It refuses if one is
+// already camped (only one at a time). eventKey names the boss deterministically
+// (the spawn month for the auto path, a stamp for a manual one).
+func (p *AdventurePlugin) spawnWorldBoss(eventKey string) (*worldBossState, error) {
+	if existing, err := loadActiveWorldBoss(); err != nil {
+		return nil, err
+	} else if existing != nil {
+		return existing, fmt.Errorf("a world boss is already active")
+	}
+	tier, hpMax, activeN := worldBossSpawnPlan()
+	name := worldBossNameFor(eventKey)
+	now := time.Now().UTC()
+	ends := now.Add(worldBossWindow)
+	bossID, err := insertWorldBoss(name, tier, hpMax, now, ends)
+	if err != nil {
+		return nil, err
+	}
+	boss, err := loadWorldBoss(bossID)
+	if err != nil {
+		return nil, err
+	}
+	p.announceWorldBossSpawn(boss, activeN)
+	slog.Info("worldboss: spawned", "id", bossID, "name", name, "tier", tier, "hp", hpMax, "activeN", activeN)
+	return boss, nil
+}
+
+// worldBossTick rides the 1-minute event ticker. It auto-spawns a boss on the
+// first of each UTC month and resolves a live boss whose window has lapsed. The
+// defeat path is not here — a bout crossing the pool to zero resolves inline
+// (W2), because the ticker never sees the pool between two 60s reads.
+func (p *AdventurePlugin) worldBossTick() {
+	boss, err := loadActiveWorldBoss()
+	if err != nil {
+		slog.Warn("worldboss: tick load failed", "err", err)
+		return
+	}
+	now := time.Now().UTC()
+	if boss != nil {
+		// Safety net: a killing blow commits the pool to 0 inline, but if the
+		// process died (or was redeployed) before the bout resolved the status,
+		// the boss is left active/0-HP. Resolve it as the defeat it was — never
+		// let the survive branch below debit the pot for a boss the town killed.
+		if boss.HPCurrent <= 0 {
+			p.resolveWorldBossDefeated(boss)
+			return
+		}
+		if now.After(boss.EndsAt) {
+			p.resolveWorldBossSurvived(boss)
+		}
+		return
+	}
+	// No boss camped — auto-spawn on the 1st of the month, once.
+	if now.Day() != 1 {
+		return
+	}
+	monthKey := now.Format("2006-01")
+	if db.JobCompleted("worldboss_spawn", monthKey) {
+		return
+	}
+	if _, err := p.spawnWorldBoss(monthKey); err != nil {
+		slog.Warn("worldboss: auto-spawn failed", "err", err)
+		return
+	}
+	db.MarkJobCompleted("worldboss_spawn", monthKey)
+}
+
+// ── Resolution ───────────────────────────────────────────────────────────────
+
+// worldBossPayout is one contributor's minted defeat reward.
+type worldBossPayout struct {
+	UserID id.UserID
+	Fights int
+	Euro   int
+}
+
+// computeWorldBossPayouts scales the minted bounty by fights fought (not damage —
+// accessibility). Pure so the split is testable without a euro/Matrix stub.
+func computeWorldBossPayouts(contribs []worldBossContrib, baseEuro int) []worldBossPayout {
+	out := make([]worldBossPayout, 0, len(contribs))
+	for _, c := range contribs {
+		if c.Fights <= 0 {
+			continue
+		}
+		out = append(out, worldBossPayout{UserID: c.UserID, Fights: c.Fights, Euro: baseEuro * c.Fights})
+	}
+	return out
+}
+
+// resolveWorldBossDefeated pays every contributor a minted bounty scaled by
+// fights, plus a consumable cache and one low-rate treasure roll each, then
+// announces the kill. Guarded so it fires once.
+func (p *AdventurePlugin) resolveWorldBossDefeated(boss *worldBossState) {
+	won, err := setWorldBossStatus(boss.ID, "defeated")
+	if err != nil {
+		slog.Warn("worldboss: defeat close-out failed", "err", err)
+		return
+	}
+	if !won {
+		return // someone else already resolved it
+	}
+	contribs, err := loadWorldBossContribs(boss.ID)
+	if err != nil {
+		slog.Warn("worldboss: contrib load failed", "err", err)
+	}
+	payouts := computeWorldBossPayouts(contribs, worldBossDefeatBaseEuro)
+	treasureZone := worldBossTreasureZone(boss.Tier)
+	for _, pay := range payouts {
+		p.euro.Credit(pay.UserID, float64(pay.Euro), "worldboss_bounty")
+		for _, item := range consumableCache(boss.Tier, worldBossCacheSize) {
+			it := item
+			p.grantZoneItem(pay.UserID, &it, "🧪")
+		}
+		if treasureZone != "" {
+			p.rollZoneTreasure(pay.UserID, treasureZone, worldBossTreasureWeight)
+		}
+	}
+	p.announceWorldBossDefeated(boss, payouts)
+	slog.Info("worldboss: defeated", "id", boss.ID, "contributors", len(payouts))
+}
+
+// resolveWorldBossSurvived debits the community pot as a tribute (a sink) and
+// announces the town's loss. Guarded so it fires once.
+func (p *AdventurePlugin) resolveWorldBossSurvived(boss *worldBossState) {
+	won, err := setWorldBossStatus(boss.ID, "survived")
+	if err != nil {
+		slog.Warn("worldboss: survive close-out failed", "err", err)
+		return
+	}
+	if !won {
+		return
+	}
+	tribute := int(float64(communityPotBalance()) * worldBossTributePct)
+	paid := 0
+	if tribute > 0 && communityPotDebit(tribute) {
+		paid = tribute
+	}
+	p.announceWorldBossSurvived(boss, paid)
+	slog.Info("worldboss: survived", "id", boss.ID, "tribute", paid)
+}
+
+// worldBossTreasureZone maps the boss tier to a representative zone whose treasure
+// table the defeat roll draws from. "" if no zone of that tier exists.
+func worldBossTreasureZone(tier int) ZoneID {
+	zs := zonesByTier(ZoneTier(tier))
+	if len(zs) == 0 {
+		return ""
+	}
+	return zs[0].ID
+}
+
+// ── Announcements (games room) ───────────────────────────────────────────────
+
+// announceWorldBoss posts to the shared games room. No-op if GAMES_ROOM is unset.
+func (p *AdventurePlugin) announceWorldBoss(text string) {
+	gr := gamesRoom()
+	if gr == "" {
+		return
+	}
+	if err := p.SendMessage(gr, text); err != nil {
+		slog.Warn("worldboss: games-room announce failed", "err", err)
+	}
+}
+
+func (p *AdventurePlugin) announceWorldBossSpawn(boss *worldBossState, activeN int) {
+	p.announceWorldBoss(fmt.Sprintf(
+		"⚔️ **The Siege has begun!** **%s** (Tier %d) camps outside town with **%s HP**.\n"+
+			"Everyone gets **one bout per day** for the next 72 hours — `!adventure worldboss fight`. "+
+			"Every hit chips the shared pool. Fell it together for a bounty; let it stand and it loots the town.",
+		boss.Name, boss.Tier, groupInt(boss.HPMax)))
+}
+
+func (p *AdventurePlugin) announceWorldBossDefeated(boss *worldBossState, payouts []worldBossPayout) {
+	var top string
+	if len(payouts) > 0 {
+		top = fmt.Sprintf(" Top of the muster: %s (%d fights).",
+			p.DisplayName(payouts[0].UserID), payouts[0].Fights)
+	}
+	p.announceWorldBoss(fmt.Sprintf(
+		"🏆 **%s has fallen!** %d adventurer(s) brought it down.%s\n"+
+			"Bounties, supply caches, and salvage have been paid out to everyone who fought.",
+		boss.Name, len(payouts), top))
+}
+
+func (p *AdventurePlugin) announceWorldBossSurvived(boss *worldBossState, tribute int) {
+	msg := fmt.Sprintf("💀 **%s still stands.** The Siege is over — the town could not bring it down.", boss.Name)
+	if tribute > 0 {
+		msg += fmt.Sprintf(" It loots **€%s** from the community pot on its way out.", groupInt(tribute))
+	}
+	p.announceWorldBoss(msg)
+}
+
+// ── Player command (W2) ──────────────────────────────────────────────────────
+
+// handleWorldBossCmd routes `!adventure worldboss [status|fight|spawn]` (alias
+// `!adventure siege …`). Bare / "status" shows the board; "fight" takes today's
+// bout; "spawn" is an operator override.
+func (p *AdventurePlugin) handleWorldBossCmd(ctx MessageContext, args string) error {
+	switch strings.ToLower(strings.TrimSpace(args)) {
+	case "", "status":
+		return p.worldBossStatusDM(ctx)
+	case "fight":
+		return p.fightWorldBoss(ctx)
+	case "spawn":
+		return p.worldBossOperatorSpawn(ctx)
+	}
+	return p.SendDM(ctx.Sender, "Usage: `!adventure worldboss [status|fight]`")
+}
+
+// worldBossOperatorSpawn lets an admin start a Siege on demand (the override half
+// of the "both" spawn decision). Silent to non-admins, like the other admin
+// commands.
+func (p *AdventurePlugin) worldBossOperatorSpawn(ctx MessageContext) error {
+	if !p.IsAdmin(ctx.Sender) {
+		return nil
+	}
+	key := "manual-" + time.Now().UTC().Format("2006-01-02T15:04")
+	boss, err := p.spawnWorldBoss(key)
+	if err != nil {
+		return p.SendDM(ctx.Sender, fmt.Sprintf("Could not spawn the Siege: %v", err))
+	}
+	return p.SendDM(ctx.Sender, fmt.Sprintf(
+		"Spawned **%s** (Tier %d, %s HP). It camps for 72 hours.",
+		boss.Name, boss.Tier, groupInt(boss.HPMax)))
+}
+
+// fightWorldBoss runs one player's daily bout against the Siege: an arena-style
+// solo fight whose damage is subtracted from the shared pool win or lose. Real
+// HP cost, no death — a loss leaves the fighter battered (floored at 1 HP) but
+// standing. The per-user lock serialises a player's own repeat submits, so the
+// once-per-day gate can't be raced by a double-tap.
+func (p *AdventurePlugin) fightWorldBoss(ctx MessageContext) error {
+	userMu := p.advUserLock(ctx.Sender)
+	userMu.Lock()
+	defer userMu.Unlock()
+
+	boss, err := loadActiveWorldBoss()
+	if err != nil {
+		return p.SendDM(ctx.Sender, "Something went wrong reaching the Siege. Try again in a moment.")
+	}
+	if boss == nil {
+		return p.SendDM(ctx.Sender, "No Siege is camped outside town right now.")
+	}
+
+	char, err := loadAdvCharacter(ctx.Sender)
+	if err != nil || char == nil {
+		return p.SendDM(ctx.Sender, "You need an adventurer first — type `!adventure` to begin.")
+	}
+	if !char.Alive {
+		return p.SendDM(ctx.Sender, "You're dead. The Siege will have to wait until you're back on your feet.")
+	}
+
+	today := time.Now().UTC().Format("2006-01-02")
+	if worldBossBoutUsedToday(boss.ID, ctx.Sender, today) {
+		return p.SendDM(ctx.Sender, fmt.Sprintf(
+			"You've already taken your bout against **%s** today. Come back tomorrow — one fight per day.", boss.Name))
+	}
+
+	bout, err := p.resolveWorldBossBout(ctx.Sender, boss, today)
+	if err != nil {
+		slog.Error("worldboss: bout failed", "user", ctx.Sender, "err", err)
+		return p.SendDM(ctx.Sender, "The Siege combat hit an error. Try again in a moment.")
+	}
+
+	// Resolve a defeat BEFORE streaming the (multi-second) narration. The pool is
+	// already committed to 0; flipping the status now closes the window where a
+	// crash or the ticker's survive path could resolve a killed boss as a
+	// survival and debit the pot instead of paying bounties.
+	if bout.Killed {
+		p.resolveWorldBossDefeated(boss)
+	}
+
+	playerName, _ := loadDisplayName(ctx.Sender)
+	if playerName == "" {
+		playerName = "You"
+	}
+	phaseMessages := append([]string{
+		fmt.Sprintf("⚔️ **The Siege — %s** (Tier %d)", boss.Name, boss.Tier),
+	}, RenderCombatLog(bout.Combat, playerName, boss.Name)...)
+
+	var footer string
+	if bout.Killed {
+		footer = fmt.Sprintf("💥 You deal **%d** damage — the killing blow! **%s** falls!", bout.Damage, boss.Name)
+	} else {
+		footer = fmt.Sprintf("💥 You deal **%d** damage. **%s** has **%s / %s HP** left.",
+			bout.Damage, boss.Name, groupInt(bout.Remaining), groupInt(boss.HPMax))
+	}
+	if bout.Battered {
+		footer += "\nYou stagger out of the fight at 1 HP — rest up before your next outing."
+	}
+
+	<-p.sendZoneCombatMessages(ctx.Sender, phaseMessages, footer)
+	return nil
+}
+
+// worldBossBoutUsedToday reports whether a player has already spent their daily
+// bout against this boss.
+func worldBossBoutUsedToday(bossID int64, userID id.UserID, dateKey string) bool {
+	c, err := loadWorldBossContrib(bossID, userID)
+	return err == nil && c != nil && c.LastFightDate == dateKey
+}
+
+// worldBossBoutResult is the outcome of one resolved bout, before narration.
+type worldBossBoutResult struct {
+	Damage    int
+	Remaining int
+	Killed    bool
+	Battered  bool
+	Combat    CombatResult
+}
+
+// resolveWorldBossBout runs the arena-style fight, applies the real HP cost with
+// the no-death floor, subtracts the damage dealt from the shared pool, and
+// records the contribution. It performs no DM or games-room I/O, so it is the
+// testable core of fightWorldBoss.
+func (p *AdventurePlugin) resolveWorldBossBout(userID id.UserID, boss *worldBossState, dateKey string) (worldBossBoutResult, error) {
+	monster := worldBossTemplate(boss.Name, boss.Tier)
+	result, err := p.runZoneCombat(userID, monster, boss.Tier, bossCombatPhases, 50)
+	if err != nil {
+		return worldBossBoutResult{}, err
+	}
+
+	// No death / no hospital: floor the fighter at 1 HP so a loss never reads as
+	// a corpse. runZoneCombat already persisted the real HP cost.
+	battered := worldBossFloorHP(userID)
+
+	dmg := result.EnemyEntryHP - result.EnemyEndHP
+	if dmg < 0 {
+		dmg = 0
+	}
+	// Record the contribution (which also sets the once-per-day gate) BEFORE
+	// draining the shared pool. If this write fails we must not have already
+	// drained the pool — otherwise the player could refight a pool they emptied
+	// and lose the credit for it. A hard error here aborts the bout; the HP cost
+	// was already paid, but the pool is untouched and the player can retry.
+	if err := upsertWorldBossContrib(boss.ID, userID, dmg, dateKey); err != nil {
+		return worldBossBoutResult{}, err
+	}
+	remaining, killed, err := applyWorldBossDamage(boss.ID, dmg)
+	if err != nil {
+		return worldBossBoutResult{}, err
+	}
+	return worldBossBoutResult{
+		Damage: dmg, Remaining: remaining, Killed: killed, Battered: battered, Combat: result,
+	}, nil
+}
+
+// worldBossFloorHP raises a player to 1 HP if the bout left them at zero, and
+// reports whether it had to. Keeps "no death" honest without undoing the real
+// HP cost of a bout the player mostly survived.
+func worldBossFloorHP(userID id.UserID) bool {
+	cur, _ := dndHPSnapshot(userID)
+	if cur > 0 {
+		return false
+	}
+	if _, err := db.Get().Exec(
+		`UPDATE dnd_character SET hp_current = 1, updated_at = CURRENT_TIMESTAMP WHERE user_id = ?`,
+		string(userID)); err != nil {
+		slog.Warn("worldboss: hp floor failed", "user", userID, "err", err)
+	}
+	return true
+}
+
+// worldBossStatusDM renders the current Siege board to the caller.
+func (p *AdventurePlugin) worldBossStatusDM(ctx MessageContext) error {
+	boss, err := loadActiveWorldBoss()
+	if err != nil {
+		return p.SendDM(ctx.Sender, "Something went wrong reaching the Siege. Try again in a moment.")
+	}
+	if boss == nil {
+		return p.SendDM(ctx.Sender,
+			"No Siege is camped outside town right now. The next one arrives at the start of the month.")
+	}
+
+	var sb strings.Builder
+	pct := 0
+	if boss.HPMax > 0 {
+		pct = boss.HPCurrent * 100 / boss.HPMax
+	}
+	fmt.Fprintf(&sb, "⚔️ **The Siege — %s** (Tier %d)\n", boss.Name, boss.Tier)
+	fmt.Fprintf(&sb, "Pool: **%s / %s HP** (%d%%)\n", groupInt(boss.HPCurrent), groupInt(boss.HPMax), pct)
+	if left := time.Until(boss.EndsAt); left > 0 {
+		h := int(left.Hours())
+		m := int(left.Minutes()) % 60
+		fmt.Fprintf(&sb, "Time left: **%dh %dm**\n", h, m)
+	}
+
+	today := time.Now().UTC().Format("2006-01-02")
+	if c, _ := loadWorldBossContrib(boss.ID, ctx.Sender); c != nil {
+		line := fmt.Sprintf("\nYou: %d fight(s), %s damage dealt.", c.Fights, groupInt(c.Damage))
+		if c.LastFightDate == today {
+			line += " Your bout is spent for today."
+		} else {
+			line += " Your bout is ready — `!adventure worldboss fight`."
+		}
+		sb.WriteString(line + "\n")
+	} else {
+		sb.WriteString("\nYou haven't fought yet — `!adventure worldboss fight`.\n")
+	}
+
+	if contribs, _ := loadWorldBossContribs(boss.ID); len(contribs) > 0 {
+		sb.WriteString("\n**Top of the muster:**\n")
+		for i, c := range contribs {
+			if i >= 5 {
+				break
+			}
+			fmt.Fprintf(&sb, "%d. %s — %d fight(s)\n", i+1, p.DisplayName(c.UserID), c.Fights)
+		}
+	}
+	return p.SendDM(ctx.Sender, sb.String())
+}

internal/plugin/adventure_worldboss_test.go

@@ -0,0 +1,417 @@
+package plugin
+
+import (
+	"testing"
+	"time"
+
+	"gogobee/internal/db"
+
+	"maunium.net/go/mautrix/id"
+)
+
+func newWorldBossTestDB(t *testing.T) {
+	t.Helper()
+	dir := t.TempDir()
+	db.Close()
+	if err := db.Init(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(db.Close)
+}
+
+func TestWorldBossName_DeterministicAndInPool(t *testing.T) {
+	first := worldBossNameFor("2026-07")
+	if again := worldBossNameFor("2026-07"); again != first {
+		t.Errorf("name not deterministic: %q vs %q", first, again)
+	}
+	inPool := false
+	for _, n := range worldBossNames {
+		if n == first {
+			inPool = true
+			break
+		}
+	}
+	if !inPool {
+		t.Errorf("generated name %q not in worldBossNames pool", first)
+	}
+}
+
+func TestMedianInt(t *testing.T) {
+	cases := []struct {
+		in   []int
+		want int
+	}{
+		{nil, 0},
+		{[]int{5}, 5},
+		{[]int{3, 1, 2}, 2},         // odd, unsorted
+		{[]int{4, 2, 8, 6}, 5},      // even → mean of the two middles (4,6)
+		{[]int{10, 10, 10, 10}, 10}, // even, all equal
+	}
+	for _, c := range cases {
+		if got := medianInt(c.in); got != c.want {
+			t.Errorf("medianInt(%v) = %d, want %d", c.in, got, c.want)
+		}
+	}
+}
+
+func TestTierForCombinedLevel(t *testing.T) {
+	cases := []struct{ level, want int }{
+		{0, worldBossMinTier},
+		{11, worldBossMinTier},
+		{12, 4},
+		{20, 4},
+		{21, 5},
+		{99, 5},
+	}
+	for _, c := range cases {
+		if got := tierForCombinedLevel(c.level); got != c.want {
+			t.Errorf("tierForCombinedLevel(%d) = %d, want %d", c.level, got, c.want)
+		}
+	}
+}
+
+func TestWorldBoss_InsertLoadRoundTrip(t *testing.T) {
+	newWorldBossTestDB(t)
+	now := time.Now().UTC().Truncate(time.Second)
+	id0, err := insertWorldBoss("Gorloth", 5, 2400, now, now.Add(worldBossWindow))
+	if err != nil {
+		t.Fatal(err)
+	}
+	active, err := loadActiveWorldBoss()
+	if err != nil || active == nil {
+		t.Fatalf("loadActiveWorldBoss: %v (nil=%v)", err, active == nil)
+	}
+	if active.ID != id0 || active.Name != "Gorloth" || active.Tier != 5 ||
+		active.HPMax != 2400 || active.HPCurrent != 2400 || active.Status != "active" {
+		t.Errorf("round-trip mismatch: %+v", active)
+	}
+}
+
+func TestApplyWorldBossDamage_ClampsAndFells(t *testing.T) {
+	newWorldBossTestDB(t)
+	now := time.Now().UTC()
+	bossID, err := insertWorldBoss("Kravok", 3, 100, now, now.Add(worldBossWindow))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	rem, killed, err := applyWorldBossDamage(bossID, 40)
+	if err != nil || rem != 60 || killed {
+		t.Fatalf("first hit: rem=%d killed=%v err=%v (want 60,false)", rem, killed, err)
+	}
+
+	// Overkill clamps at 0 and reports the fell.
+	rem, killed, err = applyWorldBossDamage(bossID, 999)
+	if err != nil || rem != 0 || !killed {
+		t.Fatalf("overkill: rem=%d killed=%v err=%v (want 0,true)", rem, killed, err)
+	}
+
+	// Negative damage is treated as zero.
+	if rem, _, err := applyWorldBossDamage(bossID, -5); err != nil || rem != 0 {
+		t.Fatalf("negative: rem=%d err=%v", rem, err)
+	}
+}
+
+func TestSetWorldBossStatus_ResolvesOnce(t *testing.T) {
+	newWorldBossTestDB(t)
+	now := time.Now().UTC()
+	bossID, err := insertWorldBoss("Ymirok", 4, 500, now, now.Add(worldBossWindow))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ok, err := setWorldBossStatus(bossID, "defeated"); err != nil || !ok {
+		t.Fatalf("first close-out: ok=%v err=%v (want true)", ok, err)
+	}
+	// A second close-out is a no-op — the boss is no longer active.
+	if ok, err := setWorldBossStatus(bossID, "survived"); err != nil || ok {
+		t.Fatalf("double close-out: ok=%v err=%v (want false)", ok, err)
+	}
+	// And damage no longer lands on a resolved boss.
+	if rem, killed, _ := applyWorldBossDamage(bossID, 500); rem != 500 || killed {
+		t.Errorf("damage on resolved boss changed pool: rem=%d killed=%v", rem, killed)
+	}
+}
+
+func TestWorldBossContrib_UpsertAccumulates(t *testing.T) {
+	newWorldBossTestDB(t)
+	user := id.UserID("@a:test.invalid")
+	if err := upsertWorldBossContrib(1, user, 30, "2026-07-01"); err != nil {
+		t.Fatal(err)
+	}
+	if err := upsertWorldBossContrib(1, user, 45, "2026-07-02"); err != nil {
+		t.Fatal(err)
+	}
+	c, err := loadWorldBossContrib(1, user)
+	if err != nil || c == nil {
+		t.Fatalf("load: %v (nil=%v)", err, c == nil)
+	}
+	if c.Fights != 2 || c.Damage != 75 || c.LastFightDate != "2026-07-02" {
+		t.Errorf("accumulate mismatch: %+v", c)
+	}
+}
+
+func TestLoadWorldBossContribs_OrderedByFights(t *testing.T) {
+	newWorldBossTestDB(t)
+	a := id.UserID("@a:test.invalid")
+	b := id.UserID("@b:test.invalid")
+	// a: 1 fight; b: 2 fights → b sorts first.
+	upsertWorldBossContrib(7, a, 100, "2026-07-01")
+	upsertWorldBossContrib(7, b, 10, "2026-07-01")
+	upsertWorldBossContrib(7, b, 10, "2026-07-02")
+	got, err := loadWorldBossContribs(7)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 2 || got[0].UserID != b || got[1].UserID != a {
+		t.Errorf("order = %+v, want b then a", got)
+	}
+}
+
+func TestComputeWorldBossPayouts_ScalesByFights(t *testing.T) {
+	contribs := []worldBossContrib{
+		{UserID: "@a:t", Fights: 3, Damage: 999},
+		{UserID: "@b:t", Fights: 1, Damage: 10},
+		{UserID: "@c:t", Fights: 0, Damage: 0}, // no fights → no payout
+	}
+	pays := computeWorldBossPayouts(contribs, 1000)
+	if len(pays) != 2 {
+		t.Fatalf("got %d payouts, want 2 (zero-fight excluded)", len(pays))
+	}
+	if pays[0].Euro != 3000 || pays[1].Euro != 1000 {
+		t.Errorf("payouts = %d,%d want 3000,1000", pays[0].Euro, pays[1].Euro)
+	}
+}
+
+// TestWorldBossSpawnPlan_SizesToActiveTown seeds three active max-level players
+// and checks the boss is T5 with a pool scaled to the turnout.
+func TestWorldBossSpawnPlan_SizesToActiveTown(t *testing.T) {
+	newWorldBossTestDB(t)
+	today := time.Now().UTC().Format("2006-01-02")
+	for _, u := range []string{"@a:test.invalid", "@b:test.invalid", "@c:test.invalid"} {
+		c := &AdventureCharacter{UserID: id.UserID(u), DisplayName: "P", Alive: true,
+			ForagingSkill: 30, CreatedAt: time.Now().UTC()}
+		if err := saveAdvCharacter(c); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := db.Get().Exec(
+			`INSERT INTO daily_activity (user_id, date, message_count) VALUES (?, ?, 1)`,
+			u, today); err != nil {
+			t.Fatal(err)
+		}
+	}
+	tier, hpMax, activeN := worldBossSpawnPlan()
+	if activeN != 3 {
+		t.Errorf("activeN = %d, want 3", activeN)
+	}
+	if tier != 5 {
+		t.Errorf("tier = %d, want 5 (combined >= 21)", tier)
+	}
+	// bouts = 3 × 2.0 = 6; perBout at T5 = 400 → pool 2400.
+	perBout, _, _, _, _ := arenaTierBaseStats(5)
+	if want := perBout * 6; hpMax != want {
+		t.Errorf("hpMax = %d, want %d", hpMax, want)
+	}
+}
+
+// TestWorldBossSpawnPlan_EmptyTownGetsFloorBoss: no active players still yields a
+// beatable floor boss so a manual spawn works.
+func TestWorldBossSpawnPlan_EmptyTownGetsFloorBoss(t *testing.T) {
+	newWorldBossTestDB(t)
+	tier, hpMax, activeN := worldBossSpawnPlan()
+	if activeN != 0 {
+		t.Errorf("activeN = %d, want 0", activeN)
+	}
+	if tier != worldBossMinTier {
+		t.Errorf("tier = %d, want floor %d", tier, worldBossMinTier)
+	}
+	perBout, _, _, _, _ := arenaTierBaseStats(worldBossMinTier)
+	if want := perBout * worldBossMinBouts; hpMax != want {
+		t.Errorf("hpMax = %d, want %d (min bouts floor)", hpMax, want)
+	}
+}
+
+func TestSpawnWorldBoss_RefusesWhenOneIsActive(t *testing.T) {
+	newWorldBossTestDB(t)
+	p := &AdventurePlugin{}
+	first, err := p.spawnWorldBoss("2026-07")
+	if err != nil || first == nil {
+		t.Fatalf("first spawn: %v (nil=%v)", err, first == nil)
+	}
+	second, err := p.spawnWorldBoss("2026-07")
+	if err == nil {
+		t.Error("second spawn should refuse while one is active")
+	}
+	if second == nil || second.ID != first.ID {
+		t.Error("refusal should return the existing active boss")
+	}
+}
+
+// TestResolveWorldBossSurvived_DebitsPot exercises the survive path end to end:
+// the boss closes out and the pot loses its tribute.
+func TestResolveWorldBossSurvived_DebitsPot(t *testing.T) {
+	newWorldBossTestDB(t)
+	communityPotAdd(1000)
+	now := time.Now().UTC()
+	bossID, err := insertWorldBoss("Vornath", 5, 2400, now.Add(-worldBossWindow), now.Add(-time.Hour))
+	if err != nil {
+		t.Fatal(err)
+	}
+	boss, _ := loadWorldBoss(bossID)
+	p := &AdventurePlugin{}
+	p.resolveWorldBossSurvived(boss)
+
+	after, _ := loadWorldBoss(bossID)
+	if after.Status != "survived" {
+		t.Errorf("status = %q, want survived", after.Status)
+	}
+	// tribute = 20% of 1000 = 200 → pot left with 800.
+	if bal := communityPotBalance(); bal != 800 {
+		t.Errorf("pot = %d, want 800 after 20%% tribute", bal)
+	}
+}
+
+// ── W2: the bout ─────────────────────────────────────────────────────────────
+
+func fightableChar(t *testing.T, uid id.UserID) {
+	t.Helper()
+	if err := createAdvCharacter(uid, "boxer"); err != nil {
+		t.Fatalf("createAdvCharacter: %v", err)
+	}
+	c := &DnDCharacter{
+		UserID: uid, Race: RaceHuman, Class: ClassFighter, Level: 12,
+		STR: 18, DEX: 14, CON: 16, INT: 10, WIS: 10, CHA: 10,
+		HPMax: 120, HPCurrent: 120, ArmorClass: 18,
+	}
+	if err := SaveDnDCharacter(c); err != nil {
+		t.Fatalf("SaveDnDCharacter: %v", err)
+	}
+}
+
+func TestWorldBossFloorHP(t *testing.T) {
+	newWorldBossTestDB(t)
+	uid := id.UserID("@floor:test.invalid")
+	fightableChar(t, uid)
+	if worldBossFloorHP(uid) {
+		t.Error("floor should be a no-op above 0 HP")
+	}
+	if _, err := db.Get().Exec(`UPDATE dnd_character SET hp_current = 0 WHERE user_id = ?`, string(uid)); err != nil {
+		t.Fatal(err)
+	}
+	if !worldBossFloorHP(uid) {
+		t.Error("floor should raise a 0-HP fighter")
+	}
+	if cur, _ := dndHPSnapshot(uid); cur != 1 {
+		t.Errorf("hp after floor = %d, want 1", cur)
+	}
+}
+
+func TestResolveWorldBossBout_SubtractsAndRecords(t *testing.T) {
+	newWorldBossTestDB(t)
+	uid := id.UserID("@bout:test.invalid")
+	fightableChar(t, uid)
+	now := time.Now().UTC()
+	// Big pool so one bout can only chip it — assert the partial subtract + contrib.
+	bossID, err := insertWorldBoss("Kravok", 3, 100000, now, now.Add(worldBossWindow))
+	if err != nil {
+		t.Fatal(err)
+	}
+	boss, _ := loadWorldBoss(bossID)
+	p := &AdventurePlugin{}
+	bout, err := p.resolveWorldBossBout(uid, boss, "2026-07-05")
+	if err != nil {
+		t.Fatalf("bout: %v", err)
+	}
+	if bout.Damage < 0 {
+		t.Errorf("damage negative: %d", bout.Damage)
+	}
+	if bout.Killed {
+		t.Error("a 100k pool should survive one bout")
+	}
+	if bout.Remaining != 100000-bout.Damage {
+		t.Errorf("remaining %d != max-dmg %d", bout.Remaining, 100000-bout.Damage)
+	}
+	c, _ := loadWorldBossContrib(bossID, uid)
+	if c == nil || c.Fights != 1 || c.Damage != bout.Damage || c.LastFightDate != "2026-07-05" {
+		t.Errorf("contrib mismatch: %+v (bout dmg %d)", c, bout.Damage)
+	}
+	if !worldBossBoutUsedToday(bossID, uid, "2026-07-05") {
+		t.Error("bout should read as used for that day")
+	}
+	if worldBossBoutUsedToday(bossID, uid, "2026-07-06") {
+		t.Error("a different day should still be available")
+	}
+}
+
+func TestResolveWorldBossBout_FellsTinyPool(t *testing.T) {
+	newWorldBossTestDB(t)
+	uid := id.UserID("@kill:test.invalid")
+	fightableChar(t, uid)
+	now := time.Now().UTC()
+	bossID, err := insertWorldBoss("Wisp", 3, 1, now, now.Add(worldBossWindow))
+	if err != nil {
+		t.Fatal(err)
+	}
+	boss, _ := loadWorldBoss(bossID)
+	p := &AdventurePlugin{}
+	bout, err := p.resolveWorldBossBout(uid, boss, "2026-07-05")
+	if err != nil {
+		t.Fatalf("bout: %v", err)
+	}
+	// A L12 fighter lands at least one blow on a T3 dummy over a full boss fight,
+	// felling a 1-HP pool.
+	if !bout.Killed || bout.Remaining != 0 {
+		t.Errorf("tiny pool not felled: killed=%v remaining=%d dmg=%d", bout.Killed, bout.Remaining, bout.Damage)
+	}
+	// Resolution is the caller's job — the bout leaves the boss active.
+	after, _ := loadWorldBoss(bossID)
+	if after.Status != "active" {
+		t.Errorf("bout should not self-resolve; status=%q", after.Status)
+	}
+}
+
+// TestWorldBossTick_ResolvesZeroHPBossAsDefeated: a killing blow that committed
+// the pool to 0 but (crash/redeploy) never resolved the status must be resolved
+// as DEFEATED by the ticker net — never fall through to the survive/pot-debit
+// path. No contributors here, so resolution never touches euro.
+func TestWorldBossTick_ResolvesZeroHPBossAsDefeated(t *testing.T) {
+	newWorldBossTestDB(t)
+	now := time.Now().UTC()
+	communityPotAdd(1000)
+	bossID, err := insertWorldBoss("Ghost", 3, 100, now, now.Add(worldBossWindow))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Get().Exec(`UPDATE world_boss SET hp_current = 0 WHERE id = ?`, bossID); err != nil {
+		t.Fatal(err)
+	}
+	p := &AdventurePlugin{}
+	p.worldBossTick()
+	after, _ := loadWorldBoss(bossID)
+	if after.Status != "defeated" {
+		t.Errorf("status = %q, want defeated (ticker safety net)", after.Status)
+	}
+	if bal := communityPotBalance(); bal != 1000 {
+		t.Errorf("pot = %d, want 1000 — a defeat mints, it must not debit the pot", bal)
+	}
+}
+
+// TestWorldBossTick_ResolvesLapsedBossAsSurvived: a boss whose window lapsed with
+// the pool still up survives and loots the pot.
+func TestWorldBossTick_ResolvesLapsedBossAsSurvived(t *testing.T) {
+	newWorldBossTestDB(t)
+	now := time.Now().UTC()
+	communityPotAdd(1000)
+	bossID, err := insertWorldBoss("Titan", 4, 500, now.Add(-worldBossWindow), now.Add(-time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+	p := &AdventurePlugin{}
+	p.worldBossTick()
+	after, _ := loadWorldBoss(bossID)
+	if after.Status != "survived" {
+		t.Errorf("status = %q, want survived", after.Status)
+	}
+	if bal := communityPotBalance(); bal != 800 {
+		t.Errorf("pot = %d, want 800 after 20%% tribute", bal)
+	}
+}

internal/plugin/anime.go

@@ -20,15 +20,15 @@ import (
 
 // jikanAnime represents an anime entry from the Jikan API.
 type jikanAnime struct {
-	MalID    int    `json:"mal_id"`
-	URL      string `json:"url"`
-	Title    string `json:"title"`
-	TitleEng string `json:"title_english"`
-	Type     string `json:"type"`
-	Episodes int    `json:"episodes"`
-	Status   string `json:"status"`
+	MalID    int     `json:"mal_id"`
+	URL      string  `json:"url"`
+	Title    string  `json:"title"`
+	TitleEng string  `json:"title_english"`
+	Type     string  `json:"type"`
+	Episodes int     `json:"episodes"`
+	Status   string  `json:"status"`
 	Score    float64 `json:"score"`
-	Synopsis string `json:"synopsis"`
+	Synopsis string  `json:"synopsis"`
 	Aired    struct {
 		String string `json:"string"`
 		From   string `json:"from"`

internal/plugin/archetype.go

@@ -29,51 +29,51 @@ const (
 	thLinkmasterMinMsgs     = 50
 
 	// Temporal
-	thNightOwlPct     = 40
-	thNightOwlMinMsgs = 100
-	thEarlyBirdPct    = 40
+	thNightOwlPct      = 40
+	thNightOwlMinMsgs  = 100
+	thEarlyBirdPct     = 40
 	thEarlyBirdMinMsgs = 100
 
 	// Emotional (LLM-gated)
-	thEmotionalMinClassified    = 100
-	thCheerleaderPosPct         = 50
-	thPhilosopherNeutPct        = 40
-	thPhilosopherQPct           = 10
-	thPhilosopherAvgWords       = 8
-	thAgitatorNegPct            = 30
-	thAgitatorMinMsgs           = 200
-	thWildcardStdDev            = 0.5
-	thWildcardMinClassified     = 150
-	thHypeMachineExclPct        = 20
-	thHypeMachinePosPct         = 60
+	thEmotionalMinClassified = 100
+	thCheerleaderPosPct      = 50
+	thPhilosopherNeutPct     = 40
+	thPhilosopherQPct        = 10
+	thPhilosopherAvgWords    = 8
+	thAgitatorNegPct         = 30
+	thAgitatorMinMsgs        = 200
+	thWildcardStdDev         = 0.5
+	thWildcardMinClassified  = 150
+	thHypeMachineExclPct     = 20
+	thHypeMachinePosPct      = 60
 
 	// Economy
 	thBrokeSpiritedMaxBalance = 100.0
 	thDegenerateMinLosses     = 10
 
 	// Games
-	thSharkWinRate           = 55
-	thSharkMinGames          = 15
-	thWordleMinPuzzles       = 10
-	thArenaChampMinTier      = 4
-	thArenaChampWinRate      = 50
-	thArenaCowardMinRuns     = 3
-	thArenaCowardMaxAvgTier  = 2
-	thTriviaNerdMinCorrect   = 10
+	thSharkWinRate          = 55
+	thSharkMinGames         = 15
+	thWordleMinPuzzles      = 10
+	thArenaChampMinTier     = 4
+	thArenaChampWinRate     = 50
+	thArenaCowardMinRuns    = 3
+	thArenaCowardMaxAvgTier = 2
+	thTriviaNerdMinCorrect  = 10
 
 	// Adventure
-	thAdvMinDays           = 10
-	thAdvDiverseMinDays    = 15
-	thAdvDiverseMinTypes   = 3
-	thAdvDiverseMaxShare   = 40
+	thAdvMinDays            = 10
+	thAdvDiverseMinDays     = 15
+	thAdvDiverseMinTypes    = 3
+	thAdvDiverseMaxShare    = 40
 	thGearheadMinMasterwork = 3
 
 	// Communication (vocabulary)
 	thWordsmithMinFancyWords = 10
 
 	// Social
-	thPatronMinRepGiven      = 5
-	thPatronRatioMultiplier  = 2
+	thPatronMinRepGiven     = 5
+	thPatronRatioMultiplier = 2
 
 	// Display
 	maxDisplayArchetypes = 6
@@ -83,13 +83,13 @@ const (
 
 var archetypeFlavors = map[string]string{
 	// Communication
-	"Novelist":    "Writes in paragraphs. Has opinions. Probably re-reads their own messages.",
-	"Minimalist":  "Says a lot with very little. You're never sure if they're fine or not.",
-	"Inquisitor":  "Always asking. Never satisfied with the first answer. Probably has follow-ups.",
-	"Enthusiast":  "Genuinely excited about things. All the things. Possibly all at once.",
-	"Chatterbox":  "Has thoughts. Many thoughts. Shares them all. You wouldn't have it any other way.",
-	"Linkmaster":  "The community's unofficial curator. Their tab count is not your business.",
-	"Wordsmith":   "Uses words most people have to look up. The thesaurus fears them.",
+	"Novelist":   "Writes in paragraphs. Has opinions. Probably re-reads their own messages.",
+	"Minimalist": "Says a lot with very little. You're never sure if they're fine or not.",
+	"Inquisitor": "Always asking. Never satisfied with the first answer. Probably has follow-ups.",
+	"Enthusiast": "Genuinely excited about things. All the things. Possibly all at once.",
+	"Chatterbox": "Has thoughts. Many thoughts. Shares them all. You wouldn't have it any other way.",
+	"Linkmaster": "The community's unofficial curator. Their tab count is not your business.",
+	"Wordsmith":  "Uses words most people have to look up. The thesaurus fears them.",
 
 	// Temporal
 	"Night Owl":  "Awake when they probably shouldn't be. Thriving despite all evidence.",
@@ -103,8 +103,8 @@ var archetypeFlavors = map[string]string{
 	"Hype Machine": "Arrived and immediately made everything louder. The room is better for it.",
 
 	// Economy
-	"Whale":             "Has money. Spends money. Has more money somehow. The math is unclear.",
-	"Degenerate":        "Knows exactly what they're doing. Does it anyway. Respects it.",
+	"Whale":              "Has money. Spends money. Has more money somehow. The math is unclear.",
+	"Degenerate":         "Knows exactly what they're doing. Does it anyway. Respects it.",
 	"Broke But Spirited": "Down but not out. The pot fears them anyway.",
 
 	// Games
@@ -221,16 +221,16 @@ type userData struct {
 	userID string
 
 	// user_stats
-	totalMsgs    int
-	totalWords   int
-	totalLinks   int
-	totalImages  int
+	totalMsgs      int
+	totalWords     int
+	totalLinks     int
+	totalImages    int
 	totalQuestions int
-	totalExcl    int
-	totalEmojis  int
-	nightMsgs    int
-	morningMsgs  int
-	fancyWords   int
+	totalExcl      int
+	totalEmojis    int
+	nightMsgs      int
+	morningMsgs    int
+	fancyWords     int
 
 	// sentiment_stats
 	sentPositive int
@@ -242,7 +242,7 @@ type userData struct {
 	sentVariance    float64
 
 	// economy
-	balance       float64
+	balance        float64
 	gamblingLosses int
 	recentGaming   bool
 
@@ -251,7 +251,7 @@ type userData struct {
 	hmPlayed, hmWon             int
 	holdemPlayed                int
 	holdemNetPositive           bool
-	unoSoloPlayed, unoSoloWon  int
+	unoSoloPlayed, unoSoloWon   int
 	unoMultiPlayed, unoMultiWon int
 	wordlePlayed                int
 	triviaCorrect               int
@@ -263,13 +263,13 @@ type userData struct {
 	arenaAvgCashTier float64
 
 	// adventure
-	advDays       int
-	advActivities map[string]int // activity_type -> count
+	advDays         int
+	advActivities   map[string]int // activity_type -> count
 	masterworkCount int
 
 	// social
-	repGiven     int
-	repReceived  int
+	repGiven       int
+	repReceived    int
 	reactionsGiven int
 }
 

internal/plugin/bestiary_srd.go

@@ -83,18 +83,19 @@ var srdProfiles = map[string]SRDProfile{
 		{Name: "Scourge", AttackBonus: 9, Damage: 13},
 		{Name: "Scourge", AttackBonus: 9, Damage: 12},
 	}},
-	"boss_thornmother": {Attacks: []SRDAttack{ // Attack 18 → ~23
-		{Name: "Thorned Lash", AttackBonus: 8, Damage: 12},
-		{Name: "Thorned Lash", AttackBonus: 8, Damage: 11},
+	"boss_thornmother": {Attacks: []SRDAttack{ // D8-f #2: 2→3 lashes, ~23→~36 (faceroll → band)
+		{Name: "Thorned Lash", AttackBonus: 9, Damage: 13},
+		{Name: "Thorned Lash", AttackBonus: 9, Damage: 12},
+		{Name: "Thorned Lash", AttackBonus: 9, Damage: 11},
 	}},
-	"boss_infernax": {Attacks: []SRDAttack{ // Attack 38 → ~49
-		{Name: "Bite", AttackBonus: 11, Damage: 19},
-		{Name: "Claw", AttackBonus: 11, Damage: 15},
-		{Name: "Claw", AttackBonus: 11, Damage: 15},
+	"boss_infernax": {Attacks: []SRDAttack{ // D11 T5 lift: 49 → ~42 (nerf; was an impossible wall at L15-16)
+		{Name: "Bite", AttackBonus: 11, Damage: 16},
+		{Name: "Claw", AttackBonus: 11, Damage: 13},
+		{Name: "Claw", AttackBonus: 11, Damage: 13},
 	}},
-	"boss_belaxath": {Attacks: []SRDAttack{ // Attack 31 → ~40
+	"boss_belaxath": {Attacks: []SRDAttack{ // D11 T5 lift: 40 → ~41 (buff; was a leader faceroll)
 		{Name: "Longsword", AttackBonus: 11, Damage: 24},
-		{Name: "Whip", AttackBonus: 11, Damage: 16},
+		{Name: "Whip", AttackBonus: 11, Damage: 17},
 	}},
 
 	// ── Multiattack elites ───────────────────────────────────────────────
@@ -169,6 +170,24 @@ var srdProfiles = map[string]SRDProfile{
 		{Name: "Unarmed Strike", AttackBonus: 6, Damage: 6},
 		{Name: "Bite", AttackBonus: 6, Damage: 4},
 	}},
+
+	// ── Feywild elites (D8-f #2) ─────────────────────────────────────────
+	// Feywild martials facerolled at 97–100% even after an HP/AC raise: the
+	// roster was single-attack and low-damage, so tankier monsters just took
+	// longer to kill. Multiattack is the lever that actually pulls leaders
+	// into band (mirrors underdark's drow_elite). Casters trail (by design).
+	"fomorian": {Attacks: []SRDAttack{ // Attack 13 → ~21 (2 big fists)
+		{Name: "Greatclub", AttackBonus: 9, Damage: 11},
+		{Name: "Greatclub", AttackBonus: 9, Damage: 10},
+	}},
+	"night_hag": {Attacks: []SRDAttack{ // Attack 8 → ~12 (claw flurry)
+		{Name: "Claws", AttackBonus: 7, Damage: 6},
+		{Name: "Claws", AttackBonus: 7, Damage: 6},
+	}},
+	"green_hag": {Attacks: []SRDAttack{ // Attack 6 → ~10 (claw flurry)
+		{Name: "Claws", AttackBonus: 6, Damage: 5},
+		{Name: "Claws", AttackBonus: 6, Damage: 5},
+	}},
 }
 
 // enemyAttackProfile returns the attack rolls a creature makes on its turn.

internal/plugin/bestiary_srd_test.go

@@ -39,9 +39,23 @@ func TestEnemyAttackProfile_Registered(t *testing.T) {
 	}
 }
 
+// testCombatState seats a single actor, the shape every direct-primitive test
+// wants. The engine reads per-actor state through the embedded cursor, so a
+// combatState with a nil actor panics on the first st.playerHP touch.
+func testCombatState(playerHP, enemyHP, round int, rng *rand.Rand) *combatState {
+	a := &actor{playerHP: playerHP}
+	return &combatState{
+		actor:   a,
+		actors:  []*actor{a},
+		enemyHP: enemyHP,
+		round:   round,
+		rng:     rng,
+	}
+}
+
 func TestTurnAbilityFires(t *testing.T) {
 	enemy := baseEnemy() // MaxHP 60
-	st := &combatState{rng: rand.New(rand.NewPCG(1, 1))}
+	st := testCombatState(0, 0, 0, rand.New(rand.NewPCG(1, 1)))
 
 	cases := []struct {
 		name     string
@@ -78,10 +92,7 @@ func TestTurnAbilityFires(t *testing.T) {
 // within applyAbility with no persistent state.
 func TestApplyAbility_Slice2Effects(t *testing.T) {
 	newState := func(playerHP, enemyHP int) (*combatState, Combatant, Combatant) {
-		st := &combatState{
-			playerHP: playerHP, enemyHP: enemyHP, round: 1,
-			rng: rand.New(rand.NewPCG(7, 7)),
-		}
+		st := testCombatState(playerHP, enemyHP, 1, rand.New(rand.NewPCG(7, 7)))
 		return st, basePlayer(), baseEnemy()
 	}
 	phase := &turnCombatPhase
@@ -136,10 +147,7 @@ func TestApplyAbility_Slice2Effects(t *testing.T) {
 // all but evade), and the shared resolution primitives read that state.
 func TestApplyAbility_Slice3Effects(t *testing.T) {
 	newState := func(playerHP, enemyHP int) (*combatState, Combatant, Combatant) {
-		st := &combatState{
-			playerHP: playerHP, enemyHP: enemyHP, round: 1,
-			rng: rand.New(rand.NewPCG(9, 9)),
-		}
+		st := testCombatState(playerHP, enemyHP, 1, rand.New(rand.NewPCG(9, 9)))
 		return st, basePlayer(), baseEnemy()
 	}
 	phase := &turnCombatPhase
@@ -188,7 +196,8 @@ func TestApplyAbility_Slice3Effects(t *testing.T) {
 	}
 
 	// enemyDown lets survive_at_1 cheat death exactly once.
-	stS := &combatState{enemyHP: 0, enemySurviveArmed: true}
+	stS := testCombatState(100, 0, 1, rand.New(rand.NewPCG(13, 13)))
+	stS.enemySurviveArmed = true
 	if enemyDown(stS, "Duel") {
 		t.Error("survive_at_1: armed enemy at 0 HP should not be down")
 	}
@@ -224,10 +233,7 @@ func TestApplyAbility_Slice3Effects(t *testing.T) {
 // itself, and the shared resolution primitives / helpers read that state.
 func TestApplyAbility_Slice4Effects(t *testing.T) {
 	newState := func(playerHP, enemyHP int) (*combatState, Combatant, Combatant) {
-		st := &combatState{
-			playerHP: playerHP, enemyHP: enemyHP, round: 1,
-			rng: rand.New(rand.NewPCG(11, 11)),
-		}
+		st := testCombatState(playerHP, enemyHP, 1, rand.New(rand.NewPCG(11, 11)))
 		return st, basePlayer(), baseEnemy()
 	}
 	phase := &turnCombatPhase

internal/plugin/bestiary_tuned_data.go

@@ -14,327 +14,327 @@ package plugin
 
 func buildTunedBestiarySRD() map[string]DnDMonsterTemplate {
 	return map[string]DnDMonsterTemplate{
-		"awakened_shrub": {ID: "awakened_shrub", Name: "Awakened Shrub", CR: 0, HP: 10, AC: 10, Attack: 1, AttackBonus: 1, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: False Appearance"},
-		"baboon": {ID: "baboon", Name: "Baboon", CR: 0, HP: 3, AC: 12, Attack: 1, AttackBonus: 1, Speed: 12, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Pack Tactics"},
-		"badger": {ID: "badger", Name: "Badger", CR: 0, HP: 3, AC: 10, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Smell"},
-		"bat": {ID: "bat", Name: "Bat", CR: 0, HP: 1, AC: 12, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Echolocation, Keen Hearing"},
-		"cat": {ID: "cat", Name: "Cat", CR: 0, HP: 2, AC: 12, Attack: 1, AttackBonus: 0, Speed: 16, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Smell"},
-		"commoner": {ID: "commoner", Name: "Commoner", CR: 0, HP: 4, AC: 10, Attack: 1, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"crab": {ID: "crab", Name: "Crab", CR: 0, HP: 2, AC: 11, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
-		"deer": {ID: "deer", Name: "Deer", CR: 0, HP: 4, AC: 13, Attack: 1, AttackBonus: 2, Speed: 18, BlockRate: 0.05, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"eagle": {ID: "eagle", Name: "Eagle", CR: 0, HP: 3, AC: 12, Attack: 1, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Sight"},
-		"frog": {ID: "frog", Name: "Frog", CR: 0, HP: 1, AC: 11, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Amphibious, Standing Leap"},
-		"giant_fire_beetle": {ID: "giant_fire_beetle", Name: "Giant Fire Beetle", CR: 0, HP: 4, AC: 13, Attack: 1, AttackBonus: 1, Speed: 12, BlockRate: 0.05, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Illumination"},
-		"goat": {ID: "goat", Name: "Goat", CR: 0, HP: 4, AC: 10, Attack: 1, AttackBonus: 3, Speed: 16, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge, Sure-Footed"},
-		"hawk": {ID: "hawk", Name: "Hawk", CR: 0, HP: 1, AC: 13, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0.05, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Sight"},
-		"homunculus": {ID: "homunculus", Name: "Homunculus", CR: 0, HP: 5, AC: 13, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0.05, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Telepathic Bond"},
-		"hyena": {ID: "hyena", Name: "Hyena", CR: 0, HP: 5, AC: 11, Attack: 1, AttackBonus: 2, Speed: 18, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Pack Tactics"},
-		"jackal": {ID: "jackal", Name: "Jackal", CR: 0, HP: 3, AC: 12, Attack: 1, AttackBonus: 1, Speed: 16, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Hearing and Smell, Pack Tactics"},
-		"lemure": {ID: "lemure", Name: "Lemure", CR: 0, HP: 13, AC: 10, Attack: 1, AttackBonus: 3, Speed: 6, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Regeneration", Phase: "any", ProcChance: 0.5, Effect: "regenerate"}, Notes: "SRD-tuned baseline — Regeneration (regenerate) wired from traits. Traits: Devil's Sight, Hellish Rejuvenation"},
-		"lizard": {ID: "lizard", Name: "Lizard", CR: 0, HP: 2, AC: 10, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"octopus": {ID: "octopus", Name: "Octopus", CR: 0, HP: 3, AC: 12, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Hold Breath, Underwater Camouflage, Water Breathing"},
-		"owl": {ID: "owl", Name: "Owl", CR: 0, HP: 1, AC: 11, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Flyby, Keen Hearing and Sight"},
-		"quipper": {ID: "quipper", Name: "Quipper", CR: 0, HP: 1, AC: 13, Attack: 1, AttackBonus: 0, Speed: 16, BlockRate: 0.05, XPValue: 10, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Blood Frenzy, Water Breathing"},
-		"rat": {ID: "rat", Name: "Rat", CR: 0, HP: 1, AC: 10, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Smell"},
-		"raven": {ID: "raven", Name: "Raven", CR: 0, HP: 1, AC: 12, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Mimicry"},
-		"scorpion": {ID: "scorpion", Name: "Scorpion", CR: 0, HP: 1, AC: 11, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"sea_horse": {ID: "sea_horse", Name: "Sea Horse", CR: 0, HP: 1, AC: 11, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Water Breathing"},
-		"shrieker": {ID: "shrieker", Name: "Shrieker", CR: 0, HP: 13, AC: 10, Attack: 1, AttackBonus: 0, Speed: 10, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: False Appearance"},
-		"spider": {ID: "spider", Name: "Spider", CR: 0, HP: 1, AC: 12, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Spider Climb, Web Sense, Web Walker"},
-		"vulture": {ID: "vulture", Name: "Vulture", CR: 0, HP: 5, AC: 10, Attack: 1, AttackBonus: 2, Speed: 6, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Sight and Smell, Pack Tactics"},
-		"weasel": {ID: "weasel", Name: "Weasel", CR: 0, HP: 1, AC: 13, Attack: 1, AttackBonus: 0, Speed: 12, BlockRate: 0.05, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Hearing and Smell"},
-		"bandit": {ID: "bandit", Name: "Bandit", CR: 0.125, HP: 11, AC: 12, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"blood_hawk": {ID: "blood_hawk", Name: "Blood Hawk", CR: 0.125, HP: 7, AC: 12, Attack: 1, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 25, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Sight, Pack Tactics"},
-		"camel": {ID: "camel", Name: "Camel", CR: 0.125, HP: 15, AC: 10, Attack: 1, AttackBonus: 5, Speed: 18, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"cultist": {ID: "cultist", Name: "Cultist", CR: 0.125, HP: 9, AC: 12, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Dark Devotion"},
-		"flying_snake": {ID: "flying_snake", Name: "Flying Snake", CR: 0.125, HP: 5, AC: 14, Attack: 1, AttackBonus: 0, Speed: 12, BlockRate: 0.05, XPValue: 25, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Flyby"},
-		"giant_crab": {ID: "giant_crab", Name: "Giant Crab", CR: 0.125, HP: 13, AC: 15, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0.1, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
-		"giant_rat": {ID: "giant_rat", Name: "Giant Rat", CR: 0.125, HP: 7, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 25, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Smell, Pack Tactics"},
-		"giant_rat_diseased": {ID: "giant_rat_diseased", Name: "Giant Rat", CR: 0.125, HP: 7, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"giant_weasel": {ID: "giant_weasel", Name: "Giant Weasel", CR: 0.125, HP: 9, AC: 13, Attack: 1, AttackBonus: 5, Speed: 16, BlockRate: 0.05, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Hearing and Smell"},
-		"guard": {ID: "guard", Name: "Guard", CR: 0.125, HP: 11, AC: 16, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0.1, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"kobold": {ID: "kobold", Name: "Kobold", CR: 0.125, HP: 5, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 25, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Sunlight Sensitivity, Pack Tactics"},
-		"mastiff": {ID: "mastiff", Name: "Mastiff", CR: 0.125, HP: 5, AC: 12, Attack: 1, AttackBonus: 3, Speed: 16, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Hearing and Smell"},
-		"merfolk": {ID: "merfolk", Name: "Merfolk", CR: 0.125, HP: 11, AC: 11, Attack: 1, AttackBonus: 2, Speed: 6, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
-		"mule": {ID: "mule", Name: "Mule", CR: 0.125, HP: 11, AC: 10, Attack: 1, AttackBonus: 4, Speed: 16, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Beast of Burden, Sure-Footed"},
-		"noble": {ID: "noble", Name: "Noble", CR: 0.125, HP: 9, AC: 15, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0.1, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"poisonous_snake": {ID: "poisonous_snake", Name: "Poisonous Snake", CR: 0.125, HP: 2, AC: 13, Attack: 1, AttackBonus: 0, Speed: 12, BlockRate: 0.05, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"pony": {ID: "pony", Name: "Pony", CR: 0.125, HP: 11, AC: 10, Attack: 1, AttackBonus: 4, Speed: 16, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"stirge": {ID: "stirge", Name: "Stirge", CR: 0.125, HP: 2, AC: 14, Attack: 1, AttackBonus: 5, Speed: 6, BlockRate: 0.05, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"tribal_warrior": {ID: "tribal_warrior", Name: "Tribal Warrior", CR: 0.125, HP: 11, AC: 12, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 25, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Pack Tactics"},
-		"acolyte": {ID: "acolyte", Name: "Acolyte", CR: 0.25, HP: 9, AC: 10, Attack: 1, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Spellcasting"},
-		"axe_beak": {ID: "axe_beak", Name: "Axe Beak", CR: 0.25, HP: 19, AC: 11, Attack: 1, AttackBonus: 4, Speed: 18, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"blink_dog": {ID: "blink_dog", Name: "Blink Dog", CR: 0.25, HP: 22, AC: 13, Attack: 1, AttackBonus: 3, Speed: 16, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Hearing and Smell"},
-		"boar": {ID: "boar", Name: "Boar", CR: 0.25, HP: 11, AC: 11, Attack: 1, AttackBonus: 3, Speed: 16, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge, Relentless (Recharges after a Short or Long Rest)"},
-		"constrictor_snake": {ID: "constrictor_snake", Name: "Constrictor Snake", CR: 0.25, HP: 13, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"draft_horse": {ID: "draft_horse", Name: "Draft Horse", CR: 0.25, HP: 19, AC: 10, Attack: 1, AttackBonus: 6, Speed: 16, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"dretch": {ID: "dretch", Name: "Dretch", CR: 0.25, HP: 18, AC: 11, Attack: 1, AttackBonus: 2, Speed: 8, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dretch makes two attacks: one with its bite and one with its claws."},
-		"drow": {ID: "drow", Name: "Drow", CR: 0.25, HP: 13, AC: 15, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 50, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Fey Ancestry, Innate Spellcasting, Sunlight Sensitivity"},
-		"elk": {ID: "elk", Name: "Elk", CR: 0.25, HP: 13, AC: 10, Attack: 1, AttackBonus: 0, Speed: 18, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge"},
-		"flying_sword": {ID: "flying_sword", Name: "Flying Sword", CR: 0.25, HP: 17, AC: 17, Attack: 1, AttackBonus: 3, Speed: 18, BlockRate: 0.1, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Antimagic Susceptibility, False Appearance"},
-		"giant_badger": {ID: "giant_badger", Name: "Giant Badger", CR: 0.25, HP: 13, AC: 10, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The badger makes two attacks: one with its bite and one with its claws. Traits: Keen Smell"},
-		"giant_bat": {ID: "giant_bat", Name: "Giant Bat", CR: 0.25, HP: 22, AC: 13, Attack: 1, AttackBonus: 4, Speed: 6, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Echolocation, Keen Hearing"},
-		"giant_centipede": {ID: "giant_centipede", Name: "Giant Centipede", CR: 0.25, HP: 4, AC: 13, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"giant_frog": {ID: "giant_frog", Name: "Giant Frog", CR: 0.25, HP: 18, AC: 11, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Amphibious, Standing Leap"},
-		"giant_lizard": {ID: "giant_lizard", Name: "Giant Lizard", CR: 0.25, HP: 19, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Variant: Hold Breath, Variant: Spider Climb"},
-		"giant_owl": {ID: "giant_owl", Name: "Giant Owl", CR: 0.25, HP: 19, AC: 12, Attack: 1, AttackBonus: 3, Speed: 6, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Flyby, Keen Hearing and Sight"},
-		"giant_poisonous_snake": {ID: "giant_poisonous_snake", Name: "Giant Poisonous Snake", CR: 0.25, HP: 11, AC: 14, Attack: 1, AttackBonus: 6, Speed: 12, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"giant_wolf_spider": {ID: "giant_wolf_spider", Name: "Giant Wolf Spider", CR: 0.25, HP: 11, AC: 13, Attack: 1, AttackBonus: 3, Speed: 16, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Spider Climb, Web Sense, Web Walker"},
-		"goblin": {ID: "goblin", Name: "Goblin", CR: 0.25, HP: 7, AC: 15, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 50, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Nimble Escape"},
-		"grimlock": {ID: "grimlock", Name: "Grimlock", CR: 0.25, HP: 11, AC: 11, Attack: 1, AttackBonus: 5, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Blind Senses, Keen Hearing and Smell, Stone Camouflage"},
-		"panther": {ID: "panther", Name: "Panther", CR: 0.25, HP: 13, AC: 12, Attack: 1, AttackBonus: 4, Speed: 18, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Keen Smell, Pounce"},
-		"pseudodragon": {ID: "pseudodragon", Name: "Pseudodragon", CR: 0.25, HP: 7, AC: 13, Attack: 1, AttackBonus: 4, Speed: 6, BlockRate: 0.05, XPValue: 50, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Traits: Keen Senses, Magic Resistance, Limited Telepathy, Variant: Familiar"},
-		"riding_horse": {ID: "riding_horse", Name: "Riding Horse", CR: 0.25, HP: 13, AC: 10, Attack: 1, AttackBonus: 5, Speed: 18, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"skeleton": {ID: "skeleton", Name: "Skeleton", CR: 0.25, HP: 13, AC: 13, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"sprite": {ID: "sprite", Name: "Sprite", CR: 0.25, HP: 2, AC: 15, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0.1, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"steam_mephit": {ID: "steam_mephit", Name: "Steam Mephit", CR: 0.25, HP: 21, AC: 10, Attack: 1, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Traits: Death Burst, Innate Spellcasting (1/Day)"},
-		"swarm_of_bats": {ID: "swarm_of_bats", Name: "Swarm of Bats", CR: 0.25, HP: 22, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Echolocation, Keen Hearing, Swarm"},
-		"swarm_of_rats": {ID: "swarm_of_rats", Name: "Swarm of Rats", CR: 0.25, HP: 24, AC: 10, Attack: 1, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Smell, Swarm"},
-		"swarm_of_ravens": {ID: "swarm_of_ravens", Name: "Swarm of Ravens", CR: 0.25, HP: 24, AC: 12, Attack: 1, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
-		"violet_fungus": {ID: "violet_fungus", Name: "Violet Fungus", CR: 0.25, HP: 18, AC: 10, Attack: 1, AttackBonus: 2, Speed: 6, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The fungus makes 1d4 Rotting Touch attacks. Traits: False Appearance"},
-		"wolf": {ID: "wolf", Name: "Wolf", CR: 0.25, HP: 11, AC: 13, Attack: 1, AttackBonus: 4, Speed: 16, BlockRate: 0.05, XPValue: 50, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Hearing and Smell, Pack Tactics"},
-		"zombie": {ID: "zombie", Name: "Zombie", CR: 0.25, HP: 22, AC: 10, Attack: 1, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Undead Fortitude", Phase: "decisive", ProcChance: 0.5, Effect: "survive_at_1"}, Notes: "SRD-tuned baseline — Undead Fortitude (survive_at_1) wired from traits. Traits: Undead Fortitude"},
-		"ape": {ID: "ape", Name: "Ape", CR: 0.5, HP: 19, AC: 12, Attack: 2, AttackBonus: 5, Speed: 12, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The ape makes two fist attacks."},
-		"black_bear": {ID: "black_bear", Name: "Black Bear", CR: 0.5, HP: 19, AC: 11, Attack: 2, AttackBonus: 3, Speed: 16, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The bear makes two attacks: one with its bite and one with its claws. Traits: Keen Smell"},
-		"cockatrice": {ID: "cockatrice", Name: "Cockatrice", CR: 0.5, HP: 27, AC: 11, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"crocodile": {ID: "crocodile", Name: "Crocodile", CR: 0.5, HP: 19, AC: 12, Attack: 2, AttackBonus: 4, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Hold Breath"},
-		"darkmantle": {ID: "darkmantle", Name: "Darkmantle", CR: 0.5, HP: 22, AC: 11, Attack: 2, AttackBonus: 5, Speed: 6, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Echolocation, False Appearance"},
-		"deep_gnome_svirfneblin": {ID: "deep_gnome_svirfneblin", Name: "Deep Gnome", CR: 0.5, HP: 16, AC: 15, Attack: 2, AttackBonus: 4, Speed: 8, BlockRate: 0.1, XPValue: 100, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Stone Camouflage, Gnome Cunning, Innate Spellcasting"},
-		"dust_mephit": {ID: "dust_mephit", Name: "Dust Mephit", CR: 0.5, HP: 17, AC: 12, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Traits: Death Burst, Innate Spellcasting (1/Day)"},
-		"giant_goat": {ID: "giant_goat", Name: "Giant Goat", CR: 0.5, HP: 19, AC: 11, Attack: 2, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge, Sure-Footed"},
-		"giant_sea_horse": {ID: "giant_sea_horse", Name: "Giant Sea Horse", CR: 0.5, HP: 16, AC: 13, Attack: 2, AttackBonus: 3, Speed: 16, BlockRate: 0.05, XPValue: 100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge, Water Breathing"},
-		"giant_wasp": {ID: "giant_wasp", Name: "Giant Wasp", CR: 0.5, HP: 13, AC: 12, Attack: 2, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"gnoll": {ID: "gnoll", Name: "Gnoll", CR: 0.5, HP: 22, AC: 15, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 100, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Rampage"},
-		"gray_ooze": {ID: "gray_ooze", Name: "Gray Ooze", CR: 0.5, HP: 22, AC: 10, Attack: 2, AttackBonus: 3, Speed: 6, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amorphous, Corrode Metal, False Appearance"},
-		"hobgoblin": {ID: "hobgoblin", Name: "Hobgoblin", CR: 0.5, HP: 11, AC: 18, Attack: 2, AttackBonus: 3, Speed: 12, BlockRate: 0.15, XPValue: 100, Ability: &MonsterAbility{Name: "Martial Advantage", Phase: "any", ProcChance: 0.35, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Martial Advantage (bonus_damage) wired from traits. Traits: Martial Advantage"},
-		"ice_mephit": {ID: "ice_mephit", Name: "Ice Mephit", CR: 0.5, HP: 21, AC: 11, Attack: 2, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Traits: Death Burst, False Appearance, Innate Spellcasting (1/Day)"},
-		"lizardfolk": {ID: "lizardfolk", Name: "Lizardfolk", CR: 0.5, HP: 22, AC: 15, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The lizardfolk makes two melee attacks, each one with a different weapon. Traits: Hold Breath"},
-		"magma_mephit": {ID: "magma_mephit", Name: "Magma Mephit", CR: 0.5, HP: 22, AC: 11, Attack: 2, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Traits: Death Burst, False Appearance, Innate Spellcasting (1/Day)"},
-		"magmin": {ID: "magmin", Name: "Magmin", CR: 0.5, HP: 9, AC: 14, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 100, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Traits: Death Burst, Ignited Illumination", FireAttacker: true},
-		"orc": {ID: "orc", Name: "Orc", CR: 0.5, HP: 15, AC: 13, Attack: 2, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 100, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Aggressive"},
-		"reef_shark": {ID: "reef_shark", Name: "Reef Shark", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 4, Speed: 16, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Pack Tactics, Water Breathing"},
-		"rust_monster": {ID: "rust_monster", Name: "Rust Monster", CR: 0.5, HP: 27, AC: 14, Attack: 2, AttackBonus: 3, Speed: 16, BlockRate: 0.05, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Iron Scent, Rust Metal"},
-		"sahuagin": {ID: "sahuagin", Name: "Sahuagin", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Multiattack: The sahuagin makes two melee attacks: one with its bite and one with its claws or spear. Traits: Blood Frenzy, Limited Amphibiousness, Shark Telepathy"},
-		"satyr": {ID: "satyr", Name: "Satyr", CR: 0.5, HP: 31, AC: 14, Attack: 2, AttackBonus: 3, Speed: 16, BlockRate: 0.05, XPValue: 100, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Traits: Magic Resistance"},
-		"scout": {ID: "scout", Name: "Scout", CR: 0.5, HP: 16, AC: 13, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The scout makes two melee attacks or two ranged attacks. Traits: Keen Hearing and Sight"},
-		"shadow": {ID: "shadow", Name: "Shadow", CR: 0.5, HP: 16, AC: 12, Attack: 2, AttackBonus: 4, Speed: 16, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Surprise Attack", Phase: "opening", ProcChance: 0.8, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Surprise Attack (bonus_damage) wired from traits. Traits: Amorphous, Shadow Stealth, Sunlight Weakness"},
-		"swarm_of_beetles": {ID: "swarm_of_beetles", Name: "Swarm of Beetles", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
-		"swarm_of_centipedes": {ID: "swarm_of_centipedes", Name: "Swarm of Centipedes", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
-		"swarm_of_insects": {ID: "swarm_of_insects", Name: "Swarm of Insects", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
-		"swarm_of_spiders": {ID: "swarm_of_spiders", Name: "Swarm of Spiders", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm, Spider Climb, Web Sense, Web Walker"},
-		"swarm_of_wasps": {ID: "swarm_of_wasps", Name: "Swarm of Wasps", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 6, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
-		"thug": {ID: "thug", Name: "Thug", CR: 0.5, HP: 32, AC: 11, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Multiattack: The thug makes two melee attacks. Traits: Pack Tactics"},
-		"warhorse": {ID: "warhorse", Name: "Warhorse", CR: 0.5, HP: 19, AC: 11, Attack: 2, AttackBonus: 6, Speed: 18, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Trampling Charge"},
-		"warhorse_skeleton": {ID: "warhorse_skeleton", Name: "Warhorse Skeleton", CR: 0.5, HP: 22, AC: 13, Attack: 2, AttackBonus: 6, Speed: 18, BlockRate: 0.05, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"worg": {ID: "worg", Name: "Worg", CR: 0.5, HP: 26, AC: 13, Attack: 2, AttackBonus: 5, Speed: 18, BlockRate: 0.05, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Hearing and Smell"},
-		"animated_armor": {ID: "animated_armor", Name: "Animated Armor", CR: 1, HP: 33, AC: 18, Attack: 2, AttackBonus: 4, Speed: 10, BlockRate: 0.15, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The armor makes two melee attacks. Traits: Antimagic Susceptibility, False Appearance"},
-		"brass_dragon_wyrmling": {ID: "brass_dragon_wyrmling", Name: "Brass Dragon Wyrmling", CR: 1, HP: 16, AC: 16, Attack: 2, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat).", FireAttacker: true},
-		"brown_bear": {ID: "brown_bear", Name: "Brown Bear", CR: 1, HP: 34, AC: 11, Attack: 2, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The bear makes two attacks: one with its bite and one with its claws. Traits: Keen Smell"},
-		"bugbear": {ID: "bugbear", Name: "Bugbear", CR: 1, HP: 27, AC: 16, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 200, Ability: &MonsterAbility{Name: "Surprise Attack", Phase: "opening", ProcChance: 0.8, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Surprise Attack (bonus_damage) wired from traits. Traits: Brute, Surprise Attack"},
-		"copper_dragon_wyrmling": {ID: "copper_dragon_wyrmling", Name: "Copper Dragon Wyrmling", CR: 1, HP: 22, AC: 16, Attack: 2, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"death_dog": {ID: "death_dog", Name: "Death Dog", CR: 1, HP: 39, AC: 12, Attack: 2, AttackBonus: 4, Speed: 16, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dog makes two bite attacks. Traits: Two-Headed"},
-		"dire_wolf": {ID: "dire_wolf", Name: "Dire Wolf", CR: 1, HP: 37, AC: 14, Attack: 2, AttackBonus: 5, Speed: 18, BlockRate: 0.05, XPValue: 200, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Hearing and Smell, Pack Tactics"},
-		"dryad": {ID: "dryad", Name: "Dryad", CR: 1, HP: 22, AC: 11, Attack: 2, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Innate Spellcasting, Magic Resistance, Speak with Beasts and Plants, Tree Stride"},
-		"duergar": {ID: "duergar", Name: "Duergar", CR: 1, HP: 26, AC: 16, Attack: 2, AttackBonus: 4, Speed: 10, BlockRate: 0.1, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Duergar Resilience, Sunlight Sensitivity"},
-		"ghoul": {ID: "ghoul", Name: "Ghoul", CR: 1, HP: 22, AC: 12, Attack: 2, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"giant_eagle": {ID: "giant_eagle", Name: "Giant Eagle", CR: 1, HP: 26, AC: 13, Attack: 2, AttackBonus: 5, Speed: 6, BlockRate: 0.05, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The eagle makes two attacks: one with its beak and one with its talons. Traits: Keen Sight"},
-		"giant_hyena": {ID: "giant_hyena", Name: "Giant Hyena", CR: 1, HP: 45, AC: 12, Attack: 2, AttackBonus: 5, Speed: 18, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Rampage"},
-		"giant_octopus": {ID: "giant_octopus", Name: "Giant Octopus", CR: 1, HP: 52, AC: 11, Attack: 2, AttackBonus: 5, Speed: 6, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Hold Breath, Underwater Camouflage, Water Breathing"},
-		"giant_spider": {ID: "giant_spider", Name: "Giant Spider", CR: 1, HP: 26, AC: 14, Attack: 2, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Spider Climb, Web Sense, Web Walker"},
-		"giant_toad": {ID: "giant_toad", Name: "Giant Toad", CR: 1, HP: 39, AC: 11, Attack: 2, AttackBonus: 4, Speed: 8, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Amphibious, Standing Leap"},
-		"giant_vulture": {ID: "giant_vulture", Name: "Giant Vulture", CR: 1, HP: 22, AC: 10, Attack: 2, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Multiattack: The vulture makes two attacks: one with its beak and one with its talons. Traits: Keen Sight and Smell, Pack Tactics"},
-		"harpy": {ID: "harpy", Name: "Harpy", CR: 1, HP: 38, AC: 11, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The harpy makes two attacks: one with its claws and one with its club."},
-		"hippogriff": {ID: "hippogriff", Name: "Hippogriff", CR: 1, HP: 19, AC: 11, Attack: 2, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The hippogriff makes two attacks: one with its beak and one with its claws. Traits: Keen Sight"},
-		"imp": {ID: "imp", Name: "Imp", CR: 1, HP: 10, AC: 13, Attack: 2, AttackBonus: 5, Speed: 8, BlockRate: 0.05, XPValue: 200, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Traits: Shapechanger, Devil's Sight, Magic Resistance, Variant: Familiar"},
-		"lion": {ID: "lion", Name: "Lion", CR: 1, HP: 26, AC: 12, Attack: 2, AttackBonus: 5, Speed: 18, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Keen Smell, Pack Tactics, Pounce, Running Leap"},
-		"quasit": {ID: "quasit", Name: "Quasit", CR: 1, HP: 7, AC: 13, Attack: 2, AttackBonus: 4, Speed: 16, BlockRate: 0.05, XPValue: 200, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Traits: Shapechanger, Magic Resistance, Variant: Familiar"},
-		"specter": {ID: "specter", Name: "Specter", CR: 1, HP: 22, AC: 12, Attack: 2, AttackBonus: 4, Speed: 18, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Incorporeal Movement, Sunlight Sensitivity"},
-		"spy": {ID: "spy", Name: "Spy", CR: 1, HP: 27, AC: 12, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Martial Advantage", Phase: "any", ProcChance: 0.35, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Martial Advantage (bonus_damage) wired from traits. Multiattack: The spy makes two melee attacks. Traits: Cunning Action, Sneak Attack (1/Turn)"},
-		"swarm_of_quippers": {ID: "swarm_of_quippers", Name: "Swarm of Quippers", CR: 1, HP: 28, AC: 13, Attack: 2, AttackBonus: 5, Speed: 16, BlockRate: 0.05, XPValue: 200, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Blood Frenzy, Swarm, Water Breathing"},
-		"tiger": {ID: "tiger", Name: "Tiger", CR: 1, HP: 37, AC: 12, Attack: 2, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Keen Smell, Pounce"},
-		"ankheg": {ID: "ankheg", Name: "Ankheg", CR: 2, HP: 39, AC: 14, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"awakened_tree": {ID: "awakened_tree", Name: "Awakened Tree", CR: 2, HP: 59, AC: 13, Attack: 4, AttackBonus: 6, Speed: 8, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: False Appearance"},
-		"azer": {ID: "azer", Name: "Azer", CR: 2, HP: 39, AC: 17, Attack: 4, AttackBonus: 5, Speed: 12, BlockRate: 0.1, XPValue: 450, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Traits: Heated Body, Heated Weapons, Illumination"},
-		"bandit_captain": {ID: "bandit_captain", Name: "Bandit Captain", CR: 2, HP: 65, AC: 15, Attack: 4, AttackBonus: 5, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The captain makes three melee attacks: two with its scimitar and one with its dagger."},
-		"berserker": {ID: "berserker", Name: "Berserker", CR: 2, HP: 67, AC: 13, Attack: 4, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 450, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Reckless"},
-		"black_dragon_wyrmling": {ID: "black_dragon_wyrmling", Name: "Black Dragon Wyrmling", CR: 2, HP: 33, AC: 17, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
-		"bronze_dragon_wyrmling": {ID: "bronze_dragon_wyrmling", Name: "Bronze Dragon Wyrmling", CR: 2, HP: 32, AC: 17, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
-		"centaur": {ID: "centaur", Name: "Centaur", CR: 2, HP: 45, AC: 12, Attack: 4, AttackBonus: 6, Speed: 18, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Multiattack: The centaur makes two attacks: one with its pike and one with its hooves or two with its longbow. Traits: Charge"},
-		"cult_fanatic": {ID: "cult_fanatic", Name: "Cult Fanatic", CR: 2, HP: 22, AC: 13, Attack: 4, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 450, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The fanatic makes two melee attacks. Traits: Dark Devotion, Spellcasting"},
-		"druid": {ID: "druid", Name: "Druid", CR: 2, HP: 27, AC: 11, Attack: 4, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Spellcasting"},
-		"ettercap": {ID: "ettercap", Name: "Ettercap", CR: 2, HP: 44, AC: 13, Attack: 4, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The ettercap makes two attacks: one with its bite and one with its claws. Traits: Spider Climb, Web Sense, Web Walker"},
-		"gargoyle": {ID: "gargoyle", Name: "Gargoyle", CR: 2, HP: 52, AC: 15, Attack: 4, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The gargoyle makes two attacks: one with its bite and one with its claws. Traits: False Appearance"},
-		"gelatinous_cube": {ID: "gelatinous_cube", Name: "Gelatinous Cube", CR: 2, HP: 84, AC: 10, Attack: 4, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Ooze Cube, Transparent"},
-		"ghast": {ID: "ghast", Name: "Ghast", CR: 2, HP: 36, AC: 13, Attack: 4, AttackBonus: 3, Speed: 12, BlockRate: 0.05, XPValue: 450, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Traits: Stench, Turn Defiance"},
-		"giant_boar": {ID: "giant_boar", Name: "Giant Boar", CR: 2, HP: 42, AC: 12, Attack: 4, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge, Relentless (Recharges after a Short or Long Rest)"},
-		"giant_constrictor_snake": {ID: "giant_constrictor_snake", Name: "Giant Constrictor Snake", CR: 2, HP: 60, AC: 12, Attack: 4, AttackBonus: 6, Speed: 12, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"giant_elk": {ID: "giant_elk", Name: "Giant Elk", CR: 2, HP: 42, AC: 15, Attack: 4, AttackBonus: 6, Speed: 18, BlockRate: 0.1, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge"},
-		"gibbering_mouther": {ID: "gibbering_mouther", Name: "Gibbering Mouther", CR: 2, HP: 67, AC: 10, Attack: 4, AttackBonus: 2, Speed: 6, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The gibbering mouther makes one bite attack and, if it can, uses its Blinding Spittle. Traits: Aberrant Ground, Gibbering"},
-		"green_dragon_wyrmling": {ID: "green_dragon_wyrmling", Name: "Green Dragon Wyrmling", CR: 2, HP: 38, AC: 17, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
-		"grick": {ID: "grick", Name: "Grick", CR: 2, HP: 27, AC: 14, Attack: 4, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The grick makes one attack with its tentacles. Traits: Stone Camouflage"},
-		"griffon": {ID: "griffon", Name: "Griffon", CR: 2, HP: 59, AC: 12, Attack: 4, AttackBonus: 6, Speed: 12, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The griffon makes two attacks: one with its beak and one with its claws. Traits: Keen Sight"},
-		"hunter_shark": {ID: "hunter_shark", Name: "Hunter Shark", CR: 2, HP: 45, AC: 12, Attack: 4, AttackBonus: 6, Speed: 16, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Blood Frenzy, Water Breathing"},
-		"merrow": {ID: "merrow", Name: "Merrow", CR: 2, HP: 45, AC: 13, Attack: 4, AttackBonus: 6, Speed: 6, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The merrow makes two attacks: one with its bite and one with its claws or harpoon. Traits: Amphibious"},
-		"mimic": {ID: "mimic", Name: "Mimic", CR: 2, HP: 58, AC: 12, Attack: 4, AttackBonus: 5, Speed: 6, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Shapechanger, Adhesive (Object Form Only), False Appearance (Object Form Only), Grappler"},
-		"minotaur_skeleton": {ID: "minotaur_skeleton", Name: "Minotaur Skeleton", CR: 2, HP: 67, AC: 12, Attack: 4, AttackBonus: 6, Speed: 16, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge"},
-		"ochre_jelly": {ID: "ochre_jelly", Name: "Ochre Jelly", CR: 2, HP: 45, AC: 10, Attack: 4, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amorphous, Spider Climb"},
-		"ogre": {ID: "ogre", Name: "Ogre", CR: 2, HP: 59, AC: 11, Attack: 4, AttackBonus: 6, Speed: 16, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"ogre_zombie": {ID: "ogre_zombie", Name: "Ogre Zombie", CR: 2, HP: 85, AC: 10, Attack: 4, AttackBonus: 6, Speed: 12, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Undead Fortitude", Phase: "decisive", ProcChance: 0.5, Effect: "survive_at_1"}, Notes: "SRD-tuned baseline — Undead Fortitude (survive_at_1) wired from traits. Traits: Undead Fortitude"},
-		"pegasus": {ID: "pegasus", Name: "Pegasus", CR: 2, HP: 59, AC: 12, Attack: 4, AttackBonus: 6, Speed: 18, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"plesiosaurus": {ID: "plesiosaurus", Name: "Plesiosaurus", CR: 2, HP: 68, AC: 13, Attack: 4, AttackBonus: 6, Speed: 8, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Hold Breath"},
-		"polar_bear": {ID: "polar_bear", Name: "Polar Bear", CR: 2, HP: 42, AC: 12, Attack: 4, AttackBonus: 7, Speed: 16, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The bear makes two attacks: one with its bite and one with its claws. Traits: Keen Smell"},
-		"priest": {ID: "priest", Name: "Priest", CR: 2, HP: 27, AC: 13, Attack: 4, AttackBonus: 2, Speed: 10, BlockRate: 0.05, XPValue: 450, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Divine Eminence, Spellcasting"},
-		"rhinoceros": {ID: "rhinoceros", Name: "Rhinoceros", CR: 2, HP: 45, AC: 11, Attack: 4, AttackBonus: 7, Speed: 16, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge"},
-		"rug_of_smothering": {ID: "rug_of_smothering", Name: "Rug of Smothering", CR: 2, HP: 33, AC: 12, Attack: 4, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Antimagic Susceptibility, Damage Transfer, False Appearance"},
-		"saber_toothed_tiger": {ID: "saber_toothed_tiger", Name: "Saber-Toothed Tiger", CR: 2, HP: 52, AC: 12, Attack: 4, AttackBonus: 6, Speed: 16, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Keen Smell, Pounce"},
-		"sea_hag": {ID: "sea_hag", Name: "Sea Hag", CR: 2, HP: 52, AC: 14, Attack: 4, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 450, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Amphibious, Horrific Appearance, Hag Coven, Shared Spellcasting (Coven Only), Hag Eye (Coven Only)"},
-		"silver_dragon_wyrmling": {ID: "silver_dragon_wyrmling", Name: "Silver Dragon Wyrmling", CR: 2, HP: 45, AC: 17, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"awakened_shrub":            {ID: "awakened_shrub", Name: "Awakened Shrub", CR: 0, HP: 10, AC: 10, Attack: 1, AttackBonus: 1, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: False Appearance"},
+		"baboon":                    {ID: "baboon", Name: "Baboon", CR: 0, HP: 3, AC: 12, Attack: 1, AttackBonus: 1, Speed: 12, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Pack Tactics"},
+		"badger":                    {ID: "badger", Name: "Badger", CR: 0, HP: 3, AC: 10, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Smell"},
+		"bat":                       {ID: "bat", Name: "Bat", CR: 0, HP: 1, AC: 12, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Echolocation, Keen Hearing"},
+		"cat":                       {ID: "cat", Name: "Cat", CR: 0, HP: 2, AC: 12, Attack: 1, AttackBonus: 0, Speed: 16, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Smell"},
+		"commoner":                  {ID: "commoner", Name: "Commoner", CR: 0, HP: 4, AC: 10, Attack: 1, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"crab":                      {ID: "crab", Name: "Crab", CR: 0, HP: 2, AC: 11, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
+		"deer":                      {ID: "deer", Name: "Deer", CR: 0, HP: 4, AC: 13, Attack: 1, AttackBonus: 2, Speed: 18, BlockRate: 0.05, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"eagle":                     {ID: "eagle", Name: "Eagle", CR: 0, HP: 3, AC: 12, Attack: 1, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Sight"},
+		"frog":                      {ID: "frog", Name: "Frog", CR: 0, HP: 1, AC: 11, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Amphibious, Standing Leap"},
+		"giant_fire_beetle":         {ID: "giant_fire_beetle", Name: "Giant Fire Beetle", CR: 0, HP: 4, AC: 13, Attack: 1, AttackBonus: 1, Speed: 12, BlockRate: 0.05, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Illumination"},
+		"goat":                      {ID: "goat", Name: "Goat", CR: 0, HP: 4, AC: 10, Attack: 1, AttackBonus: 3, Speed: 16, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge, Sure-Footed"},
+		"hawk":                      {ID: "hawk", Name: "Hawk", CR: 0, HP: 1, AC: 13, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0.05, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Sight"},
+		"homunculus":                {ID: "homunculus", Name: "Homunculus", CR: 0, HP: 5, AC: 13, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0.05, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Telepathic Bond"},
+		"hyena":                     {ID: "hyena", Name: "Hyena", CR: 0, HP: 5, AC: 11, Attack: 1, AttackBonus: 2, Speed: 18, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Pack Tactics"},
+		"jackal":                    {ID: "jackal", Name: "Jackal", CR: 0, HP: 3, AC: 12, Attack: 1, AttackBonus: 1, Speed: 16, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Hearing and Smell, Pack Tactics"},
+		"lemure":                    {ID: "lemure", Name: "Lemure", CR: 0, HP: 13, AC: 10, Attack: 1, AttackBonus: 3, Speed: 6, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Regeneration", Phase: "any", ProcChance: 0.5, Effect: "regenerate"}, Notes: "SRD-tuned baseline — Regeneration (regenerate) wired from traits. Traits: Devil's Sight, Hellish Rejuvenation"},
+		"lizard":                    {ID: "lizard", Name: "Lizard", CR: 0, HP: 2, AC: 10, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"octopus":                   {ID: "octopus", Name: "Octopus", CR: 0, HP: 3, AC: 12, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Hold Breath, Underwater Camouflage, Water Breathing"},
+		"owl":                       {ID: "owl", Name: "Owl", CR: 0, HP: 1, AC: 11, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Flyby, Keen Hearing and Sight"},
+		"quipper":                   {ID: "quipper", Name: "Quipper", CR: 0, HP: 1, AC: 13, Attack: 1, AttackBonus: 0, Speed: 16, BlockRate: 0.05, XPValue: 10, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Blood Frenzy, Water Breathing"},
+		"rat":                       {ID: "rat", Name: "Rat", CR: 0, HP: 1, AC: 10, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Smell"},
+		"raven":                     {ID: "raven", Name: "Raven", CR: 0, HP: 1, AC: 12, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Mimicry"},
+		"scorpion":                  {ID: "scorpion", Name: "Scorpion", CR: 0, HP: 1, AC: 11, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"sea_horse":                 {ID: "sea_horse", Name: "Sea Horse", CR: 0, HP: 1, AC: 11, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Water Breathing"},
+		"shrieker":                  {ID: "shrieker", Name: "Shrieker", CR: 0, HP: 13, AC: 10, Attack: 1, AttackBonus: 0, Speed: 10, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: False Appearance"},
+		"spider":                    {ID: "spider", Name: "Spider", CR: 0, HP: 1, AC: 12, Attack: 1, AttackBonus: 0, Speed: 8, BlockRate: 0, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Spider Climb, Web Sense, Web Walker"},
+		"vulture":                   {ID: "vulture", Name: "Vulture", CR: 0, HP: 5, AC: 10, Attack: 1, AttackBonus: 2, Speed: 6, BlockRate: 0, XPValue: 10, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Sight and Smell, Pack Tactics"},
+		"weasel":                    {ID: "weasel", Name: "Weasel", CR: 0, HP: 1, AC: 13, Attack: 1, AttackBonus: 0, Speed: 12, BlockRate: 0.05, XPValue: 10, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Hearing and Smell"},
+		"bandit":                    {ID: "bandit", Name: "Bandit", CR: 0.125, HP: 11, AC: 12, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"blood_hawk":                {ID: "blood_hawk", Name: "Blood Hawk", CR: 0.125, HP: 7, AC: 12, Attack: 1, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 25, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Sight, Pack Tactics"},
+		"camel":                     {ID: "camel", Name: "Camel", CR: 0.125, HP: 15, AC: 10, Attack: 1, AttackBonus: 5, Speed: 18, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"cultist":                   {ID: "cultist", Name: "Cultist", CR: 0.125, HP: 9, AC: 12, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Dark Devotion"},
+		"flying_snake":              {ID: "flying_snake", Name: "Flying Snake", CR: 0.125, HP: 5, AC: 14, Attack: 1, AttackBonus: 0, Speed: 12, BlockRate: 0.05, XPValue: 25, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Flyby"},
+		"giant_crab":                {ID: "giant_crab", Name: "Giant Crab", CR: 0.125, HP: 13, AC: 15, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0.1, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
+		"giant_rat":                 {ID: "giant_rat", Name: "Giant Rat", CR: 0.125, HP: 7, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 25, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Smell, Pack Tactics"},
+		"giant_rat_diseased":        {ID: "giant_rat_diseased", Name: "Giant Rat", CR: 0.125, HP: 7, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"giant_weasel":              {ID: "giant_weasel", Name: "Giant Weasel", CR: 0.125, HP: 9, AC: 13, Attack: 1, AttackBonus: 5, Speed: 16, BlockRate: 0.05, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Hearing and Smell"},
+		"guard":                     {ID: "guard", Name: "Guard", CR: 0.125, HP: 11, AC: 16, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0.1, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"kobold":                    {ID: "kobold", Name: "Kobold", CR: 0.125, HP: 5, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 25, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Sunlight Sensitivity, Pack Tactics"},
+		"mastiff":                   {ID: "mastiff", Name: "Mastiff", CR: 0.125, HP: 5, AC: 12, Attack: 1, AttackBonus: 3, Speed: 16, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Hearing and Smell"},
+		"merfolk":                   {ID: "merfolk", Name: "Merfolk", CR: 0.125, HP: 11, AC: 11, Attack: 1, AttackBonus: 2, Speed: 6, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
+		"mule":                      {ID: "mule", Name: "Mule", CR: 0.125, HP: 11, AC: 10, Attack: 1, AttackBonus: 4, Speed: 16, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Beast of Burden, Sure-Footed"},
+		"noble":                     {ID: "noble", Name: "Noble", CR: 0.125, HP: 9, AC: 15, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0.1, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"poisonous_snake":           {ID: "poisonous_snake", Name: "Poisonous Snake", CR: 0.125, HP: 2, AC: 13, Attack: 1, AttackBonus: 0, Speed: 12, BlockRate: 0.05, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"pony":                      {ID: "pony", Name: "Pony", CR: 0.125, HP: 11, AC: 10, Attack: 1, AttackBonus: 4, Speed: 16, BlockRate: 0, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"stirge":                    {ID: "stirge", Name: "Stirge", CR: 0.125, HP: 2, AC: 14, Attack: 1, AttackBonus: 5, Speed: 6, BlockRate: 0.05, XPValue: 25, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"tribal_warrior":            {ID: "tribal_warrior", Name: "Tribal Warrior", CR: 0.125, HP: 11, AC: 12, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 25, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Pack Tactics"},
+		"acolyte":                   {ID: "acolyte", Name: "Acolyte", CR: 0.25, HP: 9, AC: 10, Attack: 1, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Spellcasting"},
+		"axe_beak":                  {ID: "axe_beak", Name: "Axe Beak", CR: 0.25, HP: 19, AC: 11, Attack: 1, AttackBonus: 4, Speed: 18, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"blink_dog":                 {ID: "blink_dog", Name: "Blink Dog", CR: 0.25, HP: 22, AC: 13, Attack: 1, AttackBonus: 3, Speed: 16, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Hearing and Smell"},
+		"boar":                      {ID: "boar", Name: "Boar", CR: 0.25, HP: 11, AC: 11, Attack: 1, AttackBonus: 3, Speed: 16, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge, Relentless (Recharges after a Short or Long Rest)"},
+		"constrictor_snake":         {ID: "constrictor_snake", Name: "Constrictor Snake", CR: 0.25, HP: 13, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"draft_horse":               {ID: "draft_horse", Name: "Draft Horse", CR: 0.25, HP: 19, AC: 10, Attack: 1, AttackBonus: 6, Speed: 16, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"dretch":                    {ID: "dretch", Name: "Dretch", CR: 0.25, HP: 18, AC: 11, Attack: 1, AttackBonus: 2, Speed: 8, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dretch makes two attacks: one with its bite and one with its claws."},
+		"drow":                      {ID: "drow", Name: "Drow", CR: 0.25, HP: 13, AC: 15, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 50, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Fey Ancestry, Innate Spellcasting, Sunlight Sensitivity"},
+		"elk":                       {ID: "elk", Name: "Elk", CR: 0.25, HP: 13, AC: 10, Attack: 1, AttackBonus: 0, Speed: 18, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge"},
+		"flying_sword":              {ID: "flying_sword", Name: "Flying Sword", CR: 0.25, HP: 17, AC: 17, Attack: 1, AttackBonus: 3, Speed: 18, BlockRate: 0.1, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Antimagic Susceptibility, False Appearance"},
+		"giant_badger":              {ID: "giant_badger", Name: "Giant Badger", CR: 0.25, HP: 13, AC: 10, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The badger makes two attacks: one with its bite and one with its claws. Traits: Keen Smell"},
+		"giant_bat":                 {ID: "giant_bat", Name: "Giant Bat", CR: 0.25, HP: 22, AC: 13, Attack: 1, AttackBonus: 4, Speed: 6, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Echolocation, Keen Hearing"},
+		"giant_centipede":           {ID: "giant_centipede", Name: "Giant Centipede", CR: 0.25, HP: 4, AC: 13, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"giant_frog":                {ID: "giant_frog", Name: "Giant Frog", CR: 0.25, HP: 18, AC: 11, Attack: 1, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Amphibious, Standing Leap"},
+		"giant_lizard":              {ID: "giant_lizard", Name: "Giant Lizard", CR: 0.25, HP: 19, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Variant: Hold Breath, Variant: Spider Climb"},
+		"giant_owl":                 {ID: "giant_owl", Name: "Giant Owl", CR: 0.25, HP: 19, AC: 12, Attack: 1, AttackBonus: 3, Speed: 6, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Flyby, Keen Hearing and Sight"},
+		"giant_poisonous_snake":     {ID: "giant_poisonous_snake", Name: "Giant Poisonous Snake", CR: 0.25, HP: 11, AC: 14, Attack: 1, AttackBonus: 6, Speed: 12, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"giant_wolf_spider":         {ID: "giant_wolf_spider", Name: "Giant Wolf Spider", CR: 0.25, HP: 11, AC: 13, Attack: 1, AttackBonus: 3, Speed: 16, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Spider Climb, Web Sense, Web Walker"},
+		"goblin":                    {ID: "goblin", Name: "Goblin", CR: 0.25, HP: 7, AC: 15, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 50, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Nimble Escape"},
+		"grimlock":                  {ID: "grimlock", Name: "Grimlock", CR: 0.25, HP: 11, AC: 11, Attack: 1, AttackBonus: 5, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Blind Senses, Keen Hearing and Smell, Stone Camouflage"},
+		"panther":                   {ID: "panther", Name: "Panther", CR: 0.25, HP: 13, AC: 12, Attack: 1, AttackBonus: 4, Speed: 18, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Keen Smell, Pounce"},
+		"pseudodragon":              {ID: "pseudodragon", Name: "Pseudodragon", CR: 0.25, HP: 7, AC: 13, Attack: 1, AttackBonus: 4, Speed: 6, BlockRate: 0.05, XPValue: 50, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Traits: Keen Senses, Magic Resistance, Limited Telepathy, Variant: Familiar"},
+		"riding_horse":              {ID: "riding_horse", Name: "Riding Horse", CR: 0.25, HP: 13, AC: 10, Attack: 1, AttackBonus: 5, Speed: 18, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"skeleton":                  {ID: "skeleton", Name: "Skeleton", CR: 0.25, HP: 13, AC: 13, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"sprite":                    {ID: "sprite", Name: "Sprite", CR: 0.25, HP: 2, AC: 15, Attack: 1, AttackBonus: 0, Speed: 6, BlockRate: 0.1, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"steam_mephit":              {ID: "steam_mephit", Name: "Steam Mephit", CR: 0.25, HP: 21, AC: 10, Attack: 1, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Traits: Death Burst, Innate Spellcasting (1/Day)"},
+		"swarm_of_bats":             {ID: "swarm_of_bats", Name: "Swarm of Bats", CR: 0.25, HP: 22, AC: 12, Attack: 1, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Echolocation, Keen Hearing, Swarm"},
+		"swarm_of_rats":             {ID: "swarm_of_rats", Name: "Swarm of Rats", CR: 0.25, HP: 24, AC: 10, Attack: 1, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Smell, Swarm"},
+		"swarm_of_ravens":           {ID: "swarm_of_ravens", Name: "Swarm of Ravens", CR: 0.25, HP: 24, AC: 12, Attack: 1, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
+		"violet_fungus":             {ID: "violet_fungus", Name: "Violet Fungus", CR: 0.25, HP: 18, AC: 10, Attack: 1, AttackBonus: 2, Speed: 6, BlockRate: 0, XPValue: 50, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The fungus makes 1d4 Rotting Touch attacks. Traits: False Appearance"},
+		"wolf":                      {ID: "wolf", Name: "Wolf", CR: 0.25, HP: 11, AC: 13, Attack: 1, AttackBonus: 4, Speed: 16, BlockRate: 0.05, XPValue: 50, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Hearing and Smell, Pack Tactics"},
+		"zombie":                    {ID: "zombie", Name: "Zombie", CR: 0.25, HP: 22, AC: 10, Attack: 1, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 50, Ability: &MonsterAbility{Name: "Undead Fortitude", Phase: "decisive", ProcChance: 0.5, Effect: "survive_at_1"}, Notes: "SRD-tuned baseline — Undead Fortitude (survive_at_1) wired from traits. Traits: Undead Fortitude"},
+		"ape":                       {ID: "ape", Name: "Ape", CR: 0.5, HP: 19, AC: 12, Attack: 2, AttackBonus: 5, Speed: 12, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The ape makes two fist attacks."},
+		"black_bear":                {ID: "black_bear", Name: "Black Bear", CR: 0.5, HP: 19, AC: 11, Attack: 2, AttackBonus: 3, Speed: 16, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The bear makes two attacks: one with its bite and one with its claws. Traits: Keen Smell"},
+		"cockatrice":                {ID: "cockatrice", Name: "Cockatrice", CR: 0.5, HP: 27, AC: 11, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"crocodile":                 {ID: "crocodile", Name: "Crocodile", CR: 0.5, HP: 19, AC: 12, Attack: 2, AttackBonus: 4, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Hold Breath"},
+		"darkmantle":                {ID: "darkmantle", Name: "Darkmantle", CR: 0.5, HP: 22, AC: 11, Attack: 2, AttackBonus: 5, Speed: 6, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Echolocation, False Appearance"},
+		"deep_gnome_svirfneblin":    {ID: "deep_gnome_svirfneblin", Name: "Deep Gnome", CR: 0.5, HP: 16, AC: 15, Attack: 2, AttackBonus: 4, Speed: 8, BlockRate: 0.1, XPValue: 100, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Stone Camouflage, Gnome Cunning, Innate Spellcasting"},
+		"dust_mephit":               {ID: "dust_mephit", Name: "Dust Mephit", CR: 0.5, HP: 17, AC: 12, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Traits: Death Burst, Innate Spellcasting (1/Day)"},
+		"giant_goat":                {ID: "giant_goat", Name: "Giant Goat", CR: 0.5, HP: 19, AC: 11, Attack: 2, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge, Sure-Footed"},
+		"giant_sea_horse":           {ID: "giant_sea_horse", Name: "Giant Sea Horse", CR: 0.5, HP: 16, AC: 13, Attack: 2, AttackBonus: 3, Speed: 16, BlockRate: 0.05, XPValue: 100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge, Water Breathing"},
+		"giant_wasp":                {ID: "giant_wasp", Name: "Giant Wasp", CR: 0.5, HP: 13, AC: 12, Attack: 2, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"gnoll":                     {ID: "gnoll", Name: "Gnoll", CR: 0.5, HP: 22, AC: 15, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 100, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Rampage"},
+		"gray_ooze":                 {ID: "gray_ooze", Name: "Gray Ooze", CR: 0.5, HP: 22, AC: 10, Attack: 2, AttackBonus: 3, Speed: 6, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amorphous, Corrode Metal, False Appearance"},
+		"hobgoblin":                 {ID: "hobgoblin", Name: "Hobgoblin", CR: 0.5, HP: 11, AC: 18, Attack: 2, AttackBonus: 3, Speed: 12, BlockRate: 0.15, XPValue: 100, Ability: &MonsterAbility{Name: "Martial Advantage", Phase: "any", ProcChance: 0.35, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Martial Advantage (bonus_damage) wired from traits. Traits: Martial Advantage"},
+		"ice_mephit":                {ID: "ice_mephit", Name: "Ice Mephit", CR: 0.5, HP: 21, AC: 11, Attack: 2, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Traits: Death Burst, False Appearance, Innate Spellcasting (1/Day)"},
+		"lizardfolk":                {ID: "lizardfolk", Name: "Lizardfolk", CR: 0.5, HP: 22, AC: 15, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The lizardfolk makes two melee attacks, each one with a different weapon. Traits: Hold Breath"},
+		"magma_mephit":              {ID: "magma_mephit", Name: "Magma Mephit", CR: 0.5, HP: 22, AC: 11, Attack: 2, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Traits: Death Burst, False Appearance, Innate Spellcasting (1/Day)"},
+		"magmin":                    {ID: "magmin", Name: "Magmin", CR: 0.5, HP: 9, AC: 14, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 100, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Traits: Death Burst, Ignited Illumination", FireAttacker: true},
+		"orc":                       {ID: "orc", Name: "Orc", CR: 0.5, HP: 15, AC: 13, Attack: 2, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 100, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Aggressive"},
+		"reef_shark":                {ID: "reef_shark", Name: "Reef Shark", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 4, Speed: 16, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Pack Tactics, Water Breathing"},
+		"rust_monster":              {ID: "rust_monster", Name: "Rust Monster", CR: 0.5, HP: 27, AC: 14, Attack: 2, AttackBonus: 3, Speed: 16, BlockRate: 0.05, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Iron Scent, Rust Metal"},
+		"sahuagin":                  {ID: "sahuagin", Name: "Sahuagin", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 12, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Multiattack: The sahuagin makes two melee attacks: one with its bite and one with its claws or spear. Traits: Blood Frenzy, Limited Amphibiousness, Shark Telepathy"},
+		"satyr":                     {ID: "satyr", Name: "Satyr", CR: 0.5, HP: 31, AC: 14, Attack: 2, AttackBonus: 3, Speed: 16, BlockRate: 0.05, XPValue: 100, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Traits: Magic Resistance"},
+		"scout":                     {ID: "scout", Name: "Scout", CR: 0.5, HP: 16, AC: 13, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The scout makes two melee attacks or two ranged attacks. Traits: Keen Hearing and Sight"},
+		"shadow":                    {ID: "shadow", Name: "Shadow", CR: 0.5, HP: 16, AC: 12, Attack: 2, AttackBonus: 4, Speed: 16, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Surprise Attack", Phase: "opening", ProcChance: 0.8, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Surprise Attack (bonus_damage) wired from traits. Traits: Amorphous, Shadow Stealth, Sunlight Weakness"},
+		"swarm_of_beetles":          {ID: "swarm_of_beetles", Name: "Swarm of Beetles", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
+		"swarm_of_centipedes":       {ID: "swarm_of_centipedes", Name: "Swarm of Centipedes", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
+		"swarm_of_insects":          {ID: "swarm_of_insects", Name: "Swarm of Insects", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
+		"swarm_of_spiders":          {ID: "swarm_of_spiders", Name: "Swarm of Spiders", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm, Spider Climb, Web Sense, Web Walker"},
+		"swarm_of_wasps":            {ID: "swarm_of_wasps", Name: "Swarm of Wasps", CR: 0.5, HP: 22, AC: 12, Attack: 2, AttackBonus: 3, Speed: 6, BlockRate: 0, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
+		"thug":                      {ID: "thug", Name: "Thug", CR: 0.5, HP: 32, AC: 11, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Multiattack: The thug makes two melee attacks. Traits: Pack Tactics"},
+		"warhorse":                  {ID: "warhorse", Name: "Warhorse", CR: 0.5, HP: 19, AC: 11, Attack: 2, AttackBonus: 6, Speed: 18, BlockRate: 0, XPValue: 100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Trampling Charge"},
+		"warhorse_skeleton":         {ID: "warhorse_skeleton", Name: "Warhorse Skeleton", CR: 0.5, HP: 22, AC: 13, Attack: 2, AttackBonus: 6, Speed: 18, BlockRate: 0.05, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"worg":                      {ID: "worg", Name: "Worg", CR: 0.5, HP: 26, AC: 13, Attack: 2, AttackBonus: 5, Speed: 18, BlockRate: 0.05, XPValue: 100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Keen Hearing and Smell"},
+		"animated_armor":            {ID: "animated_armor", Name: "Animated Armor", CR: 1, HP: 33, AC: 18, Attack: 2, AttackBonus: 4, Speed: 10, BlockRate: 0.15, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The armor makes two melee attacks. Traits: Antimagic Susceptibility, False Appearance"},
+		"brass_dragon_wyrmling":     {ID: "brass_dragon_wyrmling", Name: "Brass Dragon Wyrmling", CR: 1, HP: 16, AC: 16, Attack: 2, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat).", FireAttacker: true},
+		"brown_bear":                {ID: "brown_bear", Name: "Brown Bear", CR: 1, HP: 34, AC: 11, Attack: 2, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The bear makes two attacks: one with its bite and one with its claws. Traits: Keen Smell"},
+		"bugbear":                   {ID: "bugbear", Name: "Bugbear", CR: 1, HP: 27, AC: 16, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 200, Ability: &MonsterAbility{Name: "Surprise Attack", Phase: "opening", ProcChance: 0.8, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Surprise Attack (bonus_damage) wired from traits. Traits: Brute, Surprise Attack"},
+		"copper_dragon_wyrmling":    {ID: "copper_dragon_wyrmling", Name: "Copper Dragon Wyrmling", CR: 1, HP: 22, AC: 16, Attack: 2, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"death_dog":                 {ID: "death_dog", Name: "Death Dog", CR: 1, HP: 39, AC: 12, Attack: 2, AttackBonus: 4, Speed: 16, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dog makes two bite attacks. Traits: Two-Headed"},
+		"dire_wolf":                 {ID: "dire_wolf", Name: "Dire Wolf", CR: 1, HP: 37, AC: 14, Attack: 2, AttackBonus: 5, Speed: 18, BlockRate: 0.05, XPValue: 200, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Hearing and Smell, Pack Tactics"},
+		"dryad":                     {ID: "dryad", Name: "Dryad", CR: 1, HP: 22, AC: 11, Attack: 2, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Innate Spellcasting, Magic Resistance, Speak with Beasts and Plants, Tree Stride"},
+		"duergar":                   {ID: "duergar", Name: "Duergar", CR: 1, HP: 26, AC: 16, Attack: 2, AttackBonus: 4, Speed: 10, BlockRate: 0.1, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Duergar Resilience, Sunlight Sensitivity"},
+		"ghoul":                     {ID: "ghoul", Name: "Ghoul", CR: 1, HP: 22, AC: 12, Attack: 2, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"giant_eagle":               {ID: "giant_eagle", Name: "Giant Eagle", CR: 1, HP: 26, AC: 13, Attack: 2, AttackBonus: 5, Speed: 6, BlockRate: 0.05, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The eagle makes two attacks: one with its beak and one with its talons. Traits: Keen Sight"},
+		"giant_hyena":               {ID: "giant_hyena", Name: "Giant Hyena", CR: 1, HP: 45, AC: 12, Attack: 2, AttackBonus: 5, Speed: 18, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Rampage"},
+		"giant_octopus":             {ID: "giant_octopus", Name: "Giant Octopus", CR: 1, HP: 52, AC: 11, Attack: 2, AttackBonus: 5, Speed: 6, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Hold Breath, Underwater Camouflage, Water Breathing"},
+		"giant_spider":              {ID: "giant_spider", Name: "Giant Spider", CR: 1, HP: 26, AC: 14, Attack: 2, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Spider Climb, Web Sense, Web Walker"},
+		"giant_toad":                {ID: "giant_toad", Name: "Giant Toad", CR: 1, HP: 39, AC: 11, Attack: 2, AttackBonus: 4, Speed: 8, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Amphibious, Standing Leap"},
+		"giant_vulture":             {ID: "giant_vulture", Name: "Giant Vulture", CR: 1, HP: 22, AC: 10, Attack: 2, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Multiattack: The vulture makes two attacks: one with its beak and one with its talons. Traits: Keen Sight and Smell, Pack Tactics"},
+		"harpy":                     {ID: "harpy", Name: "Harpy", CR: 1, HP: 38, AC: 11, Attack: 2, AttackBonus: 3, Speed: 8, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The harpy makes two attacks: one with its claws and one with its club."},
+		"hippogriff":                {ID: "hippogriff", Name: "Hippogriff", CR: 1, HP: 19, AC: 11, Attack: 2, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The hippogriff makes two attacks: one with its beak and one with its claws. Traits: Keen Sight"},
+		"imp":                       {ID: "imp", Name: "Imp", CR: 1, HP: 10, AC: 13, Attack: 2, AttackBonus: 5, Speed: 8, BlockRate: 0.05, XPValue: 200, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Traits: Shapechanger, Devil's Sight, Magic Resistance, Variant: Familiar"},
+		"lion":                      {ID: "lion", Name: "Lion", CR: 1, HP: 26, AC: 12, Attack: 2, AttackBonus: 5, Speed: 18, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Keen Smell, Pack Tactics, Pounce, Running Leap"},
+		"quasit":                    {ID: "quasit", Name: "Quasit", CR: 1, HP: 7, AC: 13, Attack: 2, AttackBonus: 4, Speed: 16, BlockRate: 0.05, XPValue: 200, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Traits: Shapechanger, Magic Resistance, Variant: Familiar"},
+		"specter":                   {ID: "specter", Name: "Specter", CR: 1, HP: 22, AC: 12, Attack: 2, AttackBonus: 4, Speed: 18, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Incorporeal Movement, Sunlight Sensitivity"},
+		"spy":                       {ID: "spy", Name: "Spy", CR: 1, HP: 27, AC: 12, Attack: 2, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Martial Advantage", Phase: "any", ProcChance: 0.35, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Martial Advantage (bonus_damage) wired from traits. Multiattack: The spy makes two melee attacks. Traits: Cunning Action, Sneak Attack (1/Turn)"},
+		"swarm_of_quippers":         {ID: "swarm_of_quippers", Name: "Swarm of Quippers", CR: 1, HP: 28, AC: 13, Attack: 2, AttackBonus: 5, Speed: 16, BlockRate: 0.05, XPValue: 200, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Blood Frenzy, Swarm, Water Breathing"},
+		"tiger":                     {ID: "tiger", Name: "Tiger", CR: 1, HP: 37, AC: 12, Attack: 2, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 200, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Keen Smell, Pounce"},
+		"ankheg":                    {ID: "ankheg", Name: "Ankheg", CR: 2, HP: 39, AC: 14, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"awakened_tree":             {ID: "awakened_tree", Name: "Awakened Tree", CR: 2, HP: 59, AC: 13, Attack: 4, AttackBonus: 6, Speed: 8, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: False Appearance"},
+		"azer":                      {ID: "azer", Name: "Azer", CR: 2, HP: 39, AC: 17, Attack: 4, AttackBonus: 5, Speed: 12, BlockRate: 0.1, XPValue: 450, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Traits: Heated Body, Heated Weapons, Illumination"},
+		"bandit_captain":            {ID: "bandit_captain", Name: "Bandit Captain", CR: 2, HP: 65, AC: 15, Attack: 4, AttackBonus: 5, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The captain makes three melee attacks: two with its scimitar and one with its dagger."},
+		"berserker":                 {ID: "berserker", Name: "Berserker", CR: 2, HP: 67, AC: 13, Attack: 4, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 450, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Reckless"},
+		"black_dragon_wyrmling":     {ID: "black_dragon_wyrmling", Name: "Black Dragon Wyrmling", CR: 2, HP: 33, AC: 17, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
+		"bronze_dragon_wyrmling":    {ID: "bronze_dragon_wyrmling", Name: "Bronze Dragon Wyrmling", CR: 2, HP: 32, AC: 17, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
+		"centaur":                   {ID: "centaur", Name: "Centaur", CR: 2, HP: 45, AC: 12, Attack: 4, AttackBonus: 6, Speed: 18, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Multiattack: The centaur makes two attacks: one with its pike and one with its hooves or two with its longbow. Traits: Charge"},
+		"cult_fanatic":              {ID: "cult_fanatic", Name: "Cult Fanatic", CR: 2, HP: 22, AC: 13, Attack: 4, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 450, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The fanatic makes two melee attacks. Traits: Dark Devotion, Spellcasting"},
+		"druid":                     {ID: "druid", Name: "Druid", CR: 2, HP: 27, AC: 11, Attack: 4, AttackBonus: 2, Speed: 12, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Spellcasting"},
+		"ettercap":                  {ID: "ettercap", Name: "Ettercap", CR: 2, HP: 44, AC: 13, Attack: 4, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The ettercap makes two attacks: one with its bite and one with its claws. Traits: Spider Climb, Web Sense, Web Walker"},
+		"gargoyle":                  {ID: "gargoyle", Name: "Gargoyle", CR: 2, HP: 52, AC: 15, Attack: 4, AttackBonus: 4, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The gargoyle makes two attacks: one with its bite and one with its claws. Traits: False Appearance"},
+		"gelatinous_cube":           {ID: "gelatinous_cube", Name: "Gelatinous Cube", CR: 2, HP: 84, AC: 10, Attack: 4, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Ooze Cube, Transparent"},
+		"ghast":                     {ID: "ghast", Name: "Ghast", CR: 2, HP: 36, AC: 13, Attack: 4, AttackBonus: 3, Speed: 12, BlockRate: 0.05, XPValue: 450, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Traits: Stench, Turn Defiance"},
+		"giant_boar":                {ID: "giant_boar", Name: "Giant Boar", CR: 2, HP: 42, AC: 12, Attack: 4, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge, Relentless (Recharges after a Short or Long Rest)"},
+		"giant_constrictor_snake":   {ID: "giant_constrictor_snake", Name: "Giant Constrictor Snake", CR: 2, HP: 60, AC: 12, Attack: 4, AttackBonus: 6, Speed: 12, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"giant_elk":                 {ID: "giant_elk", Name: "Giant Elk", CR: 2, HP: 42, AC: 15, Attack: 4, AttackBonus: 6, Speed: 18, BlockRate: 0.1, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge"},
+		"gibbering_mouther":         {ID: "gibbering_mouther", Name: "Gibbering Mouther", CR: 2, HP: 67, AC: 10, Attack: 4, AttackBonus: 2, Speed: 6, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The gibbering mouther makes one bite attack and, if it can, uses its Blinding Spittle. Traits: Aberrant Ground, Gibbering"},
+		"green_dragon_wyrmling":     {ID: "green_dragon_wyrmling", Name: "Green Dragon Wyrmling", CR: 2, HP: 38, AC: 17, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious"},
+		"grick":                     {ID: "grick", Name: "Grick", CR: 2, HP: 27, AC: 14, Attack: 4, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The grick makes one attack with its tentacles. Traits: Stone Camouflage"},
+		"griffon":                   {ID: "griffon", Name: "Griffon", CR: 2, HP: 59, AC: 12, Attack: 4, AttackBonus: 6, Speed: 12, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The griffon makes two attacks: one with its beak and one with its claws. Traits: Keen Sight"},
+		"hunter_shark":              {ID: "hunter_shark", Name: "Hunter Shark", CR: 2, HP: 45, AC: 12, Attack: 4, AttackBonus: 6, Speed: 16, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Blood Frenzy, Water Breathing"},
+		"merrow":                    {ID: "merrow", Name: "Merrow", CR: 2, HP: 45, AC: 13, Attack: 4, AttackBonus: 6, Speed: 6, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The merrow makes two attacks: one with its bite and one with its claws or harpoon. Traits: Amphibious"},
+		"mimic":                     {ID: "mimic", Name: "Mimic", CR: 2, HP: 58, AC: 12, Attack: 4, AttackBonus: 5, Speed: 6, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Shapechanger, Adhesive (Object Form Only), False Appearance (Object Form Only), Grappler"},
+		"minotaur_skeleton":         {ID: "minotaur_skeleton", Name: "Minotaur Skeleton", CR: 2, HP: 67, AC: 12, Attack: 4, AttackBonus: 6, Speed: 16, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge"},
+		"ochre_jelly":               {ID: "ochre_jelly", Name: "Ochre Jelly", CR: 2, HP: 45, AC: 10, Attack: 4, AttackBonus: 4, Speed: 6, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amorphous, Spider Climb"},
+		"ogre":                      {ID: "ogre", Name: "Ogre", CR: 2, HP: 59, AC: 11, Attack: 4, AttackBonus: 6, Speed: 16, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"ogre_zombie":               {ID: "ogre_zombie", Name: "Ogre Zombie", CR: 2, HP: 85, AC: 10, Attack: 4, AttackBonus: 6, Speed: 12, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Undead Fortitude", Phase: "decisive", ProcChance: 0.5, Effect: "survive_at_1"}, Notes: "SRD-tuned baseline — Undead Fortitude (survive_at_1) wired from traits. Traits: Undead Fortitude"},
+		"pegasus":                   {ID: "pegasus", Name: "Pegasus", CR: 2, HP: 59, AC: 12, Attack: 4, AttackBonus: 6, Speed: 18, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"plesiosaurus":              {ID: "plesiosaurus", Name: "Plesiosaurus", CR: 2, HP: 68, AC: 13, Attack: 4, AttackBonus: 6, Speed: 8, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Hold Breath"},
+		"polar_bear":                {ID: "polar_bear", Name: "Polar Bear", CR: 2, HP: 42, AC: 12, Attack: 4, AttackBonus: 7, Speed: 16, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The bear makes two attacks: one with its bite and one with its claws. Traits: Keen Smell"},
+		"priest":                    {ID: "priest", Name: "Priest", CR: 2, HP: 27, AC: 13, Attack: 4, AttackBonus: 2, Speed: 10, BlockRate: 0.05, XPValue: 450, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Divine Eminence, Spellcasting"},
+		"rhinoceros":                {ID: "rhinoceros", Name: "Rhinoceros", CR: 2, HP: 45, AC: 11, Attack: 4, AttackBonus: 7, Speed: 16, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Charge"},
+		"rug_of_smothering":         {ID: "rug_of_smothering", Name: "Rug of Smothering", CR: 2, HP: 33, AC: 12, Attack: 4, AttackBonus: 0, Speed: 6, BlockRate: 0, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Antimagic Susceptibility, Damage Transfer, False Appearance"},
+		"saber_toothed_tiger":       {ID: "saber_toothed_tiger", Name: "Saber-Toothed Tiger", CR: 2, HP: 52, AC: 12, Attack: 4, AttackBonus: 6, Speed: 16, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Keen Smell, Pounce"},
+		"sea_hag":                   {ID: "sea_hag", Name: "Sea Hag", CR: 2, HP: 52, AC: 14, Attack: 4, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 450, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Amphibious, Horrific Appearance, Hag Coven, Shared Spellcasting (Coven Only), Hag Eye (Coven Only)"},
+		"silver_dragon_wyrmling":    {ID: "silver_dragon_wyrmling", Name: "Silver Dragon Wyrmling", CR: 2, HP: 45, AC: 17, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
 		"swarm_of_poisonous_snakes": {ID: "swarm_of_poisonous_snakes", Name: "Swarm of Poisonous Snakes", CR: 2, HP: 36, AC: 14, Attack: 4, AttackBonus: 6, Speed: 12, BlockRate: 0.05, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Swarm"},
-		"wererat": {ID: "wererat", Name: "Wererat", CR: 2, HP: 33, AC: 12, Attack: 4, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Shapechanger, Keen Smell"},
-		"white_dragon_wyrmling": {ID: "white_dragon_wyrmling", Name: "White Dragon Wyrmling", CR: 2, HP: 32, AC: 16, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"will_o_wisp": {ID: "will_o_wisp", Name: "Will-o'-Wisp", CR: 2, HP: 22, AC: 19, Attack: 4, AttackBonus: 4, Speed: 18, BlockRate: 0.15, XPValue: 450, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Consume Life, Ephemeral, Incorporeal Movement, Variable Illumination"},
-		"basilisk": {ID: "basilisk", Name: "Basilisk", CR: 3, HP: 52, AC: 12, Attack: 6, AttackBonus: 5, Speed: 8, BlockRate: 0, XPValue: 700, Ability: &MonsterAbility{Name: "Frightful Presence", Phase: "opening", ProcChance: 0.4, Effect: "stun"}, Notes: "SRD-tuned baseline — Frightful Presence (stun) wired from traits. Traits: Petrifying Gaze"},
-		"bearded_devil": {ID: "bearded_devil", Name: "Bearded Devil", CR: 3, HP: 52, AC: 13, Attack: 6, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 700, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes two attacks: one with its beard and one with its glaive. Traits: Devil's Sight, Magic Resistance, Steadfast"},
-		"blue_dragon_wyrmling": {ID: "blue_dragon_wyrmling", Name: "Blue Dragon Wyrmling", CR: 3, HP: 52, AC: 17, Attack: 6, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
-		"doppelganger": {ID: "doppelganger", Name: "Doppelganger", CR: 3, HP: 52, AC: 14, Attack: 6, AttackBonus: 6, Speed: 12, BlockRate: 0.05, XPValue: 700, Ability: &MonsterAbility{Name: "Surprise Attack", Phase: "opening", ProcChance: 0.8, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Surprise Attack (bonus_damage) wired from traits. Multiattack: The doppelganger makes two melee attacks. Traits: Shapechanger, Ambusher, Surprise Attack"},
-		"giant_scorpion": {ID: "giant_scorpion", Name: "Giant Scorpion", CR: 3, HP: 52, AC: 15, Attack: 6, AttackBonus: 4, Speed: 16, BlockRate: 0.1, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The scorpion makes three attacks: two with its claws and one with its sting."},
-		"gold_dragon_wyrmling": {ID: "gold_dragon_wyrmling", Name: "Gold Dragon Wyrmling", CR: 3, HP: 60, AC: 17, Attack: 6, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious", FireAttacker: true},
-		"green_hag": {ID: "green_hag", Name: "Green Hag", CR: 3, HP: 82, AC: 17, Attack: 6, AttackBonus: 6, Speed: 12, BlockRate: 0.1, XPValue: 700, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Amphibious, Innate Spellcasting, Mimicry, Hag Coven, Shared Spellcasting (Coven Only), Hag Eye (Coven Only)"},
-		"hell_hound": {ID: "hell_hound", Name: "Hell Hound", CR: 3, HP: 45, AC: 15, Attack: 6, AttackBonus: 0, Speed: 18, BlockRate: 0.1, XPValue: 700, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Hearing and Smell, Pack Tactics", FireAttacker: true},
-		"killer_whale": {ID: "killer_whale", Name: "Killer Whale", CR: 3, HP: 90, AC: 12, Attack: 6, AttackBonus: 0, Speed: 18, BlockRate: 0, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Echolocation, Hold Breath, Keen Hearing"},
-		"knight": {ID: "knight", Name: "Knight", CR: 3, HP: 52, AC: 18, Attack: 6, AttackBonus: 5, Speed: 12, BlockRate: 0.15, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The knight makes two melee attacks. Traits: Brave"},
-		"manticore": {ID: "manticore", Name: "Manticore", CR: 3, HP: 68, AC: 14, Attack: 6, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The manticore makes three attacks: one with its bite and two with its claws or three with its tail spikes. Traits: Tail Spike Regrowth"},
-		"minotaur": {ID: "minotaur", Name: "Minotaur", CR: 3, HP: 76, AC: 14, Attack: 6, AttackBonus: 6, Speed: 16, BlockRate: 0.05, XPValue: 700, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Charge, Labyrinthine Recall, Reckless"},
-		"mummy": {ID: "mummy", Name: "Mummy", CR: 3, HP: 58, AC: 11, Attack: 6, AttackBonus: 5, Speed: 8, BlockRate: 0, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The mummy can use its Dreadful Glare and makes one attack with its rotting fist."},
-		"nightmare": {ID: "nightmare", Name: "Nightmare", CR: 3, HP: 68, AC: 13, Attack: 6, AttackBonus: 6, Speed: 18, BlockRate: 0.05, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Confer Fire Resistance, Illumination"},
-		"owlbear": {ID: "owlbear", Name: "Owlbear", CR: 3, HP: 59, AC: 13, Attack: 6, AttackBonus: 7, Speed: 16, BlockRate: 0.05, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The owlbear makes two attacks: one with its beak and one with its claws. Traits: Keen Sight and Smell"},
-		"phase_spider": {ID: "phase_spider", Name: "Phase Spider", CR: 3, HP: 32, AC: 13, Attack: 6, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 700, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Ethereal Jaunt, Spider Climb, Web Walker"},
-		"veteran": {ID: "veteran", Name: "Veteran", CR: 3, HP: 58, AC: 17, Attack: 6, AttackBonus: 5, Speed: 12, BlockRate: 0.1, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The veteran makes two longsword attacks."},
-		"werewolf": {ID: "werewolf", Name: "Werewolf", CR: 3, HP: 58, AC: 11, Attack: 6, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 700, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Shapechanger, Keen Hearing and Smell"},
-		"wight": {ID: "wight", Name: "Wight", CR: 3, HP: 45, AC: 14, Attack: 6, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The wight makes two longsword attacks or two longbow attacks. Traits: Sunlight Sensitivity"},
-		"winter_wolf": {ID: "winter_wolf", Name: "Winter Wolf", CR: 3, HP: 75, AC: 13, Attack: 6, AttackBonus: 0, Speed: 18, BlockRate: 0.05, XPValue: 700, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Hearing and Smell, Pack Tactics, Snow Camouflage"},
-		"black_pudding": {ID: "black_pudding", Name: "Black Pudding", CR: 4, HP: 85, AC: 10, Attack: 7, AttackBonus: 5, Speed: 8, BlockRate: 0, XPValue: 1100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amorphous, Corrosive Form, Spider Climb"},
-		"chuul": {ID: "chuul", Name: "Chuul", CR: 4, HP: 93, AC: 16, Attack: 7, AttackBonus: 6, Speed: 12, BlockRate: 0.1, XPValue: 1100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The chuul makes two pincer attacks. Traits: Amphibious, Sense Magic"},
-		"couatl": {ID: "couatl", Name: "Couatl", CR: 4, HP: 97, AC: 19, Attack: 7, AttackBonus: 6, Speed: 12, BlockRate: 0.15, XPValue: 1100, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Innate Spellcasting, Magic Weapons, Shielded Mind"},
-		"elephant": {ID: "elephant", Name: "Elephant", CR: 4, HP: 76, AC: 12, Attack: 7, AttackBonus: 8, Speed: 16, BlockRate: 0, XPValue: 1100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Trampling Charge"},
-		"ettin": {ID: "ettin", Name: "Ettin", CR: 4, HP: 85, AC: 12, Attack: 7, AttackBonus: 7, Speed: 16, BlockRate: 0, XPValue: 1100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The ettin makes two attacks: one with its battleaxe and one with its morningstar. Traits: Two Heads, Wakeful"},
-		"ghost": {ID: "ghost", Name: "Ghost", CR: 4, HP: 45, AC: 11, Attack: 7, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 1100, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Ethereal Sight, Incorporeal Movement"},
-		"lamia": {ID: "lamia", Name: "Lamia", CR: 4, HP: 97, AC: 13, Attack: 7, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 1100, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The lamia makes two attacks: one with its claws and one with its dagger or Intoxicating Touch. Traits: Innate Spellcasting"},
-		"red_dragon_wyrmling": {ID: "red_dragon_wyrmling", Name: "Red Dragon Wyrmling", CR: 4, HP: 75, AC: 17, Attack: 7, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 1100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat).", FireAttacker: true},
-		"succubusincubus": {ID: "succubusincubus", Name: "Succubus/Incubus", CR: 4, HP: 66, AC: 15, Attack: 7, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 1100, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Telepathic Bond, Shapechanger"},
-		"wereboar": {ID: "wereboar", Name: "Wereboar", CR: 4, HP: 78, AC: 10, Attack: 7, AttackBonus: 5, Speed: 12, BlockRate: 0, XPValue: 1100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Shapechanger, Charge (Boar or Hybrid Form Only), Relentless (Recharges after a Short or Long Rest)"},
-		"weretiger": {ID: "weretiger", Name: "Weretiger", CR: 4, HP: 120, AC: 12, Attack: 7, AttackBonus: 5, Speed: 12, BlockRate: 0, XPValue: 1100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Shapechanger, Keen Hearing and Smell, Pounce (Tiger or Hybrid Form Only)"},
-		"air_elemental": {ID: "air_elemental", Name: "Air Elemental", CR: 5, HP: 90, AC: 15, Attack: 8, AttackBonus: 8, Speed: 18, BlockRate: 0.1, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The elemental makes two slam attacks. Traits: Air Form"},
-		"barbed_devil": {ID: "barbed_devil", Name: "Barbed Devil", CR: 5, HP: 110, AC: 15, Attack: 8, AttackBonus: 6, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes three melee attacks: one with its tail and two with its claws. Traits: Barbed Hide, Devil's Sight, Magic Resistance"},
-		"bulette": {ID: "bulette", Name: "Bulette", CR: 5, HP: 94, AC: 17, Attack: 8, AttackBonus: 7, Speed: 16, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Standing Leap"},
-		"earth_elemental": {ID: "earth_elemental", Name: "Earth Elemental", CR: 5, HP: 126, AC: 17, Attack: 8, AttackBonus: 8, Speed: 12, BlockRate: 0.1, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The elemental makes two slam attacks. Traits: Earth Glide, Siege Monster"},
-		"fire_elemental": {ID: "fire_elemental", Name: "Fire Elemental", CR: 5, HP: 102, AC: 13, Attack: 8, AttackBonus: 6, Speed: 18, BlockRate: 0.05, XPValue: 1800, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Multiattack: The elemental makes two touch attacks. Traits: Fire Form, Illumination, Water Susceptibility", FireAttacker: true},
-		"flesh_golem": {ID: "flesh_golem", Name: "Flesh Golem", CR: 5, HP: 93, AC: 10, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0, XPValue: 1800, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The golem makes two slam attacks. Traits: Berserk, Aversion of Fire, Immutable Form, Lightning Absorption, Magic Resistance, Magic Weapons"},
-		"giant_crocodile": {ID: "giant_crocodile", Name: "Giant Crocodile", CR: 5, HP: 85, AC: 14, Attack: 8, AttackBonus: 8, Speed: 12, BlockRate: 0.05, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The crocodile makes two attacks: one with its bite and one with its tail. Traits: Hold Breath"},
-		"giant_shark": {ID: "giant_shark", Name: "Giant Shark", CR: 5, HP: 126, AC: 13, Attack: 8, AttackBonus: 9, Speed: 18, BlockRate: 0.05, XPValue: 1800, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Blood Frenzy, Water Breathing"},
-		"gladiator": {ID: "gladiator", Name: "Gladiator", CR: 5, HP: 112, AC: 16, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Multiattack: The gladiator makes three melee attacks or two ranged attacks. Traits: Brave, Brute"},
-		"gorgon": {ID: "gorgon", Name: "Gorgon", CR: 5, HP: 114, AC: 19, Attack: 8, AttackBonus: 8, Speed: 16, BlockRate: 0.15, XPValue: 1800, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Trampling Charge"},
-		"half_red_dragon_veteran": {ID: "half_red_dragon_veteran", Name: "Half-Red Dragon Veteran", CR: 5, HP: 65, AC: 18, Attack: 8, AttackBonus: 0, Speed: 12, BlockRate: 0.15, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The veteran makes two longsword attacks.", FireAttacker: true},
-		"hill_giant": {ID: "hill_giant", Name: "Hill Giant", CR: 5, HP: 105, AC: 13, Attack: 8, AttackBonus: 8, Speed: 16, BlockRate: 0.05, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The giant makes two greatclub attacks."},
-		"night_hag": {ID: "night_hag", Name: "Night Hag", CR: 5, HP: 112, AC: 17, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Innate Spellcasting, Magic Resistance, Night Hag Items, Hag Coven, Shared Spellcasting (Coven Only), Hag Eye (Coven Only)"},
-		"otyugh": {ID: "otyugh", Name: "Otyugh", CR: 5, HP: 114, AC: 14, Attack: 8, AttackBonus: 6, Speed: 12, BlockRate: 0.05, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The otyugh makes three attacks: one with its bite and two with its tentacles. Traits: Limited Telepathy"},
-		"roper": {ID: "roper", Name: "Roper", CR: 5, HP: 93, AC: 20, Attack: 8, AttackBonus: 7, Speed: 6, BlockRate: 0.15, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The roper makes four attacks with its tendrils, uses Reel, and makes one attack with its bite. Traits: False Appearance, Grasping Tendrils, Spider Climb"},
-		"salamander": {ID: "salamander", Name: "Salamander", CR: 5, HP: 90, AC: 15, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Multiattack: The salamander makes two attacks: one with its spear and one with its tail. Traits: Heated Body, Heated Weapons"},
-		"shambling_mound": {ID: "shambling_mound", Name: "Shambling Mound", CR: 5, HP: 136, AC: 15, Attack: 8, AttackBonus: 7, Speed: 8, BlockRate: 0.1, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The shambling mound makes two slam attacks. Traits: Lightning Absorption"},
-		"triceratops": {ID: "triceratops", Name: "Triceratops", CR: 5, HP: 95, AC: 13, Attack: 8, AttackBonus: 9, Speed: 18, BlockRate: 0.05, XPValue: 1800, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Trampling Charge"},
-		"troll": {ID: "troll", Name: "Troll", CR: 5, HP: 84, AC: 15, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Regeneration", Phase: "any", ProcChance: 0.5, Effect: "regenerate"}, Notes: "SRD-tuned baseline — Regeneration (regenerate) wired from traits. Multiattack: The troll makes three attacks: one with its bite and two with its claws. Traits: Keen Smell, Regeneration, Variant: Loathsome Limbs"},
-		"unicorn": {ID: "unicorn", Name: "Unicorn", CR: 5, HP: 67, AC: 12, Attack: 8, AttackBonus: 7, Speed: 18, BlockRate: 0, XPValue: 1800, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The unicorn makes two attacks: one with its hooves and one with its horn. Traits: Charge, Innate Spellcasting, Magic Resistance, Magic Weapons"},
-		"vampire_spawn": {ID: "vampire_spawn", Name: "Vampire Spawn", CR: 5, HP: 82, AC: 15, Attack: 8, AttackBonus: 6, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Regeneration", Phase: "any", ProcChance: 0.5, Effect: "regenerate"}, Notes: "SRD-tuned baseline — Regeneration (regenerate) wired from traits. Multiattack: The vampire makes two attacks, only one of which can be a bite attack. Traits: Regeneration, Spider Climb, Vampire Weaknesses"},
-		"water_elemental": {ID: "water_elemental", Name: "Water Elemental", CR: 5, HP: 114, AC: 14, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0.05, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The elemental makes two slam attacks. Traits: Water Form, Freeze"},
-		"werebear": {ID: "werebear", Name: "Werebear", CR: 5, HP: 135, AC: 10, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0, XPValue: 1800, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Multiattack: In bear form, the werebear makes two claw attacks. Traits: Shapechanger, Keen Smell"},
-		"wraith": {ID: "wraith", Name: "Wraith", CR: 5, HP: 67, AC: 13, Attack: 8, AttackBonus: 6, Speed: 18, BlockRate: 0.05, XPValue: 1800, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Incorporeal Movement, Sunlight Sensitivity"},
-		"xorn": {ID: "xorn", Name: "Xorn", CR: 5, HP: 73, AC: 19, Attack: 8, AttackBonus: 6, Speed: 8, BlockRate: 0.15, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The xorn makes three claw attacks and one bite attack. Traits: Earth Glide, Stone Camouflage, Treasure Sense"},
-		"chimera": {ID: "chimera", Name: "Chimera", CR: 6, HP: 114, AC: 14, Attack: 10, AttackBonus: 0, Speed: 12, BlockRate: 0.05, XPValue: 2300, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The chimera makes three attacks: one with its bite, one with its horns, and one with its claws.", FireAttacker: true},
-		"drider": {ID: "drider", Name: "Drider", CR: 6, HP: 123, AC: 19, Attack: 10, AttackBonus: 6, Speed: 12, BlockRate: 0.15, XPValue: 2300, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The drider makes three attacks, either with its longsword or its longbow. Traits: Fey Ancestry, Innate Spellcasting, Spider Climb, Sunlight Sensitivity, Web Walker"},
-		"invisible_stalker": {ID: "invisible_stalker", Name: "Invisible Stalker", CR: 6, HP: 104, AC: 14, Attack: 10, AttackBonus: 6, Speed: 18, BlockRate: 0.05, XPValue: 2300, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The stalker makes two slam attacks. Traits: Invisibility, Faultless Tracker"},
-		"mage": {ID: "mage", Name: "Mage", CR: 6, HP: 40, AC: 12, Attack: 10, AttackBonus: 5, Speed: 12, BlockRate: 0, XPValue: 2300, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Spellcasting"},
-		"mammoth": {ID: "mammoth", Name: "Mammoth", CR: 6, HP: 126, AC: 13, Attack: 10, AttackBonus: 10, Speed: 16, BlockRate: 0.05, XPValue: 2300, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Trampling Charge"},
-		"medusa": {ID: "medusa", Name: "Medusa", CR: 6, HP: 127, AC: 15, Attack: 10, AttackBonus: 5, Speed: 12, BlockRate: 0.1, XPValue: 2300, Ability: &MonsterAbility{Name: "Frightful Presence", Phase: "opening", ProcChance: 0.4, Effect: "stun"}, Notes: "SRD-tuned baseline — Frightful Presence (stun) wired from traits. Multiattack: The medusa makes either three melee attacks - one with its snake hair and two with its shortsword - or two ranged attacks with its longbow. Traits: Petrifying Gaze"},
-		"vrock": {ID: "vrock", Name: "Vrock", CR: 6, HP: 104, AC: 15, Attack: 10, AttackBonus: 6, Speed: 16, BlockRate: 0.1, XPValue: 2300, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The vrock makes two attacks: one with its beak and one with its talons. Traits: Magic Resistance"},
-		"wyvern": {ID: "wyvern", Name: "Wyvern", CR: 6, HP: 110, AC: 13, Attack: 10, AttackBonus: 7, Speed: 8, BlockRate: 0.05, XPValue: 2300, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The wyvern makes two attacks: one with its bite and one with its stinger."},
-		"young_brass_dragon": {ID: "young_brass_dragon", Name: "Young Brass Dragon", CR: 6, HP: 110, AC: 17, Attack: 10, AttackBonus: 0, Speed: 16, BlockRate: 0.1, XPValue: 2300, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws.", FireAttacker: true},
-		"young_white_dragon": {ID: "young_white_dragon", Name: "Young White Dragon", CR: 6, HP: 133, AC: 17, Attack: 10, AttackBonus: 0, Speed: 16, BlockRate: 0.1, XPValue: 2300, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws. Traits: Ice Walk"},
-		"giant_ape": {ID: "giant_ape", Name: "Giant Ape", CR: 7, HP: 157, AC: 12, Attack: 12, AttackBonus: 9, Speed: 16, BlockRate: 0, XPValue: 2900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The ape makes two fist attacks."},
-		"oni": {ID: "oni", Name: "Oni", CR: 7, HP: 110, AC: 16, Attack: 12, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 2900, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The oni makes two attacks, either with its claws or its glaive. Traits: Innate Spellcasting, Magic Weapons, Regeneration"},
-		"shield_guardian": {ID: "shield_guardian", Name: "Shield Guardian", CR: 7, HP: 142, AC: 17, Attack: 12, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 2900, Ability: &MonsterAbility{Name: "Regeneration", Phase: "any", ProcChance: 0.5, Effect: "regenerate"}, Notes: "SRD-tuned baseline — Regeneration (regenerate) wired from traits. Multiattack: The guardian makes two fist attacks. Traits: Bound, Regeneration, Spell Storing"},
-		"stone_giant": {ID: "stone_giant", Name: "Stone Giant", CR: 7, HP: 126, AC: 17, Attack: 12, AttackBonus: 9, Speed: 16, BlockRate: 0.1, XPValue: 2900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The giant makes two greatclub attacks. Traits: Stone Camouflage"},
-		"young_black_dragon": {ID: "young_black_dragon", Name: "Young Black Dragon", CR: 7, HP: 127, AC: 18, Attack: 12, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 2900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws. Traits: Amphibious"},
-		"young_copper_dragon": {ID: "young_copper_dragon", Name: "Young Copper Dragon", CR: 7, HP: 119, AC: 17, Attack: 12, AttackBonus: 0, Speed: 16, BlockRate: 0.1, XPValue: 2900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws."},
-		"assassin": {ID: "assassin", Name: "Assassin", CR: 8, HP: 78, AC: 15, Attack: 13, AttackBonus: 6, Speed: 12, BlockRate: 0.1, XPValue: 3900, Ability: &MonsterAbility{Name: "Surprise Attack", Phase: "opening", ProcChance: 0.8, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Surprise Attack (bonus_damage) wired from traits. Multiattack: The assassin makes two shortsword attacks. Traits: Assassinate, Evasion, Sneak Attack (1/Turn)"},
-		"cloaker": {ID: "cloaker", Name: "Cloaker", CR: 8, HP: 78, AC: 14, Attack: 13, AttackBonus: 6, Speed: 6, BlockRate: 0.05, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The cloaker makes two attacks: one with its bite and one with its tail. Traits: Damage Transfer, False Appearance, Light Sensitivity"},
-		"frost_giant": {ID: "frost_giant", Name: "Frost Giant", CR: 8, HP: 138, AC: 15, Attack: 13, AttackBonus: 9, Speed: 16, BlockRate: 0.1, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The giant makes two greataxe attacks."},
-		"hezrou": {ID: "hezrou", Name: "Hezrou", CR: 8, HP: 136, AC: 16, Attack: 13, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 3900, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The hezrou makes three attacks: one with its bite and two with its claws. Traits: Magic Resistance, Stench"},
-		"hydra": {ID: "hydra", Name: "Hydra", CR: 8, HP: 172, AC: 15, Attack: 13, AttackBonus: 8, Speed: 12, BlockRate: 0.1, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The hydra makes as many bite attacks as it has heads. Traits: Hold Breath, Multiple Heads, Reactive Heads, Wakeful"},
-		"spirit_naga": {ID: "spirit_naga", Name: "Spirit Naga", CR: 8, HP: 75, AC: 15, Attack: 13, AttackBonus: 7, Speed: 16, BlockRate: 0.1, XPValue: 3900, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Rejuvenation, Spellcasting"},
-		"tyrannosaurus_rex": {ID: "tyrannosaurus_rex", Name: "Tyrannosaurus Rex", CR: 8, HP: 136, AC: 13, Attack: 13, AttackBonus: 10, Speed: 18, BlockRate: 0.05, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The tyrannosaurus makes two attacks: one with its bite and one with its tail."},
-		"young_bronze_dragon": {ID: "young_bronze_dragon", Name: "Young Bronze Dragon", CR: 8, HP: 142, AC: 18, Attack: 13, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws. Traits: Amphibious"},
-		"young_green_dragon": {ID: "young_green_dragon", Name: "Young Green Dragon", CR: 8, HP: 136, AC: 18, Attack: 13, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws. Traits: Amphibious"},
-		"bone_devil": {ID: "bone_devil", Name: "Bone Devil", CR: 9, HP: 142, AC: 19, Attack: 14, AttackBonus: 8, Speed: 16, BlockRate: 0.15, XPValue: 5000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes three attacks: two with its claws and one with its sting. Traits: Devil's Sight, Magic Resistance"},
-		"clay_golem": {ID: "clay_golem", Name: "Clay Golem", CR: 9, HP: 133, AC: 14, Attack: 14, AttackBonus: 8, Speed: 8, BlockRate: 0.05, XPValue: 5000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The golem makes two slam attacks. Traits: Acid Absorption, Berserk, Immutable Form, Magic Resistance, Magic Weapons"},
-		"cloud_giant": {ID: "cloud_giant", Name: "Cloud Giant", CR: 9, HP: 200, AC: 14, Attack: 14, AttackBonus: 12, Speed: 16, BlockRate: 0.05, XPValue: 5000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The giant makes two morningstar attacks. Traits: Keen Smell, Innate Spellcasting"},
-		"fire_giant": {ID: "fire_giant", Name: "Fire Giant", CR: 9, HP: 162, AC: 18, Attack: 14, AttackBonus: 11, Speed: 12, BlockRate: 0.15, XPValue: 5000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The giant makes two greatsword attacks."},
-		"glabrezu": {ID: "glabrezu", Name: "Glabrezu", CR: 9, HP: 157, AC: 17, Attack: 14, AttackBonus: 9, Speed: 16, BlockRate: 0.1, XPValue: 5000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The glabrezu makes four attacks: two with its pincers and two with its fists. Traits: Innate Spellcasting, Magic Resistance"},
-		"treant": {ID: "treant", Name: "Treant", CR: 9, HP: 138, AC: 16, Attack: 14, AttackBonus: 10, Speed: 12, BlockRate: 0.1, XPValue: 5000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The treant makes two slam attacks. Traits: False Appearance, Siege Monster"},
-		"young_blue_dragon": {ID: "young_blue_dragon", Name: "Young Blue Dragon", CR: 9, HP: 152, AC: 18, Attack: 14, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 5000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws."},
-		"young_silver_dragon": {ID: "young_silver_dragon", Name: "Young Silver Dragon", CR: 9, HP: 168, AC: 18, Attack: 14, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 5000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws."},
-		"aboleth": {ID: "aboleth", Name: "Aboleth", CR: 10, HP: 135, AC: 17, Attack: 16, AttackBonus: 9, Speed: 6, BlockRate: 0.1, XPValue: 5900, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Multiattack: The aboleth makes three tentacle attacks. Traits: Amphibious, Mucous Cloud, Probing Telepathy"},
-		"deva": {ID: "deva", Name: "Deva", CR: 10, HP: 136, AC: 17, Attack: 16, AttackBonus: 8, Speed: 12, BlockRate: 0.1, XPValue: 5900, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The deva makes two melee attacks. Traits: Angelic Weapons, Innate Spellcasting, Magic Resistance"},
-		"guardian_naga": {ID: "guardian_naga", Name: "Guardian Naga", CR: 10, HP: 127, AC: 18, Attack: 16, AttackBonus: 8, Speed: 16, BlockRate: 0.15, XPValue: 5900, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Rejuvenation, Spellcasting"},
-		"stone_golem": {ID: "stone_golem", Name: "Stone Golem", CR: 10, HP: 178, AC: 17, Attack: 16, AttackBonus: 10, Speed: 12, BlockRate: 0.1, XPValue: 5900, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The golem makes two slam attacks. Traits: Immutable Form, Magic Resistance, Magic Weapons"},
-		"young_gold_dragon": {ID: "young_gold_dragon", Name: "Young Gold Dragon", CR: 10, HP: 178, AC: 18, Attack: 16, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 5900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws. Traits: Amphibious", FireAttacker: true},
-		"young_red_dragon": {ID: "young_red_dragon", Name: "Young Red Dragon", CR: 10, HP: 178, AC: 18, Attack: 16, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 5900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws.", FireAttacker: true},
-		"behir": {ID: "behir", Name: "Behir", CR: 11, HP: 168, AC: 17, Attack: 18, AttackBonus: 0, Speed: 18, BlockRate: 0.1, XPValue: 7200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The behir makes two attacks: one with its bite and one to constrict."},
-		"chain_devil": {ID: "chain_devil", Name: "Chain Devil", CR: 11, HP: 85, AC: 16, Attack: 18, AttackBonus: 8, Speed: 12, BlockRate: 0.1, XPValue: 7200, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes two attacks with its chains. Traits: Devil's Sight, Magic Resistance"},
-		"djinni": {ID: "djinni", Name: "Djinni", CR: 11, HP: 161, AC: 17, Attack: 18, AttackBonus: 9, Speed: 12, BlockRate: 0.1, XPValue: 7200, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Multiattack: The djinni makes three scimitar attacks. Traits: Elemental Demise, Innate Spellcasting, Variant: Genie Powers"},
-		"efreeti": {ID: "efreeti", Name: "Efreeti", CR: 11, HP: 200, AC: 17, Attack: 18, AttackBonus: 7, Speed: 16, BlockRate: 0.1, XPValue: 7200, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Multiattack: The efreeti makes two scimitar attacks or uses its Hurl Flame twice. Traits: Elemental Demise, Innate Spellcasting, Variant: Genie Powers", FireAttacker: true},
-		"gynosphinx": {ID: "gynosphinx", Name: "Gynosphinx", CR: 11, HP: 136, AC: 17, Attack: 18, AttackBonus: 9, Speed: 16, BlockRate: 0.1, XPValue: 7200, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The sphinx makes two claw attacks. Traits: Inscrutable, Magic Weapons, Spellcasting"},
-		"horned_devil": {ID: "horned_devil", Name: "Horned Devil", CR: 11, HP: 178, AC: 18, Attack: 18, AttackBonus: 10, Speed: 8, BlockRate: 0.15, XPValue: 7200, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes three melee attacks: two with its fork and one with its tail. Traits: Devil's Sight, Magic Resistance"},
-		"remorhaz": {ID: "remorhaz", Name: "Remorhaz", CR: 11, HP: 195, AC: 17, Attack: 18, AttackBonus: 11, Speed: 12, BlockRate: 0.1, XPValue: 7200, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Traits: Heated Body"},
-		"roc": {ID: "roc", Name: "Roc", CR: 11, HP: 248, AC: 15, Attack: 18, AttackBonus: 13, Speed: 8, BlockRate: 0.1, XPValue: 7200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The roc makes two attacks: one with its beak and one with its talons. Traits: Keen Sight"},
-		"archmage": {ID: "archmage", Name: "Archmage", CR: 12, HP: 99, AC: 12, Attack: 19, AttackBonus: 6, Speed: 12, BlockRate: 0, XPValue: 8400, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Magic Resistance, Spellcasting"},
-		"erinyes": {ID: "erinyes", Name: "Erinyes", CR: 12, HP: 153, AC: 18, Attack: 19, AttackBonus: 8, Speed: 12, BlockRate: 0.15, XPValue: 8400, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The erinyes makes three attacks Traits: Hellish Weapons, Magic Resistance"},
-		"adult_brass_dragon": {ID: "adult_brass_dragon", Name: "Adult Brass Dragon", CR: 13, HP: 172, AC: 18, Attack: 21, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 10000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)", FireAttacker: true},
-		"adult_white_dragon": {ID: "adult_white_dragon", Name: "Adult White Dragon", CR: 13, HP: 200, AC: 18, Attack: 21, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 10000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Ice Walk, Legendary Resistance (3/Day)"},
-		"nalfeshnee": {ID: "nalfeshnee", Name: "Nalfeshnee", CR: 13, HP: 184, AC: 18, Attack: 21, AttackBonus: 10, Speed: 8, BlockRate: 0.15, XPValue: 10000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The nalfeshnee uses Horror Nimbus if it can. Traits: Magic Resistance"},
-		"rakshasa": {ID: "rakshasa", Name: "Rakshasa", CR: 13, HP: 110, AC: 16, Attack: 21, AttackBonus: 7, Speed: 16, BlockRate: 0.1, XPValue: 10000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The rakshasa makes two claw attacks Traits: Limited Magic Immunity, Innate Spellcasting"},
-		"storm_giant": {ID: "storm_giant", Name: "Storm Giant", CR: 13, HP: 230, AC: 16, Attack: 21, AttackBonus: 0, Speed: 18, BlockRate: 0.1, XPValue: 10000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The giant makes two greatsword attacks. Traits: Amphibious, Innate Spellcasting"},
-		"vampire": {ID: "vampire", Name: "Vampire", CR: 13, HP: 144, AC: 16, Attack: 21, AttackBonus: 9, Speed: 12, BlockRate: 0.1, XPValue: 10000, Ability: &MonsterAbility{Name: "Regeneration", Phase: "any", ProcChance: 0.5, Effect: "regenerate"}, Notes: "SRD-tuned baseline — Regeneration (regenerate) wired from traits. Traits: Shapechanger, Legendary Resistance (3/Day), Misty Escape, Regeneration, Spider Climb, Vampire Weaknesses"},
-		"adult_black_dragon": {ID: "adult_black_dragon", Name: "Adult Black Dragon", CR: 14, HP: 195, AC: 19, Attack: 23, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 11500, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
-		"adult_copper_dragon": {ID: "adult_copper_dragon", Name: "Adult Copper Dragon", CR: 14, HP: 184, AC: 18, Attack: 23, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 11500, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
-		"ice_devil": {ID: "ice_devil", Name: "Ice Devil", CR: 14, HP: 180, AC: 18, Attack: 23, AttackBonus: 10, Speed: 16, BlockRate: 0.15, XPValue: 11500, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes three attacks: one with its bite, one with its claws, and one with its tail. Traits: Devil's Sight, Magic Resistance"},
-		"adult_bronze_dragon": {ID: "adult_bronze_dragon", Name: "Adult Bronze Dragon", CR: 15, HP: 212, AC: 19, Attack: 24, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 13000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
-		"adult_green_dragon": {ID: "adult_green_dragon", Name: "Adult Green Dragon", CR: 15, HP: 207, AC: 19, Attack: 24, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 13000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
-		"mummy_lord": {ID: "mummy_lord", Name: "Mummy Lord", CR: 15, HP: 97, AC: 17, Attack: 24, AttackBonus: 9, Speed: 8, BlockRate: 0.1, XPValue: 13000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The mummy can use its Dreadful Glare and makes one attack with its rotting fist. Traits: Magic Resistance, Rejuvenation, Spellcasting"},
-		"purple_worm": {ID: "purple_worm", Name: "Purple Worm", CR: 15, HP: 247, AC: 18, Attack: 24, AttackBonus: 9, Speed: 18, BlockRate: 0.15, XPValue: 13000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The worm makes two attacks: one with its bite and one with its stinger. Traits: Tunneler"},
-		"adult_blue_dragon": {ID: "adult_blue_dragon", Name: "Adult Blue Dragon", CR: 16, HP: 225, AC: 19, Attack: 26, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 15000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
-		"adult_silver_dragon": {ID: "adult_silver_dragon", Name: "Adult Silver Dragon", CR: 16, HP: 243, AC: 19, Attack: 26, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 15000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
-		"iron_golem": {ID: "iron_golem", Name: "Iron Golem", CR: 16, HP: 210, AC: 20, Attack: 26, AttackBonus: 0, Speed: 12, BlockRate: 0.15, XPValue: 15000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The golem makes two melee attacks. Traits: Fire Absorption, Immutable Form, Magic Resistance, Magic Weapons"},
-		"marilith": {ID: "marilith", Name: "Marilith", CR: 16, HP: 189, AC: 18, Attack: 26, AttackBonus: 9, Speed: 16, BlockRate: 0.15, XPValue: 15000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The marilith can make seven attacks: six with its longswords and one with its tail. Traits: Magic Resistance, Magic Weapons, Reactive"},
-		"planetar": {ID: "planetar", Name: "Planetar", CR: 16, HP: 200, AC: 19, Attack: 26, AttackBonus: 12, Speed: 16, BlockRate: 0.15, XPValue: 15000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The planetar makes two melee attacks. Traits: Angelic Weapons, Divine Awareness, Innate Spellcasting, Magic Resistance"},
-		"adult_gold_dragon": {ID: "adult_gold_dragon", Name: "Adult Gold Dragon", CR: 17, HP: 256, AC: 19, Attack: 28, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 18000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)", FireAttacker: true},
-		"adult_red_dragon": {ID: "adult_red_dragon", Name: "Adult Red Dragon", CR: 17, HP: 256, AC: 19, Attack: 28, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 18000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)", FireAttacker: true},
-		"androsphinx": {ID: "androsphinx", Name: "Androsphinx", CR: 17, HP: 199, AC: 17, Attack: 28, AttackBonus: 12, Speed: 16, BlockRate: 0.1, XPValue: 18000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The sphinx makes two claw attacks. Traits: Inscrutable, Magic Weapons, Spellcasting"},
-		"dragon_turtle": {ID: "dragon_turtle", Name: "Dragon Turtle", CR: 17, HP: 341, AC: 20, Attack: 28, AttackBonus: 0, Speed: 8, BlockRate: 0.15, XPValue: 18000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon turtle makes three attacks: one with its bite and two with its claws. Traits: Amphibious", FireAttacker: true},
-		"balor": {ID: "balor", Name: "Balor", CR: 19, HP: 262, AC: 19, Attack: 31, AttackBonus: 14, Speed: 16, BlockRate: 0.15, XPValue: 22000, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Multiattack: The balor makes two attacks: one with its longsword and one with its whip. Traits: Death Throes, Fire Aura, Magic Resistance, Magic Weapons"},
-		"ancient_brass_dragon": {ID: "ancient_brass_dragon", Name: "Ancient Brass Dragon", CR: 20, HP: 297, AC: 20, Attack: 33, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 25000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)", FireAttacker: true},
-		"ancient_white_dragon": {ID: "ancient_white_dragon", Name: "Ancient White Dragon", CR: 20, HP: 333, AC: 20, Attack: 33, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 25000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Ice Walk, Legendary Resistance (3/Day)"},
-		"pit_fiend": {ID: "pit_fiend", Name: "Pit Fiend", CR: 20, HP: 300, AC: 19, Attack: 33, AttackBonus: 14, Speed: 12, BlockRate: 0.15, XPValue: 25000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The pit fiend makes four attacks: one with its bite, one with its claw, one with its mace, and one with its tail. Traits: Fear Aura, Magic Resistance, Magic Weapons, Innate Spellcasting"},
-		"ancient_black_dragon": {ID: "ancient_black_dragon", Name: "Ancient Black Dragon", CR: 21, HP: 367, AC: 22, Attack: 34, AttackBonus: 15, Speed: 16, BlockRate: 0.15, XPValue: 33000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
-		"ancient_copper_dragon": {ID: "ancient_copper_dragon", Name: "Ancient Copper Dragon", CR: 21, HP: 350, AC: 21, Attack: 34, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 33000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
-		"lich": {ID: "lich", Name: "Lich", CR: 21, HP: 135, AC: 17, Attack: 34, AttackBonus: 12, Speed: 12, BlockRate: 0.1, XPValue: 33000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Legendary Resistance (3/Day), Rejuvenation, Spellcasting, Turn Resistance"},
-		"solar": {ID: "solar", Name: "Solar", CR: 21, HP: 243, AC: 21, Attack: 34, AttackBonus: 15, Speed: 18, BlockRate: 0.15, XPValue: 33000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The solar makes two greatsword attacks. Traits: Angelic Weapons, Divine Awareness, Innate Spellcasting, Magic Resistance"},
-		"ancient_bronze_dragon": {ID: "ancient_bronze_dragon", Name: "Ancient Bronze Dragon", CR: 22, HP: 444, AC: 22, Attack: 36, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 41000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
-		"ancient_green_dragon": {ID: "ancient_green_dragon", Name: "Ancient Green Dragon", CR: 22, HP: 385, AC: 21, Attack: 36, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 41000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
-		"ancient_blue_dragon": {ID: "ancient_blue_dragon", Name: "Ancient Blue Dragon", CR: 23, HP: 481, AC: 22, Attack: 37, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 50000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
-		"ancient_silver_dragon": {ID: "ancient_silver_dragon", Name: "Ancient Silver Dragon", CR: 23, HP: 487, AC: 22, Attack: 37, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 50000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
-		"kraken": {ID: "kraken", Name: "Kraken", CR: 23, HP: 472, AC: 18, Attack: 37, AttackBonus: 7, Speed: 8, BlockRate: 0.15, XPValue: 50000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The kraken makes three tentacle attacks, each of which it can replace with one use of Fling. Traits: Amphibious, Freedom of Movement, Siege Monster"},
-		"ancient_gold_dragon": {ID: "ancient_gold_dragon", Name: "Ancient Gold Dragon", CR: 24, HP: 546, AC: 22, Attack: 38, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 62000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)", FireAttacker: true},
-		"ancient_red_dragon": {ID: "ancient_red_dragon", Name: "Ancient Red Dragon", CR: 24, HP: 546, AC: 22, Attack: 38, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 62000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)", FireAttacker: true},
-		"tarrasque": {ID: "tarrasque", Name: "Tarrasque", CR: 30, HP: 676, AC: 25, Attack: 46, AttackBonus: 19, Speed: 16, BlockRate: 0.15, XPValue: 155000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The tarrasque can use its Frightful Presence. Traits: Legendary Resistance (3/Day), Magic Resistance, Reflective Carapace, Siege Monster"},
+		"wererat":                   {ID: "wererat", Name: "Wererat", CR: 2, HP: 33, AC: 12, Attack: 4, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 450, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Shapechanger, Keen Smell"},
+		"white_dragon_wyrmling":     {ID: "white_dragon_wyrmling", Name: "White Dragon Wyrmling", CR: 2, HP: 32, AC: 16, Attack: 4, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 450, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"will_o_wisp":               {ID: "will_o_wisp", Name: "Will-o'-Wisp", CR: 2, HP: 22, AC: 19, Attack: 4, AttackBonus: 4, Speed: 18, BlockRate: 0.15, XPValue: 450, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Consume Life, Ephemeral, Incorporeal Movement, Variable Illumination"},
+		"basilisk":                  {ID: "basilisk", Name: "Basilisk", CR: 3, HP: 52, AC: 12, Attack: 6, AttackBonus: 5, Speed: 8, BlockRate: 0, XPValue: 700, Ability: &MonsterAbility{Name: "Frightful Presence", Phase: "opening", ProcChance: 0.4, Effect: "stun"}, Notes: "SRD-tuned baseline — Frightful Presence (stun) wired from traits. Traits: Petrifying Gaze"},
+		"bearded_devil":             {ID: "bearded_devil", Name: "Bearded Devil", CR: 3, HP: 52, AC: 13, Attack: 6, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 700, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes two attacks: one with its beard and one with its glaive. Traits: Devil's Sight, Magic Resistance, Steadfast"},
+		"blue_dragon_wyrmling":      {ID: "blue_dragon_wyrmling", Name: "Blue Dragon Wyrmling", CR: 3, HP: 52, AC: 17, Attack: 6, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat)."},
+		"doppelganger":              {ID: "doppelganger", Name: "Doppelganger", CR: 3, HP: 52, AC: 14, Attack: 6, AttackBonus: 6, Speed: 12, BlockRate: 0.05, XPValue: 700, Ability: &MonsterAbility{Name: "Surprise Attack", Phase: "opening", ProcChance: 0.8, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Surprise Attack (bonus_damage) wired from traits. Multiattack: The doppelganger makes two melee attacks. Traits: Shapechanger, Ambusher, Surprise Attack"},
+		"giant_scorpion":            {ID: "giant_scorpion", Name: "Giant Scorpion", CR: 3, HP: 52, AC: 15, Attack: 6, AttackBonus: 4, Speed: 16, BlockRate: 0.1, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The scorpion makes three attacks: two with its claws and one with its sting."},
+		"gold_dragon_wyrmling":      {ID: "gold_dragon_wyrmling", Name: "Gold Dragon Wyrmling", CR: 3, HP: 60, AC: 17, Attack: 6, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amphibious", FireAttacker: true},
+		"green_hag":                 {ID: "green_hag", Name: "Green Hag", CR: 3, HP: 82, AC: 17, Attack: 6, AttackBonus: 6, Speed: 12, BlockRate: 0.1, XPValue: 700, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Amphibious, Innate Spellcasting, Mimicry, Hag Coven, Shared Spellcasting (Coven Only), Hag Eye (Coven Only)"},
+		"hell_hound":                {ID: "hell_hound", Name: "Hell Hound", CR: 3, HP: 45, AC: 15, Attack: 6, AttackBonus: 0, Speed: 18, BlockRate: 0.1, XPValue: 700, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Hearing and Smell, Pack Tactics", FireAttacker: true},
+		"killer_whale":              {ID: "killer_whale", Name: "Killer Whale", CR: 3, HP: 90, AC: 12, Attack: 6, AttackBonus: 0, Speed: 18, BlockRate: 0, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Echolocation, Hold Breath, Keen Hearing"},
+		"knight":                    {ID: "knight", Name: "Knight", CR: 3, HP: 52, AC: 18, Attack: 6, AttackBonus: 5, Speed: 12, BlockRate: 0.15, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The knight makes two melee attacks. Traits: Brave"},
+		"manticore":                 {ID: "manticore", Name: "Manticore", CR: 3, HP: 68, AC: 14, Attack: 6, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The manticore makes three attacks: one with its bite and two with its claws or three with its tail spikes. Traits: Tail Spike Regrowth"},
+		"minotaur":                  {ID: "minotaur", Name: "Minotaur", CR: 3, HP: 76, AC: 14, Attack: 6, AttackBonus: 6, Speed: 16, BlockRate: 0.05, XPValue: 700, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Charge, Labyrinthine Recall, Reckless"},
+		"mummy":                     {ID: "mummy", Name: "Mummy", CR: 3, HP: 58, AC: 11, Attack: 6, AttackBonus: 5, Speed: 8, BlockRate: 0, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The mummy can use its Dreadful Glare and makes one attack with its rotting fist."},
+		"nightmare":                 {ID: "nightmare", Name: "Nightmare", CR: 3, HP: 68, AC: 13, Attack: 6, AttackBonus: 6, Speed: 18, BlockRate: 0.05, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Confer Fire Resistance, Illumination"},
+		"owlbear":                   {ID: "owlbear", Name: "Owlbear", CR: 3, HP: 59, AC: 13, Attack: 6, AttackBonus: 7, Speed: 16, BlockRate: 0.05, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The owlbear makes two attacks: one with its beak and one with its claws. Traits: Keen Sight and Smell"},
+		"phase_spider":              {ID: "phase_spider", Name: "Phase Spider", CR: 3, HP: 32, AC: 13, Attack: 6, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 700, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Ethereal Jaunt, Spider Climb, Web Walker"},
+		"veteran":                   {ID: "veteran", Name: "Veteran", CR: 3, HP: 58, AC: 17, Attack: 6, AttackBonus: 5, Speed: 12, BlockRate: 0.1, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The veteran makes two longsword attacks."},
+		"werewolf":                  {ID: "werewolf", Name: "Werewolf", CR: 3, HP: 58, AC: 11, Attack: 6, AttackBonus: 4, Speed: 12, BlockRate: 0, XPValue: 700, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Shapechanger, Keen Hearing and Smell"},
+		"wight":                     {ID: "wight", Name: "Wight", CR: 3, HP: 45, AC: 14, Attack: 6, AttackBonus: 4, Speed: 12, BlockRate: 0.05, XPValue: 700, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The wight makes two longsword attacks or two longbow attacks. Traits: Sunlight Sensitivity"},
+		"winter_wolf":               {ID: "winter_wolf", Name: "Winter Wolf", CR: 3, HP: 75, AC: 13, Attack: 6, AttackBonus: 0, Speed: 18, BlockRate: 0.05, XPValue: 700, Ability: &MonsterAbility{Name: "Pack Tactics", Phase: "any", ProcChance: 0.3, Effect: "advantage"}, Notes: "SRD-tuned baseline — Pack Tactics (advantage) wired from traits. Traits: Keen Hearing and Smell, Pack Tactics, Snow Camouflage"},
+		"black_pudding":             {ID: "black_pudding", Name: "Black Pudding", CR: 4, HP: 85, AC: 10, Attack: 7, AttackBonus: 5, Speed: 8, BlockRate: 0, XPValue: 1100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Traits: Amorphous, Corrosive Form, Spider Climb"},
+		"chuul":                     {ID: "chuul", Name: "Chuul", CR: 4, HP: 93, AC: 16, Attack: 7, AttackBonus: 6, Speed: 12, BlockRate: 0.1, XPValue: 1100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The chuul makes two pincer attacks. Traits: Amphibious, Sense Magic"},
+		"couatl":                    {ID: "couatl", Name: "Couatl", CR: 4, HP: 97, AC: 19, Attack: 7, AttackBonus: 6, Speed: 12, BlockRate: 0.15, XPValue: 1100, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Innate Spellcasting, Magic Weapons, Shielded Mind"},
+		"elephant":                  {ID: "elephant", Name: "Elephant", CR: 4, HP: 76, AC: 12, Attack: 7, AttackBonus: 8, Speed: 16, BlockRate: 0, XPValue: 1100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Trampling Charge"},
+		"ettin":                     {ID: "ettin", Name: "Ettin", CR: 4, HP: 85, AC: 12, Attack: 7, AttackBonus: 7, Speed: 16, BlockRate: 0, XPValue: 1100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The ettin makes two attacks: one with its battleaxe and one with its morningstar. Traits: Two Heads, Wakeful"},
+		"ghost":                     {ID: "ghost", Name: "Ghost", CR: 4, HP: 45, AC: 11, Attack: 7, AttackBonus: 5, Speed: 16, BlockRate: 0, XPValue: 1100, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Ethereal Sight, Incorporeal Movement"},
+		"lamia":                     {ID: "lamia", Name: "Lamia", CR: 4, HP: 97, AC: 13, Attack: 7, AttackBonus: 5, Speed: 12, BlockRate: 0.05, XPValue: 1100, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The lamia makes two attacks: one with its claws and one with its dagger or Intoxicating Touch. Traits: Innate Spellcasting"},
+		"red_dragon_wyrmling":       {ID: "red_dragon_wyrmling", Name: "Red Dragon Wyrmling", CR: 4, HP: 75, AC: 17, Attack: 7, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 1100, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat).", FireAttacker: true},
+		"succubusincubus":           {ID: "succubusincubus", Name: "Succubus/Incubus", CR: 4, HP: 66, AC: 15, Attack: 7, AttackBonus: 0, Speed: 12, BlockRate: 0.1, XPValue: 1100, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Telepathic Bond, Shapechanger"},
+		"wereboar":                  {ID: "wereboar", Name: "Wereboar", CR: 4, HP: 78, AC: 10, Attack: 7, AttackBonus: 5, Speed: 12, BlockRate: 0, XPValue: 1100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Shapechanger, Charge (Boar or Hybrid Form Only), Relentless (Recharges after a Short or Long Rest)"},
+		"weretiger":                 {ID: "weretiger", Name: "Weretiger", CR: 4, HP: 120, AC: 12, Attack: 7, AttackBonus: 5, Speed: 12, BlockRate: 0, XPValue: 1100, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Shapechanger, Keen Hearing and Smell, Pounce (Tiger or Hybrid Form Only)"},
+		"air_elemental":             {ID: "air_elemental", Name: "Air Elemental", CR: 5, HP: 90, AC: 15, Attack: 8, AttackBonus: 8, Speed: 18, BlockRate: 0.1, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The elemental makes two slam attacks. Traits: Air Form"},
+		"barbed_devil":              {ID: "barbed_devil", Name: "Barbed Devil", CR: 5, HP: 110, AC: 15, Attack: 8, AttackBonus: 6, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes three melee attacks: one with its tail and two with its claws. Traits: Barbed Hide, Devil's Sight, Magic Resistance"},
+		"bulette":                   {ID: "bulette", Name: "Bulette", CR: 5, HP: 94, AC: 17, Attack: 8, AttackBonus: 7, Speed: 16, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Standing Leap"},
+		"earth_elemental":           {ID: "earth_elemental", Name: "Earth Elemental", CR: 5, HP: 126, AC: 17, Attack: 8, AttackBonus: 8, Speed: 12, BlockRate: 0.1, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The elemental makes two slam attacks. Traits: Earth Glide, Siege Monster"},
+		"fire_elemental":            {ID: "fire_elemental", Name: "Fire Elemental", CR: 5, HP: 102, AC: 13, Attack: 8, AttackBonus: 6, Speed: 18, BlockRate: 0.05, XPValue: 1800, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Multiattack: The elemental makes two touch attacks. Traits: Fire Form, Illumination, Water Susceptibility", FireAttacker: true},
+		"flesh_golem":               {ID: "flesh_golem", Name: "Flesh Golem", CR: 5, HP: 93, AC: 10, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0, XPValue: 1800, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The golem makes two slam attacks. Traits: Berserk, Aversion of Fire, Immutable Form, Lightning Absorption, Magic Resistance, Magic Weapons"},
+		"giant_crocodile":           {ID: "giant_crocodile", Name: "Giant Crocodile", CR: 5, HP: 85, AC: 14, Attack: 8, AttackBonus: 8, Speed: 12, BlockRate: 0.05, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The crocodile makes two attacks: one with its bite and one with its tail. Traits: Hold Breath"},
+		"giant_shark":               {ID: "giant_shark", Name: "Giant Shark", CR: 5, HP: 126, AC: 13, Attack: 8, AttackBonus: 9, Speed: 18, BlockRate: 0.05, XPValue: 1800, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Traits: Blood Frenzy, Water Breathing"},
+		"gladiator":                 {ID: "gladiator", Name: "Gladiator", CR: 5, HP: 112, AC: 16, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Frenzy", Phase: "any", ProcChance: 0.4, Effect: "enrage"}, Notes: "SRD-tuned baseline — Frenzy (enrage) wired from traits. Multiattack: The gladiator makes three melee attacks or two ranged attacks. Traits: Brave, Brute"},
+		"gorgon":                    {ID: "gorgon", Name: "Gorgon", CR: 5, HP: 114, AC: 19, Attack: 8, AttackBonus: 8, Speed: 16, BlockRate: 0.15, XPValue: 1800, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Trampling Charge"},
+		"half_red_dragon_veteran":   {ID: "half_red_dragon_veteran", Name: "Half-Red Dragon Veteran", CR: 5, HP: 65, AC: 18, Attack: 8, AttackBonus: 0, Speed: 12, BlockRate: 0.15, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The veteran makes two longsword attacks.", FireAttacker: true},
+		"hill_giant":                {ID: "hill_giant", Name: "Hill Giant", CR: 5, HP: 105, AC: 13, Attack: 8, AttackBonus: 8, Speed: 16, BlockRate: 0.05, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The giant makes two greatclub attacks."},
+		"night_hag":                 {ID: "night_hag", Name: "Night Hag", CR: 5, HP: 112, AC: 17, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Innate Spellcasting, Magic Resistance, Night Hag Items, Hag Coven, Shared Spellcasting (Coven Only), Hag Eye (Coven Only)"},
+		"otyugh":                    {ID: "otyugh", Name: "Otyugh", CR: 5, HP: 114, AC: 14, Attack: 8, AttackBonus: 6, Speed: 12, BlockRate: 0.05, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The otyugh makes three attacks: one with its bite and two with its tentacles. Traits: Limited Telepathy"},
+		"roper":                     {ID: "roper", Name: "Roper", CR: 5, HP: 93, AC: 20, Attack: 8, AttackBonus: 7, Speed: 6, BlockRate: 0.15, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The roper makes four attacks with its tendrils, uses Reel, and makes one attack with its bite. Traits: False Appearance, Grasping Tendrils, Spider Climb"},
+		"salamander":                {ID: "salamander", Name: "Salamander", CR: 5, HP: 90, AC: 15, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Multiattack: The salamander makes two attacks: one with its spear and one with its tail. Traits: Heated Body, Heated Weapons"},
+		"shambling_mound":           {ID: "shambling_mound", Name: "Shambling Mound", CR: 5, HP: 136, AC: 15, Attack: 8, AttackBonus: 7, Speed: 8, BlockRate: 0.1, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The shambling mound makes two slam attacks. Traits: Lightning Absorption"},
+		"triceratops":               {ID: "triceratops", Name: "Triceratops", CR: 5, HP: 95, AC: 13, Attack: 8, AttackBonus: 9, Speed: 18, BlockRate: 0.05, XPValue: 1800, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Trampling Charge"},
+		"troll":                     {ID: "troll", Name: "Troll", CR: 5, HP: 84, AC: 15, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Regeneration", Phase: "any", ProcChance: 0.5, Effect: "regenerate"}, Notes: "SRD-tuned baseline — Regeneration (regenerate) wired from traits. Multiattack: The troll makes three attacks: one with its bite and two with its claws. Traits: Keen Smell, Regeneration, Variant: Loathsome Limbs"},
+		"unicorn":                   {ID: "unicorn", Name: "Unicorn", CR: 5, HP: 67, AC: 12, Attack: 8, AttackBonus: 7, Speed: 18, BlockRate: 0, XPValue: 1800, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The unicorn makes two attacks: one with its hooves and one with its horn. Traits: Charge, Innate Spellcasting, Magic Resistance, Magic Weapons"},
+		"vampire_spawn":             {ID: "vampire_spawn", Name: "Vampire Spawn", CR: 5, HP: 82, AC: 15, Attack: 8, AttackBonus: 6, Speed: 12, BlockRate: 0.1, XPValue: 1800, Ability: &MonsterAbility{Name: "Regeneration", Phase: "any", ProcChance: 0.5, Effect: "regenerate"}, Notes: "SRD-tuned baseline — Regeneration (regenerate) wired from traits. Multiattack: The vampire makes two attacks, only one of which can be a bite attack. Traits: Regeneration, Spider Climb, Vampire Weaknesses"},
+		"water_elemental":           {ID: "water_elemental", Name: "Water Elemental", CR: 5, HP: 114, AC: 14, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0.05, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The elemental makes two slam attacks. Traits: Water Form, Freeze"},
+		"werebear":                  {ID: "werebear", Name: "Werebear", CR: 5, HP: 135, AC: 10, Attack: 8, AttackBonus: 7, Speed: 12, BlockRate: 0, XPValue: 1800, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Multiattack: In bear form, the werebear makes two claw attacks. Traits: Shapechanger, Keen Smell"},
+		"wraith":                    {ID: "wraith", Name: "Wraith", CR: 5, HP: 67, AC: 13, Attack: 8, AttackBonus: 6, Speed: 18, BlockRate: 0.05, XPValue: 1800, Ability: &MonsterAbility{Name: "Evasive", Phase: "any", ProcChance: 0.3, Effect: "evade"}, Notes: "SRD-tuned baseline — Evasive (evade) wired from traits. Traits: Incorporeal Movement, Sunlight Sensitivity"},
+		"xorn":                      {ID: "xorn", Name: "Xorn", CR: 5, HP: 73, AC: 19, Attack: 8, AttackBonus: 6, Speed: 8, BlockRate: 0.15, XPValue: 1800, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The xorn makes three claw attacks and one bite attack. Traits: Earth Glide, Stone Camouflage, Treasure Sense"},
+		"chimera":                   {ID: "chimera", Name: "Chimera", CR: 6, HP: 114, AC: 14, Attack: 10, AttackBonus: 0, Speed: 12, BlockRate: 0.05, XPValue: 2300, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The chimera makes three attacks: one with its bite, one with its horns, and one with its claws.", FireAttacker: true},
+		"drider":                    {ID: "drider", Name: "Drider", CR: 6, HP: 123, AC: 19, Attack: 10, AttackBonus: 6, Speed: 12, BlockRate: 0.15, XPValue: 2300, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The drider makes three attacks, either with its longsword or its longbow. Traits: Fey Ancestry, Innate Spellcasting, Spider Climb, Sunlight Sensitivity, Web Walker"},
+		"invisible_stalker":         {ID: "invisible_stalker", Name: "Invisible Stalker", CR: 6, HP: 104, AC: 14, Attack: 10, AttackBonus: 6, Speed: 18, BlockRate: 0.05, XPValue: 2300, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The stalker makes two slam attacks. Traits: Invisibility, Faultless Tracker"},
+		"mage":                      {ID: "mage", Name: "Mage", CR: 6, HP: 40, AC: 12, Attack: 10, AttackBonus: 5, Speed: 12, BlockRate: 0, XPValue: 2300, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Spellcasting"},
+		"mammoth":                   {ID: "mammoth", Name: "Mammoth", CR: 6, HP: 126, AC: 13, Attack: 10, AttackBonus: 10, Speed: 16, BlockRate: 0.05, XPValue: 2300, Ability: &MonsterAbility{Name: "Charge", Phase: "opening", ProcChance: 0.4, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Charge (bonus_damage) wired from traits. Traits: Trampling Charge"},
+		"medusa":                    {ID: "medusa", Name: "Medusa", CR: 6, HP: 127, AC: 15, Attack: 10, AttackBonus: 5, Speed: 12, BlockRate: 0.1, XPValue: 2300, Ability: &MonsterAbility{Name: "Frightful Presence", Phase: "opening", ProcChance: 0.4, Effect: "stun"}, Notes: "SRD-tuned baseline — Frightful Presence (stun) wired from traits. Multiattack: The medusa makes either three melee attacks - one with its snake hair and two with its shortsword - or two ranged attacks with its longbow. Traits: Petrifying Gaze"},
+		"vrock":                     {ID: "vrock", Name: "Vrock", CR: 6, HP: 104, AC: 15, Attack: 10, AttackBonus: 6, Speed: 16, BlockRate: 0.1, XPValue: 2300, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The vrock makes two attacks: one with its beak and one with its talons. Traits: Magic Resistance"},
+		"wyvern":                    {ID: "wyvern", Name: "Wyvern", CR: 6, HP: 110, AC: 13, Attack: 10, AttackBonus: 7, Speed: 8, BlockRate: 0.05, XPValue: 2300, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The wyvern makes two attacks: one with its bite and one with its stinger."},
+		"young_brass_dragon":        {ID: "young_brass_dragon", Name: "Young Brass Dragon", CR: 6, HP: 110, AC: 17, Attack: 10, AttackBonus: 0, Speed: 16, BlockRate: 0.1, XPValue: 2300, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws.", FireAttacker: true},
+		"young_white_dragon":        {ID: "young_white_dragon", Name: "Young White Dragon", CR: 6, HP: 133, AC: 17, Attack: 10, AttackBonus: 0, Speed: 16, BlockRate: 0.1, XPValue: 2300, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws. Traits: Ice Walk"},
+		"giant_ape":                 {ID: "giant_ape", Name: "Giant Ape", CR: 7, HP: 157, AC: 12, Attack: 12, AttackBonus: 9, Speed: 16, BlockRate: 0, XPValue: 2900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The ape makes two fist attacks."},
+		"oni":                       {ID: "oni", Name: "Oni", CR: 7, HP: 110, AC: 16, Attack: 12, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 2900, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The oni makes two attacks, either with its claws or its glaive. Traits: Innate Spellcasting, Magic Weapons, Regeneration"},
+		"shield_guardian":           {ID: "shield_guardian", Name: "Shield Guardian", CR: 7, HP: 142, AC: 17, Attack: 12, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 2900, Ability: &MonsterAbility{Name: "Regeneration", Phase: "any", ProcChance: 0.5, Effect: "regenerate"}, Notes: "SRD-tuned baseline — Regeneration (regenerate) wired from traits. Multiattack: The guardian makes two fist attacks. Traits: Bound, Regeneration, Spell Storing"},
+		"stone_giant":               {ID: "stone_giant", Name: "Stone Giant", CR: 7, HP: 126, AC: 17, Attack: 12, AttackBonus: 9, Speed: 16, BlockRate: 0.1, XPValue: 2900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The giant makes two greatclub attacks. Traits: Stone Camouflage"},
+		"young_black_dragon":        {ID: "young_black_dragon", Name: "Young Black Dragon", CR: 7, HP: 127, AC: 18, Attack: 12, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 2900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws. Traits: Amphibious"},
+		"young_copper_dragon":       {ID: "young_copper_dragon", Name: "Young Copper Dragon", CR: 7, HP: 119, AC: 17, Attack: 12, AttackBonus: 0, Speed: 16, BlockRate: 0.1, XPValue: 2900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws."},
+		"assassin":                  {ID: "assassin", Name: "Assassin", CR: 8, HP: 78, AC: 15, Attack: 13, AttackBonus: 6, Speed: 12, BlockRate: 0.1, XPValue: 3900, Ability: &MonsterAbility{Name: "Surprise Attack", Phase: "opening", ProcChance: 0.8, Effect: "bonus_damage"}, Notes: "SRD-tuned baseline — Surprise Attack (bonus_damage) wired from traits. Multiattack: The assassin makes two shortsword attacks. Traits: Assassinate, Evasion, Sneak Attack (1/Turn)"},
+		"cloaker":                   {ID: "cloaker", Name: "Cloaker", CR: 8, HP: 78, AC: 14, Attack: 13, AttackBonus: 6, Speed: 6, BlockRate: 0.05, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The cloaker makes two attacks: one with its bite and one with its tail. Traits: Damage Transfer, False Appearance, Light Sensitivity"},
+		"frost_giant":               {ID: "frost_giant", Name: "Frost Giant", CR: 8, HP: 138, AC: 15, Attack: 13, AttackBonus: 9, Speed: 16, BlockRate: 0.1, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The giant makes two greataxe attacks."},
+		"hezrou":                    {ID: "hezrou", Name: "Hezrou", CR: 8, HP: 136, AC: 16, Attack: 13, AttackBonus: 7, Speed: 12, BlockRate: 0.1, XPValue: 3900, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The hezrou makes three attacks: one with its bite and two with its claws. Traits: Magic Resistance, Stench"},
+		"hydra":                     {ID: "hydra", Name: "Hydra", CR: 8, HP: 172, AC: 15, Attack: 13, AttackBonus: 8, Speed: 12, BlockRate: 0.1, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The hydra makes as many bite attacks as it has heads. Traits: Hold Breath, Multiple Heads, Reactive Heads, Wakeful"},
+		"spirit_naga":               {ID: "spirit_naga", Name: "Spirit Naga", CR: 8, HP: 75, AC: 15, Attack: 13, AttackBonus: 7, Speed: 16, BlockRate: 0.1, XPValue: 3900, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Rejuvenation, Spellcasting"},
+		"tyrannosaurus_rex":         {ID: "tyrannosaurus_rex", Name: "Tyrannosaurus Rex", CR: 8, HP: 136, AC: 13, Attack: 13, AttackBonus: 10, Speed: 18, BlockRate: 0.05, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The tyrannosaurus makes two attacks: one with its bite and one with its tail."},
+		"young_bronze_dragon":       {ID: "young_bronze_dragon", Name: "Young Bronze Dragon", CR: 8, HP: 142, AC: 18, Attack: 13, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws. Traits: Amphibious"},
+		"young_green_dragon":        {ID: "young_green_dragon", Name: "Young Green Dragon", CR: 8, HP: 136, AC: 18, Attack: 13, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 3900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws. Traits: Amphibious"},
+		"bone_devil":                {ID: "bone_devil", Name: "Bone Devil", CR: 9, HP: 142, AC: 19, Attack: 14, AttackBonus: 8, Speed: 16, BlockRate: 0.15, XPValue: 5000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes three attacks: two with its claws and one with its sting. Traits: Devil's Sight, Magic Resistance"},
+		"clay_golem":                {ID: "clay_golem", Name: "Clay Golem", CR: 9, HP: 133, AC: 14, Attack: 14, AttackBonus: 8, Speed: 8, BlockRate: 0.05, XPValue: 5000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The golem makes two slam attacks. Traits: Acid Absorption, Berserk, Immutable Form, Magic Resistance, Magic Weapons"},
+		"cloud_giant":               {ID: "cloud_giant", Name: "Cloud Giant", CR: 9, HP: 200, AC: 14, Attack: 14, AttackBonus: 12, Speed: 16, BlockRate: 0.05, XPValue: 5000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The giant makes two morningstar attacks. Traits: Keen Smell, Innate Spellcasting"},
+		"fire_giant":                {ID: "fire_giant", Name: "Fire Giant", CR: 9, HP: 162, AC: 18, Attack: 14, AttackBonus: 11, Speed: 12, BlockRate: 0.15, XPValue: 5000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The giant makes two greatsword attacks."},
+		"glabrezu":                  {ID: "glabrezu", Name: "Glabrezu", CR: 9, HP: 157, AC: 17, Attack: 14, AttackBonus: 9, Speed: 16, BlockRate: 0.1, XPValue: 5000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The glabrezu makes four attacks: two with its pincers and two with its fists. Traits: Innate Spellcasting, Magic Resistance"},
+		"treant":                    {ID: "treant", Name: "Treant", CR: 9, HP: 138, AC: 16, Attack: 14, AttackBonus: 10, Speed: 12, BlockRate: 0.1, XPValue: 5000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The treant makes two slam attacks. Traits: False Appearance, Siege Monster"},
+		"young_blue_dragon":         {ID: "young_blue_dragon", Name: "Young Blue Dragon", CR: 9, HP: 152, AC: 18, Attack: 14, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 5000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws."},
+		"young_silver_dragon":       {ID: "young_silver_dragon", Name: "Young Silver Dragon", CR: 9, HP: 168, AC: 18, Attack: 14, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 5000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws."},
+		"aboleth":                   {ID: "aboleth", Name: "Aboleth", CR: 10, HP: 135, AC: 17, Attack: 16, AttackBonus: 9, Speed: 6, BlockRate: 0.1, XPValue: 5900, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Multiattack: The aboleth makes three tentacle attacks. Traits: Amphibious, Mucous Cloud, Probing Telepathy"},
+		"deva":                      {ID: "deva", Name: "Deva", CR: 10, HP: 136, AC: 17, Attack: 16, AttackBonus: 8, Speed: 12, BlockRate: 0.1, XPValue: 5900, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The deva makes two melee attacks. Traits: Angelic Weapons, Innate Spellcasting, Magic Resistance"},
+		"guardian_naga":             {ID: "guardian_naga", Name: "Guardian Naga", CR: 10, HP: 127, AC: 18, Attack: 16, AttackBonus: 8, Speed: 16, BlockRate: 0.15, XPValue: 5900, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Rejuvenation, Spellcasting"},
+		"stone_golem":               {ID: "stone_golem", Name: "Stone Golem", CR: 10, HP: 178, AC: 17, Attack: 16, AttackBonus: 10, Speed: 12, BlockRate: 0.1, XPValue: 5900, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The golem makes two slam attacks. Traits: Immutable Form, Magic Resistance, Magic Weapons"},
+		"young_gold_dragon":         {ID: "young_gold_dragon", Name: "Young Gold Dragon", CR: 10, HP: 178, AC: 18, Attack: 16, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 5900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws. Traits: Amphibious", FireAttacker: true},
+		"young_red_dragon":          {ID: "young_red_dragon", Name: "Young Red Dragon", CR: 10, HP: 178, AC: 18, Attack: 16, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 5900, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon makes three attacks: one with its bite and two with its claws.", FireAttacker: true},
+		"behir":                     {ID: "behir", Name: "Behir", CR: 11, HP: 168, AC: 17, Attack: 18, AttackBonus: 0, Speed: 18, BlockRate: 0.1, XPValue: 7200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The behir makes two attacks: one with its bite and one to constrict."},
+		"chain_devil":               {ID: "chain_devil", Name: "Chain Devil", CR: 11, HP: 85, AC: 16, Attack: 18, AttackBonus: 8, Speed: 12, BlockRate: 0.1, XPValue: 7200, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes two attacks with its chains. Traits: Devil's Sight, Magic Resistance"},
+		"djinni":                    {ID: "djinni", Name: "Djinni", CR: 11, HP: 161, AC: 17, Attack: 18, AttackBonus: 9, Speed: 12, BlockRate: 0.1, XPValue: 7200, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Multiattack: The djinni makes three scimitar attacks. Traits: Elemental Demise, Innate Spellcasting, Variant: Genie Powers"},
+		"efreeti":                   {ID: "efreeti", Name: "Efreeti", CR: 11, HP: 200, AC: 17, Attack: 18, AttackBonus: 7, Speed: 16, BlockRate: 0.1, XPValue: 7200, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Multiattack: The efreeti makes two scimitar attacks or uses its Hurl Flame twice. Traits: Elemental Demise, Innate Spellcasting, Variant: Genie Powers", FireAttacker: true},
+		"gynosphinx":                {ID: "gynosphinx", Name: "Gynosphinx", CR: 11, HP: 136, AC: 17, Attack: 18, AttackBonus: 9, Speed: 16, BlockRate: 0.1, XPValue: 7200, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The sphinx makes two claw attacks. Traits: Inscrutable, Magic Weapons, Spellcasting"},
+		"horned_devil":              {ID: "horned_devil", Name: "Horned Devil", CR: 11, HP: 178, AC: 18, Attack: 18, AttackBonus: 10, Speed: 8, BlockRate: 0.15, XPValue: 7200, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes three melee attacks: two with its fork and one with its tail. Traits: Devil's Sight, Magic Resistance"},
+		"remorhaz":                  {ID: "remorhaz", Name: "Remorhaz", CR: 11, HP: 195, AC: 17, Attack: 18, AttackBonus: 11, Speed: 12, BlockRate: 0.1, XPValue: 7200, Ability: &MonsterAbility{Name: "Damaging Aura", Phase: "any", ProcChance: 0.4, Effect: "retaliate"}, Notes: "SRD-tuned baseline — Damaging Aura (retaliate) wired from traits. Traits: Heated Body"},
+		"roc":                       {ID: "roc", Name: "Roc", CR: 11, HP: 248, AC: 15, Attack: 18, AttackBonus: 13, Speed: 8, BlockRate: 0.1, XPValue: 7200, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The roc makes two attacks: one with its beak and one with its talons. Traits: Keen Sight"},
+		"archmage":                  {ID: "archmage", Name: "Archmage", CR: 12, HP: 99, AC: 12, Attack: 19, AttackBonus: 6, Speed: 12, BlockRate: 0, XPValue: 8400, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Magic Resistance, Spellcasting"},
+		"erinyes":                   {ID: "erinyes", Name: "Erinyes", CR: 12, HP: 153, AC: 18, Attack: 19, AttackBonus: 8, Speed: 12, BlockRate: 0.15, XPValue: 8400, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The erinyes makes three attacks Traits: Hellish Weapons, Magic Resistance"},
+		"adult_brass_dragon":        {ID: "adult_brass_dragon", Name: "Adult Brass Dragon", CR: 13, HP: 172, AC: 18, Attack: 21, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 10000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)", FireAttacker: true},
+		"adult_white_dragon":        {ID: "adult_white_dragon", Name: "Adult White Dragon", CR: 13, HP: 200, AC: 18, Attack: 21, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 10000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Ice Walk, Legendary Resistance (3/Day)"},
+		"nalfeshnee":                {ID: "nalfeshnee", Name: "Nalfeshnee", CR: 13, HP: 184, AC: 18, Attack: 21, AttackBonus: 10, Speed: 8, BlockRate: 0.15, XPValue: 10000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The nalfeshnee uses Horror Nimbus if it can. Traits: Magic Resistance"},
+		"rakshasa":                  {ID: "rakshasa", Name: "Rakshasa", CR: 13, HP: 110, AC: 16, Attack: 21, AttackBonus: 7, Speed: 16, BlockRate: 0.1, XPValue: 10000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The rakshasa makes two claw attacks Traits: Limited Magic Immunity, Innate Spellcasting"},
+		"storm_giant":               {ID: "storm_giant", Name: "Storm Giant", CR: 13, HP: 230, AC: 16, Attack: 21, AttackBonus: 0, Speed: 18, BlockRate: 0.1, XPValue: 10000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The giant makes two greatsword attacks. Traits: Amphibious, Innate Spellcasting"},
+		"vampire":                   {ID: "vampire", Name: "Vampire", CR: 13, HP: 144, AC: 16, Attack: 21, AttackBonus: 9, Speed: 12, BlockRate: 0.1, XPValue: 10000, Ability: &MonsterAbility{Name: "Regeneration", Phase: "any", ProcChance: 0.5, Effect: "regenerate"}, Notes: "SRD-tuned baseline — Regeneration (regenerate) wired from traits. Traits: Shapechanger, Legendary Resistance (3/Day), Misty Escape, Regeneration, Spider Climb, Vampire Weaknesses"},
+		"adult_black_dragon":        {ID: "adult_black_dragon", Name: "Adult Black Dragon", CR: 14, HP: 195, AC: 19, Attack: 23, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 11500, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
+		"adult_copper_dragon":       {ID: "adult_copper_dragon", Name: "Adult Copper Dragon", CR: 14, HP: 184, AC: 18, Attack: 23, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 11500, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
+		"ice_devil":                 {ID: "ice_devil", Name: "Ice Devil", CR: 14, HP: 180, AC: 18, Attack: 23, AttackBonus: 10, Speed: 16, BlockRate: 0.15, XPValue: 11500, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The devil makes three attacks: one with its bite, one with its claws, and one with its tail. Traits: Devil's Sight, Magic Resistance"},
+		"adult_bronze_dragon":       {ID: "adult_bronze_dragon", Name: "Adult Bronze Dragon", CR: 15, HP: 212, AC: 19, Attack: 24, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 13000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
+		"adult_green_dragon":        {ID: "adult_green_dragon", Name: "Adult Green Dragon", CR: 15, HP: 207, AC: 19, Attack: 24, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 13000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
+		"mummy_lord":                {ID: "mummy_lord", Name: "Mummy Lord", CR: 15, HP: 97, AC: 17, Attack: 24, AttackBonus: 9, Speed: 8, BlockRate: 0.1, XPValue: 13000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The mummy can use its Dreadful Glare and makes one attack with its rotting fist. Traits: Magic Resistance, Rejuvenation, Spellcasting"},
+		"purple_worm":               {ID: "purple_worm", Name: "Purple Worm", CR: 15, HP: 247, AC: 18, Attack: 24, AttackBonus: 9, Speed: 18, BlockRate: 0.15, XPValue: 13000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The worm makes two attacks: one with its bite and one with its stinger. Traits: Tunneler"},
+		"adult_blue_dragon":         {ID: "adult_blue_dragon", Name: "Adult Blue Dragon", CR: 16, HP: 225, AC: 19, Attack: 26, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 15000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
+		"adult_silver_dragon":       {ID: "adult_silver_dragon", Name: "Adult Silver Dragon", CR: 16, HP: 243, AC: 19, Attack: 26, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 15000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
+		"iron_golem":                {ID: "iron_golem", Name: "Iron Golem", CR: 16, HP: 210, AC: 20, Attack: 26, AttackBonus: 0, Speed: 12, BlockRate: 0.15, XPValue: 15000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The golem makes two melee attacks. Traits: Fire Absorption, Immutable Form, Magic Resistance, Magic Weapons"},
+		"marilith":                  {ID: "marilith", Name: "Marilith", CR: 16, HP: 189, AC: 18, Attack: 26, AttackBonus: 9, Speed: 16, BlockRate: 0.15, XPValue: 15000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The marilith can make seven attacks: six with its longswords and one with its tail. Traits: Magic Resistance, Magic Weapons, Reactive"},
+		"planetar":                  {ID: "planetar", Name: "Planetar", CR: 16, HP: 200, AC: 19, Attack: 26, AttackBonus: 12, Speed: 16, BlockRate: 0.15, XPValue: 15000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The planetar makes two melee attacks. Traits: Angelic Weapons, Divine Awareness, Innate Spellcasting, Magic Resistance"},
+		"adult_gold_dragon":         {ID: "adult_gold_dragon", Name: "Adult Gold Dragon", CR: 17, HP: 256, AC: 19, Attack: 28, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 18000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)", FireAttacker: true},
+		"adult_red_dragon":          {ID: "adult_red_dragon", Name: "Adult Red Dragon", CR: 17, HP: 256, AC: 19, Attack: 28, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 18000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)", FireAttacker: true},
+		"androsphinx":               {ID: "androsphinx", Name: "Androsphinx", CR: 17, HP: 199, AC: 17, Attack: 28, AttackBonus: 12, Speed: 16, BlockRate: 0.1, XPValue: 18000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The sphinx makes two claw attacks. Traits: Inscrutable, Magic Weapons, Spellcasting"},
+		"dragon_turtle":             {ID: "dragon_turtle", Name: "Dragon Turtle", CR: 17, HP: 341, AC: 20, Attack: 28, AttackBonus: 0, Speed: 8, BlockRate: 0.15, XPValue: 18000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The dragon turtle makes three attacks: one with its bite and two with its claws. Traits: Amphibious", FireAttacker: true},
+		"balor":                     {ID: "balor", Name: "Balor", CR: 19, HP: 262, AC: 19, Attack: 31, AttackBonus: 14, Speed: 16, BlockRate: 0.15, XPValue: 22000, Ability: &MonsterAbility{Name: "Death Burst", Phase: "decisive", ProcChance: 1, Effect: "death_aoe"}, Notes: "SRD-tuned baseline — Death Burst (death_aoe) wired from traits. Multiattack: The balor makes two attacks: one with its longsword and one with its whip. Traits: Death Throes, Fire Aura, Magic Resistance, Magic Weapons"},
+		"ancient_brass_dragon":      {ID: "ancient_brass_dragon", Name: "Ancient Brass Dragon", CR: 20, HP: 297, AC: 20, Attack: 33, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 25000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)", FireAttacker: true},
+		"ancient_white_dragon":      {ID: "ancient_white_dragon", Name: "Ancient White Dragon", CR: 20, HP: 333, AC: 20, Attack: 33, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 25000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Ice Walk, Legendary Resistance (3/Day)"},
+		"pit_fiend":                 {ID: "pit_fiend", Name: "Pit Fiend", CR: 20, HP: 300, AC: 19, Attack: 33, AttackBonus: 14, Speed: 12, BlockRate: 0.15, XPValue: 25000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The pit fiend makes four attacks: one with its bite, one with its claw, one with its mace, and one with its tail. Traits: Fear Aura, Magic Resistance, Magic Weapons, Innate Spellcasting"},
+		"ancient_black_dragon":      {ID: "ancient_black_dragon", Name: "Ancient Black Dragon", CR: 21, HP: 367, AC: 22, Attack: 34, AttackBonus: 15, Speed: 16, BlockRate: 0.15, XPValue: 33000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
+		"ancient_copper_dragon":     {ID: "ancient_copper_dragon", Name: "Ancient Copper Dragon", CR: 21, HP: 350, AC: 21, Attack: 34, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 33000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
+		"lich":                      {ID: "lich", Name: "Lich", CR: 21, HP: 135, AC: 17, Attack: 34, AttackBonus: 12, Speed: 12, BlockRate: 0.1, XPValue: 33000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Traits: Legendary Resistance (3/Day), Rejuvenation, Spellcasting, Turn Resistance"},
+		"solar":                     {ID: "solar", Name: "Solar", CR: 21, HP: 243, AC: 21, Attack: 34, AttackBonus: 15, Speed: 18, BlockRate: 0.15, XPValue: 33000, Ability: &MonsterAbility{Name: "Spellcasting", Phase: "opening", ProcChance: 0.5, Effect: "aoe"}, Notes: "SRD-tuned baseline — Spellcasting (aoe) wired from traits. Multiattack: The solar makes two greatsword attacks. Traits: Angelic Weapons, Divine Awareness, Innate Spellcasting, Magic Resistance"},
+		"ancient_bronze_dragon":     {ID: "ancient_bronze_dragon", Name: "Ancient Bronze Dragon", CR: 22, HP: 444, AC: 22, Attack: 36, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 41000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
+		"ancient_green_dragon":      {ID: "ancient_green_dragon", Name: "Ancient Green Dragon", CR: 22, HP: 385, AC: 21, Attack: 36, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 41000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)"},
+		"ancient_blue_dragon":       {ID: "ancient_blue_dragon", Name: "Ancient Blue Dragon", CR: 23, HP: 481, AC: 22, Attack: 37, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 50000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
+		"ancient_silver_dragon":     {ID: "ancient_silver_dragon", Name: "Ancient Silver Dragon", CR: 23, HP: 487, AC: 22, Attack: 37, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 50000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)"},
+		"kraken":                    {ID: "kraken", Name: "Kraken", CR: 23, HP: 472, AC: 18, Attack: 37, AttackBonus: 7, Speed: 8, BlockRate: 0.15, XPValue: 50000, Notes: "SRD-tuned baseline — no ability wired (traits are non-combat). Multiattack: The kraken makes three tentacle attacks, each of which it can replace with one use of Fling. Traits: Amphibious, Freedom of Movement, Siege Monster"},
+		"ancient_gold_dragon":       {ID: "ancient_gold_dragon", Name: "Ancient Gold Dragon", CR: 24, HP: 546, AC: 22, Attack: 38, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 62000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Amphibious, Legendary Resistance (3/Day)", FireAttacker: true},
+		"ancient_red_dragon":        {ID: "ancient_red_dragon", Name: "Ancient Red Dragon", CR: 24, HP: 546, AC: 22, Attack: 38, AttackBonus: 0, Speed: 16, BlockRate: 0.15, XPValue: 62000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The dragon can use its Frightful Presence. Traits: Legendary Resistance (3/Day)", FireAttacker: true},
+		"tarrasque":                 {ID: "tarrasque", Name: "Tarrasque", CR: 30, HP: 676, AC: 25, Attack: 46, AttackBonus: 19, Speed: 16, BlockRate: 0.15, XPValue: 155000, Ability: &MonsterAbility{Name: "Magic Resistance", Phase: "any", ProcChance: 0.5, Effect: "spell_resist"}, Notes: "SRD-tuned baseline — Magic Resistance (spell_resist) wired from traits. Multiattack: The tarrasque can use its Frightful Presence. Traits: Legendary Resistance (3/Day), Magic Resistance, Reflective Carapace, Siege Monster"},
 	}
 }

internal/plugin/blackjack.go

@@ -141,11 +141,11 @@ type bjTable struct {
 // ---------------------------------------------------------------------------
 
 type bjConfig struct {
-	TimeoutSeconds     int
-	AutoplayThreshold  int
-	MinBet             float64
-	MaxBet             float64
-	DebtLimit          float64
+	TimeoutSeconds    int
+	AutoplayThreshold int
+	MinBet            float64
+	MaxBet            float64
+	DebtLimit         float64
 }
 
 func loadBJConfig() bjConfig {
@@ -877,5 +877,3 @@ func (p *BlackjackPlugin) recordBJScore(userID id.UserID, net float64) {
 		recordBotDefeat(userID, "blackjack")
 	}
 }
-
-

internal/plugin/bootstrap_caster_hp.go

@@ -0,0 +1,84 @@
+package plugin
+
+import (
+	"log/slog"
+
+	"gogobee/internal/db"
+)
+
+// bootstrapCasterHPRefresh recomputes hp_max for caster characters after
+// the J3 D8-d-fix caster HP multiplier (casterHPMult in dnd.go) shipped.
+// Without this, existing caster rows keep their pre-lift hp_max until
+// the next computeMaxHP recall (level-up / reset). Mirrors
+// bootstrapPhase5BHPRefresh — only ever raises hp_max, preserves the
+// absolute wound (delta added to hp_current, capped at new max). Run
+// once per startup, idempotent via db.JobCompleted.
+func bootstrapCasterHPRefresh() {
+	const jobName = "caster_hp_refresh_v1"
+	if db.JobCompleted(jobName, "once") {
+		return
+	}
+
+	d := db.Get()
+	rows, err := d.Query(`
+		SELECT user_id, class, con_score, dnd_level, hp_max, hp_current
+		FROM dnd_character WHERE dnd_level > 0`)
+	if err != nil {
+		slog.Error("caster hp refresh: enumerate failed", "err", err)
+		return
+	}
+	defer rows.Close()
+
+	type row struct {
+		userID    string
+		class     DnDClass
+		conScore  int
+		level     int
+		hpMax     int
+		hpCurrent int
+	}
+	var batch []row
+	for rows.Next() {
+		var r row
+		var classStr string
+		if err := rows.Scan(&r.userID, &classStr, &r.conScore, &r.level, &r.hpMax, &r.hpCurrent); err != nil {
+			slog.Warn("caster hp refresh: scan failed", "err", err)
+			continue
+		}
+		r.class = DnDClass(classStr)
+		batch = append(batch, r)
+	}
+
+	refreshed := 0
+	for _, r := range batch {
+		if casterHPMult(r.class) == 1.0 {
+			continue
+		}
+		conMod := abilityModifier(r.conScore)
+		newMax := computeMaxHP(r.class, conMod, r.level)
+		if newMax <= r.hpMax {
+			continue
+		}
+		delta := newMax - r.hpMax
+		newCurrent := r.hpCurrent + delta
+		if newCurrent > newMax {
+			newCurrent = newMax
+		}
+		if newCurrent < 1 {
+			newCurrent = 1
+		}
+		if _, err := d.Exec(`UPDATE dnd_character
+			SET hp_max = ?, hp_current = ?, updated_at = CURRENT_TIMESTAMP
+			WHERE user_id = ?`,
+			newMax, newCurrent, r.userID); err != nil {
+			slog.Warn("caster hp refresh: update failed", "user", r.userID, "err", err)
+			continue
+		}
+		refreshed++
+	}
+
+	db.MarkJobCompleted(jobName, "once")
+	if refreshed > 0 {
+		slog.Info("caster hp refresh: refreshed caster HPMax to D8-d-fix floor", "count", refreshed)
+	}
+}

internal/plugin/bootstrap_josie_caster_aid.go

@@ -0,0 +1,144 @@
+package plugin
+
+import (
+	"log/slog"
+	"time"
+
+	"gogobee/internal/db"
+	"maunium.net/go/mautrix/id"
+)
+
+// Two one-shot startup bootstraps that lift a low-DPS caster who was stuck in a
+// boss-wall "death loop". Diagnosis: the boss isn't overtuned — the player is an
+// over-levelled cleric whose damage output is structurally low. Two account
+// gaps, fixed idempotently here so they reach the live player without a respec.
+//
+// 1. bootstrapCasterSpellBackfill — characters created before a default spell
+//    was added to defaultKnownSpells keep their original spellbook forever:
+//    ensureSpellsForCharacter only seeds when the known-spell list is EMPTY, so
+//    later default additions never reach existing casters. This backfills any
+//    missing default into known+prepared (e.g. inflict_wounds, added to the
+//    cleric defaults after the affected character was rolled). General + future
+//    proof — it fixes any caster with the same stale-default gap.
+//
+// 2. bootstrapGrantStarterPet — a targeted gift of a combat companion to a
+//    specific endgame player who never received the 25% morning pet-arrival
+//    roll. A pet adds sustained per-round damage + deflect mitigation, which
+//    helps caster trailers most.
+
+// bootstrapCasterSpellBackfill adds any missing defaultKnownSpells entry to
+// every existing caster as known+prepared. addKnownSpell is idempotent and
+// leaves the prepared flag of already-known spells untouched (ON CONFLICT only
+// refreshes source), so this only ever adds the genuinely-missing defaults.
+func bootstrapCasterSpellBackfill() {
+	const jobName = "caster_default_spell_backfill_v1"
+	if db.JobCompleted(jobName, "once") {
+		return
+	}
+
+	chars, err := loadAllAdvCharacters()
+	if err != nil {
+		slog.Error("bootstrap: caster spell backfill — load characters failed", "err", err)
+		return
+	}
+
+	added := 0
+	for _, ac := range chars {
+		c, err := LoadDnDCharacter(ac.UserID)
+		if err != nil || c == nil || !isSpellcaster(c) {
+			continue
+		}
+		known, err := listKnownSpells(c.UserID)
+		if err != nil {
+			slog.Warn("bootstrap: caster spell backfill — list known failed", "user", c.UserID, "err", err)
+			continue
+		}
+		have := make(map[string]bool, len(known))
+		for _, k := range known {
+			have[k.SpellID] = true
+		}
+		defaults := defaultKnownSpells(c.Class, c.Level)
+		if c.Class == ClassRogue && c.Subclass == SubclassArcaneTrickster {
+			defaults = arcaneTricksterDefaultSpells(c.Level)
+		}
+		for _, sid := range defaults {
+			if have[sid] {
+				continue
+			}
+			if err := addKnownSpell(c.UserID, sid, "class", true); err != nil {
+				slog.Error("bootstrap: caster spell backfill — add failed", "user", c.UserID, "spell", sid, "err", err)
+				continue
+			}
+			slog.Info("bootstrap: backfilled default spell", "user", c.UserID, "spell", sid)
+			added++
+		}
+	}
+
+	db.MarkJobCompleted(jobName, "once")
+	if added > 0 {
+		slog.Warn("bootstrap: caster default-spell backfill complete", "spells_added", added)
+	}
+}
+
+// josieStarterPet identifies the one player the pet gift targets and the pet
+// it grants. Kept as data so the intent is legible: this is an admin gift, not
+// a game-wide policy.
+var josieStarterPet = struct {
+	userID id.UserID
+	typ    string
+	name   string
+	level  int
+}{
+	userID: "@holymachina:parodia.dev",
+	typ:    "dog",
+	name:   "Biscuit",
+	level:  10,
+}
+
+// bootstrapGrantStarterPet gives the targeted player a combat companion if they
+// have none. No-op once they have a pet (this gift, a later arrival, or one
+// chased away — we don't override the player's own pet history). Idempotent via
+// the job gate AND the has-pet guard.
+func bootstrapGrantStarterPet() {
+	const jobName = "grant_starter_pet_holymachina_v1"
+	if db.JobCompleted(jobName, "once") {
+		return
+	}
+	g := josieStarterPet
+
+	char, err := loadAdvCharacter(g.userID)
+	if err != nil || char == nil {
+		// Target not present in this DB (e.g. fresh deploy) — mark done so we
+		// don't re-scan every startup; the gift is a one-off, not a standing rule.
+		db.MarkJobCompleted(jobName, "once")
+		return
+	}
+	if char.PetType != "" || char.PetArrived {
+		slog.Info("bootstrap: starter pet — target already has a pet, skipping", "user", g.userID)
+		db.MarkJobCompleted(jobName, "once")
+		return
+	}
+
+	char.PetType = g.typ
+	char.PetName = g.name
+	char.PetLevel = g.level
+	char.PetXP = 0
+	char.PetArrived = true
+	char.PetChasedAway = false
+	if g.level >= 10 {
+		// Mirror the babysit path that stamps the L10 date when a pet first
+		// reaches the cap, so milestone/supply-shop logic stays consistent.
+		char.PetLevel10Date = time.Now().UTC().Format("2006-01-02")
+	}
+	if err := saveAdvCharacter(char); err != nil {
+		slog.Error("bootstrap: starter pet — save failed", "user", g.userID, "err", err)
+		return
+	}
+	if err := upsertPlayerMetaPetState(char.UserID, petStateFromAdvChar(char)); err != nil {
+		slog.Error("bootstrap: starter pet — player_meta mirror failed", "user", g.userID, "err", err)
+		return
+	}
+
+	db.MarkJobCompleted(jobName, "once")
+	slog.Warn("bootstrap: granted starter pet", "user", g.userID, "pet", g.name, "level", g.level)
+}

internal/plugin/bootstrap_rooms_traversed.go

@@ -0,0 +1,35 @@
+package plugin
+
+import (
+	"log/slog"
+
+	"gogobee/internal/db"
+)
+
+// bootstrapRoomsTraversed backfills dnd_zone_run.rooms_traversed for rows
+// that predate the revisit R1 column. Before R1 the step counter was implicit
+// — len(visited_nodes) — because navigation was forward-only, so replaying
+// that identity is an exact reconstruction, not an estimate.
+//
+// The ALTER lands DEFAULT 0, which would tell an in-flight run it has walked
+// nowhere: ambient narration cadence would reset to the entry-room line and
+// R2's revisit preflight would read a fresh run. Hence the backfill.
+//
+// Idempotent, and safe to run against live rows: every row written after R1
+// inserts rooms_traversed >= 1 (the entry node counts as one traversal), so
+// `rooms_traversed = 0` uniquely identifies a row this has not yet touched.
+// Kept in-tree permanently — a fresh deploy restoring an old backup needs it
+// (feedback_loader_rewire_needs_bootstrap).
+func bootstrapRoomsTraversed() {
+	res, err := db.Get().Exec(`
+		UPDATE dnd_zone_run
+		   SET rooms_traversed = MAX(json_array_length(visited_nodes), 1)
+		 WHERE rooms_traversed = 0`)
+	if err != nil {
+		slog.Error("bootstrap: rooms_traversed backfill failed", "err", err)
+		return
+	}
+	if n, _ := res.RowsAffected(); n > 0 {
+		slog.Warn("bootstrap: rooms_traversed backfilled from visited_nodes", "rows", n)
+	}
+}

internal/plugin/combat_armed_ability_test.go

@@ -0,0 +1,294 @@
+package plugin
+
+import (
+	"testing"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// An armed ability is consumed once, at fight start, and its id is parked on the
+// seat. Everything here defends that split.
+//
+// Before it existed, buildZoneCombatants consumed the ability itself — and the
+// turn-based engine calls that builder again on every !attack. So a Berserker
+// raged on round 1, the builder cleared their armed flag and saved, and round 2
+// rebuilt them with no rage at all. They paid stamina for one round of a buff
+// that is supposed to span the fight, and the close-out could not see the rage
+// it was supposed to charge exhaustion for.
+
+// ragingBerserker is a Fighter who has already `!arm`ed rage.
+func ragingBerserker(t *testing.T, uid id.UserID) *DnDCharacter {
+	t.Helper()
+	if err := createAdvCharacter(uid, string(uid)); err != nil {
+		t.Fatal(err)
+	}
+	c := &DnDCharacter{
+		UserID: uid, Race: RaceHuman, Class: ClassFighter, Subclass: SubclassBerserker, Level: 5,
+		STR: 16, DEX: 12, CON: 14, INT: 10, WIS: 10, CHA: 10,
+		HPMax: 40, HPCurrent: 40, ArmorClass: 15,
+		ArmedAbility: "rage",
+	}
+	if err := SaveDnDCharacter(c); err != nil {
+		t.Fatal(err)
+	}
+	return c
+}
+
+// ── the split ────────────────────────────────────────────────────────────────
+
+// consumeArmedAbility disarms and reports; applyAbilityByID applies and does not
+// disarm. Calling the second one twice must be indistinguishable from once.
+func TestApplyAbilityByID_IsPureAndRepeatable(t *testing.T) {
+	setupEmptyTestDB(t)
+	c := ragingBerserker(t, "@pure:example.org")
+
+	armed := consumeArmedAbility(c)
+	if armed != "rage" {
+		t.Fatalf("consumeArmedAbility = %q, want rage", armed)
+	}
+	if c.ArmedAbility != "" {
+		t.Errorf("character still armed after consume: %q", c.ArmedAbility)
+	}
+	if again := consumeArmedAbility(c); again != "" {
+		t.Errorf("second consume returned %q, want \"\" — the ability is spent", again)
+	}
+
+	// Same id, applied to two independent mod sets, yields the same rage.
+	for i, want := range []bool{true, true} {
+		var mods CombatModifiers
+		name, fired := applyAbilityByID(c, armed, &mods)
+		if !fired || name != "Rage" {
+			t.Fatalf("apply #%d: fired=%v name=%q", i+1, fired, name)
+		}
+		if mods.BerserkerRage != want {
+			t.Errorf("apply #%d: BerserkerRage = %v, want %v", i+1, mods.BerserkerRage, want)
+		}
+		if mods.RageMeleeDmg != 2 || !mods.PhysicalResistRage {
+			t.Errorf("apply #%d: rage did not carry its full mod set: %+v", i+1, mods)
+		}
+	}
+
+	// And it never writes back to the sheet.
+	got, _ := LoadDnDCharacter(c.UserID)
+	if got.ArmedAbility != "" {
+		t.Errorf("applyAbilityByID re-armed the sheet: %q", got.ArmedAbility)
+	}
+}
+
+func TestApplyAbilityByID_UnknownAndEmptyAreNoOps(t *testing.T) {
+	c := &DnDCharacter{Class: ClassFighter}
+	for _, id := range []string{"", "no_such_ability"} {
+		var mods CombatModifiers
+		if _, fired := applyAbilityByID(c, id, &mods); fired {
+			t.Errorf("applyAbilityByID(%q) fired", id)
+		}
+		if mods.BerserkerRage {
+			t.Errorf("applyAbilityByID(%q) set rage", id)
+		}
+	}
+}
+
+// ── the fight-start seat ─────────────────────────────────────────────────────
+
+// The seat carries the id forward, and the sheet is disarmed exactly once.
+func TestBuildFightSeats_ConsumesTheAbilityOnceAndCarriesItOnTheSeat(t *testing.T) {
+	setupEmptyTestDB(t)
+	uid := id.UserID("@berserk:example.org")
+	ragingBerserker(t, uid)
+
+	seats, _, _, refusal := (&AdventurePlugin{}).buildFightSeats(
+		uid, []id.UserID{uid}, dndBestiary["goblin"], 1, 0)
+	if refusal != "" {
+		t.Fatalf("fight refused: %s", refusal)
+	}
+	if len(seats) != 1 {
+		t.Fatalf("seats = %d, want 1", len(seats))
+	}
+	if seats[0].ArmedAbility != "rage" {
+		t.Errorf("seat.ArmedAbility = %q, want rage", seats[0].ArmedAbility)
+	}
+	if !seats[0].Mods.BerserkerRage {
+		t.Error("seat built without rage in its mods")
+	}
+	got, _ := LoadDnDCharacter(uid)
+	if got.ArmedAbility != "" {
+		t.Errorf("sheet still armed after fight start: %q", got.ArmedAbility)
+	}
+}
+
+// The regression itself: rebuilding the combatant — what every !attack does —
+// must reproduce the rage from the persisted id, not from the (now cleared)
+// sheet. Two rebuilds in a row, both raging.
+func TestBuildZoneCombatants_RebuildKeepsTheRageForTheWholeFight(t *testing.T) {
+	setupEmptyTestDB(t)
+	uid := id.UserID("@rebuild:example.org")
+	ragingBerserker(t, uid)
+	p := &AdventurePlugin{}
+
+	seats, _, _, refusal := p.buildFightSeats(uid, []id.UserID{uid}, dndBestiary["goblin"], 1, 0)
+	if refusal != "" {
+		t.Fatalf("fight refused: %s", refusal)
+	}
+	armed := seats[0].ArmedAbility
+
+	for round := 2; round <= 3; round++ {
+		player, _, _, err := p.buildZoneCombatants(uid, dndBestiary["goblin"], 1, 0, armed)
+		if err != nil {
+			t.Fatalf("round %d rebuild: %v", round, err)
+		}
+		if !player.Mods.BerserkerRage {
+			t.Errorf("round %d: rage evaporated on rebuild", round)
+		}
+		if player.Mods.RageMeleeDmg != 2 {
+			t.Errorf("round %d: RageMeleeDmg = %d, want 2", round, player.Mods.RageMeleeDmg)
+		}
+	}
+
+	// A seat that armed nothing rebuilds without rage — the id is the only source.
+	player, _, _, err := p.buildZoneCombatants(uid, dndBestiary["goblin"], 1, 0, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if player.Mods.BerserkerRage {
+		t.Error("unarmed rebuild raged anyway")
+	}
+}
+
+// A member who is down sits the fight out. They must not be charged the ability
+// they had readied for it — the refusal is checked before the arm.
+func TestBuildFightSeats_SatOutMemberKeepsTheirArmedAbility(t *testing.T) {
+	setupEmptyTestDB(t)
+	leader := id.UserID("@lead:example.org")
+	downed := id.UserID("@downed:example.org")
+	fightTestChar(t, leader, 30)
+	ragingBerserker(t, downed)
+
+	// Drop the member to 0 HP with rage still armed.
+	c, _ := LoadDnDCharacter(downed)
+	c.HPCurrent = 0
+	if err := SaveDnDCharacter(c); err != nil {
+		t.Fatal(err)
+	}
+
+	seats, _, _, refusal := (&AdventurePlugin{}).buildFightSeats(
+		leader, []id.UserID{leader, downed}, dndBestiary["goblin"], 1, 0)
+	if refusal != "" {
+		t.Fatalf("fight refused: %s", refusal)
+	}
+	if len(seats) != 1 || seats[0].UserID != leader {
+		t.Fatalf("seats = %+v, want the leader alone", seats)
+	}
+	got, _ := LoadDnDCharacter(downed)
+	if got.ArmedAbility != "rage" {
+		t.Errorf("downed member was disarmed for a fight they never joined: %q", got.ArmedAbility)
+	}
+}
+
+// ── the close-out ────────────────────────────────────────────────────────────
+
+func TestSeatFightStartMods_ReadsTheRageOffTheSeatsStatuses(t *testing.T) {
+	c := &DnDCharacter{Class: ClassFighter, Subclass: SubclassBerserker, Level: 5}
+
+	raging := &CombatSession{}
+	raging.Statuses.ArmedAbility = "rage"
+	if !seatFightStartMods(raging, 0, c).BerserkerRage {
+		t.Error("seat 0 armed rage, mods say otherwise")
+	}
+
+	// Seat 1 reads its own statuses, not the leader's.
+	party := &CombatSession{Participants: []CombatParticipant{{Seat: 1}}}
+	party.Statuses.ArmedAbility = "rage"
+	if seatFightStartMods(party, 1, c).BerserkerRage {
+		t.Error("a member inherited the leader's rage")
+	}
+}
+
+func TestSeatCombatResult_ReadsWinAndNearDeathOffTheSession(t *testing.T) {
+	sess := &CombatSession{
+		Status: CombatStatusWon, Round: 4, PlayerHP: 5, PlayerHPMax: 40, EnemyHP: 0,
+		TurnLog: []CombatEvent{
+			{Action: "attack", Seat: 0},
+			{Action: "use_consumable", Seat: 1},
+		},
+	}
+	got := seatCombatResult(sess, 0)
+	if !got.PlayerWon {
+		t.Error("PlayerWon = false on a won session")
+	}
+	if !got.NearDeath {
+		t.Error("5/40 HP is under the 15% near-death line")
+	}
+	if len(got.Events) != 1 || got.Events[0].Action != "attack" {
+		t.Errorf("seat 0 got seat 1's events: %+v", got.Events)
+	}
+
+	sess.PlayerHP = 30
+	if seatCombatResult(sess, 0).NearDeath {
+		t.Error("30/40 HP is not near death")
+	}
+	sess.Status = CombatStatusLost
+	sess.PlayerHP = 0
+	if seatCombatResult(sess, 0).PlayerWon {
+		t.Error("PlayerWon = true on a lost session")
+	}
+}
+
+// Item A: the manual kill now costs the Berserker their exhaustion, exactly as
+// the auto-resolved one always has.
+func TestPostCombatBookkeepingForSeat_RageCostsExhaustionOnTheTurnBasedPath(t *testing.T) {
+	setupEmptyTestDB(t)
+	uid := id.UserID("@exhausted:example.org")
+	ragingBerserker(t, uid)
+
+	sess := &CombatSession{
+		UserID: string(uid), Status: CombatStatusWon, Round: 3,
+		PlayerHP: 12, PlayerHPMax: 40,
+	}
+	sess.Statuses.ArmedAbility = "rage"
+
+	(&AdventurePlugin{}).postCombatBookkeepingForSeat(sess, 0)
+
+	got, _ := LoadDnDCharacter(uid)
+	if got.Exhaustion != 1 {
+		t.Errorf("Exhaustion = %d after a raging win, want 1", got.Exhaustion)
+	}
+}
+
+// A fight nobody raged in leaves the sheet alone.
+func TestPostCombatBookkeepingForSeat_NoRageNoExhaustion(t *testing.T) {
+	setupEmptyTestDB(t)
+	uid := id.UserID("@calm:example.org")
+	fightTestChar(t, uid, 30)
+
+	sess := &CombatSession{
+		UserID: string(uid), Status: CombatStatusWon, Round: 2,
+		PlayerHP: 20, PlayerHPMax: 30,
+	}
+	(&AdventurePlugin{}).postCombatBookkeepingForSeat(sess, 0)
+
+	got, _ := LoadDnDCharacter(uid)
+	if got.Exhaustion != 0 {
+		t.Errorf("Exhaustion = %d with no rage, want 0", got.Exhaustion)
+	}
+}
+
+// Losing while raging still exhausts you — the close-out runs on every terminal
+// status, not just the win. This is the half the turn-based path used to skip.
+func TestPostCombatBookkeepingForSeat_RageCostsExhaustionOnALoss(t *testing.T) {
+	setupEmptyTestDB(t)
+	uid := id.UserID("@dead:example.org")
+	ragingBerserker(t, uid)
+
+	sess := &CombatSession{
+		UserID: string(uid), Status: CombatStatusLost, Round: 6,
+		PlayerHP: 0, PlayerHPMax: 40,
+	}
+	sess.Statuses.ArmedAbility = "rage"
+
+	(&AdventurePlugin{}).postCombatBookkeepingForSeat(sess, 0)
+
+	got, _ := LoadDnDCharacter(uid)
+	if got.Exhaustion != 1 {
+		t.Errorf("Exhaustion = %d after a raging loss, want 1", got.Exhaustion)
+	}
+}

internal/plugin/combat_bridge.go

@@ -10,6 +10,30 @@ import (
 	"maunium.net/go/mautrix/id"
 )
 
+// postCombatBookkeeping is the close-out every fight owes its character,
+// whatever surface it was fought on: achievements, and the subclass state that
+// outlives the fight (Berserker exhaustion, Grim Harvest's kill-heal).
+//
+// It exists because there are four close-outs — two auto-resolve
+// (runDungeonCombat, runZoneCombatRoster) and two turn-based
+// (finishCombatSession, finishPartyCombatSession) — and for a long time only
+// the auto-resolve pair ran any of this. The same Elite kill therefore paid out
+// differently depending on whether the player let it auto-resolve or fought it
+// a round at a time. Route all four through here and the divergence cannot
+// silently reopen.
+//
+// raged is whether the character's Berserker rage was active for this fight;
+// mods carries the fight-start modifiers Grim Harvest reads. HP persistence is
+// NOT done here — the turn-based paths already own their own HP writes.
+func (p *AdventurePlugin) postCombatBookkeeping(
+	userID id.UserID, dndChar *DnDCharacter, raged bool, result CombatResult, mods CombatModifiers,
+) {
+	p.grantCombatAchievements(userID, result)
+	if err := persistDnDPostCombatSubclass(dndChar, raged, result, mods); err != nil {
+		slog.Error("dnd: post-combat subclass persist", "user", userID, "err", err)
+	}
+}
+
 // grantCombatAchievements checks combat results for achievement-worthy moments.
 func (p *AdventurePlugin) grantCombatAchievements(userID id.UserID, result CombatResult) {
 	if p.achievements == nil {
@@ -87,7 +111,7 @@ func (p *AdventurePlugin) runDungeonCombat(
 	applySubclassPassives(&playerStats, &playerMods, dndChar)
 	applyMagicItemEffects(&playerStats, &playerMods, userID)
 	trySimAutoArm(dndChar)
-	if firedName, fired := applyArmedAbility(dndChar, &playerMods); fired {
+	if firedName, fired := armAbilityForFight(dndChar, &playerMods); fired {
 		slog.Info("dnd: armed ability fired", "user", userID, "ability", firedName)
 	}
 	applyDnDDungeonMonsterLayer(&enemyStats, loc.Tier)
@@ -129,12 +153,8 @@ func (p *AdventurePlugin) runDungeonCombat(
 	// until a player-driven use command lands.
 	consumeFiredHealingItems(userID, countHealEventsFired(result))
 
-	p.grantCombatAchievements(userID, result)
-
 	persistDnDHPAfterCombat(userID, result.PlayerEndHP)
-	if err := persistDnDPostCombatSubclass(dndChar, playerMods.BerserkerRage, result, playerMods); err != nil {
-		slog.Error("dnd: post-combat subclass persist (dungeon)", "user", userID, "err", err)
-	}
+	p.postCombatBookkeeping(userID, dndChar, playerMods.BerserkerRage, result, playerMods)
 
 	if xp := dungeonCombatXP(result, loc.Tier); xp > 0 {
 		if _, err := p.grantDnDXP(userID, xp); err != nil {
@@ -165,7 +185,7 @@ func (p *AdventurePlugin) loadConsumableInventory(userID id.UserID) []Consumable
 	// Auto-craft if player has foraging level 10+
 	char, err := loadAdvCharacter(userID)
 	if err == nil && char.ForagingSkill >= 10 {
-		craftResults, updatedItems := autoCraftConsumables(userID, items, char.ForagingSkill)
+		craftResults, updatedItems := autoCraftConsumables(userID, items, char.ForagingSkill, homeWorkshopCraftBonus(char.HouseTier))
 		if len(craftResults) > 0 {
 			items = updatedItems
 			for _, cr := range craftResults {
@@ -592,4 +612,3 @@ func (p *AdventurePlugin) resolveDungeonAction(
 
 	return result
 }
-

internal/plugin/combat_cmd.go

@@ -27,34 +27,53 @@ func encounterIDForRoom(roomIdx int) string {
 	return fmt.Sprintf("room%d", roomIdx)
 }
 
+// replyDM sends a player-facing combat reply unless ctx.Silent is set. The
+// turn-engine combat commands route all their DMs through here so the
+// background autopilot can drive a boss/elite fight on the real engine
+// (long-expedition D8-f) without spamming the player a DM per round — the
+// state mutations (HP, XP, threat, run-clear) still happen; only the
+// narration is dropped. Non-silent callers (manual !fight) are unchanged.
+func (p *AdventurePlugin) replyDM(ctx MessageContext, text string) error {
+	// An empty body means the caller already answered the player another way —
+	// a party fan-out, say. Sending it would post a blank DM.
+	if ctx.Silent || text == "" {
+		return nil
+	}
+	return p.SendDM(ctx.Sender, text)
+}
+
 // ── !fight ──────────────────────────────────────────────────────────────────
 
 func (p *AdventurePlugin) handleFightCmd(ctx MessageContext) error {
-	userMu := p.advUserLock(ctx.Sender)
-	userMu.Lock()
-	defer userMu.Unlock()
+	// Resolve the roster before locking — a member's `!fight` opens the leader's
+	// fight, under the leader's lock, and seat 0 names that leader. fightRoster
+	// deliberately does not touch getActiveZoneRun: that lookup carries the §4.3
+	// idle reap, and it must only ever fire under the lock, on its owner's behalf.
+	roster := fightRoster(ctx.Sender)
+	release := p.lockCombatFight(roster[0], ctx.Sender)
+	defer release()
 
-	run, err := getActiveZoneRun(ctx.Sender)
+	run, _, err := activeZoneRunFor(ctx.Sender)
 	if err != nil {
-		return p.SendDM(ctx.Sender, "Couldn't read run state: "+err.Error())
+		return p.replyDM(ctx, "Couldn't read run state: "+err.Error())
 	}
 	if run == nil {
-		return p.SendDM(ctx.Sender, "No active zone run. Use `!zone enter <id>` first.")
+		return p.replyDM(ctx, "No active zone run. Use `!zone enter <id>` first.")
 	}
 	roomType := run.CurrentRoomType()
 	if roomType != RoomElite && roomType != RoomBoss {
-		return p.SendDM(ctx.Sender, "Nothing to fight here — `!fight` is for Elite and Boss rooms. Use `!zone advance`.")
+		return p.replyDM(ctx, "Nothing to fight here — `!fight` is for Elite and Boss rooms. Use `!zone advance`.")
 	}
 
 	encID := encounterIDForRoom(run.CurrentRoom)
 	if existing, _ := getCombatSessionForEncounter(run.RunID, encID); existing != nil {
 		switch existing.Status {
 		case CombatStatusActive:
-			return p.SendDM(ctx.Sender, "You're already in this fight — `!attack` or `!flee`.")
+			return p.replyDM(ctx, "You're already in this fight — `!attack` or `!flee`.")
 		case CombatStatusWon:
-			return p.SendDM(ctx.Sender, "You've already cleared this room. `!zone advance` to move on.")
+			return p.replyDM(ctx, "You've already cleared this room. "+continueHint(ctx.Sender))
 		default:
-			return p.SendDM(ctx.Sender, "This fight is already over. `!zone status` for where you stand.")
+			return p.replyDM(ctx, "This fight is already over. `!zone status` for where you stand.")
 		}
 	}
 
@@ -67,38 +86,37 @@ func (p *AdventurePlugin) handleFightCmd(ctx MessageContext) error {
 	} else {
 		monster, ok = pickZoneEnemy(zone, run.RunID, run.CurrentRoom, true)
 	}
-	if !ok {
-		return p.SendDM(ctx.Sender, "_(No bestiary entry for this encounter — file a bug. `!zone abandon` to bail.)_")
+	if !ok || monster.ID == "" {
+		// monster.ID == "" guards a malformed bestiary entry (e.g. one whose
+		// ID field was dropped): startCombatSession would otherwise persist a
+		// session with an empty EnemyID, and the turn engine — having no enemy
+		// to resolve — spins inertly until autoDriveCombat's round cap. Fail
+		// loudly instead of stalling.
+		return p.replyDM(ctx, "_(No bestiary entry for this encounter — file a bug. `!zone abandon` to bail.)_")
 	}
 
-	player, enemy, _, err := p.buildZoneCombatants(ctx.Sender, monster, int(zone.Tier), run.DMMood)
-	if err != nil {
-		return p.SendDM(ctx.Sender, "Couldn't set up the fight: "+err.Error())
+	// Seat the whole party, leader first. A solo player is a one-seat roster and
+	// takes the path they always took: one build, one INSERT, no participant rows.
+	seats, enemy, senderSkip, refusal := p.buildFightSeats(ctx.Sender, roster, monster, int(zone.Tier), run.DMMood)
+	if refusal != "" {
+		return p.replyDM(ctx, refusal)
 	}
+	// The persisted session scales enemy HP for a party (solo scales by 1.0, so
+	// this is a no-op there); mirror it here so the entry banner and the opening
+	// round resolve against the same ceiling startPartyCombatSession persisted and
+	// the rebuilt rounds use.
+	enemyHP := scaledEnemyMaxHP(enemy.Stats.MaxHP, len(seats))
 
-	playerHP, playerMax := dndHPSnapshot(ctx.Sender)
-	if playerHP <= 0 {
-		return p.SendDM(ctx.Sender, "You're in no shape to fight. `!rest` first.")
-	}
-	enemyHP := enemy.Stats.MaxHP
-
-	sess, err := startCombatSession(ctx.Sender, run.RunID, encID, monster.ID, playerHP, playerMax, enemyHP, enemyHP)
+	// Fight-start one-shot resources (Abjuration Arcane Ward, etc.) are seeded
+	// per seat onto the session and its participant rows, so they survive the
+	// turn engine's resume/commit cycle. The pet rolls per-turn inside the
+	// engine, so there's no fight-start roll.
+	sess, err := p.startPartyCombatSession(run.RunID, encID, monster.ID, enemy, seats)
 	if err != nil {
 		if err == ErrCombatSessionAlreadyActive {
-			return p.SendDM(ctx.Sender, "You're already in a fight. Finish it with `!attack` / `!flee`.")
-		}
-		return p.SendDM(ctx.Sender, "Couldn't start the fight: "+err.Error())
-	}
-
-	// Carry fight-start one-shot resources (Abjuration Arcane Ward, etc.) onto
-	// the session so they survive the turn engine's resume/commit cycle, and
-	// make the one-and-only per-fight pet-attack roll.
-	seeded := seedCombatSessionOneShots(sess, player.Mods)
-	pet := rollCombatSessionPetProc(sess, player.Mods)
-	if seeded || pet {
-		if err := saveCombatSession(sess); err != nil {
-			slog.Error("combat: seed session one-shots", "user", ctx.Sender, "err", err)
+			return p.replyDM(ctx, "You're already in a fight. Finish it with `!attack` / `!flee`.")
 		}
+		return p.replyDM(ctx, "Couldn't start the fight: "+err.Error())
 	}
 
 	var b strings.Builder
@@ -113,14 +131,57 @@ func (p *AdventurePlugin) handleFightCmd(ctx MessageContext) error {
 		}
 		b.WriteString(fmt.Sprintf("⚔️ **Elite — %s** (HP %d, AC %d)\n", monster.Name, enemyHP, enemy.Stats.AC))
 	}
-	b.WriteString(fmt.Sprintf("You: **%d/%d HP**.\n", playerHP, playerMax))
-	if curios := activeMagicItemsLine(ctx.Sender); curios != "" {
+
+	if sess.IsParty() {
+		players := seatCombatants(seats)
+		// Align the in-memory template with the scaled HP persisted above, so the
+		// opening-round settle resolves the enemy against the same MaxHP the
+		// rebuilt rounds do (regen clamp, bloodied-ability threshold). The persist
+		// already happened off the unscaled value, so this does not double-scale.
+		enemy.Stats.MaxHP = enemyHP
+		// The enemy may have won initiative. Resolve everything the round owes
+		// before anyone is asked to act, so the opening block narrates the hit
+		// rather than showing its damage with no explanation.
+		opening, serr := settleCombatSession(sess, players, enemy)
+		if serr != nil {
+			return p.replyDM(ctx, "Couldn't resolve the round: "+serr.Error())
+		}
+		ct := &combatTurn{sess: sess, players: players, enemy: enemy, seat: 0, uid: roster[0]}
+		outcomes := p.closePartyRound(ct)
+		if !ctx.Silent {
+			// The opening block is per-reader for the same reason a round's
+			// narration is: "You: 40/40 HP" has to be the reader's own pool.
+			p.announcePartyFightStart(sess, players, enemy, b.String(), opening, outcomes)
+		}
+		// A member the roster left behind is owed an answer of their own: nothing
+		// above was addressed to them, because they are not seated.
+		if senderSkip != "" {
+			return p.replyDM(ctx, senderSkip)
+		}
+		return nil
+	}
+
+	// One seat. Usually that is a solo player fighting their own fight, and this
+	// is the block they have always been sent. It can also be a leader whose only
+	// companion was left behind — in which case the block is the leader's and the
+	// sender is owed the reason they are not in it.
+	owner := id.UserID(sess.UserID)
+	b.WriteString(fmt.Sprintf("You: **%d/%d HP**.\n", sess.PlayerHP, sess.PlayerHPMax))
+	if curios := activeMagicItemsLine(owner); curios != "" {
 		b.WriteString(curios)
 		b.WriteString("\n")
 	}
 	b.WriteString("\n")
 	b.WriteString(combatTurnPrompt(sess))
-	return p.SendDM(ctx.Sender, b.String())
+	if senderSkip != "" {
+		if !ctx.Silent {
+			if err := p.SendDM(owner, b.String()); err != nil {
+				slog.Error("combat: fight-start DM to leader failed", "user", owner, "err", err)
+			}
+		}
+		return p.replyDM(ctx, senderSkip)
+	}
+	return p.replyDM(ctx, b.String())
 }
 
 // ── !attack / !flee ─────────────────────────────────────────────────────────
@@ -133,29 +194,43 @@ func (p *AdventurePlugin) handleFleeCmd(ctx MessageContext) error {
 	return p.handleCombatActionCmd(ctx, PlayerAction{Kind: ActionFlee})
 }
 
+const noFightMsg = "You're not in a fight. `!fight` at an Elite or Boss room to start one."
+
 func (p *AdventurePlugin) handleCombatActionCmd(ctx MessageContext, action PlayerAction) error {
-	userMu := p.advUserLock(ctx.Sender)
-	userMu.Lock()
-	defer userMu.Unlock()
-
-	sess, err := getActiveCombatSession(ctx.Sender)
-	if err != nil {
-		return p.SendDM(ctx.Sender, "Couldn't read combat state: "+err.Error())
+	ct, release, msg := p.beginCombatTurn(ctx.Sender, noFightMsg)
+	if ct == nil {
+		return p.replyDM(ctx, msg)
 	}
-	if sess == nil {
-		return p.SendDM(ctx.Sender, "You're not in a fight. `!fight` at an Elite or Boss room to start one.")
+	defer release()
+
+	// Fleeing ends the run for the whole party, so it is the leader's call —
+	// the same reasoning that makes `!extract` leader-only.
+	if action.Kind == ActionFlee && ct.isParty() && ct.seat != 0 {
+		return p.replyDM(ctx, "Only your party leader can break off a fight.")
 	}
 
-	player, enemy, err := p.combatantsForSession(sess)
+	events, err := p.driveCombatRound(ct, action)
 	if err != nil {
-		return p.SendDM(ctx.Sender, "Couldn't rebuild the fight: "+err.Error())
+		return p.replyDM(ctx, "Couldn't resolve the round: "+err.Error())
 	}
+	return p.replyCombatRound(ctx, ct, events)
+}
 
-	events, err := runCombatRound(sess, &player, &enemy, action)
-	if err != nil {
-		return p.SendDM(ctx.Sender, "Couldn't resolve the round: "+err.Error())
+// replyCombatRound narrates a resolved round. A solo fight answers the one
+// player who typed, exactly as it always has. A party fight fans out: every
+// member gets the play-by-play with the right names on it, and their own footer
+// or close-out. Terminal side effects run either way — a silent autopilot round
+// still owes the party its XP and loot.
+func (p *AdventurePlugin) replyCombatRound(ctx MessageContext, ct *combatTurn, events []CombatEvent) error {
+	if !ct.isParty() {
+		return p.replyDM(ctx, p.renderRoundResult(ctx.Sender, ct.sess, events, ct.players[0].Name, *ct.enemy))
 	}
-	return p.SendDM(ctx.Sender, p.renderRoundResult(ctx.Sender, sess, events, player.Name, enemy))
+	outcomes := p.closePartyRound(ct)
+	if ctx.Silent {
+		return nil
+	}
+	p.announcePartyRound(ct, events, "", outcomes)
+	return nil
 }
 
 // renderRoundResult turns a resolved round into the player-facing block: the
@@ -176,24 +251,64 @@ func (p *AdventurePlugin) renderRoundResult(userID id.UserID, sess *CombatSessio
 	return b.String()
 }
 
-// runCombatRound resolves one full round: the player's chosen action, then the
-// enemy turn and the round-end status tick, advancing the session until it is
-// back at a player_turn or has reached a terminal status. Returns every event
-// the round produced. Each advanceCombatSession call persists the session, so
+// runCombatRound resolves one full round of a solo fight: the player's chosen
+// action, then the enemy turn and the round-end status tick, advancing the
+// session until it is back at a player_turn or has reached a terminal status.
+// Returns every event the round produced. Each advance persists the session, so
 // a crash mid-round resumes cleanly from the last phase.
 func runCombatRound(sess *CombatSession, player, enemy *Combatant, action PlayerAction) ([]CombatEvent, error) {
-	events, err := advanceCombatSession(sess, player, enemy, action)
+	return runPartyCombatRound(sess, []*Combatant{player}, enemy, action)
+}
+
+// partyRoundStepCap bounds the drain loop below. A round is at most one step per
+// seat plus the enemy turn and the round-end tick, so a 3-player party settles
+// in 5; the cap only turns a hypothetical non-advancing phase into a loud error
+// instead of a hung goroutine holding the fight's lock.
+const partyRoundStepCap = 64
+
+// runPartyCombatRound resolves the acting seat's action and then drains every
+// phase after it that needs no human: the enemy turn, the round-end status tick,
+// and any seat that is down (which forfeits its turn silently). It comes to rest
+// on a standing player's turn, or on a terminal status.
+//
+// A latched-onto-autopilot seat is *not* drained here — resolving its turn means
+// running the picker, which needs the plugin to reach the character's spells and
+// inventory. driveCombatRound layers that on top.
+//
+// For a solo roster this is exactly the old loop: a solo player_turn always
+// belongs to a standing player, since a downed one has already ended the fight.
+func runPartyCombatRound(sess *CombatSession, players []*Combatant, enemy *Combatant, action PlayerAction) ([]CombatEvent, error) {
+	events, err := advancePartyCombatSession(sess, players, enemy, action)
 	if err != nil {
 		return events, err
 	}
-	for sess.IsActive() && sess.Phase != CombatPhasePlayerTurn {
-		more, merr := advanceCombatSession(sess, player, enemy, PlayerAction{})
+	more, err := settleCombatSession(sess, players, enemy)
+	return append(events, more...), err
+}
+
+// settleCombatSession drains every phase the engine can resolve without a human:
+// the enemy turn, the round-end status tick, and any seat that is down. It comes
+// to rest on a standing player's turn, or on a terminal status.
+//
+// It is a no-op on a session already parked on a standing player's turn, which
+// is where every solo fight sits between commands.
+func settleCombatSession(sess *CombatSession, players []*Combatant, enemy *Combatant) ([]CombatEvent, error) {
+	var events []CombatEvent
+	for i := 0; i < partyRoundStepCap; i++ {
+		if !sess.IsActive() {
+			return events, nil
+		}
+		if seat, waiting := actingSeat(sess, players, enemy); waiting && sess.seatAlive(seat) {
+			return events, nil
+		}
+		more, merr := advancePartyCombatSession(sess, players, enemy, PlayerAction{})
 		if merr != nil {
 			return events, merr
 		}
 		events = append(events, more...)
 	}
-	return events, nil
+	return events, fmt.Errorf("combat session %s: round did not settle within %d steps",
+		sess.SessionID, partyRoundStepCap)
 }
 
 // combatTurnPrompt is the "your move" footer shown after every non-terminal
@@ -204,12 +319,32 @@ func combatTurnPrompt(sess *CombatSession) string {
 
 // ── close-out ───────────────────────────────────────────────────────────────
 
+// continueHint returns the verb the player uses to keep moving after a
+// manual Elite/Boss fight, phrased for their current mode. On an
+// expedition the autopilot drives the walk, so `!zone advance` is the
+// wrong surface — point them at `!expedition run` instead. Standalone
+// zone runs still advance with `!zone advance`.
+func continueHint(userID id.UserID) string {
+	exp, isLeader, err := activeExpeditionFor(userID)
+	switch {
+	case err != nil || exp == nil:
+		return "`!zone advance` to move on."
+	case !isLeader:
+		return "Your leader marches the party on."
+	}
+	return "`!expedition run` to keep going."
+}
+
 // finishCombatSession runs the post-fight side effects once a CombatSession
 // has reached a terminal status, and returns the player-facing outcome block.
 // The graph is NOT advanced here: the terminal session row is the record that
 // the room's manual combat is done, and a fresh !zone advance clears the room.
 func (p *AdventurePlugin) finishCombatSession(userID id.UserID, sess *CombatSession, enemy Combatant) string {
 	persistDnDHPAfterCombat(userID, sess.PlayerHP)
+	// Achievements and post-combat subclass state are owed on every terminal
+	// status, not just a win — a Berserker who rages and loses still comes out
+	// of it exhausted. The auto-resolve close-outs have always done this.
+	p.postCombatBookkeepingForSeat(sess, 0)
 
 	run, _ := getZoneRun(sess.RunID)
 	var zone ZoneDefinition
@@ -228,26 +363,12 @@ func (p *AdventurePlugin) finishCombatSession(userID id.UserID, sess *CombatSess
 	var b strings.Builder
 	switch sess.Status {
 	case CombatStatusWon:
-		recordZoneKillForUser(userID, sess.EnemyID)
-		applyRoomCombatThreatForUser(userID, elite)
-		// zoneCombatXP only reads PlayerWon + NearDeath off the result.
-		nearDeath := sess.PlayerHPMax > 0 && sess.PlayerHP*5 < sess.PlayerHPMax
 		tier := 1
 		if run != nil {
 			tier = int(zone.Tier)
 		}
-		if xp := zoneCombatXP(CombatResult{PlayerWon: true, NearDeath: nearDeath}, monster.CR, tier); xp > 0 {
-			if _, err := p.grantDnDXP(userID, xp); err != nil {
-				slog.Error("combat: grantDnDXP turn-based", "user", userID, "err", err)
-			}
-		}
-		if !elite {
-			// §8.1 — zone boss defeat drops expedition threat. Silent no-op
-			// for standalone zone runs (no active expedition).
-			if exp, eerr := getActiveExpedition(userID); eerr == nil && exp != nil {
-				_ = applyBossDefeatThreat(exp.ID)
-			}
-		}
+		bossOnExpedition := p.applyOwnerWinEffects(userID, sess.EnemyID, elite)
+		p.grantSeatWinXP(userID, sess.PlayerHP, sess.PlayerHPMax, monster, tier)
 		if line := twinBeeLine(zone.ID, DMCombatEnd, sess.RunID, cadence); line != "" {
 			b.WriteString(line + "\n")
 		}
@@ -257,17 +378,24 @@ func (p *AdventurePlugin) finishCombatSession(userID id.UserID, sess *CombatSess
 		}
 		b.WriteString(fmt.Sprintf("%s **%s** down. You finished at **%d/%d HP**.\n",
 			emoji, enemy.Name, sess.PlayerHP, sess.PlayerHPMax))
-		if drop := p.dropZoneLoot(userID, zone.ID, monster, !elite); drop != "" {
+		if drop := p.dropZoneLoot(userID, zone.ID, monster, !elite, elite); drop != "" {
 			b.WriteString(drop + "\n")
 		}
-		b.WriteString("`!zone advance` to move on.")
+		if !elite {
+			writeBossEpilogue(&b, zone.ID)
+		}
+		if bossOnExpedition {
+			// The boss is the expedition's climax. Frame the close-out as
+			// the win rather than a "keep walking" nudge. One more
+			// `!expedition run` walks out the cleared room and triggers
+			// finalizeExpeditionOnZoneClear (rewards + status flip).
+			b.WriteString("🎉 **Zone cleared — the expedition is won.** `!expedition run` to march out and claim your spoils.")
+		} else {
+			b.WriteString(continueHint(userID))
+		}
 
 	case CombatStatusLost:
-		if run != nil {
-			_, _ = applyMoodEvent(sess.RunID, MoodEventPlayerDeath)
-		}
-		_ = abandonZoneRun(userID)
-		forceExtractExpeditionForRunLoss(userID, "combat death")
+		endRunOnLoss(userID, sess.RunID, true)
 		markAdventureDead(userID, "zone", zone.Display)
 		if line := twinBeeLine(zone.ID, DMPlayerDeath, sess.RunID, cadence); line != "" {
 			b.WriteString(line + "\n")
@@ -278,8 +406,7 @@ func (p *AdventurePlugin) finishCombatSession(userID id.UserID, sess *CombatSess
 		// Flee = run ends, light penalty: wounds persist (HP already saved),
 		// but no death timer. Chosen candidate from the migration plan's
 		// open question on flee outcome.
-		_ = abandonZoneRun(userID)
-		forceExtractExpeditionForRunLoss(userID, "combat flee")
+		endRunOnLoss(userID, sess.RunID, false)
 		b.WriteString(fmt.Sprintf("🏃 You broke off from **%s** and slipped away. Run ended — you keep your wounds, but you live.", enemy.Name))
 
 	default:
@@ -367,65 +494,87 @@ func parseCombatCast(userID id.UserID, c *DnDCharacter, args string) (SpellDefin
 }
 
 func (p *AdventurePlugin) handleCombatCastCmd(ctx MessageContext, args string) error {
-	userMu := p.advUserLock(ctx.Sender)
-	userMu.Lock()
-	defer userMu.Unlock()
+	// "not in a fight anymore" — this handler is only routed to when the caller
+	// already saw an active session, so a miss here means it closed under them.
+	ct, release, msg := p.beginCombatTurn(ctx.Sender, "You're not in a fight anymore.")
+	if ct == nil {
+		return p.replyDM(ctx, msg)
+	}
+	defer release()
 
-	sess, err := getActiveCombatSession(ctx.Sender)
+	action, settle, errMsg := p.castActionForSeat(ct, ct.seat, args)
+	if errMsg != "" {
+		return p.replyDM(ctx, errMsg)
+	}
+	events, err := p.driveCombatRound(ct, action)
+	settle(err == nil)
 	if err != nil {
-		return p.SendDM(ctx.Sender, "Couldn't read combat state: "+err.Error())
-	}
-	if sess == nil {
-		// Race: the fight closed between the route check and the lock.
-		return p.SendDM(ctx.Sender, "You're not in a fight anymore.")
+		return p.replyDM(ctx, "Couldn't resolve the round: "+err.Error())
 	}
+	return p.replyCombatRound(ctx, ct, events)
+}
 
-	advChar, _ := loadAdvCharacter(ctx.Sender)
-	c, err := p.ensureCharForDnDCmd(ctx.Sender, advChar)
+// castActionForSeat resolves a `!cast` for one seat into a PlayerAction, having
+// already spent the slot and any material component. It is shared by the command
+// handler and by the autopilot that plays an absent member's turn, so both spend
+// resources through exactly one code path.
+//
+// The returned settle(ok) must be called once the round has been attempted: on
+// failure it refunds the slot. On refusal (non-empty msg) nothing was spent.
+//
+// A buff spell folds its delta into *this seat's* persisted statuses and rebuilds
+// the roster so the buff is live for the round's enemy turn. Before P5 that
+// delta went to the session's embedded copy — seat 0 — so a party member
+// buffing themselves would have buffed the leader.
+func (p *AdventurePlugin) castActionForSeat(ct *combatTurn, seat int, args string) (PlayerAction, func(bool), string) {
+	noop := func(bool) {}
+	uid := id.UserID(ct.sess.seatUserID(seat))
+
+	advChar, _ := loadAdvCharacter(uid)
+	c, err := p.ensureCharForDnDCmd(uid, advChar)
 	if err != nil || c == nil {
-		return p.SendDM(ctx.Sender, "Couldn't load your Adv 2.0 sheet.")
+		return PlayerAction{}, noop, "Couldn't load your Adv 2.0 sheet."
 	}
 	if !isSpellcaster(c) {
-		return p.SendDM(ctx.Sender, fmt.Sprintf(
-			"%s isn't a caster class. `!attack` or `!consume <item>` instead.", titleClass(c.Class)))
+		return PlayerAction{}, noop, fmt.Sprintf(
+			"%s isn't a caster class. `!attack` or `!consume <item>` instead.", titleClass(c.Class))
 	}
 
-	spell, slotLevel, errMsg := parseCombatCast(ctx.Sender, c, strings.TrimSpace(args))
+	spell, slotLevel, errMsg := parseCombatCast(uid, c, strings.TrimSpace(args))
 	if errMsg != "" {
-		return p.SendDM(ctx.Sender, errMsg)
+		return PlayerAction{}, noop, errMsg
 	}
 	if spell.Effect == EffectReaction {
-		return p.SendDM(ctx.Sender, fmt.Sprintf(
-			"%s is a reaction spell — those still aren't usable. Pick a damage, healing, or control spell.", spell.Name))
+		return PlayerAction{}, noop, fmt.Sprintf(
+			"%s is a reaction spell — those still aren't usable. Pick a damage, healing, or control spell.", spell.Name)
 	}
 
-	player, enemy, err := p.combatantsForSession(sess)
-	if err != nil {
-		return p.SendDM(ctx.Sender, "Couldn't rebuild the fight: "+err.Error())
+	refund := func(ok bool) {
+		if !ok && spell.Level > 0 {
+			_ = refundSpellSlot(uid, slotLevel)
+		}
 	}
 
 	var eff *turnActionEffect
 	if spell.Effect == EffectBuffSelf || spell.Effect == EffectBuffAlly {
 		// Buff path — resolve the buff against a throwaway combatant, fold the
-		// marginal effect into the session's persisted state, then rebuild the
-		// pair so the buff is live for this round's enemy turn.
+		// marginal effect into that seat's persisted state, then rebuild the
+		// roster so the buff is live for this round's enemy turn.
+		player := ct.players[seat]
 		as, am := player.Stats, player.Mods
 		applySpellBuff(spell, c, &as, &am, slotLevel)
 		d := diffTurnBuff(player.Stats, as, player.Mods, am)
 		if !d.any() {
-			return p.SendDM(ctx.Sender, fmt.Sprintf(
-				"%s has no effect the turn-based engine can apply yet.", spell.Name))
+			return PlayerAction{}, noop, fmt.Sprintf(
+				"%s has no effect the turn-based engine can apply yet.", spell.Name)
 		}
-		if msg := p.chargeSpellCost(ctx.Sender, spell, slotLevel); msg != "" {
-			return p.SendDM(ctx.Sender, msg)
+		if msg := p.chargeSpellCost(uid, spell, slotLevel); msg != "" {
+			return PlayerAction{}, noop, msg
 		}
-		sess.Statuses.applyBuffDelta(d)
-		player, enemy, err = p.combatantsForSession(sess)
-		if err != nil {
-			if spell.Level > 0 {
-				_ = refundSpellSlot(ctx.Sender, slotLevel)
-			}
-			return p.SendDM(ctx.Sender, "Couldn't rebuild the fight: "+err.Error())
+		ct.sess.actorStatusesPtr(seat).applyBuffDelta(d)
+		if rerr := p.rebuildRoster(ct); rerr != nil {
+			refund(false)
+			return PlayerAction{}, noop, "Couldn't rebuild the fight: " + rerr.Error()
 		}
 		label := spell.Name + " — active"
 		if d.heal > 0 {
@@ -436,13 +585,25 @@ func (p *AdventurePlugin) handleCombatCastCmd(ctx MessageContext, args string) e
 			PlayerHeal: d.heal, EnemySkip: d.enemySkip,
 		}
 	} else {
-		out, supported := resolveTurnSpell(c, spell, slotLevel, &enemy.Stats)
+		out, supported := resolveTurnSpell(c, spell, slotLevel, &ct.enemy.Stats)
 		if !supported {
-			return p.SendDM(ctx.Sender, fmt.Sprintf(
-				"%s is a utility spell — those aren't usable in turn-based fights yet. Try a damage, healing, control, or buff spell.", spell.Name))
+			return PlayerAction{}, noop, fmt.Sprintf(
+				"%s is a utility spell — those aren't usable in turn-based fights yet. Try a damage, healing, control, or buff spell.", spell.Name)
 		}
-		if msg := p.chargeSpellCost(ctx.Sender, spell, slotLevel); msg != "" {
-			return p.SendDM(ctx.Sender, msg)
+		if msg := p.chargeSpellCost(uid, spell, slotLevel); msg != "" {
+			return PlayerAction{}, noop, msg
+		}
+		// Park the Necromancy kill-heal stash on the casting seat. The
+		// auto-resolve path keeps it on the fight-start CombatModifiers, which
+		// a turn-based fight has nowhere to hold — it rebuilds its combatants
+		// every round. Only a damaging cast stashes (a miss leaves the slot at
+		// 0), and each one overwrites the last, so the stash always describes
+		// the seat's most recent landed spell — which is the only one that can
+		// have been lethal by the time the close-out reads it.
+		if out.GrimHarvestSlot > 0 {
+			as := ct.sess.actorStatusesPtr(seat)
+			as.GrimHarvestSlot = out.GrimHarvestSlot
+			as.GrimHarvestNecrotic = out.GrimHarvestNecrotic
 		}
 		eff = &turnActionEffect{
 			Label:       out.Desc,
@@ -451,16 +612,27 @@ func (p *AdventurePlugin) handleCombatCastCmd(ctx MessageContext, args string) e
 			PlayerHeal:  out.PlayerHeal,
 			EnemySkip:   out.EnemySkip,
 		}
-	}
-
-	events, err := runCombatRound(sess, &player, &enemy, PlayerAction{Kind: ActionCast, Effect: eff})
-	if err != nil {
-		if spell.Level > 0 {
-			_ = refundSpellSlot(ctx.Sender, slotLevel)
+		// Concentration AOE damage spells linger: the burst lands this round
+		// (EnemyDamage) and the same value re-ticks every round_end after, via
+		// the engine's concentration aura. spiritual_weapon already covers the
+		// cleric's bonus-action half of the combo; this restores the action half.
+		if spell.Concentration &&
+			(spell.Effect == EffectDamageAuto || spell.Effect == EffectDamageSave) {
+			eff.ConcentrationDmg = out.EnemyDamage
 		}
-		return p.SendDM(ctx.Sender, "Couldn't resolve the round: "+err.Error())
 	}
-	return p.SendDM(ctx.Sender, p.renderRoundResult(ctx.Sender, sess, events, player.Name, enemy))
+	return PlayerAction{Kind: ActionCast, Effect: eff}, refund, ""
+}
+
+// rebuildRoster re-derives the seated combatants after a mid-fight buff changed
+// a seat's persisted statuses, so the buff is live for the rest of the round.
+func (p *AdventurePlugin) rebuildRoster(ct *combatTurn) error {
+	players, enemy, err := p.partyCombatantsForSession(ct.sess)
+	if err != nil {
+		return err
+	}
+	ct.players, ct.enemy = players, enemy
+	return nil
 }
 
 // chargeSpellCost debits a spell's material component and leveled slot for a
@@ -525,45 +697,70 @@ func matchConsumable(inv []ConsumableItem, query string) (*ConsumableItem, strin
 }
 
 func (p *AdventurePlugin) handleConsumeCmd(ctx MessageContext, args string) error {
-	userMu := p.advUserLock(ctx.Sender)
-	userMu.Lock()
-	defer userMu.Unlock()
+	const notFighting = "`!consume <item>` spends an item on your turn in an Elite or Boss fight. You're not in one — outside combat, consumables fire automatically."
 
-	sess, err := getActiveCombatSession(ctx.Sender)
-	if err != nil {
-		return p.SendDM(ctx.Sender, "Couldn't read combat state: "+err.Error())
-	}
-	if sess == nil {
-		return p.SendDM(ctx.Sender, "`!consume <item>` spends an item on your turn in an Elite or Boss fight. You're not in one — outside combat, consumables fire automatically.")
-	}
-
-	inv := p.loadConsumableInventory(ctx.Sender)
 	args = strings.TrimSpace(args)
 	if args == "" {
+		// Listing the pack reads no turn state, so it neither takes the fight's
+		// lock nor settles a phase — a player peeking at their options between
+		// rounds must not advance the fight.
+		probe, err := activeCombatSessionFor(ctx.Sender)
+		if err != nil {
+			return p.replyDM(ctx, "Couldn't read combat state: "+err.Error())
+		}
+		if probe == nil {
+			return p.replyDM(ctx, notFighting)
+		}
+		inv := p.loadConsumableInventory(ctx.Sender)
 		if len(inv) == 0 {
-			return p.SendDM(ctx.Sender, "You have no combat consumables. `!attack` / `!cast` / `!flee`.")
+			return p.replyDM(ctx, "You have no combat consumables. `!attack` / `!cast` / `!flee`.")
 		}
 		names := make([]string, len(inv))
 		for i, c := range inv {
 			names[i] = c.Def.Name
 		}
-		return p.SendDM(ctx.Sender, "Usage: `!consume <item>`. You're carrying: "+strings.Join(names, ", ")+".")
+		return p.replyDM(ctx, "Usage: `!consume <item>`. You're carrying: "+strings.Join(names, ", ")+".")
 	}
 
+	ct, release, msg := p.beginCombatTurn(ctx.Sender, notFighting)
+	if ct == nil {
+		return p.replyDM(ctx, msg)
+	}
+	defer release()
+
+	action, settle, errMsg := p.consumeActionForSeat(ct, ct.seat, args)
+	if errMsg != "" {
+		return p.replyDM(ctx, errMsg)
+	}
+	events, err := p.driveCombatRound(ct, action)
+	settle(err == nil)
+	if err != nil {
+		return p.replyDM(ctx, "Couldn't resolve the round: "+err.Error())
+	}
+	return p.replyCombatRound(ctx, ct, events)
+}
+
+// consumeActionForSeat resolves a `!consume` for one seat into a PlayerAction.
+// Shared by the command handler and by the autopilot that plays an absent
+// member's turn.
+//
+// The returned settle(ok) burns the item only once the round has resolved: a
+// removal failure leaves the player a free use (logged, rare), which beats
+// charging them for a round that errored out.
+func (p *AdventurePlugin) consumeActionForSeat(ct *combatTurn, seat int, args string) (PlayerAction, func(bool), string) {
+	noop := func(bool) {}
+	uid := id.UserID(ct.sess.seatUserID(seat))
+
+	inv := p.loadConsumableInventory(uid)
 	item, ambig := matchConsumable(inv, args)
 	if ambig != "" {
-		return p.SendDM(ctx.Sender, ambig)
+		return PlayerAction{}, noop, ambig
 	}
 	if item == nil {
-		return p.SendDM(ctx.Sender, fmt.Sprintf("No consumable matching %q in your inventory.", args))
+		return PlayerAction{}, noop, fmt.Sprintf("No consumable matching %q in your inventory.", args)
 	}
 
 	def := item.Def
-	player, enemy, err := p.combatantsForSession(sess)
-	if err != nil {
-		return p.SendDM(ctx.Sender, "Couldn't rebuild the fight: "+err.Error())
-	}
-
 	eff := &turnActionEffect{Action: "use_consumable"}
 	switch def.Effect {
 	case EffectHeal:
@@ -574,34 +771,32 @@ func (p *AdventurePlugin) handleConsumeCmd(ctx MessageContext, args string) erro
 		eff.Label = fmt.Sprintf("%s — %d damage", def.Name, eff.EnemyDamage)
 	default:
 		// Buff-type consumable — resolve the marginal effect against a
-		// throwaway combatant, fold it into the session's persisted state, and
-		// rebuild the pair so the buff is live for this round's enemy turn.
+		// throwaway combatant, fold it into that seat's persisted state, and
+		// rebuild the roster so the buff is live for this round's enemy turn.
+		player := ct.players[seat]
 		as, am := player.Stats, player.Mods
 		ApplyConsumableMods(&as, &am, []ConsumableItem{{Def: def}})
 		d := diffTurnBuff(player.Stats, as, player.Mods, am)
 		if !d.any() {
-			return p.SendDM(ctx.Sender, fmt.Sprintf(
-				"**%s** has no effect the turn-based engine can apply yet.", def.Name))
+			return PlayerAction{}, noop, fmt.Sprintf(
+				"**%s** has no effect the turn-based engine can apply yet.", def.Name)
 		}
-		sess.Statuses.applyBuffDelta(d)
-		player, enemy, err = p.combatantsForSession(sess)
-		if err != nil {
-			return p.SendDM(ctx.Sender, "Couldn't rebuild the fight: "+err.Error())
+		ct.sess.actorStatusesPtr(seat).applyBuffDelta(d)
+		if rerr := p.rebuildRoster(ct); rerr != nil {
+			return PlayerAction{}, noop, "Couldn't rebuild the fight: " + rerr.Error()
 		}
 		eff.Label = def.Name + " — active"
 		eff.PlayerHeal = d.heal
 		eff.EnemySkip = d.enemySkip
 	}
 
-	events, err := runCombatRound(sess, &player, &enemy, PlayerAction{Kind: ActionConsume, Effect: eff})
-	if err != nil {
-		return p.SendDM(ctx.Sender, "Couldn't resolve the round: "+err.Error())
+	burn := func(ok bool) {
+		if !ok {
+			return
+		}
+		if rerr := removeAdvInventoryItem(item.InventoryID); rerr != nil {
+			slog.Error("combat: consume remove inventory item failed", "user", uid, "item", def.Name, "err", rerr)
+		}
 	}
-	// Round resolved and persisted — now burn the item. A removal failure here
-	// leaves the player a free use (logged, rare); better than charging them
-	// for a round that errored out.
-	if rerr := removeAdvInventoryItem(item.InventoryID); rerr != nil {
-		slog.Error("combat: consume remove inventory item failed", "user", ctx.Sender, "item", def.Name, "err", rerr)
-	}
-	return p.SendDM(ctx.Sender, p.renderRoundResult(ctx.Sender, sess, events, player.Name, enemy))
+	return PlayerAction{Kind: ActionConsume, Effect: eff}, burn, ""
 }

internal/plugin/combat_engine.go

@@ -46,13 +46,18 @@ type CombatStats struct {
 }
 
 type CombatModifiers struct {
-	DamageBonus      float64 // additive: 0 = neutral, 0.25 = +25% damage. Applied as (1 + DamageBonus).
-	DamageReduct     float64 // multiplicative damage-taken reduction, 1.0 = neutral
-	DeathSave        bool    // Sovereign reprieve — survive one lethal hit
-	PetAttackProc    float64
-	PetAttackDmg     int
-	PetDeflectProc   float64
-	PetWhiffProc     float64 // pet distracts enemy → guaranteed miss
+	DamageBonus    float64 // additive: 0 = neutral, 0.25 = +25% damage. Applied as (1 + DamageBonus).
+	DamageReduct   float64 // multiplicative damage-taken reduction, 1.0 = neutral
+	DeathSave      bool    // Sovereign reprieve — survive one lethal hit
+	PetAttackProc  float64
+	PetAttackDmg   int
+	PetDeflectProc float64
+	PetWhiffProc   float64 // pet distracts enemy → guaranteed miss
+	// Spiritual Weapon — separate channel from the pet so the spectral mace
+	// gets its own narration when a cleric without a companion casts it.
+	// Damage formula mirrors PetAttack (Dmg + d5), proc rolls per round.
+	SpiritWeaponProc float64
+	SpiritWeaponDmg  int
 	SniperKillProc   float64 // Arina instant-kill
 	MistyHealProc    float64
 	MistyHealAmt     int
@@ -157,9 +162,11 @@ type CombatModifiers struct {
 	// ArcaneWardHP: flat HP buffer absorbed before player HP. Refilled at the
 	// start of each combat by Abjuration L5+ (2× Mage level, +prof at L7).
 	// Persists across rounds within a single combat; not refunded between fights.
-	// GrimHarvestSlot/Necrotic: snapshot of the queued spell stashed by
-	// applyPendingCast for the post-combat Grim Harvest hook (Necromancy L5+).
-	// Heal fires only if the spell event is what dropped the enemy to 0.
+	// GrimHarvestSlot/Necrotic: snapshot of the damaging spell stashed for the
+	// post-combat Grim Harvest hook (Necromancy L5+) — by applyPendingCast on
+	// the auto-resolve path, and by seatFightStartMods reading the seat's
+	// statuses on the turn-based one. Heal fires only if that spell's event is
+	// what dropped the enemy to 0.
 	ArcaneWardHP        int
 	GrimHarvestSlot     int
 	GrimHarvestNecrotic bool
@@ -206,6 +213,15 @@ type CombatEvent struct {
 	// Roll is the raw d20 (1..20); RollAgainst is the target AC.
 	Roll        int
 	RollAgainst int
+	// Seat is the roster index of the character this event is about: the one
+	// who swung, whose pet struck, who the enemy hit, whose poison ticked. The
+	// turn engine stamps it (turnEngine.stampSeat); the auto-resolve engine
+	// leaves it 0, which is correct for its one and only combatant.
+	//
+	// It exists so a party's play-by-play can name the right person. Solo events
+	// are all seat 0, and the omitempty tag keeps the field out of every solo
+	// turn_log_json — rows written before N3/P5 decode unchanged.
+	Seat int `json:"Seat,omitempty"`
 }
 
 type CombatResult struct {
@@ -287,10 +303,28 @@ var bossCombatPhases = []CombatPhase{
 
 // ── Simulation ───────────────────────────────────────────────────────────────
 
-// combatState tracks mutable state during the simulation.
-type combatState struct {
+// actor is the per-combatant half of the simulation state — everything that
+// belongs to one player character rather than to the fight as a whole.
+//
+// It is embedded into combatState as a *pointer*, which promotes its fields:
+// `st.playerHP` still resolves, now to `st.actor.playerHP`. The embedded
+// pointer is a cursor naming whoever is currently resolving. Solo combat has a
+// one-element roster and never moves the cursor, so every read and every RNG
+// draw is bit-identical to the pre-roster engine — which is what keeps the
+// solo balance corpus (sim_results/d8prereq_corpus.jsonl lineage) valid.
+//
+// Field names are deliberately unchanged from when they lived on combatState.
+type actor struct {
+	// c is the Combatant this state belongs to. Nil only in tests that drive
+	// a primitive directly without a roster.
+	c *Combatant
+
 	playerHP int
-	enemyHP  int
+	// hpMax is this actor's HP ceiling for in-fight healing. It tracks
+	// c.Stats.MaxHP except in the turn-based engine, where seat 0 restores the
+	// session's persisted player_hp_max — that snapshot comes from
+	// dndHPSnapshot and can differ from the rebuilt combatant's MaxHP.
+	hpMax int
 
 	// Consumable one-shots
 	healChargesLeft int // remaining heal-at-<50% triggers
@@ -299,13 +333,10 @@ type combatState struct {
 	reflectFrac     float64
 	autoCrit        bool
 
-	// Monster ability effects
-	poisonTicks   int
-	poisonDmg     int
-	stunPlayer    bool
-	enraged       bool
-	armorBroken   bool
-	armorBreakAmt float64
+	// Monster ability effects landing on this actor
+	poisonTicks int
+	poisonDmg   int
+	stunPlayer  bool
 
 	// Sovereign reprieve
 	deathSaveUsed bool
@@ -315,14 +346,6 @@ type combatState struct {
 	raged             bool // Orc Rage already triggered this fight
 	pendingRageAttack bool // next player attack gets +50% damage
 
-	// Phase 9 spell — enemy skip-first-attack (consumed on the first round
-	// the enemy would otherwise attack).
-	enemySkipFirst bool
-
-	// Phase 13 turn-based — pet attack decided once at fight start; the pet
-	// strikes once on the player's first acting turn, which clears this.
-	petProcReady bool
-
 	// Phase 10 SUB2a-ii first-attack one-shots.
 	firstAttackBonusUsed  bool
 	assassinateRerollUsed bool
@@ -331,19 +354,56 @@ type combatState struct {
 	// Phase 10 SUB2b — Abjuration Arcane Ward HP buffer.
 	arcaneWardHP int
 
+	// Debuffs the enemy has stacked onto this actor specifically.
+	playerAtkDrain int // stat_drain: flat reduction to this actor's hit damage
+	playerACDebuff int // debuff: flat reduction to this actor's effective AC
+	maxHPDrain     int // max_hp_drain: reduction to this actor's effective MaxHP
+
+	// concentrationDmg — per-round damage of an active concentration AOE
+	// (Spirit Guardians et al.). Concentration is per-caster, so it lives
+	// here rather than on the fight.
+	concentrationDmg int
+}
+
+// combatState tracks mutable state during the simulation. The embedded *actor
+// is the cursor: the player character currently resolving. Everything declared
+// directly on combatState is shared by the whole fight — the enemy, the round
+// counter, the event log, and the RNG stream.
+type combatState struct {
+	*actor          // cursor into actors; promotes the per-actor fields
+	actors []*actor // the player roster, in seating order. len == 1 for solo.
+	// seatIdx is the roster index the cursor points at. Kept in step with the
+	// embedded *actor by seat(); read only by the turn engine, to attribute the
+	// events a phase emitted to the character they happened to.
+	seatIdx int
+
+	enemyHP int
+
+	// Monster ability effects (enemy-side stance — shared across the roster)
+	enraged       bool
+	armorBroken   bool
+	armorBreakAmt float64
+
+	// Phase 9 spell — enemy skip-first-attack (consumed on the first round
+	// the enemy would otherwise attack). Holding the enemy holds it for
+	// everyone, so this is fight-scoped, not per-caster.
+	enemySkipFirst bool
+
 	// Phase 13 bestiary slice 3 — stateful monster-ability effects. Each is
 	// armed by applyAbility and read by the shared resolution primitives, so
 	// both engines honour them; the turn-based engine additionally round-trips
 	// them through CombatStatuses so they survive a suspend/resume.
+	//
+	// These describe the *enemy's* stance, so they are fight-scoped: an enemy
+	// holding a parry stance parries the next swing from anyone. The debuffs
+	// it stacks onto a specific character (stat_drain / debuff / max_hp_drain)
+	// live on actor instead.
 	enemyEvadeNext     bool    // evade: next player weapon attack auto-misses
 	enemyBlockUp       bool    // block: enemy holds a parry stance (~50% block on player hits)
 	enemyAdvantage     bool    // advantage: enemy rolls its attacks with advantage
 	enemyRetaliateFrac float64 // retaliate: fraction of a player hit reflected back
 	enemyRegen         int     // regenerate: enemy heals this much each round end
 	enemySurviveArmed  bool    // survive_at_1: enemy cheats death once, dropping to 1 HP
-	playerAtkDrain     int     // stat_drain: flat reduction to the player's hit damage
-	playerACDebuff     int     // debuff: flat reduction to the player's effective AC
-	maxHPDrain         int     // max_hp_drain: reduction to the player's effective MaxHP
 
 	// Phase 13 bestiary slice 4 — the former flavor-only placeholders, now
 	// backed by real state.
@@ -368,6 +428,50 @@ type combatState struct {
 // Auto-resolve leaves st.rng nil — behaviorally identical to the
 // pre-injection code; the turn-based engine and the timeout reaper seed
 // it per session so a fight can be resumed and replayed reproducibly.
+// newActor seats one player character, deriving its opening per-fight state
+// from that character's modifiers.
+func newActor(c *Combatant) *actor {
+	startHP := c.Stats.MaxHP
+	if c.Stats.StartHP > 0 && c.Stats.StartHP < c.Stats.MaxHP {
+		startHP = c.Stats.StartHP
+	}
+	a := &actor{
+		c:            c,
+		playerHP:     startHP,
+		hpMax:        c.Stats.MaxHP,
+		wardCharges:  c.Mods.WardCharges,
+		sporeRounds:  c.Mods.SporeCloud,
+		reflectFrac:  c.Mods.ReflectNext,
+		autoCrit:     c.Mods.AutoCritFirst,
+		arcaneWardHP: c.Mods.ArcaneWardHP,
+	}
+	// HealItemCharges: explicit count overrides legacy one-shot. Backfill
+	// to 1 charge if the caller set a HealItem amount but no count.
+	a.healChargesLeft = c.Mods.HealItemCharges
+	if a.healChargesLeft == 0 && c.Mods.HealItem > 0 {
+		a.healChargesLeft = 1
+	}
+	return a
+}
+
+// seat points the cursor at roster index i. Every per-actor read in the
+// resolution primitives (st.playerHP, st.wardCharges, …) follows the cursor.
+// Solo combat seats index 0 once and never moves it.
+// seat moves the cursor to a roster index. seatIdx trails it so the turn engine
+// can tag the events a phase emits with the character they are about.
+func (st *combatState) seat(i int) { st.actor, st.seatIdx = st.actors[i], i }
+
+// anyAlive reports whether at least one seated character is still standing.
+// Solo fights read this as "the player is alive".
+func (st *combatState) anyAlive() bool {
+	for _, a := range st.actors {
+		if a.playerHP > 0 {
+			return true
+		}
+	}
+	return false
+}
+
 func (st *combatState) roll(n int) int     { return rngIntN(st.rng, n) }
 func (st *combatState) randFloat() float64 { return rngFloat(st.rng) }
 
@@ -380,325 +484,12 @@ func SimulateCombat(player, enemy Combatant, phases []CombatPhase) CombatResult
 // The characterization test and the turn-based engine pass a seeded *rand.Rand
 // so a fight is fully reproducible. Passing nil is behaviorally identical to
 // the pre-injection code.
+//
+// This is the one-seat case of the N-body engine in combat_engine_party.go.
+// Every roster short-circuit in there collapses for a single player, so the
+// draw order — and therefore TestCombatCharacterization — is unchanged.
 func simulateCombatWithRNG(player, enemy Combatant, phases []CombatPhase, rng *rand.Rand) CombatResult {
-	playerStart := player.Stats.MaxHP
-	if player.Stats.StartHP > 0 && player.Stats.StartHP < player.Stats.MaxHP {
-		playerStart = player.Stats.StartHP
-	}
-	enemyStart := enemy.Stats.MaxHP
-	if enemy.Stats.StartHP > 0 && enemy.Stats.StartHP < enemy.Stats.MaxHP {
-		enemyStart = enemy.Stats.StartHP
-	}
-	st := &combatState{
-		playerHP:       playerStart,
-		enemyHP:        enemyStart,
-		wardCharges:    player.Mods.WardCharges,
-		sporeRounds:    player.Mods.SporeCloud,
-		reflectFrac:    player.Mods.ReflectNext,
-		autoCrit:       player.Mods.AutoCritFirst,
-		enemySkipFirst: player.Mods.SpellEnemySkipFirst,
-		arcaneWardHP:   player.Mods.ArcaneWardHP,
-		rng:            rng,
-	}
-	// HealItemCharges: explicit count overrides legacy one-shot. Backfill
-	// to 1 charge if the caller set a HealItem amount but no count.
-	st.healChargesLeft = player.Mods.HealItemCharges
-	if st.healChargesLeft == 0 && player.Mods.HealItem > 0 {
-		st.healChargesLeft = 1
-	}
-
-	result := CombatResult{
-		PlayerStartHP: player.Stats.MaxHP,
-		PlayerEntryHP: playerStart,
-		EnemyStartHP:  enemy.Stats.MaxHP,
-		EnemyEntryHP:  enemyStart,
-	}
-
-	// Pre-combat: Arina sniper check
-	if player.Mods.SniperKillProc > 0 && st.randFloat() < player.Mods.SniperKillProc {
-		st.enemyHP = 0
-		st.events = append(st.events, CombatEvent{
-			Round: 0, Phase: "pre_combat", Actor: "npc", Action: "sniper_kill",
-			Damage: enemy.Stats.MaxHP, PlayerHP: st.playerHP, EnemyHP: 0,
-			Desc: "Arina",
-		})
-		result.SniperKilled = true
-		return finalize(result, st, player, enemy)
-	}
-
-	// Pre-combat: Coal Bomb / flat start damage
-	if player.Mods.FlatDmgStart > 0 {
-		dmg := player.Mods.FlatDmgStart
-		st.enemyHP = max(0, st.enemyHP-dmg)
-		st.events = append(st.events, CombatEvent{
-			Round: 0, Phase: "pre_combat", Actor: "consumable", Action: "flat_damage",
-			Damage: dmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-		})
-		if st.enemyHP <= 0 {
-			return finalize(result, st, player, enemy)
-		}
-	}
-
-	// Pre-combat: queued spell. Resolved by applyPendingCast() before this
-	// runs — the modifiers carry the resolved damage and narrative hook.
-	if player.Mods.SpellPreDamageDesc != "" {
-		dmg := player.Mods.SpellPreDamage
-		resisted := dmg > 0 && enemyResistsSpells(&enemy, st)
-		if resisted {
-			dmg = max(1, dmg/2)
-		}
-		if dmg > 0 {
-			st.enemyHP = max(0, st.enemyHP-dmg)
-		}
-		st.events = append(st.events, CombatEvent{
-			Round: 0, Phase: "pre_combat", Actor: "player", Action: "spell_cast",
-			Damage: dmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-			Desc: player.Mods.SpellPreDamageDesc,
-		})
-		if resisted {
-			st.events = append(st.events, CombatEvent{
-				Round: 0, Phase: "pre_combat", Actor: "enemy", Action: "spell_fizzle",
-				Damage: dmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-			})
-		}
-		if st.enemyHP <= 0 {
-			return finalize(result, st, player, enemy)
-		}
-	}
-
-	// Pre-combat: Misty gourmet is now a per-round heal, no pre-combat damage
-
-	// Main simulation loop
-	for _, phase := range phases {
-		roundsThisPhase := phase.Rounds
-		// Add slight variance: ±1 round for non-Decisive phases
-		if phase.Name != "Decisive" && roundsThisPhase > 1 {
-			roundsThisPhase += st.roll(2) // 0 or +1
-		}
-		for r := 0; r < roundsThisPhase; r++ {
-			st.round++
-			if simulateRound(st, &player, &enemy, &phase, &result) {
-				return finalize(result, st, player, enemy)
-			}
-		}
-	}
-
-	// If we exhaust all phases without a kill, tiebreak by HP percentage
-	// to decide the *outcome* (PlayerWon flag) — but DO NOT zero out HP
-	// on the loser. Timeout = retreat, not lethal blow. Caller treats a
-	// timeout loss as "fight ended, no character death".
-	//
-	// Absolute-HP tiebreak (briefly used on the legacy ~120 HP scale) was
-	// wrong post HP-unification: monster pools (~30–175) are 2-3× player
-	// pools (~13–83), so absolute always favored the larger combatant
-	// even when the player took less proportional damage. Slight bias
-	// toward the player on exact ties (frac >=).
-	result.TimedOut = true
-	playerFrac := float64(st.playerHP) / float64(max(1, player.Stats.MaxHP))
-	enemyFrac := float64(st.enemyHP) / float64(max(1, enemy.Stats.MaxHP))
-	playerWonTiebreak := playerFrac >= enemyFrac
-	st.events = append(st.events, CombatEvent{
-		Round: st.round, Phase: "exhaust", Actor: "system", Action: "timeout",
-		PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-	})
-	out := finalize(result, st, player, enemy)
-	out.PlayerWon = playerWonTiebreak
-	return out
-}
-
-// simulateRound runs one round. Returns true if combat is over.
-func simulateRound(st *combatState, player, enemy *Combatant, phase *CombatPhase, result *CombatResult) bool {
-	phaseName := phase.Name
-
-	// Phase 9 spell: control effect (Hold Person, Sleep, Command) skips the
-	// enemy's attack for one round. Logged as a dedicated event so narrative
-	// can read it as a held/stunned beat rather than a generic miss.
-	enemyHeldThisRound := false
-	if st.enemySkipFirst {
-		st.enemySkipFirst = false
-		if enemyImmuneToControl(enemy, st) {
-			// fear_immune: the control spell can't take hold — the enemy acts
-			// as normal this round.
-			st.events = append(st.events, CombatEvent{
-				Round: st.round, Phase: phaseName, Actor: "enemy", Action: "fear_resist",
-				PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-			})
-		} else {
-			enemyHeldThisRound = true
-			st.events = append(st.events, CombatEvent{
-				Round: st.round, Phase: phaseName, Actor: "enemy", Action: "spell_held",
-				PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-			})
-		}
-	}
-
-	// Monster ability: check at round start
-	abilityDealtDamage := enemyHeldThisRound
-	if enemy.Ability != nil {
-		if abilityFires(enemy.Ability, phaseName, st) {
-			if applyAbility(st, player, enemy, phase, result) {
-				return true
-			}
-			// Cleave and lifesteal deal damage — skip normal enemy attack this round
-			switch enemy.Ability.Effect {
-			case "cleave", "lifesteal":
-				abilityDealtDamage = true
-			}
-		}
-	}
-
-	// Poison tick from previous round
-	if st.poisonTicks > 0 {
-		st.playerHP = max(0, st.playerHP-st.poisonDmg)
-		st.poisonTicks--
-		st.events = append(st.events, CombatEvent{
-			Round: st.round, Phase: phaseName, Actor: "enemy", Action: "poison_tick",
-			Damage: st.poisonDmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-		})
-		if st.playerHP <= 0 {
-			if trySave(st, player, phaseName) {
-				// survived
-			} else {
-				return true
-			}
-		}
-	}
-
-	// Pet whiff: if proc'd, enemy's attack this round is a guaranteed miss
-	petWhiff := player.Mods.PetWhiffProc > 0 && st.randFloat() < player.Mods.PetWhiffProc
-	// Pet deflect: halves incoming damage to player this round
-	petDeflect := player.Mods.PetDeflectProc > 0 && st.randFloat() < player.Mods.PetDeflectProc
-	if petDeflect {
-		result.PetDeflected = true
-	}
-
-	// Spore cloud: enemy has 15% miss chance (decremented when enemy actually attacks)
-	sporeMiss := st.sporeRounds > 0 && st.randFloat() < 0.15
-
-	// Determine initiative. DM mood (Effusive/Hostile) biases the player's
-	// roll via player.Mods.InitiativeBias — +X means player goes first
-	// more often, -X means the enemy does.
-	playerSpeed := float64(player.Stats.Speed) * phase.SpeedWeight
-	enemySpeed := float64(enemy.Stats.Speed) * phase.SpeedWeight
-	playerInit := playerSpeed + st.randFloat()*10 + player.Mods.InitiativeBias
-	enemyInit := enemySpeed + st.randFloat()*10
-	playerFirst := playerInit >= enemyInit
-
-	if playerFirst {
-		if resolvePlayerSwings(st, player, enemy, phase, result) {
-			return true
-		}
-		if !abilityDealtDamage {
-			if resolveEnemyAttack(st, player, enemy, phase, result, petWhiff, petDeflect, sporeMiss) {
-				return true
-			}
-		}
-	} else {
-		if !abilityDealtDamage {
-			if resolveEnemyAttack(st, player, enemy, phase, result, petWhiff, petDeflect, sporeMiss) {
-				return true
-			}
-		}
-		if resolvePlayerSwings(st, player, enemy, phase, result) {
-			return true
-		}
-	}
-
-	// Environmental hazard
-	if phase.EnvironmentProc > 0 && st.randFloat() < phase.EnvironmentProc {
-		envDmg := 2 + st.roll(5)
-		st.playerHP = max(0, st.playerHP-envDmg)
-		st.events = append(st.events, CombatEvent{
-			Round: st.round, Phase: phaseName, Actor: "environment", Action: "environmental",
-			Damage: envDmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-		})
-		if st.playerHP <= 0 {
-			if !trySave(st, player, phaseName) {
-				return true
-			}
-		}
-	}
-
-	// Misty crowd revenge (debuff for declining Misty)
-	if player.Mods.CrowdRevengeProc > 0 && st.randFloat() < player.Mods.CrowdRevengeProc {
-		dmg := player.Mods.CrowdRevengeDmg
-		st.playerHP = max(0, st.playerHP-dmg)
-		st.events = append(st.events, CombatEvent{
-			Round: st.round, Phase: phaseName, Actor: "environment", Action: "crowd_revenge",
-			Damage: dmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-			Desc: "Misty's crowd",
-		})
-		if st.playerHP <= 0 {
-			if !trySave(st, player, phaseName) {
-				return true
-			}
-		}
-	}
-
-	// Pet attack
-	if player.Mods.PetAttackProc > 0 && st.randFloat() < player.Mods.PetAttackProc {
-		petDmg := player.Mods.PetAttackDmg + st.roll(5)
-		st.enemyHP = max(0, st.enemyHP-petDmg)
-		result.PetAttacked = true
-		st.events = append(st.events, CombatEvent{
-			Round: st.round, Phase: phaseName, Actor: "pet", Action: "pet_attack",
-			Damage: petDmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-		})
-		if enemyDown(st, phaseName) {
-			return true
-		}
-	}
-
-	// Misty heal
-	if player.Mods.MistyHealProc > 0 && st.randFloat() < player.Mods.MistyHealProc {
-		healAmt := player.Mods.MistyHealAmt
-		st.playerHP = min(effPlayerMaxHP(player, st), st.playerHP+healAmt)
-		result.MistyHealed = true
-		st.events = append(st.events, CombatEvent{
-			Round: st.round, Phase: phaseName, Actor: "npc", Action: "misty_heal",
-			Damage: healAmt, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-			Desc: "Misty",
-		})
-	}
-
-	// Consumable heal: triggers when player drops below 60% HP. Fires up
-	// to HealItemCharges times per fight (1 = legacy one-shot; bosses can
-	// stack from inventory).
-	//
-	// Threshold is 60% rather than 50% to give low-HP classes (cleric,
-	// mage) more breathing room — at 50% a cleric was bleeding into the
-	// danger zone before the heal fired.
-	if st.healChargesLeft > 0 && player.Mods.HealItem > 0 &&
-		st.playerHP > 0 && st.playerHP*5 < player.Stats.MaxHP*3 {
-		st.healChargesLeft--
-		healAmt := player.Mods.HealItem
-		st.playerHP = min(effPlayerMaxHP(player, st), st.playerHP+healAmt)
-		st.events = append(st.events, CombatEvent{
-			Round: st.round, Phase: phaseName, Actor: "consumable", Action: "heal_item",
-			Damage: healAmt, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-		})
-	}
-
-	// Regenerate (monster ability): the enemy knits its wounds at the close of
-	// every round once the ability has armed st.enemyRegen.
-	if st.enemyRegen > 0 && st.enemyHP > 0 && st.enemyHP < enemy.Stats.MaxHP {
-		st.enemyHP = min(enemy.Stats.MaxHP, st.enemyHP+st.enemyRegen)
-		st.events = append(st.events, CombatEvent{
-			Round: st.round, Phase: phaseName, Actor: "enemy", Action: "regen_tick",
-			Damage: st.enemyRegen, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
-		})
-	}
-
-	// End-of-round Orc Rage backstop. The primary trigger sits at the
-	// top of resolvePlayerAttack so rage fires same-round when the player
-	// swings after taking the threshold-crossing hit. But if the enemy
-	// goes first this round AND next, the player can be two-shot without
-	// ever getting back to that check. Re-checking here ensures the rage
-	// event always fires while HP > 0 and below 50%, even if the buff
-	// goes unused.
-	maybeTriggerOrcRage(st, player, phaseName)
-
-	return false
+	return simulatePartyWithRNG([]Combatant{player}, enemy, phases, rng).Seats[0]
 }
 
 // maybeTriggerOrcRage emits the "rage" event and arms pendingRageAttack
@@ -1509,25 +1300,3 @@ func trySave(st *combatState, player *Combatant, phaseName string) bool {
 	}
 	return false
 }
-
-func finalize(result CombatResult, st *combatState, player, enemy Combatant) CombatResult {
-	result.Events = st.events
-	result.PlayerEndHP = st.playerHP
-	result.EnemyEndHP = st.enemyHP
-	result.TotalRounds = st.round
-	result.PlayerWon = st.enemyHP <= 0
-
-	playerMax := max(1, player.Stats.MaxHP)
-	enemyMax := max(1, enemy.Stats.MaxHP)
-	if result.PlayerWon && st.playerHP > 0 {
-		result.NearDeath = float64(st.playerHP) < float64(playerMax)*0.15
-		winnerRemaining := float64(st.playerHP) / float64(playerMax)
-		result.Closeness = 1.0 - winnerRemaining
-	} else if !result.PlayerWon {
-		enemyRemaining := float64(st.enemyHP) / float64(enemyMax)
-		result.NearDeath = enemyRemaining < 0.15
-		result.Closeness = 1.0 - enemyRemaining
-	}
-
-	return result
-}

internal/plugin/combat_engine_characterization_test.go

@@ -202,9 +202,138 @@ func characterizationScenarios() []charScenario {
 			return e
 		}(), defaultCombatPhases},
 		{"weapon_profile", weaponPlayer(), baseEnemy(), defaultCombatPhases},
+
+		// --- Class-identity mods (2026-05-16 audit + J1). ExtraAttacks is the
+		// lever J1 moved, so it needs a pin before the roster refactor.
+		{"extra_attacks_1", modPlayer(func(m *CombatModifiers) { m.ExtraAttacks = 1 }), tankyEnemy(), defaultCombatPhases},
+		{"extra_attacks_3", modPlayer(func(m *CombatModifiers) { m.ExtraAttacks = 3 }), tankyEnemy(), defaultCombatPhases},
+		{"sneak_attack", modPlayer(func(m *CombatModifiers) { m.SneakAttackDie = 4 }), tankyEnemy(), defaultCombatPhases},
+		{"hunters_mark", modPlayer(func(m *CombatModifiers) { m.HuntersMarkDie = 3 }), tankyEnemy(), defaultCombatPhases},
+		{"divine_strike", weaponMods(func(m *CombatModifiers) { m.DivineStrikePerHit = 4 }), tankyEnemy(), defaultCombatPhases},
+		{"thorn_lash", modPlayer(func(m *CombatModifiers) { m.ThornLashDmg = 3 }), hardHitEnemy(), defaultCombatPhases},
+		{"crit_threshold_19", modPlayer(func(m *CombatModifiers) { m.CritThreshold = 19 }), tankyEnemy(), defaultCombatPhases},
+		{"first_attack_bonus", modPlayer(func(m *CombatModifiers) { m.FirstAttackBonus = 8 }), tankyEnemy(), defaultCombatPhases},
+		{"assassinate", modPlayer(func(m *CombatModifiers) {
+			m.AssassinateAdvantage = true
+			m.AssassinateBonusDmg = 12
+		}), tankyEnemy(), defaultCombatPhases},
+		{"berserker_rage", modPlayer(func(m *CombatModifiers) {
+			m.BerserkerRage = true
+			m.RageMeleeDmg = 2
+			m.PhysicalResistRage = true
+			m.FrenzyDmgBonus = 0.25
+		}), hardHitEnemy(), defaultCombatPhases},
+		{"spirit_weapon", modPlayer(func(m *CombatModifiers) {
+			m.SpiritWeaponProc = 1.0
+			m.SpiritWeaponDmg = 8
+		}), tankyEnemy(), defaultCombatPhases},
+		{"arcane_ward", modPlayer(func(m *CombatModifiers) { m.ArcaneWardHP = 25 }), hardHitEnemy(), defaultCombatPhases},
+		{"heal_charges_3", modPlayer(func(m *CombatModifiers) {
+			m.HealItem = 20
+			m.HealItemCharges = 3
+		}), hardHitEnemy(), defaultCombatPhases},
+		{"crowd_revenge", modPlayer(func(m *CombatModifiers) {
+			m.CrowdRevengeProc = 1.0
+			m.CrowdRevengeDmg = 4
+		}), baseEnemy(), defaultCombatPhases},
+
+		// --- Race passives.
+		{"lucky_reroll", modPlayer(func(m *CombatModifiers) { m.LuckyReroll = true }), tankyEnemy(), defaultCombatPhases},
+		{"orc_rage", modPlayer(func(m *CombatModifiers) { m.RageReady = true }), hardHitEnemy(), defaultCombatPhases},
+		{"poison_resist", modPlayer(func(m *CombatModifiers) { m.PoisonResist = true }), abilityEnemy("Venom", "poison", "any"), defaultCombatPhases},
+		{"fire_resist_aoe", modPlayer(func(m *CombatModifiers) { m.FireResist = true }), abilityEnemy("Flame Breath", "aoe_fire", "any"), defaultCombatPhases},
+
+		// --- Phase 13 bestiary slices 3 + 4. None of these were pinned.
+		{"ability_bonus_damage", basePlayer(), abilityEnemy("Smash", "bonus_damage", "any"), defaultCombatPhases},
+		{"ability_aoe", basePlayer(), abilityEnemy("Blast", "aoe", "any"), defaultCombatPhases},
+		{"ability_death_aoe", basePlayer(), abilityEnemy("Last Breath", "death_aoe", "any"), defaultCombatPhases},
+		{"ability_execute", func() Combatant {
+			p := basePlayer()
+			p.Stats.MaxHP = 40
+			return p
+		}(), abilityEnemy("Finisher", "execute", "any"), defaultCombatPhases},
+		{"ability_self_heal", basePlayer(), abilityEnemy("Mend", "self_heal", "any"), defaultCombatPhases},
+		{"ability_evade", basePlayer(), abilityEnemy("Blink", "evade", "any"), defaultCombatPhases},
+		{"ability_block", basePlayer(), abilityEnemy("Parry", "block", "any"), defaultCombatPhases},
+		{"ability_advantage", basePlayer(), abilityEnemy("Focus", "advantage", "any"), defaultCombatPhases},
+		{"ability_retaliate", basePlayer(), abilityEnemy("Spines", "retaliate", "any"), defaultCombatPhases},
+		{"ability_regenerate", basePlayer(), abilityEnemy("Regrow", "regenerate", "any"), defaultCombatPhases},
+		{"ability_survive_at_1", basePlayer(), func() Combatant {
+			e := abilityEnemy("Undying", "survive_at_1", "any")
+			e.Stats.MaxHP = 40
+			return e
+		}(), defaultCombatPhases},
+		{"ability_stat_drain", basePlayer(), abilityEnemy("Sap", "stat_drain", "any"), defaultCombatPhases},
+		{"ability_debuff", basePlayer(), abilityEnemy("Curse", "debuff", "any"), defaultCombatPhases},
+		{"ability_max_hp_drain", basePlayer(), abilityEnemy("Wither", "max_hp_drain", "any"), defaultCombatPhases},
+		{"ability_spell_resist", func() Combatant {
+			p := basePlayer()
+			p.Mods.SpellPreDamage = 30
+			p.Mods.SpellPreDamageDesc = "Fireball"
+			return p
+		}(), abilityEnemy("Warded", "spell_resist", "any"), defaultCombatPhases},
+		{"ability_reveal_action", basePlayer(), abilityEnemy("Expose", "reveal_action", "any"), defaultCombatPhases},
+		{"ability_fear_immune", func() Combatant {
+			p := basePlayer()
+			p.Mods.SpellPreDamage = 5
+			p.Mods.SpellPreDamageDesc = "Hold Person"
+			p.Mods.SpellEnemySkipFirst = true
+			return p
+		}(), abilityEnemy("Fearless", "fear_immune", "any"), defaultCombatPhases},
+		{"ability_ally_buff", basePlayer(), abilityEnemy("Warcry", "ally_buff", "any"), defaultCombatPhases},
+
+		// --- Phase-scoped ability gating + environment hazard.
+		{"ability_opening_phase", basePlayer(), abilityEnemy("Ambush", "bonus_damage", "opening"), defaultCombatPhases},
+		{"environment_heavy", basePlayer(), baseEnemy(), []CombatPhase{
+			{"Opening", 2, 0.6, 0.8, 1.5, 1.0},
+			{"Clash", 3, 1.2, 1.0, 0.8, 1.0},
+		}},
 	}
 }
 
+// modPlayer returns basePlayer with a mutation applied to its modifiers.
+func modPlayer(f func(*CombatModifiers)) Combatant {
+	p := basePlayer()
+	f(&p.Mods)
+	return p
+}
+
+// weaponMods is modPlayer for effects that only fire on the weapon-dice
+// damage path (Divine Strike has no effect without a Weapon).
+func weaponMods(f func(*CombatModifiers)) Combatant {
+	p := basePlayer()
+	p.Stats.Weapon = weaponByID("wpn_longsword")
+	f(&p.Mods)
+	return p
+}
+
+// tankyEnemy survives long enough for per-hit and per-swing riders to
+// accumulate across several rounds instead of dying in the opening.
+func tankyEnemy() Combatant {
+	e := baseEnemy()
+	e.Stats.MaxHP = 300
+	e.Stats.Defense = 10
+	return e
+}
+
+// hardHitEnemy hits hard enough to exercise damage-taken paths (wards,
+// resists, retaliation, heal triggers) before the fight resolves.
+func hardHitEnemy() Combatant {
+	e := baseEnemy()
+	e.Stats.MaxHP = 150
+	e.Stats.Attack = 28
+	return e
+}
+
+// abilityEnemy is baseEnemy carrying an always-proccing ability, so the
+// golden pins the effect rather than the proc roll.
+func abilityEnemy(name, effect, phase string) Combatant {
+	e := baseEnemy()
+	e.Stats.MaxHP = 120
+	e.Ability = &MonsterAbility{Name: name, Phase: phase, ProcChance: 1.0, Effect: effect}
+	return e
+}
+
 // charSeeds drives each scenario. Multiple seeds widen RNG-branch coverage
 // without exploding the golden file.
 var charSeeds = []uint64{1, 2, 3, 7, 42}

internal/plugin/combat_engine_party.go

@@ -0,0 +1,787 @@
+package plugin
+
+import (
+	"math/rand/v2"
+	"sort"
+)
+
+// ── N-body auto-resolve ──────────────────────────────────────────────────────
+//
+// The auto-resolve engine seats a roster, exactly as the turn-based engine has
+// since P3. `SimulateCombat` is the one-seat case and nothing more: for a solo
+// roster every short-circuit below collapses to the pre-roster code path and
+// the engine draws from the RNG in precisely the pre-roster order. That is what
+// keeps `TestCombatCharacterization` byte-identical and the d8prereq_corpus
+// baselines comparable. If the golden moves, solo balance moved — stop.
+//
+// The invariants the solo path rests on, all of them mirrored from P3:
+//
+//   - enemyTargetSeat draws nothing for a one-seat roster (there is only one
+//     target), so the enemy's choice costs no randomness.
+//   - the initiative loop draws one player roll then one enemy roll, which is
+//     the pre-roster order; ties go to the player, as `playerInit >= enemyInit`
+//     always did.
+//   - the per-seat loops run exactly once.
+//
+// Per-actor state (poison, charges, rage, wards) follows the `combatState`
+// cursor, so the resolution primitives need no changes: they already read
+// `st.c` — the turn engine has called them that way since P3.
+
+// PartyCombatResult is one fight, seen from every seat at once. The fight-scoped
+// fields (the enemy, the round count, the event log) are shared; `Seats` holds
+// the per-character view, and `Seats[i]` is a complete `CombatResult` so a solo
+// caller can take `Seats[0]` and be handed exactly what `SimulateCombat` always
+// returned.
+type PartyCombatResult struct {
+	PlayerWon   bool
+	TimedOut    bool
+	TotalRounds int
+	Events      []CombatEvent
+
+	EnemyStartHP int
+	EnemyEntryHP int
+	EnemyEndHP   int
+
+	Seats []CombatResult
+}
+
+// AnySurvivor reports whether at least one seat is still standing. A party can
+// win a fight it did not all walk away from.
+func (r PartyCombatResult) AnySurvivor() bool {
+	for i := range r.Seats {
+		if r.Seats[i].PlayerEndHP > 0 {
+			return true
+		}
+	}
+	return false
+}
+
+// simulateParty auto-resolves one enemy against a roster of N player characters.
+// Production auto-resolve passes a nil rng (package global); the sim harness and
+// the characterization test seed it.
+func simulateParty(players []Combatant, enemy Combatant, phases []CombatPhase) PartyCombatResult {
+	return simulatePartyWithRNG(players, enemy, phases, nil)
+}
+
+func simulatePartyWithRNG(players []Combatant, enemy Combatant, phases []CombatPhase, rng *rand.Rand) PartyCombatResult {
+	// Party-only: bump the enemy's max HP so the fight lasts long enough for the
+	// scaled action economy to actually threaten each member. Solo is unchanged
+	// (scale 1.0), so SimulateCombat and the golden do not move.
+	if len(players) > 1 {
+		enemy.Stats.MaxHP = scaledEnemyMaxHP(enemy.Stats.MaxHP, len(players))
+	}
+	enemyStart := enemy.Stats.MaxHP
+	if enemy.Stats.StartHP > 0 && enemy.Stats.StartHP < enemy.Stats.MaxHP {
+		enemyStart = enemy.Stats.StartHP
+	}
+
+	actors := make([]*actor, len(players))
+	seats := make([]CombatResult, len(players))
+	for i := range players {
+		actors[i] = newActor(&players[i])
+		seats[i] = CombatResult{
+			PlayerStartHP: players[i].Stats.MaxHP,
+			PlayerEntryHP: actors[i].playerHP,
+			EnemyStartHP:  enemy.Stats.MaxHP,
+			EnemyEntryHP:  enemyStart,
+		}
+	}
+
+	st := &combatState{
+		actor:   actors[0],
+		actors:  actors,
+		enemyHP: enemyStart,
+		rng:     rng,
+	}
+	// Holding the enemy holds it for everyone, so the control effect is
+	// fight-scoped: any caster who queued one arms it.
+	for i := range players {
+		if players[i].Mods.SpellEnemySkipFirst {
+			st.enemySkipFirst = true
+		}
+	}
+
+	// Pre-combat one-shots, grouped by kind rather than by seat. A one-seat
+	// roster walks these in the pre-roster order.
+	for i := range actors {
+		st.seat(i)
+		if st.c.Mods.SniperKillProc > 0 && st.randFloat() < st.c.Mods.SniperKillProc {
+			st.enemyHP = 0
+			st.events = append(st.events, CombatEvent{
+				Round: 0, Phase: "pre_combat", Actor: "npc", Action: "sniper_kill",
+				Damage: enemy.Stats.MaxHP, PlayerHP: st.playerHP, EnemyHP: 0,
+				Seat: i, Desc: "Arina",
+			})
+			seats[i].SniperKilled = true
+			return finalizeParty(seats, st, players, enemy)
+		}
+	}
+
+	for i := range actors {
+		st.seat(i)
+		if st.c.Mods.FlatDmgStart > 0 {
+			dmg := st.c.Mods.FlatDmgStart
+			st.enemyHP = max(0, st.enemyHP-dmg)
+			st.events = append(st.events, CombatEvent{
+				Round: 0, Phase: "pre_combat", Actor: "consumable", Action: "flat_damage",
+				Damage: dmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP, Seat: i,
+			})
+			if st.enemyHP <= 0 {
+				return finalizeParty(seats, st, players, enemy)
+			}
+		}
+	}
+
+	// Queued spells. Resolved by applyPendingCast() before this runs — the
+	// modifiers carry the resolved damage and narrative hook.
+	for i := range actors {
+		st.seat(i)
+		if st.c.Mods.SpellPreDamageDesc == "" {
+			continue
+		}
+		dmg := st.c.Mods.SpellPreDamage
+		resisted := dmg > 0 && enemyResistsSpells(&enemy, st)
+		if resisted {
+			dmg = max(1, dmg/2)
+		}
+		if dmg > 0 {
+			st.enemyHP = max(0, st.enemyHP-dmg)
+		}
+		st.events = append(st.events, CombatEvent{
+			Round: 0, Phase: "pre_combat", Actor: "player", Action: "spell_cast",
+			Damage: dmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP, Seat: i,
+			Desc: st.c.Mods.SpellPreDamageDesc,
+		})
+		if resisted {
+			st.events = append(st.events, CombatEvent{
+				Round: 0, Phase: "pre_combat", Actor: "enemy", Action: "spell_fizzle",
+				Damage: dmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP, Seat: i,
+			})
+		}
+		if st.enemyHP <= 0 {
+			return finalizeParty(seats, st, players, enemy)
+		}
+	}
+
+	// Pre-combat: Misty gourmet is now a per-round heal, no pre-combat damage
+
+	for _, phase := range phases {
+		roundsThisPhase := phase.Rounds
+		// Add slight variance: ±1 round for non-Decisive phases
+		if phase.Name != "Decisive" && roundsThisPhase > 1 {
+			roundsThisPhase += st.roll(2) // 0 or +1
+		}
+		for r := 0; r < roundsThisPhase; r++ {
+			st.round++
+			if simulatePartyRound(st, &enemy, &phase, seats) {
+				return finalizeParty(seats, st, players, enemy)
+			}
+		}
+	}
+
+	// Exhausted the phase clock without a kill. Tiebreak on HP percentage to
+	// decide the outcome — but DO NOT zero out HP on the loser. Timeout =
+	// retreat, not a lethal blow, so no character-death side effects fire.
+	//
+	// The party reads its fraction off the pooled roster, which for one seat is
+	// that seat's own fraction, i.e. the pre-roster comparison. Slight bias to
+	// the players on exact ties (frac >=).
+	var partyHP, partyMax int
+	for i := range st.actors {
+		partyHP += st.actors[i].playerHP
+		partyMax += players[i].Stats.MaxHP
+	}
+	playerFrac := float64(partyHP) / float64(max(1, partyMax))
+	enemyFrac := float64(st.enemyHP) / float64(max(1, enemy.Stats.MaxHP))
+	playerWonTiebreak := playerFrac >= enemyFrac
+	st.seat(0)
+	st.events = append(st.events, CombatEvent{
+		Round: st.round, Phase: "exhaust", Actor: "system", Action: "timeout",
+		PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+	})
+	for i := range seats {
+		seats[i].TimedOut = true
+	}
+	out := finalizeParty(seats, st, players, enemy)
+	out.TimedOut = true
+	out.PlayerWon = playerWonTiebreak
+	for i := range out.Seats {
+		out.Seats[i].PlayerWon = playerWonTiebreak
+	}
+	return out
+}
+
+// combatOver reads the fight's terminal condition off HP rather than off a
+// primitive's bool. resolvePlayerAttack documents why: a retaliate aura can
+// drop the swinger with the enemy still standing, so `true` means "something
+// decisive happened", not "the players won". For a one-seat roster this is the
+// same answer the old `return true` gave.
+func combatOver(st *combatState) bool {
+	return st.enemyHP <= 0 || !st.anyAlive()
+}
+
+// enemyTargetSeat picks who the enemy swings at. A one-seat roster draws no
+// randomness — there is only one target — which is what keeps the solo RNG
+// stream identical. Shared with the turn engine.
+func enemyTargetSeat(st *combatState) (int, bool) {
+	if len(st.actors) == 1 {
+		return 0, st.actors[0].playerHP > 0
+	}
+	standing := make([]int, 0, len(st.actors))
+	for i, a := range st.actors {
+		if a.playerHP > 0 {
+			standing = append(standing, i)
+		}
+	}
+	if len(standing) == 0 {
+		return 0, false
+	}
+	return standing[st.roll(len(standing))], true
+}
+
+// eventsForSeat is the sub-log a single character is responsible for. Events the
+// engine never stamped — the enemy regenerating, the phase clock running out —
+// carry seat 0, so they read as the leader's. Only ever called for a party: a
+// solo seat is handed the whole log by identity.
+func eventsForSeat(events []CombatEvent, seat int) []CombatEvent {
+	out := make([]CombatEvent, 0, len(events))
+	for _, e := range events {
+		if e.Seat == seat {
+			out = append(out, e)
+		}
+	}
+	return out
+}
+
+// stampEventSeats attributes every event appended since `mark` to a seat, so
+// party narration can say who did what. Seat 0 stamps a zero, which is
+// `omitempty` — a solo fight's event log is byte-identical.
+func stampEventSeats(st *combatState, mark, seat int) {
+	for i := mark; i < len(st.events); i++ {
+		st.events[i].Seat = seat
+	}
+}
+
+// roundInitiative rolls the round's turn order: every seat, then the enemy, in
+// seating order — the pre-roster draw order when there is one seat. Ties favour
+// the players, then the lower seat.
+func roundInitiative(st *combatState, enemy *Combatant, phase *CombatPhase) []int {
+	type entry struct {
+		seat int
+		init float64
+	}
+	entries := make([]entry, 0, len(st.actors)+1)
+	for i, a := range st.actors {
+		speed := float64(a.c.Stats.Speed) * phase.SpeedWeight
+		entries = append(entries, entry{i, speed + st.randFloat()*10 + a.c.Mods.InitiativeBias})
+	}
+	enemySpeed := float64(enemy.Stats.Speed) * phase.SpeedWeight
+	entries = append(entries, entry{enemySeat, enemySpeed + st.randFloat()*10})
+
+	sort.SliceStable(entries, func(i, j int) bool {
+		a, b := entries[i], entries[j]
+		if a.init != b.init {
+			return a.init > b.init
+		}
+		if (a.seat == enemySeat) != (b.seat == enemySeat) {
+			return b.seat == enemySeat
+		}
+		return a.seat < b.seat
+	})
+	order := make([]int, len(entries))
+	for i, e := range entries {
+		order[i] = e.seat
+	}
+	return order
+}
+
+// enemyActionsThisRound is how many attack-actions the enemy takes this round
+// against the seated roster. Solo returns 1 without drawing from the RNG, so both
+// combat engines collapse to their pre-party behaviour and the characterization
+// golden and d8prereq corpus do not move.
+//
+// A party's action budget is a *fractional expectation* (partyActionExpectation),
+// realised as floor(exp) actions plus one more with probability frac(exp). The
+// fraction matters because the action lever is coarse: against a party of two, an
+// integer 2 actions is a 100% faceroll and 3 is brutal (~45%), with nothing
+// between — a per-round coin-flip for the extra action is the only way to land
+// the band in the gap. The single draw is taken only for a party, so the solo RNG
+// stream is untouched.
+func enemyActionsThisRound(st *combatState) int {
+	n := len(st.actors)
+	if n < 2 {
+		return 1
+	}
+	exp := partyActionExpectation(n)
+	base := int(exp)
+	if frac := exp - float64(base); frac > 0 && st.randFloat() < frac {
+		base++
+	}
+	return base
+}
+
+// partyActionExpectation is the expected number of enemy attack-actions per round
+// against a party of n. A single enemy swing (the pre-P8 behaviour) let each
+// member absorb ~1/N² of the solo incoming and cleared 100% of T5; the sim band
+// landed the martial-leader target only near ~2N actions, and HP alone can't touch
+// a martial (fighter stays at 100% even at enemy HP ×1.6). So the enemy's action
+// economy is the load-bearing lever, and it is fractional so a two-person party
+// lands between soloing and a trio instead of snapping to one of two integers
+// (against a duo, an integer 2 actions is a ~91% faceroll and 3 is a ~45% meat
+// grinder — 2.4 sits fighter+cleric at ~75%, between solo 70% and trio 90%).
+//
+// N≥3 follows 2N−1, the point that gave fighter ~90% / cleric-led ~72% at
+// HP ×1.15. The whole curve is monotonic by party size and never drops a
+// composition below its solo clear rate — bringing a friend is never a penalty.
+func partyActionExpectation(n int) float64 {
+	switch {
+	case n < 2:
+		return 1
+	case n == 2:
+		return 2.4
+	default:
+		return float64(2*n - 1)
+	}
+}
+
+// partyEnemyHPScale is the party-only multiplier on the enemy's max HP. Solo
+// (roster < 2) returns 1.0, so the solo path — and the characterization golden
+// and the d8prereq corpus — is byte-for-byte untouched. With the action economy
+// fixed, each member now takes ~1 swing a round, so a longer fight is more
+// cumulative exposure per member: HP became a live difficulty lever exactly the
+// way P6e predicted it would once the enemy stopped swinging only once.
+//
+// 1.15 is where the P8 sim sweep landed the band: with 2N−1 actions, a party of
+// three clears the T5 martial-leader band at ~89% (fighter) / ~67% (cleric-led),
+// clearly safer than soloing (70% / 27%) but with real TPKs and member deaths —
+// not the 100% faceroll a single enemy swing produced.
+func partyEnemyHPScale(rosterSize int) float64 {
+	if rosterSize < 2 {
+		return 1.0
+	}
+	return 1.15
+}
+
+// scaledEnemyMaxHP applies the party HP scalar to a base max-HP with one rounding
+// rule, so every call site (the auto-resolve engine, the party session's initial
+// persist, and the per-turn rebuild) agrees on the same number.
+func scaledEnemyMaxHP(baseMaxHP, rosterSize int) int {
+	return int(float64(baseMaxHP) * partyEnemyHPScale(rosterSize))
+}
+
+// enemyActionPlan is the shared action budget both combat engines resolve an
+// enemy turn against: how many attack-actions the enemy takes, and whether the
+// first one reuses the round's already-picked target (and its already-rolled
+// procs). A cleave/lifesteal ability already spent the first action, so one fewer
+// follows and none of them reuse the initial target. Both engines call this so
+// the load-bearing count stays in lockstep even though their per-action bodies
+// differ.
+func enemyActionPlan(st *combatState, abilityDealtDamage bool) (count int, reuseFirst bool) {
+	count = enemyActionsThisRound(st)
+	reuseFirst = !abilityDealtDamage
+	if abilityDealtDamage {
+		count--
+	}
+	return count, reuseFirst
+}
+
+// enemyRoundSwings resolves the enemy's attacks for one round of the auto-resolve
+// engine. A solo roster takes exactly one swing at its single seat, reusing the
+// round's already-rolled target and pet procs, so its RNG stream and event log are
+// byte-for-byte the pre-P8 engine's. A party faces enemyActionsThisRound() swings,
+// each re-targeted at a random standing seat with that seat's own pet procs, so the
+// damage is spread across the roster instead of pinning the round's first target.
+//
+// abilityDealtDamage means a cleave/lifesteal already spent the enemy's first
+// action this round, so one fewer swing follows — for solo that collapses to the
+// old "the ability stands in for the attack" skip. Returns true if the fight is
+// decided.
+func enemyRoundSwings(st *combatState, enemy *Combatant, phase *CombatPhase, seats []CombatResult,
+	target int, abilityDealtDamage, petWhiff, petDeflect, sporeMiss bool) bool {
+
+	swings, reuseFirst := enemyActionPlan(st, abilityDealtDamage)
+	for k := 0; k < swings; k++ {
+		tgt := target
+		sw, sd, sp := petWhiff, petDeflect, sporeMiss
+		if !(reuseFirst && k == 0) {
+			// A fresh target for every swing past the first: re-pick among the
+			// standing seats and roll that seat's own pet procs. This branch never
+			// runs for a solo roster, so it adds no draws to the solo stream.
+			var alive bool
+			if tgt, alive = enemyTargetSeat(st); !alive {
+				return combatOver(st)
+			}
+			st.seat(tgt)
+			sw = st.c.Mods.PetWhiffProc > 0 && st.randFloat() < st.c.Mods.PetWhiffProc
+			sd = st.c.Mods.PetDeflectProc > 0 && st.randFloat() < st.c.Mods.PetDeflectProc
+			if sd {
+				seats[tgt].PetDeflected = true
+			}
+			sp = st.sporeRounds > 0 && st.randFloat() < 0.15
+		}
+		st.seat(tgt)
+		mark := len(st.events)
+		over := resolveEnemyAttack(st, st.c, enemy, phase, &seats[tgt], sw, sd, sp)
+		stampEventSeats(st, mark, tgt)
+		if over && combatOver(st) {
+			return true
+		}
+	}
+	return false
+}
+
+// simulatePartyRound runs one round for the whole roster. Returns true if the
+// fight is over.
+func simulatePartyRound(st *combatState, enemy *Combatant, phase *CombatPhase, seats []CombatResult) bool {
+	phaseName := phase.Name
+
+	// Whoever the enemy is looking at this round. Chosen before the ability
+	// fires, because the ability lands on its target. Costs no RNG when solo.
+	target, alive := enemyTargetSeat(st)
+	if !alive {
+		return true
+	}
+	st.seat(target)
+
+	// Phase 9 spell: control effect (Hold Person, Sleep, Command) skips the
+	// enemy's attack for one round. Fight-scoped — holding it holds it for all.
+	enemyHeldThisRound := false
+	if st.enemySkipFirst {
+		st.enemySkipFirst = false
+		if enemyImmuneToControl(enemy, st) {
+			// fear_immune: the control spell can't take hold — the enemy acts
+			// as normal this round.
+			st.events = append(st.events, CombatEvent{
+				Round: st.round, Phase: phaseName, Actor: "enemy", Action: "fear_resist",
+				PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+			})
+		} else {
+			enemyHeldThisRound = true
+			st.events = append(st.events, CombatEvent{
+				Round: st.round, Phase: phaseName, Actor: "enemy", Action: "spell_held",
+				PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+			})
+		}
+	}
+
+	// Monster ability: check at round start. It resolves against the enemy's
+	// target, which the cursor already points at.
+	abilityDealtDamage := enemyHeldThisRound
+	if enemy.Ability != nil {
+		if abilityFires(enemy.Ability, phaseName, st) {
+			mark := len(st.events)
+			over := applyAbility(st, st.c, enemy, phase, &seats[target])
+			stampEventSeats(st, mark, target)
+			if over && combatOver(st) {
+				return true
+			}
+			// Cleave and lifesteal deal damage — skip normal enemy attack this round
+			switch enemy.Ability.Effect {
+			case "cleave", "lifesteal":
+				abilityDealtDamage = true
+			}
+		}
+	}
+
+	// Poison tick from previous round. Stacked per character, so every seat
+	// carrying it bleeds.
+	for i := range st.actors {
+		st.seat(i)
+		if st.poisonTicks <= 0 {
+			continue
+		}
+		st.playerHP = max(0, st.playerHP-st.poisonDmg)
+		st.poisonTicks--
+		st.events = append(st.events, CombatEvent{
+			Round: st.round, Phase: phaseName, Actor: "enemy", Action: "poison_tick",
+			Damage: st.poisonDmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP, Seat: i,
+		})
+		if st.playerHP <= 0 && !trySave(st, st.c, phaseName) && !st.anyAlive() {
+			return true
+		}
+	}
+
+	// The poison may have dropped the seat the enemy had picked. Re-target
+	// before the swing procs, which read the target's own modifiers.
+	if st.actors[target].playerHP <= 0 {
+		if target, alive = enemyTargetSeat(st); !alive {
+			return true
+		}
+	}
+	st.seat(target)
+
+	// Pet whiff: if proc'd, enemy's attack this round is a guaranteed miss
+	petWhiff := st.c.Mods.PetWhiffProc > 0 && st.randFloat() < st.c.Mods.PetWhiffProc
+	// Pet deflect: halves incoming damage to the target this round
+	petDeflect := st.c.Mods.PetDeflectProc > 0 && st.randFloat() < st.c.Mods.PetDeflectProc
+	if petDeflect {
+		seats[target].PetDeflected = true
+	}
+	// Spore cloud: enemy has 15% miss chance (decremented when enemy actually attacks)
+	sporeMiss := st.sporeRounds > 0 && st.randFloat() < 0.15
+
+	// Determine initiative. DM mood (Effusive/Hostile) biases a player's roll
+	// via Mods.InitiativeBias — +X means they go first more often.
+	for _, s := range roundInitiative(st, enemy, phase) {
+		if s == enemySeat {
+			if enemyRoundSwings(st, enemy, phase, seats, target, abilityDealtDamage, petWhiff, petDeflect, sporeMiss) {
+				return true
+			}
+			continue
+		}
+		if st.actors[s].playerHP <= 0 {
+			// A seat that went down earlier this round forfeits its swing.
+			continue
+		}
+		st.seat(s)
+		mark := len(st.events)
+		over := resolvePlayerSwings(st, st.c, enemy, phase, &seats[s])
+		stampEventSeats(st, mark, s)
+		if over && combatOver(st) {
+			return true
+		}
+	}
+
+	// End-of-round, per surviving character.
+	for i := range st.actors {
+		st.seat(i)
+		if st.playerHP <= 0 {
+			continue
+		}
+		mark := len(st.events)
+		if over := endOfRoundForSeat(st, phase, &seats[i]); over {
+			stampEventSeats(st, mark, i)
+			return true
+		}
+		stampEventSeats(st, mark, i)
+	}
+
+	// Regenerate (monster ability): the enemy knits its wounds at the close of
+	// every round once the ability has armed st.enemyRegen. Fight-scoped.
+	if st.enemyRegen > 0 && st.enemyHP > 0 && st.enemyHP < enemy.Stats.MaxHP {
+		st.enemyHP = min(enemy.Stats.MaxHP, st.enemyHP+st.enemyRegen)
+		st.events = append(st.events, CombatEvent{
+			Round: st.round, Phase: phaseName, Actor: "enemy", Action: "regen_tick",
+			Damage: st.enemyRegen, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+		})
+	}
+
+	// End-of-round Orc Rage backstop. The primary trigger sits at the top of
+	// resolvePlayerAttack so rage fires same-round when the character swings
+	// after taking the threshold-crossing hit. But if the enemy goes first this
+	// round AND next, they can be two-shot without ever getting back to that
+	// check. Re-checking here ensures the rage event always fires while HP > 0
+	// and below 50%, even if the buff goes unused.
+	for i := range st.actors {
+		st.seat(i)
+		mark := len(st.events)
+		maybeTriggerOrcRage(st, st.c, phaseName)
+		stampEventSeats(st, mark, i)
+	}
+
+	return false
+}
+
+// ── Misty's pair, shared by both engines ─────────────────────────────────────
+//
+// These two are the only round-end effects the turn engine did not have its own
+// copy of. Everything else in endOfRoundForSeat either exists there already (the
+// pet, the spiritual weapon — fired after a player action rather than at round
+// end), is deliberately absent (the environmental hazard: turnCombatPhase is a
+// single flat "Duel" phase with EnvironmentProc at 0), or is replaced by an
+// explicit player command (the consumable auto-heal, which is `!consume`).
+//
+// So they are hoisted rather than re-implemented. A parallel sibling is what let
+// the two win close-outs drift apart (deferred item D); this pair is now one
+// list of effects with two callers, and cannot.
+//
+// Neither draws from the RNG unless its proc is armed, so a character with no
+// Misty history rolls exactly the dice it rolled before — the sim corpus and
+// combat_characterization.golden do not move.
+
+// mistyCrowdRevenge is the debuff for declining Misty: her crowd takes a swing
+// at the end of the round. Returns true when it decided the fight — that is,
+// when it dropped this character, the death save failed, and nobody else is
+// standing. A downed character in a still-live party returns false.
+func mistyCrowdRevenge(st *combatState, player *Combatant, phaseName string) bool {
+	if player.Mods.CrowdRevengeProc <= 0 || st.randFloat() >= player.Mods.CrowdRevengeProc {
+		return false
+	}
+	dmg := player.Mods.CrowdRevengeDmg
+	st.playerHP = max(0, st.playerHP-dmg)
+	st.events = append(st.events, CombatEvent{
+		Round: st.round, Phase: phaseName, Actor: "environment", Action: "crowd_revenge",
+		Damage: dmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+		Desc: "Misty's crowd",
+	})
+	return st.playerHP <= 0 && !trySave(st, player, phaseName) && !st.anyAlive()
+}
+
+// mistyHeal is the buff's payout. It cannot decide the fight, so it returns
+// nothing. result may be a scratch value the caller discards (the turn engine's
+// is) — the durable record is the misty_heal event on the log, which is what
+// seatCombatResult reads to award combat_misty_clutch.
+func mistyHeal(st *combatState, player *Combatant, phaseName string, result *CombatResult) {
+	if player.Mods.MistyHealProc <= 0 || st.randFloat() >= player.Mods.MistyHealProc {
+		return
+	}
+	healAmt := player.Mods.MistyHealAmt
+	st.playerHP = min(effPlayerMaxHP(player, st), st.playerHP+healAmt)
+	result.MistyHealed = true
+	st.events = append(st.events, CombatEvent{
+		Round: st.round, Phase: phaseName, Actor: "npc", Action: "misty_heal",
+		Damage: healAmt, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+		Desc: "Misty",
+	})
+}
+
+// seatEndOfRound runs the round-end effects the turn engine owes one seat, in
+// the order endOfRoundForSeat runs them: the crowd's swing, then — if the seat
+// survived it — Misty's heal. Returns true when the fight is over.
+//
+// It exists because the turn engine's stepRoundEnd never ran either one. A
+// player carrying Misty's buff lost it by fighting manually; worse, a player
+// carrying her debuff *escaped* it by doing the same, which needed no discovery
+// to exploit — just press !attack.
+func seatEndOfRound(st *combatState, player *Combatant, phaseName string, result *CombatResult) bool {
+	if over := mistyCrowdRevenge(st, player, phaseName); over {
+		return true
+	}
+	if st.playerHP <= 0 {
+		return false
+	}
+	mistyHeal(st, player, phaseName, result)
+	return false
+}
+
+// endOfRoundForSeat runs the per-character close of a round against the seat the
+// cursor already points at: environment, Misty's crowd, the pet, the spiritual
+// weapon, Misty's heal, and the consumable auto-heal — in that order, which is
+// the pre-roster order. Returns true if the fight is over.
+func endOfRoundForSeat(st *combatState, phase *CombatPhase, result *CombatResult) bool {
+	phaseName := phase.Name
+	player := st.c
+
+	// Environmental hazard
+	if phase.EnvironmentProc > 0 && st.randFloat() < phase.EnvironmentProc {
+		envDmg := 2 + st.roll(5)
+		st.playerHP = max(0, st.playerHP-envDmg)
+		st.events = append(st.events, CombatEvent{
+			Round: st.round, Phase: phaseName, Actor: "environment", Action: "environmental",
+			Damage: envDmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+		})
+		if st.playerHP <= 0 && !trySave(st, player, phaseName) && !st.anyAlive() {
+			return true
+		}
+	}
+
+	// Misty crowd revenge (debuff for declining Misty)
+	if over := mistyCrowdRevenge(st, player, phaseName); over {
+		return true
+	}
+
+	// A character the round just killed stops acting, but the fight goes on if
+	// anyone else is standing.
+	if st.playerHP <= 0 {
+		return false
+	}
+
+	// Pet attack
+	if player.Mods.PetAttackProc > 0 && st.randFloat() < player.Mods.PetAttackProc {
+		petDmg := player.Mods.PetAttackDmg + st.roll(5)
+		st.enemyHP = max(0, st.enemyHP-petDmg)
+		result.PetAttacked = true
+		st.events = append(st.events, CombatEvent{
+			Round: st.round, Phase: phaseName, Actor: "pet", Action: "pet_attack",
+			Damage: petDmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+		})
+		if enemyDown(st, phaseName) {
+			return true
+		}
+	}
+
+	// Spiritual Weapon strike
+	if player.Mods.SpiritWeaponProc > 0 && st.randFloat() < player.Mods.SpiritWeaponProc {
+		swDmg := player.Mods.SpiritWeaponDmg + st.roll(5)
+		st.enemyHP = max(0, st.enemyHP-swDmg)
+		st.events = append(st.events, CombatEvent{
+			Round: st.round, Phase: phaseName, Actor: "spirit_weapon", Action: "spirit_weapon_strike",
+			Damage: swDmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+		})
+		if enemyDown(st, phaseName) {
+			return true
+		}
+	}
+
+	// Misty heal
+	mistyHeal(st, player, phaseName, result)
+
+	// Consumable heal: triggers when the character drops below 60% HP. Fires up
+	// to HealItemCharges times per fight (1 = legacy one-shot; bosses can
+	// stack from inventory).
+	//
+	// Threshold is 60% rather than 50% to give low-HP classes (cleric, mage)
+	// more breathing room — at 50% a cleric was bleeding into the danger zone
+	// before the heal fired.
+	if st.healChargesLeft > 0 && player.Mods.HealItem > 0 &&
+		st.playerHP > 0 && st.playerHP*5 < player.Stats.MaxHP*3 {
+		st.healChargesLeft--
+		healAmt := player.Mods.HealItem
+		st.playerHP = min(effPlayerMaxHP(player, st), st.playerHP+healAmt)
+		st.events = append(st.events, CombatEvent{
+			Round: st.round, Phase: phaseName, Actor: "consumable", Action: "heal_item",
+			Damage: healAmt, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
+		})
+	}
+
+	return false
+}
+
+// finalizeParty closes the fight, giving every seat its own view. The enemy's
+// numbers and the event log are shared; HP, closeness and near-death are read
+// per character. For one seat this is byte-for-byte the old `finalize`.
+func finalizeParty(seats []CombatResult, st *combatState, players []Combatant, enemy Combatant) PartyCombatResult {
+	won := st.enemyHP <= 0
+	enemyMax := max(1, enemy.Stats.MaxHP)
+
+	// A solo fight's seat holds the whole log, which is the same slice header the
+	// pre-roster engine returned. A party's seats each hold their own events, so
+	// the per-seat close-out (heal items burned, combat achievements) counts what
+	// that character actually did rather than what the party did.
+	solo := len(seats) == 1
+
+	for i := range seats {
+		a := st.actors[i]
+		r := &seats[i]
+		if solo {
+			r.Events = st.events
+		} else {
+			r.Events = eventsForSeat(st.events, i)
+		}
+		r.PlayerEndHP = a.playerHP
+		r.EnemyEndHP = st.enemyHP
+		r.TotalRounds = st.round
+		r.PlayerWon = won
+
+		playerMax := max(1, players[i].Stats.MaxHP)
+		if won && a.playerHP > 0 {
+			r.NearDeath = float64(a.playerHP) < float64(playerMax)*0.15
+			winnerRemaining := float64(a.playerHP) / float64(playerMax)
+			r.Closeness = 1.0 - winnerRemaining
+		} else if !won {
+			enemyRemaining := float64(st.enemyHP) / float64(enemyMax)
+			r.NearDeath = enemyRemaining < 0.15
+			r.Closeness = 1.0 - enemyRemaining
+		}
+	}
+
+	return PartyCombatResult{
+		PlayerWon:    won,
+		TotalRounds:  st.round,
+		Events:       st.events,
+		EnemyStartHP: enemy.Stats.MaxHP,
+		EnemyEntryHP: seats[0].EnemyEntryHP,
+		EnemyEndHP:   st.enemyHP,
+		Seats:        seats,
+	}
+}

internal/plugin/combat_engine_party_test.go

@@ -0,0 +1,275 @@
+package plugin
+
+import (
+	"math/rand/v2"
+	"testing"
+)
+
+// seededRNG gives each test its own deterministic stream, so none of these can
+// join the flaky set that rode the package global before P4 seeded them.
+func seededRNG(seed uint64) *rand.Rand {
+	return rand.New(rand.NewPCG(seed, seed^0x9e3779b9))
+}
+
+// The load-bearing claim of P6e: a one-seat roster draws from the RNG in exactly
+// the pre-roster order, so SimulateCombat is the degenerate case of the N-body
+// engine and the d8prereq_corpus baselines still compare. TestCombatCharacterization
+// is the real proof (57 scenarios); this pins the delegation itself.
+func TestSimulateCombat_IsTheOneSeatPartyCase(t *testing.T) {
+	for seed := uint64(1); seed <= 40; seed++ {
+		solo := simulateCombatWithRNG(basePlayer(), baseEnemy(), dungeonCombatPhases, seededRNG(seed))
+		party := simulatePartyWithRNG([]Combatant{basePlayer()}, baseEnemy(), dungeonCombatPhases, seededRNG(seed))
+
+		if len(party.Seats) != 1 {
+			t.Fatalf("seed %d: one player seated %d seats", seed, len(party.Seats))
+		}
+		got := party.Seats[0]
+		if got.PlayerWon != solo.PlayerWon || got.PlayerEndHP != solo.PlayerEndHP ||
+			got.EnemyEndHP != solo.EnemyEndHP || got.TotalRounds != solo.TotalRounds ||
+			got.TimedOut != solo.TimedOut {
+			t.Fatalf("seed %d: one-seat party diverged from solo\n solo=%+v\nparty=%+v", seed, solo, got)
+		}
+		if len(got.Events) != len(solo.Events) {
+			t.Fatalf("seed %d: event count %d != solo %d", seed, len(got.Events), len(solo.Events))
+		}
+		for i := range solo.Events {
+			if got.Events[i] != solo.Events[i] {
+				t.Fatalf("seed %d: event %d differs\n solo=%+v\nparty=%+v", seed, i, solo.Events[i], got.Events[i])
+			}
+		}
+	}
+}
+
+// A solo fight never stamps a seat, because seat 0 is the zero value and the
+// field is omitempty. If this regresses, the golden file moves.
+func TestSimulateCombat_SoloEventsCarryNoSeat(t *testing.T) {
+	res := simulateCombatWithRNG(basePlayer(), baseEnemy(), dungeonCombatPhases, seededRNG(7))
+	for i, e := range res.Events {
+		if e.Seat != 0 {
+			t.Fatalf("event %d (%s/%s) stamped seat %d in a solo fight", i, e.Phase, e.Action, e.Seat)
+		}
+	}
+}
+
+// The whole point of P6e. Three characters swinging at one monster must land more
+// player attacks per round than one character does — before this, the members
+// stood in the doorway while the leader fought.
+func TestSimulateParty_EverySeatSwings(t *testing.T) {
+	tank := baseEnemy()
+	tank.Stats.MaxHP = 5000 // outlast the phase clock so we can count swings
+
+	countSwings := func(events []CombatEvent, seat int) int {
+		n := 0
+		for _, e := range events {
+			if e.Actor == "player" && e.Seat == seat && e.Roll > 0 {
+				n++
+			}
+		}
+		return n
+	}
+
+	res := simulatePartyWithRNG(
+		[]Combatant{basePlayer(), basePlayer(), basePlayer()}, tank, dungeonCombatPhases, seededRNG(11))
+
+	if len(res.Seats) != 3 {
+		t.Fatalf("seated %d, want 3", len(res.Seats))
+	}
+	for seat := range 3 {
+		if got := countSwings(res.Events, seat); got == 0 {
+			t.Fatalf("seat %d never swung — the party is not fighting together", seat)
+		}
+	}
+}
+
+// A member going down is not the end of the fight. Only an empty roster is.
+// This is the bug P7 measured from the outside: every party loss was the leader
+// dying alone, because a member was never in the fight to begin with.
+func TestSimulateParty_DownedMemberDoesNotEndTheFight(t *testing.T) {
+	glass := basePlayer()
+	glass.Stats.MaxHP = 1
+	glass.Stats.Defense = 0
+
+	brute := basePlayer()
+	brute.Stats.MaxHP = 4000
+
+	killer := baseEnemy()
+	killer.Stats.MaxHP = 3000
+	killer.Stats.Attack = 40
+
+	res := simulatePartyWithRNG([]Combatant{brute, glass}, killer, dungeonCombatPhases, seededRNG(3))
+
+	if res.Seats[1].PlayerEndHP > 0 {
+		t.Skip("the glass cannon survived this seed; nothing to assert")
+	}
+	if !res.AnySurvivor() {
+		t.Fatalf("both seats down — pick a seed where the brute lives")
+	}
+	if res.TotalRounds <= 1 {
+		t.Fatalf("fight ended in %d round(s) when a member fell; the roster should have fought on",
+			res.TotalRounds)
+	}
+	// The brute must have kept swinging after the member fell.
+	lastMemberEvent, lastBruteEvent := -1, -1
+	for i, e := range res.Events {
+		if e.Seat == 1 && e.Actor == "player" {
+			lastMemberEvent = i
+		}
+		if e.Seat == 0 && e.Actor == "player" && e.Roll > 0 {
+			lastBruteEvent = i
+		}
+	}
+	if lastBruteEvent < lastMemberEvent {
+		t.Fatalf("the fight stopped when seat 1 fell (last brute swing %d, last member event %d)",
+			lastBruteEvent, lastMemberEvent)
+	}
+}
+
+// P8 scaling constants: solo is exempt on both levers (1 action, ×1.0 HP) so the
+// characterization golden and the d8prereq corpus are untouched. A party's action
+// budget is a fractional expectation — 2.4 for a duo (so it lands between soloing
+// and a trio, where an integer 2 vs 3 has no room), 2N−1 for N≥3 — plus ×1.15
+// enemy HP.
+func TestP8PartyScaling_SoloExemptPartyScaled(t *testing.T) {
+	if got := partyActionExpectation(1); got != 1 {
+		t.Fatalf("solo action expectation = %v, want 1", got)
+	}
+	if got := partyEnemyHPScale(1); got != 1.0 {
+		t.Fatalf("solo HP scale = %v, want 1.0", got)
+	}
+	if got := scaledEnemyMaxHP(200, 1); got != 200 {
+		t.Fatalf("solo enemy HP = %d, want 200 (unscaled)", got)
+	}
+	if got := partyActionExpectation(2); got != 2.4 {
+		t.Fatalf("duo action expectation = %v, want 2.4", got)
+	}
+	for n := 3; n <= 5; n++ {
+		if got, want := partyActionExpectation(n), float64(2*n-1); got != want {
+			t.Fatalf("party of %d: action expectation = %v, want %v", n, got, want)
+		}
+	}
+	if got := partyEnemyHPScale(3); got != 1.15 {
+		t.Fatalf("party HP scale = %v, want 1.15", got)
+	}
+	// int(200*1.15) truncates 229.99… to 229; the 1-HP floor is immaterial.
+	if got := scaledEnemyMaxHP(200, 3); got != 229 {
+		t.Fatalf("party enemy HP = %d, want 229 (trunc 200*1.15)", got)
+	}
+}
+
+// P8: the enemy's action economy scales with the roster. A party of N faces up to
+// N attack-actions a round, each re-targeted, so the enemy's damage spreads across
+// the roster instead of pinning one seat — the 1/N² exposure that made P6e's party
+// a 100%-clear faceroll. Solo stays at exactly one swing a round, the pre-party
+// behaviour the characterization golden pins.
+func TestSimulateParty_EnemyActionEconomyScalesWithRoster(t *testing.T) {
+	enemyRollsPerRound := func(res PartyCombatResult) map[int]int {
+		perRound := map[int]int{}
+		for _, e := range res.Events {
+			if e.Actor == "enemy" && e.Roll > 0 {
+				perRound[e.Round]++
+			}
+		}
+		return perRound
+	}
+
+	// Solo: never more than one enemy swing in a round.
+	soloTank := baseEnemy()
+	soloTank.Stats.MaxHP = 5000
+	solo := simulatePartyWithRNG(
+		[]Combatant{basePlayer()}, soloTank, dungeonCombatPhases, seededRNG(23))
+	if len(enemyRollsPerRound(solo)) == 0 {
+		t.Fatal("solo: the enemy never attacked")
+	}
+	for round, n := range enemyRollsPerRound(solo) {
+		if n > 1 {
+			t.Fatalf("solo round %d: enemy swung %d times, want at most 1", round, n)
+		}
+	}
+
+	// Party of 3: no round exceeds the roster's action budget, and at least one
+	// round sees more than one swing — the enemy is really taking extra actions.
+	tank := baseEnemy()
+	tank.Stats.MaxHP = 5000
+	party := simulatePartyWithRNG(
+		[]Combatant{basePlayer(), basePlayer(), basePlayer()}, tank, dungeonCombatPhases, seededRNG(23))
+	budget := int(partyActionExpectation(3))
+	if partyActionExpectation(3) > float64(budget) {
+		budget++ // ceil: the coin-flip round can add one action
+	}
+	sawMulti := false
+	for round, n := range enemyRollsPerRound(party) {
+		if n > budget {
+			t.Fatalf("party round %d: enemy swung %d times, over the %d-action budget", round, n, budget)
+		}
+		if n > 1 {
+			sawMulti = true
+		}
+	}
+	if !sawMulti {
+		t.Fatal("a party of 3 never faced more than one enemy swing in a round — action economy did not scale")
+	}
+}
+
+// Over many seeds the enemy must spread its attention across the roster, or
+// "targeting" is really "always seat 0" and members take no risk.
+func TestSimulateParty_EnemySpreadsItsTargetsAcrossTheRoster(t *testing.T) {
+	hit := map[int]bool{}
+	for seed := uint64(1); seed <= 30; seed++ {
+		tank := baseEnemy()
+		tank.Stats.MaxHP = 5000
+		res := simulatePartyWithRNG(
+			[]Combatant{basePlayer(), basePlayer(), basePlayer()}, tank, dungeonCombatPhases, seededRNG(seed))
+		for _, e := range res.Events {
+			if e.Actor == "enemy" && e.Roll > 0 {
+				hit[e.Seat] = true
+			}
+		}
+	}
+	for seat := range 3 {
+		if !hit[seat] {
+			t.Fatalf("seat %d was never targeted across 30 seeds — the enemy is not really choosing", seat)
+		}
+	}
+}
+
+// Per-seat close-out reads its own events, not the party's. If eventsForSeat
+// leaked, a member's potions would be burned for the leader's heals.
+func TestEventsForSeat_PartitionsTheLog(t *testing.T) {
+	events := []CombatEvent{
+		{Action: "heal_item", Seat: 0},
+		{Action: "heal_item", Seat: 1},
+		{Action: "heal_item", Seat: 1},
+		{Action: "regen_tick"}, // unstamped: reads as the leader's
+	}
+	if got := len(eventsForSeat(events, 0)); got != 2 {
+		t.Fatalf("seat 0 saw %d events, want 2", got)
+	}
+	if got := countHealEventsFired(CombatResult{Events: eventsForSeat(events, 1)}); got != 2 {
+		t.Fatalf("seat 1 fired %d heal items, want 2", got)
+	}
+	if got := countHealEventsFired(CombatResult{Events: eventsForSeat(events, 0)}); got != 1 {
+		t.Fatalf("seat 0 fired %d heal items, want 1", got)
+	}
+}
+
+// A party that wins with a casualty is a win, and the casualty is still a
+// casualty: survival is read per seat off HP, never off the fight's outcome.
+func TestAnySurvivor_ReadsHPNotOutcome(t *testing.T) {
+	res := PartyCombatResult{
+		PlayerWon: true,
+		Seats: []CombatResult{
+			{PlayerEndHP: 12},
+			{PlayerEndHP: 0},
+			{PlayerEndHP: 3},
+		},
+	}
+	if !res.AnySurvivor() {
+		t.Fatal("AnySurvivor said nobody lived")
+	}
+
+	// A won fight nobody walked away from is still nobody walking away.
+	wiped := PartyCombatResult{PlayerWon: true, Seats: []CombatResult{{PlayerEndHP: 0}}}
+	if wiped.AnySurvivor() {
+		t.Fatal("AnySurvivor counted a downed seat as standing")
+	}
+}

internal/plugin/combat_grim_harvest_turn_test.go

@@ -0,0 +1,232 @@
+package plugin
+
+import (
+	"testing"
+
+	"maunium.net/go/mautrix/id"
+)
+
+// Grim Harvest on the turn-based surface.
+//
+// The auto-resolve path stashes the killing spell's slot level on the
+// fight-start CombatModifiers, where the close-out reads it. A turn-based fight
+// has nowhere to keep that: it rebuilds its combatants from the session row on
+// every !attack / !cast. resolveTurnSpell computed the stash into a local mod
+// set and dropped it on the floor, so a Necromancy Mage who killed with a spell
+// never healed — on a class that already trails.
+//
+// The stash now rides on the casting seat's ActorStatuses, and the close-out
+// asks whether the *last* spell_cast is the one that dropped the enemy to 0.
+//
+// (Empowered Evocation and Overchannel were never broken here: they only move
+// mods.SpellPreDamage, which resolveTurnSpell already returns as EnemyDamage.)
+
+// necromancer is a Mage who has reached L5 Grim Harvest.
+func necromancer(t *testing.T, uid id.UserID, level int) *DnDCharacter {
+	t.Helper()
+	if err := createAdvCharacter(uid, string(uid)); err != nil {
+		t.Fatal(err)
+	}
+	c := &DnDCharacter{
+		UserID: uid, Race: RaceHuman, Class: ClassMage, Subclass: SubclassNecromancy, Level: level,
+		STR: 8, DEX: 12, CON: 12, INT: 16, WIS: 10, CHA: 10,
+		HPMax: 30, HPCurrent: 10, ArmorClass: 12,
+	}
+	if err := SaveDnDCharacter(c); err != nil {
+		t.Fatal(err)
+	}
+	return c
+}
+
+// tough is a stat block a spell can be cast at without any of it mattering.
+func tough() CombatStats { return CombatStats{MaxHP: 40, AC: 10} }
+
+// ── the leak itself ──────────────────────────────────────────────────────────
+
+// resolveTurnSpell must hand the stash back to its caller. Before this, the
+// slot level lived and died inside the function.
+func TestResolveTurnSpell_CarriesTheGrimHarvestStashOut(t *testing.T) {
+	c := &DnDCharacter{Class: ClassMage, Subclass: SubclassNecromancy, Level: 5, INT: 16}
+
+	// magic_missile: auto-hit, force damage, upcast to a 3rd-level slot.
+	spell, _ := lookupSpell("magic_missile")
+	enemy := tough()
+	out, ok := resolveTurnSpell(c, spell, 3, &enemy)
+	if !ok {
+		t.Fatal("magic_missile should be a supported turn spell")
+	}
+	if out.GrimHarvestSlot != 3 {
+		t.Errorf("GrimHarvestSlot = %d, want 3 (the slot it was cast at)", out.GrimHarvestSlot)
+	}
+	if out.GrimHarvestNecrotic {
+		t.Error("magic_missile deals force damage — Necrotic should be false")
+	}
+
+	// blight: auto-hit, necrotic — the flag that triples the heal.
+	spell, _ = lookupSpell("blight")
+	enemy = tough()
+	out, _ = resolveTurnSpell(c, spell, 4, &enemy)
+	if out.GrimHarvestSlot != 4 || !out.GrimHarvestNecrotic {
+		t.Errorf("blight L4: slot=%d necrotic=%v, want 4/true", out.GrimHarvestSlot, out.GrimHarvestNecrotic)
+	}
+}
+
+// Nobody else stashes. A Mage below L5 has not learned the harvest, and an
+// Evocation Mage never will.
+func TestResolveTurnSpell_NoStashForAnyoneElse(t *testing.T) {
+	spell, _ := lookupSpell("magic_missile")
+	for _, c := range []*DnDCharacter{
+		{Class: ClassMage, Subclass: SubclassNecromancy, Level: 4, INT: 16},
+		{Class: ClassMage, Subclass: SubclassEvocation, Level: 12, INT: 16},
+		{Class: ClassSorcerer, Level: 12, CHA: 16},
+	} {
+		enemy := tough()
+		out, _ := resolveTurnSpell(c, spell, 3, &enemy)
+		if out.GrimHarvestSlot != 0 {
+			t.Errorf("%s/%s L%d stashed slot %d, want 0",
+				c.Class, c.Subclass, c.Level, out.GrimHarvestSlot)
+		}
+	}
+}
+
+// ── which cast counts ────────────────────────────────────────────────────────
+
+// The killing-blow check used to break on the first spell_cast it saw. In a
+// turn-based fight the mage casts every round, so the first one is an opening
+// cantrip that left the enemy standing — and it vetoed the heal the killing
+// spell had earned. It is the last cast that has to be lethal.
+func TestGrimHarvestHeal_ReadsTheLastCastNotTheFirst(t *testing.T) {
+	c := &DnDCharacter{Class: ClassMage, Subclass: SubclassNecromancy, Level: 5, INT: 16}
+	mods := CombatModifiers{GrimHarvestSlot: 2, GrimHarvestNecrotic: true}
+
+	result := CombatResult{PlayerWon: true, Events: []CombatEvent{
+		{Round: 1, Action: "spell_cast", EnemyHP: 22}, // opening cantrip, enemy stands
+		{Round: 2, Action: "enemy_attack", EnemyHP: 22},
+		{Round: 2, Action: "spell_cast", EnemyHP: 0}, // this one killed it
+	}}
+	if got := grimHarvestHeal(c, result, mods); got != 6 {
+		t.Errorf("heal = %d, want 6 (3× a 2nd-level necrotic slot)", got)
+	}
+}
+
+// The mirror: the mage softened it up with a spell, then finished it with a
+// weapon. No spell landed the blow, so no harvest.
+func TestGrimHarvestHeal_WeaponKillAfterASpellDoesNotHarvest(t *testing.T) {
+	c := &DnDCharacter{Class: ClassMage, Subclass: SubclassNecromancy, Level: 5, INT: 16}
+	mods := CombatModifiers{GrimHarvestSlot: 2, GrimHarvestNecrotic: true}
+
+	result := CombatResult{PlayerWon: true, Events: []CombatEvent{
+		{Round: 1, Action: "spell_cast", EnemyHP: 9},
+		{Round: 2, Action: "player_attack", EnemyHP: 0},
+	}}
+	if got := grimHarvestHeal(c, result, mods); got != 0 {
+		t.Errorf("heal = %d, want 0 — the sword landed the blow, not the spell", got)
+	}
+}
+
+// ── the seam through the session ─────────────────────────────────────────────
+
+// The stash has to survive the round-trip the fight puts it through: parked on
+// the seat by the cast, carried across commit()'s snapshot, read back by the
+// close-out.
+func TestSeatFightStartMods_ReadsTheStashOffTheSeat(t *testing.T) {
+	setupEmptyTestDB(t)
+	uid := id.UserID("@seatstash:example.org")
+	c := necromancer(t, uid, 5)
+
+	sess := &CombatSession{UserID: string(uid), Status: CombatStatusWon}
+	sess.Statuses.GrimHarvestSlot = 3
+	sess.Statuses.GrimHarvestNecrotic = true
+
+	mods := seatFightStartMods(sess, 0, c)
+	if mods.GrimHarvestSlot != 3 || !mods.GrimHarvestNecrotic {
+		t.Fatalf("seatFightStartMods lost the stash: %+v", mods)
+	}
+
+	// snapshotActor rebuilds ActorStatuses from combatState each commit; fields
+	// with no combatState counterpart must be carried over from the prior
+	// snapshot, the way ArmedAbility is.
+	kept := snapshotActor(&actor{}, sess.Statuses.ActorStatuses)
+	if kept.GrimHarvestSlot != 3 || !kept.GrimHarvestNecrotic {
+		t.Errorf("commit() dropped the stash: %+v", kept)
+	}
+}
+
+// End to end at the close-out: a necromancer who ended the fight at 10/30 HP
+// with a lethal 2nd-level necrotic spell walks away with 6 HP back.
+func TestPostCombatBookkeepingForSeat_GrimHarvestHealsOnASpellKill(t *testing.T) {
+	setupEmptyTestDB(t)
+	uid := id.UserID("@harvest:example.org")
+	necromancer(t, uid, 5)
+
+	sess := &CombatSession{
+		UserID: string(uid), Status: CombatStatusWon, Round: 3,
+		PlayerHP: 10, PlayerHPMax: 30, EnemyHP: 0,
+		TurnLog: []CombatEvent{
+			{Round: 1, Action: "spell_cast", EnemyHP: 14},
+			{Round: 3, Action: "spell_cast", EnemyHP: 0},
+		},
+	}
+	sess.Statuses.GrimHarvestSlot = 2
+	sess.Statuses.GrimHarvestNecrotic = true
+
+	(&AdventurePlugin{}).postCombatBookkeepingForSeat(sess, 0)
+
+	got, _ := LoadDnDCharacter(uid)
+	if got.HPCurrent != 16 {
+		t.Errorf("HPCurrent = %d after a turn-based spell kill, want 16 (10 + 3×2)", got.HPCurrent)
+	}
+}
+
+// A seat with no stash — the mage never cast, or missed every time — is left
+// exactly as the fight left them.
+func TestPostCombatBookkeepingForSeat_NoStashNoHeal(t *testing.T) {
+	setupEmptyTestDB(t)
+	uid := id.UserID("@nostash:example.org")
+	necromancer(t, uid, 5)
+
+	sess := &CombatSession{
+		UserID: string(uid), Status: CombatStatusWon, Round: 2,
+		PlayerHP: 10, PlayerHPMax: 30, EnemyHP: 0,
+		TurnLog: []CombatEvent{{Round: 2, Action: "player_attack", EnemyHP: 0}},
+	}
+	(&AdventurePlugin{}).postCombatBookkeepingForSeat(sess, 0)
+
+	got, _ := LoadDnDCharacter(uid)
+	if got.HPCurrent != 10 {
+		t.Errorf("HPCurrent = %d, want 10 — nothing was stashed", got.HPCurrent)
+	}
+}
+
+// Party fights: the stash is per-seat, so seat 1's harvest cannot heal seat 0.
+// This is the same class of bug P5 fixed for mid-fight buffs.
+func TestGrimHarvestStash_IsPerSeat(t *testing.T) {
+	setupEmptyTestDB(t)
+	leader, member := id.UserID("@leader:example.org"), id.UserID("@member:example.org")
+	fightTestChar(t, leader, 30)
+	necromancer(t, member, 5)
+
+	sess := &CombatSession{
+		UserID: string(leader), Status: CombatStatusWon, Round: 2,
+		PlayerHP: 20, PlayerHPMax: 30, EnemyHP: 0,
+		Participants: []CombatParticipant{{Seat: 1, UserID: string(member), HP: 10, HPMax: 30}},
+		TurnLog: []CombatEvent{
+			{Round: 2, Seat: 1, Action: "spell_cast", EnemyHP: 0},
+		},
+	}
+	sess.Participants[0].Statuses.GrimHarvestSlot = 2
+	sess.Participants[0].Statuses.GrimHarvestNecrotic = true
+
+	p := &AdventurePlugin{}
+	p.postCombatBookkeepingForSeat(sess, 0)
+	p.postCombatBookkeepingForSeat(sess, 1)
+
+	gotLeader, _ := LoadDnDCharacter(leader)
+	if gotLeader.HPCurrent != 30 {
+		t.Errorf("leader HPCurrent = %d, want 30 — the member's harvest is not theirs", gotLeader.HPCurrent)
+	}
+	gotMember, _ := LoadDnDCharacter(member)
+	if gotMember.HPCurrent != 16 {
+		t.Errorf("member HPCurrent = %d, want 16 (10 + 3×2)", gotMember.HPCurrent)
+	}
+}

internal/plugin/combat_misty_turn_test.go

@@ -0,0 +1,169 @@
+package plugin
+
+import (
+	"math/rand/v2"
+	"testing"
+)
+
+// Misty's two round-end procs on the turn-based surface.
+//
+// Both were built onto every turn-based combatant by DerivePlayerStats and then
+// never read: stepRoundEnd had no counterpart to endOfRoundForSeat. The buff was
+// simply lost. The debuff was an exploit — a player who declined Misty escaped
+// her crowd entirely by fighting with !attack instead of letting the room
+// auto-resolve, which needed no discovery at all.
+//
+// seatEndOfRound is the shared hook. These pin that it fires, that it cannot be
+// dodged, and that a character with no Misty history is not touched at all —
+// the property that keeps the sim corpus and the golden file still.
+
+// mistyState seats one combatant at hp, cursor armed, with a seeded RNG.
+func mistyState(t *testing.T, player *Combatant, hp int) *combatState {
+	t.Helper()
+	st := testCombatState(hp, 100, 1, rand.New(rand.NewPCG(7, 7)))
+	st.actor.c = player
+	st.actor.hpMax = player.Stats.MaxHP
+	return st
+}
+
+// The two procs at certainty, so no test depends on a roll.
+func mistyCursed(maxHP, dmg int) *Combatant {
+	return &Combatant{
+		Name:  "Cursed",
+		Stats: CombatStats{MaxHP: maxHP, AC: 10},
+		Mods:  CombatModifiers{CrowdRevengeProc: 1.0, CrowdRevengeDmg: dmg},
+	}
+}
+
+func mistyBuffed(maxHP, heal int) *Combatant {
+	return &Combatant{
+		Name:  "Buffed",
+		Stats: CombatStats{MaxHP: maxHP, AC: 10},
+		Mods:  CombatModifiers{MistyHealProc: 1.0, MistyHealAmt: heal},
+	}
+}
+
+// ── the exploit ──────────────────────────────────────────────────────────────
+
+// The debuff must land at round end in a manual fight, exactly as it does when
+// the room auto-resolves. Before seatEndOfRound, !attack was a clean escape.
+func TestSeatEndOfRound_CrowdRevengeCannotBeDodgedByFightingManually(t *testing.T) {
+	st := mistyState(t, mistyCursed(40, 6), 40)
+	over := seatEndOfRound(st, st.c, CombatPhaseRoundEnd, &CombatResult{})
+
+	if over {
+		t.Fatal("a 6-damage swing against 40 HP should not end the fight")
+	}
+	if st.playerHP != 34 {
+		t.Errorf("playerHP = %d, want 34 — Misty's crowd took its swing", st.playerHP)
+	}
+	if !hasAction(st.events, "crowd_revenge") {
+		t.Error("no crowd_revenge event on the log")
+	}
+}
+
+// The debuff can be lethal, and a lethal one with nobody else standing ends the
+// fight rather than leaving a corpse to take the next round's turn.
+func TestSeatEndOfRound_CrowdRevengeCanEndASoloFight(t *testing.T) {
+	st := mistyState(t, mistyCursed(40, 30), 3)
+	over := seatEndOfRound(st, st.c, CombatPhaseRoundEnd, &CombatResult{})
+
+	if st.playerHP != 0 {
+		t.Fatalf("playerHP = %d, want 0", st.playerHP)
+	}
+	if !over {
+		t.Error("a solo character dropped by the crowd should end the fight")
+	}
+}
+
+// ── the buff ─────────────────────────────────────────────────────────────────
+
+// The heal fires, caps at max HP, and marks the result so the achievement can
+// be granted.
+func TestSeatEndOfRound_MistyHealFiresAndCaps(t *testing.T) {
+	st := mistyState(t, mistyBuffed(40, 12), 34)
+	var res CombatResult
+	seatEndOfRound(st, st.c, CombatPhaseRoundEnd, &res)
+
+	if st.playerHP != 40 {
+		t.Errorf("playerHP = %d, want 40 — the heal caps at max HP", st.playerHP)
+	}
+	if !res.MistyHealed {
+		t.Error("MistyHealed flag not set")
+	}
+	if !hasAction(st.events, "misty_heal") {
+		t.Error("no misty_heal event on the log")
+	}
+}
+
+// A character the crowd just dropped is not then healed back up by the same
+// hook. The heal is for the living.
+func TestSeatEndOfRound_NoHealForACharacterTheCrowdJustDropped(t *testing.T) {
+	c := mistyCursed(40, 40)
+	c.Mods.MistyHealProc = 1.0
+	c.Mods.MistyHealAmt = 20
+
+	st := mistyState(t, c, 10)
+	st.actors = append(st.actors, &actor{playerHP: 5}) // an ally keeps the fight alive
+	over := seatEndOfRound(st, st.c, CombatPhaseRoundEnd, &CombatResult{})
+
+	if over {
+		t.Fatal("an ally is still standing — the fight is not over")
+	}
+	if st.playerHP != 0 {
+		t.Errorf("playerHP = %d, want 0 — the heal must not resurrect them", st.playerHP)
+	}
+	if hasAction(st.events, "misty_heal") {
+		t.Error("misty_heal fired on a downed character")
+	}
+}
+
+// ── the property that protects the corpus ────────────────────────────────────
+
+// A character with no Misty history is untouched: no HP change, no events, and
+// — because both procs short-circuit before st.randFloat() — no dice drawn. If
+// the hook drew even one float, every simulated fight would diverge and
+// combat_characterization.golden would move.
+func TestSeatEndOfRound_UnbuffedCharacterIsUntouchedAndDrawsNoDice(t *testing.T) {
+	plain := &Combatant{Name: "Plain", Stats: CombatStats{MaxHP: 40, AC: 10}}
+
+	st := mistyState(t, plain, 40)
+	control := mistyState(t, plain, 40) // same seed, never passed to the hook
+
+	if over := seatEndOfRound(st, st.c, CombatPhaseRoundEnd, &CombatResult{}); over {
+		t.Fatal("an unbuffed character cannot be dropped by a hook that does nothing")
+	}
+	if st.playerHP != 40 || len(st.events) != 0 {
+		t.Errorf("unbuffed character was touched: hp=%d events=%d", st.playerHP, len(st.events))
+	}
+	// The RNG streams must still be in lockstep: the hook consumed nothing.
+	if got, want := st.randFloat(), control.randFloat(); got != want {
+		t.Errorf("seatEndOfRound consumed RNG: next float %v, want %v", got, want)
+	}
+}
+
+// ── the wiring ───────────────────────────────────────────────────────────────
+
+// The unit tests above call seatEndOfRound directly, which proves the hook is
+// correct but not that stepRoundEnd calls it. This drives the real session API
+// through a round_end step. Comment the call out of stepRoundEnd and this test
+// reports PlayerHP=40 — the exploit, exactly as it shipped.
+func TestStepRoundEnd_WiresSeatEndOfRound(t *testing.T) {
+	setupEmptyTestDB(t)
+	player := mistyCursed(40, 6)
+	enemy := &Combatant{Name: "Target", Stats: CombatStats{MaxHP: 100, AC: 10}}
+	sess := &CombatSession{
+		SessionID: "wiring", UserID: "@u:example.org", Status: CombatStatusActive,
+		PlayerHP: 40, PlayerHPMax: 40, EnemyHP: 100,
+		Phase: CombatPhaseRoundEnd, Round: 1,
+	}
+	if _, err := advanceCombatSession(sess, player, enemy, PlayerAction{}); err != nil {
+		t.Fatal(err)
+	}
+	if sess.PlayerHP != 34 {
+		t.Errorf("PlayerHP = %d, want 34 — stepRoundEnd never ran the hook", sess.PlayerHP)
+	}
+	if !hasAction(sess.TurnLog, "crowd_revenge") {
+		t.Error("no crowd_revenge event persisted to the session log")
+	}
+}

internal/plugin/combat_narrative.go

@@ -236,6 +236,12 @@ func renderEvent(e CombatEvent, playerName, enemyName string, result CombatResul
 	case "pet_attack":
 		return fmt.Sprintf(pickRand(narrativePetAttack), e.Damage)
 
+	case "spirit_weapon_strike":
+		return fmt.Sprintf(pickRand(narrativeSpiritWeapon), e.Damage)
+
+	case "concentration_tick":
+		return fmt.Sprintf(pickRand(narrativeConcentrationTick), e.Damage)
+
 	case "pet_deflect":
 		return pickRand(narrativePetDeflect)
 
@@ -326,9 +332,9 @@ func renderEvent(e CombatEvent, playerName, enemyName string, result CombatResul
 	case "survive_at_1":
 		return pickRand(narrativeSurvive)
 	case "stat_drain":
-		return pickRand(narrativeStatDrain)
+		return fmt.Sprintf(pickRand(narrativeStatDrain), e.Damage)
 	case "debuff":
-		return pickRand(narrativeDebuff)
+		return fmt.Sprintf(pickRand(narrativeDebuff), e.Damage)
 	case "max_hp_drain":
 		return fmt.Sprintf(pickRand(narrativeMaxHPDrain), e.Damage)
 
@@ -346,7 +352,7 @@ func renderEvent(e CombatEvent, playerName, enemyName string, result CombatResul
 	case "fear_resist":
 		return pickRand(narrativeFearResist)
 	case "ally_buff":
-		return pickRand(narrativeAllyBuff)
+		return fmt.Sprintf(pickRand(narrativeAllyBuff), e.Damage)
 
 	case "timeout":
 		return pickRand(narrativeTimeout)
@@ -526,6 +532,20 @@ var narrativePetAttack = []string{
 	"🐾 Your faithful companion lands a hit for %d damage. More faithful than accurate, but today both applied.",
 }
 
+var narrativeSpiritWeapon = []string{
+	"✨ The spectral mace swings on its own and lands for %d damage. Floating menace, well-balanced.",
+	"✨ Your spiritual weapon hovers, picks an angle, strikes — %d damage. No grip, all conviction.",
+	"✨ A glowing weapon arcs in from beside you. %d damage. The enemy keeps trying to track it. Cannot.",
+	"✨ The spectral blade flickers, then bites. %d damage. It does not tire. It does not blink.",
+}
+
+var narrativeConcentrationTick = []string{
+	"🌀 The lingering aura grinds the enemy down — %d damage. Still humming. Still hungry.",
+	"🌀 Your spell hasn't let go: the spirits sweep through again for %d damage.",
+	"🌀 The radiant field pulses once more — %d damage. Concentration holds.",
+	"🌀 The enemy steps wrong and the standing magic answers, %d damage. It does not move on.",
+}
+
 var narrativePetDeflect = []string{
 	"🐾 Your pet intercepts the blow. Damage halved. Your pet is now your best piece of equipment.",
 	"🐾 Your pet pushes you aside at the last second. Impact reduced. You did not ask to be pushed. Results speak for themselves.",
@@ -854,16 +874,46 @@ var narrativeCloseLoss = []string{
 // handful of events, and across a long boss fight the picker resetting each
 // round reads as variety rather than staleness.
 func RenderTurnRound(events []CombatEvent, playerName, enemyName string) string {
+	return RenderPartyTurnRound(events, []string{playerName}, enemyName, 0)
+}
+
+// RenderPartyTurnRound renders a round for one member of a party — the reader at
+// viewerSeat.
+//
+// The turn narration pool is written in the second person: "You score 9 damage",
+// "A hit gets through your guard". That is exactly right for the reader's own
+// events and exactly wrong for everybody else's, so this splits on the event's
+// Seat. The reader's own events go through the same flavor pool a solo fight
+// uses, untouched; an ally's are summarised third-person by renderAllySeatEvent.
+//
+// A solo fight has one seat, every event belongs to it, and the reader is it —
+// so it renders the same bytes it always has.
+func RenderPartyTurnRound(events []CombatEvent, seatNames []string, enemyName string, viewerSeat int) string {
+	if len(seatNames) == 0 {
+		seatNames = []string{"You"}
+	}
+	seatName := func(seat int) string {
+		if seat > 0 && seat < len(seatNames) {
+			return seatNames[seat]
+		}
+		return seatNames[0]
+	}
+
 	picker := newActionPicker()
 	var lines []string
 	for _, e := range events {
-		line := renderTurnEvent(e, playerName, enemyName, picker)
+		var line string
+		if e.Seat == viewerSeat {
+			line = renderTurnEvent(e, seatName(e.Seat), enemyName, picker)
+			if roll := rollAnnotation(e); line != "" && roll != "" {
+				line += " " + roll
+			}
+		} else {
+			line = renderAllySeatEvent(e, seatName(e.Seat), enemyName)
+		}
 		if line == "" {
 			continue
 		}
-		if roll := rollAnnotation(e); roll != "" {
-			line += " " + roll
-		}
 		lines = append(lines, line)
 	}
 	if len(lines) == 0 {
@@ -872,6 +922,86 @@ func RenderTurnRound(events []CombatEvent, playerName, enemyName string) string
 	return strings.Join(lines, "\n")
 }
 
+// renderAllySeatEvent summarises one event belonging to somebody else's
+// character, for a party member's DM. Terse on purpose: the reader wants the
+// shape of the round, not three sentences of flavor about their friend's pet.
+// Anything not worth a line in someone else's DM renders as "".
+func renderAllySeatEvent(e CombatEvent, name, enemyName string) string {
+	who := "**" + name + "**"
+	down := func(line string) string {
+		if e.PlayerHP <= 0 {
+			return line + " " + who + " is down."
+		}
+		return line
+	}
+	switch e.Action {
+	case "hit":
+		if e.Actor == "player" {
+			return fmt.Sprintf("%s hits %s for %d.", who, enemyName, e.Damage)
+		}
+		return down(fmt.Sprintf("%s hits %s for %d.", enemyName, who, e.Damage))
+	case "crit":
+		if e.Actor == "player" {
+			return fmt.Sprintf("%s crits %s for %d!", who, enemyName, e.Damage)
+		}
+		return down(fmt.Sprintf("%s crits %s for %d!", enemyName, who, e.Damage))
+	case "miss":
+		if e.Actor == "player" {
+			return fmt.Sprintf("%s misses.", who)
+		}
+		return fmt.Sprintf("%s misses %s.", enemyName, who)
+	case "block":
+		// renderEvent's convention: Actor "player" means the *enemy* blocked the
+		// player's swing, and vice versa.
+		if e.Actor == "player" {
+			return fmt.Sprintf("%s blocks %s (%d).", enemyName, who, e.Damage)
+		}
+		return fmt.Sprintf("%s blocks (%d).", who, e.Damage)
+	case "spell_cast":
+		label := e.Desc
+		if label == "" {
+			label = "a spell"
+		}
+		return fmt.Sprintf("%s casts %s.", who, label)
+	case "use_consumable":
+		label := e.Desc
+		if label == "" {
+			label = "an item"
+		}
+		return fmt.Sprintf("%s uses %s.", who, label)
+	case "pet_attack":
+		return fmt.Sprintf("🐾 %s's pet strikes for %d.", who, e.Damage)
+	case "spirit_weapon_strike":
+		return fmt.Sprintf("%s's spirit weapon strikes for %d.", who, e.Damage)
+	case "concentration_tick":
+		return fmt.Sprintf("%s's aura burns %s for %d.", who, enemyName, e.Damage)
+	case "poison_tick":
+		return down(fmt.Sprintf("☠️ %s takes %d from poison.", who, e.Damage))
+	case "environmental":
+		return down(fmt.Sprintf("%s takes %d from the room.", who, e.Damage))
+	case "crowd_revenge":
+		// Deliberately unattributed. An ally sees the damage land — silence
+		// would read as HP vanishing — but Misty's grudge is the owner's own
+		// discovery, and naming her here would spoil it for the whole party.
+		// Same reason misty_heal below reads as a plain recovery.
+		return down(fmt.Sprintf("%s takes %d.", who, e.Damage))
+	case "flat_damage":
+		return fmt.Sprintf("%s deals %d.", who, e.Damage)
+	case "heal_item", "misty_heal":
+		return fmt.Sprintf("%s recovers %d.", who, e.Damage)
+	case "death_save":
+		return fmt.Sprintf("%s clings on.", who)
+	case "stun", "stunned":
+		return fmt.Sprintf("%s is stunned.", who)
+	case "flee":
+		return fmt.Sprintf("%s breaks off.", who)
+	default:
+		// Ward absorbs, spore misses, reflects, enrage cues: real, but noise in
+		// somebody else's DM. The owner sees them in full in their own.
+		return ""
+	}
+}
+
 func renderTurnEvent(e CombatEvent, playerName, enemyName string, picker *actionPicker) string {
 	switch e.Action {
 	case "flee":

internal/plugin/combat_narrative_drain_test.go

@@ -0,0 +1,24 @@
+package plugin
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestRenderEvent_StatefulDrainsFormatMagnitude is a regression test for the
+// leaked "%d" in stateful enemy-effect narration. stat_drain, debuff and
+// ally_buff carry their magnitude in CombatEvent.Damage and their flavor
+// pools contain a %d placeholder; renderEvent must fmt.Sprintf them rather
+// than emit the template raw (which surfaced "-%d damage" to players).
+func TestRenderEvent_StatefulDrainsFormatMagnitude(t *testing.T) {
+	for _, action := range []string{"stat_drain", "debuff", "ally_buff"} {
+		e := CombatEvent{Actor: "enemy", Action: action, Damage: 4}
+		out := renderEvent(e, "Rurina", "Shadow", CombatResult{}, newActionPicker())
+		if strings.Contains(out, "%") {
+			t.Errorf("%s: leaked format placeholder in output: %q", action, out)
+		}
+		if !strings.Contains(out, "4") {
+			t.Errorf("%s: expected magnitude 4 in output: %q", action, out)
+		}
+	}
+}