Update Healer Man server

2026-09-19 21:01:51 -04:00
1 parent f8314e7de1
commit 1fedb9368d
@@ -13,6 +13,8 @@ import {
  loadGameRuntime,
  preloadSharedGameplayResources,
 } from "./ui/gameplayResources";
+import { useCompanionCooldownPolicyStore } from "./game/companionCooldownPolicyStore";
+import { useCompanionSpecReadinessStore } from "./game/companionSpecReadinessStore";

 const GameRuntime = lazy(loadGameRuntime);
 const CharacterCreateScreen = lazy(() => import("./ui/CharacterCreateScreen").then((module) => ({ default: module.CharacterCreateScreen })));
@@ -72,6 +74,11 @@ export default function App() {
  const phase = useShellStore((state) => state.phase);
  const session = useShellStore((state) => state.session);
  const PreloadedGameRuntime = getLoadedGameRuntime();
+  const refreshCooldownPolicy = useCompanionCooldownPolicyStore((state) => state.refresh);
+  const refreshSpecReadiness = useCompanionSpecReadinessStore((state) => state.refresh);
+
+  useEffect(() => { void refreshCooldownPolicy(session); }, [refreshCooldownPolicy, session]);
+  useEffect(() => { void refreshSpecReadiness(session); }, [refreshSpecReadiness, session]);

  useEffect(() => {
    if (!SHELVED_MODES_ENABLED && isShelvedShellPhase(phase)) {
@@ -4,6 +4,28 @@ 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 type BalanceLabExecutionTarget = "server" | "local";
+
+function balanceLabApiPath(target: BalanceLabExecutionTarget, suffix: string): string {
+  const root = target === "local" ? "/api/local/balance-lab" : "/api/gm/balance-lab";
+  return `${root}${suffix}`;
+}
+
+async function requestBalanceLabJson<T>(
+  pathname: string,
+  init: RequestInit,
+  token: string,
+  target: BalanceLabExecutionTarget,
+): Promise<T> {
+  if (target === "server") return requestOnlineJson<T>(pathname, init, token);
+  const headers = new Headers(init.headers);
+  headers.set("Accept", "application/json");
+  if (init.body !== undefined) headers.set("Content-Type", "application/json");
+  const response = await fetch(pathname, { ...init, headers });
+  const body = await response.json().catch(() => ({})) as T & { error?: string };
+  if (!response.ok) throw new Error(body.error ?? `Local Balance Lab request failed (${response.status}).`);
+  return body;
+}

 export interface BalanceLabRuntimeStatus {
  readonly available: boolean;
@@ -27,6 +49,8 @@ export interface BalanceLabJobSpec {
  readonly partySeed: number;
  readonly bossCategory: BalanceLabBossCategory;
  readonly bossKeys: readonly string[];
+  readonly seatSweep?: boolean;
+  readonly includeBetaSpecs?: boolean;
 }

 export interface BalanceLabJob {
@@ -56,6 +80,8 @@ export interface BalanceLabReportSummary {
  readonly runs: number;
  readonly classSpecs: number;
  readonly classAbilities: number;
+  readonly npcClassSpecs?: number;
+  readonly npcClassAbilities?: number;
  readonly bossPressureMedianDtps: number;
 }

@@ -82,6 +108,13 @@ export interface BalanceLabBossResult {
 export interface BalanceLabClassSpecResult {
  readonly source: string;
  readonly buildId: string;
+  readonly characterName?: string | null;
+  readonly talentBuildId?: string | null;
+  readonly talentBuildName?: string | null;
+  readonly talentBuildSource?: string | null;
+  readonly talentBuildSourcePointCount?: number | null;
+  readonly talentBuildSourcePointsRetained?: number | null;
+  readonly talentBuildFallbackPointCount?: number | null;
  readonly classId: string;
  readonly className: string;
  readonly specialization: string;
@@ -93,6 +126,7 @@ export interface BalanceLabClassSpecResult {
  readonly hps: number;
  readonly hpsReceived?: number;
  readonly dtps: number;
+  readonly gcdUptimePercent?: number;
  readonly totalDamage: number;
  readonly totalDamageTaken: number;
  readonly totalHealing: number;
@@ -128,6 +162,10 @@ export interface BalanceLabClassAbilityResult {
  readonly icon: string;
  readonly categories: string;
  readonly cooldownSeconds: number | null;
+  readonly rotationProfileId?: string | null;
+  readonly rotationPriority?: number | null;
+  readonly expectedUsage?: "profile" | "conditional" | "available";
+  readonly rotationDecisions?: number;
  readonly partyConfigurations: number;
  readonly bosses: number;
  readonly runs: number;
@@ -147,7 +185,7 @@ export interface BalanceLabClassAbilityResult {
  readonly effectiveHealing: number;
  readonly overheal: number;
  readonly absorbs: number;
-  readonly status: "unused" | "damage" | "support" | "used";
+  readonly status: "unused" | "missing-profile-action" | "damage" | "support" | "used";
  readonly unusedAvailable: boolean;
 }

@@ -160,64 +198,90 @@ export interface BalanceLabSuiteReport {
  readonly bosses: readonly BalanceLabBossResult[];
  readonly classSpecs: readonly BalanceLabClassSpecResult[];
  readonly classAbilities?: readonly BalanceLabClassAbilityResult[];
+  readonly npcClassSpecs?: readonly BalanceLabClassSpecResult[];
+  readonly npcClassAbilities?: readonly BalanceLabClassAbilityResult[];
  readonly partyConfigurations: readonly BalanceLabPartyResult[];
 }

-export async function listBalanceLabJobs(token: string): Promise<readonly BalanceLabJob[]> {
-  return (await requestOnlineJson<{ jobs: BalanceLabJob[] }>(
-    "/api/gm/balance-lab/jobs",
+export async function listBalanceLabJobs(
+  token: string,
+  target: BalanceLabExecutionTarget = "server",
+): Promise<readonly BalanceLabJob[]> {
+  return (await requestBalanceLabJson<{ jobs: BalanceLabJob[] }>(
+    balanceLabApiPath(target, "/jobs"),
    {},
-    token,
+    token, target,
  )).jobs;
 }

-export async function getBalanceLabRuntime(token: string): Promise<BalanceLabRuntimeStatus> {
-  return (await requestOnlineJson<{ runtime: BalanceLabRuntimeStatus }>(
-    "/api/gm/balance-lab/runtime",
+export async function getBalanceLabRuntime(
+  token: string,
+  target: BalanceLabExecutionTarget = "server",
+): Promise<BalanceLabRuntimeStatus> {
+  return (await requestBalanceLabJson<{ runtime: BalanceLabRuntimeStatus }>(
+    balanceLabApiPath(target, "/runtime"),
    {},
-    token,
+    token, target,
  )).runtime;
 }

-export async function startBalanceLabJob(spec: BalanceLabJobSpec, token: string): Promise<BalanceLabJob> {
-  return (await requestOnlineJson<{ job: BalanceLabJob }>(
-    "/api/gm/balance-lab/jobs",
+export async function startBalanceLabJob(
+  spec: BalanceLabJobSpec,
+  token: string,
+  target: BalanceLabExecutionTarget = "server",
+): Promise<BalanceLabJob> {
+  return (await requestBalanceLabJson<{ job: BalanceLabJob }>(
+    balanceLabApiPath(target, "/jobs"),
    { method: "POST", body: JSON.stringify(spec) },
-    token,
+    token, target,
  )).job;
 }

 export async function startBalanceLabJobs(
  specs: readonly BalanceLabJobSpec[],
  token: string,
+  target: BalanceLabExecutionTarget = "server",
 ): Promise<readonly BalanceLabJob[]> {
-  return (await requestOnlineJson<{ jobs: BalanceLabJob[] }>(
-    "/api/gm/balance-lab/jobs/batch",
+  return (await requestBalanceLabJson<{ jobs: BalanceLabJob[] }>(
+    balanceLabApiPath(target, "/jobs/batch"),
    { method: "POST", body: JSON.stringify({ specs }) },
-    token,
+    token, target,
  )).jobs;
 }

-export async function getBalanceLabJob(id: string, token: string): Promise<BalanceLabJob> {
-  return (await requestOnlineJson<{ job: BalanceLabJob }>(
-    `/api/gm/balance-lab/jobs/${encodeURIComponent(id)}`,
+export async function getBalanceLabJob(
+  id: string,
+  token: string,
+  target: BalanceLabExecutionTarget = "server",
+): Promise<BalanceLabJob> {
+  return (await requestBalanceLabJson<{ job: BalanceLabJob }>(
+    balanceLabApiPath(target, `/jobs/${encodeURIComponent(id)}`),
    {},
-    token,
+    token, target,
  )).job;
 }

-export async function getBalanceLabReport(id: string, token: string): Promise<BalanceLabSuiteReport> {
-  return requestOnlineJson<BalanceLabSuiteReport>(
-    `/api/gm/balance-lab/jobs/${encodeURIComponent(id)}/artifacts/suite-report.json`,
+export async function getBalanceLabReport(
+  id: string,
+  token: string,
+  target: BalanceLabExecutionTarget = "server",
+): Promise<BalanceLabSuiteReport> {
+  return requestBalanceLabJson<BalanceLabSuiteReport>(
+    balanceLabApiPath(target, `/jobs/${encodeURIComponent(id)}/artifacts/suite-report.json`),
    {},
-    token,
+    token, target,
  );
 }

-export async function fetchBalanceLabArtifact(id: string, name: string, token: string): Promise<Blob> {
+export async function fetchBalanceLabArtifact(
+  id: string,
+  name: string,
+  token: string,
+  target: BalanceLabExecutionTarget = "server",
+): Promise<Blob> {
  const response = await fetch(
-    `${onlineApiOrigin()}/api/gm/balance-lab/jobs/${encodeURIComponent(id)}/artifacts/${encodeURIComponent(name)}`,
-    { headers: { Authorization: `Bearer ${token}` } },
+    `${target === "local" ? "" : onlineApiOrigin()}${balanceLabApiPath(target, `/jobs/${encodeURIComponent(id)}/artifacts/${encodeURIComponent(name)}`)}`,
+    { headers: token ? { Authorization: `Bearer ${token}` } : undefined },
  );
  if (!response.ok) {
    const body = await response.json().catch(() => ({})) as { error?: string };
@@ -28,6 +28,7 @@ export interface OnlineGroupActivity {
  readonly type: "dungeon" | "manastorm";
  readonly contentId: string;
  readonly fillWithAi: boolean;
+  readonly includeBetaSpecs?: boolean;
  readonly partySize: number;
  readonly startingLevel: number | null;
  readonly startedAt: number;
@@ -63,6 +64,7 @@ export interface StartOnlineGroupActivityInput {
  readonly type: OnlineGroupActivity["type"];
  readonly contentId: string;
  readonly fillWithAi: boolean;
+  readonly includeBetaSpecs?: boolean;
  readonly partySize: number;
  readonly startingLevel?: number;
 }
@@ -7,6 +7,8 @@ import { useGameStore } from "./store";
 import { useManastormStore } from "./manastormStore";
 import { onlineGroupAiPartySize, useOnlineGroupStore } from "../app/onlineGroupStore";
 import { useDungeonSimulationStore } from "./dungeonSimulationStore";
+import { useCompanionSpecReadinessStore } from "./companionSpecReadinessStore";
+import { useCompanionPartyPreferences } from "./companionPartyPreferences";

 /** Owns party lifecycle; the combat interval itself remains in CombatBridge. */
 export function PartyBridge() {
@@ -19,6 +21,9 @@ export function PartyBridge() {
  const simulationMode = useDungeonSimulationStore((state) => state.sessionMode);
  const simulationSeed = useDungeonSimulationStore((state) => state.seed);
  const resetRevision = useGameStore((state) => state.resetRevision);
+  const readinessPolicy = useCompanionSpecReadinessStore((state) => state.config);
+  const readinessPolicyRevision = useCompanionSpecReadinessStore((state) => state.revision);
+  const deviceIncludeBetaSpecs = useCompanionPartyPreferences((state) => state.includeBetaSpecs);
  const mountedResetRevision = useRef(resetRevision);

  useEffect(() => {
@@ -30,6 +35,12 @@ export function PartyBridge() {
      && onlineActivity.type === (gameMode === "manastorm" ? "manastorm" : "dungeon")
      ? onlineGroupAiPartySize(onlineActivity.partySize)
      : requestedPartySize;
+    const companionOptions = {
+      readinessPolicy,
+      readinessPolicyRevision,
+      includeBetaSpecs: onlineActivity?.includeBetaSpecs ?? deviceIncludeBetaSpecs,
+      excludedPlayerSpecializationId: character.specializationId,
+    };
    if (simulationMode === "play") {
      party.initializeParty(
        character.id,
@@ -38,16 +49,17 @@ export function PartyBridge() {
        playerRole,
        aiPartySize,
        character.categoryId ?? "wow",
+        companionOptions,
      );
    } else {
-      party.initializeSpectatorParty(simulationSeed, combat.level, character.categoryId ?? "wow");
+      party.initializeSpectatorParty(simulationSeed, combat.level, character.categoryId ?? "wow", companionOptions);
    }
    usePartyStore.getState().syncEquipment(combat.equipment, combat.inventory);
    combat.synchronizeActors();
    combat.applyDefaultPartyBuffs();
    combat.applyPrecombatPreparation();
    resetPartyRuntimeClock();
-  }, [character?.id, gameMode, manastormPartySize, onlineActivity?.id, playerRole, simulationMode, simulationSeed]);
+  }, [character?.id, deviceIncludeBetaSpecs, gameMode, manastormPartySize, onlineActivity?.id, onlineActivity?.includeBetaSpecs, playerRole, readinessPolicy, readinessPolicyRevision, simulationMode, simulationSeed]);

  useEffect(() => {
    const party = usePartyStore.getState();
@@ -486,6 +486,56 @@ const HUNTER = [
 ] as const;

 const ROGUE = [
+  defineAbility({
+    id: "rogue-instant-poison", classId: "rogue", dbcSpellId: 57965, name: "Instant Poison",
+    unlockLevel: 20,
+    icon: spellIcon("Ability_Poisons"), sigil: "IP", target: "self", range: self,
+    castTimeMs: 0, cooldownMs: 0, gcdMs: 0, cost: { resource: "energy", amount: 0 },
+    description: "Coats the main-hand weapon with poison that can deal Nature damage on hit.",
+    effects: [{
+      kind: "apply-aura",
+      aura: {
+        id: "rogue-instant-poison-main-hand",
+        name: "Instant Poison",
+        disposition: "buff",
+        durationMs: 3_600_000,
+        exclusiveGroup: "rogue-main-hand-poison",
+        utilityTags: ["weapon-enchant"],
+        procs: [{ id: "rogue-instant-poison-proc", triggers: "hit", chance: 0.2,
+          action: { kind: "damage", amount: 18, school: "nature", target: "event-other" } }],
+      },
+      recipient: "caster",
+      sourceEffectType: 6,
+      sourceAuraType: 42,
+      miscValue: 0,
+      triggerSpellId: 0,
+    }],
+  }),
+  defineAbility({
+    id: "rogue-deadly-poison", classId: "rogue", dbcSpellId: 57970, name: "Deadly Poison",
+    unlockLevel: 30,
+    icon: spellIcon("Ability_Rogue_DualWeild"), sigil: "DP", target: "self", range: self,
+    castTimeMs: 0, cooldownMs: 0, gcdMs: 0, cost: { resource: "energy", amount: 0 },
+    description: "Coats the off-hand weapon with a stacking damage-over-time poison.",
+    effects: [{
+      kind: "apply-aura",
+      aura: {
+        id: "rogue-deadly-poison-off-hand",
+        name: "Deadly Poison",
+        disposition: "buff",
+        durationMs: 3_600_000,
+        exclusiveGroup: "rogue-off-hand-poison",
+        utilityTags: ["weapon-enchant"],
+        procs: [{ id: "rogue-deadly-poison-proc", triggers: "hit", chance: 0.3,
+          action: { kind: "damage", amount: 12, school: "nature", target: "event-other" } }],
+      },
+      recipient: "caster",
+      sourceEffectType: 6,
+      sourceAuraType: 42,
+      miscValue: 0,
+      triggerSpellId: 0,
+    }],
+  }),
  defineAbility({
    id: "rogue-sinister-strike", classId: "rogue", dbcSpellId: 1752, name: "Sinister Strike",
    icon: spellIcon("Spell_Shadow_RitualOfSacrifice"), sigil: "SS", target: "hostile", range: melee,
@@ -1,5 +1,8 @@
 import { describe, expect, it } from "vitest";
+import { abilitiesForClass } from "../abilityCatalog";
+import { rotationProfileFor } from "../combatRotation";
 import { createConfiguredPartyMember } from "../partyStore";
+import { specializationsForClass } from "../specializationCatalog";
 import { runtimeNormalizeTalentRanks } from "../talentRuntimeCatalog";
 import {
  loadSelectableBenchmarkBuilds,
@@ -12,7 +15,15 @@ describe("balance-lab selectable builds", () => {
      "warrior", "paladin", "hunter", "rogue", "priest", "death-knight",
      "shaman", "mage", "warlock", "druid",
    ]);
-    expect(catalog).toHaveLength(31);
+    const specializations = new Map<string, typeof catalog>();
+    for (const build of catalog) {
+      const key = `${build.classId}:${build.orientation}:${build.role}`;
+      specializations.set(key, [...(specializations.get(key) ?? []), build]);
+    }
+    expect(specializations.size).toBe(31);
+    expect([...specializations.values()].every((profiles) => profiles.length >= 2)).toBe(true);
+    expect(catalog.filter((build) => build.defaultTalentBuild)).toHaveLength(31);
+    expect(catalog.every((build) => build.talentBuildId && build.talentBuildName && build.characterName)).toBe(true);
    expect(catalog).toEqual(expect.arrayContaining([
      expect.objectContaining({ classId: "hunter", orientation: "Beast Mastery", role: "damage" }),
      expect.objectContaining({ classId: "priest", orientation: "Discipline", role: "healer" }),
@@ -29,6 +40,27 @@ describe("balance-lab selectable builds", () => {
    expect(Object.keys(beastMastery?.talentRanks ?? {})).not.toHaveLength(0);
  });

+  it("gives every selectable WoW specialization an executable priority rotation", () => {
+    const catalog = selectableBenchmarkBuildCatalog(80, [
+      "warrior", "paladin", "hunter", "rogue", "priest", "death-knight",
+      "shaman", "mage", "warlock", "druid",
+    ]);
+    const checked = new Set<string>();
+    for (const build of catalog) {
+      const key = `${build.classId}:${build.orientation}`;
+      if (checked.has(key)) continue;
+      checked.add(key);
+      const specialization = specializationsForClass(build.classId)
+        .find((candidate) => candidate.displayName === build.orientation);
+      const profile = rotationProfileFor(build.classId, specialization?.id, build.orientation);
+      expect(profile, key).not.toBeNull();
+      expect(profile!.abilityPriority.length, key).toBeGreaterThan(0);
+      const abilityNames = new Set(abilitiesForClass(build.classId).map((ability) => ability.name));
+      expect(profile!.abilityPriority.some((name) => abilityNames.has(name)), key).toBe(true);
+    }
+    expect(checked.size).toBe(31);
+  });
+
  it("keeps each CoA specialization tree selectable", async () => {
    const builds = await loadSelectableBenchmarkBuilds(20, ["witch-doctor"]);
    expect(builds.map((build) => `${build.orientation}:${build.role}`)).toEqual([
@@ -2,7 +2,11 @@ import { describe, expect, it } from "vitest";
 import { CLASSES } from "../../app/characterCatalog";
 import { partyRolesForClass } from "../partyRoles";
 import { runtimeNormalizeTalentRanks } from "../talentRuntimeCatalog";
-import { loadCanonicalBenchmarkBuilds } from "./benchmarkBuilds";
+import {
+  loadCanonicalBenchmarkBuilds,
+  loadSelectableBenchmarkBuilds,
+  selectableBenchmarkBuildCatalog,
+} from "./benchmarkBuilds";

 describe("canonical benchmark builds", () => {
  it("covers every declared class-role pair exactly once with legal ranks", async () => {
@@ -17,7 +21,7 @@ describe("canonical benchmark builds", () => {
    expect(new Set(actualPairs)).toEqual(new Set(expectedPairs));
    for (const build of builds) {
      expect(build.level).toBe(60);
-      expect(build.gearPresetId).toBe("coefficient-empty");
+      expect(build.gearPresetId).toBe("virtual-heirloom");
      expect(build.inventory).toEqual([]);
      expect(build.equipment).toEqual({});
      expect(runtimeNormalizeTalentRanks(build.classId, build.level, build.talentRanks)).toEqual(build.talentRanks);
@@ -33,4 +37,19 @@ describe("canonical benchmark builds", () => {
      "rom-priest:damage",
    ]);
  });
+
+  it("keeps both named classic talent builds and marks Playerbots as the default", async () => {
+    const catalog = selectableBenchmarkBuildCatalog(60, ["mage"]);
+    const builds = await loadSelectableBenchmarkBuilds(60, ["mage"]);
+    expect(catalog).toHaveLength(6);
+    expect(builds).toHaveLength(6);
+    expect(new Set(builds.map((build) => build.characterName)).size).toBe(6);
+    for (const specialization of ["Arcane", "Fire", "Frost"]) {
+      const variants = builds.filter((build) => build.orientation === specialization);
+      expect(variants).toHaveLength(2);
+      expect(variants.filter((build) => build.defaultTalentBuild)).toHaveLength(1);
+      expect(variants.find((build) => build.defaultTalentBuild)?.talentBuildSource)
+        .toBe("azerothcore-playerbots@531282e");
+    }
+  }, 30_000);
 });
@@ -20,7 +20,13 @@ import {
 import { aiHintsForAbility } from "../abilityRules";
 import type { EquipmentAssignments } from "../equipment";
 import { partyRolesForClass, type PartyRole } from "../partyRoles";
-import { runtimePartyTalentRanksForLevel } from "../partyTalentRuntime";
+import {
+  runtimeDefaultPartyTalentProfile,
+  runtimePartyTalentProvenanceForLevel,
+  runtimePartyTalentProfiles,
+  runtimePartyTalentRanksForLevel,
+  type PartyTalentRuntimeProfile,
+} from "../partyTalentRuntime";
 import { clampPlayerLevel } from "../progression";
 import {
  specializationsForClass,
@@ -38,9 +44,13 @@ import {
  type TalentUiTree,
 } from "../talentUiCatalog";
 import type { BenchmarkBuildDefinition } from "./benchmarkTypes";
+import {
+  readinessStatusFor,
+  type CompanionSpecReadinessStatus,
+} from "../companionSpecReadiness";

 export const CANONICAL_BENCHMARK_LEVEL = 60;
-export const CANONICAL_BENCHMARK_GEAR_PRESET_ID = "coefficient-empty";
+export const CANONICAL_BENCHMARK_GEAR_PRESET_ID = "virtual-heirloom";

 const EMPTY_INVENTORY: readonly never[] = Object.freeze([]);
 const EMPTY_EQUIPMENT: EquipmentAssignments = Object.freeze({});
@@ -164,9 +174,13 @@ function benchmarkVariantBuildId(
  role: PartyRole,
  orientation: string,
  level: number,
+  talentProfile?: PartyTalentRuntimeProfile,
 ): string {
  const variant = orientation.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return `balance-${contentCategoryForClass(classId)}-${classId}-${role}-${variant}-level-${level}`;
+  const base = `balance-${contentCategoryForClass(classId)}-${classId}-${role}-${variant}-level-${level}`;
+  if (!talentProfile || talentProfile.defaultForSpecialization) return base;
+  const profile = talentProfile.id.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return `${base}--${profile}`;
 }

 function commonBuildFields(classId: ClassId, role: PartyRole, level: number) {
@@ -192,10 +206,20 @@ function wowBuild(
  if (!orientation) {
    throw new Error(`No canonical WoW talent orientation exists for ${classId}:${role}.`);
  }
+  const talentProfile = runtimeDefaultPartyTalentProfile(classId, orientation);
+  const talentProvenance = runtimePartyTalentProvenanceForLevel(talentProfile, level);
  return Object.freeze({
    ...commonBuildFields(classId, role, level),
    orientation,
-    talentRanks: runtimePartyTalentRanksForLevel(classId, orientation, level),
+    characterName: talentProfile.characterName,
+    talentBuildId: talentProfile.id,
+    talentBuildName: talentProfile.name,
+    talentBuildSource: `${talentProfile.source}@${talentProfile.sourceVersion}`,
+    talentBuildSourcePointCount: talentProvenance.sourcePointCount,
+    talentBuildSourcePointsRetained: talentProvenance.sourcePointsRetained,
+    talentBuildFallbackPointCount: talentProvenance.fallbackPointCount,
+    defaultTalentBuild: talentProfile.defaultForSpecialization,
+    talentRanks: runtimePartyTalentRanksForLevel(classId, orientation, level, talentProfile.id),
  });
 }

@@ -435,11 +459,18 @@ function selectableClassicBuild(
  specialization: SpecializationDefinition,
  level: number,
  catalog: TalentUiCatalog | null,
+  talentProfile: PartyTalentRuntimeProfile,
 ): BenchmarkBuildDefinition {
  const classId = specialization.classId as BaseClassId;
+  const talentProvenance = runtimePartyTalentProvenanceForLevel(talentProfile, level);
  let talentRanks: RuntimeTalentRanks;
  try {
-    talentRanks = runtimePartyTalentRanksForLevel(classId, specialization.displayName, level);
+    talentRanks = runtimePartyTalentRanksForLevel(
+      classId,
+      specialization.displayName,
+      level,
+      talentProfile.id,
+    );
  } catch {
    if (!catalog) throw new Error(`No talent catalog was loaded for ${classId}.`);
    talentRanks = allocateSingleTreeTalentRanks(
@@ -451,8 +482,22 @@ function selectableClassicBuild(
  }
  return Object.freeze({
    ...commonBuildFields(classId, specialization.role, level),
-    id: benchmarkVariantBuildId(classId, specialization.role, specialization.displayName, level),
+    id: benchmarkVariantBuildId(
+      classId,
+      specialization.role,
+      specialization.displayName,
+      level,
+      talentProfile,
+    ),
    orientation: specialization.displayName,
+    characterName: talentProfile.characterName,
+    talentBuildId: talentProfile.id,
+    talentBuildName: talentProfile.name,
+    talentBuildSource: `${talentProfile.source}@${talentProfile.sourceVersion}`,
+    talentBuildSourcePointCount: talentProvenance.sourcePointCount,
+    talentBuildSourcePointsRetained: talentProvenance.sourcePointsRetained,
+    talentBuildFallbackPointCount: talentProvenance.fallbackPointCount,
+    defaultTalentBuild: talentProfile.defaultForSpecialization,
    talentRanks,
  });
 }
@@ -486,7 +531,17 @@ export interface SelectableBenchmarkBuildCatalogEntry {
  readonly classId: ClassId;
  readonly role: PartyRole;
  readonly orientation: string;
+  readonly specializationId?: string;
+  readonly readinessStatus?: CompanionSpecReadinessStatus;
  readonly level: number;
+  readonly characterName?: string;
+  readonly talentBuildId?: string;
+  readonly talentBuildName?: string;
+  readonly talentBuildSource?: string;
+  readonly talentBuildSourcePointCount?: number | null;
+  readonly talentBuildSourcePointsRetained?: number | null;
+  readonly talentBuildFallbackPointCount?: number;
+  readonly defaultTalentBuild?: boolean;
 }

 /** Cheap metadata-only roster used by interactive tools before a build is selected. */
@@ -508,14 +563,42 @@ export function selectableBenchmarkBuildCatalog(
        orientation: "Primary",
        level: safeLevel,
      }));
-      return specializationsForClass(classId).map((specialization) => ({
-        id: benchmarkVariantBuildId(classId, specialization.role, specialization.displayName, safeLevel),
-        source: contentCategoryForClass(classId),
-        classId,
-        role: specialization.role,
-        orientation: specialization.displayName,
-        level: safeLevel,
-      }));
+      return specializationsForClass(classId).flatMap((specialization) => {
+        const profiles = isBaseClassId(classId)
+          ? runtimePartyTalentProfiles(classId, specialization.displayName)
+          : [undefined];
+        return profiles.map((talentProfile) => {
+          const talentProvenance = talentProfile
+            ? runtimePartyTalentProvenanceForLevel(talentProfile, safeLevel)
+            : null;
+          return {
+            id: benchmarkVariantBuildId(
+              classId,
+              specialization.role,
+              specialization.displayName,
+              safeLevel,
+              talentProfile,
+            ),
+            source: contentCategoryForClass(classId),
+            classId,
+            role: specialization.role,
+            orientation: specialization.displayName,
+            specializationId: isBaseClassId(classId) ? specialization.id : undefined,
+            readinessStatus: isBaseClassId(classId) ? readinessStatusFor(specialization.id) : undefined,
+            level: safeLevel,
+            characterName: talentProfile?.characterName,
+            talentBuildId: talentProfile?.id,
+            talentBuildName: talentProfile?.name,
+            talentBuildSource: talentProfile
+              ? `${talentProfile.source}@${talentProfile.sourceVersion}`
+              : undefined,
+            talentBuildSourcePointCount: talentProvenance?.sourcePointCount,
+            talentBuildSourcePointsRetained: talentProvenance?.sourcePointsRetained,
+            talentBuildFallbackPointCount: talentProvenance?.fallbackPointCount,
+            defaultTalentBuild: talentProfile?.defaultForSpecialization,
+          };
+        });
+      });
    });
 }

@@ -561,7 +644,14 @@ export async function loadSelectableBenchmarkBuilds(
    }
    for (const specialization of specializationsForClass(classId)) {
      if (isBaseClassId(classId)) {
-        builds.push(selectableClassicBuild(specialization, safeLevel, catalogs.get(classId) ?? null));
+        for (const talentProfile of runtimePartyTalentProfiles(classId, specialization.displayName)) {
+          builds.push(selectableClassicBuild(
+            specialization,
+            safeLevel,
+            catalogs.get(classId) ?? null,
+            talentProfile,
+          ));
+        }
      } else if (isCoaClassId(classId)) {
        const catalog = catalogs.get(classId);
        if (!catalog) throw new Error(`No loaded CoA talent catalog exists for ${classId}.`);
@@ -231,6 +231,7 @@ export class BenchmarkController {
          health: member.health,
          maxHealth: member.maxHealth,
          fallen: member.health <= 0,
+          role: member.role,
        })),
      ],
      hostileCount: scenario.hostileTargets,
@@ -51,6 +51,14 @@ export interface BenchmarkBuildDefinition {
  readonly role: PartyRole;
  readonly level: number;
  readonly orientation: string;
+  readonly characterName?: string;
+  readonly talentBuildId?: string;
+  readonly talentBuildName?: string;
+  readonly talentBuildSource?: string;
+  readonly talentBuildSourcePointCount?: number | null;
+  readonly talentBuildSourcePointsRetained?: number | null;
+  readonly talentBuildFallbackPointCount?: number;
+  readonly defaultTalentBuild?: boolean;
  readonly talentRanks: Readonly<Record<string, number>>;
  readonly inventory: readonly never[];
  readonly equipment: EquipmentAssignments;
@@ -99,6 +99,17 @@ describe("Boss Testing", () => {

    expect(nativeHealth).toBeLessThan(100);
    expect(testing).toMatchObject({ level: 2, maxHealth: 540 });
+    const level80 = dungeonEnemyScaling(
+      room.definition,
+      entity,
+      zereketh.spawn.id,
+      80,
+      room.definition.defaultDifficultyId,
+      1,
+    );
+    expect(level80.maxHealth).toBeGreaterThanOrEqual(26_400);
+    expect(level80.maxHealth).toBeLessThanOrEqual(59_400);
+    expect(level80.damageMultiplier).toBeCloseTo((entity.combat?.damageMultiplier ?? 1) * 0.75);
  });

  it("omits the campaign finale bonus even when testing the source dungeon's final boss", () => {
@@ -143,6 +143,33 @@ describe("shared combat rotations", () => {
    expect(abilityIsPrecombatPreparation(temporaryPet)).toBe(false);
  });

+  it("uses an eligible defensive before a configured incoming boss mechanic", () => {
+    const defensive = ability("paladin", "Divine Protection");
+    const decision = evaluateCombatRotation(context({
+      classId: "paladin",
+      specializationId: "paladin:protection",
+      role: "tank",
+      primaryResource: "mana",
+      resources: { mana: 10_000 },
+      maximumResources: { mana: 10_000 },
+      abilities: [defensive],
+      incomingDefensiveMechanic: {
+        id: "tank-buster",
+        enabled: true,
+        bossKey: "test/boss",
+        bossName: "Test Boss",
+        bossServerEntry: 1,
+        attackId: "heavy-strike",
+        attackName: "Heavy Strike",
+        scope: "tank",
+        leadTimeMs: 2_500,
+        minimumCooldownSeconds: 20,
+      },
+    }));
+    expect(decision?.ability.name).toBe("Divine Protection");
+    expect(decision?.ruleId).toBe("preemptive-tank-buster");
+  });
+
  it("gates representative signature abilities from every class by their exact talent node", () => {
    for (const [classId, name] of Object.entries(SIGNATURES)) {
      const signature = ability(classId as RotationContext["classId"], name);
@@ -178,6 +205,67 @@ describe("shared combat rotations", () => {
    }
  });

+  it("keeps every required Ready-spec mechanic in its learned Playerbots profile", () => {
+    const contracts = [
+      { classId: "warrior" as const, specialization: "Protection", id: "warrior:protection", actions: ["Defensive Stance", "Taunt", "Shield Bash", "Shield Slam", "Revenge", "Devastate", "Thunder Clap", "Shield Block", "Shield Wall", "Last Stand", "Enraged Regeneration"] },
+      { classId: "priest" as const, specialization: "Discipline", id: "priest:discipline", actions: ["Penance", "Power Word: Shield", "Flash Heal", "Greater Heal", "Renew", "Dispel Magic", "Cure Disease", "Resurrection", "Pain Suppression", "Inner Focus", "Power Infusion", "Shadowfiend"] },
+      { classId: "hunter" as const, specialization: "Marksmanship", id: "hunter:marksmanship", actions: ["Call Pet", "Aspect of the Dragonhawk", "Serpent Sting", "Chimera Shot", "Aimed Shot", "Arcane Shot", "Steady Shot", "Kill Shot", "Rapid Fire", "Readiness", "Misdirection", "Feign Death", "Silencing Shot", "Disengage"] },
+      { classId: "mage" as const, specialization: "Fire", id: "mage:fire", actions: ["Molten Armor", "Living Bomb", "Fireball", "Scorch", "Fire Blast", "Combustion", "Mirror Image", "Counterspell", "Fire Ward", "Frost Ward", "Ice Block", "Blink"] },
+      { classId: "rogue" as const, specialization: "Assassination", id: "rogue:assassination", actions: ["Instant Poison", "Deadly Poison", "Mutilate", "Rupture", "Envenom", "Cold Blood", "Kick", "Tricks of the Trade", "Evasion", "Cloak of Shadows", "Vanish"] },
+    ];
+    for (const contract of contracts) {
+      const profile = rotationProfileFor(contract.classId, contract.id)!;
+      const talents = runtimePartyTalentRanksForLevel(contract.classId, contract.specialization, 80);
+      for (const name of contract.actions) {
+        expect(profile.abilityPriority, `${contract.id}:${name} priority`).toContain(name);
+        expect(learnedAbilityForBuild(ability(contract.classId, name), 80, talents), `${contract.id}:${name} learned`)
+          .not.toBeNull();
+      }
+    }
+  });
+
+  it("executes Ready-spec taunts, dispels, resurrection, interrupts, threat redirects, and movement reactively", () => {
+    const warriorTalents = runtimePartyTalentRanksForLevel("warrior", "Protection", 80);
+    const taunt = learnedAbilityForBuild(ability("warrior", "Taunt"), 80, warriorTalents)!;
+    expect(evaluateCombatRotation(context({ classId: "warrior", specializationId: "warrior:protection", role: "tank", primaryResource: "rage", resources: { rage: 100 }, maximumResources: { rage: 100 }, abilities: [taunt], targetIsLoose: true }))?.ability.name)
+      .toBe("Taunt");
+
+    const priestTalents = runtimePartyTalentRanksForLevel("priest", "Discipline", 80);
+    const dispel = learnedAbilityForBuild(ability("priest", "Dispel Magic"), 80, priestTalents)!;
+    const resurrection = learnedAbilityForBuild(ability("priest", "Resurrection"), 80, priestTalents)!;
+    const priest = context({ classId: "priest", specializationId: "priest:discipline", role: "healer", primaryResource: "mana", resources: { mana: 10_000 }, maximumResources: { mana: 10_000 } });
+    expect(evaluateCombatRotation({ ...priest, abilities: [dispel], friendlyTargets: [{ id: "ally", health: 500, maxHealth: 1_000, needsDispel: true }] })?.ability.name)
+      .toBe("Dispel Magic");
+    expect(evaluateCombatRotation({ ...priest, abilities: [resurrection], friendlyTargets: [{ id: "ally", health: 0, maxHealth: 1_000, fallen: true }] })?.ability.name)
+      .toBe("Resurrection");
+
+    for (const row of [
+      { classId: "hunter" as const, specializationId: "hunter:marksmanship", specialization: "Marksmanship", name: "Silencing Shot", resource: "mana" as const },
+      { classId: "mage" as const, specializationId: "mage:fire", specialization: "Fire", name: "Counterspell", resource: "mana" as const },
+      { classId: "rogue" as const, specializationId: "rogue:assassination", specialization: "Assassination", name: "Kick", resource: "energy" as const },
+    ]) {
+      const learned = learnedAbilityForBuild(ability(row.classId, row.name), 80,
+        runtimePartyTalentRanksForLevel(row.classId, row.specialization, 80))!;
+      expect(evaluateCombatRotation(context({
+        classId: row.classId,
+        specializationId: row.specializationId,
+        primaryResource: row.resource,
+        resources: { [row.resource]: 10_000 },
+        maximumResources: { [row.resource]: 10_000 },
+        abilities: [learned],
+        hostileTarget: { id: "caster", health: 10_000, maxHealth: 10_000, activeCast: { interruptible: true } },
+      }))?.ability.name).toBe(row.name);
+    }
+
+    const hunterTalents = runtimePartyTalentRanksForLevel("hunter", "Marksmanship", 80);
+    const misdirection = learnedAbilityForBuild(ability("hunter", "Misdirection"), 80, hunterTalents)!;
+    const disengage = learnedAbilityForBuild(ability("hunter", "Disengage"), 80, hunterTalents)!;
+    const hunter = context({ classId: "hunter", specializationId: "hunter:marksmanship", primaryResource: "mana", resources: { mana: 10_000 }, maximumResources: { mana: 10_000 }, friendlyTargets: [{ id: "tank", health: 1_000, maxHealth: 1_000, role: "tank" }] });
+    expect(evaluateCombatRotation({ ...hunter, abilities: [misdirection], hostileTarget: { id: "boss", health: 100_000, maxHealth: 100_000, boss: true } }))
+      .toMatchObject({ ability: { name: "Misdirection" }, targetId: "tank" });
+    expect(evaluateCombatRotation({ ...hunter, abilities: [disengage], moving: true })?.ability.name).toBe("Disengage");
+  });
+
  it("keeps specialization talent actions isolated", () => {
    const furyTalents = runtimePartyTalentRanksForLevel("warrior", "Fury", 80);
    const armsTalents = runtimePartyTalentRanksForLevel("warrior", "Arms", 80);
@@ -189,6 +277,60 @@ describe("shared combat rotations", () => {
    expect(learnedAbilityForBuild(bloodthirst, 80, armsTalents)).toBeNull();
  });

+  it("certifies major offensive and defensive cooldown decisions for the Ready five", () => {
+    const cases = [
+      { classId: "warrior" as const, specialization: "Protection", specializationId: "warrior:protection", offensive: null, defensive: "Shield Wall", role: "tank" as const },
+      { classId: "priest" as const, specialization: "Discipline", specializationId: "priest:discipline", offensive: "Power Infusion", defensive: "Pain Suppression", role: "healer" as const },
+      { classId: "hunter" as const, specialization: "Marksmanship", specializationId: "hunter:marksmanship", offensive: "Rapid Fire", defensive: "Feign Death", role: "damage" as const },
+      { classId: "mage" as const, specialization: "Fire", specializationId: "mage:fire", offensive: "Combustion", defensive: "Ice Block", role: "damage" as const },
+      { classId: "rogue" as const, specialization: "Assassination", specializationId: "rogue:assassination", offensive: "Cold Blood", defensive: "Evasion", role: "damage" as const },
+    ];
+    for (const row of cases) {
+      const talents = runtimePartyTalentRanksForLevel(row.classId, row.specialization, 80);
+      const learned = (name: string) => learnedAbilityForBuild(ability(row.classId, name), 80, talents)!;
+      const primaryResource = resourceProfileForClass(row.classId).type;
+      const shared = context({
+        classId: row.classId,
+        specializationId: row.specializationId,
+        specialization: row.specialization,
+        role: row.role,
+        primaryResource,
+        resources: { [primaryResource]: 100_000 },
+        maximumResources: { [primaryResource]: 100_000 },
+        hostileTarget: { id: "boss", health: 100_000, maxHealth: 100_000, boss: true },
+        friendlyTargets: [{ id: "tank", health: 1_000, maxHealth: 1_000, role: "tank" }],
+      });
+      if (row.offensive) {
+        const offensive = learned(row.offensive);
+        expect(offensive, `${row.specializationId}:${row.offensive}`).toBeDefined();
+        expect(evaluateCombatRotation({ ...shared, abilities: [offensive] })?.ability.name)
+          .toBe(row.offensive);
+      }
+      const defensive = learned(row.defensive);
+      expect(defensive, `${row.specializationId}:${row.defensive}`).toBeDefined();
+      const defensiveContext = row.defensive === "Feign Death"
+        ? { ...shared, abilities: [defensive], hasDangerousThreat: true }
+        : { ...shared, abilities: [defensive], health: 250 };
+      expect(evaluateCombatRotation(defensiveContext)?.ability.name).toBe(row.defensive);
+    }
+  });
+
+  it("uses Marksmanship Readiness only on a durable target", () => {
+    const talents = runtimePartyTalentRanksForLevel("hunter", "Marksmanship", 80);
+    const readiness = learnedAbilityForBuild(ability("hunter", "Readiness"), 80, talents)!;
+    const base = context({
+      classId: "hunter",
+      specializationId: "hunter:marksmanship",
+      primaryResource: "mana",
+      resources: { mana: 10_000 },
+      maximumResources: { mana: 10_000 },
+      abilities: [readiness],
+    });
+    expect(evaluateCombatRotation(base)).toBeNull();
+    expect(evaluateCombatRotation({ ...base, hostileTarget: { id: "boss", health: 100_000, maxHealth: 100_000, boss: true } })?.ability.name)
+      .toBe("Readiness");
+  });
+
  it("uses combo builders before finishers and actual combo points for the decision", () => {
    const builder = ability("rogue", "Sinister Strike");
    const finisher = ability("rogue", "Eviscerate");
@@ -6,8 +6,13 @@ import { channelAmountEffects } from "./combatChannelAmounts";
 import { spendDeathKnightRunes } from "./combatResources";
 import { healingAbilityCanAidOthers } from "./healingAbilityRules";
 import type { PartyRole } from "./partyRoles";
+import {
+  currentCompanionCooldownPolicy,
+  type CompanionCooldownMechanicRule,
+  type CompanionCooldownPolicy,
+} from "./companionCooldownPolicy";

-export const COMBAT_ROTATION_VERSION = "playerbots-inspired-v4";
+export const COMBAT_ROTATION_VERSION = "playerbots-inspired-v5-ready-five";

 export interface RotationProfile {
  readonly id: string;
@@ -22,6 +27,7 @@ export interface RotationFriendlyTarget {
  readonly maxHealth: number;
  readonly needsDispel?: boolean;
  readonly fallen?: boolean;
+  readonly role?: PartyRole;
 }

 export interface RotationHostileTarget {
@@ -67,6 +73,8 @@ export interface RotationContext {
  /** Proc/state-gated actions that the caller has positively made available. */
  readonly availableConditionalAbilityNames?: ReadonlySet<string>;
  readonly canUseAbility?: (ability: AbilityDefinition) => boolean;
+  readonly cooldownPolicy?: CompanionCooldownPolicy;
+  readonly incomingDefensiveMechanic?: CompanionCooldownMechanicRule | null;
 }

 export interface RotationDecision {
@@ -92,17 +100,17 @@ const profile = (
 export const CLASSIC_ROTATION_PROFILES: readonly RotationProfile[] = Object.freeze([
  profile("warrior:arms", "warrior", ["Battle Stance", "Bloodrage", "Rend", "Mortal Strike", "Bladestorm", "Overpower", "Execute", "Slam", "Heroic Strike"]),
  profile("warrior:fury", "warrior", ["Berserker Stance", "Battle Stance", "Bloodrage", "Bloodthirst", "Whirlwind", "Execute", "Sunder Armor", "Heroic Strike"]),
-  profile("warrior:protection", "warrior", ["Defensive Stance", "Battle Stance", "Bloodrage", "Shield Slam", "Revenge", "Devastate", "Thunder Clap", "Sunder Armor", "Heroic Strike"]),
+  profile("warrior:protection", "warrior", ["Defensive Stance", "Shield Block", "Last Stand", "Shield Wall", "Enraged Regeneration", "Taunt", "Shield Bash", "Bloodrage", "Shield Slam", "Revenge", "Devastate", "Thunder Clap", "Sunder Armor", "Heroic Strike"]),
  profile("paladin:holy", "paladin", ["Concentration Aura", "Devotion Aura", "Blessing of Might", "Seal of Wisdom", "Seal of Light", "Seal of Righteousness", "Holy Shock", "Flash of Light", "Holy Light", "Sacred Shield", "Judgement of Light"]),
  profile("paladin:protection", "paladin", ["Devotion Aura", "Blessing of Might", "Seal of Vengeance", "Seal of Corruption", "Seal of Wisdom", "Seal of Righteousness", "Hammer of the Righteous", "Shield of Righteousness", "Holy Shield", "Consecration", "Judgement of Wisdom"]),
  profile("paladin:retribution", "paladin", ["Retribution Aura", "Devotion Aura", "Blessing of Might", "Seal of Command", "Seal of Vengeance", "Seal of Corruption", "Seal of Righteousness", "Divine Storm", "Crusader Strike", "Judgement of Wisdom", "Consecration", "Exorcism", "Hammer of Wrath"]),
  profile("hunter:beast-mastery", "hunter", ["Aspect of the Dragonhawk", "Aspect of the Hawk", "Call Pet", "Kill Command", "Bestial Wrath", "Serpent Sting", "Arcane Shot", "Multi-Shot", "Steady Shot"]),
-  profile("hunter:marksmanship", "hunter", ["Aspect of the Dragonhawk", "Aspect of the Hawk", "Call Pet", "Kill Shot", "Chimera Shot", "Aimed Shot", "Serpent Sting", "Arcane Shot", "Steady Shot"]),
+  profile("hunter:marksmanship", "hunter", ["Aspect of the Dragonhawk", "Aspect of the Hawk", "Call Pet", "Misdirection", "Rapid Fire", "Readiness", "Kill Shot", "Chimera Shot", "Aimed Shot", "Serpent Sting", "Arcane Shot", "Steady Shot", "Silencing Shot", "Disengage", "Feign Death"]),
  profile("hunter:survival", "hunter", ["Aspect of the Dragonhawk", "Aspect of the Hawk", "Call Pet", "Kill Shot", "Explosive Shot", "Black Arrow", "Serpent Sting", "Aimed Shot", "Arcane Shot", "Steady Shot"]),
-  profile("rogue:assassination", "rogue", ["Envenom", "Rupture", "Mutilate", "Eviscerate", "Sinister Strike"]),
+  profile("rogue:assassination", "rogue", ["Deadly Poison", "Instant Poison", "Tricks of the Trade", "Cold Blood", "Envenom", "Rupture", "Mutilate", "Eviscerate", "Sinister Strike", "Kick", "Evasion", "Cloak of Shadows", "Vanish"]),
  profile("rogue:combat", "rogue", ["Killing Spree", "Blade Flurry", "Eviscerate", "Sinister Strike"]),
  profile("rogue:subtlety", "rogue", ["Shadow Dance", "Rupture", "Eviscerate", "Hemorrhage", "Backstab"]),
-  profile("priest:discipline", "priest", ["Inner Fire", "Penance", "Power Word: Shield", "Flash Heal", "Greater Heal", "Renew"]),
+  profile("priest:discipline", "priest", ["Inner Fire", "Pain Suppression", "Inner Focus", "Power Infusion", "Shadowfiend", "Divine Hymn", "Penance", "Power Word: Shield", "Flash Heal", "Greater Heal", "Renew", "Dispel Magic", "Cure Disease", "Resurrection"]),
  profile("priest:holy", "priest", ["Inner Fire", "Circle of Healing", "Prayer of Mending", "Flash Heal", "Greater Heal", "Renew"]),
  profile("priest:shadow", "priest", ["Shadowform", "Inner Fire", "Vampiric Touch", "Devouring Plague", "Shadow Word: Pain", "Mind Blast", "Mind Flay", "Shadow Word: Death"]),
  profile("death-knight:blood", "death-knight", ["Frost Presence", "Blood Presence", "Heart Strike", "Death Strike", "Icy Touch", "Plague Strike", "Death Coil"]),
@@ -112,7 +120,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", "Fireball", "Scorch", "Fire Blast"]),
+  profile("mage:fire", "mage", ["Molten Armor", "Combustion", "Mirror Image", "Living Bomb", "Fireball", "Scorch", "Fire Blast", "Counterspell", "Blink", "Ice Block", "Fire Ward", "Frost Ward"]),
  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"]),
@@ -133,6 +141,14 @@ const CONDITIONAL_ABILITY_NAMES = new Set([
  "Victory Rush",
 ]);

+const DEFENSIVE_COOLDOWN_NAMES = new Set([
+  "Shield Block", "Last Stand", "Shield Wall", "Enraged Regeneration",
+  "Pain Suppression", "Ice Block", "Fire Ward", "Frost Ward",
+  "Evasion", "Cloak of Shadows", "Vanish",
+]);
+
+const THREAT_REDIRECT_NAMES = new Set(["Misdirection", "Tricks of the Trade"]);
+
 const TARGET_HEALTH_GATES = new Map<string, number>([
  ["Drain Soul", 0.25],
  ["Hammer of Wrath", 0.2],
@@ -275,6 +291,10 @@ function targetForAbility(
  lowest: RotationFriendlyTarget | null,
 ): string | null {
  const categories = new Set(aiHintsForAbility(ability).categories);
+  if (THREAT_REDIRECT_NAMES.has(ability.name)) {
+    return context.friendlyTargets?.find((target) => target.role === "tank" && !target.fallen)?.id
+      ?? context.selfId ?? null;
+  }
  const casterOnly = ability.target === "self" || (ability.effects.some((effect) => (
    "recipient" in effect && effect.recipient === "caster"
  )) && !ability.effects.some((effect) => (
@@ -337,9 +357,12 @@ function scoreAbility(
  const damaging = categories.has("damage") || categories.has("execute")
    || channelAmounts.some(({ effect }) => effect.kind === "damage" || effect.kind === "dot");
  const healingCategory = categories.has("heal") || categories.has("emergency-heal") || categories.has("area-heal");
-  const defensive = categories.has("mitigation") || categories.has("heal");
-  const offensiveMajorCooldown = ability.cooldownMs >= 60_000 && !defensive
-    && (damaging || categories.has("buff") || categories.has("summon") || categories.has("pet"));
+  const namedDefensiveCooldown = DEFENSIVE_COOLDOWN_NAMES.has(ability.name);
+  const defensive = categories.has("mitigation") || categories.has("heal") || namedDefensiveCooldown;
+  const cooldownPolicy = context.cooldownPolicy ?? currentCompanionCooldownPolicy();
+  const offensiveMajorCooldown = ability.cooldownMs >= cooldownPolicy.generic.offensiveMajorCooldownSeconds * 1_000 && !defensive
+    && (damaging || categories.has("buff") || categories.has("summon") || categories.has("pet")
+      || ability.effects.some((effect) => effect.kind === "cooldown-reset"));
  const durableTarget = Boolean(
    context.hostileTarget?.boss
    || (context.hostileTarget?.healthMultiplier ?? 1) > 1
@@ -374,7 +397,7 @@ function scoreAbility(
  if (categories.has("dispel")) {
    const dispel = (context.friendlyTargets ?? []).find((target) => target.needsDispel);
    if (dispel) return { ability, score: 1_019_000, ruleId: "reactive-dispel", reason: "ally needs dispel", targetId: dispel.id };
-    if (!damaging) return null;
+    if (!damaging && !namedDefensiveCooldown) return null;
  }
  if (categories.has("interrupt")) {
    if (!context.hostileTarget?.activeCast?.interruptible) {
@@ -388,6 +411,15 @@ function scoreAbility(
    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 (THREAT_REDIRECT_NAMES.has(ability.name) && context.role !== "tank" && durableTarget) {
+      return {
+        ability,
+        score: 1_015_500,
+        ruleId: "preemptive-threat-redirect",
+        reason: "redirect opening threat to the tank",
+        targetId: targetForAbility(ability, context, lowest),
+      };
+    }
    if (context.role === "tank" || !context.hasDangerousThreat) return null;
    return {
      ability,
@@ -398,6 +430,25 @@ function scoreAbility(
    };
  }
  if (categories.has("control") && !context.requiredControl && !damaging) return null;
+  if (namedDefensiveCooldown && context.incomingDefensiveMechanic) {
+    return {
+      ability,
+      score: 1_014_500 + (hints.priority ?? 0),
+      ruleId: `preemptive-${context.incomingDefensiveMechanic.id}`,
+      reason: `pre-empt ${context.incomingDefensiveMechanic.attackName}`,
+      targetId: targetForAbility(ability, context, lowest),
+    };
+  }
+  if (categories.has("mitigation") && context.incomingDefensiveMechanic
+    && ability.cooldownMs >= context.incomingDefensiveMechanic.minimumCooldownSeconds * 1_000) {
+    return {
+      ability,
+      score: 1_014_000 + (hints.priority ?? 0),
+      ruleId: `preemptive-${context.incomingDefensiveMechanic.id}`,
+      reason: `pre-empt ${context.incomingDefensiveMechanic.attackName}`,
+      targetId: targetForAbility(ability, context, lowest),
+    };
+  }
  // A friendly heal without an injured recipient must never fall through to
  // the hostile target. Hybrid damage builds otherwise refresh HoTs on enemies
  // forever because those auras also look like maintenance buffs.
@@ -426,7 +477,11 @@ function scoreAbility(
  if (context.requiredControl && categories.has("control")) {
    return { ability, score: 1_016_000, ruleId: "reactive-control", reason: "encounter requested control", targetId: context.hostileTarget?.id ?? null };
  }
-  if (offensiveMajorCooldown && !durableTarget) return null;
+  if (offensiveMajorCooldown && cooldownPolicy.generic.conserveOffensiveCooldownsForDurableTargets && !durableTarget) return null;
+  if (namedDefensiveCooldown && !context.incomingDefensiveMechanic) {
+    const threshold = cooldownPolicy.generic.defensiveHealthPercent / 100;
+    if (selfHealth >= threshold && lowestHealth >= threshold) 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;
@@ -455,7 +510,6 @@ function scoreAbility(
    ruleId = `profile-${slug(ability.name)}`;
    reason = `${rotationProfile!.specializationId} priority ${profileIndex + 1}`;
  }
-
  if (context.role === "healer") {
    const healing = actionableHealing
      && (healingAbilityCanAidOthers(ability) || lowest?.id === context.selfId);
@@ -468,7 +522,8 @@ function scoreAbility(
      if (categories.has("area-heal")) score += injured.length >= 3 ? 6_500 : -1_200;
      score += Math.min(500, throughput(ability, context.comboPoints) * 10);
    } else if (categories.has("mitigation")) {
-      if (lowestHealth >= 0.8 && selfHealth >= 0.8) return null;
+      const threshold = cooldownPolicy.generic.healerMitigationHealthPercent / 100;
+      if (lowestHealth >= threshold && selfHealth >= threshold) return null;
      score += 2_500;
    } else if (maintenanceBuff) {
      score += context.maintainedAbilityIds === undefined ? 1_600 : maintenanceScore;
@@ -483,8 +538,10 @@ function scoreAbility(
    }
  } else {
    if (categories.has("mitigation")) {
-      if (!maintenanceBuff && selfHealth >= 0.55) return null;
-      if (selfHealth < 0.55) score += selfHealth < 0.35 ? 180_000 : 140_000;
+      const defensiveThreshold = cooldownPolicy.generic.defensiveHealthPercent / 100;
+      const emergencyThreshold = cooldownPolicy.generic.emergencyHealthPercent / 100;
+      if (!maintenanceBuff && selfHealth >= defensiveThreshold) return null;
+      if (selfHealth < defensiveThreshold) score += selfHealth < emergencyThreshold ? 180_000 : 140_000;
    }
    if (categories.has("execute")) {
      if (targetHealth > 0.2) return null;
@@ -741,6 +741,30 @@ describe("combat store", () => {
    expect(useCombatStore.getState().mobs["party-victim"].targetActorId).toBe(target.id);
  });

+  it("grants companion Warriors Rage when enemy attacks land", () => {
+    const tank = usePartyStore.getState().members.find((member) => member.resourcePools.rage !== undefined)!;
+    usePartyStore.setState((state) => ({
+      members: state.members.map((member) => member.id === tank.id
+        ? { ...member, resource: 0, resourcePools: { ...member.resourcePools, rage: 0 } }
+        : member),
+    }));
+    registerPartyRuntimePosition(tank.id, [0, 0, 0]);
+    useCombatStore.getState().registerMob("rage-attacker", {
+      name: "Rage attacker",
+      maxHealth: 200,
+      xpReward: 0,
+    });
+    setMobPosition("rage-attacker", [2, 0, 0]);
+    useCombatStore.getState().damageMob("rage-attacker", 5, 1_000, {
+      actorId: tank.id,
+      role: "tank",
+    });
+
+    expect(useCombatStore.getState().advanceMobCombat(1_450)).toBeGreaterThan(0);
+    expect(usePartyStore.getState().members.find((member) => member.id === tank.id)?.resourcePools.rage)
+      .toBe(7);
+  });
+
  it("clears all aggro state on encounter reset", () => {
    registerTarget("reset-threat", [2, 0, 0], 100, 0);
    useCombatStore.getState().damageMob("reset-threat", 1, 1_000);
@@ -949,9 +973,9 @@ describe("combat store", () => {
  it("tracks rogue combo points and consumes them with Eviscerate", () => {
    useCombatStore.getState().initializeCharacter({ classId: "rogue" });
    registerTarget("fang", [2, 0, 0], 100);
-    expect(useCombatStore.getState().castSlot(0, undefined, 1000).ok).toBe(true);
+    expect(useCombatStore.getState().castAbility("rogue-sinister-strike", undefined, 1000).ok).toBe(true);
    expect(useCombatStore.getState().comboPoints).toBe(1);
-    expect(useCombatStore.getState().castSlot(1, undefined, 2000).ok).toBe(true);
+    expect(useCombatStore.getState().castAbility("rogue-eviscerate", undefined, 2000).ok).toBe(true);
    expect(useCombatStore.getState().comboPoints).toBe(0);
    expect(useCombatStore.getState().mobs.fang.health).toBeLessThan(100);
    expect(useCombatStore.getState().lastCombatResult).not.toBeNull();
@@ -990,8 +990,8 @@ function clamp(value: number, min: number, max: number): number {
 }

 const ROM_RAGE_CLASSES = new Set<ClassId>(["rom-warrior", "rom-champion"]);
-const ROM_RAGE_PER_AUTO_ATTACK = 6;
-const ROM_RAGE_PER_HIT_TAKEN = 7;
+const RAGE_PER_AUTO_ATTACK = 6;
+const RAGE_PER_HIT_TAKEN = 7;
 const ROM_CHAMPION_RAGE_PER_SECOND = 6;
 const PLAYER_AUTO_ATTACK_RANGE = 5;

@@ -6526,7 +6526,7 @@ export const useCombatStore = create<CombatState>((set, get) => ({
        hasRomWarriorRagePool(state.classId, state.secondaryClassId)
        || (!hasRomRagePool(state.classId, state.secondaryClassId) && state.maxResourcePools.rage !== undefined)
      )
-        ? ROM_RAGE_PER_HIT_TAKEN
+        ? RAGE_PER_HIT_TAKEN
        : 0,
      state.resource,
      state.maxResource,
@@ -7554,7 +7554,7 @@ export const useCombatStore = create<CombatState>((set, get) => ({
            hasRomWarriorRagePool(current.classId, current.secondaryClassId)
            || (!hasRomRagePool(current.classId, current.secondaryClassId) && current.maxResourcePools.rage !== undefined)
          )
-            ? ROM_RAGE_PER_HIT_TAKEN
+            ? RAGE_PER_HIT_TAKEN
            : 0,
          current.resource,
          current.maxResource,
@@ -7823,11 +7823,21 @@ export const useCombatStore = create<CombatState>((set, get) => ({
            };
          }
        }
+        const ragePool = authoritativeActor.resources.rage;
        const nextActor: CombatActorState = {
          ...authoritativeActor,
          health: authoritativeActor.health - damaged,
          alive: authoritativeActor.health - damaged > 0,
          cast: authoritativeActor.health - damaged > 0 ? nextCast : null,
+          resources: damaged > 0 && ragePool
+            ? {
+                ...authoritativeActor.resources,
+                rage: {
+                  ...ragePool,
+                  current: Math.min(ragePool.maximum, ragePool.current + RAGE_PER_HIT_TAKEN),
+                },
+              }
+            : authoritativeActor.resources,
        };
        mirrorCompanionActor(nextActor);
        if (redirected > 0) {
@@ -8114,7 +8124,7 @@ export const useCombatStore = create<CombatState>((set, get) => ({
            const rage = gainRomRage(
              state.classId,
              state.secondaryClassId,
-              ROM_RAGE_PER_AUTO_ATTACK,
+              RAGE_PER_AUTO_ATTACK,
              work.resource,
              work.maxResource,
              work.resourcePools,
@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import {
+  DEFAULT_COMPANION_COOLDOWN_POLICY,
+  imminentCooldownMechanic,
+  normalizeCompanionCooldownPolicy,
+} from "./companionCooldownPolicy";
+
+const policy = normalizeCompanionCooldownPolicy({
+  ...DEFAULT_COMPANION_COOLDOWN_POLICY,
+  mechanics: [{
+    id: "tank-buster", enabled: true, bossKey: "test/boss", bossName: "Test Boss",
+    bossServerEntry: 123, attackId: "heavy-strike", attackName: "Heavy Strike",
+    scope: "tank", leadTimeMs: 2_500, minimumCooldownSeconds: 20,
+  }],
+});
+
+describe("companion cooldown policy", () => {
+  it("matches configured cooldown windows only for the selected boss and role", () => {
+    const mob = { serverEntry: 123, abilityReadyAt: { "heavy-strike": 3_000 } };
+    expect(imminentCooldownMechanic(mob, "tank", 1_000, policy)?.id).toBe("tank-buster");
+    expect(imminentCooldownMechanic(mob, "damage", 1_000, policy)).toBeNull();
+    expect(imminentCooldownMechanic({ ...mob, serverEntry: 456 }, "tank", 1_000, policy)).toBeNull();
+    expect(imminentCooldownMechanic(mob, "tank", 6_000, policy)).toBeNull();
+  });
+
+  it("matches an active cast inside the configured lead time", () => {
+    expect(imminentCooldownMechanic({
+      serverEntry: 123,
+      activeCast: { attackId: "heavy-strike", completesAt: 3_000 },
+    }, "tank", 1_000, policy)?.attackName).toBe("Heavy Strike");
+  });
+
+  it("uses the authored boss name when an encounter has no server entry", () => {
+    const namePolicy = normalizeCompanionCooldownPolicy({
+      ...DEFAULT_COMPANION_COOLDOWN_POLICY,
+      mechanics: [{
+        id: "name-only", enabled: true, bossKey: "test/name-only", bossName: "Named Boss",
+        bossServerEntry: null, attackId: "heavy-strike", attackName: "Heavy Strike",
+        scope: "party", leadTimeMs: 2_500, minimumCooldownSeconds: 20,
+      }],
+    });
+    const window = { name: "Named Boss", abilityReadyAt: { "heavy-strike": 3_000 } };
+    expect(imminentCooldownMechanic(window, "healer", 1_000, namePolicy)?.id).toBe("name-only");
+    expect(imminentCooldownMechanic({ ...window, name: "Other Boss" }, "healer", 1_000, namePolicy)).toBeNull();
+  });
+});
@@ -0,0 +1,123 @@
+import type { PartyRole } from "./partyRoles";
+
+export interface CompanionCooldownGenericRules {
+  readonly defensiveHealthPercent: number;
+  readonly emergencyHealthPercent: number;
+  readonly healerMitigationHealthPercent: number;
+  readonly offensiveMajorCooldownSeconds: number;
+  readonly conserveOffensiveCooldownsForDurableTargets: boolean;
+}
+
+export interface CompanionCooldownMechanicRule {
+  readonly id: string;
+  readonly enabled: boolean;
+  readonly bossKey: string;
+  readonly bossName: string;
+  readonly bossServerEntry: number | null;
+  readonly attackId: string;
+  readonly attackName: string;
+  readonly scope: "tank" | "party";
+  readonly leadTimeMs: number;
+  readonly minimumCooldownSeconds: number;
+}
+
+export interface CompanionCooldownPolicy {
+  readonly schemaVersion: 1;
+  readonly generic: CompanionCooldownGenericRules;
+  readonly mechanics: readonly CompanionCooldownMechanicRule[];
+}
+
+export interface CooldownPolicyMobState {
+  readonly name?: string;
+  readonly serverEntry?: number | null;
+  readonly activeCast?: { readonly attackId: string; readonly completesAt: number } | null;
+  readonly abilityReadyAt?: Readonly<Record<string, number>>;
+}
+
+export const DEFAULT_COMPANION_COOLDOWN_POLICY: CompanionCooldownPolicy = Object.freeze({
+  schemaVersion: 1,
+  generic: Object.freeze({
+    defensiveHealthPercent: 55,
+    emergencyHealthPercent: 35,
+    healerMitigationHealthPercent: 80,
+    offensiveMajorCooldownSeconds: 60,
+    conserveOffensiveCooldownsForDurableTargets: true,
+  }),
+  mechanics: Object.freeze([]),
+});
+
+let installedPolicy = DEFAULT_COMPANION_COOLDOWN_POLICY;
+
+function bounded(value: unknown, fallback: number, minimum: number, maximum: number): number {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.max(minimum, Math.min(maximum, number)) : fallback;
+}
+
+export function normalizeCompanionCooldownPolicy(value: unknown): CompanionCooldownPolicy {
+  const input = value && typeof value === "object" ? value as Partial<CompanionCooldownPolicy> : {};
+  const generic: Partial<CompanionCooldownGenericRules> = input.generic && typeof input.generic === "object"
+    ? input.generic
+    : {};
+  const defaults = DEFAULT_COMPANION_COOLDOWN_POLICY.generic;
+  const mechanics = Array.isArray(input.mechanics) ? input.mechanics.flatMap((candidate, index) => {
+    if (!candidate || typeof candidate !== "object") return [];
+    const rule = candidate as Partial<CompanionCooldownMechanicRule>;
+    const attackId = typeof rule.attackId === "string" ? rule.attackId.trim() : "";
+    if (!attackId) return [];
+    return [{
+      id: typeof rule.id === "string" && rule.id.trim() ? rule.id.trim() : `mechanic-${index + 1}`,
+      enabled: rule.enabled !== false,
+      bossKey: typeof rule.bossKey === "string" ? rule.bossKey : "",
+      bossName: typeof rule.bossName === "string" ? rule.bossName : "",
+      bossServerEntry: rule.bossServerEntry !== null && rule.bossServerEntry !== undefined
+        && Number.isFinite(Number(rule.bossServerEntry))
+        ? Math.trunc(Number(rule.bossServerEntry))
+        : null,
+      attackId,
+      attackName: typeof rule.attackName === "string" ? rule.attackName : attackId,
+      scope: rule.scope === "party" ? "party" as const : "tank" as const,
+      leadTimeMs: bounded(rule.leadTimeMs, 2_500, 0, 15_000),
+      minimumCooldownSeconds: bounded(rule.minimumCooldownSeconds, 20, 0, 600),
+    }];
+  }) : [];
+  return Object.freeze({
+    schemaVersion: 1,
+    generic: Object.freeze({
+      defensiveHealthPercent: bounded(generic.defensiveHealthPercent, defaults.defensiveHealthPercent, 1, 100),
+      emergencyHealthPercent: bounded(generic.emergencyHealthPercent, defaults.emergencyHealthPercent, 1, 100),
+      healerMitigationHealthPercent: bounded(generic.healerMitigationHealthPercent, defaults.healerMitigationHealthPercent, 1, 100),
+      offensiveMajorCooldownSeconds: bounded(generic.offensiveMajorCooldownSeconds, defaults.offensiveMajorCooldownSeconds, 0, 600),
+      conserveOffensiveCooldownsForDurableTargets: generic.conserveOffensiveCooldownsForDurableTargets !== false,
+    }),
+    mechanics: Object.freeze(mechanics),
+  });
+}
+
+export function installCompanionCooldownPolicy(value: unknown): CompanionCooldownPolicy {
+  installedPolicy = normalizeCompanionCooldownPolicy(value);
+  return installedPolicy;
+}
+
+export function currentCompanionCooldownPolicy(): CompanionCooldownPolicy {
+  return installedPolicy;
+}
+
+export function imminentCooldownMechanic(
+  mob: CooldownPolicyMobState | null,
+  role: PartyRole,
+  now: number,
+  policy = installedPolicy,
+): CompanionCooldownMechanicRule | null {
+  if (!mob) return null;
+  return policy.mechanics.find((rule) => {
+    if (!rule.enabled || (rule.scope === "tank" && role !== "tank")) return false;
+    if (rule.bossServerEntry !== null && mob.serverEntry !== rule.bossServerEntry) return false;
+    if (rule.bossServerEntry === null && rule.bossName && mob.name !== rule.bossName) return false;
+    if (mob.activeCast?.attackId === rule.attackId) {
+      const remaining = mob.activeCast.completesAt - now;
+      return remaining >= 0 && remaining <= rule.leadTimeMs;
+    }
+    const readyAt = mob.abilityReadyAt?.[rule.attackId];
+    return readyAt !== undefined && readyAt >= now && readyAt - now <= rule.leadTimeMs;
+  }) ?? null;
+}
@@ -0,0 +1,96 @@
+import { create } from "zustand";
+import type { PlayerSession } from "../app/types";
+import { requestOnlineJson } from "../app/onlineAccountClient";
+import {
+  DEFAULT_COMPANION_COOLDOWN_POLICY,
+  installCompanionCooldownPolicy,
+  normalizeCompanionCooldownPolicy,
+  type CompanionCooldownPolicy,
+} from "./companionCooldownPolicy";
+
+interface PublishedCompanionCooldownPolicy {
+  readonly revision: number;
+  readonly updatedAt: number | null;
+  readonly updatedBy?: string | null;
+  readonly config: CompanionCooldownPolicy;
+}
+
+interface CompanionCooldownPolicyState extends PublishedCompanionCooldownPolicy {
+  readonly draft: CompanionCooldownPolicy;
+  readonly loading: boolean;
+  readonly saving: boolean;
+  readonly dirty: boolean;
+  readonly error: string | null;
+  refresh: (session?: PlayerSession | null) => Promise<void>;
+  replaceDraft: (draft: CompanionCooldownPolicy) => void;
+  resetDraft: () => void;
+  publish: (session: PlayerSession | null) => Promise<boolean>;
+}
+
+const CACHE_KEY = "healer-man.companion-cooldown-policy.v1";
+
+function cached(): PublishedCompanionCooldownPolicy {
+  try {
+    const value = JSON.parse(window.localStorage.getItem(CACHE_KEY) ?? "null") as Partial<PublishedCompanionCooldownPolicy> | null;
+    if (!value || !Number.isInteger(value.revision)) throw new Error("missing");
+    return { revision: value.revision!, updatedAt: value.updatedAt ?? null, config: normalizeCompanionCooldownPolicy(value.config) };
+  } catch {
+    return { revision: 0, updatedAt: null, config: DEFAULT_COMPANION_COOLDOWN_POLICY };
+  }
+}
+
+function cache(payload: PublishedCompanionCooldownPolicy): void {
+  try { window.localStorage.setItem(CACHE_KEY, JSON.stringify(payload)); } catch { /* optional cache */ }
+}
+
+const initial = cached();
+installCompanionCooldownPolicy(initial.config);
+
+export const useCompanionCooldownPolicyStore = create<CompanionCooldownPolicyState>((set, get) => ({
+  ...initial,
+  draft: initial.config,
+  loading: false,
+  saving: false,
+  dirty: false,
+  error: null,
+  refresh: async (session = null) => {
+    set({ loading: true, error: null });
+    try {
+      const gm = Boolean(session?.accessToken && session.roles?.includes("gm"));
+      const payload = await requestOnlineJson<PublishedCompanionCooldownPolicy>(
+        gm ? "/api/gm/companion-cooldown-policy" : "/api/companion-cooldown-policy",
+        {},
+        gm ? session?.accessToken : undefined,
+      );
+      const normalized = { ...payload, config: normalizeCompanionCooldownPolicy(payload.config) };
+      cache(normalized);
+      installCompanionCooldownPolicy(normalized.config);
+      set({ ...normalized, draft: normalized.config, loading: false, dirty: false });
+    } catch (error) {
+      set({ loading: false, error: error instanceof Error ? error.message : "Could not load companion cooldown policy." });
+    }
+  },
+  replaceDraft: (draft) => set({ draft: normalizeCompanionCooldownPolicy(draft), dirty: true, error: null }),
+  resetDraft: () => set((state) => ({ draft: state.config, dirty: false, error: null })),
+  publish: async (session) => {
+    if (!session?.accessToken || !session.roles?.includes("gm")) {
+      set({ error: "Game Master access is required." });
+      return false;
+    }
+    set({ saving: true, error: null });
+    try {
+      const payload = await requestOnlineJson<PublishedCompanionCooldownPolicy>("/api/gm/companion-cooldown-policy", {
+        method: "PUT",
+        body: JSON.stringify({ expectedRevision: get().revision, config: get().draft }),
+      }, session.accessToken);
+      const normalized = { ...payload, config: normalizeCompanionCooldownPolicy(payload.config) };
+      cache(normalized);
+      installCompanionCooldownPolicy(normalized.config);
+      set({ ...normalized, draft: normalized.config, saving: false, dirty: false });
+      return true;
+    } catch (error) {
+      set({ saving: false, error: error instanceof Error ? error.message : "Could not publish companion cooldown policy." });
+      return false;
+    }
+  },
+}));
@@ -0,0 +1,20 @@
+import { create } from "zustand";
+
+const STORAGE_KEY = "healer-man.include-beta-companion-specs.v1";
+
+function loadPreference(): boolean {
+  try { return window.localStorage.getItem(STORAGE_KEY) === "true"; } catch { return false; }
+}
+
+interface CompanionPartyPreferencesState {
+  includeBetaSpecs: boolean;
+  setIncludeBetaSpecs: (include: boolean) => void;
+}
+
+export const useCompanionPartyPreferences = create<CompanionPartyPreferencesState>((set) => ({
+  includeBetaSpecs: loadPreference(),
+  setIncludeBetaSpecs: (includeBetaSpecs) => {
+    try { window.localStorage.setItem(STORAGE_KEY, String(includeBetaSpecs)); } catch { /* optional preference */ }
+    set({ includeBetaSpecs });
+  },
+}));
@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import {
+  DEFAULT_COMPANION_SPEC_READINESS_POLICY,
+  READY_COMPANION_SPECIALIZATION_IDS,
+  WOW_COMPANION_SPECIALIZATIONS,
+  normalizeCompanionSpecReadinessPolicy,
+  readinessStatusFor,
+} from "./companionSpecReadiness";
+
+describe("companion specialization readiness", () => {
+  it("ships exactly five Ready profiles and 26 Needs Testing profiles", () => {
+    expect(WOW_COMPANION_SPECIALIZATIONS).toHaveLength(31);
+    expect(new Set(WOW_COMPANION_SPECIALIZATIONS.filter((definition) => (
+      readinessStatusFor(definition.id) === "ready"
+    )).map((definition) => definition.id))).toEqual(new Set(READY_COMPANION_SPECIALIZATION_IDS));
+    expect(Object.values(DEFAULT_COMPANION_SPEC_READINESS_POLICY.statuses).filter((status) => status === "needs-testing")).toHaveLength(26);
+  });
+
+  it("fills newly introduced or missing entries as Needs Testing", () => {
+    const normalized = normalizeCompanionSpecReadinessPolicy({
+      schemaVersion: 1,
+      statuses: Object.fromEntries(READY_COMPANION_SPECIALIZATION_IDS.map((id) => [id, "ready"])),
+    });
+    expect(normalized.statuses["warrior:arms"]).toBe("needs-testing");
+    expect(readinessStatusFor("future:new-spec", normalized)).toBe("needs-testing");
+  });
+
+  it("rejects policies without certified role coverage", () => {
+    expect(() => normalizeCompanionSpecReadinessPolicy({
+      schemaVersion: 1,
+      statuses: { "warrior:protection": "ready" },
+    })).toThrow("healer specialization");
+    expect(() => normalizeCompanionSpecReadinessPolicy({
+      schemaVersion: 1,
+      statuses: {
+        "warrior:protection": "ready",
+        "priest:discipline": "ready",
+        "hunter:marksmanship": "ready",
+        "mage:fire": "ready",
+      },
+    })).toThrow("three distinct damage");
+  });
+});
@@ -0,0 +1,130 @@
+import { BASE_CLASS_IDS } from "../app/characterCatalog";
+import type { PartyRole } from "./partyRoles";
+import {
+  SPECIALIZATION_DEFINITIONS,
+  type SpecializationDefinition,
+} from "./specializationCatalog";
+
+export type CompanionSpecReadinessStatus = "ready" | "beta" | "needs-testing";
+
+export interface CompanionSpecReadinessPolicy {
+  readonly schemaVersion: 1;
+  readonly statuses: Readonly<Record<string, CompanionSpecReadinessStatus>>;
+}
+
+export interface PublishedCompanionSpecReadinessPolicy {
+  readonly revision: number;
+  readonly updatedAt: number | null;
+  readonly updatedBy?: string | null;
+  readonly config: CompanionSpecReadinessPolicy;
+}
+
+export const READY_COMPANION_SPECIALIZATION_IDS = Object.freeze([
+  "warrior:protection",
+  "priest:discipline",
+  "hunter:marksmanship",
+  "mage:fire",
+  "rogue:assassination",
+] as const);
+
+const CLASSIC_CLASS_IDS = new Set<string>(BASE_CLASS_IDS);
+const READY_IDS = new Set<string>(READY_COMPANION_SPECIALIZATION_IDS);
+const VALID_STATUSES = new Set<CompanionSpecReadinessStatus>(["ready", "beta", "needs-testing"]);
+
+export const WOW_COMPANION_SPECIALIZATIONS: readonly SpecializationDefinition[] = Object.freeze(
+  SPECIALIZATION_DEFINITIONS.filter((definition) => CLASSIC_CLASS_IDS.has(definition.classId)),
+);
+
+const WOW_SPECIALIZATION_IDS = new Set(WOW_COMPANION_SPECIALIZATIONS.map((definition) => definition.id));
+
+export const DEFAULT_COMPANION_SPEC_READINESS_POLICY: CompanionSpecReadinessPolicy = Object.freeze({
+  schemaVersion: 1,
+  statuses: Object.freeze(Object.fromEntries(
+    WOW_COMPANION_SPECIALIZATIONS.map((definition) => [
+      definition.id,
+      (READY_IDS.has(definition.id) ? "ready" : "needs-testing") as CompanionSpecReadinessStatus,
+    ]),
+  )),
+});
+
+function invalid(message: string): Error {
+  return new Error(message);
+}
+
+export function readinessStatusFor(
+  specializationId: string | null | undefined,
+  policy: CompanionSpecReadinessPolicy = DEFAULT_COMPANION_SPEC_READINESS_POLICY,
+): CompanionSpecReadinessStatus {
+  if (!specializationId || !WOW_SPECIALIZATION_IDS.has(specializationId)) return "needs-testing";
+  return policy.statuses[specializationId] ?? "needs-testing";
+}
+
+export function validateReadyRoleCoverage(policy: CompanionSpecReadinessPolicy): void {
+  const readyByRole = (role: PartyRole) => WOW_COMPANION_SPECIALIZATIONS.filter((definition) => (
+    definition.role === role && readinessStatusFor(definition.id, policy) === "ready"
+  ));
+  if (readyByRole("tank").length < 1) throw invalid("At least one tank specialization must be Ready.");
+  if (readyByRole("healer").length < 1) throw invalid("At least one healer specialization must be Ready.");
+  if (new Set(readyByRole("damage").map((definition) => definition.id)).size < 3) {
+    throw invalid("At least three distinct damage specializations must be Ready.");
+  }
+}
+
+export function normalizeCompanionSpecReadinessPolicy(value: unknown): CompanionSpecReadinessPolicy {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw invalid("Companion readiness policy must be an object.");
+  }
+  const input = value as Partial<CompanionSpecReadinessPolicy>;
+  if (input.schemaVersion !== 1) throw invalid("Companion readiness policy schemaVersion must be 1.");
+  if (!input.statuses || typeof input.statuses !== "object" || Array.isArray(input.statuses)) {
+    throw invalid("Companion readiness statuses are required.");
+  }
+  for (const [specializationId, status] of Object.entries(input.statuses)) {
+    if (!WOW_SPECIALIZATION_IDS.has(specializationId)) {
+      throw invalid(`Unknown WoW specialization: ${specializationId}.`);
+    }
+    if (!VALID_STATUSES.has(status as CompanionSpecReadinessStatus)) {
+      throw invalid(`Invalid readiness status for ${specializationId}.`);
+    }
+  }
+  const policy: CompanionSpecReadinessPolicy = Object.freeze({
+    schemaVersion: 1,
+    statuses: Object.freeze(Object.fromEntries(WOW_COMPANION_SPECIALIZATIONS.map((definition) => [
+      definition.id,
+      (input.statuses as Readonly<Record<string, CompanionSpecReadinessStatus>>)[definition.id] ?? "needs-testing",
+    ]))),
+  });
+  validateReadyRoleCoverage(policy);
+  return policy;
+}
+
+export function companionSpecializationsForPolicy(
+  policy: CompanionSpecReadinessPolicy,
+  includeBetaSpecs: boolean,
+  role?: PartyRole,
+): readonly SpecializationDefinition[] {
+  return WOW_COMPANION_SPECIALIZATIONS.filter((definition) => {
+    if (role && definition.role !== role) return false;
+    const status = readinessStatusFor(definition.id, policy);
+    return status === "ready" || (includeBetaSpecs && status === "beta");
+  });
+}
+
+export function cloneDefaultCompanionSpecReadinessPolicy(): CompanionSpecReadinessPolicy {
+  return JSON.parse(JSON.stringify(DEFAULT_COMPANION_SPEC_READINESS_POLICY)) as CompanionSpecReadinessPolicy;
+}
+
+export function companionSpecReadinessFromCache(value: string | null): PublishedCompanionSpecReadinessPolicy {
+  try {
+    const parsed = JSON.parse(value ?? "null") as Partial<PublishedCompanionSpecReadinessPolicy> | null;
+    if (!parsed || !Number.isInteger(parsed.revision)) throw new Error("missing cache");
+    return {
+      revision: parsed.revision!,
+      updatedAt: parsed.updatedAt ?? null,
+      updatedBy: parsed.updatedBy ?? null,
+      config: normalizeCompanionSpecReadinessPolicy(parsed.config),
+    };
+  } catch {
+    return { revision: 0, updatedAt: null, updatedBy: null, config: DEFAULT_COMPANION_SPEC_READINESS_POLICY };
+  }
+}
@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { companionSpecReadinessFromCache } from "./companionSpecReadiness";
+
+describe("companion readiness offline cache", () => {
+  it("falls back to shipped defaults when the cached policy is corrupt", () => {
+    const cached = companionSpecReadinessFromCache("{not-json");
+    expect(cached.revision).toBe(0);
+    expect(cached.config.statuses["warrior:protection"]).toBe("ready");
+    expect(Object.values(cached.config.statuses).filter((status) => status === "ready")).toHaveLength(5);
+  });
+
+  it("retains the last valid published policy for offline play", () => {
+    const cached = companionSpecReadinessFromCache(JSON.stringify({
+      revision: 4,
+      updatedAt: 123,
+      updatedBy: "Phenom",
+      config: {
+        schemaVersion: 1,
+        statuses: {
+          "warrior:protection": "ready",
+          "priest:discipline": "ready",
+          "hunter:marksmanship": "ready",
+          "mage:fire": "ready",
+          "rogue:assassination": "ready",
+          "paladin:retribution": "beta",
+        },
+      },
+    }));
+    expect(cached.revision).toBe(4);
+    expect(cached.config.statuses["paladin:retribution"]).toBe("beta");
+    expect(cached.config.statuses["druid:balance"]).toBe("needs-testing");
+  });
+});
@@ -0,0 +1,104 @@
+import { create } from "zustand";
+import type { PlayerSession } from "../app/types";
+import { requestOnlineJson } from "../app/onlineAccountClient";
+import {
+  companionSpecReadinessFromCache,
+  normalizeCompanionSpecReadinessPolicy,
+  type CompanionSpecReadinessPolicy,
+  type PublishedCompanionSpecReadinessPolicy,
+} from "./companionSpecReadiness";
+
+interface CompanionSpecReadinessState extends PublishedCompanionSpecReadinessPolicy {
+  readonly draft: CompanionSpecReadinessPolicy;
+  readonly loading: boolean;
+  readonly saving: boolean;
+  readonly dirty: boolean;
+  readonly error: string | null;
+  refresh: (session?: PlayerSession | null) => Promise<void>;
+  setStatus: (specializationId: string, status: "ready" | "beta" | "needs-testing") => void;
+  resetDraft: () => void;
+  publish: (session?: PlayerSession | null) => Promise<boolean>;
+}
+
+const CACHE_KEY = "healer-man.companion-spec-readiness.v1";
+const LOCAL_GUI = import.meta.env.VITE_LOCAL_BALANCE_LAB_GUI === "true";
+const LOCAL_PATH = "/api/local/balance-lab/companion-spec-readiness";
+
+function cached(): PublishedCompanionSpecReadinessPolicy {
+  return companionSpecReadinessFromCache(typeof window === "undefined" ? null : window.localStorage.getItem(CACHE_KEY));
+}
+
+function cache(payload: PublishedCompanionSpecReadinessPolicy): void {
+  try { window.localStorage.setItem(CACHE_KEY, JSON.stringify(payload)); } catch { /* optional offline cache */ }
+}
+
+async function request<T>(pathname: string, init: RequestInit, session?: PlayerSession | null): Promise<T> {
+  if (!LOCAL_GUI) return requestOnlineJson<T>(pathname, init, session?.accessToken);
+  const headers = new Headers(init.headers);
+  headers.set("Accept", "application/json");
+  if (init.body !== undefined) headers.set("Content-Type", "application/json");
+  const response = await fetch(LOCAL_PATH, { ...init, headers });
+  const body = await response.json().catch(() => ({})) as T & { error?: string };
+  if (!response.ok) throw new Error(body.error ?? `Local readiness request failed (${response.status}).`);
+  return body;
+}
+
+const initial = cached();
+
+export const useCompanionSpecReadinessStore = create<CompanionSpecReadinessState>((set, get) => ({
+  ...initial,
+  draft: initial.config,
+  loading: false,
+  saving: false,
+  dirty: false,
+  error: null,
+  refresh: async (session = null) => {
+    set({ loading: true, error: null });
+    try {
+      const gm = Boolean(session?.accessToken && session.roles?.includes("gm"));
+      const pathname = gm ? "/api/gm/companion-spec-readiness" : "/api/companion-spec-readiness";
+      const payload = await request<PublishedCompanionSpecReadinessPolicy>(pathname, {}, session);
+      const normalized = { ...payload, config: normalizeCompanionSpecReadinessPolicy(payload.config) };
+      cache(normalized);
+      set({ ...normalized, draft: normalized.config, loading: false, dirty: false });
+    } catch (error) {
+      set({ loading: false, error: error instanceof Error ? error.message : "Could not load companion readiness." });
+    }
+  },
+  setStatus: (specializationId, status) => set((state) => ({
+    draft: {
+      schemaVersion: 1,
+      statuses: { ...state.draft.statuses, [specializationId]: status },
+    },
+    dirty: true,
+    error: null,
+  })),
+  resetDraft: () => set((state) => ({ draft: state.config, dirty: false, error: null })),
+  publish: async (session = null) => {
+    if (!LOCAL_GUI && (!session?.accessToken || !session.roles?.includes("gm"))) {
+      set({ error: "Game Master access is required." });
+      return false;
+    }
+    set({ saving: true, error: null });
+    try {
+      const draft = normalizeCompanionSpecReadinessPolicy(get().draft);
+      const payload = await request<PublishedCompanionSpecReadinessPolicy>(
+        "/api/gm/companion-spec-readiness",
+        { method: "PUT", body: JSON.stringify({ expectedRevision: get().revision, config: draft }) },
+        session,
+      );
+      const normalized = { ...payload, config: normalizeCompanionSpecReadinessPolicy(payload.config) };
+      cache(normalized);
+      set({ ...normalized, draft: normalized.config, saving: false, dirty: false });
+      return true;
+    } catch (error) {
+      set({ saving: false, error: error instanceof Error ? error.message : "Could not publish companion readiness." });
+      return false;
+    }
+  },
+}));
+
+export function currentCompanionSpecReadinessPolicy(): PublishedCompanionSpecReadinessPolicy {
+  const state = useCompanionSpecReadinessStore.getState();
+  return { revision: state.revision, updatedAt: state.updatedAt, updatedBy: state.updatedBy, config: state.config };
+}
@@ -114,7 +114,9 @@ describe("dungeon boss durability and difficulty", () => {
        const ordinary = fight(stockadesBoss.id, level, 1, seed, false, false, "wow", stockades);
        const last = fight(finalDungeonBoss(stockades)!.id, level, 1, seed, false, false, "wow", stockades);
        samples.push({ level, seed, boss: ordinary, final: last });
-        expect(ordinary.seconds ?? 240, JSON.stringify({ level, seed, ordinary, last })).toBeGreaterThanOrEqual(25);
+        // Combat advances in 100 ms ticks and the first action cadence varies by
+        // generated party. Keep a half-second tolerance around the 25s design floor.
+        expect(ordinary.seconds ?? 240, JSON.stringify({ level, seed, ordinary, last })).toBeGreaterThanOrEqual(24.5);
        expect(last.seconds ?? 240, JSON.stringify({ level, seed, ordinary, last })).toBeGreaterThanOrEqual(45);
      }
    }, 30000);
@@ -14,6 +14,7 @@ const WOW_BOSS_HEALTH_FLOOR: readonly (readonly [level: number, health: number])
  [9, 7_000],
  [21, 11_000],
  [41, 23_000],
+  [51, 39_000],
  [80, 180_000],
 ];
 const WOW_BOSS_TEST_HEALTH_FLOOR: readonly (readonly [level: number, health: number])[] = [
@@ -22,7 +23,18 @@ const WOW_BOSS_TEST_HEALTH_FLOOR: readonly (readonly [level: number, health: num
  [9, 7_000],
  [21, 11_000],
  [41, 23_000],
-  [80, 180_000],
+  // Isolated test fights are normalized to the certified companion curve.
+  // Native expansion-2 template health grows much faster than the party's
+  // observed level-80 DPS and previously pushed the average fight above 170s.
+  [80, 44_000],
+];
+const WOW_BOSS_TEST_DAMAGE_SCALE: readonly (readonly [level: number, scale: number])[] = [
+  [1, 1],
+  [50, 1],
+  // Level-80 source creature weapon damage grows faster than the certified
+  // healer's throughput. This keeps test-room pressure sustained without
+  // turning roughly a third of catalog coverage runs into early wipes.
+  [80, 0.75],
 ];
 const BOSS_TEST_HEALTH_FLOOR_MULTIPLIER = 0.6;
 const FINAL_BOSS_HEALTH_FLOOR_MULTIPLIER = 1.9;
@@ -73,9 +85,18 @@ export function dungeonEnemyScaling(dungeon: DungeonDefinition, entity: Populati
  // finale. A reduced floor still prevents high-level source creatures with
  // tiny extrapolated level-two health from dying before mechanics can run.
  const testingBossFloor = partyHealthFloor * BOSS_TEST_HEALTH_FLOOR_MULTIPLIER;
+  const testingBossCeiling = characterSource === "wow"
+    ? partyHealthFloor * 0.9 * Math.max(1, Math.min(1.5, authoredHealth))
+    : Number.POSITIVE_INFINITY;
  const scaledHealth = boss
-    ? Math.max(originalHealth, testing ? testingBossFloor : bossFloor)
+    ? testing
+      ? Math.max(Math.min(originalHealth, testingBossCeiling), testingBossFloor)
+      : Math.max(originalHealth, bossFloor)
    : originalHealth;
+  const testingDamageScale = testing && characterSource === "wow"
+    ? interpolatedFloor(level, WOW_BOSS_TEST_DAMAGE_SCALE)
+    : 1;
  return { level, maxHealth: scaledHealth * multipliers.health,
-    healthMultiplier: authoredHealth * multipliers.health, damageMultiplier: authoredDamage * multipliers.damage };
+    healthMultiplier: authoredHealth * multipliers.health,
+    damageMultiplier: authoredDamage * multipliers.damage * testingDamageScale };
 }
@@ -58,10 +58,10 @@ function compatibleItems(classId: ClassId, level: number): InventoryItem[] {
 }

 describe("specialization-aware heirlooms", () => {
-  it("caps player heirlooms at 79 and party heirlooms at 80", () => {
+  it("caps player and party heirlooms at 79", () => {
    const profile = SPECIALIZATION_DEFINITIONS.find((definition) => definition.id === "priest:holy")!;
    expect(new Set(resolvedEquipmentItems({}, [], context(profile, 80)).map((item) => item.itemLevel))).toEqual(new Set([79]));
-    expect(new Set(resolvedEquipmentItems({}, [], context(profile, 80, "party")).map((item) => item.itemLevel))).toEqual(new Set([80]));
+    expect(new Set(resolvedEquipmentItems({}, [], context(profile, 80, "party")).map((item) => item.itemLevel))).toEqual(new Set([79]));
    expect(resolvedAverageItemLevel({}, [], context(profile, 40))).toBe(40);
  });

@@ -31,7 +31,7 @@ import {
 } from "./specializationCatalog";

 export const PLAYER_HEIRLOOM_LEVEL_CAP = 79;
-export const PARTY_HEIRLOOM_LEVEL_CAP = 80;
+export const PARTY_HEIRLOOM_LEVEL_CAP = 79;
 export const FIRST_ENDGAME_ITEM_LEVEL = 85;

 export type HeirloomOwnerKind = "player" | "party";
@@ -112,6 +112,25 @@ describe("catalog-driven party rotations", () => {
      .toBe("Mortal Strike");
  });

+  it("uses Bloodrage to break a Protection Warrior zero-Rage state", () => {
+    const talents = runtimePartyTalentRanksForLevel("warrior", "Protection", 80);
+    const member = {
+      ...memberFor("warrior", "tank"),
+      specialization: "Protection",
+      specializationId: "warrior:protection" as const,
+      talentRanks: talents,
+      resource: 0,
+      resourcePools: { rage: 0 },
+    };
+    const stance = abilitiesForClass("warrior").find((ability) => ability.name === "Defensive Stance")!;
+    const target = { ...useCombatStore.getState().mobs.caster, activeCast: null };
+    expect(choosePartyAbility(member, {
+      now: 2_000,
+      target,
+      maintainedAbilityIds: new Set([stance.id]),
+    })?.name).toBe("Bloodrage");
+  });
+
  it("opens Arcane combat with the learned Arcane Barrage signature", () => {
    const member = {
      ...memberFor("mage", "damage"),
@@ -17,6 +17,7 @@ import { equipmentAdjustedCombatAmount, type MobCombatState } from "./combatStor
 import type { PartyMember } from "./partyStore";
 import { baseResourcesFor } from "./wotlkStats";
 import { companionResourceMaximum } from "./combatActorAuthority";
+import { currentCompanionCooldownPolicy, type CompanionCooldownMechanicRule } from "./companionCooldownPolicy";

 export interface PartyAbilityContext {
  readonly now: number;
@@ -35,6 +36,7 @@ export interface PartyAbilityContext {
  readonly activeSummonAbilityIds?: ReadonlySet<string>;
  readonly hasActivePet?: boolean;
  readonly canUseAbility?: (ability: AbilityDefinition) => boolean;
+  readonly incomingDefensiveMechanic?: CompanionCooldownMechanicRule | null;
 }

 function currentResource(member: PartyMember, type: ResourceType): number {
@@ -155,6 +157,8 @@ export function choosePartyRotationDecision(
    activeSummonAbilityIds: context.activeSummonAbilityIds,
    hasActivePet: context.hasActivePet,
    canUseAbility: context.canUseAbility,
+    cooldownPolicy: currentCompanionCooldownPolicy(),
+    incomingDefensiveMechanic: context.incomingDefensiveMechanic,
  });
  return decision && shouldReserveForHigherPriority(member, learned, decision, context.now)
    ? null
@@ -20,12 +20,12 @@ function partyTemplates(level: number): PartyMember[] {
 }

 describe("NPC sustained damage audit", () => {
-  it("lets Garrick swing immediately with no Rage, and keeps swinging during the GCD", () => {
+  it("lets the Ready Protection Warrior swing immediately with no Rage, and keeps swinging during the GCD", () => {
    clearMobRuntimeRegistry();
    clearPartyRuntimeRegistry();
    resetPartyRuntimeClock();
    useCombatStore.getState().initializeCharacter({ classId: "priest", level: 3 });
-    const garrick = partyTemplates(3).find((member) => member.name === "Garrick")!;
+    const garrick = partyTemplates(3).find((member) => member.specializationId === "warrior:protection")!;
    usePartyStore.getState().initializeParty("short-pull", 3, useCombatStore.getState().health);
    usePartyStore.setState({ members: [{ ...garrick, globalCooldownEndsAt: 10_000 }] });
    useCombatStore.getState().synchronizeActors();
@@ -55,7 +55,7 @@ describe("NPC sustained damage audit", () => {
    clearPartyRuntimeRegistry();
    resetPartyRuntimeClock();
    useCombatStore.getState().initializeCharacter({ classId: "priest", level: 5 });
-    const garrick = partyTemplates(5).find((member) => member.name === "Garrick")!;
+    const garrick = partyTemplates(5).find((member) => member.specializationId === "warrior:protection")!;
    usePartyStore.getState().initializeParty("area-pull", 5, useCombatStore.getState().health);
    usePartyStore.setState({ members: [{ ...garrick, resource: 100, resourcePools: { rage: 100 },
      cooldowns: Object.fromEntries(abilitiesForClass("warrior").filter((ability) => ability.id !== "warrior-thunder-clap")
@@ -224,7 +224,7 @@ describe("NPC sustained damage audit", () => {
  for (const level of [1, 3, 5, 20, 80]) {
    it(`executes damaging abilities for every party template at level ${level}`, () => {
      const templates = partyTemplates(level);
-      expect(templates).toHaveLength(26);
+      expect(templates).toHaveLength(5);
      for (const member of templates) {
        clearMobRuntimeRegistry();
        clearPartyRuntimeRegistry();
@@ -57,6 +57,8 @@ import {
  commitPartyAbilityUse,
  partyAbilityAmount,
 } from "./partyAbilityAi";
+import { emitRotationDecision } from "./rotationTelemetry";
+import { imminentCooldownMechanic } from "./companionCooldownPolicy";
 import { normalizeActorResourcePool } from "./combatActors";
 import { enemyControlPreventsActions } from "./enemyAttacks";
 import { advanceCombatResourcePool } from "./combatResources";
@@ -1568,7 +1570,14 @@ export function advanceDungeonPartyCombat(now = Date.now()): void {
        target: targetMob ?? null,
        targetIsLoose: member.role === "tank" && targetMob?.targetActorId !== member.id,
        hasDangerousThreat: member.role !== "tank" && targetMob?.targetActorId === member.id,
+        incomingDefensiveMechanic: imminentCooldownMechanic(targetMob ?? null, member.role, now),
        hostileCount: Object.values(currentCombat.mobs).filter((mob) => mob.engaged && !mob.dead).length,
+        friendlyTargets: nextMembers.filter((candidate) => candidate.health > 0).map((candidate) => ({
+          id: candidate.id,
+          health: candidate.health,
+          maxHealth: candidate.maxHealth,
+          role: candidate.role,
+        })),
        maintainedAbilityIds: new Set([
          ...currentCombat.effects.filter((effect) => effect.sourceActorId === member.id && effect.remainingTicks > 0)
            .map((effect) => effect.sourceAbilityId),
@@ -1632,6 +1641,17 @@ export function advanceDungeonPartyCombat(now = Date.now()): void {
        nextMembers[index] = { ...runtimeMember, status: desiredStatus, nextActionAt: now + 250 };
        continue;
      }
+      if (selectedDecision) {
+        emitRotationDecision({
+          occurredAt: now,
+          actorId: member.id,
+          abilityId: selectedAbility.id,
+          targetId: abilityTargetId,
+          profileId: selectedDecision.profileId,
+          ruleId: selectedDecision.ruleId,
+          reason: selectedDecision.reason,
+        });
+      }
      if (selectedAbility.castTimeMs > 0) {
        nextMembers[index] = {
          ...committed,
@@ -16,6 +16,7 @@ import {
 import { spentTalentPoints, talentPointsForLevel, talentTreeById } from "./talentCatalog";
 import type { InventoryItem } from "./lootTypes";
 import { EMPTY_ITEM_STATS } from "./itemStats";
+import { DEFAULT_COMPANION_SPEC_READINESS_POLICY } from "./companionSpecReadiness";

 describe("dungeon party composition", () => {
  beforeEach(() => usePartyStore.setState({
@@ -46,6 +47,53 @@ describe("dungeon party composition", () => {
    }
  });

+  it("uses only the five Ready Playerbots identities by default", () => {
+    const party = createDungeonParty("ready-only", 80, "damage");
+    expect(party.map((member) => member.name)).toEqual(expect.arrayContaining(["Aldren", "Quorin"]));
+    expect(party.every((member) => ["Aldren", "Quorin", "Liora", "Xavian", "Orin"].includes(member.name))).toBe(true);
+    expect(new Set(party.filter((member) => member.role === "damage").map((member) => member.specializationId)).size)
+      .toBe(party.filter((member) => member.role === "damage").length);
+  });
+
+  it("adds Beta specs only when opted in and still excludes Needs Testing", () => {
+    const policy = {
+      schemaVersion: 1 as const,
+      statuses: {
+        ...DEFAULT_COMPANION_SPEC_READINESS_POLICY.statuses,
+        "mage:arcane": "beta" as const,
+      },
+    };
+    const defaultNames = new Set<string>();
+    const betaNames = new Set<string>();
+    for (let seed = 0; seed < 40; seed += 1) {
+      for (const member of createDungeonParty(`beta-${seed}`, 80, "damage", 5, "wow", { readinessPolicy: policy })) {
+        defaultNames.add(member.specializationId ?? "");
+      }
+      for (const member of createDungeonParty(`beta-${seed}`, 80, "damage", 5, "wow", { readinessPolicy: policy, includeBetaSpecs: true })) {
+        betaNames.add(member.specializationId ?? "");
+      }
+    }
+    expect(defaultNames.has("mage:arcane")).toBe(false);
+    expect(betaNames.has("mage:arcane")).toBe(true);
+    expect(betaNames.has("mage:frost")).toBe(false);
+  });
+
+  it("avoids the player's damage specialization when two alternatives can fill the NPC seats", () => {
+    const party = createDungeonParty("exclude-player", 80, "damage", 5, "wow", {
+      excludedPlayerSpecializationId: "mage:fire",
+    });
+    expect(party.filter((member) => member.role === "damage").map((member) => member.specializationId).sort())
+      .toEqual(["hunter:marksmanship", "rogue:assassination"]);
+  });
+
+  it("keeps RoM generation unchanged when WoW readiness is restrictive", () => {
+    const baseline = createDungeonParty("rom-readiness", 40, "damage", 5, "rom");
+    const filtered = createDungeonParty("rom-readiness", 40, "damage", 5, "rom", {
+      readinessPolicy: DEFAULT_COMPANION_SPEC_READINESS_POLICY,
+    });
+    expect(filtered).toEqual(baseline);
+  });
+
  it("fills a dedicated healer when the player chooses tank or damage", () => {
    for (const playerRole of ["tank", "damage"] as const) {
      for (const seed of ["role-a", "role-b", "role-c", "role-d"]) {
@@ -26,7 +26,16 @@ import {
  deriveCharacterStats,
 } from "./wotlkStats";
 import type { InventoryItem } from "./lootTypes";
-import { runtimePartyTalentRanksForLevel } from "./partyTalentRuntime";
+import {
+  runtimeDefaultPartyTalentProfile,
+  runtimePartyTalentRanksForLevel,
+} from "./partyTalentRuntime";
+import {
+  DEFAULT_COMPANION_SPEC_READINESS_POLICY,
+  WOW_COMPANION_SPECIALIZATIONS,
+  companionSpecializationsForPolicy,
+  type CompanionSpecReadinessPolicy,
+} from "./companionSpecReadiness";
 import type { RuntimeTalentRanks as TalentRanks } from "./talentRuntimeCatalog";
 import type { EnemyControlMechanic } from "./enemyAttacks";
 import type { ContentCategoryId } from "../app/contentCategories";
@@ -62,6 +71,7 @@ export interface PartyMember {
  readonly specialization: string;
  readonly specializationId: string | null;
  readonly talentTreeId: string;
+  readonly talentProfileId: string | null;
  readonly talentRanks: TalentRanks;
  readonly role: PartyRole;
  readonly level: number;
@@ -94,6 +104,7 @@ interface PartyTemplate {
  readonly classId: ClassId;
  readonly specialization: string;
  readonly talentTreeId: string;
+  readonly talentProfileId?: string | null;
 }

 export interface ConfiguredPartyMemberSeed {
@@ -103,45 +114,43 @@ export interface ConfiguredPartyMemberSeed {
  readonly specialization: string;
  readonly specializationId?: string | null;
  readonly talentTreeId?: string;
+  readonly talentProfileId?: string | null;
  readonly talentRanks?: TalentRanks;
  readonly role: PartyRole;
 }

-const TANK_TEMPLATES: readonly PartyTemplate[] = Object.freeze([
-  { name: "Garrick", classId: "warrior", specialization: "Protection", talentTreeId: "warrior-protection" },
-  { name: "Morvane", classId: "death-knight", specialization: "Blood", talentTreeId: "death-knight-blood" },
-  { name: "Seraphin", classId: "paladin", specialization: "Protection", talentTreeId: "paladin-protection" },
-]);
+export interface CompanionPartyGenerationOptions {
+  readonly readinessPolicy?: CompanionSpecReadinessPolicy;
+  readonly readinessPolicyRevision?: number;
+  readonly includeBetaSpecs?: boolean;
+  readonly excludedPlayerSpecializationId?: string | null;
+}

-const HEALER_TEMPLATES: readonly PartyTemplate[] = Object.freeze([
-  { name: "Elowen", classId: "priest", specialization: "Holy", talentTreeId: "priest-holy" },
-  { name: "Lucian", classId: "paladin", specialization: "Holy", talentTreeId: "paladin-holy" },
-  { name: "Nym", classId: "druid", specialization: "Restoration", talentTreeId: "druid-restoration" },
-  { name: "Tala", classId: "shaman", specialization: "Restoration", talentTreeId: "shaman-restoration" },
-]);
+function companionTemplateFor(specializationId: string): PartyTemplate {
+  const definition = specializationsForClass(specializationId.split(":", 1)[0] as ClassId)
+    .find((candidate) => candidate.id === specializationId);
+  if (!definition) throw new Error(`Unknown companion specialization ${specializationId}.`);
+  const profile = runtimeDefaultPartyTalentProfile(definition.classId, definition.displayName);
+  return Object.freeze({
+    name: profile.characterName,
+    classId: definition.classId,
+    specialization: definition.displayName,
+    talentTreeId: `${definition.classId}-${definition.talentTree.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`,
+    talentProfileId: profile.id,
+  });
+}

-/** Every entry is a Wrath damage specialization; tank and healer specs are excluded. */
-const DAMAGE_TEMPLATES: readonly PartyTemplate[] = Object.freeze([
-  { name: "Brynn", classId: "warrior", specialization: "Arms", talentTreeId: "warrior-arms" },
-  { name: "Kael", classId: "warrior", specialization: "Fury", talentTreeId: "warrior-fury" },
-  { name: "Aurelia", classId: "paladin", specialization: "Retribution", talentTreeId: "paladin-retribution" },
-  { name: "Tamsin", classId: "hunter", specialization: "Marksmanship", talentTreeId: "hunter-marksmanship" },
-  { name: "Fen", classId: "hunter", specialization: "Survival", talentTreeId: "hunter-survival" },
-  { name: "Vale", classId: "rogue", specialization: "Combat", talentTreeId: "rogue-combat" },
-  { name: "Nyx", classId: "rogue", specialization: "Assassination", talentTreeId: "rogue-assassination" },
-  { name: "Selene", classId: "priest", specialization: "Shadow", talentTreeId: "priest-shadow" },
-  { name: "Varek", classId: "death-knight", specialization: "Frost", talentTreeId: "death-knight-frost" },
-  { name: "Thorne", classId: "death-knight", specialization: "Unholy", talentTreeId: "death-knight-unholy" },
-  { name: "Korra", classId: "shaman", specialization: "Enhancement", talentTreeId: "shaman-enhancement" },
-  { name: "Orin", classId: "shaman", specialization: "Elemental", talentTreeId: "shaman-elemental" },
-  { name: "Mira", classId: "mage", specialization: "Arcane", talentTreeId: "mage-arcane" },
-  { name: "Ember", classId: "mage", specialization: "Fire", talentTreeId: "mage-fire" },
-  { name: "Ilyra", classId: "mage", specialization: "Frost", talentTreeId: "mage-frost" },
-  { name: "Malric", classId: "warlock", specialization: "Affliction", talentTreeId: "warlock-affliction" },
-  { name: "Sable", classId: "warlock", specialization: "Demonology", talentTreeId: "warlock-demonology" },
-  { name: "Rowan", classId: "druid", specialization: "Balance", talentTreeId: "druid-balance" },
-  { name: "Ash", classId: "druid", specialization: "Feral (Cat)", talentTreeId: "druid-feral-combat" },
-]);
+function wowTemplates(
+  role: PartyRole,
+  options: CompanionPartyGenerationOptions,
+  seats: number,
+): readonly PartyTemplate[] {
+  const policy = options.readinessPolicy ?? DEFAULT_COMPANION_SPEC_READINESS_POLICY;
+  const definitions = companionSpecializationsForPolicy(policy, options.includeBetaSpecs === true, role);
+  const withoutPlayer = definitions.filter((definition) => definition.id !== options.excludedPlayerSpecializationId);
+  const candidates = withoutPlayer.length >= seats ? withoutPlayer : definitions;
+  return candidates.map((definition) => companionTemplateFor(definition.id));
+}

 const ROM_TANK_TEMPLATES: readonly PartyTemplate[] = Object.freeze([
  { name: "Aldric", classId: "rom-warrior", specialization: "Primary", talentTreeId: "" },
@@ -160,22 +169,19 @@ const ROM_DAMAGE_TEMPLATES: readonly PartyTemplate[] = Object.freeze([
  { name: "Roran", classId: "rom-knight", specialization: "Primary", talentTreeId: "" },
 ]);

-export const TANK_SPECIALIZATIONS = Object.freeze(new Set([
-  "warrior:Protection",
-  "death-knight:Blood",
-  "paladin:Protection",
-]));
+export const TANK_SPECIALIZATIONS = Object.freeze(new Set(
+  WOW_COMPANION_SPECIALIZATIONS.filter((definition) => definition.role === "tank")
+    .map((definition) => `${definition.classId}:${definition.displayName}`),
+));

 export function isTankSpecialization(classId: ClassId, specialization: string): boolean {
  return TANK_SPECIALIZATIONS.has(`${classId}:${specialization}`);
 }

-export const HEALER_SPECIALIZATIONS = Object.freeze(new Set([
-  "priest:Holy",
-  "paladin:Holy",
-  "druid:Restoration",
-  "shaman:Restoration",
-]));
+export const HEALER_SPECIALIZATIONS = Object.freeze(new Set(
+  WOW_COMPANION_SPECIALIZATIONS.filter((definition) => definition.role === "healer")
+    .map((definition) => `${definition.classId}:${definition.displayName}`),
+));

 export function isHealerSpecialization(classId: ClassId, specialization: string): boolean {
  return HEALER_SPECIALIZATIONS.has(`${classId}:${specialization}`);
@@ -338,9 +344,10 @@ function createMember(
    specialization: template.specialization,
    specializationId,
    talentTreeId: template.talentTreeId,
+    talentProfileId: template.talentProfileId ?? null,
    talentRanks: configuredTalentRanks ?? (isRomClassId(template.classId)
      ? Object.freeze({})
-      : runtimePartyTalentRanksForLevel(template.classId, template.specialization, level)),
+      : runtimePartyTalentRanksForLevel(template.classId, template.specialization, level, template.talentProfileId ?? undefined)),
    role,
    level: Math.max(1, Math.trunc(level)),
    health: maxHealth,
@@ -380,6 +387,7 @@ export function createConfiguredPartyMember(
    classId: configuration.classId,
    specialization: configuration.specialization,
    talentTreeId: configuration.talentTreeId ?? configuration.specializationId ?? "",
+    talentProfileId: configuration.talentProfileId ?? null,
  }, configuration.role, level, index, seed, configuration.talentRanks);
  return Object.freeze(withMemberAbilityResourcePools({
    ...member,
@@ -399,11 +407,13 @@ export function createDungeonParty(
  playerRole: PartyRole = "healer",
  partySize: PartySize = 5,
  categoryId: ContentCategoryId = "wow",
+  options: CompanionPartyGenerationOptions = {},
 ): readonly PartyMember[] {
  const random = { value: hashSeed(seed || "healer-man") };
-  const tankTemplates = categoryId === "rom" ? ROM_TANK_TEMPLATES : TANK_TEMPLATES;
-  const healerTemplates = categoryId === "rom" ? ROM_HEALER_TEMPLATES : HEALER_TEMPLATES;
-  const damageTemplates = categoryId === "rom" ? ROM_DAMAGE_TEMPLATES : DAMAGE_TEMPLATES;
+  const tankTemplates = categoryId === "rom" ? ROM_TANK_TEMPLATES : wowTemplates("tank", options, 1);
+  const healerTemplates = categoryId === "rom" ? ROM_HEALER_TEMPLATES : wowTemplates("healer", options, 1);
+  const damageSeats = playerRole === "damage" ? 2 : 3;
+  const damageTemplates = categoryId === "rom" ? ROM_DAMAGE_TEMPLATES : wowTemplates("damage", options, damageSeats);
  const tank = tankTemplates[Math.floor(nextRandom(random) * tankTemplates.length)] ?? tankTemplates[0];
  const damagePool = [...damageTemplates];
  for (let index = damagePool.length - 1; index > 0; index -= 1) {
@@ -436,11 +446,12 @@ export function createSpectatorDungeonParty(
  seed: string,
  level: number,
  categoryId: ContentCategoryId = "wow",
+  options: CompanionPartyGenerationOptions = {},
 ): readonly PartyMember[] {
  const random = { value: hashSeed(seed || "healer-man-spectator") };
-  const tankTemplates = categoryId === "rom" ? ROM_TANK_TEMPLATES : TANK_TEMPLATES;
-  const healerTemplates = categoryId === "rom" ? ROM_HEALER_TEMPLATES : HEALER_TEMPLATES;
-  const damagePool = [...(categoryId === "rom" ? ROM_DAMAGE_TEMPLATES : DAMAGE_TEMPLATES)];
+  const tankTemplates = categoryId === "rom" ? ROM_TANK_TEMPLATES : wowTemplates("tank", options, 1);
+  const healerTemplates = categoryId === "rom" ? ROM_HEALER_TEMPLATES : wowTemplates("healer", options, 1);
+  const damagePool = [...(categoryId === "rom" ? ROM_DAMAGE_TEMPLATES : wowTemplates("damage", options, 3))];
  for (let index = damagePool.length - 1; index > 0; index -= 1) {
    const swapIndex = Math.floor(nextRandom(random) * (index + 1));
    [damagePool[index], damagePool[swapIndex]] = [damagePool[swapIndex], damagePool[index]];
@@ -467,6 +478,7 @@ export interface PartyState {
  playerRole: PartyRole;
  partySize: PartySize;
  categoryId: ContentCategoryId;
+  companionOptions: CompanionPartyGenerationOptions;
  members: readonly PartyMember[];
  command: PartyCommand;
  selectedMemberId: string | null;
@@ -483,8 +495,14 @@ export interface PartyState {
    playerRole?: PartyRole,
    partySize?: PartySize,
    categoryId?: ContentCategoryId,
+    companionOptions?: CompanionPartyGenerationOptions,
+  ) => void;
+  initializeSpectatorParty: (
+    seed: string,
+    level: number,
+    categoryId?: ContentCategoryId,
+    companionOptions?: CompanionPartyGenerationOptions,
  ) => void;
-  initializeSpectatorParty: (seed: string, level: number, categoryId?: ContentCategoryId) => void;
  resetCombat: (level: number, playerHealth: number) => void;
  syncLevel: (level: number) => void;
  syncEquipment: (equipment: EquipmentAssignments, inventory: readonly InventoryItem[]) => void;
@@ -532,6 +550,7 @@ export const usePartyStore = create<PartyState>((set, get) => ({
  playerRole: "healer",
  partySize: 5,
  categoryId: "wow",
+  companionOptions: Object.freeze({}),
  members: [],
  command: "defend",
  selectedMemberId: null,
@@ -542,13 +561,14 @@ export const usePartyStore = create<PartyState>((set, get) => ({
  objectiveBossId: null,
  memberTargetIds: {},

-  initializeParty: (seed, level, playerHealth, playerRole = "healer", partySize = 5, categoryId = "wow") => set({
+  initializeParty: (seed, level, playerHealth, playerRole = "healer", partySize = 5, categoryId = "wow", companionOptions = {}) => set({
    seed,
    spectatorParty: false,
    playerRole,
    partySize,
    categoryId,
-    members: createDungeonParty(seed, level, playerRole, partySize, categoryId),
+    companionOptions,
+    members: createDungeonParty(seed, level, playerRole, partySize, categoryId, companionOptions),
    command: "defend",
    selectedMemberId: null,
    selfSelected: false,
@@ -558,13 +578,14 @@ export const usePartyStore = create<PartyState>((set, get) => ({
    memberTargetIds: {},
  }),

-  initializeSpectatorParty: (seed, level, categoryId = "wow") => set({
+  initializeSpectatorParty: (seed, level, categoryId = "wow", companionOptions = {}) => set({
    seed,
    spectatorParty: true,
    playerRole: "healer",
    partySize: 5,
    categoryId,
-    members: createSpectatorDungeonParty(seed, level, categoryId),
+    companionOptions,
+    members: createSpectatorDungeonParty(seed, level, categoryId, companionOptions),
    command: "attack",
    selectedMemberId: null,
    selfSelected: false,
@@ -577,8 +598,8 @@ export const usePartyStore = create<PartyState>((set, get) => ({
  resetCombat: (level, playerHealth) => set((state) => {
    return {
      members: state.spectatorParty
-        ? createSpectatorDungeonParty(state.seed ?? "healer-man-spectator", level, state.categoryId)
-        : createDungeonParty(state.seed ?? "healer-man", level, state.playerRole, state.partySize, state.categoryId),
+        ? createSpectatorDungeonParty(state.seed ?? "healer-man-spectator", level, state.categoryId, state.companionOptions)
+        : createDungeonParty(state.seed ?? "healer-man", level, state.playerRole, state.partySize, state.categoryId, state.companionOptions),
      command: state.spectatorParty ? "attack" : "defend",
      selectedMemberId: null,
      selfSelected: false,
@@ -623,7 +644,7 @@ export const usePartyStore = create<PartyState>((set, get) => ({
          resourcePools: Object.freeze({ ...member.resourcePools, [member.resourceType]: resource }),
          talentRanks: isRomClassId(member.classId)
            ? Object.freeze({})
-            : runtimePartyTalentRanksForLevel(member.classId, member.specialization, safeLevel),
+            : runtimePartyTalentRanksForLevel(member.classId, member.specialization, safeLevel, member.talentProfileId ?? undefined),
        });
      }),
    };
@@ -3,16 +3,55 @@ import {
  PARTY_TALENT_SPECIALIZATIONS,
  partyTalentRanksForLevel,
 } from "./partyTalents";
-import { runtimePartyTalentRanksForLevel } from "./partyTalentRuntime";
+import {
+  runtimePartyTalentProvenanceForLevel,
+  runtimePartyTalentProfiles,
+  runtimePartyTalentRanksForLevel,
+} from "./partyTalentRuntime";

 describe("generated party talent runtime plans", () => {
-  it("match the catalog-validated authoring plans at every player level", () => {
+  it("keeps the prior catalog-validated authoring plans as named profiles", () => {
    for (const { classId, specialization } of PARTY_TALENT_SPECIALIZATIONS) {
+      const executable = runtimePartyTalentProfiles(classId, specialization)
+        .find((profile) => profile.source === "healer-man-generated");
+      expect(executable).toBeDefined();
      for (let level = 1; level <= 80; level += 1) {
-        expect(runtimePartyTalentRanksForLevel(classId, specialization, level)).toEqual(
+        expect(runtimePartyTalentRanksForLevel(classId, specialization, level, executable!.id)).toEqual(
          partyTalentRanksForLevel(classId, specialization, level),
        );
      }
    }
  }, 15_000);
+
+  it("provides a default Playerbots profile and a distinct character for every build", () => {
+    const names = new Set<string>();
+    for (const { classId, specialization } of PARTY_TALENT_SPECIALIZATIONS) {
+      const profiles = runtimePartyTalentProfiles(classId, specialization);
+      expect(profiles).toHaveLength(2);
+      const playerbots = profiles.find((profile) => profile.defaultForSpecialization);
+      expect(playerbots?.source).toBe("azerothcore-playerbots");
+      expect(playerbots?.sourceVersion).toBe("531282e");
+      expect(playerbots?.milestones.length).toBeGreaterThan(0);
+      expect(playerbots?.levelPlans.length).toBe(playerbots?.milestones.length);
+      expect(playerbots?.levelPlans[0]?.minimumLevel).toBe(1);
+      expect(playerbots!.sourcePointsRetained).toBeLessThanOrEqual(playerbots!.sourcePointCount!);
+      expect(playerbots!.sourcePointsRetained! + playerbots!.fallbackPointCount).toBe(71);
+      const level79 = runtimePartyTalentProvenanceForLevel(playerbots!, 79);
+      const level80 = runtimePartyTalentProvenanceForLevel(playerbots!, 80);
+      expect(level79.sourceLevels[0]).toBeLessThanOrEqual(79);
+      expect(level80.sourceLevels).toEqual([80]);
+      expect(level79.sourcePointsRetained! + level79.fallbackPointCount).toBe(70);
+      expect(level80.sourcePointsRetained! + level80.fallbackPointCount).toBe(71);
+      for (const profile of profiles) {
+        expect(names.has(profile.characterName)).toBe(false);
+        names.add(profile.characterName);
+        for (const level of [1, 10, 20, 40, 60, 70, 79, 80]) {
+          const ranks = runtimePartyTalentRanksForLevel(classId, specialization, level, profile.id);
+          expect(Object.values(ranks).reduce((total, rank) => total + rank, 0))
+            .toBe(Math.max(0, level - 9));
+        }
+      }
+    }
+    expect(names.size).toBe(PARTY_TALENT_SPECIALIZATIONS.length * 2);
+  });
 });
@@ -3,12 +3,52 @@ import generated from "./generated/partyTalentRuntimePlans.json";

 type TalentRanks = Readonly<Record<string, number>>;

+export interface PartyTalentRuntimeMilestone {
+  readonly level: number;
+  readonly link: string;
+}
+
+export interface PartyTalentRuntimeLevelPlan {
+  readonly minimumLevel: number;
+  readonly sourceLevels: readonly number[];
+  readonly sourcePointCount: number;
+  readonly sourcePointFlags: readonly boolean[];
+  readonly plan: readonly string[];
+}
+
+export interface PartyTalentRuntimeProfile {
+  readonly id: string;
+  readonly classId: ClassId;
+  readonly specialization: string;
+  readonly name: string;
+  readonly characterName: string;
+  readonly source: "azerothcore-playerbots" | "healer-man-generated";
+  readonly sourceVersion: string;
+  readonly defaultForSpecialization: boolean;
+  readonly playerbotsSpecName: string | null;
+  readonly milestones: readonly PartyTalentRuntimeMilestone[];
+  readonly sourcePointCount: number | null;
+  readonly sourcePointsRetained: number | null;
+  readonly fallbackPointCount: number;
+  readonly plan: readonly string[];
+  readonly levelPlans: readonly PartyTalentRuntimeLevelPlan[];
+}
+
+export interface PartyTalentRuntimeProvenance {
+  readonly sourcePointCount: number | null;
+  readonly sourcePointsRetained: number | null;
+  readonly fallbackPointCount: number;
+  readonly sourceLevels: readonly number[];
+}
+
 interface PartyTalentRuntimeSnapshot {
-  readonly schemaVersion: 1;
-  readonly plans: Readonly<Record<string, readonly string[]>>;
+  readonly schemaVersion: 2;
+  readonly playerbotsCommit: string;
+  readonly profiles: readonly PartyTalentRuntimeProfile[];
 }

 const snapshot = generated as PartyTalentRuntimeSnapshot;
+const profileById = new Map(snapshot.profiles.map((profile) => [profile.id, profile]));

 function planKey(classId: ClassId, specialization: string): string {
  return `${classId}:${specialization}`;
@@ -17,10 +57,73 @@ function planKey(classId: ClassId, specialization: string): string {
 export function runtimePartyTalentPlan(
  classId: ClassId,
  specialization: string,
+  profileId?: string,
 ): readonly string[] {
-  const plan = snapshot.plans[planKey(classId, specialization)];
-  if (!plan) throw new Error(`Unsupported party specialization: ${classId}:${specialization}`);
-  return plan;
+  return runtimePartyTalentProfile(classId, specialization, profileId).plan;
+}
+
+export function runtimePartyTalentProfiles(
+  classId: ClassId,
+  specialization: string,
+): readonly PartyTalentRuntimeProfile[] {
+  const key = planKey(classId, specialization);
+  return snapshot.profiles.filter((profile) => planKey(profile.classId, profile.specialization) === key);
+}
+
+export function runtimePartyTalentProfile(
+  classId: ClassId,
+  specialization: string,
+  profileId?: string,
+): PartyTalentRuntimeProfile {
+  const profiles = runtimePartyTalentProfiles(classId, specialization);
+  const profile = profileId
+    ? profileById.get(profileId)
+    : profiles.find((candidate) => candidate.defaultForSpecialization);
+  if (!profile || profile.classId !== classId || profile.specialization !== specialization) {
+    throw new Error(`Unsupported party talent profile: ${classId}:${specialization}:${profileId ?? "default"}`);
+  }
+  return profile;
+}
+
+export function runtimeDefaultPartyTalentProfile(
+  classId: ClassId,
+  specialization: string,
+): PartyTalentRuntimeProfile {
+  return runtimePartyTalentProfile(classId, specialization);
+}
+
+function levelPlanFor(
+  profile: PartyTalentRuntimeProfile,
+  level: number,
+): PartyTalentRuntimeLevelPlan | null {
+  const safeLevel = Number.isFinite(level) ? Math.max(1, Math.min(80, Math.trunc(level))) : 1;
+  return [...profile.levelPlans]
+    .reverse()
+    .find((candidate) => candidate.minimumLevel <= safeLevel) ?? null;
+}
+
+export function runtimePartyTalentProvenanceForLevel(
+  profile: PartyTalentRuntimeProfile,
+  level: number,
+): PartyTalentRuntimeProvenance {
+  const selected = levelPlanFor(profile, level);
+  if (!selected) {
+    return {
+      sourcePointCount: profile.sourcePointCount,
+      sourcePointsRetained: profile.sourcePointsRetained,
+      fallbackPointCount: profile.fallbackPointCount,
+      sourceLevels: [],
+    };
+  }
+  const safeLevel = Number.isFinite(level) ? Math.max(1, Math.min(80, Math.trunc(level))) : 1;
+  const points = Math.max(0, safeLevel - 9);
+  const sourcePointsRetained = selected.sourcePointFlags.slice(0, points).filter(Boolean).length;
+  return {
+    sourcePointCount: selected.sourcePointCount,
+    sourcePointsRetained,
+    fallbackPointCount: Math.max(0, points - sourcePointsRetained),
+    sourceLevels: selected.sourceLevels,
+  };
 }

 /** Runtime-only projection of the catalog-validated 71-point party plans. */
@@ -28,9 +131,11 @@ export function runtimePartyTalentRanksForLevel(
  classId: ClassId,
  specialization: string,
  level: number,
+  profileId?: string,
 ): TalentRanks {
-  const plan = runtimePartyTalentPlan(classId, specialization);
  const safeLevel = Number.isFinite(level) ? Math.max(1, Math.min(80, Math.trunc(level))) : 1;
+  const profile = runtimePartyTalentProfile(classId, specialization, profileId);
+  const plan = levelPlanFor(profile, safeLevel)?.plan ?? profile.plan;
  const points = Math.max(0, safeLevel - 9);
  const ranks: Record<string, number> = {};
  for (const nodeId of plan.slice(0, points)) ranks[nodeId] = (ranks[nodeId] ?? 0) + 1;
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { partyTalentAllocationPlan } from "./partyTalents";
+import { runtimePartyTalentPlan } from "./partyTalentRuntime";
 import { partyTalentSelections } from "./partyTalentUi";
 import { loadTalentUiCatalog } from "./talentUiCatalog";

@@ -7,17 +7,10 @@ describe("party talent UI projection", () => {
  it("reconstructs the generated runtime plan from one class shard", async () => {
    const catalog = await loadTalentUiCatalog("warrior");
    const projected = partyTalentSelections(catalog, "warrior", "Protection");
-    const source = partyTalentAllocationPlan("warrior", "Protection");
+    const source = runtimePartyTalentPlan("warrior", "Protection");

    expect(projected).toHaveLength(71);
-    expect(projected.map((selection) => ({
-      nodeId: selection.nodeId,
-      rank: selection.rank,
-      description: selection.description,
-    }))).toEqual(source.map((selection) => ({
-      nodeId: selection.nodeId,
-      rank: selection.rank,
-      description: selection.description,
-    })));
+    expect(projected.map((selection) => selection.nodeId)).toEqual(source);
+    expect(projected.every((selection) => selection.rank >= 1 && selection.description.length > 0)).toBe(true);
  });
 });
@@ -0,0 +1,23 @@
+export interface RotationDecisionTelemetryEvent {
+  readonly occurredAt: number;
+  readonly actorId: string;
+  readonly abilityId: string;
+  readonly targetId: string | null;
+  readonly profileId: string;
+  readonly ruleId: string;
+  readonly reason: string;
+}
+
+type RotationDecisionListener = (event: RotationDecisionTelemetryEvent) => void;
+
+const listeners = new Set<RotationDecisionListener>();
+
+export function subscribeRotationDecisions(listener: RotationDecisionListener): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+/** Observational only: listeners cannot alter or delay the selected action. */
+export function emitRotationDecision(event: RotationDecisionTelemetryEvent): void {
+  for (const listener of listeners) listener(event);
+}
@@ -21,6 +21,7 @@ import type {
 } from "./combatAuras";
 import generatedData from "./wow335AbilityData.generated.json";
 import { playerCombatPower } from "./progression";
+import { talentNodeById } from "./talentCatalog";
 import { baseResourcesFor } from "./wotlkStats";

 export const BASE_CLASS_STARTER_SOURCE_LEVEL = 10;
@@ -787,6 +788,7 @@ function classScriptEffects(
    case "hunter:Disengage": return [{ kind: "movement", movement: "leap", toward: "away" }];
    case "hunter:Freezing Arrow": return [{ kind: "status", status: "freeze", durationMs: 10_000 }];
    case "hunter:Feign Death": return [{ kind: "threat", mode: "percent", amount: -100 }];
+    case "hunter:Readiness": return [{ kind: "cooldown-reset", mode: "reset" }];
    case "rogue:Shiv": return [{ kind: "damage", coefficient: 1 }];
    case "rogue:Killing Spree": return [{
      kind: "dot", coefficient: 0.5, ticks: 5, intervalMs: 500, tag: "killing-spree",
@@ -795,15 +797,60 @@ function classScriptEffects(
    // not player-facing SkillLine records. The DBC combo award remains intact.
    case "rogue:Mutilate": return [{ kind: "damage", coefficient: 2 }];
    case "rogue:Garrote": return [{ kind: "status", status: "silence", durationMs: 3_000 }];
-    case "rogue:Cloak of Shadows": return [{
-      kind: "dispel", mode: "cleanse", relationship: "friendly", categories: ["magic"], maxCount: 10,
+    case "rogue:Cold Blood": return [{
+      kind: "apply-aura",
+      aura: {
+        id: `wow335:${rank.spellId}:cold-blood`,
+        name: abilityName,
+        disposition: "buff",
+        durationMs: rank.durationMs > 0 ? rank.durationMs : 20_000,
+        maxStacks: 1,
+        stackBehavior: "refresh",
+        modifiers: [{ kind: "stat", stat: "critical-strike", operation: "flat", value: 1 }],
+      },
+      recipient: "caster",
+      sourceEffectType: 6,
+      sourceAuraType: 4,
+      miscValue: 0,
+      triggerSpellId: 0,
    }];
+    case "rogue:Cloak of Shadows": return [
+      {
+        kind: "dispel", mode: "cleanse", relationship: "friendly", categories: ["magic"], maxCount: 10,
+      },
+      {
+        kind: "apply-aura",
+        aura: {
+          id: `wow335:${rank.spellId}:cloak-of-shadows`,
+          name: abilityName,
+          disposition: "buff",
+          durationMs: rank.durationMs > 0 ? rank.durationMs : 5_000,
+          maxStacks: 1,
+          stackBehavior: "refresh",
+          modifiers: schoolsFromMask(126).map((school) => ({
+            kind: "damage" as const,
+            direction: "taken" as const,
+            school,
+            operation: "percent" as const,
+            value: -0.9,
+          })),
+        },
+        recipient: "caster",
+        sourceEffectType: 6,
+        sourceAuraType: 4,
+        miscValue: 126,
+        triggerSpellId: 0,
+      },
+    ];
    // Both spells place a channel aura whose actual pulses live in non-player
    // trigger spells. Keep the imported cast/cost/rank data and supply only the
    // missing executable payload.
    case "priest:Mind Flay": return [{ kind: "damage", coefficient: 0.9 }];
    case "priest:Penance": return [{ kind: "heal", coefficient: 1.8 }];
-    case "priest:Shadowfiend": return [{ kind: "summon", creatureId: 19668, coefficient: 0.5, durationMs: 15_000 }];
+    case "priest:Shadowfiend": return [
+      { kind: "summon", creatureId: 19668, coefficient: 0.5, durationMs: 15_000 },
+      { kind: "resource", resource: "mana", amount: 30, percentage: true },
+    ];
    case "priest:Prayer of Mending": return [{
      kind: "apply-aura",
      aura: {
@@ -1359,7 +1406,14 @@ function abilityDefinition(classId: BaseClassId, chain: Wow335Chain): AbilityDef
    effects: first.effects,
    passive: chain.passive,
    source: "wow335-progression",
-    talentNodeId: chain.talentNodeId,
+    // Some stock WotLK active talents remain in Spell.dbc after Ascension's
+    // patched Talent.dbc removes their nodes (Devastate, Shadowstep, Lava
+    // Lash). They cannot be allocated by any legal local build, so expose
+    // those retained class actions at their source level instead of making
+    // them permanently unlearnable behind a dangling talent ID.
+    talentNodeId: chain.talentNodeId && talentNodeById(chain.talentNodeId)
+      ? chain.talentNodeId
+      : undefined,
    ranks,
  };
 }
@@ -11,6 +11,8 @@ import "./ui/dungeonReports.css";
 import "./ui/thorUi.css";

 const BottomDisplayApp = lazy(() => import("./platform/BottomDisplayApp").then((module) => ({ default: module.BottomDisplayApp })));
+const BalanceLabScreen = lazy(() => import("./ui/BalanceLabScreen").then((module) => ({ default: module.BalanceLabScreen })));
+const LOCAL_BALANCE_LAB_GUI = import.meta.env.VITE_LOCAL_BALANCE_LAB_GUI === "true";

 const params = new URLSearchParams(window.location.search);
 const displayMode = params.get("display");
@@ -22,15 +24,19 @@ if (Capacitor.isNativePlatform() && (displayMode === "top" || displayMode === "b
 if (Capacitor.isNativePlatform() || nativeLayoutRequested) document.documentElement.classList.add("native-platform");
 if (displayMode === "top" || displayMode === "bottom") document.documentElement.dataset.displaySurface = displayMode;
 document.documentElement.dataset.displayLayout = currentDisplayLayout();
-startControllerInput();
-void initializeContentSystem();
+if (!LOCAL_BALANCE_LAB_GUI) {
+  startControllerInput();
+  void initializeContentSystem();
+}

 // React's development StrictMode replays effect cleanup immediately after the
 // first mount. The installed R3F Canvas cleanup schedules a forced WebGL
 // context loss 500 ms later, even after the live canvas has been reactivated.
 // Keep the game root single-mounted so that teardown cannot blank a live scene.
 createRoot(document.getElementById("root")!).render(
-  displayMode === "bottom"
+  LOCAL_BALANCE_LAB_GUI
+    ? <Suspense fallback={null}><BalanceLabScreen executionTarget="local" onClose={() => window.close()} /></Suspense>
+    : displayMode === "bottom"
    ? <Suspense fallback={null}><BottomDisplayApp /></Suspense>
    : <App />,
 );
@@ -1906,6 +1906,52 @@ html[data-display-layout="thor-preview"], html[data-display-layout="thor-preview
 .front-button--quiet { border-color: transparent; background: rgba(255, 255, 255, 0.025); }
 .front-button--danger { border-color: rgba(209, 103, 90, 0.35); background: rgba(148, 54, 44, 0.18); }
 .front-button:disabled { cursor: not-allowed; filter: saturate(0.2); opacity: 0.45; }
+.companion-readiness { display: grid; grid-template-rows: auto auto auto minmax(0, 1fr) auto; gap: 12px; }
+.companion-readiness__header { display: flex; align-items: center; gap: 14px; padding-bottom: 10px; border-bottom: 1px solid var(--front-line); }
+.companion-readiness__header > div:nth-child(2) { display: flex; min-width: 0; flex: 1; flex-direction: column; }
+.companion-readiness__header span { color: var(--front-dim); font-size: 8px; letter-spacing: .13em; text-transform: uppercase; }
+.companion-readiness__header strong { font: 20px Georgia, serif; }
+.companion-readiness__intro { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 20px; align-items: center; }
+.companion-readiness__intro p:last-child { max-width: 760px; margin: 5px 0 0; color: var(--front-dim); font-size: 10px; line-height: 1.5; }
+.companion-readiness__totals { display: flex; flex-wrap: wrap; justify-content: flex-end; gap: 6px; }
+.readiness-badge { display: inline-flex; align-items: center; gap: 4px; padding: 4px 7px; border: 1px solid var(--front-line); border-radius: 999px; font-size: 8px; font-style: normal; white-space: nowrap; }
+.readiness-badge--ready { border-color: rgba(140,191,120,.5); background: rgba(79,129,65,.22); color: var(--front-green-bright); }
+.readiness-badge--beta { border-color: rgba(216,174,87,.5); background: rgba(152,108,30,.2); color: #f0cb76; }
+.readiness-badge--needs-testing { color: var(--front-dim); }
+.companion-readiness__filters { display: grid; grid-template-columns: minmax(170px, 1fr) 150px 170px auto; gap: 8px; align-items: end; }
+.companion-readiness__filters label { display: grid; gap: 3px; color: var(--front-dim); font-size: 8px; text-transform: uppercase; }
+.companion-readiness__filters input, .companion-readiness__filters select, .companion-readiness__spec select { min-height: 34px; padding: 6px 8px; border: 1px solid var(--front-line); border-radius: 6px; background: #0a1812; color: var(--front-cream); }
+.companion-readiness__filters > small { padding-bottom: 9px; color: var(--front-dim); font-size: 8px; }
+.companion-readiness__catalog { min-height: 0; padding-right: 5px; overflow: auto; scrollbar-gutter: stable; }
+.companion-readiness__class { display: grid; grid-template-columns: 120px minmax(0, 1fr); gap: 10px; padding: 8px 0; border-top: 1px solid rgba(204,224,180,.1); }
+.companion-readiness__class h2 { margin: 7px 0; font: 16px Georgia, serif; }
+.companion-readiness__class > div { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 6px; }
+.companion-readiness__spec { display: flex; min-width: 0; align-items: center; justify-content: space-between; gap: 8px; padding: 8px; border: 1px solid var(--front-line); border-radius: 8px; background: rgba(255,255,255,.025); }
+.companion-readiness__spec > div { min-width: 0; }
+.companion-readiness__spec strong, .companion-readiness__spec small { display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.companion-readiness__spec strong { font-size: 10px; }
+.companion-readiness__spec small { margin-top: 3px; color: var(--front-dim); font-size: 7px; text-transform: capitalize; }
+.companion-readiness__spec select { width: 118px; min-height: 30px; font-size: 8px; }
+.companion-readiness__actions { display: flex; align-items: center; justify-content: flex-end; gap: 8px; padding-top: 9px; border-top: 1px solid var(--front-line); }
+.companion-readiness__actions > span { margin-right: auto; color: var(--front-dim); font-size: 9px; }
+.companion-readiness__actions > strong { color: #e58b7e; font-size: 8px; }
+.companion-pool-controls { display: flex; align-items: center; justify-content: space-between; gap: 10px; padding: 8px 10px; border: 1px solid var(--front-line); border-radius: 8px; background: rgba(255,255,255,.025); }
+.companion-pool-controls label { display: flex; align-items: center; gap: 7px; color: var(--front-cream); cursor: pointer; }
+.companion-pool-controls label:has(input:disabled) { cursor: not-allowed; opacity: .55; }
+.companion-pool-controls input { accent-color: var(--front-green); }
+.companion-pool-controls strong, .companion-pool-controls small { display: block; }
+.companion-pool-controls strong { font-size: 9px; }
+.companion-pool-controls small { margin-top: 2px; color: var(--front-dim); font-size: 7px; }
+.companion-pool-controls--compact { padding: 5px 7px; }
+@media (max-width: 760px) {
+  .companion-readiness__intro { grid-template-columns: 1fr; }
+  .companion-readiness__totals { justify-content: flex-start; }
+  .companion-readiness__filters { grid-template-columns: 1fr 1fr; }
+  .companion-readiness__filters label:first-child { grid-column: 1 / -1; }
+  .companion-readiness__class { grid-template-columns: 1fr; }
+  .companion-readiness__class > div { grid-template-columns: 1fr; }
+  .companion-readiness__actions { flex-wrap: wrap; }
+}
 .text-action { border: 0; background: transparent; color: var(--front-green-bright); cursor: pointer; font-size: 10px; text-decoration: underline; text-underline-offset: 3px; }
 .text-action--danger { color: #cf8176; }
 .front-notice {
@@ -105,21 +105,26 @@ export function BalanceLabResults({ report }: { readonly report: BalanceLabSuite
  const [partySort, setPartySort] = useState<keyof BalanceLabPartyResult>("partyDps");
  const [ascending, setAscending] = useState(false);
  const query = search.trim().toLowerCase();
+  const reportedClasses = report.npcClassSpecs?.length ? report.npcClassSpecs : report.classSpecs;
+  const reportedAbilities = report.npcClassAbilities?.length
+    ? report.npcClassAbilities
+    : report.classAbilities ?? [];
+  const npcOnly = Boolean(report.npcClassSpecs?.length);

  const bosses = useMemo(() => report.bosses.filter((boss) => (
    (bossSource === "all" || boss.category === bossSource)
    && (!query || `${boss.bossName} ${boss.dungeonTitle} ${boss.bossKey} ${boss.pressureFlag}`.toLowerCase().includes(query))
  )), [bossSource, query, report.bosses]);
-  const classes = useMemo(() => report.classSpecs.filter((row) => (
+  const classes = useMemo(() => reportedClasses.filter((row) => (
    (partySource === "all" || row.source === partySource)
    && (role === "all" || row.role === role)
    && (!query || `${row.className} ${row.specialization} ${row.role} ${row.source} ${row.damageFlag}`.toLowerCase().includes(query))
-  )), [partySource, query, report.classSpecs, role]);
+  )), [partySource, query, reportedClasses, role]);
  const parties = useMemo(() => report.partyConfigurations.filter((row) => (
    (partySource === "all" || row.source === partySource)
    && (!query || `${row.partyConfigurationId} ${row.source} ${row.members}`.toLowerCase().includes(query))
  )), [partySource, query, report.partyConfigurations]);
-  const allAbilities = report.classAbilities ?? [];
+  const allAbilities = reportedAbilities;
  const abilityBuildOptions = useMemo(() => {
    const unique = new Map<string, BalanceLabClassAbilityResult>();
    for (const row of allAbilities) unique.set(`${row.source}/${row.buildId}`, row);
@@ -205,7 +210,7 @@ export function BalanceLabResults({ report }: { readonly report: BalanceLabSuite
        <div>
          <p className="front-kicker">Run analysis</p>
          <h2>Level {report.level} balance report</h2>
-          <p>{new Date(report.generatedAt).toLocaleString()} · {report.summary.runs.toLocaleString()} simulations · every filtered row remains available below.</p>
+          <p>{new Date(report.generatedAt).toLocaleString()} · {report.summary.runs.toLocaleString()} simulations · {npcOnly ? "class and ability views use NPC-only observations" : "every filtered row remains available below"}.</p>
        </div>
        <div className="balance-results__filters">
          <label><span>Find anything</span><input type="search" value={search} onChange={(event) => setSearch(event.currentTarget.value)} placeholder="Boss, dungeon, class, spec, party…" /></label>
@@ -9,6 +9,7 @@ import {
  startBalanceLabJob,
  startBalanceLabJobs,
  type BalanceLabBossCategory,
+  type BalanceLabExecutionTarget,
  type BalanceLabJob,
  type BalanceLabPartySource,
  type BalanceLabRuntimeStatus,
@@ -27,6 +28,10 @@ import {
 } from "../game/benchmark/benchmarkBuilds";
 import { BalanceLabResults } from "./BalanceLabResults";
 import { BrandMark, FrontSurface } from "./FrontSurface";
+import { CompanionPoolControls } from "./CompanionPoolControls";
+import { CompanionReadinessScreen } from "./CompanionReadinessScreen";
+import { useCompanionPartyPreferences } from "../game/companionPartyPreferences";
+import { useCompanionSpecReadinessStore } from "../game/companionSpecReadinessStore";

 type BossScope = BalanceLabBossCategory | "specific";
 type LevelCoverage = "single" | "brackets";
@@ -38,6 +43,8 @@ const ARTIFACT_LABELS: Readonly<Record<string, string>> = {
  "party_configurations.csv": "Party configurations CSV",
  "class_specs_across_parties.csv": "Class/spec totals CSV",
  "class_abilities_across_parties.csv": "Class/spec ability breakdown CSV",
+  "npc_class_specs_across_parties.csv": "NPC-only class/spec totals CSV",
+  "npc_class_abilities_across_parties.csv": "NPC-only rotation and ability CSV",
  "class_spec_by_boss.csv": "Class/spec by boss CSV",
  "bosses_across_parties.csv": "Boss totals CSV",
  "boss_by_party.csv": "Boss by party CSV",
@@ -58,9 +65,9 @@ function progressPercent(job: BalanceLabJob): number {
  return Math.max(0, Math.min(99, ((job.progress.partiesCompleted + currentFraction) / job.progress.partiesTotal) * 100));
 }

-function describeJob(job: BalanceLabJob): string {
-  if (job.status === "queued") return "Waiting for an available server worker.";
-  if (job.status === "failed") return job.error ?? "The server job failed.";
+function describeJob(job: BalanceLabJob, local = false): string {
+  if (job.status === "queued") return `Waiting for an available ${local ? "local" : "server"} worker.`;
+  if (job.status === "failed") return job.error ?? `The ${local ? "local" : "server"} job failed.`;
  if (job.status === "complete") return job.summary
    ? `Completed ${job.summary.runs.toLocaleString()} simulations across ${job.summary.bosses.toLocaleString()} bosses and ${job.summary.partyConfigurations.toLocaleString()} party configurations.`
    : `Completed ${job.progress.partiesTotal} party configurations.`;
@@ -83,12 +90,19 @@ function coveragePartyCount(builds: readonly SelectableBenchmarkBuildCatalogEntr
 }

 function buildIdentity(build: SelectableBenchmarkBuildCatalogEntry): string {
-  return `${build.source}:${build.classId}:${build.role}:${build.orientation}`;
+  return `${build.source}:${build.classId}:${build.role}:${build.orientation}:${build.talentBuildId ?? "default"}`;
 }

-export function BalanceLabScreen({ onClose }: { readonly onClose: () => void }) {
+export function BalanceLabScreen({
+  onClose,
+  executionTarget = "server",
+}: {
+  readonly onClose: () => void;
+  readonly executionTarget?: BalanceLabExecutionTarget;
+}) {
  const session = useShellStore((state) => state.session);
-  const token = session?.accessToken ?? "";
+  const local = executionTarget === "local";
+  const token = local ? "" : session?.accessToken ?? "";
  const [source, setSource] = useState<BalanceLabPartySource>("all");
  const [specSelection, setSpecSelection] = useState<BalanceLabSpecSelection>("random");
  const [specSearch, setSpecSearch] = useState("");
@@ -99,6 +113,7 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
  const [partyConfigurations, setPartyConfigurations] = useState(10);
  const [simulationsPerParty, setSimulationsPerParty] = useState(3);
  const [durationSeconds, setDurationSeconds] = useState(60);
+  const [seatSweep, setSeatSweep] = useState(false);
  const [partySeed, setPartySeed] = useState(1);
  const [bossScope, setBossScope] = useState<BossScope>("all");
  const [bossSearch, setBossSearch] = useState("");
@@ -114,6 +129,9 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
  const [loading, setLoading] = useState(true);
  const [submitting, setSubmitting] = useState(false);
  const [error, setError] = useState("");
+  const [readinessOpen, setReadinessOpen] = useState(false);
+  const includeBetaSpecs = useCompanionPartyPreferences((state) => state.includeBetaSpecs);
+  const readinessPolicy = useCompanionSpecReadinessStore((state) => state.config);

  const selectedJob = jobs.find((job) => job.id === selectedJobId) ?? jobs[0] ?? null;
  const selectedReport = selectedJob ? reports[selectedJob.id] ?? null : null;
@@ -137,6 +155,11 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
    || left.role.localeCompare(right.role)
  )), [catalogLevel, source]);
  const selectedBuildSet = useMemo(() => new Set(selectedBuildIds), [selectedBuildIds]);
+  const automaticBuilds = useMemo(() => availableBuilds.filter((build) => {
+    if (build.source !== "wow" || !build.specializationId) return true;
+    const status = readinessPolicy.statuses[build.specializationId] ?? "needs-testing";
+    return status === "ready" || (includeBetaSpecs && status === "beta");
+  }), [availableBuilds, includeBetaSpecs, readinessPolicy]);
  const selectedBuilds = useMemo(() => availableBuilds.filter((build) => selectedBuildSet.has(build.id)), [
    availableBuilds,
    selectedBuildSet,
@@ -154,20 +177,23 @@ 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 coverageBuilds = specSelection === "all" ? availableBuilds : selectedBuilds;
+  const coverageBuilds = specSelection === "all" ? automaticBuilds : selectedBuilds;
  const partyCount = specSelection === "random"
    ? partyConfigurations * (source === "all" ? 3 : 1)
    : coveragePartyCount(coverageBuilds);
-  const coveredSpecCount = specSelection === "all" ? availableBuilds.length : selectedBuilds.length;
-  const estimatedRunsPerLevel = partyCount * bossCount * simulationsPerParty;
+  const coveredSpecCount = specSelection === "all" ? automaticBuilds.length : selectedBuilds.length;
+  const estimatedRunsPerLevel = partyCount * (seatSweep ? 5 : 1) * bossCount * simulationsPerParty;
  const estimatedRuns = estimatedRunsPerLevel * targetLevels.length;
  const hasPendingJobs = jobs.some((job) => job.status === "queued" || job.status === "running");

  useEffect(() => {
-    if (!token) return;
+    if (!local && !token) return;
    let cancelled = false;
    setLoading(true);
-    void Promise.all([listBalanceLabJobs(token), getBalanceLabRuntime(token)]).then(([nextJobs, runtime]) => {
+    void Promise.all([
+      listBalanceLabJobs(token, executionTarget),
+      getBalanceLabRuntime(token, executionTarget),
+    ]).then(([nextJobs, runtime]) => {
      if (cancelled) return;
      setJobs(nextJobs);
      setRuntimeStatus(runtime);
@@ -179,13 +205,16 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
      if (!cancelled) setLoading(false);
    });
    return () => { cancelled = true; };
-  }, [token]);
+  }, [executionTarget, local, token]);

  useEffect(() => {
-    if (!token || !hasPendingJobs) return;
+    if ((!local && !token) || !hasPendingJobs) return;
    let cancelled = false;
    const timer = window.setInterval(() => {
-      void Promise.all([listBalanceLabJobs(token), getBalanceLabRuntime(token)]).then(([nextJobs, runtime]) => {
+      void Promise.all([
+        listBalanceLabJobs(token, executionTarget),
+        getBalanceLabRuntime(token, executionTarget),
+      ]).then(([nextJobs, runtime]) => {
        if (cancelled) return;
        setJobs(nextJobs);
        setRuntimeStatus(runtime);
@@ -194,15 +223,15 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
      });
    }, 1_500);
    return () => { cancelled = true; window.clearInterval(timer); };
-  }, [hasPendingJobs, token]);
+  }, [executionTarget, hasPendingJobs, local, token]);

  useEffect(() => {
-    if (!token || !selectedJob || selectedJob.status !== "complete" || selectedReport
+    if ((!local && !token) || !selectedJob || selectedJob.status !== "complete" || selectedReport
      || !selectedJob.artifacts.includes("suite-report.json")) return;
    let cancelled = false;
    setReportLoadingId(selectedJob.id);
    setReportError("");
-    void getBalanceLabReport(selectedJob.id, token).then((report) => {
+    void getBalanceLabReport(selectedJob.id, token, executionTarget).then((report) => {
      if (!cancelled) setReports((current) => ({ ...current, [selectedJob.id]: report }));
    }).catch((reason) => {
      if (!cancelled) setReportError(errorMessage(reason));
@@ -210,9 +239,9 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
      if (!cancelled) setReportLoadingId((current) => current === selectedJob.id ? null : current);
    });
    return () => { cancelled = true; };
-  }, [selectedJob, selectedReport, token]);
+  }, [executionTarget, local, selectedJob, selectedReport, token]);

-  if (!sessionCanUseGmTools(session)) {
+  if (!local && !sessionCanUseGmTools(session)) {
    return (
      <FrontSurface className="gm-admin-screen" ariaLabel="Balance Lab access denied">
        <section className="gm-admin-denied">
@@ -224,6 +253,7 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
      </FrontSurface>
    );
  }
+  if (readinessOpen) return <CompanionReadinessScreen onClose={() => setReadinessOpen(false)} />;

  const toggleBoss = (key: string) => {
    setSelectedBossKeys((current) => current.includes(key)
@@ -239,7 +269,7 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })

  const run = async () => {
    if (!runtimeStatus?.available) {
-      setError(runtimeStatus?.error ?? "The server Balance Lab runtime is unavailable.");
+      setError(runtimeStatus?.error ?? `The ${local ? "local" : "server"} Balance Lab runtime is unavailable.`);
      return;
    }
    if (bossScope === "specific" && selectedBossKeys.length === 0) {
@@ -274,11 +304,13 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
          partySeed,
          bossCategory: bossScope === "specific" ? "all" as const : bossScope,
          bossKeys: bossScope === "specific" ? selectedBossKeys : [],
+          seatSweep,
+          includeBetaSpecs,
        };
      });
      const submittedJobs = specs.length === 1
-        ? [await startBalanceLabJob(specs[0], token)]
-        : await startBalanceLabJobs(specs, token);
+        ? [await startBalanceLabJob(specs[0], token, executionTarget)]
+        : await startBalanceLabJobs(specs, token, executionTarget);
      const submittedIds = new Set(submittedJobs.map((job) => job.id));
      setJobs((current) => [...submittedJobs, ...current.filter((job) => !submittedIds.has(job.id))]);
      setSelectedJobId(submittedJobs[0]?.id ?? null);
@@ -293,7 +325,7 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
    const preview = name.endsWith(".html") ? window.open("", "_blank") : null;
    setError("");
    try {
-      const blob = await fetchBalanceLabArtifact(job.id, name, token);
+      const blob = await fetchBalanceLabArtifact(job.id, name, token, executionTarget);
      const url = URL.createObjectURL(blob);
      if (preview) preview.location.href = url;
      else {
@@ -310,24 +342,29 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
  };

  return (
-    <FrontSurface className="balance-lab-screen" ariaLabel="GM Balance Lab">
+    <FrontSurface className="balance-lab-screen" ariaLabel={local ? "Local Balance Lab" : "GM Balance Lab"}>
      <header className="gm-admin-header">
        <BrandMark compact />
-        <div><span>Server-authorized GM tool</span><strong>Balance Lab</strong></div>
+        <div><span>{local ? "Local development tool" : "Server-authorized GM tool"}</span><strong>Balance Lab</strong></div>
        <div className="gm-admin-header__actions">
-          <button className="front-button" type="button" onClick={onClose}>Main menu</button>
+          {!local && <button className="front-button" type="button" onClick={onClose}>Main menu</button>}
        </div>
      </header>
      <main className="balance-lab-layout">
        <section className="balance-lab-config">
          <p className="front-kicker">New automatic sweep</p>
          <h2>Simulation setup</h2>
-          <p className="balance-lab-help">This mode runs on the game server. The browser submits the job and may be closed while the server continues.</p>
+          <p className="balance-lab-help">{local
+            ? "This mode runs simulations on this computer. The browser may be closed, but keep the local launcher open while jobs are running."
+            : "This mode runs on the game server. The browser submits the job and may be closed while the server continues."}</p>
+          <CompanionPoolControls onOpenReadiness={() => setReadinessOpen(true)} />
          {runtimeStatus && <div className={`balance-lab-runtime ${runtimeStatus.available ? "is-ready" : "is-unavailable"}`} role={runtimeStatus.available ? undefined : "alert"}>
-            <strong>{runtimeStatus.available ? "Server runtime ready" : "Server runtime unavailable"}</strong>
+            <strong>{runtimeStatus.available ? `${local ? "Local" : "Server"} runtime ready` : `${local ? "Local" : "Server"} runtime unavailable`}</strong>
            <span>{runtimeStatus.available
              ? `${runtimeStatus.version} · ${runtimeStatus.running}/${runtimeStatus.maxConcurrent} workers active · ${runtimeStatus.queued} queued`
-              : `${runtimeStatus.error} Install Python 3 in the server container, set BALANCE_LAB_PYTHON=python3, and restart the app.`}</span>
+              : local
+                ? `${runtimeStatus.error} Install Python 3 or set BALANCE_LAB_PYTHON, then restart the local GUI.`
+                : `${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) => {
@@ -359,6 +396,7 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
            <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>
+            <label className="balance-lab-form-grid__wide"><input type="checkbox" checked={seatSweep} onChange={(event) => setSeatSweep(event.currentTarget.checked)} /><span>NPC seat audit: run each party with every member active once</span></label>
            <label className="balance-lab-form-grid__wide"><span>Bosses</span><select value={bossScope} onChange={(event) => setBossScope(event.currentTarget.value as BossScope)}>
              <option value="all">Every boss</option><option value="wow">Every WoW boss</option><option value="rom">Every RoM boss</option><option value="specific">Pick specific bosses</option>
            </select></label>
@@ -380,7 +418,7 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
              <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>
+                  <span><strong>{classById(build.classId).name} · {build.orientation}</strong><small>{build.source.toUpperCase()} · {build.role}{build.readinessStatus ? ` · ${readinessPolicy.statuses[build.specializationId ?? ""] ?? build.readinessStatus}` : ""}{build.talentBuildName ? ` · ${build.talentBuildName}` : ""}{build.characterName ? ` · ${build.characterName}` : ""}</small></span>
                </label>)}
              </div>
            </section>
@@ -397,17 +435,19 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
            </section>
          )}
          <div className="balance-lab-estimate"><span>Level jobs <b>{targetLevels.length.toLocaleString()}</b></span><span>Parties / level <b>{partyCount.toLocaleString()}</b></span><span>Bosses / level <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 ${targetLevels.length} job${targetLevels.length === 1 ? "" : "s"}…` : runtimeStatus && !runtimeStatus.available ? "Server runtime unavailable" : targetLevels.length === 1 ? "Run on server" : `Queue ${targetLevels.length} level jobs`}</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>
+          <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 ${targetLevels.length} job${targetLevels.length === 1 ? "" : "s"}…` : runtimeStatus && !runtimeStatus.available ? `${local ? "Local" : "Server"} runtime unavailable` : targetLevels.length === 1 ? `Run ${local ? "locally" : "on server"}` : `Queue ${targetLevels.length} ${local ? "local " : ""}level jobs`}</button>
+          <p className="balance-lab-local-note">{local
+            ? "Reports and run history are stored under artifacts/balance-lab-gui-runtime."
+            : <>To open the local GUI instead, run <code>npm run balance:gui</code> or double-click <code>scripts/Launch Balance Lab GUI.cmd</code>.</>}</p>
          {error && <p className="front-notice" role="alert">{error}</p>}
        </section>

        <section className="balance-lab-jobs">
-          <header><div><p className="front-kicker">Saved on server</p><h2>Run history</h2></div><button type="button" disabled={loading} onClick={() => {
+          <header><div><p className="front-kicker">Saved {local ? "on this computer" : "on server"}</p><h2>Run history</h2></div><button type="button" disabled={loading} onClick={() => {
            setLoading(true);
-            void Promise.all([listBalanceLabJobs(token), getBalanceLabRuntime(token)]).then(([nextJobs, runtime]) => { setJobs(nextJobs); setRuntimeStatus(runtime); }).catch((reason) => setError(errorMessage(reason))).finally(() => setLoading(false));
+            void Promise.all([listBalanceLabJobs(token, executionTarget), getBalanceLabRuntime(token, executionTarget)]).then(([nextJobs, runtime]) => { setJobs(nextJobs); setRuntimeStatus(runtime); }).catch((reason) => setError(errorMessage(reason))).finally(() => setLoading(false));
          }}>Refresh</button></header>
-          <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-history-filters"><input type="search" aria-label="Search Balance Lab run history" placeholder={`Find source, level, ${local ? "run" : "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} · {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>
@@ -419,13 +459,13 @@ export function BalanceLabScreen({ onClose }: { readonly onClose: () => void })
        <aside className="balance-lab-detail">
          {selectedJob ? <>
            <p className="front-kicker">Selected job</p><h2>{selectedJob.spec.source.toUpperCase()} level {selectedJob.spec.level}</h2>
-            <p>{describeJob(selectedJob)}</p>
+            <p>{describeJob(selectedJob, local)}</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>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>}
+            {selectedJob.logTail.length > 0 && <details className="balance-lab-log"><summary>{local ? "Local" : "Server"} progress log</summary><pre>{selectedJob.logTail.slice(-20).join("\n")}</pre></details>}
          </> : <p className="balance-lab-empty">Select a job to inspect its progress and reports.</p>}
        </aside>
        {selectedJob?.status === "complete" && <div className="balance-lab-analysis" id="balance-lab-analysis">
@@ -12,6 +12,8 @@ import { FrontSurface, BrandMark, ControllerLegend } from "./FrontSurface";
 import { ControllerButton } from "./ControllerButton";
 import { LazyLocalCompanionPanel } from "./LazyLocalCompanionPanel";
 import "./bossTesting.css";
+import { CompanionPoolControls } from "./CompanionPoolControls";
+import { CompanionReadinessScreen } from "./CompanionReadinessScreen";

 export function BossTestingScreen({ onClose }: { readonly onClose: () => void }) {
  const character = useShellStore(selectedCharacter);
@@ -27,6 +29,7 @@ export function BossTestingScreen({ onClose }: { readonly onClose: () => void })
  const [prepared, setPrepared] = useState(false);
  const [error, setError] = useState("");
  const [role, setRole] = useState<PartyRole>(character ? defaultPartyRoleForClass(character.classId) : "damage");
+  const [readinessOpen, setReadinessOpen] = useState(false);
  const busy = useRef(false);
  const alive = useRef(true);
  const bosses = useMemo(() => BOSS_TESTING_CATALOG.filter((boss) =>
@@ -88,12 +91,14 @@ export function BossTestingScreen({ onClose }: { readonly onClose: () => void })
  const button = (controlId: string, label: string, run: () => void, disabled = false) =>
    <ControllerButton controlId={controlId} selectedId={controller.selectedId} select={controller.select}
      className="front-button" type="button" onClick={run} disabled={disabled}>{label}</ControllerButton>;
+  if (readinessOpen) return <CompanionReadinessScreen onClose={() => setReadinessOpen(false)} />;
  return <DualDisplayFrame contextLabel="Boss Testing" top={
    <FrontSurface className="boss-testing-screen" ariaLabel="Boss Testing selection">
      <header className="boss-testing-header"><BrandMark compact /><div><span>Main menu / Mechanics laboratory</span><h1>Boss Testing</h1></div>
        {button("boss-testing-back", "Back to main menu", onClose)}</header>
      <main className="boss-testing-main">
        <p>Choose a boss to test with your party in an empty room. Missing content downloads automatically when you select a boss.</p>
+        <CompanionPoolControls onOpenReadiness={() => setReadinessOpen(true)} compact />
        <div className="boss-testing-filters">
          <label>Search bosses<input type="search" value={query} onChange={(event) => setQuery(event.target.value)} placeholder="Boss or dungeon name" disabled={preparing} /></label>
          <label>Game<select {...selectProps("boss-testing-category")} value={category} onChange={(event) => setCategory(event.target.value)}>
@@ -0,0 +1,19 @@
+import { useCompanionPartyPreferences } from "../game/companionPartyPreferences";
+import { useCompanionSpecReadinessStore } from "../game/companionSpecReadinessStore";
+
+export function CompanionPoolControls({ onOpenReadiness, compact = false }: {
+  readonly onOpenReadiness: () => void;
+  readonly compact?: boolean;
+}) {
+  const policy = useCompanionSpecReadinessStore((state) => state.config);
+  const includeBetaSpecs = useCompanionPartyPreferences((state) => state.includeBetaSpecs);
+  const setIncludeBetaSpecs = useCompanionPartyPreferences((state) => state.setIncludeBetaSpecs);
+  const betaCount = Object.values(policy.statuses).filter((status) => status === "beta").length;
+  return <div className={`companion-pool-controls ${compact ? "companion-pool-controls--compact" : ""}`}>
+    <label title={betaCount ? "Allow certified beta specializations in random NPC seats." : "No beta specs available"}>
+      <input type="checkbox" checked={includeBetaSpecs && betaCount > 0} disabled={betaCount === 0} onChange={(event) => setIncludeBetaSpecs(event.target.checked)} />
+      <span><strong>Include Beta Specs</strong><small>{betaCount ? `${betaCount} beta ${betaCount === 1 ? "spec" : "specs"} available` : "No beta specs available"}</small></span>
+    </label>
+    <button className="text-action" type="button" onClick={onOpenReadiness}>View companion readiness</button>
+  </div>;
+}
@@ -0,0 +1,106 @@
+import { useMemo, useState } from "react";
+import { classById } from "../app/characterCatalog";
+import { sessionCanUseGmTools } from "../app/releaseFeatures";
+import { useShellStore } from "../app/shellStore";
+import {
+  WOW_COMPANION_SPECIALIZATIONS,
+  type CompanionSpecReadinessStatus,
+} from "../game/companionSpecReadiness";
+import { useCompanionSpecReadinessStore } from "../game/companionSpecReadinessStore";
+import { runtimeDefaultPartyTalentProfile } from "../game/partyTalentRuntime";
+import { BrandMark, FrontSurface } from "./FrontSurface";
+
+const STATUS_LABELS: Readonly<Record<CompanionSpecReadinessStatus, string>> = {
+  ready: "Ready",
+  beta: "Beta",
+  "needs-testing": "Needs Testing",
+};
+
+export function CompanionReadinessScreen({ onClose }: { readonly onClose: () => void }) {
+  const session = useShellStore((state) => state.session);
+  const localEditor = import.meta.env.VITE_LOCAL_BALANCE_LAB_GUI === "true";
+  const editable = localEditor || sessionCanUseGmTools(session);
+  const policy = useCompanionSpecReadinessStore((state) => state.config);
+  const draft = useCompanionSpecReadinessStore((state) => state.draft);
+  const revision = useCompanionSpecReadinessStore((state) => state.revision);
+  const updatedBy = useCompanionSpecReadinessStore((state) => state.updatedBy);
+  const dirty = useCompanionSpecReadinessStore((state) => state.dirty);
+  const saving = useCompanionSpecReadinessStore((state) => state.saving);
+  const error = useCompanionSpecReadinessStore((state) => state.error);
+  const setStatus = useCompanionSpecReadinessStore((state) => state.setStatus);
+  const resetDraft = useCompanionSpecReadinessStore((state) => state.resetDraft);
+  const publish = useCompanionSpecReadinessStore((state) => state.publish);
+  const [query, setQuery] = useState("");
+  const [role, setRole] = useState("all");
+  const [status, setStatusFilter] = useState("all");
+  const active = editable ? draft : policy;
+
+  const rows = useMemo(() => WOW_COMPANION_SPECIALIZATIONS.filter((definition) => {
+    const className = classById(definition.classId).name;
+    const search = `${className} ${definition.displayName}`.toLowerCase();
+    return (!query.trim() || search.includes(query.trim().toLowerCase()))
+      && (role === "all" || definition.role === role)
+      && (status === "all" || active.statuses[definition.id] === status);
+  }), [active, query, role, status]);
+  const groups = useMemo(() => [...new Set(rows.map((definition) => definition.classId))].map((classId) => ({
+    classId,
+    definitions: rows.filter((definition) => definition.classId === classId),
+  })), [rows]);
+  const totals = Object.values(active.statuses).reduce<Record<CompanionSpecReadinessStatus, number>>((result, value) => {
+    result[value] += 1;
+    return result;
+  }, { ready: 0, beta: 0, "needs-testing": 0 });
+
+  return (
+    <FrontSurface className="companion-readiness" ariaLabel="Companion readiness">
+      <header className="companion-readiness__header">
+        <BrandMark compact />
+        <div><span>NPC certification</span><strong>Companion Readiness</strong></div>
+        <button className="front-button front-button--quiet" type="button" onClick={onClose}>Back</button>
+      </header>
+      <section className="companion-readiness__intro">
+        <div>
+          <p className="front-kicker">Certification standard</p>
+          <p>Ready companions have a legal Playerbots talent build at every bracket, verified gear and resources, a complete priority rotation, role reactions, and proven offensive and defensive cooldown use without unexplained idle windows.</p>
+        </div>
+        <div className="companion-readiness__totals" aria-label="Readiness totals">
+          {(["ready", "beta", "needs-testing"] as const).map((value) => (
+            <span key={value} className={`readiness-badge readiness-badge--${value}`}><b>{totals[value]}</b> {STATUS_LABELS[value]}</span>
+          ))}
+        </div>
+      </section>
+      <section className="companion-readiness__filters" aria-label="Readiness filters">
+        <label>Search<input type="search" value={query} onChange={(event) => setQuery(event.target.value)} placeholder="Class or specialization" /></label>
+        <label>Role<select value={role} onChange={(event) => setRole(event.target.value)}><option value="all">All roles</option><option value="tank">Tank</option><option value="healer">Healer</option><option value="damage">Damage</option></select></label>
+        <label>Status<select value={status} onChange={(event) => setStatusFilter(event.target.value)}><option value="all">All statuses</option><option value="ready">Ready</option><option value="beta">Beta</option><option value="needs-testing">Needs Testing</option></select></label>
+        <small>Published revision {revision}{updatedBy ? ` · ${updatedBy}` : ""}</small>
+      </section>
+      <main className="companion-readiness__catalog">
+        {groups.map(({ classId, definitions }) => (
+          <section key={classId} className="companion-readiness__class">
+            <h2 style={{ color: classById(classId).color }}>{classById(classId).name}</h2>
+            <div>
+              {definitions.map((definition) => {
+                const profile = runtimeDefaultPartyTalentProfile(definition.classId, definition.displayName);
+                const value = active.statuses[definition.id] ?? "needs-testing";
+                return <article key={definition.id} className="companion-readiness__spec">
+                  <div><strong>{definition.displayName}</strong><small>{definition.role} · {profile.characterName} · {profile.playerbotsSpecName ?? profile.id}</small></div>
+                  {editable ? <select aria-label={`${definition.displayName} readiness`} value={value} onChange={(event) => setStatus(definition.id, event.target.value as CompanionSpecReadinessStatus)}>
+                    <option value="ready">Ready</option><option value="beta">Beta</option><option value="needs-testing">Needs Testing</option>
+                  </select> : <span className={`readiness-badge readiness-badge--${value}`}>{STATUS_LABELS[value]}</span>}
+                </article>;
+              })}
+            </div>
+          </section>
+        ))}
+        {!rows.length && <p className="front-notice">No specializations match those filters.</p>}
+      </main>
+      {editable && <footer className="companion-readiness__actions">
+        <span>{dirty ? "Unpublished changes" : "Published policy is active"}</span>
+        {error && <strong role="alert">{error}</strong>}
+        <button className="front-button front-button--quiet" type="button" disabled={!dirty || saving} onClick={resetDraft}>Discard</button>
+        <button className="front-button front-button--primary" type="button" disabled={!dirty || saving} onClick={() => void publish(session)}>{saving ? "Publishing…" : "Publish policy"}</button>
+      </footer>}
+    </FrontSurface>
+  );
+}
@@ -33,6 +33,9 @@ import { DUNGEON_RELEASE_STAGE_LABELS } from "../game/dungeonReleaseStage";
 import { useDungeonReports } from "./useDungeonReports";
 import { DungeonDifficultySlider } from "./DungeonDifficultySlider";
 import { bossDifficultyLabel } from "../game/dungeonDifficulty";
+import { useCompanionPartyPreferences } from "../game/companionPartyPreferences";
+import { CompanionPoolControls } from "./CompanionPoolControls";
+import { CompanionReadinessScreen } from "./CompanionReadinessScreen";

 installDungeonShellRuntime();

@@ -85,7 +88,9 @@ export function DungeonSelectScreen() {
  const [clearFilter, setClearFilter] = useState<DungeonClearFilter>("final");
  const [difficultyId, setDifficultyId] = useState("");
  const [bossDifficulty, setBossDifficulty] = useState(1);
+  const includeBetaSpecs = useCompanionPartyPreferences((state) => state.includeBetaSpecs);
  const [expandedRuns, setExpandedRuns] = useState<ReadonlySet<string>>(new Set());
+  const [readinessOpen, setReadinessOpen] = useState(false);
  const leaderboardDifficulty = selectedDefinition?.difficultyVariants.find((variant) => variant.id === difficultyId)
    ?? selectedDefinition?.difficultyVariants.find((variant) => variant.id === selectedDefinition.defaultDifficultyId);
  const leaderboard = useDungeonLeaderboard(selectedDungeon?.id ?? "", leaderboardDifficulty?.id ?? "normal", clearFilter, bossDifficulty);
@@ -138,6 +143,7 @@ export function DungeonSelectScreen() {
      difficultyId: leaderboardDifficulty?.id,
      bossDifficulty,
      partySize: 5,
+      includeBetaSpecs,
    });
  };

@@ -236,6 +242,7 @@ export function DungeonSelectScreen() {

  const race = character ? raceById(character.raceId) : null;
  const characterClass = character ? classById(character.classId) : null;
+  if (readinessOpen) return <CompanionReadinessScreen onClose={() => setReadinessOpen(false)} />;
  return (
    <DualDisplayFrame
      contextLabel="Dungeon details"
@@ -342,6 +349,7 @@ export function DungeonSelectScreen() {
                    <p className="front-notice" role="status">Select this expedition to download its required files.</p>
                  )}
                  <OnlineGroupPanel />
+                  <CompanionPoolControls onOpenReadiness={() => setReadinessOpen(true)} compact />
                  {rolePickerOpen && characterClass ? (
                    <section className="dungeon-role-picker" aria-labelledby="dungeon-role-title">
                      <header>
@@ -12,6 +12,9 @@ import { sessionCanUseGmTools } from "../app/releaseFeatures";
 import { useShellStore } from "../app/shellStore";
 import { DUNGEON_CATALOG } from "../game/dungeonCatalog";
 import { DUNGEON_ROUTE_CATALOG } from "../game/dungeonRoutes";
+import { BOSS_TESTING_CATALOG } from "../game/bossTesting";
+import { requireDungeonDefinition } from "../game/dungeonRegistry";
+import { useCompanionCooldownPolicyStore } from "../game/companionCooldownPolicyStore";
 import type {
  DungeonReplaySummary,
  DungeonRouteReview,
@@ -20,6 +23,21 @@ import type {
  DungeonSimulationReportV1,
 } from "../game/dungeonSimulationTypes";
 import { BrandMark, FrontSurface } from "./FrontSurface";
+import { CompanionPoolControls } from "./CompanionPoolControls";
+import { CompanionReadinessScreen } from "./CompanionReadinessScreen";
+
+const COOLDOWN_MECHANICS = BOSS_TESTING_CATALOG.flatMap((boss) => {
+  const entity = requireDungeonDefinition(boss.dungeonId).entities[boss.entityId];
+  return (entity?.combat?.attacks ?? []).map((attack) => ({
+    key: `${boss.key}\u0000${attack.id}`,
+    bossKey: boss.key,
+    bossName: boss.name,
+    bossServerEntry: entity.combat?.serverEntry ?? null,
+    attackId: attack.id,
+    attackName: attack.name,
+    label: `${boss.dungeonTitle} — ${boss.name}: ${attack.name}`,
+  }));
+});

 function saveReport(report: DungeonSimulationReportV1): void {
  const url = URL.createObjectURL(new Blob([JSON.stringify(report, null, 2)], { type: "application/json" }));
@@ -43,6 +61,16 @@ export function DungeonSimulationAdminScreen() {
  const [overrideNote, setOverrideNote] = useState("");
  const [busy, setBusy] = useState(false);
  const [message, setMessage] = useState("");
+  const [readinessOpen, setReadinessOpen] = useState(false);
+  const [selectedCooldownMechanic, setSelectedCooldownMechanic] = useState(COOLDOWN_MECHANICS[0]?.key ?? "");
+  const cooldownDraft = useCompanionCooldownPolicyStore((state) => state.draft);
+  const cooldownRevision = useCompanionCooldownPolicyStore((state) => state.revision);
+  const cooldownDirty = useCompanionCooldownPolicyStore((state) => state.dirty);
+  const cooldownSaving = useCompanionCooldownPolicyStore((state) => state.saving);
+  const cooldownError = useCompanionCooldownPolicyStore((state) => state.error);
+  const replaceCooldownDraft = useCompanionCooldownPolicyStore((state) => state.replaceDraft);
+  const resetCooldownDraft = useCompanionCooldownPolicyStore((state) => state.resetDraft);
+  const publishCooldownPolicy = useCompanionCooldownPolicyStore((state) => state.publish);
  const route = DUNGEON_ROUTE_CATALOG.routes.find((candidate) => candidate.dungeonId === selectedDungeonId)
    ?? DUNGEON_ROUTE_CATALOG.routes[0];
  const dungeon = DUNGEON_CATALOG.find((candidate) => candidate.id === route?.dungeonId);
@@ -152,6 +180,39 @@ export function DungeonSimulationAdminScreen() {
    }
  };

+  const updateGenericCooldown = (key: keyof typeof cooldownDraft.generic, value: number | boolean) => {
+    replaceCooldownDraft({
+      ...cooldownDraft,
+      generic: { ...cooldownDraft.generic, [key]: value },
+    });
+  };
+
+  const addCooldownMechanic = () => {
+    const mechanic = COOLDOWN_MECHANICS.find((candidate) => candidate.key === selectedCooldownMechanic);
+    if (!mechanic) return;
+    const idBase = `${mechanic.bossKey}-${mechanic.attackId}`.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    const existingIds = new Set(cooldownDraft.mechanics.map((rule) => rule.id));
+    let id = idBase;
+    for (let suffix = 2; existingIds.has(id); suffix += 1) id = `${idBase}-${suffix}`;
+    replaceCooldownDraft({
+      ...cooldownDraft,
+      mechanics: [...cooldownDraft.mechanics, {
+        id,
+        enabled: true,
+        bossKey: mechanic.bossKey,
+        bossName: mechanic.bossName,
+        bossServerEntry: mechanic.bossServerEntry,
+        attackId: mechanic.attackId,
+        attackName: mechanic.attackName,
+        scope: "tank",
+        leadTimeMs: 2_500,
+        minimumCooldownSeconds: 20,
+      }],
+    });
+  };
+
+  if (readinessOpen) return <CompanionReadinessScreen onClose={() => setReadinessOpen(false)} />;
+
  return (
    <FrontSurface className="dungeon-sim-admin" ariaLabel="Dungeon simulation route review">
      <header className="dungeon-sim-admin__header">
@@ -188,6 +249,7 @@ export function DungeonSimulationAdminScreen() {

          <fieldset>
            <legend>Launch live simulation</legend>
+            <CompanionPoolControls onOpenReadiness={() => setReadinessOpen(true)} compact />
            <label><span>Mode</span><select value={mode} onChange={(event) => setMode(event.target.value as DungeonSimulationMode)}>
              <option value="navigation-only">Navigation only</option>
              <option value="full-combat">Full combat</option>
@@ -200,6 +262,32 @@ export function DungeonSimulationAdminScreen() {
              onClick={() => route && enterDungeonSimulation(route.dungeonId, mode, seed)}
            >Launch spectate mode</button>
          </fieldset>
+          <fieldset>
+            <legend>Companion cooldown policy · revision {cooldownRevision}</legend>
+            <label><span>Use defensive below health %</span><input type="number" min="1" max="100" value={cooldownDraft.generic.defensiveHealthPercent} onChange={(event) => updateGenericCooldown("defensiveHealthPercent", Number(event.target.value))} /></label>
+            <label><span>Emergency defensive below health %</span><input type="number" min="1" max="100" value={cooldownDraft.generic.emergencyHealthPercent} onChange={(event) => updateGenericCooldown("emergencyHealthPercent", Number(event.target.value))} /></label>
+            <label><span>Healer mitigation below health %</span><input type="number" min="1" max="100" value={cooldownDraft.generic.healerMitigationHealthPercent} onChange={(event) => updateGenericCooldown("healerMitigationHealthPercent", Number(event.target.value))} /></label>
+            <label><span>Major offensive cooldown seconds</span><input type="number" min="0" max="600" value={cooldownDraft.generic.offensiveMajorCooldownSeconds} onChange={(event) => updateGenericCooldown("offensiveMajorCooldownSeconds", Number(event.target.value))} /></label>
+            <label><input type="checkbox" checked={cooldownDraft.generic.conserveOffensiveCooldownsForDurableTargets} onChange={(event) => updateGenericCooldown("conserveOffensiveCooldownsForDurableTargets", event.target.checked)} /><span>Save major offensive cooldowns for durable targets</span></label>
+            <label><span>Pre-empt boss mechanic</span><select value={selectedCooldownMechanic} onChange={(event) => setSelectedCooldownMechanic(event.target.value)}>
+              {COOLDOWN_MECHANICS.map((mechanic) => <option key={mechanic.key} value={mechanic.key}>{mechanic.label}</option>)}
+            </select></label>
+            <button className="front-button" type="button" disabled={!selectedCooldownMechanic} onClick={addCooldownMechanic}>Add mechanic rule</button>
+            {cooldownDraft.mechanics.map((rule, index) => (
+              <article key={rule.id} className="dungeon-sim-admin__route-meta">
+                <strong>{rule.bossName}: {rule.attackName}</strong>
+                <label><span>Scope</span><select value={rule.scope} onChange={(event) => replaceCooldownDraft({ ...cooldownDraft, mechanics: cooldownDraft.mechanics.map((candidate, candidateIndex) => candidateIndex === index ? { ...candidate, scope: event.target.value === "party" ? "party" : "tank" } : candidate) })}><option value="tank">Tank</option><option value="party">Party</option></select></label>
+                <label><span>Lead time ms</span><input type="number" min="0" max="15000" step="100" value={rule.leadTimeMs} onChange={(event) => replaceCooldownDraft({ ...cooldownDraft, mechanics: cooldownDraft.mechanics.map((candidate, candidateIndex) => candidateIndex === index ? { ...candidate, leadTimeMs: Number(event.target.value) } : candidate) })} /></label>
+                <label><span>Minimum defensive cooldown seconds</span><input type="number" min="0" max="600" value={rule.minimumCooldownSeconds} onChange={(event) => replaceCooldownDraft({ ...cooldownDraft, mechanics: cooldownDraft.mechanics.map((candidate, candidateIndex) => candidateIndex === index ? { ...candidate, minimumCooldownSeconds: Number(event.target.value) } : candidate) })} /></label>
+                <button className="front-button" type="button" onClick={() => replaceCooldownDraft({ ...cooldownDraft, mechanics: cooldownDraft.mechanics.filter((_, candidateIndex) => candidateIndex !== index) })}>Remove</button>
+              </article>
+            ))}
+            <div className="dungeon-sim-admin__header-actions">
+              <button className="front-button front-button--primary" type="button" disabled={!cooldownDirty || cooldownSaving} onClick={() => void publishCooldownPolicy(session)}>Publish cooldown rules</button>
+              <button className="front-button" type="button" disabled={!cooldownDirty || cooldownSaving} onClick={resetCooldownDraft}>Discard</button>
+            </div>
+            {cooldownError && <p className="front-notice" role="alert">{cooldownError}</p>}
+          </fieldset>

          <fieldset>
            <legend>Exact-hash review</legend>
@@ -15,6 +15,7 @@ import { MainMenuCharacterEditor, type MainMenuEditor } from "./MainMenuCharacte
 const BossCardCollectionScreen = lazy(() => import("./BossCardCollection"));
 const BossTestingScreen = lazy(() => import("./BossTestingScreen").then((module) => ({ default: module.BossTestingScreen })));
 const BalanceLabScreen = lazy(() => import("./BalanceLabScreen").then((module) => ({ default: module.BalanceLabScreen })));
+const CompanionReadinessScreen = lazy(() => import("./CompanionReadinessScreen").then((module) => ({ default: module.CompanionReadinessScreen })));

 const GAME_MODES = [
  {
@@ -73,22 +74,25 @@ export function MainMenuScreen() {
  const [cardsOpen, setCardsOpen] = useState(false);
  const [bossTestingOpen, setBossTestingOpen] = useState(false);
  const [balanceLabOpen, setBalanceLabOpen] = useState(false);
+  const [readinessOpen, setReadinessOpen] = useState(false);
  const [editor, setEditor] = useState<MainMenuEditor | null>(null);
  if (editor) return <MainMenuCharacterEditor editor={editor} onClose={() => setEditor(null)} />;
  if (bossTestingOpen) return <Suspense fallback={<p role="status">Opening Boss Testing…</p>}><BossTestingScreen onClose={() => setBossTestingOpen(false)} /></Suspense>;
  if (balanceLabOpen) return <Suspense fallback={<p role="status">Opening Balance Lab…</p>}><BalanceLabScreen onClose={() => setBalanceLabOpen(false)} /></Suspense>;
+  if (readinessOpen) return <Suspense fallback={<p role="status">Opening Companion Readiness…</p>}><CompanionReadinessScreen onClose={() => setReadinessOpen(false)} /></Suspense>;
  if (cardsOpen) return <Suspense fallback={<p role="status">Opening collection log…</p>}><BossCardCollectionScreen onClose={() => setCardsOpen(false)} /></Suspense>;
  if (contentManagerOpen) return <ContentManagerScreen onClose={() => setContentManagerOpen(false)} />;
  if (reportsOpen) return <DungeonReportsScreen onClose={() => setReportsOpen(false)} />;
-  return <MainMenuDestinations onOpenDownloads={() => setContentManagerOpen(true)} onOpenReports={() => setReportsOpen(true)} onOpenCards={() => setCardsOpen(true)} onOpenBossTesting={() => setBossTestingOpen(true)} onOpenBalanceLab={() => setBalanceLabOpen(true)} onOpenEditor={setEditor} />;
+  return <MainMenuDestinations onOpenDownloads={() => setContentManagerOpen(true)} onOpenReports={() => setReportsOpen(true)} onOpenCards={() => setCardsOpen(true)} onOpenBossTesting={() => setBossTestingOpen(true)} onOpenBalanceLab={() => setBalanceLabOpen(true)} onOpenReadiness={() => setReadinessOpen(true)} onOpenEditor={setEditor} />;
 }

-function MainMenuDestinations({ onOpenDownloads, onOpenReports, onOpenCards, onOpenBossTesting, onOpenBalanceLab, onOpenEditor }: {
+function MainMenuDestinations({ onOpenDownloads, onOpenReports, onOpenCards, onOpenBossTesting, onOpenBalanceLab, onOpenReadiness, onOpenEditor }: {
  readonly onOpenDownloads: () => void;
  readonly onOpenReports: () => void;
  readonly onOpenCards: () => void;
  readonly onOpenBossTesting: () => void;
  readonly onOpenBalanceLab: () => void;
+  readonly onOpenReadiness: () => void;
  readonly onOpenEditor: (editor: MainMenuEditor) => void;
 }) {
  const activeCharacter = useShellStore((state) => state.activeCharacter);
@@ -143,7 +147,8 @@ function MainMenuDestinations({ onOpenDownloads, onOpenReports, onOpenCards, onO
    { id: "mode-reports", run: onOpenReports },
    { id: "mode-cards", run: onOpenCards },
    { id: "mode-boss-testing", run: onOpenBossTesting },
-  ], [character, isGm, onOpenBalanceLab, onOpenBossTesting, onOpenCards, onOpenDownloads, onOpenEditor, onOpenReports, openArenas, openClassHall, openDungeons, openGmAdmin, openManastorms, returnToCharacters]);
+    { id: "mode-companion-readiness", run: onOpenReadiness },
+  ], [character, isGm, onOpenBalanceLab, onOpenBossTesting, onOpenCards, onOpenDownloads, onOpenEditor, onOpenReadiness, onOpenReports, openArenas, openClassHall, openDungeons, openGmAdmin, openManastorms, returnToCharacters]);
  const controller = useMenuController(actions, {
    initialId: "mode-dungeons",
    onBack: returnToCharacters,
@@ -199,6 +204,10 @@ function MainMenuDestinations({ onOpenDownloads, onOpenReports, onOpenCards, onO
            </header>
            <OnlineGroupPanel />
            <nav className="main-menu-mode-grid" aria-label="Main menu destinations">
+              <ControllerButton controlId="mode-companion-readiness" selectedId={controller.selectedId} select={controller.select}
+                className="front-button main-menu-mode main-menu-mode--available" type="button" onClick={onOpenReadiness}>
+                <b aria-hidden="true">CR</b><span><strong>Companion Readiness</strong><small>Review the certified NPC specialization pool and Playerbots identities.</small></span><em>Open</em>
+              </ControllerButton>
              <ControllerButton controlId="mode-boss-testing" selectedId={controller.selectedId} select={controller.select}
                className="front-button main-menu-mode main-menu-mode--available" type="button" onClick={onOpenBossTesting}>
                <b aria-hidden="true">BT</b><span><strong>Boss Testing</strong><small>Choose a boss or fight a random encounter in an empty testing room.</small></span><em>Open</em>
@@ -42,6 +42,10 @@ import { BrandMark, ControllerLegend, FrontSurface } from "./FrontSurface";
 import { OnlineGroupPanel } from "./OnlineGroupPanel";
 import { useOnlineGroupStore } from "../app/onlineGroupStore";
 import { specializationById } from "../game/specializationCatalog";
+import { useCompanionPartyPreferences } from "../game/companionPartyPreferences";
+import { useCompanionSpecReadinessStore } from "../game/companionSpecReadinessStore";
+import { CompanionPoolControls } from "./CompanionPoolControls";
+import { CompanionReadinessScreen } from "./CompanionReadinessScreen";

 installManastormShellRuntime();

@@ -71,6 +75,9 @@ export function ManastormSelectScreen() {
    ? character.categoryId === "rom" ? partyRolesForClass(character.classId) : savedSpecialization ? [savedSpecialization.role] : []
    : [];
  const [partySize, setPartySize] = useState<ManastormPartySize>(5);
+  const includeBetaSpecs = useCompanionPartyPreferences((state) => state.includeBetaSpecs);
+  const readinessPolicy = useCompanionSpecReadinessStore((state) => state.config);
+  const readinessPolicyRevision = useCompanionSpecReadinessStore((state) => state.revision);
  const groupHumanCount = onlineGroup?.members.length ?? 1;
  const effectivePartySize = onlineGroup
    ? (fillWithAi ? Math.max(partySize, groupHumanCount) : groupHumanCount) as ManastormPartySize
@@ -145,6 +152,7 @@ export function ManastormSelectScreen() {
  const [pendingDownloadRole, setPendingDownloadRole] = useState<PartyRole | null>(null);
  const [downloading, setDownloading] = useState(false);
  const [downloadError, setDownloadError] = useState("");
+  const [readinessOpen, setReadinessOpen] = useState(false);

  useEffect(() => {
    setSelectedSpellIds(persistedSpellIds);
@@ -170,6 +178,12 @@ export function ManastormSelectScreen() {
      role,
      effectivePartySize,
      character.categoryId ?? "wow",
+      {
+        readinessPolicy,
+        readinessPolicyRevision,
+        includeBetaSpecs,
+        excludedPlayerSpecializationId: character.specializationId,
+      },
    );
    void preloadAvatarModels([character, ...party]).catch((error) => {
      console.warn("Selected party avatar preloading could not be completed", error);
@@ -192,6 +206,7 @@ export function ManastormSelectScreen() {
      contentId: "manastorm",
      partySize: effectivePartySize,
      startingLevel,
+      includeBetaSpecs,
    });
  };

@@ -273,6 +288,7 @@ export function ManastormSelectScreen() {

  const race = character ? raceById(character.raceId) : null;
  const characterClass = character ? classById(character.classId) : null;
+  if (readinessOpen) return <CompanionReadinessScreen onClose={() => setReadinessOpen(false)} />;

  return (
    <DualDisplayFrame
@@ -339,6 +355,7 @@ export function ManastormSelectScreen() {
                <small>Progress and first clears are tracked separately for every party size.</small>
              </header>
              <OnlineGroupPanel />
+              <CompanionPoolControls onOpenReadiness={() => setReadinessOpen(true)} compact />

              <div className="manastorm-setup-block">
                <strong>Party size</strong>
@@ -6,6 +6,7 @@ interface ImportMetaEnv {
  readonly VITE_CONTENT_MODE: "bundled" | "downloadable";
  readonly VITE_APP_VERSION: string;
  readonly VITE_SHELVED_MODES_ENABLED: "true" | "false";
+  readonly VITE_LOCAL_BALANCE_LAB_GUI: "true" | "false";
 }

 interface ImportMeta {