Release Healer Man 0.1.53

Release Healer Man 0.1.52
Release Healer Man 0.1.51
2026-09-18 12:32:51 -04:00 · 2026-09-18 09:34:59 -04:00 · 2026-09-17 18:01:29 -04:00 · 2026-09-17 13:33:55 -04:00 · 2026-09-17 11:36:54 -04:00
31 changed files with 1134 additions and 138 deletions
@@ -11,10 +11,11 @@ These rules apply to every change under this project root.

 ## Workspace and reference boundaries

- The active project root is `D:\Projects\HealerMan`. All implementation,
-  generated content, scripts, tests, builds, documentation, and validation for
-  this project belong here.
- `D:\Projects\wow-pvt-server-backups-2` is historical reference material only.
+- The active project root is the directory containing this `AGENTS.md`
+  (currently `F:\Projects\HealerMan`); do not assume a fixed drive letter. All
+  implementation, generated content, scripts, tests, builds, documentation, and
+  validation for this project belong here.
+- The sibling `../wow-pvt-server-backups-2` tree is historical reference material only.
  Inspect it only when old-server behavior, AzerothCore data, creature IDs,
  spells, encounters, maps, or assets are useful as source information.
 - Never treat `wow-pvt-server-backups-2` as the active project, primary checkout,
@@ -27,6 +28,22 @@ These rules apply to every change under this project root.
  structure as appropriate, and validate it through HealerMan's tests/build and
  playtest workflow.

+## Obsidian project memory
+
+- The separate Healer-Man knowledge vault lives at the sibling path
+  `../ObsidianNotes/ObsidianVault1`. Start at
+  `00 Home/Healer-Man Hub.md` and follow
+  `40 Agent Workflows/Agent Memory Protocol.md` for broad or cross-system work.
+- The code and tests in this repository remain authoritative. Check a note's
+  `last_verified` date and verify material claims against current code before
+  acting on them.
+- Update the relevant vault note in the same task when a change alters feature
+  behavior, architectural ownership, entry points, cross-file relationships,
+  invariants, or required validation. Use repository-relative code paths and
+  keep transient investigation details in the vault's `50 Worklog/` area.
+- The vault is its own Git repository. Review and commit its changes separately
+  from HealerMan changes; never stage one repository from the other.
+
 ## Dungeon report triage

 - For any request to inspect or fix current dungeon reports, start with
@@ -3545,3 +3545,56 @@ Vite's existing large-chunk advisory remains informational.
  errors; all five bodies and their equipped weapon/staff silhouettes rendered
  intact. Evidence is in
  `playtest-artifacts/dungeon-health-scaling/stockades-level-three.png`.
+
+## Balance Lab healing done and received analytics (2026-09-17)
+
+- Raw Balance Lab member metrics now attribute effective healing to both the
+  caster and the party target. Party and suite reports expose healing done and
+  received per active second plus absolute totals; self-heals count on both
+  sides of the attribution.
+- The GM overview adds separate **Healing done by class/spec** and **Healing
+  received by class/spec** graphs. The class/spec table can display and sort
+  both rates and totals. Older saved reports remain readable but show no target
+  healing until they are rerun.
+- All six Python controller tests and the production build passed. A live
+  one-seed, 15-second Eck the Ferocious run recorded the Holy Paladin's 867
+  effective healing as 57.8 HPS done and the Blood Death Knight's same 867 as
+  57.8 HPS received. A matching automatic-suite run verified the new JSON and
+  CSV fields under `playtest-artifacts/balance-lab-healing-suite/`.
+
+## Balance Lab deterministic class/spec coverage (2026-09-17)
+
+- Automatic sweeps now offer **Random parties**, **All specs**, and **Specific
+  specs**. All-spec mode derives the minimum valid 1-tank/1-healer/3-damage
+  party set that covers every available build. Specific mode guarantees every
+  selected build appears and uses distinct compatible fillers for missing
+  roles; selected builds are not reused as fillers when alternatives exist.
+- A real level-20 WoW all-spec sweep against Eck the Ferocious generated eight
+  distinct parties and placed all 31 catalog builds in `suite-report.json`
+  with zero missing. The combined catalog audit found 70 CoA builds requiring
+  16 coverage parties and 16 RoM builds requiring four; every source exposes
+  enough tank, healer, and damage builds for valid coverage parties.
+- Eight Python controller tests, nine Balance Lab service tests, two server
+  integration tests, and the production build passed. Production Edge
+  automation verified the All Specs estimate, selected Paladin Holy through the
+  Specific Specs picker, completed the server job, rendered all seven overview
+  graphs, and passed desktop plus 480×900 overflow checks without browser
+  errors. Evidence is in `playtest-artifacts/balance-lab/02-server-job-config.png`
+  and `playtest-artifacts/balance-lab/03-server-job-complete.png`.
+
+## Balance Lab class/spec ability damage drill-down (2026-09-17)
+
+- Every class/spec row now exposes **View ability damage** when ability telemetry
+  exists. It opens the Abilities tab on that exact source/build, clears
+  conflicting search and role filters, and defaults to abilities with positive
+  effective damage sorted highest first.
+- The drill-down graph and table retain ability name/ID, casts, casts per minute,
+  hits, effective/raw damage, damage share, DPS, and damage per hit. Healing,
+  overheal, absorbs, usage, and unused-ability filters remain available.
+- The production build passed. A real five-second level-20 WoW run against Eck
+  the Ferocious opened a Death Knight Unholy row through the new action and
+  verified positive effective ability damage plus the expected cast, damage
+  share, and DPS columns. Desktop and 480×900 checks passed with no browser
+  errors. Evidence is in
+  `playtest-artifacts/balance-lab/04b-ability-breakdown.png` and
+  `playtest-artifacts/balance-lab/06-mobile-abilities.png`.
@@ -18,6 +18,14 @@ approval before it commits, pushes `main`, builds the signed APK, and publishes
 the Gitea release. Signing passwords and the Gitea token are passed to the
 child process in memory rather than on its command line.

+If a content, server, normal-application, or shelved-application test command
+fails, the visual manager pauses with the failed command, exit code, and recent
+test output. **Stop Release** remains the safe default, but **Continue Anyway**
+allows an intentional override and records that decision in the release log.
+Build, content-publication, Git, signing, and APK-publication failures are not
+overridable and still stop the workflow. The manual procedure below remains
+fail-closed.
+
 Before changing versions or running the longer test/build sequence, the manager
 runs an isolated release-candidate check. It validates tracked and untracked
 files without changing the real Git index, so extra blank lines at EOF and
@@ -25,10 +25,28 @@ The prompt selects:
 1. one random party, five manual members, or an automatic multi-party sweep;
 2. a WoW, CoA, or RoM party catalog; automatic mode can select all three;
 3. a level from 1 through 80;
-4. how many unique 1-tank/1-healer/3-damage configurations to generate per source;
-5. all bosses, WoW bosses, RoM bosses, or a searchable multi-boss selection;
-6. how many deterministic simulations to run for every party/boss pairing; and
-7. the maximum duration of each fight.
+4. random parties, guaranteed coverage of all class/spec builds, or a
+   searchable selection of specific class/spec builds;
+5. how many unique 1-tank/1-healer/3-damage configurations to generate per
+   source when random selection is used;
+6. all bosses, WoW bosses, RoM bosses, or a searchable multi-boss selection;
+7. how many deterministic simulations to run for every party/boss pairing; and
+8. the maximum duration of each fight.
+
+Automatic class/spec selection has three strategies:
+
+- **Random parties** preserves the original seeded behavior and generates the
+  requested number of unique parties per source.
+- **All specs** creates the minimum deterministic set of valid parties needed
+  to include every available class/spec build for the selected WoW, CoA, or
+  RoM source at least once.
+- **Specific specs** treats each selected build as required coverage and fills
+  the remaining tank, healer, and damage slots with distinct compatible builds.
+  When alternatives exist, required builds are not reused as fillers.
+
+Coverage parties always contain one tank, one healer, and three different
+damage builds. Their composition is deterministic for the party seed, and no
+build is duplicated inside one party.

 The active member is driven by the shared benchmark policy while the other four
 use the live companion AI. The healer is the default active member. Use
@@ -38,8 +56,10 @@ use the live companion AI. The healer is the default active member. Use

 A server-authorized GM sees **Balance Lab** directly underneath **GM Tools** on
 the main menu. That screen exposes the automatic sweep controls: party source,
-level, unique parties per source, simulations per party/boss, duration, random
-seed, boss category, and a searchable multi-boss picker.
+level, class/spec selection strategy, a searchable spec picker, simulations per
+party/boss, duration, random seed, boss category, and a searchable multi-boss
+picker. Random mode exposes the requested parties per source; coverage modes
+show the derived minimum party count before submission.

 **Run on server** sends only that allow-listed configuration to the authenticated
 GM API. The server places it in a one-at-a-time queue, launches the same Python
@@ -80,11 +100,14 @@ The dashboard includes:
 - party damage applied directly to each boss;
 - average successful kill time;
 - boss DPS and damage taken for every class/specialization;
+- effective healing done and effective healing received per second for every
+  class/specialization;
 - complete boss tables with pressure versus median, total incoming damage,
  defeat/wipe rates, deaths, and health;
- complete class/spec tables with total and boss DPS, HPS, DTPS, absolute
-  damage taken, damage/healing/absorb totals, deaths, and source/role-median
-  tuning flags; and
+- complete class/spec tables with total and boss DPS, healing done/received per
+  second, DTPS, absolute damage taken, healing done/received and absorb totals,
+  deaths, source/role-median tuning flags, and a direct ability-damage
+  drill-down for every build; and
 - a complete Abilities tab with learned/available abilities (including zero-use
  rows), exact runtime IDs, AI categories, active-run coverage, casts, hits,
  casts per minute, effective/raw damage, DPS, damage share, damage per hit,
@@ -96,7 +119,10 @@ The overview graphs intentionally show at most the 15 highest visible values so
 labels remain readable. They never discard report data: the Bosses, Class/spec,
 and Parties tabs retain every matching row. Search, party-source, boss-source,
 role, metric, and sort-direction controls filter the display without modifying
-the saved report.
+the saved report. **View ability damage** on a class/spec row opens the
+Abilities tab with that exact build selected, damaging abilities ranked by
+effective damage, and its casts, hits, DPS, damage share, and damage-per-hit
+details visible in the table. **Show all specs** clears that drill-down.

 Server requirements:

@@ -250,6 +276,12 @@ under `parties/<party-id>/` and adds these suite-level files:
  direct boss damage. Suite class/spec `dtps` is damage taken per active second;
  `totalDamageTaken` is the absolute healer/survivability burden across every
  included run.
+- Member `hps` is effective healing done per active second and excludes
+  overhealing. `hpsReceived` is effective healing received per active second,
+  attributed from each healing event's target (including self-heals).
+  `totalHealing` and `totalHealingReceived` are the corresponding absolute
+  values across the included runs. Reports created before target attribution
+  was added remain readable but require a rerun to populate healing received.
 - Ability `activeRuns` counts simulations with at least one cast, hit, damage,
  healing, overheal, or absorb event. `usageRate` divides that by every run for
  that build; `damageShare` divides the ability's effective damage by the
@@ -297,6 +329,21 @@ member. When a suspected class outlier could be policy-sensitive, rerun with a
 different `--active-slot`; do not compare active and companion results without
 noting that control-policy difference.

+Companion builds initialize every resource pool required by their learned
+abilities, not only the class's primary pool. Secondary Energy and Focus
+regenerate, and any companion with a Rage pool gains Rage from landed weapon
+attacks; this is what makes druid Cat and Bear rotations executable while Mana
+remains the class's primary resource. A completed companion cast resolves the
+member's currently learned rank before applying its effects, so cast-time spell
+damage and healing cannot fall back to rank one.
+
+`playerbots-inspired-v2` keeps level-10-and-up non-healer builds on their
+specialization's authored damage priority whenever that build knows a profile
+damage action. Reactive interrupts, taunts, control, and defenses still take
+precedence. Bear and Cat actions are isolated to their matching Feral specs;
+Overpower, Revenge, and Victory Rush require an explicitly modeled trigger;
+and Drain Soul, Hammer of Wrath, and Kill Shot obey their target-health gates.
+
 ## Code map

 - `scripts/balance_lab.py`: prompts, command-line parsing, random/manual/automatic
@@ -319,8 +366,8 @@ noting that control-policy difference.
 - `src/game/benchmark/benchmarkBuilds.ts`: selectable spec builds and legal
  talent allocation. The older canonical cohort remains unchanged.
 - `src/game/partyStore.ts`: `createConfiguredPartyMember`, the narrow factory
-  that preserves production stats, equipment, resources, and appearance for an
-  exact companion.
+  that preserves production stats, equipment, all learned-ability resource
+  pools, and appearance for an exact companion.
 - `src/game/bossTesting.ts`: the authoritative all-boss catalog and isolated
  room construction.

@@ -1,12 +1,12 @@
 {
  "name": "healer-man",
-  "version": "0.1.49",
+  "version": "0.1.53",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "healer-man",
-      "version": "0.1.49",
+      "version": "0.1.53",
      "dependencies": {
        "@capacitor/android": "8.4.1",
        "@capacitor/core": "8.4.1",
@@ -1,7 +1,7 @@
 {
  "name": "healer-man",
  "private": true,
-  "version": "0.1.49",
+  "version": "0.1.53",
  "type": "module",
  "scripts": {
    "dev": "vite --host 0.0.0.0",
@@ -1,4 +1,4 @@
 {
-  "versionName": "0.1.49",
-  "versionCode": 1049
+  "versionName": "0.1.53",
+  "versionCode": 1053
 }
@@ -90,6 +90,7 @@ interface MutableMemberMetrics {
  healing: number;
  rawHealing: number;
  overheal: number;
+  healingReceived: number;
  absorbs: number;
  damageTaken: number;
  rawDamageTaken: number;
@@ -286,6 +287,8 @@ function serializedMember(
    rawHealing: metrics.rawHealing,
    overheal: metrics.overheal,
    hps: metrics.healing / Math.max(0.1, activeSeconds),
+    healingReceived: metrics.healingReceived,
+    hpsReceived: metrics.healingReceived / Math.max(0.1, activeSeconds),
    absorbs: metrics.absorbs,
    damageTaken: metrics.damageTaken,
    rawDamageTaken: metrics.rawDamageTaken,
@@ -356,6 +359,7 @@ async function runBoss(
    healing: 0,
    rawHealing: 0,
    overheal: 0,
+    healingReceived: 0,
    absorbs: 0,
    damageTaken: 0,
    rawDamageTaken: 0,
@@ -395,15 +399,18 @@ async function runBoss(
        ability.hits += 1;
        bossAbilities.set(key, ability);
      }
-    } else if (event.kind === "healing" && source) {
-      source.rawHealing += event.rawAmount;
-      source.healing += event.effectiveAmount;
-      source.overheal += event.overheal;
-      const ability = abilityMetrics(source, event.abilityId);
-      ability.rawHealing += event.rawAmount;
-      ability.effectiveHealing += event.effectiveAmount;
-      ability.overheal += event.overheal;
-      ability.hits += 1;
+    } else if (event.kind === "healing") {
+      if (source) {
+        source.rawHealing += event.rawAmount;
+        source.healing += event.effectiveAmount;
+        source.overheal += event.overheal;
+        const ability = abilityMetrics(source, event.abilityId);
+        ability.rawHealing += event.rawAmount;
+        ability.effectiveHealing += event.effectiveAmount;
+        ability.overheal += event.overheal;
+        ability.hits += 1;
+      }
+      if (target) target.healingReceived += event.effectiveAmount;
    } else if (event.kind === "absorb" && source) {
      source.absorbs += event.effectiveAmount;
      abilityMetrics(source, event.abilityId).absorbs += event.effectiveAmount;
@@ -195,6 +195,92 @@ def automatic_parties(
    return configurations


+def coverage_parties(
+    builds: Sequence[dict[str, Any]],
+    sources: Sequence[str],
+    selected_build_ids: Sequence[str] | None,
+    seed: int,
+) -> list[dict[str, Any]]:
+    """Build the minimum deterministic party set that covers every requested build."""
+    requested = set(selected_build_ids) if selected_build_ids is not None else None
+    offsets = {"wow": 100_000, "coa": 200_000, "rom": 300_000}
+    configurations: list[dict[str, Any]] = []
+    for source in sources:
+        source_builds = [build for build in builds if build["source"] == source]
+        targets = source_builds if requested is None else [
+            build for build in source_builds if build["id"] in requested
+        ]
+        if not targets:
+            continue
+        available_by_role: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        targets_by_role: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        for build in source_builds:
+            available_by_role[build["role"]].append(build)
+        for build in targets:
+            targets_by_role[build["role"]].append(build)
+        if not available_by_role["tank"] or not available_by_role["healer"] or len(available_by_role["damage"]) < 3:
+            raise SystemExit(
+                f"The {source} catalog does not expose enough tank, healer, and damage builds for a 1/1/3 party."
+            )
+        party_count = max(
+            1,
+            len(targets_by_role["tank"]),
+            len(targets_by_role["healer"]),
+            math.ceil(len(targets_by_role["damage"]) / 3),
+        )
+        generator = random.Random(seed + offsets[source])
+        for rows in (*available_by_role.values(), *targets_by_role.values()):
+            rows.sort(key=lambda build: build["id"])
+            generator.shuffle(rows)
+
+        def filler(role: str, party_index: int, slot_index: int, used: set[str]) -> dict[str, Any]:
+            pool = available_by_role[role]
+            start = (party_index * (3 if role == "damage" else 1) + slot_index) % len(pool)
+            for avoid_requested in (True, False):
+                for offset in range(len(pool)):
+                    candidate = pool[(start + offset) % len(pool)]
+                    if candidate["id"] in used:
+                        continue
+                    if avoid_requested and requested is not None and candidate["id"] in requested:
+                        continue
+                    return candidate
+            raise SystemExit(f"Could not fill a unique {role} slot for a {source} coverage party.")
+
+        for party_index in range(party_count):
+            used: set[str] = set()
+            tank = targets_by_role["tank"][party_index] if party_index < len(targets_by_role["tank"]) else filler(
+                "tank", party_index, 0, used
+            )
+            used.add(tank["id"])
+            healer = targets_by_role["healer"][party_index] if party_index < len(targets_by_role["healer"]) else filler(
+                "healer", party_index, 0, used
+            )
+            used.add(healer["id"])
+            damage = list(targets_by_role["damage"][party_index * 3:(party_index + 1) * 3])
+            used.update(build["id"] for build in damage)
+            while len(damage) < 3:
+                build = filler("damage", party_index, len(damage), used)
+                damage.append(build)
+                used.add(build["id"])
+            party = [tank, healer, *damage]
+            configurations.append({
+                "id": f"{source}-party-{party_index + 1:03d}",
+                "source": source,
+                "party": party,
+                "activeSlot": 1,
+            })
+    if not configurations:
+        raise SystemExit("No class/spec builds matched the requested coverage selection.")
+    return configurations
+
+
+def search_builds(query: str, builds: Sequence[dict[str, Any]]) -> list[dict[str, Any]]:
+    needle = normalized(query)
+    return [build for build in builds if needle in normalized(
+        f"{build['id']} {build['label']} {build['source']} {build['role']}"
+    )]
+
+
 def search_bosses(query: str, bosses: Sequence[dict[str, Any]]) -> list[dict[str, Any]]:
    needle = normalized(query)
    return [boss for boss in bosses if needle in normalized(
@@ -273,6 +359,43 @@ def prompt_specific_bosses(bosses: Sequence[dict[str, Any]]) -> list[str]:
        print(f"Selected bosses: {len(selected)}")


+def prompt_specific_builds(builds: Sequence[dict[str, Any]]) -> list[str]:
+    selected: dict[str, dict[str, Any]] = {}
+    print("\nClass/spec picker: search by class, specialization, role, source, or build ID.")
+    while True:
+        suffix = f" ({len(selected)} selected; type 'done' to finish)" if selected else ""
+        query = input(f"Class/spec search{suffix}: ").strip()
+        if query.casefold() == "done":
+            if selected:
+                return list(selected)
+            print("Select at least one class/spec first.")
+            continue
+        matches = search_builds(query, builds)
+        if not matches:
+            print("No class/spec builds matched that search.")
+            continue
+        if len(matches) > 50:
+            print(f"{len(matches)} builds matched. Use a more specific search (50 maximum per result page).")
+            continue
+        for index, build in enumerate(matches, 1):
+            marker = " [selected]" if build["id"] in selected else ""
+            print(f"  {index:>2}. {console_text(build['label'])} [{build['source']}]{marker}")
+        raw = input("Add numbers separated by commas, or 'all': ").strip().casefold()
+        if raw == "all":
+            indexes = list(range(len(matches)))
+        else:
+            try:
+                indexes = [int(entry.strip()) - 1 for entry in raw.split(",") if entry.strip()]
+            except ValueError:
+                indexes = []
+        if not indexes or any(index < 0 or index >= len(matches) for index in indexes):
+            print("Choose valid result numbers.")
+            continue
+        for index in indexes:
+            selected[matches[index]["id"]] = matches[index]
+        print(f"Selected class/spec builds: {len(selected)}")
+
+
 def interactive_arguments(
    args: argparse.Namespace,
    workspace: Path,
@@ -288,7 +411,11 @@ def interactive_arguments(
    if args.party_mode == "random":
        args.party_seed = prompt_integer("Random party seed", 1, -2_147_483_648, 2_147_483_647)
    elif args.party_mode == "automatic":
-        args.party_configurations = prompt_integer("Unique party configurations per source", 10, 1, 1_000)
+        args.spec_selection = prompt_choice("Class/spec selection", ("random", "all", "specific"), "all")
+        if args.spec_selection == "random":
+            args.party_configurations = prompt_integer("Unique party configurations per source", 10, 1, 1_000)
+        elif args.spec_selection == "specific":
+            args.spec = prompt_specific_builds(catalog["builds"])
        args.party_seed = prompt_integer("Automatic party seed", 1, -2_147_483_648, 2_147_483_647)
    else:
        print("\nAvailable members:")
@@ -320,7 +447,7 @@ def interactive_arguments(
 def weighted_rate(rows: Iterable[dict[str, Any]], amount: str) -> float:
    materialized = list(rows)
    seconds = sum(float(row["elapsedSeconds"]) for row in materialized)
-    return sum(float(row[amount]) for row in materialized) / max(0.1, seconds)
+    return sum(float(row.get(amount, 0)) for row in materialized) / max(0.1, seconds)


 def mean(values: Iterable[float]) -> float:
@@ -402,9 +529,11 @@ def aggregate(raw: dict[str, Any]) -> dict[str, Any]:
            "dps": weighted_rate(rows, "damage"),
            "bossDps": weighted_rate(rows, "bossDamage"),
            "hps": weighted_rate(rows, "healing"),
+            "hpsReceived": weighted_rate(rows, "healingReceived"),
            "dtps": weighted_rate(rows, "damageTaken"),
            "totalDamage": sum(row["damage"] for row in rows),
            "totalHealing": sum(row["healing"] for row in rows),
+            "totalHealingReceived": sum(row.get("healingReceived", 0) for row in rows),
            "totalAbsorbs": sum(row["absorbs"] for row in rows),
            "deathEvents": sum(row["deathEvents"] for row in rows),
            "minimumHealthPercent": min(row["minimumHealthPercent"] for row in rows),
@@ -435,6 +564,7 @@ def aggregate(raw: dict[str, Any]) -> dict[str, Any]:
            "dps": weighted_rate(rows, "damage"),
            "bossDps": weighted_rate(rows, "bossDamage"),
            "hps": weighted_rate(rows, "healing"),
+            "hpsReceived": weighted_rate(rows, "healingReceived"),
            "dtps": weighted_rate(rows, "damageTaken"),
            "deathEvents": sum(row["deathEvents"] for row in rows),
        })
@@ -520,15 +650,16 @@ def markdown_report(report: dict[str, Any]) -> str:
        "",
        "## Every party member",
        "",
-        "| Slot | Member | Role | DPS | Boss DPS | HPS | DTPS | Role median | Flag | Death events |",
-        "| ---: | --- | --- | ---: | ---: | ---: | ---: | ---: | --- | ---: |",
+        "| Slot | Member | Role | DPS | Boss DPS | HPS done | HPS received | DTPS | Role median | Flag | Death events |",
+        "| ---: | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | --- | ---: |",
    ]
    for member in report["members"]:
        marker = " (active)" if member["activePlayer"] else ""
        lines.append(
            f"| {member['slot']} | {member['className']} — {member['specialization']}{marker} | "
            f"{member['role']} | {format_number(member['dps'])} | {format_number(member['bossDps'])} | "
-            f"{format_number(member['hps'])} | {format_number(member['dtps'])} | "
+            f"{format_number(member['hps'])} | {format_number(member['hpsReceived'])} | "
+            f"{format_number(member['dtps'])} | "
            f"{format_ratio(member['damageVsRoleMedian'])} | {member['damageFlag']} | {member['deathEvents']} |"
        )
    lines.extend([
@@ -592,12 +723,14 @@ def html_report(report: dict[str, Any]) -> str:
        "dps": format_number(row["dps"]),
        "bossDps": format_number(row["bossDps"]),
        "hps": format_number(row["hps"]),
+        "hpsReceived": format_number(row["hpsReceived"]),
        "dtps": format_number(row["dtps"]),
        "damageVsRoleMedian": format_number(row["damageVsRoleMedian"], 2),
    } for row in report["members"]]
    member_table = html_table("members", "Every party member", members, (
        ("slot", "Slot"), ("member", "Member"), ("role", "Role"), ("dps", "DPS"),
-        ("bossDps", "Boss DPS"), ("hps", "HPS"), ("dtps", "DTPS"),
+        ("bossDps", "Boss DPS"), ("hps", "HPS done"), ("hpsReceived", "HPS received"),
+        ("dtps", "DTPS"),
        ("damageVsRoleMedian", "Role median ×"), ("damageFlag", "Flag"), ("deathEvents", "Death events"),
    ))
    boss_table = html_table("bosses", "Every boss — highest pressure first", bosses, (
@@ -639,12 +772,12 @@ def create_reports(raw_path: Path, output_dir: Path) -> dict[str, Any]:
    ))
    write_csv(output_dir / "party_members.csv", report["members"], (
        "slot", "activePlayer", "classId", "className", "specialization", "role", "dps", "bossDps",
-        "hps", "dtps", "damageVsRoleMedian", "damageFlag", "totalDamage", "totalHealing",
-        "totalAbsorbs", "deathEvents", "minimumHealthPercent",
+        "hps", "hpsReceived", "dtps", "damageVsRoleMedian", "damageFlag", "totalDamage", "totalHealing",
+        "totalHealingReceived", "totalAbsorbs", "deathEvents", "minimumHealthPercent",
    ))
    write_csv(output_dir / "member_by_boss.csv", report["memberByBoss"], (
        "bossKey", "bossName", "dungeonTitle", "slot", "className", "specialization", "role",
-        "dps", "bossDps", "hps", "dtps", "deathEvents",
+        "dps", "bossDps", "hps", "hpsReceived", "dtps", "deathEvents",
    ))
    run_rows = [{
        "policyId": raw["policyId"],
@@ -688,10 +821,12 @@ def aggregate_class_specs(
            "dps": weighted_rate(observations, "damage"),
            "bossDps": weighted_rate(observations, "bossDamage"),
            "hps": weighted_rate(observations, "healing"),
+            "hpsReceived": weighted_rate(observations, "healingReceived"),
            "dtps": weighted_rate(observations, "damageTaken"),
            "totalDamage": sum(row["damage"] for row in observations),
            "totalDamageTaken": sum(row["damageTaken"] for row in observations),
            "totalHealing": sum(row["healing"] for row in observations),
+            "totalHealingReceived": sum(row.get("healingReceived", 0) for row in observations),
            "totalAbsorbs": sum(row["absorbs"] for row in observations),
            "deathEvents": sum(row["deathEvents"] for row in observations),
        })
@@ -805,14 +940,15 @@ def suite_markdown(report: dict[str, Any]) -> str:
        "",
        "## Every tested class/spec",
        "",
-        "| Source | Class/spec | Role | Parties | Runs | DPS | Boss DPS | HPS | DTPS | Total taken | Role median | Flag | Deaths |",
-        "| --- | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | ---: |",
+        "| Source | Class/spec | Role | Parties | Runs | DPS | Boss DPS | HPS done | HPS received | DTPS | Total taken | Role median | Flag | Deaths |",
+        "| --- | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | ---: |",
    ]
    for row in report["classSpecs"]:
        lines.append(
            f"| {row['source']} | {row['className']} — {row['specialization']} | {row['role']} | "
            f"{row['partyConfigurations']} | {row['runs']} | {format_number(row['dps'])} | "
-            f"{format_number(row['bossDps'])} | {format_number(row['hps'])} | {format_number(row['dtps'])} | "
+            f"{format_number(row['bossDps'])} | {format_number(row['hps'])} | "
+            f"{format_number(row['hpsReceived'])} | {format_number(row['dtps'])} | "
            f"{format_number(row['totalDamageTaken'])} | "
            f"{format_ratio(row['damageVsSourceRoleMedian'])} | {row['damageFlag']} | {row['deathEvents']} |"
        )
@@ -873,6 +1009,7 @@ def suite_html(report: dict[str, Any]) -> str:
        "dps": format_number(row["dps"]),
        "bossDps": format_number(row["bossDps"]),
        "hps": format_number(row["hps"]),
+        "hpsReceived": format_number(row["hpsReceived"]),
        "dtps": format_number(row["dtps"]),
        "totalDamageTaken": format_number(row["totalDamageTaken"]),
        "damageVsSourceRoleMedian": format_ratio(row["damageVsSourceRoleMedian"]),
@@ -911,7 +1048,8 @@ def suite_html(report: dict[str, Any]) -> str:
    class_table = html_table("class-specs", "Every tested class/spec", class_specs, (
        ("source", "Source"), ("classSpec", "Class/spec"), ("role", "Role"),
        ("partyConfigurations", "Parties"), ("runs", "Runs"), ("dps", "DPS"),
-        ("bossDps", "Boss DPS"), ("hps", "HPS"), ("dtps", "DTPS"),
+        ("bossDps", "Boss DPS"), ("hps", "HPS done"), ("hpsReceived", "HPS received"),
+        ("dtps", "DTPS"),
        ("totalDamageTaken", "Total taken"), ("damageVsSourceRoleMedian", "Role median"),
        ("damageFlag", "Flag"), ("deathEvents", "Deaths"),
    ))
@@ -1064,6 +1202,7 @@ def create_suite_reports(entries: Sequence[dict[str, Any]], output_dir: Path, le
            "dps": weighted_rate(observations, "damage"),
            "bossDps": weighted_rate(observations, "bossDamage"),
            "hps": weighted_rate(observations, "healing"),
+            "hpsReceived": weighted_rate(observations, "healingReceived"),
            "dtps": weighted_rate(observations, "damageTaken"),
            "totalDamageTaken": sum(row["damageTaken"] for row in observations),
            "deathEvents": sum(row["deathEvents"] for row in observations),
@@ -1106,8 +1245,8 @@ def create_suite_reports(entries: Sequence[dict[str, Any]], output_dir: Path, le
    ))
    write_csv(output_dir / "class_specs_across_parties.csv", class_specs, (
        "source", "buildId", "classId", "className", "specialization", "role", "partyConfigurations",
-        "runs", "dps", "bossDps", "hps", "dtps", "damageVsSourceRoleMedian", "damageFlag",
-        "totalDamage", "totalDamageTaken", "totalHealing", "totalAbsorbs", "deathEvents",
+        "runs", "dps", "bossDps", "hps", "hpsReceived", "dtps", "damageVsSourceRoleMedian", "damageFlag",
+        "totalDamage", "totalDamageTaken", "totalHealing", "totalHealingReceived", "totalAbsorbs", "deathEvents",
    ))
    write_csv(output_dir / "class_abilities_across_parties.csv", class_abilities, (
        "source", "buildId", "classId", "className", "specialization", "role", "abilityId",
@@ -1129,7 +1268,7 @@ def create_suite_reports(entries: Sequence[dict[str, Any]], output_dir: Path, le
    ))
    write_csv(output_dir / "class_spec_by_boss.csv", class_spec_by_boss, (
        "source", "buildId", "classId", "className", "specialization", "role", "bossKey", "bossName",
-        "dungeonTitle", "partyConfigurations", "runs", "dps", "bossDps", "hps", "dtps",
+        "dungeonTitle", "partyConfigurations", "runs", "dps", "bossDps", "hps", "hpsReceived", "dtps",
        "totalDamageTaken", "deathEvents",
    ))
    write_csv(output_dir / "suite_runs.csv", compact_runs, (
@@ -1147,6 +1286,10 @@ def parser() -> argparse.ArgumentParser:
    result.add_argument("--source", choices=("wow", "coa", "rom", "all"), help="party catalog; all requires automatic mode")
    result.add_argument("--level", type=int, default=60, help="party level (default: 60)")
    result.add_argument("--party-mode", choices=("random", "manual", "automatic"), default="random")
+    result.add_argument("--spec-selection", choices=("random", "all", "specific"), default="random",
+                        help="automatic party strategy (default: random)")
+    result.add_argument("--spec", action="append", default=[],
+                        help="required build ID or class:spec selector for --spec-selection specific")
    result.add_argument("--party-seed", type=int, default=1, help="random party seed")
    result.add_argument("--party-configurations", type=int, default=10, help="automatic parties per selected source")
    result.add_argument("--member", action="append", default=[], help="manual build ID or class:spec selector; repeat five times")
@@ -1203,7 +1346,25 @@ def main(argv: Sequence[str] | None = None) -> int:
    seeds = args.seeds or list(range(1, args.simulations_per_party + 1))
    if args.party_mode == "automatic":
        sources = ("wow", "coa", "rom") if args.source == "all" else (args.source,)
-        configurations = automatic_parties(builds, sources, args.party_configurations, args.party_seed)
+        if args.spec_selection != "specific" and args.spec:
+            session.close()
+            raise SystemExit("--spec values require --spec-selection specific")
+        if args.spec_selection == "random":
+            configurations = automatic_parties(builds, sources, args.party_configurations, args.party_seed)
+            selected_build_ids: list[str] = []
+        else:
+            if args.spec_selection == "specific" and not args.spec:
+                session.close()
+                raise SystemExit("--spec-selection specific requires at least one --spec value")
+            selected_build_ids = list(dict.fromkeys(
+                resolve_build(selector, builds)["id"] for selector in args.spec
+            ))
+            configurations = coverage_parties(
+                builds,
+                sources,
+                None if args.spec_selection == "all" else selected_build_ids,
+                args.party_seed,
+            )
        if args.active_slot is not None:
            if not 1 <= args.active_slot <= 5:
                session.close()
@@ -1246,10 +1407,13 @@ def main(argv: Sequence[str] | None = None) -> int:
            "policyId": catalog["policyId"],
            "rotationVersion": catalog["rotationVersion"],
            "mode": "automatic",
+            "specSelection": args.spec_selection,
+            "selectedBuildIds": selected_build_ids,
            "source": args.source,
            "level": args.level,
            "partySeed": args.party_seed,
-            "partyConfigurationsPerSource": args.party_configurations,
+            "partyConfigurationsPerSource": args.party_configurations if args.spec_selection == "random" else None,
+            "partyConfigurations": len(configurations),
            "simulationsPerParty": len(seeds),
            "seeds": seeds,
            "durationSeconds": args.duration,
@@ -56,7 +56,12 @@ const runtimeData = fs.mkdtempSync(path.join(os.tmpdir(), 'healer-man-balance-ui
    assert.match(await page.locator('.balance-lab-runtime').innerText(), /Python 3\./);
    await page.getByLabel('Party source').selectOption('wow');
    await page.getByLabel('Level').fill('20');
-    await page.getByLabel('Parties per source').fill('1');
+    await page.getByLabel('Class/spec selection').selectOption('all');
+    assert(Number(await page.getByLabel('Coverage parties').inputValue()) > 1, 'all-spec coverage should derive multiple parties');
+    await page.getByLabel('Class/spec selection').selectOption('specific');
+    await page.getByLabel('Search Balance Lab class specs').fill('Paladin Holy');
+    await page.getByRole('checkbox', { name: /Paladin · Holy/ }).check();
+    assert.equal(await page.getByLabel('Coverage parties').inputValue(), '1');
    await page.getByLabel('Runs per party/boss').fill('1');
    await page.getByLabel('Fight limit (seconds)').fill('5');
    await page.getByLabel('Bosses').selectOption('specific');
@@ -75,7 +80,7 @@ const runtimeData = fs.mkdtempSync(path.join(os.tmpdir(), 'healer-man-balance-ui

    await page.getByRole('button', { name: 'View graphs and filterable data' }).click();
    await page.locator('.balance-results').waitFor();
-    assert.equal(await page.locator('.balance-results-chart').count(), 5);
+    assert.equal(await page.locator('.balance-results-chart').count(), 7);
    assert.match(await page.locator('.balance-results-chart').filter({ hasText: 'Boss damage to party' }).innerText(), /Eck the Ferocious/);
    await capture('04-run-analytics');

@@ -91,9 +96,23 @@ const runtimeData = fs.mkdtempSync(path.join(os.tmpdir(), 'healer-man-balance-ui
    const damageRows = await page.locator('.balance-results-table-panel tbody tr').count();
    assert(damageRows > 0 && damageRows < allClassRows, 'role filtering should narrow the complete class/spec table');
    await page.getByLabel('Class role').selectOption('all');
-    await page.getByRole('button', { name: 'abilities', exact: true }).click();
+    const damageSpecRow = page.locator('.balance-results-table-panel tbody tr').filter({
+      has: page.locator('td:nth-child(3)').getByText('damage', { exact: true }),
+    }).first();
+    const damageSpecClass = await damageSpecRow.locator('td:first-child strong').innerText();
+    const damageSpecName = await damageSpecRow.locator('td:first-child small').innerText();
+    await damageSpecRow.getByRole('button', { name: `View ${damageSpecClass} ${damageSpecName} ability damage` }).click();
+    await page.getByRole('heading', { name: `${damageSpecClass} · ${damageSpecName} ability damage` }).waitFor();
+    assert.notEqual(await page.getByLabel('Filter ability class spec').inputValue(), 'all');
+    assert.equal(await page.getByLabel('Filter ability usage').inputValue(), 'damage');
    const abilityRows = page.locator('.balance-results-abilities tbody tr');
-    assert(await abilityRows.count() > 0, 'ability breakdown should retain observed and available abilities');
+    assert(await abilityRows.count() > 0, 'spec drill-down should show abilities that dealt damage');
+    assert(Number((await abilityRows.first().locator('td:nth-child(12)').innerText()).replaceAll(',', '')) > 0, 'drilled ability rows should include effective damage');
+    const abilityHeaders = await page.locator('.balance-results-abilities thead').innerText();
+    assert.match(abilityHeaders, /CASTS/);
+    assert.match(abilityHeaders, /EFFECTIVE DAMAGE/);
+    assert.match(abilityHeaders, /DAMAGE SHARE/);
+    assert.match(abilityHeaders, /DPS/);
    await page.getByLabel('Filter ability usage').selectOption('unused');
    assert(await abilityRows.count() > 0, 'available but unused abilities should remain visible');
    await page.getByLabel('Filter ability usage').selectOption('all');
@@ -1,4 +1,4 @@
-"""Visual, fail-closed release manager for Healer Man.
+"""Visual release manager for Healer Man with explicit safety gates.

 The GUI intentionally leaves the TrueNAS portion as copyable shell commands:
 the app must be stopped and started from the TrueNAS Apps UI around that block.
@@ -18,6 +18,7 @@ import sys
 import tempfile
 import threading
 import webbrowser
+from collections import deque
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Callable, Iterable, Sequence
@@ -59,6 +60,17 @@ FORBIDDEN_SUFFIXES = {
 ALLOWED_GENERATED_FILES = {
    "public/data/healer-man-loot.sqlite",
 }
+OVERRIDABLE_TEST_LABELS = frozenset(
+    {
+        "Content tests",
+        "Server tests",
+        "Application tests",
+        "Shelved-mode application tests",
+    }
+)
+ANSI_ESCAPE_PATTERN = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+FAILURE_OUTPUT_LINE_LIMIT = 160
+FAILURE_OUTPUT_CHARACTER_LIMIT = 20_000


 class ReleaseError(RuntimeError):
@@ -69,6 +81,23 @@ class ReleaseCancelled(ReleaseError):
    """The user cancelled an active release."""


+class ReleaseCommandError(ReleaseError):
+    """A release subprocess failed and retained its output for review."""
+
+    def __init__(
+        self,
+        label: str,
+        command: Sequence[str],
+        return_code: int,
+        output: str,
+    ) -> None:
+        super().__init__(f"{label} failed with exit code {return_code}.")
+        self.label = label
+        self.command = tuple(command)
+        self.return_code = return_code
+        self.output = output
+
+
@dataclass(frozen=True)
 class ReleaseVersion:
    version_name: str
@@ -88,6 +117,36 @@ def full_release_checks(npm: str) -> tuple[tuple[list[str], str], ...]:
    )


+def can_override_release_check(label: str) -> bool:
+    """Return whether the interactive release flow may continue after a failure."""
+    return label in OVERRIDABLE_TEST_LABELS
+
+
+def format_failed_test_warning(failure: ReleaseCommandError) -> str:
+    """Build the detailed warning shown before overriding a failed test command."""
+    clean_output = ANSI_ESCAPE_PATTERN.sub("", failure.output).strip()
+    output_lines = clean_output.splitlines()
+    omitted_lines = max(0, len(output_lines) - FAILURE_OUTPUT_LINE_LIMIT)
+    if omitted_lines:
+        output_lines = output_lines[-FAILURE_OUTPUT_LINE_LIMIT:]
+    recent_output = "\n".join(output_lines)
+    if len(recent_output) > FAILURE_OUTPUT_CHARACTER_LIMIT:
+        recent_output = recent_output[-FAILURE_OUTPUT_CHARACTER_LIMIT:]
+        recent_output = "… earlier output omitted …\n" + recent_output
+    elif omitted_lines:
+        recent_output = f"… {omitted_lines} earlier line(s) omitted …\n" + recent_output
+    if not recent_output:
+        recent_output = "(The command produced no output.)"
+    command = subprocess.list2cmdline(list(failure.command))
+    return (
+        f"{failure.label} failed with exit code {failure.return_code}.\n\n"
+        f"Command:\n{command}\n\n"
+        f"Recent output:\n{recent_output}\n\n"
+        "Continuing can publish a release with known test failures. "
+        "Only continue if you reviewed the failure and accept that risk."
+    )
+
+
 def parse_semver(value: str) -> tuple[int, int, int]:
    match = SEMVER_PATTERN.fullmatch(value.strip())
    if not match:
@@ -1116,7 +1175,25 @@ def launch_gui(*, smoke_test: bool = False) -> int:
                )

                for command, label in full_release_checks(npm):
-                    self._run_command(command, label)
+                    try:
+                        self._run_command(command, label)
+                    except ReleaseCommandError as failure:
+                        if not can_override_release_check(label):
+                            raise
+                        approved = self._request_approval(
+                            format_failed_test_warning(failure),
+                            title=f"Warning: {label} failed",
+                            heading="Tests failed — continue the release?",
+                            approve_label="Continue Anyway",
+                            cancel_label="Stop Release",
+                        )
+                        if not approved:
+                            raise ReleaseCancelled(
+                                f"Release stopped because {label} failed."
+                            ) from failure
+                        self._log_event(
+                            f"⚠ Continuing after failed {label}; override approved by user."
+                        )
                self._run_command(["git", "add", "-A"], "Stage release")
                staged = True

@@ -1267,31 +1344,66 @@ def launch_gui(*, smoke_test: bool = False) -> int:
            )
            self.current_process = process
            assert process.stdout is not None
+            output_lines: deque[str] = deque(maxlen=FAILURE_OUTPUT_LINE_LIMIT)
            try:
                for line in process.stdout:
-                    self._log_event(line.rstrip("\n"))
+                    rendered = line.rstrip("\n")
+                    output_lines.append(rendered)
+                    self._log_event(rendered)
                return_code = process.wait()
            finally:
                self.current_process = None
            if self.cancel_event.is_set():
                raise ReleaseCancelled("Release cancelled.")
            if return_code != 0:
-                raise ReleaseError(f"{label} failed with exit code {return_code}.")
+                raise ReleaseCommandError(
+                    label,
+                    args,
+                    return_code,
+                    "\n".join(output_lines),
+                )
            self._log_event(f"✓ {label} passed")

-        def _request_approval(self, review: str) -> bool:
+        def _request_approval(
+            self,
+            review: str,
+            *,
+            title: str = "Review staged release",
+            heading: str = "Inspect every staged path before publishing",
+            approve_label: str = "Commit, Push, and Publish",
+            cancel_label: str = "Cancel release",
+        ) -> bool:
            response: dict[str, bool] = {}
            ready = threading.Event()
-            self.events.put(("approval", review, response, ready))
+            self.events.put(
+                (
+                    "approval",
+                    review,
+                    title,
+                    heading,
+                    approve_label,
+                    cancel_label,
+                    response,
+                    ready,
+                )
+            )
            while not ready.wait(0.2):
                if self.cancel_event.is_set():
                    return False
            return response.get("approved", False)

-        def _show_staged_review(self, review: str) -> bool:
+        def _show_approval(
+            self,
+            review: str,
+            *,
+            title: str,
+            heading: str,
+            approve_label: str,
+            cancel_label: str,
+        ) -> bool:
            decision = {"approved": False}
            dialog = tk.Toplevel(self.root)
-            dialog.title("Review staged release")
+            dialog.title(title)
            dialog.geometry("820x640")
            dialog.minsize(640, 420)
            dialog.configure(bg=self.BG)
@@ -1301,7 +1413,7 @@ def launch_gui(*, smoke_test: bool = False) -> int:
            dialog.columnconfigure(0, weight=1)
            ttk.Label(
                dialog,
-                text="Inspect every staged path before publishing",
+                text=heading,
                style="Title.TLabel",
            ).grid(row=0, column=0, sticky="w", padx=18, pady=(16, 10))
            review_text = scrolledtext.ScrolledText(
@@ -1326,12 +1438,12 @@ def launch_gui(*, smoke_test: bool = False) -> int:
                dialog.grab_release()
                dialog.destroy()

-            ttk.Button(buttons, text="Cancel release", command=lambda: finish(False)).pack(
+            ttk.Button(buttons, text=cancel_label, command=lambda: finish(False)).pack(
                side="left"
            )
            ttk.Button(
                buttons,
-                text="Commit, Push, and Publish",
+                text=approve_label,
                style="Accent.TButton",
                command=lambda: finish(True),
            ).pack(side="right")
@@ -1375,8 +1487,15 @@ def launch_gui(*, smoke_test: bool = False) -> int:
                    if kind == "log":
                        self._append_log(str(event[1]))
                    elif kind == "approval":
-                        review, response, ready = event[1], event[2], event[3]
-                        approved = self._show_staged_review(str(review))
+                        review, title, heading, approve_label, cancel_label = event[1:6]
+                        response, ready = event[6], event[7]
+                        approved = self._show_approval(
+                            str(review),
+                            title=str(title),
+                            heading=str(heading),
+                            approve_label=str(approve_label),
+                            cancel_label=str(cancel_label),
+                        )
                        assert isinstance(response, dict)
                        response["approved"] = approved
                        assert isinstance(ready, threading.Event)
@@ -54,6 +54,39 @@ class SafetyTests(unittest.TestCase):
        self.assertLess(publish_index, commands.index(["npm", "run", "build"]))
        self.assertLess(publish_index, commands.index(["npm", "run", "android:sync"]))

+    def test_only_test_failures_may_be_overridden(self):
+        checks = release_manager.full_release_checks("npm")
+        overridable = {
+            label for _command, label in checks
+            if release_manager.can_override_release_check(label)
+        }
+        self.assertEqual(
+            overridable,
+            {
+                "Content tests",
+                "Server tests",
+                "Application tests",
+                "Shelved-mode application tests",
+            },
+        )
+        self.assertFalse(release_manager.can_override_release_check("Production build"))
+        self.assertFalse(release_manager.can_override_release_check("Push main"))
+
+    def test_failed_test_warning_includes_command_and_specific_output(self):
+        failure = release_manager.ReleaseCommandError(
+            "Application tests",
+            ["npm", "test"],
+            1,
+            "\x1b[31mFAIL\x1b[39m src/game/example.test.ts\n"
+            "Error: expected 2 to be 3",
+        )
+        warning = release_manager.format_failed_test_warning(failure)
+        self.assertIn("Application tests failed with exit code 1", warning)
+        self.assertIn("npm test", warning)
+        self.assertIn("FAIL src/game/example.test.ts", warning)
+        self.assertIn("Error: expected 2 to be 3", warning)
+        self.assertNotIn("\x1b", warning)
+

 class ReleaseCandidateTests(unittest.TestCase):
    def test_checks_untracked_files_without_changing_the_real_index(self):
@@ -4,6 +4,7 @@ from scripts.balance_lab import (
    aggregate_class_abilities,
    aggregate_class_specs,
    automatic_parties,
+    coverage_parties,
    random_party,
    search_bosses,
    tuning_label,
@@ -57,6 +58,44 @@ class BalanceLabControllerTests(unittest.TestCase):
                "tank", "healer", "damage", "damage", "damage",
            ])

+    def test_coverage_parties_include_every_build_with_minimum_unique_parties(self) -> None:
+        builds = [
+            {"id": "tank-a", "source": "wow", "role": "tank"},
+            {"id": "tank-b", "source": "wow", "role": "tank"},
+            {"id": "healer-a", "source": "wow", "role": "healer"},
+            {"id": "healer-b", "source": "wow", "role": "healer"},
+            *({"id": f"damage-{index}", "source": "wow", "role": "damage"} for index in range(7)),
+        ]
+        first = coverage_parties(builds, ("wow",), None, 19)
+        second = coverage_parties(builds, ("wow",), None, 19)
+        self.assertEqual(first, second)
+        self.assertEqual(len(first), 3)
+        covered = {member["id"] for configuration in first for member in configuration["party"]}
+        self.assertEqual(covered, {build["id"] for build in builds})
+        signatures = {tuple(member["id"] for member in configuration["party"]) for configuration in first}
+        self.assertEqual(len(signatures), 3)
+        for configuration in first:
+            self.assertEqual([member["role"] for member in configuration["party"]], [
+                "tank", "healer", "damage", "damage", "damage",
+            ])
+            self.assertEqual(len({member["id"] for member in configuration["party"]}), 5)
+
+    def test_specific_coverage_uses_fillers_but_guarantees_selected_builds(self) -> None:
+        builds = [
+            {"id": "tank-a", "source": "wow", "role": "tank"},
+            {"id": "tank-b", "source": "wow", "role": "tank"},
+            {"id": "healer-a", "source": "wow", "role": "healer"},
+            {"id": "healer-b", "source": "wow", "role": "healer"},
+            *({"id": f"damage-{index}", "source": "wow", "role": "damage"} for index in range(5)),
+        ]
+        selected = ["tank-a", "tank-b", "damage-4"]
+        configurations = coverage_parties(builds, ("wow",), selected, 7)
+        self.assertEqual(len(configurations), 2)
+        observed = [member["id"] for configuration in configurations for member in configuration["party"]]
+        covered = set(observed)
+        self.assertTrue(set(selected).issubset(covered))
+        self.assertTrue(all(observed.count(build_id) == 1 for build_id in selected))
+
    def test_boss_search_matches_name_dungeon_key_and_source(self) -> None:
        bosses = [
            {"key": "gundrak/eck", "name": "Eck the Ferocious", "dungeonTitle": "Gundrak", "category": "wow"},
@@ -66,23 +105,25 @@ class BalanceLabControllerTests(unittest.TestCase):
        self.assertEqual([boss["key"] for boss in search_bosses("forsaken", bosses)], ["abbey/duke"])
        self.assertEqual([boss["key"] for boss in search_bosses("rom", bosses)], ["abbey/duke"])

-    def test_class_spec_aggregate_keeps_rate_and_absolute_damage_taken(self) -> None:
+    def test_class_spec_aggregate_keeps_damage_and_healing_received_metrics(self) -> None:
        key = ("wow", "priest-holy", "priest", "Priest", "Holy", "healer")
        rows = aggregate_class_specs({key: [
            {
                "partyConfigurationId": "wow-party-001", "elapsedSeconds": 10,
-                "damage": 200, "bossDamage": 180, "healing": 500,
+                "damage": 200, "bossDamage": 180, "healing": 500, "healingReceived": 300,
                "damageTaken": 120, "absorbs": 25, "deathEvents": 0,
            },
            {
                "partyConfigurationId": "wow-party-002", "elapsedSeconds": 20,
-                "damage": 400, "bossDamage": 360, "healing": 900,
+                "damage": 400, "bossDamage": 360, "healing": 900, "healingReceived": 600,
                "damageTaken": 330, "absorbs": 50, "deathEvents": 1,
            },
        ]})
        self.assertEqual(len(rows), 1)
        self.assertEqual(rows[0]["dtps"], 15)
        self.assertEqual(rows[0]["totalDamageTaken"], 450)
+        self.assertEqual(rows[0]["hpsReceived"], 30)
+        self.assertEqual(rows[0]["totalHealingReceived"], 900)

    def test_ability_aggregate_keeps_used_and_available_but_unused_rows(self) -> None:
        class_key = ("wow", "mage-fire", "mage", "Mage", "Fire", "damage")
@@ -15,6 +15,7 @@ import { GameDatabaseError } from "./database.mjs";

 const SOURCES = new Set(["wow", "coa", "rom", "all"]);
 const BOSS_CATEGORIES = new Set(["all", "wow", "rom"]);
+const SPEC_SELECTIONS = new Set(["random", "all", "specific"]);
 const JOB_STATUSES = new Set(["queued", "running", "complete", "failed"]);
 const JOB_METADATA_NAME = "job.json";
 const JOB_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -43,12 +44,16 @@ function integer(value, name, minimum, maximum) {
 export function normalizeBalanceLabJobSpec(input) {
  const source = String(input?.source ?? "all").toLowerCase();
  const bossCategory = String(input?.bossCategory ?? "all").toLowerCase();
+  const specSelection = String(input?.specSelection ?? "random").toLowerCase();
  if (!SOURCES.has(source)) {
    throw new GameDatabaseError("Party source must be wow, coa, rom, or all.", 400, "invalid_balance_lab_job");
  }
  if (!BOSS_CATEGORIES.has(bossCategory)) {
    throw new GameDatabaseError("Boss category must be all, wow, or rom.", 400, "invalid_balance_lab_job");
  }
+  if (!SPEC_SELECTIONS.has(specSelection)) {
+    throw new GameDatabaseError("Class/spec selection must be random, all, or specific.", 400, "invalid_balance_lab_job");
+  }
  const rawBossKeys = Array.isArray(input?.bossKeys) ? input.bossKeys : [];
  if (rawBossKeys.length > 500) {
    throw new GameDatabaseError("Select no more than 500 bosses.", 400, "invalid_balance_lab_job");
@@ -57,8 +62,21 @@ export function normalizeBalanceLabJobSpec(input) {
  if (bossKeys.some((key) => key.length > 240 || !/^[A-Za-z0-9._:/-]+$/.test(key))) {
    throw new GameDatabaseError("A selected boss key is invalid.", 400, "invalid_balance_lab_job");
  }
+  const rawBuildIds = Array.isArray(input?.selectedBuildIds) ? input.selectedBuildIds : [];
+  if (rawBuildIds.length > 200) {
+    throw new GameDatabaseError("Select no more than 200 class/spec builds.", 400, "invalid_balance_lab_job");
+  }
+  const selectedBuildIds = [...new Set(rawBuildIds.map((value) => String(value).trim()).filter(Boolean))];
+  if (selectedBuildIds.some((id) => id.length > 240 || !/^[A-Za-z0-9._:/-]+$/.test(id))) {
+    throw new GameDatabaseError("A selected class/spec build ID is invalid.", 400, "invalid_balance_lab_job");
+  }
+  if (specSelection === "specific" && selectedBuildIds.length === 0) {
+    throw new GameDatabaseError("Select at least one class/spec build.", 400, "invalid_balance_lab_job");
+  }
  const spec = Object.freeze({
    source,
+    specSelection,
+    selectedBuildIds: Object.freeze(specSelection === "specific" ? selectedBuildIds : []),
    level: integer(input?.level ?? 60, "Level", 1, 80),
    partyConfigurations: integer(input?.partyConfigurations ?? 10, "Party configurations", 1, 100),
    simulationsPerParty: integer(input?.simulationsPerParty ?? 3, "Simulations per party", 1, 100),
@@ -69,7 +87,12 @@ export function normalizeBalanceLabJobSpec(input) {
  });
  const sourceCount = spec.source === "all" ? 3 : 1;
  const bossEstimate = Math.max(1, spec.bossKeys.length || (spec.bossCategory === "all" ? 500 : 300));
-  const estimatedRuns = sourceCount * spec.partyConfigurations * spec.simulationsPerParty * bossEstimate;
+  const partyEstimate = spec.specSelection === "random"
+    ? sourceCount * spec.partyConfigurations
+    : spec.specSelection === "specific"
+      ? Math.max(spec.partyConfigurations, spec.selectedBuildIds.length)
+      : Math.max(spec.partyConfigurations, spec.source === "all" ? 100 : 50);
+  const estimatedRuns = partyEstimate * spec.simulationsPerParty * bossEstimate;
  if (estimatedRuns > 250_000) {
    throw new GameDatabaseError(
      "That job is too large for one server request. Reduce parties, simulations, or selected bosses.",
@@ -90,6 +113,7 @@ export function balanceLabCommand(spec, outputDir, options = {}) {
    "--source", spec.source,
    "--level", String(spec.level),
    "--party-mode", "automatic",
+    "--spec-selection", spec.specSelection,
    "--party-seed", String(spec.partySeed),
    "--party-configurations", String(spec.partyConfigurations),
    "--simulations-per-party", String(spec.simulationsPerParty),
@@ -97,6 +121,7 @@ export function balanceLabCommand(spec, outputDir, options = {}) {
    "--boss-category", spec.bossCategory,
    "--output-dir", outputDir,
  ];
+  for (const buildId of spec.selectedBuildIds) args.push("--spec", buildId);
  for (const bossKey of spec.bossKeys) args.push("--boss", bossKey);
  return { executable, args, cwd: projectRoot };
 }
@@ -167,6 +192,12 @@ function reportSummary(outputDir) {
  }
 }

+function expectedPartyConfigurations(spec) {
+  return spec.specSelection === "random"
+    ? spec.partyConfigurations * (spec.source === "all" ? 3 : 1)
+    : spec.partyConfigurations;
+}
+
 function lineCollector(onLine) {
  let pending = "";
  return {
@@ -236,8 +267,12 @@ export function createBalanceLabJobService(options = {}) {
            requestedBy: "unknown (legacy run)",
            spec: {
              source: legacyConfig.source,
+              specSelection: legacyConfig.specSelection ?? "random",
+              selectedBuildIds: legacyConfig.selectedBuildIds ?? [],
              level: legacyConfig.level,
-              partyConfigurations: legacyConfig.partyConfigurationsPerSource,
+              partyConfigurations: legacyConfig.specSelection && legacyConfig.specSelection !== "random"
+                ? legacyConfig.partyConfigurations
+                : legacyConfig.partyConfigurationsPerSource,
              simulationsPerParty: legacyConfig.simulationsPerParty,
              durationSeconds: legacyConfig.durationSeconds,
              partySeed: legacyConfig.partySeed,
@@ -252,7 +287,8 @@ export function createBalanceLabJobService(options = {}) {
        const hasReport = existsSync(reportPath);
        const storedStatus = JOB_STATUSES.has(stored.status) ? stored.status : "failed";
        const interrupted = !hasReport && (storedStatus === "queued" || storedStatus === "running");
-        const totalParties = spec.partyConfigurations * (spec.source === "all" ? 3 : 1);
+        const restoredSummary = hasReport ? reportSummary(outputDir) : null;
+        const totalParties = restoredSummary?.partyConfigurations || expectedPartyConfigurations(spec);
        const createdAt = typeof stored.createdAt === "string"
          ? stored.createdAt
          : statSync(outputDir).birthtime.toISOString();
@@ -282,7 +318,7 @@ export function createBalanceLabJobService(options = {}) {
          logTail: Array.isArray(stored.logTail)
            ? stored.logTail.filter((line) => typeof line === "string").slice(-80)
            : [],
-          summary: hasReport ? reportSummary(outputDir) : null,
+          summary: restoredSummary,
          outputDir,
        };
        jobs.set(job.id, job);
@@ -401,7 +437,7 @@ export function createBalanceLabJobService(options = {}) {
      const id = randomUUID();
      const outputDir = path.join(jobsDir, id);
      mkdirSync(outputDir, { recursive: true });
-      const totalParties = spec.partyConfigurations * (spec.source === "all" ? 3 : 1);
+      const totalParties = expectedPartyConfigurations(spec);
      const job = {
        id,
        status: "queued",
@@ -15,6 +15,8 @@ import {
 test("normalizes and bounds server Balance Lab requests", () => {
  const spec = normalizeBalanceLabJobSpec({
    source: "ALL",
+    specSelection: "specific",
+    selectedBuildIds: ["balance-wow-priest-healer-holy-level-40", "balance-wow-priest-healer-holy-level-40"],
    level: 40,
    partyConfigurations: 2,
    simulationsPerParty: 3,
@@ -24,6 +26,8 @@ test("normalizes and bounds server Balance Lab requests", () => {
    bossKeys: ["gundrak/entry-29932", "gundrak/entry-29932"],
  });
  assert.equal(spec.source, "all");
+  assert.equal(spec.specSelection, "specific");
+  assert.deepEqual(spec.selectedBuildIds, ["balance-wow-priest-healer-holy-level-40"]);
  assert.deepEqual(spec.bossKeys, ["gundrak/entry-29932"]);
  assert.throws(
    () => normalizeBalanceLabJobSpec({ source: "wow", level: 81 }),
@@ -33,12 +37,17 @@ test("normalizes and bounds server Balance Lab requests", () => {
    () => normalizeBalanceLabJobSpec({ source: "wow", bossKeys: ["boss; shutdown"] }),
    /boss key is invalid/,
  );
+  assert.throws(
+    () => normalizeBalanceLabJobSpec({ source: "wow", specSelection: "specific", selectedBuildIds: [] }),
+    /Select at least one class\/spec build/,
+  );
 });

 test("builds an argument-array command without a shell", () => {
  const spec = normalizeBalanceLabJobSpec({
    source: "rom", level: 60, partyConfigurations: 4, simulationsPerParty: 2,
    durationSeconds: 30, partySeed: 9, bossCategory: "rom", bossKeys: ["abbey/boss-1"],
+    specSelection: "specific", selectedBuildIds: ["balance-rom-mage-damage-primary-level-60"],
  });
  const command = balanceLabCommand(spec, "C:/reports/job", {
    projectRoot: "C:/app",
@@ -47,6 +56,8 @@ test("builds an argument-array command without a shell", () => {
  assert.equal(command.executable, "python-custom");
  assert.equal(command.args.includes("--party-mode"), true);
  assert.equal(command.args.includes("automatic"), true);
+  assert.equal(command.args.includes("specific"), true);
+  assert.equal(command.args.includes("balance-rom-mage-damage-primary-level-60"), true);
  assert.equal(command.args.includes("abbey/boss-1"), true);
  assert.equal(command.cwd, path.resolve("C:/app"));
 });
@@ -44,7 +44,7 @@ async function derivePassword(password, salt) {
  return Buffer.from(await scrypt(password, salt, 64));
 }

-const GM_USERNAME_KEYS = new Set(["phenom"]);
+const GM_USERNAME_KEYS = new Set(["phenom", "codex_dev_gm"]);

 function accountRoles(username) {
  return GM_USERNAME_KEYS.has(String(username ?? "").trim().toLowerCase()) ? ["gm"] : [];
@@ -56,12 +56,15 @@ test("persists opaque cloud roster data with increasing revisions", () => withDa
  assert.equal(database.getCloudSave(registered.account.id).data.characters[0].name, "Mendbetter");
 }));

-test("derives GM authority from the hardcoded Phenom account", () => withDatabase(async (database) => {
+test("derives GM authority from the hardcoded developer accounts", () => withDatabase(async (database) => {
  const gm = await database.register("Phenom", "storm-admin");
+  const developerGm = await database.register("codex_dev_gm", "developer-admin");
  const player = await database.register("Ordinary", "storm-player");
  assert.deepEqual(gm.account.roles, ["gm"]);
  assert.deepEqual((await database.login("pHeNoM", "storm-admin")).account.roles, ["gm"]);
+  assert.deepEqual(developerGm.account.roles, ["gm"]);
  assert.equal(database.isGameMaster(database.authenticate(gm.token)), true);
+  assert.equal(database.isGameMaster(database.authenticate(developerGm.token)), true);
  assert.equal(database.isGameMaster(database.authenticate(player.token)), false);
  assert.equal(database.isGameMaster({ ...player.account, roles: ["gm"] }), false);
 }));
@@ -2,6 +2,7 @@ import { onlineApiOrigin, requestOnlineJson } from "./onlineAccountClient";

 export type BalanceLabPartySource = "wow" | "coa" | "rom" | "all";
 export type BalanceLabBossCategory = "all" | "wow" | "rom";
+export type BalanceLabSpecSelection = "random" | "all" | "specific";
 export type BalanceLabJobStatus = "queued" | "running" | "complete" | "failed";

 export interface BalanceLabRuntimeStatus {
@@ -13,6 +14,8 @@ export interface BalanceLabRuntimeStatus {

 export interface BalanceLabJobSpec {
  readonly source: BalanceLabPartySource;
+  readonly specSelection?: BalanceLabSpecSelection;
+  readonly selectedBuildIds?: readonly string[];
  readonly level: number;
  readonly partyConfigurations: number;
  readonly simulationsPerParty: number;
@@ -84,10 +87,12 @@ export interface BalanceLabClassSpecResult {
  readonly dps: number;
  readonly bossDps: number;
  readonly hps: number;
+  readonly hpsReceived?: number;
  readonly dtps: number;
  readonly totalDamage: number;
  readonly totalDamageTaken: number;
  readonly totalHealing: number;
+  readonly totalHealingReceived?: number;
  readonly totalAbsorbs: number;
  readonly deathEvents: number;
  readonly damageVsSourceRoleMedian: number | null;
@@ -219,6 +219,10 @@ export class BenchmarkController {
      comboTargetId: combat.comboTargetId,
      runes: combat.deathKnightRunes,
      abilities: availableAbilities,
+      knownDamagingAbilityNames: new Set(availableAbilities.filter((ability) => {
+        const categories = aiHintsForAbility(ability).categories;
+        return categories.includes("damage") || categories.includes("execute");
+      }).map((ability) => ability.name)),
      hostileTarget,
      friendlyTargets: [
        { id: PLAYER_AGGRO_ID, health: combat.health, maxHealth: combat.maxHealth, fallen: combat.health <= 0 },
@@ -9,7 +9,10 @@ import { deriveCharacterStats } from "./wotlkStats";

 export function companionResourceMaximum(member: PartyMember, id: string): number {
  return id === member.resourceType ? member.maxResource : id === "mana" && !isRomClassId(member.classId)
-    ? deriveCharacterStats(baseClassFor(member.classId), member.level, member.gearStats, member.raceId).mana : 100;
+    ? deriveCharacterStats(baseClassFor(member.classId), member.level, member.gearStats, member.raceId).mana
+    : id === "nature-power" ? 10
+      : id === "psi" ? 6
+        : 100;
 }

 /**
@@ -285,6 +285,73 @@ describe("shared combat rotations", () => {
      .toBe("strike");
  });

+  it("requires modeled combat state for reactive attacks and named execute-range spells", () => {
+    const revenge = ability("warrior", "Revenge");
+    const warrior = context({
+      classId: "warrior",
+      specializationId: "warrior:protection",
+      role: "tank",
+      primaryResource: "rage",
+      resources: { rage: 100 },
+      maximumResources: { rage: 100 },
+      abilities: [revenge],
+    });
+    expect(evaluateCombatRotation(warrior)).toBeNull();
+    expect(evaluateCombatRotation({
+      ...warrior,
+      availableConditionalAbilityNames: new Set(["Revenge"]),
+    })?.ability.id).toBe(revenge.id);
+
+    const drainSoul = ability("warlock", "Drain Soul");
+    const shadowBolt = ability("warlock", "Shadow Bolt");
+    const warlock = context({
+      classId: "warlock",
+      specializationId: "warlock:affliction",
+      primaryResource: "mana",
+      resources: { mana: 10_000 },
+      maximumResources: { mana: 10_000 },
+      abilities: [drainSoul, shadowBolt],
+    });
+    expect(evaluateCombatRotation(warlock)?.ability.id).toBe(shadowBolt.id);
+    expect(evaluateCombatRotation({
+      ...warlock,
+      hostileTarget: { id: "target", health: 250, maxHealth: 1_000 },
+    })?.ability.id).toBe(drainSoul.id);
+  });
+
+  it("keeps available specialization actions ahead of off-profile throughput", () => {
+    const fireball = ability("mage", "Fireball");
+    const arcaneMissiles = ability("mage", "Arcane Missiles");
+    const mage = context({
+      classId: "mage",
+      specializationId: "mage:fire",
+      primaryResource: "mana",
+      resources: { mana: 10_000 },
+      maximumResources: { mana: 10_000 },
+      abilities: [arcaneMissiles, fireball],
+    });
+    expect(evaluateCombatRotation(mage)?.ability.id).toBe(fireball.id);
+
+    const bearMangle = ability("druid", "Mangle (Bear)");
+    const rake = ability("druid", "Rake");
+    const moonfire = ability("druid", "Moonfire");
+    const bear = context({
+      classId: "druid",
+      specializationId: "druid:feral-bear",
+      role: "tank",
+      primaryResource: "mana",
+      resources: { mana: 10_000, rage: 100, energy: 100 },
+      maximumResources: { mana: 10_000, rage: 100, energy: 100 },
+      abilities: [rake, bearMangle],
+    });
+    expect(evaluateCombatRotation(bear)?.ability.id).toBe(bearMangle.id);
+    expect(evaluateCombatRotation({
+      ...bear,
+      abilities: [rake, moonfire],
+      knownDamagingAbilityNames: new Set([rake.name, moonfire.name, bearMangle.name]),
+    })).toBeNull();
+  });
+
  it("never falls a full-health friendly maintenance heal through to a hostile target", () => {
    const strike = semanticAbility("strike", [{ kind: "damage", coefficient: 1 }]);
    const prayer = semanticAbility("prayer", [
@@ -7,7 +7,7 @@ import { spendDeathKnightRunes } from "./combatResources";
 import { healingAbilityCanAidOthers } from "./healingAbilityRules";
 import type { PartyRole } from "./partyRoles";

-export const COMBAT_ROTATION_VERSION = "playerbots-inspired-v1";
+export const COMBAT_ROTATION_VERSION = "playerbots-inspired-v2";

 export interface RotationProfile {
  readonly id: string;
@@ -51,6 +51,8 @@ export interface RotationContext {
  readonly comboTargetId: string | null;
  readonly runes: readonly DeathKnightRuneState[];
  readonly abilities: readonly AbilityDefinition[];
+  /** Learned actions capable of hostile damage, including unavailable ones. */
+  readonly knownDamagingAbilityNames?: ReadonlySet<string>;
  readonly hostileTarget: RotationHostileTarget | null;
  readonly friendlyTargets?: readonly RotationFriendlyTarget[];
  readonly hostileCount?: number;
@@ -62,6 +64,8 @@ export interface RotationContext {
  readonly activeAuraExclusiveGroups?: ReadonlySet<string>;
  readonly activeSummonAbilityIds?: ReadonlySet<string>;
  readonly hasActivePet?: boolean;
+  /** Proc/state-gated actions that the caller has positively made available. */
+  readonly availableConditionalAbilityNames?: ReadonlySet<string>;
  readonly canUseAbility?: (ability: AbilityDefinition) => boolean;
 }

@@ -108,7 +112,7 @@ export const CLASSIC_ROTATION_PROFILES: readonly RotationProfile[] = Object.free
  profile("shaman:enhancement", "shaman", ["Windfury Weapon", "Rockbiter Weapon", "Lightning Shield", "Feral Spirit", "Stormstrike", "Lava Lash", "Earth Shock", "Lightning Bolt"]),
  profile("shaman:restoration", "shaman", ["Water Shield", "Rockbiter Weapon", "Lightning Shield", "Riptide", "Chain Heal", "Lesser Healing Wave", "Healing Wave", "Earth Shield"]),
  profile("mage:arcane", "mage", ["Mage Armor", "Ice Armor", "Frost Armor", "Arcane Barrage", "Arcane Blast", "Arcane Missiles"]),
-  profile("mage:fire", "mage", ["Molten Armor", "Mage Armor", "Ice Armor", "Frost Armor", "Living Bomb", "Pyroblast", "Fireball", "Scorch", "Fire Blast"]),
+  profile("mage:fire", "mage", ["Molten Armor", "Mage Armor", "Ice Armor", "Frost Armor", "Living Bomb", "Fireball", "Scorch", "Fire Blast"]),
  profile("mage:frost", "mage", ["Frost Armor", "Ice Armor", "Mage Armor", "Deep Freeze", "Frostbolt", "Ice Lance", "Cone of Cold"]),
  profile("warlock:affliction", "warlock", ["Fel Armor", "Demon Armor", "Demon Skin", "Summon Felhunter", "Summon Voidwalker", "Summon Imp", "Haunt", "Unstable Affliction", "Corruption", "Curse of Agony", "Drain Soul", "Shadow Bolt"]),
  profile("warlock:demonology", "warlock", ["Fel Armor", "Demon Armor", "Demon Skin", "Summon Felguard", "Summon Voidwalker", "Summon Imp", "Metamorphosis", "Immolate", "Corruption", "Shadow Bolt"]),
@@ -123,6 +127,45 @@ const PROFILE_BY_SPECIALIZATION = new Map(
  CLASSIC_ROTATION_PROFILES.map((entry) => [entry.specializationId, entry]),
 );

+const CONDITIONAL_ABILITY_NAMES = new Set([
+  "Overpower",
+  "Revenge",
+  "Victory Rush",
+]);
+
+const TARGET_HEALTH_GATES = new Map<string, number>([
+  ["Drain Soul", 0.25],
+  ["Hammer of Wrath", 0.2],
+  ["Kill Shot", 0.2],
+]);
+
+const BEAR_FORM_ACTION_NAMES = new Set([
+  "Bash",
+  "Challenging Roar",
+  "Demoralizing Roar",
+  "Frenzied Regeneration",
+  "Growl",
+  "Lacerate",
+  "Mangle (Bear)",
+  "Maul",
+  "Swipe (Bear)",
+]);
+
+const CAT_FORM_ACTION_NAMES = new Set([
+  "Claw",
+  "Cower",
+  "Ferocious Bite",
+  "Mangle (Cat)",
+  "Pounce",
+  "Rake",
+  "Ravage",
+  "Rip",
+  "Savage Roar",
+  "Shred",
+  "Swipe (Cat)",
+  "Tiger's Fury",
+]);
+
 function slug(value: string): string {
  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
@@ -303,32 +346,52 @@ function scoreAbility(
    || (context.hostileTarget?.maxHealth ?? 0) >= context.maxHealth * 5,
  );
  const profileIndex = rotationProfile?.abilityPriority.findIndex((name) => name === ability.name) ?? -1;
+  const knownDamagingAbilityNames = context.knownDamagingAbilityNames
+    ?? new Set(context.abilities.filter((candidate) => {
+      const candidateCategories = aiHintsForAbility(candidate).categories;
+      return candidateCategories.includes("damage") || candidateCategories.includes("execute");
+    }).map((candidate) => candidate.name));
+  const hasKnownProfileDamageAction = Boolean(rotationProfile?.abilityPriority.some((name) => (
+    knownDamagingAbilityNames.has(name)
+  )));
+
+  const targetHealthGate = TARGET_HEALTH_GATES.get(ability.name);
+  if (targetHealthGate !== undefined && targetHealth > targetHealthGate) return null;
+  if (CONDITIONAL_ABILITY_NAMES.has(ability.name)
+    && !context.availableConditionalAbilityNames?.has(ability.name)) return null;
+  if (context.classId === "druid") {
+    const specializationId = rotationProfile?.specializationId;
+    if (specializationId === "druid:feral-bear" && CAT_FORM_ACTION_NAMES.has(ability.name)) return null;
+    if (specializationId === "druid:feral-cat" && BEAR_FORM_ACTION_NAMES.has(ability.name)) return null;
+    if (specializationId && !specializationId.startsWith("druid:feral-")
+      && (BEAR_FORM_ACTION_NAMES.has(ability.name) || CAT_FORM_ACTION_NAMES.has(ability.name))) return null;
+  }

  if (categories.has("resurrection")) {
    const fallen = (context.friendlyTargets ?? []).find((target) => target.fallen);
-    return fallen ? { ability, score: 20_000, ruleId: "reactive-resurrection", reason: "fallen ally", targetId: fallen.id } : null;
+    return fallen ? { ability, score: 1_020_000, ruleId: "reactive-resurrection", reason: "fallen ally", targetId: fallen.id } : null;
  }
  if (categories.has("dispel")) {
    const dispel = (context.friendlyTargets ?? []).find((target) => target.needsDispel);
-    if (dispel) return { ability, score: 19_000, ruleId: "reactive-dispel", reason: "ally needs dispel", targetId: dispel.id };
+    if (dispel) return { ability, score: 1_019_000, ruleId: "reactive-dispel", reason: "ally needs dispel", targetId: dispel.id };
    if (!damaging) return null;
  }
  if (categories.has("interrupt")) {
    if (!context.hostileTarget?.activeCast?.interruptible) {
      if (!damaging) return null;
    } else {
-      return { ability, score: 18_000, ruleId: "reactive-interrupt", reason: "interruptible enemy cast", targetId: context.hostileTarget.id };
+      return { ability, score: 1_018_000, ruleId: "reactive-interrupt", reason: "interruptible enemy cast", targetId: context.hostileTarget.id };
    }
  }
  if (categories.has("taunt")) {
    if (context.role !== "tank" || !context.targetIsLoose) return null;
-    return { ability, score: 17_000, ruleId: "reactive-taunt", reason: "loose hostile target", targetId: context.hostileTarget?.id ?? null };
+    return { ability, score: 1_017_000, ruleId: "reactive-taunt", reason: "loose hostile target", targetId: context.hostileTarget?.id ?? null };
  }
  if (categories.has("threat") && !damaging && !maintenanceBuff) {
    if (context.role === "tank" || !context.hasDangerousThreat) return null;
    return {
      ability,
-      score: 15_000,
+      score: 1_015_000,
      ruleId: "reactive-threat-drop",
      reason: "non-tank has enemy attention",
      targetId: ability.target === "self" ? null : context.hostileTarget?.id ?? null,
@@ -359,12 +422,14 @@ function scoreAbility(
    && !petSummon && !offensiveSummon) return null;
  if (categories.has("movement") && !damaging && !context.moving) return null;
  if (context.requiredControl && categories.has("control")) {
-    return { ability, score: 16_000, ruleId: "reactive-control", reason: "encounter requested control", targetId: context.hostileTarget?.id ?? null };
+    return { ability, score: 1_016_000, ruleId: "reactive-control", reason: "encounter requested control", targetId: context.hostileTarget?.id ?? null };
  }
  if (offensiveMajorCooldown && !durableTarget) return null;
  if (maintained && (categories.has("debuff") || categories.has("buff"))) return null;
  if (activeSummon && (categories.has("summon") || categories.has("pet"))) return null;
  if (rotationProfile && profileIndex < 0 && !damaging && (maintenanceBuff || petSummon || offensiveSummon)) return null;
+  if (rotationProfile && context.level >= 10 && hasKnownProfileDamageAction
+    && context.role !== "healer" && profileIndex < 0 && damaging) return null;
  if (isComboFinisher(ability) && (context.comboPoints < 4 || context.comboTargetId !== context.hostileTarget?.id)) return null;
  if (isComboBuilder(ability) && context.comboPoints >= 5 && context.comboTargetId === context.hostileTarget?.id) return null;

@@ -374,7 +439,9 @@ function scoreAbility(
  const maintenanceScore = rotationProfile === null ? 5_200 : profileIndex >= 0 ? 7_000 : 2_000;
  const summonScore = rotationProfile === null ? 4_800 : profileIndex >= 0 ? 6_500 : 1_800;
  if (profileIndex >= 0) {
-    score += 4_000 - profileIndex * 120;
+    score += context.role === "healer" || context.level < 10
+      ? 4_000 - profileIndex * 120
+      : 100_000 - profileIndex * 1_000;
    ruleId = `profile-${slug(ability.name)}`;
    reason = `${rotationProfile!.specializationId} priority ${profileIndex + 1}`;
  }
@@ -407,7 +474,7 @@ function scoreAbility(
  } else {
    if (categories.has("mitigation")) {
      if (!maintenanceBuff && selfHealth >= 0.55) return null;
-      if (selfHealth < 0.55) score += selfHealth < 0.35 ? 8_000 : 3_000;
+      if (selfHealth < 0.55) score += selfHealth < 0.35 ? 180_000 : 140_000;
    }
    if (categories.has("execute")) {
      if (targetHealth > 0.2) return null;
@@ -117,7 +117,7 @@ describe("dungeon boss durability and difficulty", () => {
        expect(ordinary.seconds ?? 240, JSON.stringify({ level, seed, ordinary, last })).toBeGreaterThanOrEqual(25);
        expect(last.seconds ?? 240, JSON.stringify({ level, seed, ordinary, last })).toBeGreaterThanOrEqual(45);
      }
-    });
+    }, 30000);
  }

  it("allows real Stockades boss mechanics during a level-three WoW Priest party fight", () => {
@@ -60,11 +60,10 @@ export function partyAbilityIsReady(member: PartyMember, ability: AbilityDefinit
  return !runeCost || spendDeathKnightRunes(member.runes, runeCost, now) !== null;
 }

-function candidateAbilities(member: PartyMember, now: number): readonly AbilityDefinition[] {
+function learnedAbilities(member: PartyMember): readonly AbilityDefinition[] {
  return abilitiesForCharacter(member.classId, member.secondaryClassId)
    .map((ability) => learnedAbilityForBuild(ability, member.level, member.talentRanks))
-    .filter((ability): ability is AbilityDefinition => ability !== null)
-    .filter((ability) => partyAbilityIsReady(member, ability, now));
+    .filter((ability): ability is AbilityDefinition => ability !== null);
 }

 export function choosePartyRotationDecision(
@@ -85,6 +84,7 @@ export function choosePartyRotationDecision(
    [...new Set([...Object.keys(member.resourcePools), member.resourceType])]
      .map((resource) => [resource, companionResourceMaximum(member, resource)]),
  );
+  const learned = learnedAbilities(member);
  return evaluateCombatRotation({
    now: context.now,
    classId: member.classId,
@@ -102,7 +102,11 @@ export function choosePartyRotationDecision(
    comboPoints: member.comboPoints,
    comboTargetId: member.comboTargetId,
    runes: member.runes,
-    abilities: candidateAbilities(member, context.now),
+    abilities: learned.filter((ability) => partyAbilityIsReady(member, ability, context.now)),
+    knownDamagingAbilityNames: new Set(learned.filter((ability) => {
+      const categories = aiHintsForAbility(ability).categories;
+      return categories.includes("damage") || categories.includes("execute");
+    }).map((ability) => ability.name)),
    hostileTarget: context.target,
    friendlyTargets,
    hostileCount: context.hostileCount,
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createDungeonParty, usePartyStore, type PartyMember } from "./partyStore";
+import { createConfiguredPartyMember, createDungeonParty, usePartyStore, type PartyMember } from "./partyStore";
 import { useCombatStore } from "./combatStore";
 import { clearMobRuntimeRegistry, setMobPosition } from "./mobRuntimeRegistry";
 import { clearPartyRuntimeRegistry, registerPartyRuntimePosition, updatePartyRuntimeTargetVisibility } from "./partyRuntimeRegistry";
@@ -76,6 +76,87 @@ describe("NPC sustained damage audit", () => {
    expect(useCombatStore.getState().mobs["area:c"].health).toBe(1_000);
  });

+  it("generates Bear-form Rage from weapon hits and regenerates Cat-form Energy", () => {
+    clearMobRuntimeRegistry();
+    clearPartyRuntimeRegistry();
+    resetPartyRuntimeClock();
+    useCombatStore.getState().initializeCharacter({ classId: "priest", level: 80 });
+    const bear = createConfiguredPartyMember({
+      name: "Balance Bear",
+      classId: "druid",
+      specialization: "Feral (Bear)",
+      specializationId: "druid:feral-bear",
+      talentTreeId: "druid-feral-bear",
+      talentRanks: {},
+      role: "tank",
+    }, 80, 0, "feral-runtime");
+    usePartyStore.setState({ members: [{ ...bear, globalCooldownEndsAt: 60_000 }] });
+    useCombatStore.getState().synchronizeActors();
+    registerPartyRuntimePosition(bear.id, [0, 0, 0]);
+    useCombatStore.getState().registerMob("feral-target", { name: "Training target", maxHealth: 100_000, xpReward: 0 });
+    setMobPosition("feral-target", [2, 0, 0]);
+    useCombatStore.getState().damageMob("feral-target", 1, 100);
+    updatePartyRuntimeTargetVisibility(bear.id, "feral-target", true);
+    advanceDungeonPartyCombat(1_000);
+    expect(usePartyStore.getState().members[0].resourcePools.rage).toBe(6);
+
+    const cat = createConfiguredPartyMember({
+      name: "Balance Cat",
+      classId: "druid",
+      specialization: "Feral (Cat)",
+      specializationId: "druid:feral-cat",
+      talentTreeId: "druid-feral-cat",
+      talentRanks: {},
+      role: "damage",
+    }, 80, 1, "feral-runtime");
+    usePartyStore.setState({ members: [{
+      ...cat,
+      globalCooldownEndsAt: 60_000,
+      resourcePools: { ...cat.resourcePools, energy: 0 },
+    }] });
+    useCombatStore.getState().synchronizeActors();
+    registerPartyRuntimePosition(cat.id, [0, 0, 0]);
+    updatePartyRuntimeTargetVisibility(cat.id, "feral-target", true);
+    advanceDungeonPartyCombat(2_000);
+    expect(usePartyStore.getState().members[0].resourcePools.energy).toBe(10);
+  });
+
+  it("finishes companion casts with the learned level rank instead of rank one", () => {
+    clearMobRuntimeRegistry();
+    clearPartyRuntimeRegistry();
+    resetPartyRuntimeClock();
+    useCombatStore.getState().initializeCharacter({ classId: "priest", level: 80 });
+    const mage = createConfiguredPartyMember({
+      name: "Balance Frost Mage",
+      classId: "mage",
+      specialization: "Frost",
+      specializationId: "mage:frost",
+      talentTreeId: "mage-frost",
+      role: "damage",
+    }, 80, 0, "ranked-cast");
+    const frostbolt = abilitiesForClass("mage").find((ability) => ability.name === "Frostbolt")!;
+    usePartyStore.setState({ members: [{
+      ...mage,
+      cooldowns: Object.fromEntries(abilitiesForClass("mage")
+        .filter((ability) => ability.id !== frostbolt.id)
+        .map((ability) => [ability.id, 60_000])),
+    }] });
+    useCombatStore.getState().synchronizeActors();
+    registerPartyRuntimePosition(mage.id, [-12, 0, 0]);
+    useCombatStore.getState().registerMob("ranked-target", { name: "Training target", maxHealth: 100_000, xpReward: 0 });
+    setMobPosition("ranked-target", [0, 0, 0]);
+    useCombatStore.getState().damageMob("ranked-target", 1, 100);
+    updatePartyRuntimeTargetVisibility(mage.id, "ranked-target", true);
+    for (let now = 1_000; now <= 6_000; now += 100) {
+      useCombatStore.getState().tick(0.1, now);
+      advanceDungeonPartyCombat(now);
+    }
+    const hit = useCombatStore.getState().combatEvents.find((event) => (
+      event.kind === "damage" && event.sourceActorId === mage.id && event.abilityId === frostbolt.id
+    ));
+    expect(hit?.rawAmount).toBeGreaterThan(700);
+  });
+
  for (const level of [1, 3, 5, 20, 80]) {
    it(`executes damaging abilities for every party template at level ${level}`, () => {
      const templates = partyTemplates(level);
@@ -18,7 +18,7 @@ import {
 } from "./abilityRules";
 import type { MobCombatState } from "./combatStore";
 import { useCombatStore } from "./combatStore";
-import { memberFromCompanionActor } from "./combatActorAuthority";
+import { companionResourceMaximum, memberFromCompanionActor } from "./combatActorAuthority";
 import type { MobVector3 } from "./mobPopulation";
 import { requireDungeonDefinition } from "./dungeonRegistry";
 import { getMobPosition } from "./mobRuntimeRegistry";
@@ -713,9 +713,13 @@ function advancePartyWeaponAttack(member: PartyMember, targetId: string, now: nu
      targetActorId: targetId, abilityId, name: "Auto Attack", source: "fallback", school: "physical",
      delivery: baseClassFor(member.classId) === "hunter" ? "projectile" : identity.delivery, origin, targetPosition, instantCast: true });
  }
-  if (member.resourceType !== "rage" || result.amount <= 0) return member;
-  const resource = Math.min(member.maxResource, member.resource + 6);
-  return { ...member, resource, resourcePools: { ...member.resourcePools, rage: resource } };
+  if (member.resourcePools.rage === undefined || result.amount <= 0) return member;
+  const rage = Math.min(companionResourceMaximum(member, "rage"), member.resourcePools.rage + 6);
+  return {
+    ...member,
+    resource: member.resourceType === "rage" ? rage : member.resource,
+    resourcePools: { ...member.resourcePools, rage },
+  };
 }

 function partyFriendlyPosition(actorId: string): MobVector3 | null {
@@ -1207,26 +1211,37 @@ export function advanceDungeonPartyCombat(now = Date.now()): void {
  );
  members = members.map((member) => {
    const profile = resourceProfileForClass(member.classId);
-    const regeneration = (profile.type === "rage" || profile.type === "runic-power")
-      ? 0
-      : profile.regenerationPerSecond + member.gearStats.mp5 / 5 + member.gearStats.spirit * 0.02;
-    const pool = advanceCombatResourcePool(normalizeActorResourcePool(
-      member.resourceType,
-      member.resource,
-      member.maxResource,
-      regeneration,
-      member.lastResourceSpentAt[member.resourceType] ?? 0,
-    ), {
-      inCombat: Boolean(targetId),
-      actorLevel: member.level,
-      now,
-      deltaSeconds,
-      manaSpiritRegenerationPerSecond: member.gearStats.spirit * 0.02,
-    });
+    const passiveRates: Partial<Record<ResourceType, number>> = {
+      mana: 4,
+      rage: 0,
+      energy: 10,
+      focus: 6,
+      "runic-power": 0,
+    };
+    const resourcePools: Partial<Record<ResourceType, number>> = { ...member.resourcePools };
+    for (const type of Object.keys(resourcePools) as ResourceType[]) {
+      const manaRegeneration = member.gearStats.mp5 / 5 + member.gearStats.spirit * 0.02;
+      const regeneration = type === member.resourceType
+        ? (profile.type === "rage" || profile.type === "runic-power" ? 0 : profile.regenerationPerSecond + manaRegeneration)
+        : (passiveRates[type] ?? 0) + (type === "mana" ? manaRegeneration : 0);
+      resourcePools[type] = advanceCombatResourcePool(normalizeActorResourcePool(
+        type,
+        resourcePools[type] ?? 0,
+        companionResourceMaximum(member, type),
+        regeneration,
+        member.lastResourceSpentAt[type] ?? 0,
+      ), {
+        inCombat: Boolean(targetId),
+        actorLevel: member.level,
+        now,
+        deltaSeconds,
+        manaSpiritRegenerationPerSecond: type === "mana" ? member.gearStats.spirit * 0.02 : 0,
+      }).current;
+    }
    return {
      ...member,
-      resource: pool.current,
-      resourcePools: { ...member.resourcePools, [member.resourceType]: pool.current },
+      resource: resourcePools[member.resourceType] ?? member.resource,
+      resourcePools,
      cooldowns: Object.fromEntries(Object.entries(member.cooldowns).filter(([, readyAt]) => readyAt > now)),
      schoolLockedUntil: Object.fromEntries(Object.entries(member.schoolLockedUntil).filter(([, readyAt]) => (readyAt ?? 0) > now)),
    };
@@ -1291,7 +1306,10 @@ export function advanceDungeonPartyCombat(now = Date.now()): void {
      const currentCombat = useCombatStore.getState();
      if (member.activeCast) {
        const activeCast = member.activeCast;
-        const castingAbility = abilityById(member.activeCast.abilityId);
+        const catalogAbility = abilityById(member.activeCast.abilityId);
+        const castingAbility = catalogAbility
+          ? learnedAbilityForBuild(catalogAbility, member.level, member.talentRanks)
+          : null;
        const castTargetId = member.activeCastTargetId;
        if (!castingAbility || !castTargetId) {
          nextMembers[index] = { ...member, activeCast: null, activeCastTargetId: null };
@@ -8,6 +8,7 @@ import {
 } from "../app/characterCatalog";
 import {
  createDungeonParty,
+  createConfiguredPartyMember,
  isHealerSpecialization,
  isTankSpecialization,
  usePartyStore,
@@ -74,6 +75,30 @@ describe("dungeon party composition", () => {
    }
  });

+  it("creates the secondary Rage and Energy pools used by druid forms", () => {
+    const bear = createConfiguredPartyMember({
+      name: "Balance Bear",
+      classId: "druid",
+      specialization: "Feral (Bear)",
+      specializationId: "druid:feral-bear",
+      talentTreeId: "druid-feral-bear",
+      talentRanks: {},
+      role: "tank",
+    }, 80, 0, "feral-resources");
+    const cat = createConfiguredPartyMember({
+      name: "Balance Cat",
+      classId: "druid",
+      specialization: "Feral (Cat)",
+      specializationId: "druid:feral-cat",
+      talentTreeId: "druid-feral-cat",
+      talentRanks: {},
+      role: "damage",
+    }, 80, 1, "feral-resources");
+
+    expect(bear.resourcePools).toMatchObject({ mana: bear.maxResource, rage: 0, energy: 100 });
+    expect(cat.resourcePools).toMatchObject({ mana: cat.maxResource, rage: 0, energy: 100 });
+  });
+
  it("is deterministic per character and scales every ally to the player level", () => {
    const first = createDungeonParty("character-42", 18);
    const second = createDungeonParty("character-42", 18);
@@ -31,7 +31,12 @@ import type { RuntimeTalentRanks as TalentRanks } from "./talentRuntimeCatalog";
 import type { EnemyControlMechanic } from "./enemyAttacks";
 import type { ContentCategoryId } from "../app/contentCategories";
 import type { PartyRole, PartySize } from "./partyRoles";
-import { resourceProfileForClass, type ResourceType } from "./abilityCatalog";
+import {
+  abilitiesForCharacter,
+  learnedAbilityForBuild,
+  resourceProfileForClass,
+  type ResourceType,
+} from "./abilityCatalog";
 import { createDeathKnightRunes, type CombatActorCastState, type DeathKnightRuneState } from "./combatActors";

 export {
@@ -222,6 +227,43 @@ function memberMaxResource(
    : profile.maximum;
 }

+function secondaryResourceMaximum(type: ResourceType): number {
+  if (type === "nature-power") return 10;
+  if (type === "psi") return 6;
+  return 100;
+}
+
+function initialSecondaryResource(type: ResourceType, maximum: number): number {
+  return type === "rage" || type === "runic-power" || type === "nature-power" || type === "psi"
+    ? 0
+    : maximum;
+}
+
+/** Keeps every resource used by the member's learned kit available to companion AI. */
+function withMemberAbilityResourcePools(member: PartyMember): PartyMember {
+  const types = new Set<ResourceType>([member.resourceType]);
+  for (const ability of abilitiesForCharacter(member.classId, member.secondaryClassId)) {
+    const learned = learnedAbilityForBuild(ability, member.level, member.talentRanks);
+    if (!learned) continue;
+    for (const cost of learned.costs?.length ? learned.costs : [learned.cost]) {
+      if (cost.resource !== "health") types.add(cost.resource);
+    }
+  }
+  const resourcePools: Partial<Record<ResourceType, number>> = {};
+  for (const type of types) {
+    if (type === member.resourceType) {
+      resourcePools[type] = member.resource;
+      continue;
+    }
+    const maximum = secondaryResourceMaximum(type);
+    resourcePools[type] = Math.max(0, Math.min(
+      maximum,
+      member.resourcePools[type] ?? initialSecondaryResource(type, maximum),
+    ));
+  }
+  return { ...member, resourcePools: Object.freeze(resourcePools) };
+}
+
 function withMemberGearStats(member: PartyMember, gearStats: ItemStats): PartyMember {
  const maxHealth = memberMaxHealth(
    member.level,
@@ -237,7 +279,7 @@ function withMemberGearStats(member: PartyMember, gearStats: ItemStats): PartyMe
  const resource = Math.max(0, Math.round(
    member.resource / Math.max(1, member.maxResource) * maxResource,
  ));
-  return {
+  return withMemberAbilityResourcePools({
    ...member,
    gearStats,
    health,
@@ -245,7 +287,7 @@ function withMemberGearStats(member: PartyMember, gearStats: ItemStats): PartyMe
    resource,
    maxResource,
    resourcePools: Object.freeze({ ...member.resourcePools, [member.resourceType]: resource }),
-  };
+  });
 }

 function createMember(
@@ -286,7 +328,7 @@ function createMember(
  const resource = Math.round(
    maxResource * (resourceProfile.maximum > 0 ? resourceProfile.initial / resourceProfile.maximum : 0),
  );
-  return {
+  return withMemberAbilityResourcePools({
    id,
    name: template.name,
    raceId: race.id,
@@ -323,7 +365,7 @@ function createMember(
    tauntReadyAt: 0,
    controlledUntil: 0,
    controlMechanic: null,
-  };
+  });
 }

 /** Creates one exact companion while retaining the live party stat/equipment path. */
@@ -339,12 +381,12 @@ export function createConfiguredPartyMember(
    specialization: configuration.specialization,
    talentTreeId: configuration.talentTreeId ?? configuration.specializationId ?? "",
  }, configuration.role, level, index, seed, configuration.talentRanks);
-  return Object.freeze({
+  return Object.freeze(withMemberAbilityResourcePools({
    ...member,
    secondaryClassId: configuration.secondaryClassId ?? null,
    specializationId: configuration.specializationId ?? member.specializationId,
    talentRanks: configuration.talentRanks ?? member.talentRanks,
-  });
+  }));
 }

 /**
@@ -571,7 +613,7 @@ export const usePartyStore = create<PartyState>((set, get) => ({
        const resource = Math.max(0, Math.round(
          member.resource / Math.max(1, member.maxResource) * maxResource,
        ));
-        return {
+        return withMemberAbilityResourcePools({
          ...member,
          level: safeLevel,
          health,
@@ -582,7 +624,7 @@ export const usePartyStore = create<PartyState>((set, get) => ({
          talentRanks: isRomClassId(member.classId)
            ? Object.freeze({})
            : runtimePartyTalentRanksForLevel(member.classId, member.specialization, safeLevel),
-        };
+        });
      }),
    };
  }),
@@ -3236,6 +3236,9 @@ button.equipment-slot:hover { background: rgba(174,191,131,.1); }
 .balance-lab-boss-picker { margin-top: 10px; border: 1px solid var(--front-line); border-radius: 8px; overflow: hidden; }
 .balance-lab-boss-picker > header { display: grid; grid-template-columns: minmax(0, 1fr) auto; align-items: center; gap: 8px; padding: 8px; border-bottom: 1px solid var(--front-line); }
 .balance-lab-boss-picker > header strong { color: #d7c68c; font-size: 8px; white-space: nowrap; }
+.balance-lab-picker-actions { display: flex; align-items: center; gap: 5px; }
+.balance-lab-picker-actions button { padding: 5px 7px; border: 1px solid var(--front-line); border-radius: 5px; color: var(--front-dim); background: rgba(149, 190, 118, .06); cursor: pointer; font: inherit; font-size: 7px; white-space: nowrap; }
+.balance-lab-picker-actions button:hover { color: var(--front-cream); background: rgba(149, 190, 118, .12); }
 .balance-lab-boss-picker > div { display: grid; max-height: 220px; overflow: auto; }
 .balance-lab-boss-picker label { display: grid; grid-template-columns: auto minmax(0, 1fr); align-items: center; gap: 8px; padding: 7px 8px; border-bottom: 1px solid rgba(190, 213, 172, .08); cursor: pointer; }
 .balance-lab-boss-picker label:hover, .balance-lab-boss-picker label.is-selected { background: rgba(149, 190, 118, .1); }
@@ -3243,7 +3246,8 @@ button.equipment-slot:hover { background: rgba(174,191,131,.1); }
 .balance-lab-boss-picker label span, .balance-lab-boss-picker label strong, .balance-lab-boss-picker label small { display: block; min-width: 0; }
 .balance-lab-boss-picker label strong { overflow: hidden; font-size: 9px; text-overflow: ellipsis; white-space: nowrap; }
 .balance-lab-boss-picker label small { margin-top: 2px; color: var(--front-dim); font-size: 7px; }
-.balance-lab-estimate { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 5px; margin-top: 10px; }
+.balance-lab-coverage-note { margin: 8px 0 0; color: var(--front-dim); font-size: 7px; line-height: 1.45; }
+.balance-lab-estimate { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 5px; margin-top: 10px; }
 .balance-lab-estimate span { display: grid; gap: 3px; padding: 8px; border: 1px solid rgba(190, 213, 172, .11); border-radius: 6px; color: var(--front-dim); font-size: 7px; }
 .balance-lab-estimate b { color: var(--front-cream); font-size: 11px; }
 .balance-lab-run { width: 100%; margin-top: 10px; }
@@ -3317,6 +3321,8 @@ button.equipment-slot:hover { background: rgba(174,191,131,.1); }
 .balance-results-chart.is-time .balance-results-bar__track i { background: linear-gradient(90deg, #766130, #d1aa51); }
 .balance-results-chart.is-class .balance-results-bar__track i { background: linear-gradient(90deg, #395e76, #6faac4); }
 .balance-results-chart.is-taken .balance-results-bar__track i { background: linear-gradient(90deg, #6b3d70, #b376b5); }
+.balance-results-chart.is-healing .balance-results-bar__track i { background: linear-gradient(90deg, #327058, #73c995); }
+.balance-results-chart.is-received .balance-results-bar__track i { background: linear-gradient(90deg, #426a7a, #82c5c7); }
 .balance-results-bar > strong { color: #d8d2b5; font-size: 7px; text-align: right; white-space: nowrap; }
 .balance-results-chart > footer { padding: 7px 11px; border-top: 1px solid rgba(190, 213, 172, .08); color: var(--front-dim); font-size: 6px; }
 .balance-results-empty { padding: 18px 8px; color: var(--front-dim); font-size: 8px; text-align: center; }
@@ -3336,12 +3342,21 @@ button.equipment-slot:hover { background: rgba(174,191,131,.1); }
 .balance-results td strong, .balance-results td small { display: block; }
 .balance-results td strong { color: #dfe7d7; font-size: 8px; }
 .balance-results td small { max-width: 180px; margin-top: 2px; overflow: hidden; color: var(--front-dim); font-size: 6px; text-overflow: ellipsis; }
+.balance-results-drilldown { display: block; margin-top: 6px; padding: 4px 6px; border: 1px solid rgba(111, 170, 196, .34); border-radius: 5px; color: #b8d9e7; background: rgba(57, 94, 118, .18); cursor: pointer; font: inherit; font-size: 6px; white-space: nowrap; }
+.balance-results-drilldown:hover:not(:disabled), .balance-results-drilldown:focus-visible { border-color: rgba(125, 199, 231, .7); background: rgba(57, 94, 118, .34); }
+.balance-results-drilldown:disabled { border-color: var(--front-line); color: var(--front-dim); background: transparent; cursor: not-allowed; }
 .balance-results td.balance-results-members { min-width: 300px; max-width: 540px; white-space: normal; line-height: 1.5; }
 .balance-results-flag { display: inline-block; padding: 3px 5px; border-radius: 4px; color: #cbd7c5; background: rgba(116, 138, 107, .14); }
 .balance-results-flag.is-high { color: #efb8aa; background: rgba(155, 65, 50, .18); }
 .balance-results-flag.is-low { color: #b8d6ee; background: rgba(60, 111, 147, .18); }
 .balance-results-abilities { display: grid; min-width: 0; gap: 10px; }
 .balance-results-abilities > .balance-results-chart { width: 100%; }
+.balance-results-drilldown-banner { display: flex; align-items: center; justify-content: space-between; gap: 12px; padding: 10px 12px; border: 1px solid rgba(111, 170, 196, .28); border-radius: 8px; background: linear-gradient(100deg, rgba(57, 94, 118, .2), rgba(8, 19, 16, .45)); }
+.balance-results-drilldown-banner > div, .balance-results-drilldown-banner span, .balance-results-drilldown-banner strong, .balance-results-drilldown-banner small { display: block; }
+.balance-results-drilldown-banner span { color: #79abc1; font-size: 6px; letter-spacing: .09em; text-transform: uppercase; }
+.balance-results-drilldown-banner strong { margin-top: 2px; color: #e1edf0; font: 15px/1.25 Georgia, serif; }
+.balance-results-drilldown-banner small { margin-top: 2px; color: var(--front-dim); font-size: 7px; }
+.balance-results-drilldown-banner button { padding: 7px 9px; border: 1px solid rgba(111, 170, 196, .34); border-radius: 6px; color: #c8e1e9; background: rgba(1, 7, 5, .62); cursor: pointer; font: inherit; font-size: 7px; white-space: nowrap; }
 .balance-results-summary--abilities article:nth-child(3) strong { color: #efb8aa; }
 .balance-results-ability-controls { display: grid; grid-template-columns: minmax(170px, 1.15fr) minmax(145px, .9fr) minmax(145px, .9fr) auto; gap: 6px; min-width: min(680px, 60vw); }
 .balance-results-ability-controls select { width: 100%; min-width: 0; padding: 7px 8px; border: 1px solid var(--front-line); border-radius: 6px; outline: 0; color: var(--front-cream); background: rgba(1, 7, 5, .8); font: inherit; font-size: 7px; }
@@ -3374,6 +3389,7 @@ button.equipment-slot:hover { background: rgba(174,191,131,.1); }
  .balance-results__tabs button { white-space: nowrap; }
  .balance-results-table-panel > header { display: grid; }
  .balance-results-sort { width: 100%; min-width: 0; }
+  .balance-results-drilldown-banner { align-items: start; flex-direction: column; }
  .balance-results-ability-controls { width: 100%; min-width: 0; grid-template-columns: 1fr; }
  .balance-results-bar { grid-template-columns: minmax(90px, 40%) minmax(55px, 1fr) minmax(40px, auto); gap: 5px; }
 }
@@ -58,7 +58,7 @@ function BarChart({
  readonly description: string;
  readonly rows: readonly ChartDatum[];
  readonly format?: (value: number) => string;
-  readonly tone?: "damage" | "party" | "time" | "class" | "taken";
+  readonly tone?: "damage" | "party" | "time" | "class" | "taken" | "healing" | "received";
 }) {
  const sorted = [...rows].filter((row) => Number.isFinite(row.value)).sort((left, right) => right.value - left.value);
  const visible = sorted.slice(0, 15);
@@ -129,6 +129,8 @@ export function BalanceLabResults({ report }: { readonly report: BalanceLabSuite
      || left[1].specialization.localeCompare(right[1].specialization)
    ));
  }, [allAbilities]);
+  const abilityBuildKeys = useMemo(() => new Set(abilityBuildOptions.map(([key]) => key)), [abilityBuildOptions]);
+  const selectedAbilityBuild = abilityBuildOptions.find(([key]) => key === abilityBuild)?.[1] ?? null;
  const abilities = useMemo(() => allAbilities.filter((row) => {
    const buildKey = `${row.source}/${row.buildId}`;
    const matchesStatus = abilityStatus === "all"
@@ -184,6 +186,19 @@ export function BalanceLabResults({ report }: { readonly report: BalanceLabSuite
  const usedAbilityCount = abilities.filter((row) => row.activeRuns > 0).length;
  const filteredAbilityDamage = abilities.reduce((total, row) => total + row.effectiveDamage, 0);

+  const openAbilityDrilldown = (row: BalanceLabClassSpecResult) => {
+    const buildKey = `${row.source}/${row.buildId}`;
+    setPartySource(row.source === "wow" || row.source === "coa" || row.source === "rom" ? row.source : "all");
+    setRole(row.role);
+    setSearch("");
+    setAbilityBuild(buildKey);
+    setAbilityStatus("damage");
+    setAbilitySort("effectiveDamage");
+    setAscending(false);
+    setTab("abilities");
+    window.requestAnimationFrame(() => document.querySelector(".balance-results")?.scrollIntoView({ behavior: "smooth", block: "start" }));
+  };
+
  return (
    <section className="balance-results" aria-label="Balance Lab report analysis">
      <header className="balance-results__header">
@@ -217,6 +232,8 @@ export function BalanceLabResults({ report }: { readonly report: BalanceLabSuite
          <BarChart title="Kill times" description="Average seconds to defeat; bosses never defeated are listed in the boss table as —." rows={bossChart("averageTimeToDefeat")} format={formatSeconds} tone="time" />
          <BarChart title="Class/spec boss damage" description="Every tested build ranked by DPS applied directly to bosses." rows={classChart("bossDps")} tone="class" />
          <BarChart title="Damage taken by class/spec" description="Incoming damage per second by build; useful for survivability and healer-load checks." rows={classChart("dtps")} tone="taken" />
+          <BarChart title="Healing done by class/spec" description="Effective healing per second, excluding overhealing. Compare healer output with boss pressure and healer DPS." rows={classChart("hps")} tone="healing" />
+          <BarChart title="Healing received by class/spec" description="Effective healing received per second. New runs attribute every heal to its party target, including self-heals." rows={classChart("hpsReceived")} tone="received" />
        </div>
      </div>}

@@ -226,19 +243,24 @@ export function BalanceLabResults({ report }: { readonly report: BalanceLabSuite
      </div>}

      {tab === "classes" && <div className="balance-results-table-panel">
-        <header><div><h3>Every class and specialization</h3><p>{sortedClasses.length} matching builds · output, healing, mitigation, survivability, and role-relative tuning.</p></div><div className="balance-results-sort"><select aria-label="Sort class specs" value={classSort} onChange={(event) => setClassSort(event.currentTarget.value as keyof BalanceLabClassSpecResult)}><option value="bossDps">Boss DPS</option><option value="dps">Total DPS</option><option value="hps">HPS</option><option value="dtps">Damage taken / sec</option><option value="totalDamageTaken">Total damage taken</option><option value="totalDamage">Total damage dealt</option><option value="totalHealing">Total healing</option><option value="totalAbsorbs">Total absorbs</option><option value="deathEvents">Deaths</option></select><button type="button" onClick={() => setAscending((value) => !value)}>{ascending ? "Low → high" : "High → low"}</button></div></header>
-        <div className="balance-results-table-wrap"><table><thead><tr><th>Class / specialization</th><th>Source</th><th>Role</th><th>Parties</th><th>Runs</th><th>Boss DPS</th><th>Total DPS</th><th>HPS</th><th>Damage taken / sec</th><th>Total damage taken</th><th>Role median</th><th>Total damage dealt</th><th>Total healing</th><th>Absorbs</th><th>Deaths</th></tr></thead><tbody>{sortedClasses.map((row) => <tr key={`${row.source}/${row.buildId}`}><td><strong>{row.className}</strong><small>{row.specialization}</small></td><td>{row.source.toUpperCase()}</td><td>{row.role}</td><td>{row.partyConfigurations.toLocaleString()}</td><td>{row.runs.toLocaleString()}</td><td>{formatNumber(row.bossDps)}</td><td>{formatNumber(row.dps)}</td><td>{formatNumber(row.hps)}</td><td>{formatNumber(row.dtps)}</td><td>{formatWhole(row.totalDamageTaken)}</td><td><span className={`balance-results-flag ${flagClass(row.damageFlag)}`}>{formatRatio(row.damageVsSourceRoleMedian)} · {row.damageFlag}</span></td><td>{formatWhole(row.totalDamage)}</td><td>{formatWhole(row.totalHealing)}</td><td>{formatWhole(row.totalAbsorbs)}</td><td>{row.deathEvents.toLocaleString()}</td></tr>)}</tbody></table></div>
+        <header><div><h3>Every class and specialization</h3><p>{sortedClasses.length} matching builds · output, healing, mitigation, survivability, and role-relative tuning.</p></div><div className="balance-results-sort"><select aria-label="Sort class specs" value={classSort} onChange={(event) => setClassSort(event.currentTarget.value as keyof BalanceLabClassSpecResult)}><option value="bossDps">Boss DPS</option><option value="dps">Total DPS</option><option value="hps">Healing done / sec</option><option value="hpsReceived">Healing received / sec</option><option value="dtps">Damage taken / sec</option><option value="totalDamageTaken">Total damage taken</option><option value="totalDamage">Total damage dealt</option><option value="totalHealing">Total healing done</option><option value="totalHealingReceived">Total healing received</option><option value="totalAbsorbs">Total absorbs</option><option value="deathEvents">Deaths</option></select><button type="button" onClick={() => setAscending((value) => !value)}>{ascending ? "Low → high" : "High → low"}</button></div></header>
+        <div className="balance-results-table-wrap"><table><thead><tr><th>Class / specialization</th><th>Source</th><th>Role</th><th>Parties</th><th>Runs</th><th>Boss DPS</th><th>Total DPS</th><th>Healing done / sec</th><th>Healing received / sec</th><th>Damage taken / sec</th><th>Total damage taken</th><th>Role median</th><th>Total damage dealt</th><th>Total healing done</th><th>Total healing received</th><th>Absorbs</th><th>Deaths</th></tr></thead><tbody>{sortedClasses.map((row) => {
+          const buildKey = `${row.source}/${row.buildId}`;
+          const hasAbilityData = abilityBuildKeys.has(buildKey);
+          return <tr key={buildKey}><td><strong>{row.className}</strong><small>{row.specialization}</small><button className="balance-results-drilldown" type="button" disabled={!hasAbilityData} onClick={() => openAbilityDrilldown(row)} aria-label={`View ${row.className} ${row.specialization} ability damage`}>{hasAbilityData ? "View ability damage" : "No ability data"}</button></td><td>{row.source.toUpperCase()}</td><td>{row.role}</td><td>{row.partyConfigurations.toLocaleString()}</td><td>{row.runs.toLocaleString()}</td><td>{formatNumber(row.bossDps)}</td><td>{formatNumber(row.dps)}</td><td>{formatNumber(row.hps)}</td><td>{formatNumber(row.hpsReceived)}</td><td>{formatNumber(row.dtps)}</td><td>{formatWhole(row.totalDamageTaken)}</td><td><span className={`balance-results-flag ${flagClass(row.damageFlag)}`}>{formatRatio(row.damageVsSourceRoleMedian)} · {row.damageFlag}</span></td><td>{formatWhole(row.totalDamage)}</td><td>{formatWhole(row.totalHealing)}</td><td>{formatWhole(row.totalHealingReceived)}</td><td>{formatWhole(row.totalAbsorbs)}</td><td>{row.deathEvents.toLocaleString()}</td></tr>;
+        })}</tbody></table></div>
      </div>}

      {tab === "abilities" && <div className="balance-results-abilities">
        {allAbilities.length === 0 ? <p className="balance-results-legacy-note">This saved run predates ability-level reporting. Run the same configuration again to populate ability use, unused abilities, damage share, healing, and absorbs.</p> : <>
+          {selectedAbilityBuild && <div className="balance-results-drilldown-banner"><div><span>Spec damage drill-down</span><strong>{selectedAbilityBuild.className} · {selectedAbilityBuild.specialization}</strong><small>{selectedAbilityBuild.source.toUpperCase()} · {selectedAbilityBuild.role} · ability damage ranked by effective damage</small></div><button type="button" onClick={() => { setAbilityBuild("all"); setAbilityStatus("all"); setPartySource("all"); setRole("all"); }}>Show all specs</button></div>}
          <div className="balance-results-summary balance-results-summary--abilities">
            <article><span>Matching abilities</span><strong>{abilities.length.toLocaleString()}</strong></article>
            <article><span>Used in at least one run</span><strong>{usedAbilityCount.toLocaleString()}</strong></article>
            <article><span>Available but unused</span><strong>{unusedAbilityCount.toLocaleString()}</strong></article>
            <article><span>Filtered effective damage</span><strong>{formatWhole(filteredAbilityDamage)}</strong></article>
          </div>
-          <BarChart title="Ability damage contribution" description="Effective damage by ability for the selected source, role, class/spec, status, and text filters." rows={abilityChart("effectiveDamage")} tone="class" />
+          <BarChart title={selectedAbilityBuild ? `${selectedAbilityBuild.className} · ${selectedAbilityBuild.specialization} ability damage` : "Ability damage contribution"} description="Effective damage by ability for the selected source, role, class/spec, status, and text filters. Casts, hits, DPS, damage share, and damage per hit are listed below." rows={abilityChart("effectiveDamage")} tone="class" />
          <div className="balance-results-table-panel">
            <header><div><h3>Every class/spec ability</h3><p>{sortedAbilities.length} matching abilities · {availableAbilityCount} are available to the tested builds. Zero-use rows are deliberately retained.</p></div><div className="balance-results-ability-controls">
              <select aria-label="Filter ability class spec" value={abilityBuild} onChange={(event) => setAbilityBuild(event.currentTarget.value)}><option value="all">All class/specs</option>{abilityBuildOptions.map(([key, row]) => <option key={key} value={key}>{row.source.toUpperCase()} · {row.className} — {row.specialization}</option>)}</select>
@@ -12,9 +12,15 @@ import {
  type BalanceLabJob,
  type BalanceLabPartySource,
  type BalanceLabRuntimeStatus,
+  type BalanceLabSpecSelection,
  type BalanceLabSuiteReport,
 } from "../app/balanceLabClient";
+import { classById } from "../app/characterCatalog";
 import { BOSS_TESTING_CATALOG } from "../game/bossTesting";
+import {
+  selectableBenchmarkBuildCatalog,
+  type SelectableBenchmarkBuildCatalogEntry,
+} from "../game/benchmark/benchmarkBuilds";
 import { BalanceLabResults } from "./BalanceLabResults";
 import { BrandMark, FrontSurface } from "./FrontSurface";

@@ -60,10 +66,24 @@ function describeJob(job: BalanceLabJob): string {
  return `Party ${party}/${job.progress.partiesTotal}${simulation}`;
 }

+function coveragePartyCount(builds: readonly SelectableBenchmarkBuildCatalogEntry[]): number {
+  const bySource = new Map<string, SelectableBenchmarkBuildCatalogEntry[]>();
+  for (const build of builds) bySource.set(build.source, [...(bySource.get(build.source) ?? []), build]);
+  return [...bySource.values()].reduce((total, rows) => {
+    const tanks = rows.filter((build) => build.role === "tank").length;
+    const healers = rows.filter((build) => build.role === "healer").length;
+    const damage = rows.filter((build) => build.role === "damage").length;
+    return total + Math.max(1, tanks, healers, Math.ceil(damage / 3));
+  }, 0);
+}
+
 export function BalanceLabScreen({ onClose }: { readonly onClose: () => void }) {
  const session = useShellStore((state) => state.session);
  const token = session?.accessToken ?? "";
  const [source, setSource] = useState<BalanceLabPartySource>("all");
+  const [specSelection, setSpecSelection] = useState<BalanceLabSpecSelection>("random");
+  const [specSearch, setSpecSearch] = useState("");
+  const [selectedBuildIds, setSelectedBuildIds] = useState<readonly string[]>([]);
  const [level, setLevel] = useState(60);
  const [partyConfigurations, setPartyConfigurations] = useState(10);
  const [simulationsPerParty, setSimulationsPerParty] = useState(3);
@@ -90,9 +110,26 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
    const query = jobSearch.trim().toLowerCase();
    return jobs.filter((job) => (
      (jobStatus === "all" || job.status === jobStatus)
-      && (!query || `${job.requestedBy} ${job.spec.source} ${job.spec.level} ${job.id} ${job.status}`.toLowerCase().includes(query))
+      && (!query || `${job.requestedBy} ${job.spec.source} ${job.spec.level} ${job.spec.specSelection ?? "random"} ${job.id} ${job.status}`.toLowerCase().includes(query))
    ));
  }, [jobSearch, jobStatus, jobs]);
+  const availableBuilds = useMemo(() => selectableBenchmarkBuildCatalog(
+    Number.isFinite(level) ? level : 60,
+  ).filter((build) => source === "all" || build.source === source).sort((left, right) => (
+    left.source.localeCompare(right.source)
+    || classById(left.classId).name.localeCompare(classById(right.classId).name)
+    || left.orientation.localeCompare(right.orientation)
+    || left.role.localeCompare(right.role)
+  )), [level, source]);
+  const selectedBuildSet = useMemo(() => new Set(selectedBuildIds), [selectedBuildIds]);
+  const selectedBuilds = useMemo(() => availableBuilds.filter((build) => selectedBuildSet.has(build.id)), [
+    availableBuilds,
+    selectedBuildSet,
+  ]);
+  const filteredBuilds = useMemo(() => {
+    const query = specSearch.trim().toLowerCase();
+    return availableBuilds.filter((build) => !query || `${classById(build.classId).name} ${build.orientation} ${build.role} ${build.source} ${build.id}`.toLowerCase().includes(query));
+  }, [availableBuilds, specSearch]);
  const filteredBosses = useMemo(() => {
    const query = bossSearch.trim().toLowerCase();
    return BOSS_TESTING_CATALOG.filter((boss) => !query
@@ -102,7 +139,11 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
  const bossCount = bossScope === "specific"
    ? selectedBossKeys.length
    : BOSS_TESTING_CATALOG.filter((boss) => bossScope === "all" || boss.category === bossScope).length;
-  const partyCount = partyConfigurations * (source === "all" ? 3 : 1);
+  const coverageBuilds = specSelection === "all" ? availableBuilds : selectedBuilds;
+  const partyCount = specSelection === "random"
+    ? partyConfigurations * (source === "all" ? 3 : 1)
+    : coveragePartyCount(coverageBuilds);
+  const coveredSpecCount = specSelection === "all" ? availableBuilds.length : selectedBuilds.length;
  const estimatedRuns = partyCount * bossCount * simulationsPerParty;

  useEffect(() => {
@@ -172,6 +213,12 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
      : [...current, key]);
  };

+  const toggleBuild = (id: string) => {
+    setSelectedBuildIds((current) => current.includes(id)
+      ? current.filter((candidate) => candidate !== id)
+      : [...current, id]);
+  };
+
  const run = async () => {
    if (!runtimeStatus?.available) {
      setError(runtimeStatus?.error ?? "The server Balance Lab runtime is unavailable.");
@@ -181,13 +228,19 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
      setError("Select at least one boss for a specific-boss run.");
      return;
    }
+    if (specSelection === "specific" && selectedBuilds.length === 0) {
+      setError("Select at least one class/spec for a specific-spec run.");
+      return;
+    }
    setSubmitting(true);
    setError("");
    try {
      const job = await startBalanceLabJob({
        source,
+        specSelection,
+        selectedBuildIds: specSelection === "specific" ? selectedBuilds.map((build) => build.id) : [],
        level,
-        partyConfigurations,
+        partyConfigurations: specSelection === "random" ? partyConfigurations : partyCount,
        simulationsPerParty,
        durationSeconds,
        partySeed,
@@ -242,11 +295,23 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
            <span>{runtimeStatus.available ? runtimeStatus.version : `${runtimeStatus.error} Install Python 3 in the server container, set BALANCE_LAB_PYTHON=python3, and restart the app.`}</span>
          </div>}
          <div className="balance-lab-form-grid">
-            <label><span>Party source</span><select value={source} onChange={(event) => setSource(event.currentTarget.value as BalanceLabPartySource)}>
+            <label><span>Party source</span><select value={source} onChange={(event) => {
+              setSource(event.currentTarget.value as BalanceLabPartySource);
+              setSelectedBuildIds([]);
+              setSpecSearch("");
+            }}>
              <option value="all">WoW + CoA + RoM</option><option value="wow">WoW only</option><option value="coa">CoA only</option><option value="rom">RoM only</option>
            </select></label>
-            <label><span>Level</span><input type="number" min={1} max={80} value={level} onChange={(event) => setLevel(event.currentTarget.valueAsNumber)} /></label>
-            <label><span>Parties per source</span><input type="number" min={1} max={100} value={partyConfigurations} onChange={(event) => setPartyConfigurations(event.currentTarget.valueAsNumber)} /></label>
+            <label><span>Level</span><input type="number" min={1} max={80} value={level} onChange={(event) => {
+              setLevel(event.currentTarget.valueAsNumber);
+              setSelectedBuildIds([]);
+            }} /></label>
+            <label className="balance-lab-form-grid__wide"><span>Class/spec selection</span><select value={specSelection} onChange={(event) => setSpecSelection(event.currentTarget.value as BalanceLabSpecSelection)}>
+              <option value="random">Random parties</option><option value="all">All specs</option><option value="specific">Specific specs</option>
+            </select></label>
+            {specSelection === "random"
+              ? <label><span>Parties per source</span><input type="number" min={1} max={100} value={partyConfigurations} onChange={(event) => setPartyConfigurations(event.currentTarget.valueAsNumber)} /></label>
+              : <label><span>Coverage parties</span><input type="number" readOnly value={partyCount} /></label>}
            <label><span>Runs per party/boss</span><input type="number" min={1} max={100} value={simulationsPerParty} onChange={(event) => setSimulationsPerParty(event.currentTarget.valueAsNumber)} /></label>
            <label><span>Fight limit (seconds)</span><input type="number" min={5} max={600} value={durationSeconds} onChange={(event) => setDurationSeconds(event.currentTarget.valueAsNumber)} /></label>
            <label><span>Party seed</span><input type="number" value={partySeed} onChange={(event) => setPartySeed(event.currentTarget.valueAsNumber)} /></label>
@@ -254,6 +319,25 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
              <option value="all">All bosses</option><option value="wow">WoW bosses</option><option value="rom">RoM bosses</option><option value="specific">Specific selection</option>
            </select></label>
          </div>
+          {specSelection !== "random" && <p className="balance-lab-coverage-note">
+            {specSelection === "all"
+              ? `${coveredSpecCount} class/spec builds will be covered at least once across the minimum valid party set.`
+              : `${coveredSpecCount} selected class/spec builds will be covered; unselected specs fill required party roles.`}
+          </p>}
+          {specSelection === "specific" && (
+            <section className="balance-lab-boss-picker balance-lab-spec-picker">
+              <header>
+                <input aria-label="Search Balance Lab class specs" value={specSearch} onChange={(event) => setSpecSearch(event.currentTarget.value)} placeholder="Search class, spec, role, or source" />
+                <span className="balance-lab-picker-actions"><button type="button" onClick={() => setSelectedBuildIds((current) => [...new Set([...current, ...filteredBuilds.map((build) => build.id)])])}>Select visible</button><button type="button" onClick={() => setSelectedBuildIds([])}>Clear</button><strong>{selectedBuilds.length} selected</strong></span>
+              </header>
+              <div role="listbox" aria-label="Balance Lab class specs" aria-multiselectable="true">
+                {filteredBuilds.map((build) => <label key={build.id} role="option" aria-selected={selectedBuildSet.has(build.id)} className={selectedBuildSet.has(build.id) ? "is-selected" : ""}>
+                  <input type="checkbox" checked={selectedBuildSet.has(build.id)} onChange={() => toggleBuild(build.id)} />
+                  <span><strong>{classById(build.classId).name} · {build.orientation}</strong><small>{build.source.toUpperCase()} · {build.role}</small></span>
+                </label>)}
+              </div>
+            </section>
+          )}
          {bossScope === "specific" && (
            <section className="balance-lab-boss-picker">
              <header><input aria-label="Search Balance Lab bosses" value={bossSearch} onChange={(event) => setBossSearch(event.currentTarget.value)} placeholder="Search boss, dungeon, or key" /><strong>{selectedBossKeys.length} selected</strong></header>
@@ -265,7 +349,7 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
              </div>
            </section>
          )}
-          <div className="balance-lab-estimate"><span>Party configurations <b>{partyCount.toLocaleString()}</b></span><span>Bosses <b>{bossCount.toLocaleString()}</b></span><span>Total simulations <b>{estimatedRuns.toLocaleString()}</b></span></div>
+          <div className="balance-lab-estimate"><span>Party configurations <b>{partyCount.toLocaleString()}</b></span><span>Class/spec coverage <b>{specSelection === "random" ? "Random" : coveredSpecCount.toLocaleString()}</b></span><span>Bosses <b>{bossCount.toLocaleString()}</b></span><span>Total simulations <b>{estimatedRuns.toLocaleString()}</b></span></div>
          <button className="front-button front-button--primary balance-lab-run" type="button" disabled={submitting || !runtimeStatus?.available || !Number.isFinite(estimatedRuns) || estimatedRuns < 1} onClick={() => void run()}>{submitting ? "Queuing…" : runtimeStatus && !runtimeStatus.available ? "Server runtime unavailable" : "Run on server"}</button>
          <p className="balance-lab-local-note">To spend this device's CPU instead, run <code>npm run balance:lab</code> from the project checkout.</p>
          {error && <p className="front-notice" role="alert">{error}</p>}
@@ -279,7 +363,7 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
          <div className="balance-lab-history-filters"><input type="search" aria-label="Search Balance Lab run history" placeholder="Find source, level, GM…" value={jobSearch} onChange={(event) => setJobSearch(event.currentTarget.value)} /><select aria-label="Filter Balance Lab run status" value={jobStatus} onChange={(event) => setJobStatus(event.currentTarget.value as "all" | BalanceLabJob["status"])}><option value="all">All statuses</option><option value="complete">Complete</option><option value="running">Running</option><option value="queued">Queued</option><option value="failed">Failed</option></select></div>
          <div className="balance-lab-job-list">
            {visibleJobs.map((job) => <button key={job.id} type="button" className={job.id === selectedJob?.id ? "is-selected" : ""} onClick={() => setSelectedJobId(job.id)}>
-              <span><strong>{job.spec.source.toUpperCase()} level {job.spec.level}</strong><small>{new Date(job.createdAt).toLocaleString()} · {job.requestedBy}</small>{job.summary && <small>{job.summary.bosses.toLocaleString()} bosses · {job.summary.runs.toLocaleString()} simulations</small>}</span><em className={`is-${job.status}`}>{job.status}</em>
+              <span><strong>{job.spec.source.toUpperCase()} level {job.spec.level}</strong><small>{new Date(job.createdAt).toLocaleString()} · {job.requestedBy} · {job.spec.specSelection ?? "random"} specs</small>{job.summary && <small>{job.summary.bosses.toLocaleString()} bosses · {job.summary.runs.toLocaleString()} simulations</small>}</span><em className={`is-${job.status}`}>{job.status}</em>
            </button>)}
            {!loading && visibleJobs.length === 0 && <p className="balance-lab-empty">No saved runs match these filters.</p>}
          </div>
@@ -291,7 +375,7 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
            <p>{describeJob(selectedJob)}</p>
            <div className="balance-lab-progress" aria-label={`${progressPercent(selectedJob).toFixed(0)} percent complete`}><span style={{ width: `${progressPercent(selectedJob)}%` }} /></div>
            <dl>
-              <div><dt>Status</dt><dd>{selectedJob.status}</dd></div><div><dt>Parties</dt><dd>{selectedJob.progress.partiesTotal}</dd></div><div><dt>Runs per pairing</dt><dd>{selectedJob.spec.simulationsPerParty}</dd></div><div><dt>Boss filter</dt><dd>{selectedJob.spec.bossKeys.length ? `${selectedJob.spec.bossKeys.length} selected` : selectedJob.spec.bossCategory}</dd></div><div><dt>Fight limit</dt><dd>{selectedJob.spec.durationSeconds}s</dd></div>
+              <div><dt>Status</dt><dd>{selectedJob.status}</dd></div><div><dt>Parties</dt><dd>{selectedJob.progress.partiesTotal}</dd></div><div><dt>Spec selection</dt><dd>{selectedJob.spec.specSelection ?? "random"}{selectedJob.spec.specSelection === "specific" ? ` · ${selectedJob.spec.selectedBuildIds?.length ?? 0} selected` : ""}</dd></div><div><dt>Runs per pairing</dt><dd>{selectedJob.spec.simulationsPerParty}</dd></div><div><dt>Boss filter</dt><dd>{selectedJob.spec.bossKeys.length ? `${selectedJob.spec.bossKeys.length} selected` : selectedJob.spec.bossCategory}</dd></div><div><dt>Fight limit</dt><dd>{selectedJob.spec.durationSeconds}s</dd></div>
            </dl>
            {selectedJob.status === "complete" && <div className="balance-lab-artifacts"><button type="button" className="front-button front-button--primary" onClick={() => document.getElementById("balance-lab-analysis")?.scrollIntoView({ behavior: "smooth", block: "start" })}>View graphs and filterable data</button>{selectedJob.artifacts.map((name) => <button key={name} type="button" className="front-button" onClick={() => void openArtifact(selectedJob, name)}>{ARTIFACT_LABELS[name] ?? name}</button>)}</div>}
            {selectedJob.logTail.length > 0 && <details className="balance-lab-log"><summary>Server progress log</summary><pre>{selectedJob.logTail.slice(-20).join("\n")}</pre></details>}
Author	SHA1	Message	Date
phenom	d6976e6ef6	Release Healer Man 0.1.53	2026-09-18 12:32:51 -04:00
phenom	d0a02487db	Release Healer Man 0.1.52	2026-09-18 09:34:59 -04:00
phenom	dd583023ac	Release Healer Man 0.1.51	2026-09-17 18:01:29 -04:00
phenom	79153ca40d	Release Healer Man 0.1.50	2026-09-17 13:33:55 -04:00
phenom	717d12e5af	Document Obsidian project memory	2026-09-17 11:36:54 -04:00