Upgrade Knip back to 6, with raw transfer disabled

Knip 5 is effectively frozen: 5.88.1 (2026-03-19) was its last release,
with only three patches after 6.0.0 shipped and none since.

The reason for the earlier downgrade (968cc72) was misdiagnosed. The 6 GiB
allocation is not the Rust-side arena tracked in oxc-project/oxc#20513, but
a JS-side `new ArrayBuffer(BLOCK_SIZE + BLOCK_ALIGN)` in oxc-parser's
raw-transfer path, allocated by V8. Linux refuses it under heuristic
overcommit on the CI runner (3.7 GB RAM, no swap). The upstream allocator
work that has landed does not touch this path, so waiting on it would not
have helped.

Set KNIP_DISABLE_RAW_TRANSFER=1 in the `knip` script instead, and route
lefthook and `check` through the script rather than the bare binary — the
default path would otherwise crash with an opaque RangeError. Raw transfer
is worth ~5% on a repo this size (3.1s vs 3.15s); the upstream 2-4x figure
applies to large codebases. Knip 6 is still ~20% faster than 5 overall.

No change in unused-code detection. Verified under overcommit_memory=0 on
Linux as well as locally.

Closes #11

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

.jscpd.json

@@ -1,8 +1,14 @@
 {
-	"threshold": 5,
+	"threshold": 3,
 	"minLines": 5,
 	"minTokens": 50,
-	"pattern": ["**/*.ts", "**/*.tsx"],
-	"ignore": ["node_modules", "dist", "build", "coverage", ".specify", "specs"],
+	"pattern": "**/*.{ts,tsx}",
+	"ignore": [
+		"**/node_modules/**",
+		"**/dist/**",
+		"**/build/**",
+		"**/coverage/**",
+		"**/__tests__/**"
+	],
 	"reporters": ["console"]
 }

.oxlintrc.json

@@ -1,6 +1,6 @@
 {
 	"$schema": "https://raw.githubusercontent.com/nicolo-ribaudo/tc39-proposal-type-annotations/refs/heads/main/packages/oxlint/configuration_file_schema.json",
-	"plugins": ["typescript", "unicorn", "jest"],
+	"plugins": ["typescript", "unicorn", "jest", "import"],
 	"categories": {},
 	"rules": {
 		"typescript/no-unnecessary-type-assertion": "error",
@@ -8,6 +8,7 @@
 		"typescript/prefer-regexp-exec": "error",
 		"unicorn/prefer-string-replace-all": "error",
 		"unicorn/prefer-string-raw": "error",
+		"import/no-cycle": "error",
 		"jest/expect-expect": [
 			"error",
 			{
@@ -21,7 +22,6 @@
 		".claude",
 		".specify",
 		"specs",
-		".pnpm-store",
-		"scripts"
+		".pnpm-store"
 	]
 }

apps/web/package.json

@@ -27,8 +27,8 @@
 		"@types/react": "^19.0.0",
 		"@types/react-dom": "^19.0.0",
 		"@vitejs/plugin-react": "^6.0.1",
-		"jsdom": "^29.0.1",
+		"jsdom": "^30.0.1",
 		"tailwindcss": "^4.2.2",
-		"vite": "^8.0.5"
+		"vite": "^8.0.16"
 	}
 }

apps/web/src/__tests__/export-import.test.ts

@@ -266,6 +266,45 @@ describe("round-trip: export then import", () => {
 		expect(imported.encounter.combatants[1].side).toBe("enemy");
 	});
 
+	it("round-trips a combatant with hpVariant field", () => {
+		const encounterWithVariant: Encounter = {
+			combatants: [
+				{
+					id: combatantId("c-1"),
+					name: "Ogre",
+					maxHp: 24,
+					currentHp: 24,
+					hpVariant: "max",
+				},
+				{
+					id: combatantId("c-2"),
+					name: "Goblin",
+					maxHp: 2,
+					currentHp: 2,
+					hpVariant: "min",
+				},
+			],
+			activeIndex: 0,
+			roundNumber: 1,
+		};
+		const emptyUndoRedo: UndoRedoState = {
+			undoStack: [],
+			redoStack: [],
+		};
+		const bundle = assembleExportBundle(
+			encounterWithVariant,
+			emptyUndoRedo,
+			[],
+		);
+		const serialized = JSON.parse(JSON.stringify(bundle));
+		const result = validateImportBundle(serialized);
+
+		expect(typeof result).toBe("object");
+		const imported = result as ExportBundle;
+		expect(imported.encounter.combatants[0].hpVariant).toBe("max");
+		expect(imported.encounter.combatants[1].hpVariant).toBe("min");
+	});
+
 	it("round-trips a combatant without side field as undefined", () => {
 		const encounterNoSide: Encounter = {
 			combatants: [{ id: combatantId("c-1"), name: "Custom" }],

apps/web/src/adapters/ports.ts

@@ -9,18 +9,18 @@ import type {
 } from "@initiative/domain";
 
 export interface EncounterPersistence {
-	load(): Encounter | null;
-	save(encounter: Encounter): void;
+	readonly load: () => Encounter | null;
+	readonly save: (encounter: Encounter) => void;
 }
 
 export interface UndoRedoPersistence {
-	load(): UndoRedoState;
-	save(state: UndoRedoState): void;
+	readonly load: () => UndoRedoState;
+	readonly save: (state: UndoRedoState) => void;
 }
 
 export interface PlayerCharacterPersistence {
-	load(): PlayerCharacter[];
-	save(characters: PlayerCharacter[]): void;
+	readonly load: () => PlayerCharacter[];
+	readonly save: (characters: PlayerCharacter[]) => void;
 }
 
 export interface CachedSourceInfo {
@@ -31,31 +31,34 @@ export interface CachedSourceInfo {
 }
 
 export interface BestiaryCachePort {
-	cacheSource(
+	readonly cacheSource: (
 		system: string,
 		sourceCode: string,
 		displayName: string,
 		creatures: AnyCreature[],
-	): Promise<void>;
-	isSourceCached(system: string, sourceCode: string): Promise<boolean>;
-	getCachedSources(system?: string): Promise<CachedSourceInfo[]>;
-	clearSource(system: string, sourceCode: string): Promise<void>;
-	clearAll(): Promise<void>;
-	loadAllCachedCreatures(): Promise<Map<CreatureId, AnyCreature>>;
+	) => Promise<void>;
+	readonly isSourceCached: (
+		system: string,
+		sourceCode: string,
+	) => Promise<boolean>;
+	readonly getCachedSources: (system?: string) => Promise<CachedSourceInfo[]>;
+	readonly clearSource: (system: string, sourceCode: string) => Promise<void>;
+	readonly clearAll: () => Promise<void>;
+	readonly loadAllCachedCreatures: () => Promise<Map<CreatureId, AnyCreature>>;
 }
 
 export interface BestiaryIndexPort {
-	loadIndex(): BestiaryIndex;
-	getAllSourceCodes(): string[];
-	getDefaultFetchUrl(sourceCode: string, baseUrl?: string): string;
-	getSourceDisplayName(sourceCode: string): string;
+	readonly loadIndex: () => BestiaryIndex;
+	readonly getAllSourceCodes: () => string[];
+	readonly getDefaultFetchUrl: (sourceCode: string, baseUrl?: string) => string;
+	readonly getSourceDisplayName: (sourceCode: string) => string;
 }
 
 export interface Pf2eBestiaryIndexPort {
-	loadIndex(): Pf2eBestiaryIndex;
-	getAllSourceCodes(): string[];
-	getDefaultFetchUrl(sourceCode: string, baseUrl?: string): string;
-	getSourceDisplayName(sourceCode: string): string;
-	getCreaturePathsForSource(sourceCode: string): string[];
-	getCreatureNamesByPaths(paths: string[]): Map<string, string>;
+	readonly loadIndex: () => Pf2eBestiaryIndex;
+	readonly getAllSourceCodes: () => string[];
+	readonly getDefaultFetchUrl: (sourceCode: string, baseUrl?: string) => string;
+	readonly getSourceDisplayName: (sourceCode: string) => string;
+	readonly getCreaturePathsForSource: (sourceCode: string) => string[];
+	readonly getCreatureNamesByPaths: (paths: string[]) => Map<string, string>;
 }

apps/web/src/components/__tests__/combatant-row.test.tsx

@@ -373,6 +373,26 @@ describe("CombatantRow", () => {
 			).toBeInTheDocument();
 		});
 
+		it("popover is not dimmed when the combatant is downed", async () => {
+			const user = userEvent.setup();
+			renderRow({
+				combatant: {
+					id: combatantId("1"),
+					name: "Goblin",
+					maxHp: 10,
+					currentHp: 0,
+				},
+			});
+
+			await user.click(screen.getByLabelText(CURRENT_HP_REGEX));
+			// The row dims downed combatants with opacity-50, which would cascade
+			// to the popover if it rendered inside the dimmed subtree.
+			const popover = screen
+				.getByRole("button", { name: "Apply damage" })
+				.closest(".opacity-50");
+			expect(popover).toBeNull();
+		});
+
 		it("HP section is absent when maxHp is undefined", () => {
 			renderRow({
 				combatant: {

apps/web/src/components/__tests__/dialog.test.tsx

@@ -38,6 +38,22 @@ describe("Dialog", () => {
 		expect(dialog?.hasAttribute("open")).toBe(false);
 	});
 
+	it("unmounts children when closed so internal state does not persist", () => {
+		const { rerender } = render(
+			<Dialog open={true} onClose={() => {}}>
+				<span>Body</span>
+			</Dialog>,
+		);
+		expect(screen.queryByText("Body")).not.toBeNull();
+
+		rerender(
+			<Dialog open={false} onClose={() => {}}>
+				<span>Body</span>
+			</Dialog>,
+		);
+		expect(screen.queryByText("Body")).toBeNull();
+	});
+
 	it("calls onClose on cancel event", () => {
 		const onClose = vi.fn();
 		render(

apps/web/src/components/__tests__/hp-adjust-popover.test.tsx

@@ -3,11 +3,41 @@ import "@testing-library/jest-dom/vitest";
 
 import { cleanup, render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
+import { useEffect, useRef, useState } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { HpAdjustPopover } from "../hp-adjust-popover";
 
 afterEach(cleanup);
 
+function AnchoredPopover({
+	onAdjust,
+	onSetTempHp,
+	onClose,
+}: Readonly<{
+	onAdjust: (delta: number) => void;
+	onSetTempHp: (value: number) => void;
+	onClose: () => void;
+}>) {
+	const anchorRef = useRef<HTMLDivElement>(null);
+	// The popover opens on click in the app, so its anchor is always mounted
+	// first. Mirror that here — otherwise the anchor ref is still null when the
+	// popover measures its position and it renders hidden.
+	const [open, setOpen] = useState(false);
+	useEffect(() => setOpen(true), []);
+	return (
+		<div ref={anchorRef}>
+			{!!open && (
+				<HpAdjustPopover
+					anchorRef={anchorRef}
+					onAdjust={onAdjust}
+					onSetTempHp={onSetTempHp}
+					onClose={onClose}
+				/>
+			)}
+		</div>
+	);
+}
+
 function renderPopover(
 	overrides: Partial<{
 		onAdjust: (delta: number) => void;
@@ -19,7 +49,7 @@ function renderPopover(
 	const onSetTempHp = overrides.onSetTempHp ?? vi.fn();
 	const onClose = overrides.onClose ?? vi.fn();
 	const result = render(
-		<HpAdjustPopover
+		<AnchoredPopover
 			onAdjust={onAdjust}
 			onSetTempHp={onSetTempHp}
 			onClose={onClose}

apps/web/src/components/__tests__/settings-modal.test.tsx

@@ -63,8 +63,11 @@ describe("SettingsModal", () => {
 		renderModal();
 		const btn5e = screen.getByRole("button", { name: "5e (2014)" });
 		await user.click(btn5e);
-		// After clicking 5e, it should have the active style
-		expect(btn5e.className).toContain("bg-accent");
+		expect(btn5e).toHaveAttribute("aria-pressed", "true");
+		expect(screen.getByRole("button", { name: "5.5e (2024)" })).toHaveAttribute(
+			"aria-pressed",
+			"false",
+		);
 	});
 
 	it("clicking a theme button switches the active theme", async () => {
@@ -72,7 +75,7 @@ describe("SettingsModal", () => {
 		renderModal();
 		const darkBtn = screen.getByRole("button", { name: "Dark" });
 		await user.click(darkBtn);
-		expect(darkBtn.className).toContain("bg-accent");
+		expect(darkBtn).toHaveAttribute("aria-pressed", "true");
 	});
 
 	it("close button calls onClose", async () => {

apps/web/src/components/__tests__/stat-block.test.tsx

@@ -1,9 +1,11 @@
 // @vitest-environment jsdom
 import "@testing-library/jest-dom/vitest";
 
-import type { Creature } from "@initiative/domain";
-import { creatureId } from "@initiative/domain";
+import type { Creature, HpVariant } from "@initiative/domain";
+import { combatantId, creatureId } from "@initiative/domain";
 import { cleanup, render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { useState } from "react";
 import { afterEach, describe, expect, it } from "vitest";
 import { DndStatBlock as StatBlock } from "../dnd-stat-block.js";
 
@@ -128,6 +130,19 @@ function renderStatBlock(creature: Creature) {
 	return render(<StatBlock creature={creature} />);
 }
 
+/** Owns the variant the way the encounter state does in the real app. */
+function HpVariantHarness({ creature }: Readonly<{ creature: Creature }>) {
+	const [variant, setVariant] = useState<HpVariant | undefined>(undefined);
+	return (
+		<StatBlock
+			creature={creature}
+			combatantId={combatantId("c-1")}
+			hpVariant={variant}
+			onSetHpVariant={(_id, next) => setVariant(next)}
+		/>
+	);
+}
+
 describe("StatBlock", () => {
 	describe("header", () => {
 		it("renders creature name", () => {
@@ -175,6 +190,81 @@ describe("StatBlock", () => {
 		});
 	});
 
+	describe("hit point variant", () => {
+		it("offers no variant buttons while browsing without a combatant", () => {
+			renderStatBlock(GOBLIN);
+			expect(
+				screen.queryByRole("button", { name: "Max" }),
+			).not.toBeInTheDocument();
+		});
+
+		it("hides the variant buttons when the HP formula is not a dice pool", () => {
+			render(
+				<HpVariantHarness
+					creature={{
+						...GOBLIN,
+						hp: { average: 50, formula: "special" },
+					}}
+				/>,
+			);
+			expect(
+				screen.queryByRole("button", { name: "Max" }),
+			).not.toBeInTheDocument();
+			expect(screen.getByText("50")).toBeInTheDocument();
+		});
+
+		it("shows the printed average until a variant is picked", () => {
+			render(<HpVariantHarness creature={GOBLIN} />);
+			expect(screen.getByText("7")).toBeInTheDocument();
+			expect(screen.getByRole("button", { name: "Avg" })).toHaveAttribute(
+				"aria-pressed",
+				"true",
+			);
+		});
+
+		it("shows the maximum roll after picking Max", async () => {
+			const user = userEvent.setup();
+			render(<HpVariantHarness creature={GOBLIN} />);
+
+			await user.click(screen.getByRole("button", { name: "Max" }));
+
+			expect(screen.getByText("12")).toBeInTheDocument();
+			expect(screen.queryByText("7")).not.toBeInTheDocument();
+			expect(screen.getByRole("button", { name: "Max" })).toHaveAttribute(
+				"aria-pressed",
+				"true",
+			);
+		});
+
+		it("shows the minimum roll after picking Min", async () => {
+			const user = userEvent.setup();
+			render(<HpVariantHarness creature={GOBLIN} />);
+
+			await user.click(screen.getByRole("button", { name: "Min" }));
+
+			expect(screen.getByText("2")).toBeInTheDocument();
+		});
+
+		it("returns to the average after picking Avg again", async () => {
+			const user = userEvent.setup();
+			render(<HpVariantHarness creature={GOBLIN} />);
+
+			await user.click(screen.getByRole("button", { name: "Max" }));
+			await user.click(screen.getByRole("button", { name: "Avg" }));
+
+			expect(screen.getByText("7")).toBeInTheDocument();
+		});
+
+		it("keeps showing the formula for every variant", async () => {
+			const user = userEvent.setup();
+			render(<HpVariantHarness creature={GOBLIN} />);
+
+			await user.click(screen.getByRole("button", { name: "Min" }));
+
+			expect(screen.getByText("(2d6)")).toBeInTheDocument();
+		});
+	});
+
 	describe("ability scores", () => {
 		it("renders all 6 ability labels", () => {
 			renderStatBlock(GOBLIN);

apps/web/src/components/combatant-row.tsx

@@ -202,6 +202,7 @@ function ClickableHp({
 	onSetTempHp: (value: number) => void;
 }>) {
 	const [popoverOpen, setPopoverOpen] = useState(false);
+	const anchorRef = useRef<HTMLDivElement>(null);
 	const status = deriveHpStatus(currentHp, maxHp);
 
 	if (maxHp === undefined) {
@@ -209,7 +210,7 @@ function ClickableHp({
 	}
 
 	return (
-		<div className="relative flex items-center">
+		<div ref={anchorRef} className="relative flex items-center">
 			<button
 				type="button"
 				onClick={() => setPopoverOpen(true)}
@@ -230,6 +231,7 @@ function ClickableHp({
 			)}
 			{!!popoverOpen && (
 				<HpAdjustPopover
+					anchorRef={anchorRef}
 					onAdjust={onAdjust}
 					onSetTempHp={onSetTempHp}
 					onClose={() => setPopoverOpen(false)}

apps/web/src/components/dnd-stat-block.tsx

@@ -1,17 +1,34 @@
-import type { Creature } from "@initiative/domain";
+import type {
+	CombatantId,
+	Creature,
+	HpRange,
+	HpVariant,
+} from "@initiative/domain";
 import {
 	calculateInitiative,
 	formatInitiativeModifier,
+	hpForVariant,
+	hpRange,
 } from "@initiative/domain";
+import { cn } from "../lib/utils.js";
 import {
 	PropertyLine,
 	SectionDivider,
 	TraitEntry,
 	TraitSection,
 } from "./stat-block-parts.js";
+import type { SegmentedOption } from "./ui/segmented-control.js";
+import { SegmentedControl } from "./ui/segmented-control.js";
 
 interface DndStatBlockProps {
 	creature: Creature;
+	combatantId?: CombatantId;
+	hpVariant?: HpVariant;
+	onSetHpVariant?: (
+		id: CombatantId,
+		variant: HpVariant | undefined,
+		range: HpRange,
+	) => void;
 }
 
 function abilityMod(score: number): string {
@@ -19,7 +36,25 @@ function abilityMod(score: number): string {
 	return mod >= 0 ? `+${mod}` : `${mod}`;
 }
 
-export function DndStatBlock({ creature }: Readonly<DndStatBlockProps>) {
+/** Text color for a max HP that no longer shows the printed average. */
+function hpVariantColor(variant: HpVariant | undefined): string {
+	if (variant === "max") return "text-blue-400";
+	if (variant === "min") return "text-red-400";
+	return "";
+}
+
+const HP_VARIANT_OPTIONS: SegmentedOption<HpVariant | undefined>[] = [
+	{ value: "min", label: "Min" },
+	{ value: undefined, label: "Avg" },
+	{ value: "max", label: "Max" },
+];
+
+export function DndStatBlock({
+	creature,
+	combatantId,
+	hpVariant,
+	onSetHpVariant,
+}: Readonly<DndStatBlockProps>) {
 	const abilities = [
 		{ label: "STR", score: creature.abilities.str },
 		{ label: "DEX", score: creature.abilities.dex },
@@ -35,6 +70,17 @@ export function DndStatBlock({ creature }: Readonly<DndStatBlockProps>) {
 		initiativeProficiency: creature.initiativeProficiency,
 	});
 
+	// Only offer min/max HP when the formula is a real dice pool with a spread.
+	const range = hpRange(creature.hp);
+	const canPickVariant =
+		range !== null &&
+		range.min !== range.max &&
+		combatantId != null &&
+		onSetHpVariant != null;
+	const displayedHp = range
+		? hpForVariant(range, hpVariant)
+		: creature.hp.average;
+
 	return (
 		<div className="space-y-1 text-foreground">
 			{/* Header */}
@@ -68,8 +114,22 @@ export function DndStatBlock({ creature }: Readonly<DndStatBlockProps>) {
 				</div>
 				<div>
 					<span className="font-semibold">Hit Points</span>{" "}
-					{creature.hp.average}{" "}
+					<span className={cn("font-semibold", hpVariantColor(hpVariant))}>
+						{displayedHp}
+					</span>{" "}
 					<span className="text-muted-foreground">({creature.hp.formula})</span>
+					{canPickVariant ? (
+						<SegmentedControl
+							options={HP_VARIANT_OPTIONS}
+							value={hpVariant}
+							onChange={(variant) =>
+								onSetHpVariant(combatantId, variant, range)
+							}
+							size="xs"
+							label="Hit point variant"
+							className="mt-1"
+						/>
+					) : null}
 				</div>
 				<div>
 					<span className="font-semibold">Speed</span> {creature.speed}

apps/web/src/components/hp-adjust-popover.tsx

@@ -6,18 +6,21 @@ import {
 	useRef,
 	useState,
 } from "react";
+import { createPortal } from "react-dom";
 import { useClickOutside } from "../hooks/use-click-outside.js";
 import { Input } from "./ui/input";
 
 const DIGITS_ONLY_REGEX = /^\d+$/;
 
 interface HpAdjustPopoverProps {
+	readonly anchorRef: React.RefObject<HTMLElement | null>;
 	readonly onAdjust: (delta: number) => void;
 	readonly onSetTempHp: (value: number) => void;
 	readonly onClose: () => void;
 }
 
 export function HpAdjustPopover({
+	anchorRef,
 	onAdjust,
 	onSetTempHp,
 	onClose,
@@ -29,10 +32,9 @@ export function HpAdjustPopover({
 
 	useLayoutEffect(() => {
 		const el = ref.current;
-		if (!el) return;
-		const parent = el.parentElement;
-		if (!parent) return;
-		const trigger = parent.getBoundingClientRect();
+		const anchor = anchorRef.current;
+		if (!el || !anchor) return;
+		const trigger = anchor.getBoundingClientRect();
 		const popover = el.getBoundingClientRect();
 		const vw = document.documentElement.clientWidth;
 		let left = trigger.left;
@@ -43,7 +45,7 @@ export function HpAdjustPopover({
 			left = 8;
 		}
 		setPos({ top: trigger.bottom + 4, left });
-	}, []);
+	}, [anchorRef]);
 
 	useEffect(() => {
 		requestAnimationFrame(() => inputRef.current?.focus());
@@ -82,10 +84,10 @@ export function HpAdjustPopover({
 		[applyDelta, onClose],
 	);
 
-	return (
+	return createPortal(
 		<div
 			ref={ref}
-			className="card-glow fixed z-10 rounded-lg border border-border bg-background p-2"
+			className="card-glow fixed z-50 rounded-lg border border-border bg-background p-2"
 			style={
 				pos
 					? { top: pos.top, left: pos.left }
@@ -144,6 +146,7 @@ export function HpAdjustPopover({
 					<ShieldPlus size={14} />
 				</button>
 			</div>
-		</div>
+		</div>,
+		document.body,
 	);
 }

apps/web/src/components/pf2e-stat-block.tsx

@@ -15,6 +15,8 @@ import {
 	SectionDivider,
 	TraitSection,
 } from "./stat-block-parts.js";
+import type { SegmentedOption } from "./ui/segmented-control.js";
+import { SegmentedControl } from "./ui/segmented-control.js";
 
 interface Pf2eStatBlockProps {
 	creature: Pf2eCreature;
@@ -52,6 +54,12 @@ function formatMod(mod: number): string {
 	return mod >= 0 ? `+${mod}` : `${mod}`;
 }
 
+const ADJUSTMENT_OPTIONS: SegmentedOption<"weak" | "elite" | undefined>[] = [
+	{ value: "weak", label: "Weak" },
+	{ value: undefined, label: "Normal" },
+	{ value: "elite", label: "Elite" },
+];
+
 /** Returns the text color class for stats affected by weak/elite adjustment. */
 function adjustmentColor(adjustment: "weak" | "elite" | undefined): string {
 	if (adjustment === "elite") return "text-blue-400";
@@ -213,29 +221,16 @@ export function Pf2eStatBlock({
 				{combatantId != null &&
 					onSetAdjustment != null &&
 					baseCreature != null && (
-						<div className="mt-1 flex gap-1">
-							{(["weak", "normal", "elite"] as const).map((opt) => {
-								const value = opt === "normal" ? undefined : opt;
-								const isActive = adjustment === value;
-								return (
-									<button
-										key={opt}
-										type="button"
-										className={cn(
-											"rounded px-2 py-0.5 font-medium text-xs capitalize",
-											isActive
-												? "bg-accent text-primary-foreground"
-												: "bg-card text-muted-foreground hover:bg-accent/30",
-										)}
-										onClick={() =>
-											onSetAdjustment(combatantId, value, baseCreature)
-										}
-									>
-										{opt}
-									</button>
-								);
-							})}
-						</div>
+						<SegmentedControl
+							options={ADJUSTMENT_OPTIONS}
+							value={adjustment}
+							onChange={(value) =>
+								onSetAdjustment(combatantId, value, baseCreature)
+							}
+							size="xs"
+							label="Creature adjustment"
+							className="mt-1"
+						/>
 					)}
 				<div className="mt-1 flex flex-wrap gap-1">
 					{displayTraits(creature.traits).map((trait) => (

apps/web/src/components/settings-modal.tsx

@@ -2,28 +2,51 @@ import type { RulesEdition } from "@initiative/domain";
 import { Monitor, Moon, Sun } from "lucide-react";
 import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
 import { useThemeContext } from "../contexts/theme-context.js";
-import { cn } from "../lib/utils.js";
 import { Dialog, DialogHeader } from "./ui/dialog.js";
+import type { SegmentedOption } from "./ui/segmented-control.js";
+import { SegmentedControl } from "./ui/segmented-control.js";
 
 interface SettingsModalProps {
 	open: boolean;
 	onClose: () => void;
 }
 
-const EDITION_OPTIONS: { value: RulesEdition; label: string }[] = [
+const EDITION_OPTIONS: SegmentedOption<RulesEdition>[] = [
 	{ value: "5e", label: "5e (2014)" },
 	{ value: "5.5e", label: "5.5e (2024)" },
 	{ value: "pf2e", label: "Pathfinder 2e" },
 ];
 
-const THEME_OPTIONS: {
-	value: "system" | "light" | "dark";
-	label: string;
-	icon: typeof Sun;
-}[] = [
-	{ value: "system", label: "System", icon: Monitor },
-	{ value: "light", label: "Light", icon: Sun },
-	{ value: "dark", label: "Dark", icon: Moon },
+type ThemePreference = "system" | "light" | "dark";
+
+const THEME_OPTIONS: SegmentedOption<ThemePreference>[] = [
+	{
+		value: "system",
+		label: (
+			<>
+				<Monitor size={14} />
+				System
+			</>
+		),
+	},
+	{
+		value: "light",
+		label: (
+			<>
+				<Sun size={14} />
+				Light
+			</>
+		),
+	},
+	{
+		value: "dark",
+		label: (
+			<>
+				<Moon size={14} />
+				Dark
+			</>
+		),
+	},
 ];
 
 export function SettingsModal({ open, onClose }: Readonly<SettingsModalProps>) {
@@ -39,50 +62,26 @@ export function SettingsModal({ open, onClose }: Readonly<SettingsModalProps>) {
 					<span className="mb-2 block font-medium text-muted-foreground text-sm">
 						Game System
 					</span>
-					<div className="flex gap-1">
-						{EDITION_OPTIONS.map((opt) => (
-							<button
-								key={opt.value}
-								type="button"
-								className={cn(
-									"flex-1 rounded-md px-3 py-1.5 text-sm transition-colors",
-									edition === opt.value
-										? "bg-accent text-primary-foreground"
-										: "bg-card text-muted-foreground hover:bg-hover-neutral-bg hover:text-foreground",
-								)}
-								onClick={() => setEdition(opt.value)}
-							>
-								{opt.label}
-							</button>
-						))}
-					</div>
+					<SegmentedControl
+						options={EDITION_OPTIONS}
+						value={edition}
+						onChange={setEdition}
+						stretch
+						label="Game System"
+					/>
 				</div>
 
 				<div>
 					<span className="mb-2 block font-medium text-muted-foreground text-sm">
 						Theme
 					</span>
-					<div className="flex gap-1">
-						{THEME_OPTIONS.map((opt) => {
-							const Icon = opt.icon;
-							return (
-								<button
-									key={opt.value}
-									type="button"
-									className={cn(
-										"flex flex-1 items-center justify-center gap-1.5 rounded-md px-3 py-1.5 text-sm transition-colors",
-										preference === opt.value
-											? "bg-accent text-primary-foreground"
-											: "bg-card text-muted-foreground hover:bg-hover-neutral-bg hover:text-foreground",
-									)}
-									onClick={() => setPreference(opt.value)}
-								>
-									<Icon size={14} />
-									{opt.label}
-								</button>
-							);
-						})}
-					</div>
+					<SegmentedControl
+						options={THEME_OPTIONS}
+						value={preference}
+						onChange={setPreference}
+						stretch
+						label="Theme"
+					/>
 				</div>
 			</div>
 		</Dialog>

apps/web/src/components/stat-block-panel.tsx

@@ -4,6 +4,8 @@ import type {
 	CombatantId,
 	Creature,
 	CreatureId,
+	HpRange,
+	HpVariant,
 	Pf2eCreature,
 } from "@initiative/domain";
 import { applyPf2eAdjustment } from "@initiative/domain";
@@ -225,7 +227,8 @@ function MobileDrawer({
 function usePanelRole(panelRole: "browse" | "pinned") {
 	const sidePanel = useSidePanelContext();
 	const { getCreature } = useBestiaryContext();
-	const { encounter, setCreatureAdjustment } = useEncounterContext();
+	const { encounter, setCreatureAdjustment, setHpVariant } =
+		useEncounterContext();
 
 	const creatureId =
 		panelRole === "browse"
@@ -245,6 +248,7 @@ function usePanelRole(panelRole: "browse" | "pinned") {
 		creature,
 		combatant,
 		setCreatureAdjustment,
+		setHpVariant,
 		isCollapsed: isBrowse ? sidePanel.isRightPanelCollapsed : false,
 		onToggleCollapse: isBrowse ? sidePanel.toggleCollapse : () => {},
 		onDismiss: isBrowse ? sidePanel.dismissPanel : () => {},
@@ -256,14 +260,23 @@ function usePanelRole(panelRole: "browse" | "pinned") {
 	};
 }
 
-function renderStatBlock(
-	creature: AnyCreature,
-	combatant: Combatant | null,
+interface StatBlockHandlers {
 	setCreatureAdjustment: (
 		id: CombatantId,
 		adj: "weak" | "elite" | undefined,
 		base: Pf2eCreature,
-	) => void,
+	) => void;
+	setHpVariant: (
+		id: CombatantId,
+		variant: HpVariant | undefined,
+		range: HpRange,
+	) => void;
+}
+
+function renderStatBlock(
+	creature: AnyCreature,
+	combatant: Combatant | null,
+	handlers: StatBlockHandlers,
 ) {
 	if ("system" in creature && creature.system === "pf2e") {
 		const baseCreature = creature;
@@ -276,11 +289,18 @@ function renderStatBlock(
 				adjustment={combatant?.creatureAdjustment}
 				combatantId={combatant?.id}
 				baseCreature={baseCreature}
-				onSetAdjustment={setCreatureAdjustment}
+				onSetAdjustment={handlers.setCreatureAdjustment}
 			/>
 		);
 	}
-	return <DndStatBlock creature={creature as Creature} />;
+	return (
+		<DndStatBlock
+			creature={creature as Creature}
+			combatantId={combatant?.id}
+			hpVariant={combatant?.hpVariant}
+			onSetHpVariant={handlers.setHpVariant}
+		/>
+	);
 }
 
 export function StatBlockPanel({
@@ -292,6 +312,7 @@ export function StatBlockPanel({
 		creature,
 		combatant,
 		setCreatureAdjustment,
+		setHpVariant,
 		isCollapsed,
 		onToggleCollapse,
 		onDismiss,
@@ -363,7 +384,10 @@ export function StatBlockPanel({
 		}
 
 		if (creature) {
-			return renderStatBlock(creature, combatant, setCreatureAdjustment);
+			return renderStatBlock(creature, combatant, {
+				setCreatureAdjustment,
+				setHpVariant,
+			});
 		}
 
 		if (needsFetch && sourceCode) {

apps/web/src/components/ui/dialog.tsx

@@ -46,7 +46,7 @@ export function Dialog({ open, onClose, className, children }: DialogProps) {
 				className,
 			)}
 		>
-			<div className="p-6">{children}</div>
+			{open ? <div className="p-6">{children}</div> : null}
 		</dialog>
 	);
 }

apps/web/src/components/ui/segmented-control.tsx

@@ -0,0 +1,59 @@
+import type { ReactNode } from "react";
+import { cn } from "../../lib/utils.js";
+
+export interface SegmentedOption<T> {
+	readonly value: T;
+	readonly label: ReactNode;
+}
+
+interface SegmentedControlProps<T> {
+	options: readonly SegmentedOption<T>[];
+	value: T;
+	onChange: (value: T) => void;
+	/** "sm" for standalone controls, "xs" for controls inline in a stat block. */
+	size?: "sm" | "xs";
+	/** Segments share the full width of the row instead of hugging their label. */
+	stretch?: boolean;
+	label?: string;
+	className?: string;
+}
+
+/**
+ * A row of mutually exclusive options where exactly one is active — game
+ * system, theme, PF2e adjustment, D&D hit point variant.
+ */
+export function SegmentedControl<T>({
+	options,
+	value,
+	onChange,
+	size = "sm",
+	stretch = false,
+	label,
+	className,
+}: Readonly<SegmentedControlProps<T>>) {
+	return (
+		<fieldset aria-label={label} className={cn("flex gap-1", className)}>
+			{options.map((option) => {
+				const isActive = option.value === value;
+				return (
+					<button
+						key={String(option.value)}
+						type="button"
+						aria-pressed={isActive}
+						className={cn(
+							"flex items-center justify-center gap-1.5 rounded-md font-medium transition-colors",
+							size === "xs" ? "px-2 py-0.5 text-xs" : "px-3 py-1.5 text-sm",
+							stretch ? "flex-1" : "",
+							isActive
+								? "bg-accent text-primary-foreground"
+								: "bg-card text-muted-foreground hover:bg-hover-neutral-bg hover:text-foreground",
+						)}
+						onClick={() => onChange(option.value)}
+					>
+						{option.label}
+					</button>
+				);
+			})}
+		</fieldset>
+	);
+}

apps/web/src/hooks/__tests__/use-difficulty.test.tsx

@@ -341,10 +341,10 @@ describe("useDifficulty", () => {
 		await waitFor(() => {
 			expect(result.current).not.toBeNull();
 			// Level 3 budget: low=150, mod=225, high=400
-			// CR 1/4 = 50 XP -> trivial
+			// CR 1/4 = 50 XP ≤ 150 Low budget -> Low
 			expect(result.current?.thresholds[0].value).toBe(150);
 			expect(result.current?.totalMonsterXp).toBe(50);
-			expect(result.current?.tier).toBe(0);
+			expect(result.current?.tier).toBe(1);
 		});
 	});
 

apps/web/src/hooks/__tests__/use-encounter-hp-variant.test.ts

@@ -0,0 +1,95 @@
+import type { HpRange, HpVariant } from "@initiative/domain";
+import {
+	combatantId,
+	creatureId,
+	EMPTY_UNDO_REDO_STATE,
+} from "@initiative/domain";
+import { describe, expect, it } from "vitest";
+import { type EncounterState, encounterReducer } from "../use-encounter.js";
+
+// An ogre with 3d6 + 6 hit points.
+const RANGE: HpRange = { min: 9, average: 16, max: 24 };
+
+function stateWithCreature(
+	maxHp: number,
+	currentHp: number,
+	hpVariant?: HpVariant,
+): EncounterState {
+	return {
+		encounter: {
+			combatants: [
+				{
+					id: combatantId("c-1"),
+					name: "Ogre",
+					maxHp,
+					currentHp,
+					creatureId: creatureId("mm:ogre"),
+					...(hpVariant !== undefined && { hpVariant }),
+				},
+			],
+			activeIndex: 0,
+			roundNumber: 1,
+		},
+		undoRedoState: EMPTY_UNDO_REDO_STATE,
+		events: [],
+		nextId: 1,
+		lastCreatureId: null,
+	};
+}
+
+function setVariant(state: EncounterState, variant: HpVariant | undefined) {
+	return encounterReducer(state, {
+		type: "set-hp-variant",
+		id: combatantId("c-1"),
+		variant,
+		range: RANGE,
+	});
+}
+
+describe("set-hp-variant", () => {
+	it("raises max HP to the maximum roll and stores the variant", () => {
+		const next = setVariant(stateWithCreature(16, 16), "max");
+		const c = next.encounter.combatants[0];
+		expect(c.maxHp).toBe(24);
+		expect(c.currentHp).toBe(24);
+		expect(c.hpVariant).toBe("max");
+	});
+
+	it("lowers max HP to the minimum roll", () => {
+		const next = setVariant(stateWithCreature(16, 16), "min");
+		const c = next.encounter.combatants[0];
+		expect(c.maxHp).toBe(9);
+		expect(c.hpVariant).toBe("min");
+	});
+
+	it("returns to the average and clears the variant", () => {
+		const next = setVariant(stateWithCreature(24, 24, "max"), undefined);
+		const c = next.encounter.combatants[0];
+		expect(c.maxHp).toBe(16);
+		expect(c.hpVariant).toBeUndefined();
+	});
+
+	it("does not rename the combatant", () => {
+		const next = setVariant(stateWithCreature(16, 16), "max");
+		expect(next.encounter.combatants[0].name).toBe("Ogre");
+	});
+
+	it("is undoable", () => {
+		const start = stateWithCreature(16, 16);
+		const next = setVariant(start, "max");
+		const undone = encounterReducer(next, { type: "undo" });
+		expect(undone.encounter.combatants[0].maxHp).toBe(16);
+		expect(undone.encounter.combatants[0].hpVariant).toBeUndefined();
+	});
+
+	it("leaves state untouched for an unknown combatant", () => {
+		const start = stateWithCreature(16, 16);
+		const next = encounterReducer(start, {
+			type: "set-hp-variant",
+			id: combatantId("c-99"),
+			variant: "max",
+			range: RANGE,
+		});
+		expect(next).toBe(start);
+	});
+});

apps/web/src/hooks/__tests__/use-player-characters.test.tsx

@@ -112,6 +112,49 @@ describe("usePlayerCharacters", () => {
 		expect(result.current.characters[0].name).toBe("Vex'ahlia");
 	});
 
+	it("createCharacter assigns a fresh id after rehydration from persistence", () => {
+		const stored = [
+			{
+				id: playerCharacterId("pc-1"),
+				name: "Mikka",
+				ac: 12,
+				maxHp: 58,
+				color: undefined,
+				icon: undefined,
+			},
+			{
+				id: playerCharacterId("pc-3"),
+				name: "Bob",
+				ac: 14,
+				maxHp: 40,
+				color: undefined,
+				icon: undefined,
+			},
+		];
+		const adapters = createTestAdapters({ playerCharacters: stored });
+
+		const { result } = renderHook(() => usePlayerCharacters(), {
+			wrapper: ({ children }: { children: ReactNode }) => (
+				<AllProviders adapters={adapters}>{children}</AllProviders>
+			),
+		});
+
+		act(() => {
+			result.current.createCharacter(
+				"Charlie",
+				13,
+				25,
+				undefined,
+				undefined,
+				undefined,
+			);
+		});
+
+		const ids = result.current.characters.map((pc) => pc.id);
+		expect(new Set(ids).size).toBe(ids.length);
+		expect(ids).toContain(playerCharacterId("pc-4"));
+	});
+
 	it("deleteCharacter removes character and persists", () => {
 		const { result } = renderHook(() => usePlayerCharacters(), { wrapper });
 

apps/web/src/hooks/use-encounter.ts

@@ -15,6 +15,7 @@ import {
 	setConditionValueUseCase,
 	setCrUseCase,
 	setHpUseCase,
+	setHpVariantUseCase,
 	setInitiativeUseCase,
 	setSideUseCase,
 	setTempHpUseCase,
@@ -30,6 +31,8 @@ import type {
 	DomainError,
 	DomainEvent,
 	Encounter,
+	HpRange,
+	HpVariant,
 	PersistentDamageType,
 	Pf2eCreature,
 	PlayerCharacter,
@@ -59,6 +62,12 @@ type EncounterAction =
 	| { type: "edit-combatant"; id: CombatantId; newName: string }
 	| { type: "set-initiative"; id: CombatantId; value: number | undefined }
 	| { type: "set-hp"; id: CombatantId; maxHp: number | undefined }
+	| {
+			type: "set-hp-variant";
+			id: CombatantId;
+			variant: HpVariant | undefined;
+			range: HpRange;
+	  }
 	| { type: "adjust-hp"; id: CombatantId; delta: number }
 	| { type: "set-temp-hp"; id: CombatantId; tempHp: number | undefined }
 	| { type: "set-ac"; id: CombatantId; value: number | undefined }
@@ -432,6 +441,7 @@ function dispatchEncounterAction(
 		| { type: "edit-combatant" }
 		| { type: "set-initiative" }
 		| { type: "set-hp" }
+		| { type: "set-hp-variant" }
 		| { type: "adjust-hp" }
 		| { type: "set-temp-hp" }
 		| { type: "set-ac" }
@@ -472,6 +482,14 @@ function dispatchEncounterAction(
 		case "set-hp":
 			result = setHpUseCase(store, action.id, action.maxHp);
 			break;
+		case "set-hp-variant":
+			result = setHpVariantUseCase(
+				store,
+				action.id,
+				action.variant,
+				action.range,
+			);
+			break;
 		case "adjust-hp":
 			result = adjustHpUseCase(store, action.id, action.delta);
 			break;
@@ -706,6 +724,11 @@ export function useEncounter() {
 				}),
 			[],
 		),
+		setHpVariant: useCallback(
+			(id: CombatantId, variant: HpVariant | undefined, range: HpRange) =>
+				dispatch({ type: "set-hp-variant", id, variant, range }),
+			[],
+		),
 		clearEncounter: useCallback(
 			() => dispatch({ type: "clear-encounter" }),
 			[],

apps/web/src/hooks/use-player-characters.ts

@@ -9,10 +9,18 @@ import { isDomainError, playerCharacterId } from "@initiative/domain";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { useAdapters } from "../contexts/adapter-context.js";
 
-let nextPcId = 0;
+const PC_ID_PATTERN = /^pc-(\d+)$/;
 
-function generatePcId(): PlayerCharacterId {
-	return playerCharacterId(`pc-${++nextPcId}`);
+function generatePcId(existing: readonly PlayerCharacter[]): PlayerCharacterId {
+	let max = 0;
+	for (const pc of existing) {
+		const match = PC_ID_PATTERN.exec(pc.id);
+		if (match) {
+			const n = Number(match[1]);
+			if (n > max) max = n;
+		}
+	}
+	return playerCharacterId(`pc-${max + 1}`);
 }
 
 interface EditFields {
@@ -55,7 +63,7 @@ export function usePlayerCharacters() {
 			icon: string | undefined,
 			level: number | undefined,
 		) => {
-			const id = generatePcId();
+			const id = generatePcId(charactersRef.current);
 			const result = createPlayerCharacterUseCase(
 				makeStore(),
 				id,

data/bestiary/dnd-bundled.json

@@ -2393,5 +2393,85 @@
 				]
 			}
 		]
+	},
+	{
+		"id": "homebrew:centaur-youth",
+		"name": "Centaur Youth",
+		"source": "HOMEBREW",
+		"sourceDisplayName": "Homebrew",
+		"size": "Medium",
+		"type": "Fey",
+		"alignment": "Any Alignment",
+		"ac": 13,
+		"acSource": "leather armor",
+		"hp": {
+			"average": 15,
+			"formula": "2d10 + 4"
+		},
+		"speed": "45 ft.",
+		"abilities": {
+			"str": 14,
+			"dex": 15,
+			"con": 14,
+			"int": 8,
+			"wis": 13,
+			"cha": 10
+		},
+		"cr": "1/4",
+		"initiativeProficiency": 0,
+		"proficiencyBonus": 2,
+		"passive": 11,
+		"languages": "Elvish, Sylvan",
+		"traits": [
+			{
+				"name": "Gallop",
+				"segments": [
+					{
+						"type": "text",
+						"value": "Opportunity Attacks against the Centaur Youth are made at disadvantage."
+					}
+				]
+			},
+			{
+				"name": "Charge",
+				"segments": [
+					{
+						"type": "text",
+						"value": "If the Centaur Youth moves at least 15 feet in a straight line toward a target immediately before hitting it with a melee attack, it deals an extra 3 (1d6) damage on the hit. The Centaur Youth can use this trait once on each of its turns."
+					}
+				]
+			}
+		],
+		"actions": [
+			{
+				"name": "Dagger",
+				"segments": [
+					{
+						"type": "text",
+						"value": "Melee Attack Roll: +4, reach 5 ft. Hit: 4 (1d4 + 2) Piercing damage."
+					}
+				]
+			},
+			{
+				"name": "Shortbow",
+				"segments": [
+					{
+						"type": "text",
+						"value": "Ranged Attack Roll: +6, range 80/320 ft. Hit: 6 (1d6 + 2) Piercing damage."
+					}
+				]
+			}
+		],
+		"reactions": [
+			{
+				"name": "Bowshot Reposition (1/Short Rest)",
+				"segments": [
+					{
+						"type": "text",
+						"value": "Trigger: A hostile creature ends its turn within 5 ft. of the Centaur Youth. Response: The Centaur Youth moves up to half its Speed and makes one Shortbow attack at disadvantage against the creature."
+					}
+				]
+			}
+		]
 	}
 ]

knip.json

@@ -1,5 +1,5 @@
 {
-	"$schema": "https://unpkg.com/knip@5/schema.json",
+	"$schema": "https://unpkg.com/knip@6/schema.json",
 	"workspaces": {
 		".": {
 			"entry": ["scripts/*.mjs"]

lefthook.yml

@@ -3,8 +3,12 @@ pre-commit:
   jobs:
     - name: audit
       run: pnpm audit --audit-level=high
+    # Must go through the npm script, not `pnpm exec knip`: the script sets
+    # KNIP_DISABLE_RAW_TRANSFER=1. Knip 6's default oxc-parser raw-transfer path
+    # allocates a 6 GiB ArrayBuffer, which Linux refuses under heuristic
+    # overcommit on the CI runner (3.7 GB RAM, no swap). See issue #11.
     - name: knip
-      run: pnpm exec knip
+      run: pnpm knip
     - name: biome
       run: pnpm exec biome check .
     - name: check-ignores
@@ -14,7 +18,7 @@ pre-commit:
     - name: check-props
       run: node scripts/check-component-props.mjs
     - name: jscpd
-      run: pnpm exec jscpd
+      run: pnpm jscpd
     - name: jsinspect
       run: pnpm jsinspect
     - name: typecheck-oxlint-test
@@ -24,6 +28,6 @@ pre-commit:
           - name: typecheck
             run: pnpm exec tsc --build
           - name: oxlint
-            run: pnpm oxlint -- --deny warnings
+            run: pnpm oxlint
           - name: test
             run: pnpm vitest run --reporter=dot --coverage.reporter=text-summary

package.json

@@ -1,18 +1,12 @@
 {
 	"private": true,
 	"packageManager": "pnpm@10.32.1+sha512.a706938f0e89ac1456b6563eab4edf1d1faf3368d1191fc5c59790e96dc918e4456ab2e67d613de1043d2e8c81f87303e6b40d4ffeca9df15ef1ad567348f2be",
-	"pnpm": {
-		"overrides": {
-			"undici": ">=7.24.0",
-			"picomatch": ">=4.0.4"
-		}
-	},
 	"devDependencies": {
 		"@biomejs/biome": "2.4.8",
 		"@vitest/coverage-v8": "^4.1.0",
 		"jscpd": "^4.0.8",
 		"jsinspect-plus": "^3.1.3",
-		"knip": "^5.88.1",
+		"knip": "^6.31.0",
 		"lefthook": "^2.1.4",
 		"oxlint": "^1.56.0",
 		"oxlint-tsgolint": "^0.17.1",
@@ -28,13 +22,13 @@
 		"typecheck": "tsc --build",
 		"test": "vitest run",
 		"test:watch": "vitest",
-		"knip": "knip",
-		"jscpd": "jscpd",
+		"knip": "KNIP_DISABLE_RAW_TRANSFER=1 knip",
+		"jscpd": "jscpd apps/web/src packages/domain/src packages/application/src",
 		"jsinspect": "jsinspect -c .jsinspectrc apps/web/src packages/domain/src packages/application/src",
-		"oxlint": "oxlint --tsconfig apps/web/tsconfig.json --type-aware --deny-warnings",
+		"oxlint": "oxlint --tsconfig tsconfig.json --type-aware --deny-warnings",
 		"check:ignores": "node scripts/check-lint-ignores.mjs",
 		"check:classnames": "node scripts/check-cn-classnames.mjs",
 		"check:props": "node scripts/check-component-props.mjs",
-		"check": "pnpm audit --audit-level=high && knip && biome check . && node scripts/check-lint-ignores.mjs && node scripts/check-cn-classnames.mjs && node scripts/check-component-props.mjs && jscpd && pnpm jsinspect && tsc --build && oxlint --tsconfig apps/web/tsconfig.json --type-aware --deny warnings && vitest run"
+		"check": "pnpm audit --audit-level=high && pnpm knip && biome check . && node scripts/check-lint-ignores.mjs && node scripts/check-cn-classnames.mjs && node scripts/check-component-props.mjs && pnpm jscpd && pnpm jsinspect && tsc --build && pnpm oxlint && vitest run"
 	}
 }

packages/application/src/index.ts

@@ -27,6 +27,7 @@ export { setAcUseCase } from "./set-ac-use-case.js";
 export { setConditionValueUseCase } from "./set-condition-value-use-case.js";
 export { setCrUseCase } from "./set-cr-use-case.js";
 export { setHpUseCase } from "./set-hp-use-case.js";
+export { setHpVariantUseCase } from "./set-hp-variant-use-case.js";
 export { setInitiativeUseCase } from "./set-initiative-use-case.js";
 export { setSideUseCase } from "./set-side-use-case.js";
 export { setTempHpUseCase } from "./set-temp-hp-use-case.js";

packages/application/src/set-hp-variant-use-case.ts

@@ -0,0 +1,21 @@
+import {
+	type CombatantId,
+	type DomainError,
+	type DomainEvent,
+	type HpRange,
+	type HpVariant,
+	setHpVariant,
+} from "@initiative/domain";
+import type { EncounterStore } from "./ports.js";
+import { runEncounterAction } from "./run-encounter-action.js";
+
+export function setHpVariantUseCase(
+	store: EncounterStore,
+	combatantId: CombatantId,
+	variant: HpVariant | undefined,
+	range: HpRange,
+): DomainEvent[] | DomainError {
+	return runEncounterAction(store, (encounter) =>
+		setHpVariant(encounter, combatantId, variant, range),
+	);
+}

packages/domain/src/__tests__/encounter-difficulty.test.ts

@@ -49,9 +49,9 @@ function enemy(cr: string) {
 }
 
 describe("calculateEncounterDifficulty — 5.5e edition", () => {
-	it("returns tier 0 when monster XP is below Low threshold", () => {
+	it("returns tier 0 when monster XP is 0", () => {
 		// 4x level 1: Low = 200, Moderate = 300, High = 400
-		// 1x CR 0 = 0 XP -> tier 0
+		// 1x CR 0 = 0 XP -> tier 0 (5.5e has no Trivial tier; 0 bars only at 0 XP)
 		const result = calculateEncounterDifficulty(
 			[party(1), party(1), party(1), party(1), enemy("0")],
 			"5.5e",
@@ -77,9 +77,29 @@ describe("calculateEncounterDifficulty — 5.5e edition", () => {
 		expect(result.totalMonsterXp).toBe(200);
 	});
 
-	it("returns tier 2 for 5x level 3 vs 1150 XP", () => {
+	it("returns tier 2 when XP spends exactly the Moderate budget", () => {
 		// 5x level 3: Low = 750, Moderate = 1125, High = 2000
-		// CR 3 (700) + CR 2 (450) = 1150 XP >= 1125 Moderate
+		// CR 4 (1100) + CR 1/8 (25) = 1125 XP = Moderate budget
+		const result = calculateEncounterDifficulty(
+			[
+				party(3),
+				party(3),
+				party(3),
+				party(3),
+				party(3),
+				enemy("4"),
+				enemy("1/8"),
+			],
+			"5.5e",
+		);
+		expect(result.tier).toBe(2);
+		expect(result.totalMonsterXp).toBe(1125);
+		expect(result.thresholds[1].value).toBe(1125);
+	});
+
+	it("returns tier 3 when XP exceeds the Moderate budget", () => {
+		// 5x level 3: Low = 750, Moderate = 1125, High = 2000
+		// CR 3 (700) + CR 2 (450) = 1150 XP > 1125 Moderate → High
 		const result = calculateEncounterDifficulty(
 			[
 				party(3),
@@ -92,14 +112,24 @@ describe("calculateEncounterDifficulty — 5.5e edition", () => {
 			],
 			"5.5e",
 		);
-		expect(result.tier).toBe(2);
+		expect(result.tier).toBe(3);
 		expect(result.totalMonsterXp).toBe(1150);
-		expect(result.thresholds[1].value).toBe(1125);
 	});
 
-	it("returns tier 3 when XP meets High threshold", () => {
-		// 4x level 1: High = 400
-		// 2x CR 1 = 400 XP -> tier 3
+	it("returns tier 3 for 5x level 5 vs 5000 XP (over Moderate budget)", () => {
+		// 5x level 5: Low = 2500, Moderate = 3750, High = 5500
+		// CR 9 = 5000 XP > 3750 Moderate → High, even though below the High budget
+		const result = calculateEncounterDifficulty(
+			[party(5), party(5), party(5), party(5), party(5), enemy("9")],
+			"5.5e",
+		);
+		expect(result.tier).toBe(3);
+		expect(result.totalMonsterXp).toBe(5000);
+	});
+
+	it("returns tier 3 when XP exceeds the Moderate budget", () => {
+		// 4x level 1: Moderate = 300
+		// 2x CR 1 = 400 XP > 300 -> tier 3
 		const result = calculateEncounterDifficulty(
 			[party(1), party(1), party(1), party(1), enemy("1"), enemy("1")],
 			"5.5e",
@@ -120,6 +150,7 @@ describe("calculateEncounterDifficulty — 5.5e edition", () => {
 	it("handles mixed party levels", () => {
 		// 3x level 3 + 1x level 2
 		// Total: low=550, mod=825, high=1400
+		// 700 XP > 550 Low, ≤ 825 Moderate → Moderate
 		const result = calculateEncounterDifficulty(
 			[party(3), party(3), party(3), party(2), enemy("3")],
 			"5.5e",
@@ -130,7 +161,7 @@ describe("calculateEncounterDifficulty — 5.5e edition", () => {
 			{ label: "High", value: 1400 },
 		]);
 		expect(result.totalMonsterXp).toBe(700);
-		expect(result.tier).toBe(1);
+		expect(result.tier).toBe(2);
 	});
 
 	it("returns tier 0 with no enemies", () => {
@@ -164,7 +195,7 @@ describe("calculateEncounterDifficulty — 5.5e edition", () => {
 			"5.5e",
 		);
 		expect(result.totalMonsterXp).toBe(175); // 25 + 50 + 100
-		expect(result.tier).toBe(0); // 175 < 200 Low
+		expect(result.tier).toBe(1); // 175 ≤ 200 Low budget → Low
 	});
 
 	it("ignores unknown CRs (0 XP)", () => {
@@ -191,7 +222,7 @@ describe("calculateEncounterDifficulty — 5.5e edition", () => {
 			"5.5e",
 		);
 		expect(result.totalMonsterXp).toBe(250);
-		expect(result.tier).toBe(1); // 250 >= 200 Low, < 300 Moderate
+		expect(result.tier).toBe(2); // 250 > 200 Low budget, ≤ 300 Moderate → Moderate
 	});
 
 	it("floors net monster XP at 0", () => {
@@ -254,7 +285,7 @@ describe("calculateEncounterDifficulty — 5.5e edition", () => {
 			{ label: "High", value: 800 },
 		]);
 		expect(result.totalMonsterXp).toBe(700);
-		expect(result.tier).toBe(2); // 700 >= 450 Moderate, < 800 High
+		expect(result.tier).toBe(3); // 700 > 450 Moderate budget → High
 	});
 });
 
@@ -448,8 +479,8 @@ describe("pf2eCreatureXp", () => {
 		expect(pf2eCreatureXp(5 + diff, 5)).toBe(expectedXp);
 	});
 
-	it("clamps level diff below −4 to −4 (10 XP)", () => {
-		expect(pf2eCreatureXp(0, 10)).toBe(10);
+	it("returns 0 XP for creatures more than 4 levels below the party", () => {
+		expect(pf2eCreatureXp(0, 10)).toBe(0);
 	});
 
 	it("clamps level diff above +4 to +4 (160 XP)", () => {
@@ -459,7 +490,7 @@ describe("pf2eCreatureXp", () => {
 
 describe("calculateEncounterDifficulty — pf2e edition", () => {
 	it("returns Trivial (tier 0) for 40 XP with party of 4", () => {
-		// 1 creature at party level = 40 XP, below Low (60)
+		// 1 creature at party level = 40 XP, within the Trivial band (40 or less)
 		const result = calculateEncounterDifficulty(
 			[party(5), party(5), party(5), party(5), pf2eEnemy(5)],
 			"pf2e",
@@ -507,7 +538,7 @@ describe("calculateEncounterDifficulty — pf2e edition", () => {
 	});
 
 	it("returns Extreme (tier 4) for 160 XP", () => {
-		// 1 creature at +4 = 160 XP
+		// 1 creature at +4 = 160 XP > Severe budget (120)
 		const result = calculateEncounterDifficulty(
 			[party(5), party(5), party(5), party(5), pf2eEnemy(9)],
 			"pf2e",
@@ -516,8 +547,28 @@ describe("calculateEncounterDifficulty — pf2e edition", () => {
 		expect(result.totalMonsterXp).toBe(160);
 	});
 
-	it("returns tier 0 when XP is below Low threshold", () => {
-		// 1 creature at −4 = 10 XP, Low = 60
+	it("returns Moderate (tier 2) for XP between the Low and Moderate budgets", () => {
+		// +1 (60) + −4 (10) = 70 XP > Low (60), ≤ Moderate (80)
+		const result = calculateEncounterDifficulty(
+			[party(5), party(5), party(5), party(5), pf2eEnemy(6), pf2eEnemy(1)],
+			"pf2e",
+		);
+		expect(result.tier).toBe(2);
+		expect(result.totalMonsterXp).toBe(70);
+	});
+
+	it("returns Extreme (tier 4) for XP just over the Severe budget", () => {
+		// +3 (120) + −4 (10) = 130 XP > Severe (120)
+		const result = calculateEncounterDifficulty(
+			[party(5), party(5), party(5), party(5), pf2eEnemy(8), pf2eEnemy(1)],
+			"pf2e",
+		);
+		expect(result.tier).toBe(4);
+		expect(result.totalMonsterXp).toBe(130);
+	});
+
+	it("returns tier 0 when XP is within the Trivial band", () => {
+		// 1 creature at −4 = 10 XP ≤ Trivial (40)
 		const result = calculateEncounterDifficulty(
 			[party(5), party(5), party(5), party(5), pf2eEnemy(1)],
 			"pf2e",
@@ -526,6 +577,15 @@ describe("calculateEncounterDifficulty — pf2e edition", () => {
 		expect(result.totalMonsterXp).toBe(10);
 	});
 
+	it("counts creatures more than 4 levels below the party as 0 XP", () => {
+		// Party level 6: a level-1 creature is 5 below → 0 XP
+		const result = calculateEncounterDifficulty(
+			[party(6), party(6), party(6), party(6), pf2eEnemy(1), pf2eEnemy(6)],
+			"pf2e",
+		);
+		expect(result.totalMonsterXp).toBe(40); // only the at-level creature counts
+	});
+
 	it("adjusts thresholds for 5 PCs (increases by adjustment)", () => {
 		const result = calculateEncounterDifficulty(
 			[party(5), party(5), party(5), party(5), party(5), pf2eEnemy(5)],
@@ -533,7 +593,7 @@ describe("calculateEncounterDifficulty — pf2e edition", () => {
 		);
 		expect(result.thresholds).toEqual([
 			{ label: "Trivial", value: 50 },
-			{ label: "Low", value: 75 },
+			{ label: "Low", value: 80 },
 			{ label: "Moderate", value: 100 },
 			{ label: "Severe", value: 150 },
 			{ label: "Extreme", value: 200 },
@@ -547,7 +607,7 @@ describe("calculateEncounterDifficulty — pf2e edition", () => {
 		);
 		expect(result.thresholds).toEqual([
 			{ label: "Trivial", value: 30 },
-			{ label: "Low", value: 45 },
+			{ label: "Low", value: 40 },
 			{ label: "Moderate", value: 60 },
 			{ label: "Severe", value: 90 },
 			{ label: "Extreme", value: 120 },
@@ -561,9 +621,9 @@ describe("calculateEncounterDifficulty — pf2e edition", () => {
 		);
 		// 1 PC: adjustment = −3
 		// Trivial: 40 + (−3 * 10) = 10
-		// Low: 60 + (−3 * 15) = 15
+		// Low: 60 + (−3 * 20) = 0
 		expect(result.thresholds[0].value).toBe(10);
-		expect(result.thresholds[1].value).toBe(15);
+		expect(result.thresholds[1].value).toBe(0);
 		expect(result.thresholds[2].value).toBe(20); // 80 − 60
 		expect(result.thresholds[3].value).toBe(30); // 120 − 90
 		expect(result.thresholds[4].value).toBe(40); // 160 − 120

packages/domain/src/__tests__/gates.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { checkGates } from "../../../../scripts/check-gates.mjs";
+
+describe("quality gates", () => {
+	it("fail on violations instead of silently passing", () => {
+		const violations = checkGates();
+		if (violations.length > 0) {
+			throw new Error(
+				`Gate integrity violations:\n  ${violations.join("\n  ")}`,
+			);
+		}
+		expect(violations).toHaveLength(0);
+	});
+});

packages/domain/src/__tests__/hp-range.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { hpForVariant, hpRange } from "../hp-range.js";
+
+describe("hpRange", () => {
+	it("derives min and max from a formula with a positive modifier", () => {
+		const range = hpRange({ average: 16, formula: "3d6 + 6" });
+		expect(range).toEqual({ min: 9, average: 16, max: 24 });
+	});
+
+	it("derives min and max from a formula without a modifier", () => {
+		const range = hpRange({ average: 40, formula: "9d8" });
+		expect(range).toEqual({ min: 9, average: 40, max: 72 });
+	});
+
+	it("subtracts a negative modifier", () => {
+		const range = hpRange({ average: 45, formula: "10d8 - 5" });
+		expect(range).toEqual({ min: 5, average: 45, max: 75 });
+	});
+
+	it("treats an en dash as a minus sign", () => {
+		// Bundled bestiary data contains e.g. "2d6 – 2" (U+2013).
+		const range = hpRange({ average: 5, formula: "2d6 – 2" });
+		expect(range).toEqual({ min: 1, average: 5, max: 10 });
+	});
+
+	it("never drops below 1 HP when the modifier exceeds the dice", () => {
+		const range = hpRange({ average: 1, formula: "1d4 - 10" });
+		expect(range?.min).toBe(1);
+		expect(range?.max).toBe(1);
+	});
+
+	it("handles large pools without whitespace", () => {
+		expect(hpRange({ average: 256, formula: "19d12+133" })).toEqual({
+			min: 152,
+			average: 256,
+			max: 361,
+		});
+	});
+
+	it("returns null for a missing formula", () => {
+		expect(hpRange({ average: 7, formula: "" })).toBeNull();
+	});
+
+	it("returns null for prose instead of a dice pool", () => {
+		expect(
+			hpRange({ average: 0, formula: "equal to the summoner's" }),
+		).toBeNull();
+	});
+
+	it("returns null for a flat number", () => {
+		expect(hpRange({ average: 50, formula: "50" })).toBeNull();
+	});
+
+	it("returns null for a pool with zero dice or zero sides", () => {
+		expect(hpRange({ average: 0, formula: "0d6" })).toBeNull();
+		expect(hpRange({ average: 0, formula: "2d0" })).toBeNull();
+	});
+
+	it("returns null for compound formulas it cannot reason about", () => {
+		expect(hpRange({ average: 20, formula: "2d6 + 2d8" })).toBeNull();
+	});
+});
+
+describe("hpForVariant", () => {
+	const range = { min: 9, average: 16, max: 24 };
+
+	it("returns the average when no variant is set", () => {
+		expect(hpForVariant(range, undefined)).toBe(16);
+	});
+
+	it("returns the minimum for the min variant", () => {
+		expect(hpForVariant(range, "min")).toBe(9);
+	});
+
+	it("returns the maximum for the max variant", () => {
+		expect(hpForVariant(range, "max")).toBe(24);
+	});
+});

packages/domain/src/__tests__/rehydrate-combatant.test.ts

@@ -301,6 +301,34 @@ describe("rehydrateCombatant", () => {
 			expect(result?.side).toBeUndefined();
 		});
 
+		it("preserves valid hpVariant field", () => {
+			for (const hpVariant of ["min", "max"]) {
+				const result = rehydrateCombatant({
+					...minimalCombatant(),
+					hpVariant,
+				});
+				expect(result).not.toBeNull();
+				expect(result?.hpVariant).toBe(hpVariant);
+			}
+		});
+
+		it("drops invalid hpVariant field", () => {
+			for (const hpVariant of ["average", "", 42, null, true]) {
+				const result = rehydrateCombatant({
+					...minimalCombatant(),
+					hpVariant,
+				});
+				expect(result).not.toBeNull();
+				expect(result?.hpVariant).toBeUndefined();
+			}
+		});
+
+		it("combatant without hpVariant rehydrates as before", () => {
+			const result = rehydrateCombatant(minimalCombatant());
+			expect(result).not.toBeNull();
+			expect(result?.hpVariant).toBeUndefined();
+		});
+
 		it("preserves valid persistent damage entries", () => {
 			const result = rehydrateCombatant({
 				...minimalCombatant(),

packages/domain/src/__tests__/set-hp-variant.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, it } from "vitest";
+import type { HpRange, HpVariant } from "../hp-range.js";
+import { setHpVariant } from "../set-hp-variant.js";
+import type { Combatant, Encounter } from "../types.js";
+import { combatantId, isDomainError } from "../types.js";
+import { expectDomainError } from "./test-helpers.js";
+
+// A 3d6 + 6 creature: 9 / 16 / 24.
+const RANGE: HpRange = { min: 9, average: 16, max: 24 };
+
+function makeCombatant(opts?: Partial<Combatant>): Combatant {
+	return {
+		id: combatantId("c-1"),
+		name: "Ogre",
+		maxHp: 16,
+		currentHp: 16,
+		...opts,
+	};
+}
+
+function enc(combatants: Combatant[]): Encounter {
+	return { combatants, activeIndex: 0, roundNumber: 1 };
+}
+
+function apply(
+	encounter: Encounter,
+	variant: HpVariant | undefined,
+	range: HpRange = RANGE,
+) {
+	const result = setHpVariant(encounter, combatantId("c-1"), variant, range);
+	if (isDomainError(result)) {
+		throw new Error(`Expected success, got error: ${result.message}`);
+	}
+	return result;
+}
+
+describe("setHpVariant", () => {
+	describe("acceptance scenarios", () => {
+		it("average → max raises maxHp and currentHp to the maximum roll", () => {
+			const { encounter } = apply(enc([makeCombatant()]), "max");
+			const c = encounter.combatants[0];
+			expect(c.maxHp).toBe(24);
+			expect(c.currentHp).toBe(24);
+			expect(c.hpVariant).toBe("max");
+		});
+
+		it("average → min lowers maxHp and currentHp to the minimum roll", () => {
+			const { encounter } = apply(enc([makeCombatant()]), "min");
+			const c = encounter.combatants[0];
+			expect(c.maxHp).toBe(9);
+			expect(c.currentHp).toBe(9);
+			expect(c.hpVariant).toBe("min");
+		});
+
+		it("max → average restores the printed average", () => {
+			const start = enc([
+				makeCombatant({ maxHp: 24, currentHp: 24, hpVariant: "max" }),
+			]);
+			const { encounter } = apply(start, undefined);
+			const c = encounter.combatants[0];
+			expect(c.maxHp).toBe(16);
+			expect(c.currentHp).toBe(16);
+			expect(c.hpVariant).toBeUndefined();
+		});
+
+		it("min → max spans the full range in one step", () => {
+			const start = enc([
+				makeCombatant({ maxHp: 9, currentHp: 9, hpVariant: "min" }),
+			]);
+			const { encounter } = apply(start, "max");
+			expect(encounter.combatants[0].maxHp).toBe(24);
+		});
+	});
+
+	describe("damage already taken", () => {
+		it("keeps the amount of damage taken when raising max HP", () => {
+			// 5 damage taken: 11/16 → 19/24
+			const start = enc([makeCombatant({ maxHp: 16, currentHp: 11 })]);
+			const { encounter } = apply(start, "max");
+			const c = encounter.combatants[0];
+			expect(c.maxHp).toBe(24);
+			expect(c.currentHp).toBe(19);
+		});
+
+		it("floors currentHp at 0 when lowering max HP past the damage taken", () => {
+			const start = enc([makeCombatant({ maxHp: 16, currentHp: 3 })]);
+			const { encounter } = apply(start, "min");
+			const c = encounter.combatants[0];
+			expect(c.maxHp).toBe(9);
+			expect(c.currentHp).toBe(0);
+		});
+
+		it("clamps currentHp to the new maxHp", () => {
+			const start = enc([makeCombatant({ maxHp: 100, currentHp: 100 })]);
+			const { encounter } = apply(start, "min");
+			const c = encounter.combatants[0];
+			expect(c.maxHp).toBe(93);
+			expect(c.currentHp).toBe(93);
+		});
+	});
+
+	describe("edge cases", () => {
+		it("preserves a manual max HP edit as an offset", () => {
+			// User bumped the ogre to 20 HP; max is 8 above average.
+			const start = enc([makeCombatant({ maxHp: 20, currentHp: 20 })]);
+			const { encounter } = apply(start, "max");
+			expect(encounter.combatants[0].maxHp).toBe(28);
+		});
+
+		it("never lets maxHp drop below 1", () => {
+			const start = enc([makeCombatant({ maxHp: 2, currentHp: 2 })]);
+			const { encounter } = apply(start, "min");
+			expect(encounter.combatants[0].maxHp).toBe(1);
+		});
+
+		it("leaves a combatant without HP untouched but records the variant", () => {
+			const start = enc([
+				makeCombatant({ maxHp: undefined, currentHp: undefined }),
+			]);
+			const { encounter } = apply(start, "max");
+			const c = encounter.combatants[0];
+			expect(c.maxHp).toBeUndefined();
+			expect(c.currentHp).toBeUndefined();
+			expect(c.hpVariant).toBe("max");
+		});
+
+		it("is a no-op when the variant is already active", () => {
+			const start = enc([
+				makeCombatant({ maxHp: 24, currentHp: 20, hpVariant: "max" }),
+			]);
+			const { encounter, events } = apply(start, "max");
+			expect(encounter.combatants[0].currentHp).toBe(20);
+			expect(events).toEqual([]);
+		});
+
+		it("returns a domain error for an unknown combatant", () => {
+			const result = setHpVariant(
+				enc([makeCombatant()]),
+				combatantId("c-99"),
+				"max",
+				RANGE,
+			);
+			expectDomainError(result, "combatant-not-found");
+		});
+	});
+
+	it("emits an HpVariantSet event carrying the HP change", () => {
+		const { events } = apply(enc([makeCombatant()]), "max");
+		expect(events).toEqual([
+			{
+				type: "HpVariantSet",
+				combatantId: combatantId("c-1"),
+				variant: "max",
+				previousMaxHp: 16,
+				newMaxHp: 24,
+			},
+		]);
+	});
+});

packages/domain/src/encounter-difficulty.ts

@@ -187,10 +187,14 @@ const PF2E_THRESHOLDS_BASE = {
 	extreme: 160,
 } as const;
 
-/** PF2e per-PC adjustment to each threshold (added per PC beyond 4, subtracted per PC fewer). */
+/**
+ * PF2e per-PC adjustment to each threshold (added per PC beyond 4, subtracted
+ * per PC fewer). GM Core remaster values — Low is 20 there, not the
+ * pre-remaster CRB's 15.
+ */
 const PF2E_THRESHOLD_ADJUSTMENTS = {
 	trivial: 10,
-	low: 15,
+	low: 20,
 	moderate: 20,
 	severe: 30,
 	extreme: 40,
@@ -230,13 +234,19 @@ export function derivePartyLevel(levels: readonly number[]): number {
 	return Math.round(sum / levels.length);
 }
 
-/** Returns PF2e XP for a creature given its level and the party level. */
+/**
+ * Returns PF2e XP for a creature given its level and the party level.
+ * Creatures more than 4 levels below the party have no row in the GM Core
+ * table and pose no meaningful threat — they are worth 0 XP. Creatures more
+ * than 4 levels above are counted as the +4 row (160 XP).
+ */
 export function pf2eCreatureXp(
 	creatureLevel: number,
 	partyLevel: number,
 ): number {
-	const diff = Math.max(-4, Math.min(4, creatureLevel - partyLevel));
-	return PF2E_LEVEL_DIFF_XP[diff] ?? 0;
+	const diff = creatureLevel - partyLevel;
+	if (diff < -4) return 0;
+	return PF2E_LEVEL_DIFF_XP[Math.min(4, diff)] ?? 0;
 }
 
 function calculatePf2eBudget(partySize: number) {
@@ -304,7 +314,11 @@ export interface CombatantDescriptor {
 	readonly side: "party" | "enemy";
 }
 
-function determineTier(
+/**
+ * 2014 DMG: thresholds are floors — "the closest threshold that is lower
+ * than the adjusted XP value determines the encounter's difficulty".
+ */
+function tierFromThresholds(
 	xp: number,
 	tierThresholds: readonly number[],
 ): DifficultyTier {
@@ -314,6 +328,23 @@ function determineTier(
 	return 0;
 }
 
+/**
+ * 2024 DMG / PF2e: budgets are ceilings — an encounter belongs to the lowest
+ * tier whose budget it does not exceed ("spend as much of your XP budget as
+ * you can without going over"; PF2e Trivial is "40 XP or less"). XP above the
+ * last budget falls into the tier beyond it (5.5e High / PF2e Extreme have no
+ * upper bound).
+ */
+function tierFromBudgets(
+	xp: number,
+	budgets: readonly number[],
+): DifficultyTier {
+	for (let i = 0; i < budgets.length; i++) {
+		if (xp <= budgets[i]) return i as DifficultyTier;
+	}
+	return budgets.length as DifficultyTier;
+}
+
 function accumulateBudget5_5e(levels: readonly number[]) {
 	const budget = { low: 0, moderate: 0, high: 0 };
 	for (const level of levels) {
@@ -397,11 +428,11 @@ export function calculateEncounterDifficulty(
 		];
 
 		return {
-			tier: determineTier(totalCreatureXp, [
+			tier: tierFromBudgets(totalCreatureXp, [
+				budget.trivial,
 				budget.low,
 				budget.moderate,
 				budget.severe,
-				budget.extreme,
 			]),
 			totalMonsterXp: totalCreatureXp,
 			thresholds,
@@ -423,11 +454,9 @@ export function calculateEncounterDifficulty(
 			{ label: "High", value: budget.high },
 		];
 		return {
-			tier: determineTier(totalMonsterXp, [
-				budget.low,
-				budget.moderate,
-				budget.high,
-			]),
+			// 5.5e has no tier below Low, so tier 0 (empty bars) only at 0 XP.
+			// The High budget is display-only: anything over Moderate is High.
+			tier: tierFromBudgets(totalMonsterXp, [0, budget.low, budget.moderate]),
 			totalMonsterXp,
 			thresholds,
 			encounterMultiplier: undefined,
@@ -450,7 +479,7 @@ export function calculateEncounterDifficulty(
 	];
 
 	return {
-		tier: determineTier(adjustedXp, [
+		tier: tierFromThresholds(adjustedXp, [
 			budget.medium,
 			budget.hard,
 			budget.deadly,

packages/domain/src/events.ts

@@ -1,6 +1,6 @@
 import type { ConditionId } from "./conditions.js";
 import type { CreatureId } from "./creature-types.js";
-import type { PersistentDamageType } from "./persistent-damage.js";
+import type { PersistentDamageType } from "./persistent-damage-types.js";
 import type { PlayerCharacterId } from "./player-character-types.js";
 import type { CombatantId } from "./types.js";
 
@@ -152,6 +152,14 @@ export interface CreatureAdjustmentSet {
 	readonly adjustment: "weak" | "elite" | undefined;
 }
 
+export interface HpVariantSet {
+	readonly type: "HpVariantSet";
+	readonly combatantId: CombatantId;
+	readonly variant: "min" | "max" | undefined;
+	readonly previousMaxHp: number | undefined;
+	readonly newMaxHp: number | undefined;
+}
+
 export interface EncounterCleared {
 	readonly type: "EncounterCleared";
 	readonly combatantCount: number;
@@ -198,6 +206,7 @@ export type DomainEvent =
 	| PersistentDamageAdded
 	| PersistentDamageRemoved
 	| CreatureAdjustmentSet
+	| HpVariantSet
 	| EncounterCleared
 	| PlayerCharacterCreated
 	| PlayerCharacterUpdated

packages/domain/src/hp-range.ts

@@ -0,0 +1,58 @@
+/** Which end of a creature's Hit Dice range its max HP is taken from. */
+export type HpVariant = "min" | "max";
+
+export const VALID_HP_VARIANTS: ReadonlySet<string> = new Set(["min", "max"]);
+
+export interface HpRange {
+	/** Every Hit Die rolls a 1 (never below 1 HP). */
+	readonly min: number;
+	/** The statblock's printed average. */
+	readonly average: number;
+	/** Every Hit Die rolls its maximum. */
+	readonly max: number;
+}
+
+/**
+ * Matches a plain Hit Dice pool: "9d8", "3d6 + 6", "2d6 - 2".
+ * Bestiary data uses several dash characters, so hyphen, minus sign, en dash
+ * and em dash all count as a negative modifier.
+ */
+const DICE_FORMULA_REGEX =
+	/^\s*(\d+)\s*[dD]\s*(\d+)\s*(?:([-+−–—])\s*(\d+))?\s*$/;
+
+/**
+ * Derives the min/average/max HP of a creature from its Hit Dice formula.
+ * Returns null when the formula is not a plain dice pool — some sources carry
+ * prose (`hp.special`) or an empty string instead.
+ */
+export function hpRange(
+	hp: Readonly<{ average: number; formula: string }>,
+): HpRange | null {
+	const match = DICE_FORMULA_REGEX.exec(hp.formula);
+	if (!match) return null;
+
+	const count = Number(match[1]);
+	const sides = Number(match[2]);
+	if (count < 1 || sides < 1) return null;
+
+	const modifier =
+		match[4] === undefined
+			? 0
+			: (match[3] === "+" ? 1 : -1) * Number.parseInt(match[4], 10);
+
+	return {
+		min: Math.max(1, count + modifier),
+		average: hp.average,
+		max: Math.max(1, count * sides + modifier),
+	};
+}
+
+/** The HP value a variant selects; undefined means the printed average. */
+export function hpForVariant(
+	range: HpRange,
+	variant: HpVariant | undefined,
+): number {
+	if (variant === "min") return range.min;
+	if (variant === "max") return range.max;
+	return range.average;
+}

packages/domain/src/index.ts

@@ -82,6 +82,7 @@ export type {
 	CurrentHpAdjusted,
 	DomainEvent,
 	EncounterCleared,
+	HpVariantSet,
 	InitiativeSet,
 	MaxHpSet,
 	PersistentDamageAdded,
@@ -97,6 +98,13 @@ export type {
 	TurnRetreated,
 } from "./events.js";
 export type { ExportBundle } from "./export-bundle.js";
+export {
+	type HpRange,
+	type HpVariant,
+	hpForVariant,
+	hpRange,
+	VALID_HP_VARIANTS,
+} from "./hp-range.js";
 export { deriveHpStatus, type HpStatus } from "./hp-status.js";
 export {
 	calculateInitiative,
@@ -153,6 +161,10 @@ export type { RulesEdition } from "./rules-edition.js";
 export { type SetAcSuccess, setAc } from "./set-ac.js";
 export { type SetCrSuccess, setCr } from "./set-cr.js";
 export { type SetHpSuccess, setHp } from "./set-hp.js";
+export {
+	type SetHpVariantSuccess,
+	setHpVariant,
+} from "./set-hp-variant.js";
 export {
 	type SetInitiativeSuccess,
 	setInitiative,

packages/domain/src/persistent-damage-types.ts

@@ -0,0 +1,78 @@
+export const PERSISTENT_DAMAGE_TYPES = [
+	"fire",
+	"bleed",
+	"acid",
+	"cold",
+	"electricity",
+	"poison",
+	"mental",
+	"force",
+	"void",
+	"spirit",
+	"vitality",
+	"piercing",
+] as const;
+
+export type PersistentDamageType = (typeof PERSISTENT_DAMAGE_TYPES)[number];
+
+export const VALID_PERSISTENT_DAMAGE_TYPES: ReadonlySet<string> = new Set(
+	PERSISTENT_DAMAGE_TYPES,
+);
+
+export interface PersistentDamageEntry {
+	readonly type: PersistentDamageType;
+	readonly formula: string;
+}
+
+export interface PersistentDamageDefinition {
+	readonly type: PersistentDamageType;
+	readonly label: string;
+	readonly iconName: string;
+	readonly color: string;
+}
+
+export const PERSISTENT_DAMAGE_DEFINITIONS: readonly PersistentDamageDefinition[] =
+	[
+		{ type: "fire", label: "Fire", iconName: "Flame", color: "orange" },
+		{ type: "bleed", label: "Bleed", iconName: "Droplets", color: "red" },
+		{
+			type: "acid",
+			label: "Acid",
+			iconName: "FlaskConical",
+			color: "lime",
+		},
+		{ type: "cold", label: "Cold", iconName: "Snowflake", color: "sky" },
+		{
+			type: "electricity",
+			label: "Electricity",
+			iconName: "Zap",
+			color: "yellow",
+		},
+		{
+			type: "poison",
+			label: "Poison",
+			iconName: "Droplet",
+			color: "green",
+		},
+		{
+			type: "mental",
+			label: "Mental",
+			iconName: "BrainCog",
+			color: "pink",
+		},
+		{ type: "force", label: "Force", iconName: "Orbit", color: "indigo" },
+		{ type: "void", label: "Void", iconName: "Eclipse", color: "purple" },
+		{ type: "spirit", label: "Spirit", iconName: "Wind", color: "neutral" },
+		{
+			type: "vitality",
+			label: "Vitality",
+			iconName: "Sparkle",
+			color: "amber",
+		},
+		{
+			type: "piercing",
+			label: "Piercing",
+			iconName: "Sword",
+			color: "neutral",
+		},
+	];

packages/domain/src/persistent-damage.ts

@@ -1,4 +1,10 @@
 import type { DomainEvent } from "./events.js";
+import {
+	PERSISTENT_DAMAGE_DEFINITIONS,
+	type PersistentDamageEntry,
+	type PersistentDamageType,
+	VALID_PERSISTENT_DAMAGE_TYPES,
+} from "./persistent-damage-types.js";
 import {
 	type CombatantId,
 	type DomainError,
@@ -7,84 +13,14 @@ import {
 	isDomainError,
 } from "./types.js";
 
-export const PERSISTENT_DAMAGE_TYPES = [
-	"fire",
-	"bleed",
-	"acid",
-	"cold",
-	"electricity",
-	"poison",
-	"mental",
-	"force",
-	"void",
-	"spirit",
-	"vitality",
-	"piercing",
-] as const;
-
-export type PersistentDamageType = (typeof PERSISTENT_DAMAGE_TYPES)[number];
-
-export const VALID_PERSISTENT_DAMAGE_TYPES: ReadonlySet<string> = new Set(
+export {
+	PERSISTENT_DAMAGE_DEFINITIONS,
 	PERSISTENT_DAMAGE_TYPES,
-);
-
-export interface PersistentDamageEntry {
-	readonly type: PersistentDamageType;
-	readonly formula: string;
-}
-
-export interface PersistentDamageDefinition {
-	readonly type: PersistentDamageType;
-	readonly label: string;
-	readonly iconName: string;
-	readonly color: string;
-}
-
-export const PERSISTENT_DAMAGE_DEFINITIONS: readonly PersistentDamageDefinition[] =
-	[
-		{ type: "fire", label: "Fire", iconName: "Flame", color: "orange" },
-		{ type: "bleed", label: "Bleed", iconName: "Droplets", color: "red" },
-		{
-			type: "acid",
-			label: "Acid",
-			iconName: "FlaskConical",
-			color: "lime",
-		},
-		{ type: "cold", label: "Cold", iconName: "Snowflake", color: "sky" },
-		{
-			type: "electricity",
-			label: "Electricity",
-			iconName: "Zap",
-			color: "yellow",
-		},
-		{
-			type: "poison",
-			label: "Poison",
-			iconName: "Droplet",
-			color: "green",
-		},
-		{
-			type: "mental",
-			label: "Mental",
-			iconName: "BrainCog",
-			color: "pink",
-		},
-		{ type: "force", label: "Force", iconName: "Orbit", color: "indigo" },
-		{ type: "void", label: "Void", iconName: "Eclipse", color: "purple" },
-		{ type: "spirit", label: "Spirit", iconName: "Wind", color: "neutral" },
-		{
-			type: "vitality",
-			label: "Vitality",
-			iconName: "Sparkle",
-			color: "amber",
-		},
-		{
-			type: "piercing",
-			label: "Piercing",
-			iconName: "Sword",
-			color: "neutral",
-		},
-	];
+	type PersistentDamageDefinition,
+	type PersistentDamageEntry,
+	type PersistentDamageType,
+	VALID_PERSISTENT_DAMAGE_TYPES,
+} from "./persistent-damage-types.js";
 
 export interface PersistentDamageSuccess {
 	readonly encounter: Encounter;

packages/domain/src/rehydrate-combatant.ts

@@ -2,8 +2,10 @@ import type { ConditionEntry, ConditionId } from "./conditions.js";
 import { VALID_CONDITION_IDS } from "./conditions.js";
 import { creatureId } from "./creature-types.js";
 import { VALID_CR_VALUES } from "./encounter-difficulty.js";
-import type { PersistentDamageEntry } from "./persistent-damage.js";
-import { VALID_PERSISTENT_DAMAGE_TYPES } from "./persistent-damage.js";
+import type { HpVariant } from "./hp-range.js";
+import { VALID_HP_VARIANTS } from "./hp-range.js";
+import type { PersistentDamageEntry } from "./persistent-damage-types.js";
+import { VALID_PERSISTENT_DAMAGE_TYPES } from "./persistent-damage-types.js";
 import {
 	playerCharacterId,
 	VALID_PLAYER_COLORS,
@@ -144,6 +146,9 @@ function parseOptionalFields(entry: Record<string, unknown>) {
 			entry.creatureAdjustment,
 			VALID_ADJUSTMENTS,
 		) as "weak" | "elite" | undefined,
+		hpVariant: validateSetMember(entry.hpVariant, VALID_HP_VARIANTS) as
+			| HpVariant
+			| undefined,
 		cr: validateCr(entry.cr),
 		side: validateSide(entry.side),
 		color: validateSetMember(entry.color, VALID_PLAYER_COLORS),

packages/domain/src/set-hp-variant.ts

@@ -0,0 +1,73 @@
+import type { DomainEvent } from "./events.js";
+import { type HpRange, type HpVariant, hpForVariant } from "./hp-range.js";
+import {
+	type CombatantId,
+	type DomainError,
+	type Encounter,
+	findCombatant,
+	isDomainError,
+} from "./types.js";
+
+export interface SetHpVariantSuccess {
+	readonly encounter: Encounter;
+	readonly events: DomainEvent[];
+}
+
+/**
+ * Switches a combatant's max HP between the minimum, average and maximum roll
+ * of its Hit Dice.
+ *
+ * The shift is applied as a delta so manual HP edits and damage already taken
+ * survive the switch: a creature missing 5 HP still misses 5 HP afterwards.
+ */
+export function setHpVariant(
+	encounter: Encounter,
+	combatantId: CombatantId,
+	variant: HpVariant | undefined,
+	range: HpRange,
+): SetHpVariantSuccess | DomainError {
+	const found = findCombatant(encounter, combatantId);
+	if (isDomainError(found)) return found;
+
+	const { combatant } = found;
+	if (combatant.hpVariant === variant) {
+		return { encounter, events: [] };
+	}
+
+	const delta =
+		hpForVariant(range, variant) - hpForVariant(range, combatant.hpVariant);
+
+	const newMaxHp =
+		combatant.maxHp === undefined
+			? undefined
+			: Math.max(1, combatant.maxHp + delta);
+	const newCurrentHp =
+		combatant.currentHp === undefined || newMaxHp === undefined
+			? combatant.currentHp
+			: Math.max(0, Math.min(combatant.currentHp + delta, newMaxHp));
+
+	return {
+		encounter: {
+			...encounter,
+			combatants: encounter.combatants.map((c) =>
+				c.id === combatantId
+					? {
+							...c,
+							maxHp: newMaxHp,
+							currentHp: newCurrentHp,
+							hpVariant: variant,
+						}
+					: c,
+			),
+		},
+		events: [
+			{
+				type: "HpVariantSet",
+				combatantId,
+				variant,
+				previousMaxHp: combatant.maxHp,
+				newMaxHp,
+			},
+		],
+	};
+}

packages/domain/src/types.ts

@@ -7,7 +7,8 @@ export function combatantId(id: string): CombatantId {
 
 import type { ConditionEntry } from "./conditions.js";
 import type { CreatureId } from "./creature-types.js";
-import type { PersistentDamageEntry } from "./persistent-damage.js";
+import type { HpVariant } from "./hp-range.js";
+import type { PersistentDamageEntry } from "./persistent-damage-types.js";
 import type { PlayerCharacterId } from "./player-character-types.js";
 
 export interface Combatant {
@@ -23,6 +24,7 @@ export interface Combatant {
 	readonly isConcentrating?: boolean;
 	readonly creatureId?: CreatureId;
 	readonly creatureAdjustment?: "weak" | "elite";
+	readonly hpVariant?: HpVariant;
 	readonly cr?: string;
 	readonly side?: "party" | "enemy";
 	readonly color?: string;

pnpm-workspace.yaml

@@ -4,3 +4,8 @@ packages:
 
 onlyBuiltDependencies:
   - lefthook
+
+# pnpm >= 10.32 reads overrides/auditConfig from here; the "pnpm" field in
+# package.json is no longer honoured.
+overrides:
+  picomatch: ">=4.0.4"

scripts/check-gates.mjs

@@ -0,0 +1,83 @@
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const ROOT = new URL("..", import.meta.url).pathname.replace(/\/$/, "");
+const RUN_LINE_RE = /^\s*run:\s*(.+?)\s*$/;
+
+/** @param {string} path */
+const read = (path) => readFileSync(join(ROOT, path), "utf-8");
+
+/**
+ * Gates must invoke `pnpm oxlint` with no extra arguments: pnpm forwards them
+ * after `--`, where oxlint reads them as file paths and lints nothing.
+ * @param {Record<string, string>} scripts
+ */
+function findGatesWithOwnFlags(scripts) {
+	const commands = Object.entries(scripts)
+		.filter(([name]) => name !== "oxlint")
+		.flatMap(([name, body]) =>
+			body.split("&&").map((c) => [`scripts.${name}`, c.trim()]),
+		);
+	for (const line of read("lefthook.yml").split("\n")) {
+		const command = RUN_LINE_RE.exec(line)?.[1];
+		if (command) commands.push(["lefthook.yml", command]);
+	}
+	return commands
+		.filter(([, c]) => c.includes("oxlint") && c !== "pnpm oxlint")
+		.map(([source, c]) => `${source} runs "${c}" instead of "pnpm oxlint"`);
+}
+
+/**
+ * Runs the configured command with one rule forced to warn. A working gate
+ * exits non-zero; exiting 0 means it lints nothing, or does not fail on
+ * warnings.
+ * @param {string} oxlintScript
+ */
+function failsOnWarnings(oxlintScript) {
+	const args = [...oxlintScript.split(" ").slice(1), "-W", "no-console"];
+	try {
+		execFileSync(join(ROOT, "node_modules/.bin/oxlint"), args, {
+			cwd: ROOT,
+			stdio: "ignore",
+		});
+		return false;
+	} catch {
+		return true;
+	}
+}
+
+/**
+ * Reports ways a quality gate could pass without checking anything, which is
+ * indistinguishable from a clean run.
+ * @returns {string[]}
+ */
+export function checkGates() {
+	/** @type {Record<string, string>} */
+	const scripts = JSON.parse(read("package.json")).scripts;
+	const violations = findGatesWithOwnFlags(scripts);
+
+	// Vitest defaults to failing when no test file matches. Setting this puts
+	// the test gate back to exiting 0 if the include globs ever stop matching.
+	if (read("vitest.config.ts").includes("passWithNoTests")) {
+		violations.push("vitest.config.ts sets passWithNoTests");
+	}
+
+	// jscpd's pattern is a single glob string. An array matches no files, and
+	// the run then reports success having read nothing.
+	if (Array.isArray(JSON.parse(read(".jscpd.json")).pattern)) {
+		violations.push(".jscpd.json sets pattern to an array, not a glob string");
+	}
+
+	// The canary rule below is not type-aware, so the probe alone cannot
+	// detect type-aware rules being switched off.
+	if (!scripts.oxlint.includes("--type-aware")) {
+		violations.push("scripts.oxlint is missing --type-aware");
+	}
+	if (!failsOnWarnings(scripts.oxlint)) {
+		violations.push(
+			`scripts.oxlint exits 0 despite no-console violations: "${scripts.oxlint}"`,
+		);
+	}
+	return violations;
+}

scripts/check-layer-boundaries.mjs

@@ -63,7 +63,7 @@ function checkFile(file, forbidden) {
 	const lines = content.split("\n");
 
 	for (let i = 0; i < lines.length; i++) {
-		const match = lines[i].match(IMPORT_RE);
+		const match = IMPORT_RE.exec(lines[i]);
 		if (!match) continue;
 
 		const importPath = match[1] || match[2];

scripts/check-lint-ignores.mjs

@@ -23,7 +23,7 @@ for (const file of findFiles()) {
 	const lines = readFileSync(file, "utf-8").split("\n");
 
 	for (let i = 0; i < lines.length; i++) {
-		const match = lines[i].match(IGNORE_PATTERN);
+		const match = IGNORE_PATTERN.exec(lines[i]);
 		if (!match) continue;
 
 		count++;

scripts/generate-bestiary-index.mjs

@@ -108,6 +108,7 @@ const files = readdirSync(BESTIARY_DIR).filter(
 );
 
 const creatures = [];
+/** @type {Set<string>} */
 const unmappedSources = new Set();
 
 for (const file of files.sort()) {

specs/004-bestiary/spec.md

@@ -118,6 +118,11 @@ As a DM running a PF2e encounter, I want to toggle a weak or elite adjustment on
 
 When viewing a PF2e creature's stat block, a Weak/Normal/Elite toggle appears in the header. Selecting "Elite" or "Weak" applies the standard PF2e adjustments: ±2 to AC, saves, Perception, attack rolls, and strike damage; HP adjusted by the standard level bracket table; level shifted. The combatant's stored HP and AC update accordingly (see `specs/003-combatant-state/spec.md`, FR-113–FR-116), and its name gains a prefix (see `specs/001-combatant-management/spec.md`, FR-041–FR-042). The toggle defaults to "Normal" and is not shown for D&D creatures. A visual indicator (the same icon used in the toggle) appears next to the creature name in the header.
 
+**US-D8 — Set a D&D Combatant to Minimum or Maximum Hit Points (P2)**
+As a DM running a D&D encounter, I want to switch a bestiary-linked combatant between the minimum, average and maximum result of its Hit Dice so I can make a single monster tougher or flimsier without hand-editing HP.
+
+When viewing a D&D creature's stat block for a combatant, a Min/Avg/Max toggle appears under the Hit Points line. The stat block shows the printed average by default; selecting "Min" or "Max" shows the value the Hit Dice would produce if every die rolled its lowest or highest face (e.g., `3d6 + 6` → 9 or 24) and updates the combatant's stored max HP by the same delta. This is a convenience tool, not a rules mechanic — no other stat changes and the combatant is not renamed.
+
 ### Requirements
 
 - **FR-016**: The system MUST display a stat block panel with full creature information when a creature is selected.
@@ -151,6 +156,12 @@ When viewing a PF2e creature's stat block, a Weak/Normal/Elite toggle appears in
 - **FR-106**: Toggling the adjustment MUST update the combatant's name with the appropriate prefix — "Weak" or "Elite" — or remove the prefix when returning to "Normal" (see `specs/001-combatant-management/spec.md`, FR-041–FR-042).
 - **FR-107**: The stat block header MUST display a visual indicator (the same icon used in the toggle) next to the creature name when the creature has a weak or elite adjustment.
 - **FR-108**: The adjustment MUST be stored on the combatant as a `creatureAdjustment` field and persist across page reloads.
+- **FR-109**: D&D stat blocks MUST include a Min/Avg/Max hit point toggle below the Hit Points line, defaulting to "Avg".
+- **FR-110**: The Min/Avg/Max toggle MUST only be shown for a bestiary-linked combatant whose HP formula is a plain Hit Dice pool (`NdM`, optionally `± K`) with a spread — it MUST NOT be shown while browsing a creature without a combatant, for PF2e creatures, or when the HP field carries prose instead of dice.
+- **FR-111**: "Min" MUST use the result of every Hit Die rolling 1 (dice count + modifier); "Max" MUST use the result of every Hit Die rolling its highest face (dice count × faces + modifier). Both MUST be at least 1. "Avg" MUST use the printed average.
+- **FR-112**: Selecting a variant MUST shift the combatant's stored maxHp by the delta between the previously selected and newly selected value, preserving manual HP edits. The combatant's currentHp MUST shift by the same delta, clamped to [0, new maxHp].
+- **FR-113**: Selecting a variant MUST NOT change the combatant's name or any stat other than HP.
+- **FR-114**: The selected variant MUST be stored on the combatant as an `hpVariant` field (`"min" | "max"`, absent for average) and persist across page reloads and JSON export/import.
 
 ### Acceptance Scenarios
 
@@ -194,6 +205,11 @@ When viewing a PF2e creature's stat block, a Weak/Normal/Elite toggle appears in
 38. **Given** a PF2e creature with level 1 stat block is open, **When** the DM selects "Weak", **Then** the level decreases by 2 (to −1, not 0).
 39. **Given** a PF2e combatant was set to "Elite" and the page is reloaded, **When** the DM opens the stat block, **Then** the toggle shows "Elite" and the stat block displays adjusted stats.
 40. **Given** a PF2e combatant was set to "Elite", **When** the DM toggles back to "Normal", **Then** the stat block reverts to base stats, the combatant's HP/AC revert, and the name prefix is removed.
+41. **Given** a D&D combatant's stat block is open, **When** the DM views the Hit Points line, **Then** a Min/Avg/Max toggle is visible, set to "Avg".
+42. **Given** a D&D combatant with `3d6 + 6` hit points (average 16) is at full health, **When** the DM selects "Max", **Then** the stat block shows 24 hit points and the combatant's HP becomes 24/24.
+43. **Given** the same combatant, **When** the DM selects "Min", **Then** the stat block shows 9 hit points and the combatant's HP becomes 9/9.
+44. **Given** a D&D combatant set to "Max" has taken 5 damage (19/24), **When** the DM selects "Avg", **Then** the combatant's HP becomes 11/16 — the damage taken is preserved.
+45. **Given** a D&D combatant was set to "Max" and the page is reloaded, **When** the DM opens the stat block, **Then** the toggle shows "Max" and the maximum hit points are displayed.
 
 ### Edge Cases
 
@@ -216,6 +232,11 @@ When viewing a PF2e creature's stat block, a Weak/Normal/Elite toggle appears in
 - Attack with multiple on-hit effects (e.g., `["grab", "knockdown"]`): all effects shown, joined with "and" (e.g., "plus Grab and Knockdown").
 - Attack effect slug with creature-name prefix (e.g., `"lich-siphon-life"` on a Lich): the creature-name prefix is stripped, rendering as "Siphon Life".
 - Frequency `per` value variations (e.g., "day", "round", "turn"): the value is rendered as-is in the "(N/per)" format.
+- HP formula that is not a dice pool (empty, prose such as "equal to the summoner's", or a flat number): the Min/Avg/Max toggle is omitted and the printed average is shown unchanged.
+- HP formula written with an en dash or em dash instead of a hyphen (present in bundled source data, e.g. `2d6 – 2`): parsed as a negative modifier.
+- Hit Dice modifier larger than the dice pool (e.g. `1d4 - 10`): the resulting hit points are floored at 1.
+- Toggling from Min to Max: applies the full swing in a single operation.
+- Combatant whose max HP was edited by hand before toggling: the edit is preserved as an offset, since the toggle applies the delta between variants rather than an absolute value.
 
 ---
 
@@ -396,7 +417,7 @@ As a DM with a creature pinned, I want to collapse the right (browse) panel inde
 - **Source** (`BestiarySource`): A D&D or PF2e publication identified by a code (e.g., "XMM") with a display name (e.g., "Monster Manual (2025)"). Caching and fetching operate at the source level.
 - **Creature (Full)** (`Creature`): A complete creature record with all stat block data (traits, actions, legendary actions, spellcasting, etc.), available only after source data is fetched/uploaded and cached. Identified by a branded `CreatureId`. For PF2e creatures, each spell entry inside `spellcasting` carries full per-spell data (slug, level, traits, range, action cost, target/area, duration, defense, description, heightening) extracted from the embedded `items[type=spell]` data on the source NPC, enabling inline spell description display without additional fetches. PF2e creatures also carry an `equipment` list of carried items (weapons, consumables) extracted from `items[type=weapon]` and `items[type=consumable]` entries, each with name, level, traits, description, and (for scrolls) embedded spell data. PF2e attack entries carry an optional `attackEffects` list of on-hit effect names. PF2e ability entries carry an optional `frequency` with `max` and `per` fields. PF2e creature perception carries an optional `details` string (e.g., "smoke vision").
 - **Cached Source Data**: The full normalized bestiary data for a single source, stored in IndexedDB. Contains complete creature stat blocks.
-- **Combatant** (extended): Gains an optional `creatureId` reference to a `Creature`, enabling stat block lookup and stat pre-fill on creation. PF2e bestiary-linked combatants may also carry a `creatureAdjustment` (`"weak" | "elite"`) indicating the active PF2e weak/elite adjustment, persisted across reloads.
+- **Combatant** (extended): Gains an optional `creatureId` reference to a `Creature`, enabling stat block lookup and stat pre-fill on creation. PF2e bestiary-linked combatants may also carry a `creatureAdjustment` (`"weak" | "elite"`) indicating the active PF2e weak/elite adjustment, persisted across reloads. D&D bestiary-linked combatants may carry an `hpVariant` (`"min" | "max"`) indicating that their max HP was set to the lowest or highest possible Hit Dice result instead of the printed average, likewise persisted across reloads.
 - **Queued Creature**: Transient UI-only state representing a bestiary creature selected for batch-add, containing the creature reference and a count (1+). Not persisted.
 - **Bulk Import Operation**: Tracks total sources, completed count, failed count, and current status (idle / loading / complete / partial-failure).
 - **Toast Notification**: Lightweight custom UI element at bottom-center of screen with text, optional progress bar, and optional dismiss button.

specs/008-encounter-difficulty/spec.md

@@ -3,7 +3,7 @@
 **Feature Branch**: `008-encounter-difficulty`
 **Created**: 2026-03-27
 **Status**: Draft
-**Input**: Gitea issue #18 — "Encounter difficulty indicator (5.5e XP budget)", Gitea issue #22 — "Combatant side assignment for encounter difficulty", Gitea issue #23 — "2014 DMG encounter difficulty calculation"
+**Input**: Gitea issue #18 — "Encounter difficulty indicator (5.5e XP budget)", Gitea issue #22 — "Combatant side assignment for encounter difficulty", Gitea issue #23 — "2014 DMG encounter difficulty calculation", Gitea issue #28 — "PF2e encounter difficulty calculation"
 
 ## User Scenarios & Testing *(mandatory)*
 
@@ -19,15 +19,15 @@ A game master is building an encounter by adding monsters and player characters.
 
 **Acceptance Scenarios**:
 
-1. **Given** an encounter with at least one PC combatant whose player character has a level and at least one bestiary-linked combatant, **When** the total monster XP is below the Low threshold, **Then** the indicator shows three empty bars (trivial difficulty).
+1. **Given** an encounter with at least one PC combatant whose player character has a level and at least one bestiary-linked combatant, **When** the total monster XP is 0, **Then** the indicator shows three empty bars (the 2024 rules define no tier below Low, so empty bars appear only at 0 XP).
 
-2. **Given** an encounter where total monster XP meets or exceeds the Low threshold but is below Moderate, **When** the indicator renders, **Then** it shows one filled green bar and the tooltip reads "Low encounter difficulty".
+2. **Given** an encounter where total monster XP is greater than 0 and within the Low budget, **When** the indicator renders, **Then** it shows one filled green bar and the tooltip reads "Low encounter difficulty".
 
-3. **Given** an encounter where total monster XP meets or exceeds the Moderate threshold but is below High, **When** the indicator renders, **Then** it shows two filled yellow bars and the tooltip reads "Moderate encounter difficulty".
+3. **Given** an encounter where total monster XP exceeds the Low budget but is within the Moderate budget, **When** the indicator renders, **Then** it shows two filled yellow bars and the tooltip reads "Moderate encounter difficulty".
 
-4. **Given** an encounter where total monster XP meets or exceeds the High threshold, **When** the indicator renders, **Then** it shows three filled red bars and the tooltip reads "High encounter difficulty".
+4. **Given** an encounter where total monster XP exceeds the Moderate budget, **When** the indicator renders, **Then** it shows three filled red bars and the tooltip reads "High encounter difficulty" (per the 2024 DMG, budgets are maximums — an encounter over the Moderate budget is a High encounter even if it is below the High budget).
 
-5. **Given** an encounter where total monster XP exceeds the High threshold by a large margin, **When** the indicator renders, **Then** it still shows three filled red bars (High is the cap — there is no "above High" tier).
+5. **Given** an encounter where total monster XP exceeds the High budget by a large margin, **When** the indicator renders, **Then** it still shows three filled red bars (High is the cap — there is no "above High" tier).
 
 6. **Given** the difficulty indicator is visible, **When** a bestiary-linked combatant is added or removed, **Then** the indicator updates immediately to reflect the new difficulty tier.
 
@@ -39,6 +39,12 @@ A game master is building an encounter by adding monsters and player characters.
 
 10. **Given** the user switches the rules edition in settings, **When** returning to the encounter, **Then** the indicator tooltip reflects the new edition's labels immediately.
 
+11. **Given** the rules edition is set to PF2e, **When** the indicator renders, **Then** it displays four bars instead of three, supporting five visual states: zero filled bars for Trivial, one green bar for Low, two yellow bars for Moderate, three orange bars for Severe, four red bars for Extreme.
+
+12. **Given** the rules edition is set to PF2e, **When** the indicator tooltip renders, **Then** it uses PF2e tier labels (e.g., "Severe encounter difficulty").
+
+13. **Given** the user switches the rules edition to or from PF2e, **When** returning to the encounter, **Then** the indicator bar count (3 vs 4) and tier labels update immediately.
+
 ---
 
 ### Indicator Visibility
@@ -63,6 +69,10 @@ The difficulty indicator only appears when meaningful calculation is possible. I
 
 5. **Given** an encounter with one leveled PC combatant and one bestiary-linked monster, **When** the last bestiary-linked monster is removed and the remaining custom combatants have no `cr` assigned, **Then** the indicator disappears.
 
+6. **Given** the rules edition is set to PF2e and an encounter has leveled PC combatants and creatures with a creature level (from bestiary data), **When** the top bar renders, **Then** the difficulty indicator is shown. CR is not required — PF2e uses creature level, not CR.
+
+7. **Given** the rules edition is set to PF2e and an encounter has bestiary-linked PF2e creatures but no PC combatants with levels, **When** the top bar renders, **Then** the difficulty indicator is hidden.
+
 ---
 
 ### Player Character Level
@@ -93,7 +103,7 @@ The game master can set an optional level (1-20) when creating or editing a play
 
 **Story ED-4 — Correct XP budget from 5.5e rules (Priority: P1)**
 
-The difficulty calculation uses the 2024 5.5e XP Budget per Character table and a standard CR-to-XP mapping. The party's XP budget is the sum of per-character budgets for each PC combatant that has a level. The total monster XP is the sum of XP values for each bestiary-linked combatant's CR. The difficulty tier is determined by comparing total monster XP against the Low, Moderate, and High budget thresholds.
+The difficulty calculation uses the 2024 5.5e XP Budget per Character table and a standard CR-to-XP mapping. The party's XP budget is the sum of per-character budgets for each PC combatant that has a level. The total monster XP is the sum of XP values for each bestiary-linked combatant's CR. The difficulty tier is determined by comparing total monster XP against the Low, Moderate, and High budgets, where each budget is the tier's maximum ("spend as much of your XP budget as you can without going over" — 2024 DMG).
 
 **Why this priority**: Incorrect calculation would make the feature misleading — the math must match the published rules.
 
@@ -101,9 +111,9 @@ The difficulty calculation uses the 2024 5.5e XP Budget per Character table and
 
 **Acceptance Scenarios**:
 
-1. **Given** a party of four level 1 PCs (Low budget: 50 each = 200 total), **When** facing a single Bugbear (CR 1, 200 XP), **Then** the difficulty is Low (200 XP meets the Low threshold of 200 but is below Moderate at 300).
+1. **Given** a party of four level 1 PCs (Low budget: 50 each = 200 total), **When** facing a single Bugbear (CR 1, 200 XP), **Then** the difficulty is Low (200 XP spends exactly the Low budget without going over).
 
-2. **Given** a party of five level 3 PCs (Moderate budget: 225 each = 1,125 total), **When** facing monsters totaling 1,125 XP, **Then** the difficulty is Moderate.
+2. **Given** a party of five level 3 PCs (Moderate budget: 225 each = 1,125 total), **When** facing monsters totaling 1,125 XP, **Then** the difficulty is Moderate. **When** facing monsters totaling 1,150 XP (over the Moderate budget), **Then** the difficulty is High.
 
 3. **Given** a party with PCs at different levels (e.g., three level 3 and one level 2), **When** the budget is calculated, **Then** each PC's budget is looked up individually by level and summed (not averaged).
 
@@ -151,6 +161,12 @@ The game master taps the difficulty indicator to open a breakdown panel. The pan
 
 9. **Given** the rules edition is set to 5e (2014) and the breakdown panel is open, **When** viewing the party budget section, **Then** the panel shows four threshold columns (Easy, Medium, Hard, Deadly) instead of three (Low, Moderate, High).
 
+10. **Given** the rules edition is set to PF2e and the breakdown panel is open, **When** viewing the creature list, **Then** each creature shows its level, level difference from party level, and XP contribution — not CR.
+
+11. **Given** the rules edition is set to PF2e and the breakdown panel is open, **When** viewing the party budget section, **Then** the panel shows five threshold columns (Trivial/Low/Moderate/Severe/Extreme) and indicates the derived party level.
+
+12. **Given** the rules edition is set to PF2e and the party size differs from 4, **When** the breakdown panel is open, **Then** the panel shows the adjusted thresholds and a brief explanation of the party size adjustment.
+
 ---
 
 ### Manual CR Assignment
@@ -253,10 +269,46 @@ A game master who runs games using the 2014 (original 5e) rules selects "5e (201
 
 ---
 
+### PF2e Rules Edition
+
+**Story ED-10 — PF2e encounter difficulty calculation (Priority: P2)**
+
+A game master running Pathfinder 2e selects "Pathfinder 2e" in the Rules Edition setting. The difficulty indicator uses PF2e's level-based calculation: each creature's XP contribution is determined by its level relative to the party level using a standard XP table, and the total is compared against Trivial/Low/Moderate/Severe/Extreme budget thresholds. Party level is auto-derived from the PCs' levels. No encounter multiplier is used — creature XP is summed directly.
+
+**Why this priority**: The core indicator (ED-1) and 5.5e calculation (ED-4) must work first. PF2e support extends the existing system with a fundamentally different calculation paradigm (level-based instead of CR-based).
+
+**Independent Test**: Can be tested by setting rules edition to PF2e, creating an encounter with leveled PCs and PF2e bestiary creatures, and verifying the indicator uses PF2e thresholds, XP table, and labels.
+
+**Acceptance Scenarios**:
+
+1. **Given** the rules edition is set to PF2e and an encounter has leveled PCs and PF2e bestiary creatures, **When** the difficulty is calculated, **Then** the system derives each creature's XP from the PF2e creature level vs party level XP table and compares the total against Trivial/Low/Moderate/Severe/Extreme thresholds.
+
+2. **Given** a party of four level 3 PCs and a creature at level 3 (level difference 0), **When** the XP is calculated, **Then** the creature contributes 40 XP. The total (40) is within the Trivial band ("40 XP or less") — difficulty is Trivial.
+
+3. **Given** a party of four level 5 PCs and a creature at level 9 (level difference +4), **When** the XP is calculated, **Then** the creature contributes 160 XP. The total (160) exceeds the Severe budget (120) — difficulty is Extreme.
+
+4. **Given** PCs at levels 3, 3, 3, and 5, **When** the party level is derived, **Then** it is 3 (the most common level among PCs).
+
+5. **Given** PCs at levels 2, 4, 6, and 8 (all different), **When** the party level is derived, **Then** it is 5 (the average, rounded to the nearest integer).
+
+6. **Given** a party of 5 PCs (one more than the base of 4) at the Moderate tier, **When** the budget thresholds are calculated, **Then** each threshold is increased by its per-tier adjustment: Trivial +10, Low +20, Moderate +20, Severe +30, Extreme +40.
+
+7. **Given** a party of 3 PCs (one fewer than the base of 4) at the Moderate tier, **When** the budget thresholds are calculated, **Then** each threshold is decreased by its per-tier adjustment: Trivial −10, Low −20, Moderate −20, Severe −30, Extreme −40.
+
+8. **Given** the rules edition is set to PF2e, **When** the indicator visual states are rendered, **Then** 0 bars = Trivial, 1 green bar = Low, 2 yellow bars = Moderate, 3 orange bars = Severe, 4 red bars = Extreme.
+
+9. **Given** the user changes the rules edition from 5.5e to PF2e while an encounter is open, **When** the setting is saved, **Then** the difficulty indicator updates immediately to reflect the PF2e calculation, labels, and 4-bar layout.
+
+10. **Given** the rules edition is set to PF2e and a creature has a level difference below −4, **When** XP is calculated, **Then** the creature contributes 0 XP (the GM Core table has no row below −4; such creatures pose no meaningful threat).
+
+11. **Given** the rules edition is set to PF2e and a creature has a level difference above +4, **When** XP is calculated, **Then** the creature contributes 160 XP (the maximum in the table — level difference +4).
+
+---
+
 ### Edge Cases
 
-- **All bars empty (trivial)**: When total monster XP is greater than 0 but below the Low threshold, the indicator shows three empty bars. This communicates "we can calculate, but it's trivial."
-- **Zero monster XP**: If all combatants with `creatureId` have CR 0 (0 XP), the indicator shows three empty bars (trivial).
+- **All bars empty (5.5e)**: Only when total monster XP is exactly 0 — the 2024 rules define no tier below Low, so any nonzero XP within the Low budget is a Low encounter. (For 2014, adjusted XP below the Easy threshold shows empty bars.)
+- **Zero monster XP**: If all combatants with `creatureId` have CR 0 (0 XP), the indicator shows three empty bars.
 - **Mixed party levels**: PCs at different levels each contribute their own budget — the system handles heterogeneous parties correctly.
 - **Duplicate PC combatants**: If the same player character is added to the encounter multiple times, each copy contributes to the party budget independently (each counts as a party member).
 - **CR fractions**: Bestiary creatures can have fractional CRs (e.g., "1/4", "1/2"). The CR-to-XP lookup must handle these string formats.
@@ -274,6 +326,14 @@ A game master who runs games using the 2014 (original 5e) rules selects "5e (201
 - **2014 multiplier floor (×0.5)**: A single monster with 6+ PCs uses ×0.5 per the 2014 DMG party size adjustment rule.
 - **2014 multiplier ceiling (×5)**: 15+ monsters with fewer than 3 PCs shifts ×4 upward to ×5 per the 2014 DMG party size adjustment rule.
 - **Edition switch with breakdown panel open**: If the breakdown panel is open when the user switches editions in settings, the panel content updates to reflect the new edition's labels, thresholds, and (for 2014) the encounter multiplier.
+- **PF2e creature level outside table range**: A creature more than 4 levels below the party contributes 0 XP (no row in the GM Core table — no meaningful threat). A creature more than 4 levels above the party contributes 160 XP (the +4 row).
+- **PF2e party level derivation — tie in mode**: If two levels are equally common among PCs (e.g., two level 3 and two level 5), the party level is the average of all PC levels, rounded to the nearest integer.
+- **PF2e party level — single PC**: With one PC, the party level equals that PC's level.
+- **PF2e budget thresholds floored at 0**: If party size adjustment would reduce a threshold below 0, it is floored at 0.
+- **PF2e no encounter multiplier**: Unlike D&D 5e (2014), PF2e never applies an encounter multiplier. Total creature XP is used directly.
+- **PF2e creatures without level**: Custom combatants without `creatureId` (and thus no creature level) are excluded from PF2e XP calculation. Only bestiary-linked PF2e creatures with a level contribute.
+- **PF2e 4-bar indicator in edition switch**: When switching from a D&D edition (3 bars) to PF2e (4 bars) or vice versa, the indicator bar count updates immediately along with the tier labels.
+- **PF2e side assignment**: Side assignment (party/enemy) works identically to D&D — enemy-side creatures add XP, party-side creatures subtract XP. Net XP is floored at 0.
 
 ---
 
@@ -294,7 +354,12 @@ The system MUST calculate the party's XP budget by summing the per-character bud
 The system MUST calculate the net monster XP by summing the XP value (derived from CR) for each enemy-side combatant that has a CR and subtracting the XP value for each party-side combatant that has a CR. For bestiary-linked combatants, CR is derived from the creature data via `creatureId`. For custom combatants, CR comes from the optional `cr` field. Combatants with neither `creatureId` nor `cr` are excluded. The net monster XP MUST be floored at 0.
 
 #### FR-005 — Difficulty tier determination
-The system MUST determine the encounter difficulty tier by comparing total monster XP (adjusted XP for 2014) against the party's thresholds. For 5.5e: Low, Moderate, and High (3 tiers). For 2014: Easy, Medium, Hard, and Deadly (4 tiers). The tier is the highest threshold that the total XP meets or exceeds. If below the lowest threshold, the encounter is trivial (5.5e) or easy (2014). The visual indicator maps identically across editions: 0 bars = Trivial/Easy, 1 green = Low/Medium, 2 yellow = Moderate/Hard, 3 red = High/Deadly.
+The system MUST determine the encounter difficulty tier by comparing total monster XP (adjusted XP for 2014) against the party's thresholds. The comparison direction differs by edition, matching each DMG's rules:
+
+- **2014 (Easy/Medium/Hard/Deadly)**: thresholds are floors — "the closest threshold that is lower than the adjusted XP value determines the encounter's difficulty" (2014 DMG). The tier is the highest threshold the adjusted XP meets or exceeds; below the Easy threshold the encounter is effectively trivial (0 bars).
+- **5.5e (Low/Moderate/High)**: budgets are ceilings — "spend as much of your XP budget as you can without going over" (2024 DMG). The tier is the lowest budget the total XP does not exceed: XP within the Low budget is Low, over Low but within Moderate is Moderate, over Moderate is High. The High budget is display-only guidance; it does not gate the High tier. The 2024 rules define no tier below Low, so 0 bars appear only at 0 net XP.
+
+The visual indicator maps identically across editions: 0 bars = 0 XP/Easy, 1 green = Low/Medium, 2 yellow = Moderate/Hard, 3 red = High/Deadly.
 
 #### FR-006 — Difficulty indicator in top bar
 The system MUST display a 3-bar difficulty indicator in the top bar, positioned to the right of the active combatant name.
@@ -321,7 +386,7 @@ The player character create and edit forms MUST include an optional level field
 The player character level MUST be persisted and restored across sessions, consistent with existing player character persistence behavior.
 
 #### FR-014 — High is the cap
-When total monster XP exceeds the High threshold, the indicator MUST display the High state (three red bars). There is no tier above High.
+When total monster XP exceeds the High budget, the indicator MUST display the High state (three red bars). There is no tier above High.
 
 #### FR-015 — Optional CR and side fields on Combatant
 The `Combatant` entity MUST support an optional `cr` field accepting standard 5e challenge rating strings ("0", "1/8", "1/4", "1/2", "1"–"30") and an optional `side` field accepting `"party"` or `"enemy"`.
@@ -377,6 +442,33 @@ Switching the rules edition in settings MUST immediately update the difficulty i
 #### FR-032 — Settings label reflects broader scope
 The settings modal section currently labeled "Conditions" MUST be relabeled to "Rules Edition" to reflect that the edition toggle controls both condition descriptions and difficulty calculation. This supersedes spec 003 FR-096 which scoped the label to conditions only.
 
+#### FR-033 — PF2e creature level-to-XP table
+The system MUST contain the PF2e creature level vs party level XP lookup table: level difference −4=10, −3=15, −2=20, −1=30, 0=40, +1=60, +2=80, +3=120, +4=160. Creatures more than 4 levels below the party have no row in the GM Core table and contribute 0 XP (no meaningful threat). Creatures more than 4 levels above the party are counted as the +4 row (160 XP).
+
+#### FR-034 — PF2e budget thresholds
+The system MUST contain the PF2e encounter budget thresholds for a party of 4: Trivial=40, Low=60, Moderate=80, Severe=120, Extreme=160.
+
+#### FR-035 — PF2e party size budget adjustment
+The system MUST adjust PF2e budget thresholds for party size using the GM Core (remaster) Character Adjustment values. For each PC beyond 4, add per-tier adjustments: Trivial +10, Low +20, Moderate +20, Severe +30, Extreme +40. For each PC fewer than 4, subtract the same amounts. Thresholds are floored at 0. (The pre-remaster Core Rulebook listed Low as 15; this spec follows the remaster.)
+
+#### FR-036 — PF2e party level derivation
+The system MUST derive the party level from PC combatant levels. The party level is the most common (mode) level among PCs with levels. If there is no unique mode (tie or all different), the party level is the average of all PC levels, rounded to the nearest integer.
+
+#### FR-037 — PF2e XP calculation
+The system MUST calculate PF2e encounter XP by summing per-creature XP for all enemy-side bestiary-linked creatures with a level, subtracting per-creature XP for party-side creatures with a level, and flooring the net at 0. No encounter multiplier is applied.
+
+#### FR-038 — PF2e difficulty tier determination
+The system MUST determine the PF2e difficulty tier by comparing total creature XP against the adjusted budget thresholds. The five tiers are Trivial, Low, Moderate, Severe, and Extreme. Budgets are ceilings (GM Core defines Trivial as "40 XP or less"): the tier is the lowest budget the total XP does not exceed — XP within the Trivial budget is Trivial, over Trivial but within Low is Low, and so on; XP over the Severe budget is Extreme. The Extreme budget is display-only guidance; it does not gate the Extreme tier.
+
+#### FR-039 — PF2e 4-bar indicator
+When the rules edition is PF2e, the difficulty indicator MUST display four bars instead of three. Visual states: 0 filled = Trivial, 1 green = Low, 2 yellow = Moderate, 3 orange = Severe, 4 red = Extreme.
+
+#### FR-040 — PF2e breakdown panel content
+When the rules edition is PF2e, the breakdown panel MUST show creature levels and level differences (not CR), per-creature XP based on level difference, the derived party level, and five threshold columns (Trivial/Low/Moderate/Severe/Extreme). Party size adjustments MUST be explained when active.
+
+#### FR-041 — PF2e indicator visibility
+When the rules edition is PF2e, the difficulty indicator MUST be shown when the encounter has at least one PC combatant with a level and at least one bestiary-linked creature with a level. CR is not relevant for PF2e visibility.
+
 ### Key Entities
 
 - **XP Budget Table**: A lookup mapping character level (1-20) to three XP thresholds (Low, Moderate, High), sourced from the 2024 5.5e DMG.
@@ -388,6 +480,9 @@ The settings modal section currently labeled "Conditions" MUST be relabeled to "
 - **Combatant.side**: An optional string field (`"party"` | `"enemy"`) on the existing `Combatant` entity. When undefined, defaults are resolved by the hook layer: PC combatants default to `"party"`, all others to `"enemy"`.
 - **2014 XP Thresholds Table**: A lookup mapping character level (1-20) to four XP thresholds (Easy, Medium, Hard, Deadly), sourced from the 2014 DMG.
 - **EncounterMultiplier**: A lookup mapping monster count ranges to base multiplier values (×1 through ×4), with party size adjustment shifting the multiplier up or down one step (full range ×0.5 through ×5).
+- **PF2e Level Difference XP Table**: A lookup mapping creature level difference from party level (−4 to +4) to XP values (10–160).
+- **PF2e Budget Thresholds**: Base thresholds for a party of 4: Trivial=40, Low=60, Moderate=80, Severe=120, Extreme=160, with per-tier adjustments for party size.
+- **Party Level**: Derived value — the mode of PC levels, or the rounded average when no unique mode exists.
 
 ---
 
@@ -407,6 +502,7 @@ The settings modal section currently labeled "Conditions" MUST be relabeled to "
 - **SC-010**: Party-side combatants with CR correctly subtract their XP from the monster total, and the net XP is never negative.
 - **SC-011**: The 2014 difficulty calculation correctly applies encounter multipliers and party size adjustments per the 2014 DMG rules.
 - **SC-012**: Switching rules edition immediately updates the indicator with no page reload required.
+- **SC-013**: The PF2e difficulty calculation correctly derives party level, computes per-creature XP from level differences, adjusts budgets for party size, and assigns the correct tier for all combinations.
 
 ---
 
@@ -424,3 +520,8 @@ The settings modal section currently labeled "Conditions" MUST be relabeled to "
 - The CR-to-XP lookup table is shared between both editions — only the budget thresholds and multiplier logic differ.
 - MVP baseline does not include the 2014 Adventuring Day XP budget or multipart encounter rules.
 - MVP baseline does not include per-combatant level overrides — level is always derived from the player character template.
+- The PF2e level difference XP table and budget thresholds are static data that do not change at runtime.
+- PF2e creatures always have a `level` field in their bestiary data (already present on `Pf2eCreature`).
+- Custom combatants without `creatureId` cannot contribute to PF2e XP calculation — there is no manual "creature level" assignment equivalent to the manual CR picker. This may be addressed in a future issue.
+- Level differences below −4 contribute 0 XP (strict reading of the GM Core table); above +4 they are counted as the +4 row (160 XP).
+- PF2e does not use CR at all — the CR field on combatants is irrelevant when in PF2e mode.

vitest.config.ts

@@ -3,7 +3,6 @@ import { defineConfig } from "vitest/config";
 export default defineConfig({
 	test: {
 		include: ["packages/*/src/**/*.test.ts", "apps/*/src/**/*.test.{ts,tsx}"],
-		passWithNoTests: true,
 		coverage: {
 			provider: "v8",
 			enabled: true,