Add 2014 DMG encounter difficulty calculation

Support the 2014 DMG encounter difficulty as an alternative to the 5.5e system behind the existing Rules Edition toggle. The 2014 system uses Easy/Medium/Hard/Deadly thresholds, an encounter multiplier based on monster count, and party size adjustment (×0.5–×5 range). - Extract RulesEdition to its own domain module - Refactor DifficultyTier to abstract numeric values (0–3) - Restructure DifficultyResult with thresholds array - Add 2014 XP thresholds table and encounter multiplier logic - Wire edition from context into difficulty hooks - Edition-aware labels in indicator and breakdown panel - Show multiplier, adjusted XP, and party size note for 2014 - Rename settings label from "Conditions" to "Rules Edition" - Update spec 008 with issue #23 requirements Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Add combatant side assignment for encounter difficulty
2026-04-04 14:52:23 +02:00 · 2026-04-03 14:15:12 +02:00
30 changed files with 2102 additions and 563 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -69,6 +69,7 @@ docs/agents/               RPI skill artifacts (research reports, plans)
 - **oxlint** for type-aware linting that Biome can't do. Configured in `.oxlintrc.json`.
 - **TypeScript strict mode** with `verbatimModuleSyntax`. Use `.js` extensions in relative imports.
 - **Branded types** for identity values (e.g., `CombatantId`). Prefer immutability/`readonly` where practical.
+- **Reuse UI primitives** — before creating custom interactive elements (buttons, inputs, selects, dialogs), check `apps/web/src/components/ui/` for existing components with established variants and hover styles.
 - **Domain events** are plain data objects with a `type` discriminant — no classes.
 - **Tests** live in `__tests__/` directories adjacent to source. See the Testing section below for conventions on mocking, assertions, and per-layer approach.
 - **Quality gates** are enforced at pre-commit via Lefthook (parallel jobs). No gate may exist only as a CI step or manual process.
--- a/apps/web/src/tests/export-import.test.ts
+++ b/apps/web/src/tests/export-import.test.ts
@@ -234,6 +234,57 @@ describe("round-trip: export then import", () => {
 		expect(imported.encounter.combatants[0].cr).toBe("2");
 	});

+	it("round-trips a combatant with side field", () => {
+		const encounterWithSide: Encounter = {
+			combatants: [
+				{
+					id: combatantId("c-1"),
+					name: "Allied Guard",
+					cr: "2",
+					side: "party",
+				},
+				{
+					id: combatantId("c-2"),
+					name: "Goblin",
+					side: "enemy",
+				},
+			],
+			activeIndex: 0,
+			roundNumber: 1,
+		};
+		const emptyUndoRedo: UndoRedoState = {
+			undoStack: [],
+			redoStack: [],
+		};
+		const bundle = assembleExportBundle(encounterWithSide, 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].side).toBe("party");
+		expect(imported.encounter.combatants[1].side).toBe("enemy");
+	});
+
+	it("round-trips a combatant without side field as undefined", () => {
+		const encounterNoSide: Encounter = {
+			combatants: [{ id: combatantId("c-1"), name: "Custom" }],
+			activeIndex: 0,
+			roundNumber: 1,
+		};
+		const emptyUndoRedo: UndoRedoState = {
+			undoStack: [],
+			redoStack: [],
+		};
+		const bundle = assembleExportBundle(encounterNoSide, 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].side).toBeUndefined();
+	});
+
 	it("round-trips an empty encounter", () => {
 		const emptyEncounter: Encounter = {
 			combatants: [],
--- a/apps/web/src/components/tests/difficulty-breakdown-panel.test.tsx
+++ b/apps/web/src/components/tests/difficulty-breakdown-panel.test.tsx
@@ -3,7 +3,13 @@ import "@testing-library/jest-dom/vitest";

 import type { Creature, CreatureId, PlayerCharacter } from "@initiative/domain";
 import { combatantId, creatureId, playerCharacterId } from "@initiative/domain";
-import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import {
+	cleanup,
+	render,
+	renderHook,
+	screen,
+	waitFor,
+} from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
 import { createTestAdapters } from "../../__tests__/adapters/in-memory-adapters.js";
@@ -13,6 +19,7 @@ import {
 	buildEncounter,
 } from "../../__tests__/factories/index.js";
 import { AllProviders } from "../../__tests__/test-providers.js";
+import { useRulesEdition } from "../../hooks/use-rules-edition.js";
 import { DifficultyBreakdownPanel } from "../difficulty-breakdown-panel.js";

 beforeAll(() => {
@@ -121,7 +128,7 @@ describe("DifficultyBreakdownPanel", () => {
 		});
 	});

-	it("renders bestiary combatant as read-only with source name", async () => {
+	it("shows PC in party column with level", async () => {
 		renderPanel({
 			encounter: defaultEncounter(),
 			playerCharacters: defaultPCs,
@@ -129,12 +136,53 @@ describe("DifficultyBreakdownPanel", () => {
 		});

 		await waitFor(() => {
-			expect(screen.getByText("Goblin (SRD)")).toBeInTheDocument();
+			expect(screen.getByText("Hero")).toBeInTheDocument();
+			expect(screen.getByText("Lv 5")).toBeInTheDocument();
+		});
+	});
+
+	it("shows monsters in enemy column", async () => {
+		renderPanel({
+			encounter: defaultEncounter(),
+			playerCharacters: defaultPCs,
+			creatures: new Map([[goblinCreature.id, goblinCreature]]),
+		});
+
+		await waitFor(() => {
+			expect(screen.getByText("Goblin")).toBeInTheDocument();
 			expect(screen.getAllByText("CR 1/4").length).toBeGreaterThanOrEqual(1);
 		});
 	});

-	it("renders custom combatant with CR picker", async () => {
+	it("renders explanation text", async () => {
+		renderPanel({
+			encounter: defaultEncounter(),
+			playerCharacters: defaultPCs,
+			creatures: new Map([[goblinCreature.id, goblinCreature]]),
+		});
+
+		await waitFor(() => {
+			expect(
+				screen.getByText(
+					"Allied NPC XP is subtracted from encounter difficulty",
+				),
+			).toBeInTheDocument();
+		});
+	});
+
+	it("renders Net Monster XP footer", async () => {
+		renderPanel({
+			encounter: defaultEncounter(),
+			playerCharacters: defaultPCs,
+			creatures: new Map([[goblinCreature.id, goblinCreature]]),
+		});
+
+		await waitFor(() => {
+			expect(screen.getByText("Net Monster XP")).toBeInTheDocument();
+		});
+	});
+
+	it("renders custom combatant with CR picker in enemy column", async () => {
 		renderPanel({
 			encounter: defaultEncounter(),
 			playerCharacters: defaultPCs,
@@ -144,27 +192,10 @@ describe("DifficultyBreakdownPanel", () => {
 		await waitFor(() => {
 			const pickers = screen.getAllByLabelText("Challenge rating");
 			expect(pickers).toHaveLength(2);
-			// First picker is "Custom Thug" with CR 2
 			expect(pickers[0]).toHaveValue("2");
 		});
 	});

-	it("renders unassigned combatant with Assign picker and dash for XP", async () => {
-		renderPanel({
-			encounter: defaultEncounter(),
-			playerCharacters: defaultPCs,
-			creatures: new Map([[goblinCreature.id, goblinCreature]]),
-		});
-
-		await waitFor(() => {
-			const pickers = screen.getAllByLabelText("Challenge rating");
-			// Second picker is "Bandit" with no CR
-			expect(pickers[1]).toHaveValue("");
-			// "—" appears for unassigned XP
-			expect(screen.getByText("—")).toBeInTheDocument();
-		});
-	});
-
 	it("selecting a CR updates the visible XP value", async () => {
 		const user = userEvent.setup();
 		renderPanel({
@@ -173,24 +204,19 @@ describe("DifficultyBreakdownPanel", () => {
 			creatures: new Map([[goblinCreature.id, goblinCreature]]),
 		});

-		// Wait for the panel to render with bestiary data
 		await waitFor(() => {
-			expect(screen.getByText("—")).toBeInTheDocument();
+			expect(screen.getAllByLabelText("Challenge rating")).toHaveLength(2);
 		});

-		// The Bandit (second picker) has no CR — shows "—" for XP
 		const pickers = screen.getAllByLabelText("Challenge rating");
-
-		// Select CR 5 (1,800 XP) on Bandit
 		await user.selectOptions(pickers[1], "5");

-		// XP should update — the "—" should be replaced with an XP value
 		await waitFor(() => {
 			expect(screen.getByText("1,800")).toBeInTheDocument();
 		});
 	});

-	it("renders total monster XP", async () => {
+	it("non-PC combatants show toggle button", async () => {
 		renderPanel({
 			encounter: defaultEncounter(),
 			playerCharacters: defaultPCs,
@@ -198,12 +224,57 @@ describe("DifficultyBreakdownPanel", () => {
 		});

 		await waitFor(() => {
-			expect(screen.getByText("Total Monster XP")).toBeInTheDocument();
+			// Each non-PC enemy combatant has a toggle button
+			expect(
+				screen.getByLabelText("Move Goblin to party side"),
+			).toBeInTheDocument();
+			expect(
+				screen.getByLabelText("Move Custom Thug to party side"),
+			).toBeInTheDocument();
+		});
+	});
+
+	it("PC combatants do not show side toggle", async () => {
+		renderPanel({
+			encounter: defaultEncounter(),
+			playerCharacters: defaultPCs,
+			creatures: new Map([[goblinCreature.id, goblinCreature]]),
+		});
+
+		await waitFor(() => {
+			expect(screen.getByText("Hero")).toBeInTheDocument();
+		});
+
+		expect(
+			screen.queryByLabelText("Move Hero to enemy side"),
+		).not.toBeInTheDocument();
+	});
+
+	it("side toggle moves combatant between sections", async () => {
+		const user = userEvent.setup();
+		renderPanel({
+			encounter: defaultEncounter(),
+			playerCharacters: defaultPCs,
+			creatures: new Map([[goblinCreature.id, goblinCreature]]),
+		});
+
+		await waitFor(() => {
+			expect(screen.getByText("Goblin")).toBeInTheDocument();
+		});
+
+		// Toggle goblin to party side
+		const toggleBtn = screen.getByLabelText("Move Goblin to party side");
+		await user.click(toggleBtn);
+
+		// After toggle, the aria-label should change to "Move Goblin to enemy side"
+		await waitFor(() => {
+			expect(
+				screen.getByLabelText("Move Goblin to enemy side"),
+			).toBeInTheDocument();
 		});
 	});

 	it("renders nothing when breakdown data is insufficient", () => {
-		// No PCs with level → breakdown returns null
 		const { container } = renderPanel({
 			encounter: buildEncounter({
 				combatants: [
@@ -215,6 +286,63 @@ describe("DifficultyBreakdownPanel", () => {
 		expect(container.innerHTML).toBe("");
 	});

+	it("shows 4 threshold columns for 2014 edition", async () => {
+		const { result: editionResult } = renderHook(() => useRulesEdition());
+		editionResult.current.setEdition("5e");
+
+		try {
+			renderPanel({
+				encounter: defaultEncounter(),
+				playerCharacters: defaultPCs,
+				creatures: new Map([[goblinCreature.id, goblinCreature]]),
+			});
+
+			await waitFor(() => {
+				expect(screen.getByText("Easy:", { exact: false })).toBeInTheDocument();
+				expect(screen.getByText("Med:", { exact: false })).toBeInTheDocument();
+				expect(screen.getByText("Hard:", { exact: false })).toBeInTheDocument();
+				expect(
+					screen.getByText("Deadly:", { exact: false }),
+				).toBeInTheDocument();
+			});
+		} finally {
+			editionResult.current.setEdition("5.5e");
+		}
+	});
+
+	it("shows multiplier and adjusted XP for 2014 edition", async () => {
+		const { result: editionResult } = renderHook(() => useRulesEdition());
+		editionResult.current.setEdition("5e");
+
+		try {
+			renderPanel({
+				encounter: defaultEncounter(),
+				playerCharacters: defaultPCs,
+				creatures: new Map([[goblinCreature.id, goblinCreature]]),
+			});
+
+			await waitFor(() => {
+				expect(screen.getByText("Monster XP")).toBeInTheDocument();
+				// 1 PC (<3) triggers party size adjustment
+				expect(screen.getByText("Adjusted for 1 PC")).toBeInTheDocument();
+			});
+		} finally {
+			editionResult.current.setEdition("5.5e");
+		}
+	});
+
+	it("shows Net Monster XP for 5.5e edition (no multiplier)", async () => {
+		renderPanel({
+			encounter: defaultEncounter(),
+			playerCharacters: defaultPCs,
+			creatures: new Map([[goblinCreature.id, goblinCreature]]),
+		});
+
+		await waitFor(() => {
+			expect(screen.getByText("Net Monster XP")).toBeInTheDocument();
+		});
+	});
+
 	it("calls onClose when Escape is pressed", async () => {
 		const user = userEvent.setup();
 		const onClose = vi.fn();
--- a/apps/web/src/components/tests/difficulty-indicator.test.tsx
+++ b/apps/web/src/components/tests/difficulty-indicator.test.tsx
@@ -3,7 +3,11 @@ import type { DifficultyResult } from "@initiative/domain";
 import { cleanup, render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { DifficultyIndicator } from "../difficulty-indicator.js";
+import {
+	DifficultyIndicator,
+	TIER_LABELS_5_5E,
+	TIER_LABELS_2014,
+} from "../difficulty-indicator.js";

 afterEach(cleanup);

@@ -11,50 +15,77 @@ function makeResult(tier: DifficultyResult["tier"]): DifficultyResult {
 	return {
 		tier,
 		totalMonsterXp: 100,
-		partyBudget: { low: 50, moderate: 100, high: 200 },
+		thresholds: [
+			{ label: "Low", value: 50 },
+			{ label: "Moderate", value: 100 },
+			{ label: "High", value: 200 },
+		],
+		encounterMultiplier: undefined,
+		adjustedXp: undefined,
+		partySizeAdjusted: undefined,
 	};
 }

 describe("DifficultyIndicator", () => {
 	it("renders 3 bars", () => {
 		const { container } = render(
-			<DifficultyIndicator result={makeResult("moderate")} />,
+			<DifficultyIndicator result={makeResult(2)} labels={TIER_LABELS_5_5E} />,
 		);
 		const bars = container.querySelectorAll("[class*='rounded-sm']");
 		expect(bars).toHaveLength(3);
 	});

-	it("shows 'Trivial encounter difficulty' label for trivial tier", () => {
-		render(<DifficultyIndicator result={makeResult("trivial")} />);
+	it("shows 'Trivial encounter difficulty' for 5.5e tier 0", () => {
+		render(
+			<DifficultyIndicator result={makeResult(0)} labels={TIER_LABELS_5_5E} />,
+		);
 		expect(
-			screen.getByRole("img", {
-				name: "Trivial encounter difficulty",
-			}),
+			screen.getByRole("img", { name: "Trivial encounter difficulty" }),
 		).toBeDefined();
 	});

-	it("shows 'Low encounter difficulty' label for low tier", () => {
-		render(<DifficultyIndicator result={makeResult("low")} />);
+	it("shows 'Low encounter difficulty' for 5.5e tier 1", () => {
+		render(
+			<DifficultyIndicator result={makeResult(1)} labels={TIER_LABELS_5_5E} />,
+		);
 		expect(
 			screen.getByRole("img", { name: "Low encounter difficulty" }),
 		).toBeDefined();
 	});

-	it("shows 'Moderate encounter difficulty' label for moderate tier", () => {
-		render(<DifficultyIndicator result={makeResult("moderate")} />);
+	it("shows 'Moderate encounter difficulty' for 5.5e tier 2", () => {
+		render(
+			<DifficultyIndicator result={makeResult(2)} labels={TIER_LABELS_5_5E} />,
+		);
 		expect(
-			screen.getByRole("img", {
-				name: "Moderate encounter difficulty",
-			}),
+			screen.getByRole("img", { name: "Moderate encounter difficulty" }),
 		).toBeDefined();
 	});

-	it("shows 'High encounter difficulty' label for high tier", () => {
-		render(<DifficultyIndicator result={makeResult("high")} />);
+	it("shows 'High encounter difficulty' for 5.5e tier 3", () => {
+		render(
+			<DifficultyIndicator result={makeResult(3)} labels={TIER_LABELS_5_5E} />,
+		);
 		expect(
-			screen.getByRole("img", {
-				name: "High encounter difficulty",
-			}),
+			screen.getByRole("img", { name: "High encounter difficulty" }),
+		).toBeDefined();
+	});
+
+	it("shows 'Easy encounter difficulty' for 2014 tier 0", () => {
+		render(
+			<DifficultyIndicator result={makeResult(0)} labels={TIER_LABELS_2014} />,
+		);
+		expect(
+			screen.getByRole("img", { name: "Easy encounter difficulty" }),
+		).toBeDefined();
+	});
+
+	it("shows 'Deadly encounter difficulty' for 2014 tier 3", () => {
+		render(
+			<DifficultyIndicator result={makeResult(3)} labels={TIER_LABELS_2014} />,
+		);
+		expect(
+			screen.getByRole("img", { name: "Deadly encounter difficulty" }),
 		).toBeDefined();
 	});

@@ -63,22 +94,21 @@ describe("DifficultyIndicator", () => {
 		const handleClick = vi.fn();
 		render(
 			<DifficultyIndicator
-				result={makeResult("moderate")}
+				result={makeResult(2)}
+				labels={TIER_LABELS_5_5E}
 				onClick={handleClick}
 			/>,
 		);

 		await user.click(
-			screen.getByRole("img", {
-				name: "Moderate encounter difficulty",
-			}),
+			screen.getByRole("img", { name: "Moderate encounter difficulty" }),
 		);
 		expect(handleClick).toHaveBeenCalledOnce();
 	});

 	it("renders as div when onClick not provided", () => {
 		const { container } = render(
-			<DifficultyIndicator result={makeResult("moderate")} />,
+			<DifficultyIndicator result={makeResult(2)} labels={TIER_LABELS_5_5E} />,
 		);
 		const element = container.querySelector("[role='img']");
 		expect(element?.tagName).toBe("DIV");
@@ -87,7 +117,8 @@ describe("DifficultyIndicator", () => {
 	it("renders as button when onClick provided", () => {
 		const { container } = render(
 			<DifficultyIndicator
-				result={makeResult("moderate")}
+				result={makeResult(2)}
+				labels={TIER_LABELS_5_5E}
 				onClick={() => {}}
 			/>,
 		);
--- a/apps/web/src/components/tests/settings-modal.test.tsx
+++ b/apps/web/src/components/tests/settings-modal.test.tsx
@@ -37,8 +37,9 @@ function renderModal(open = true) {
 }

 describe("SettingsModal", () => {
-	it("renders edition toggle buttons", () => {
+	it("renders edition section with 'Rules Edition' label", () => {
 		renderModal();
+		expect(screen.getByText("Rules Edition")).toBeInTheDocument();
 		expect(
 			screen.getByRole("button", { name: "5e (2014)" }),
 		).toBeInTheDocument();
--- a/apps/web/src/components/difficulty-breakdown-panel.tsx
+++ b/apps/web/src/components/difficulty-breakdown-panel.tsx
@@ -1,37 +1,97 @@
-import type { DifficultyTier } from "@initiative/domain";
+import type { DifficultyTier, RulesEdition } from "@initiative/domain";
+import { ArrowLeftRight } from "lucide-react";
 import { useRef } from "react";
 import { useEncounterContext } from "../contexts/encounter-context.js";
+import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
 import { useClickOutside } from "../hooks/use-click-outside.js";
 import {
 	type BreakdownCombatant,
 	useDifficultyBreakdown,
 } from "../hooks/use-difficulty-breakdown.js";
 import { CrPicker } from "./cr-picker.js";
+import { Button } from "./ui/button.js";

-const TIER_LABELS: Record<DifficultyTier, { label: string; color: string }> = {
-	trivial: { label: "Trivial", color: "text-muted-foreground" },
-	low: { label: "Low", color: "text-green-500" },
-	moderate: { label: "Moderate", color: "text-yellow-500" },
-	high: { label: "High", color: "text-red-500" },
+const TIER_LABEL_MAP: Record<
+	RulesEdition,
+	Record<DifficultyTier, { label: string; color: string }>
+> = {
+	"5.5e": {
+		0: { label: "Trivial", color: "text-muted-foreground" },
+		1: { label: "Low", color: "text-green-500" },
+		2: { label: "Moderate", color: "text-yellow-500" },
+		3: { label: "High", color: "text-red-500" },
+	},
+	"5e": {
+		0: { label: "Easy", color: "text-muted-foreground" },
+		1: { label: "Medium", color: "text-green-500" },
+		2: { label: "Hard", color: "text-yellow-500" },
+		3: { label: "Deadly", color: "text-red-500" },
+	},
 };

+/** Short labels for threshold display where horizontal space is limited. */
+const SHORT_LABELS: Readonly<Record<string, string>> = {
+	Moderate: "Mod",
+	Medium: "Med",
+};
+
+function shortLabel(label: string): string {
+	return SHORT_LABELS[label] ?? label;
+}
+
 function formatXp(xp: number): string {
 	return xp.toLocaleString();
 }

-function CombatantRow({ entry }: { entry: BreakdownCombatant }) {
-	const { setCr } = useEncounterContext();
+function PcRow({ entry }: { entry: BreakdownCombatant }) {
+	return (
+		<div className="col-span-4 grid grid-cols-subgrid items-center text-xs">
+			<span className="min-w-0 truncate" title={entry.combatant.name}>
+				{entry.combatant.name}
+			</span>
+			<span />
+			<span className="text-muted-foreground">
+				{entry.level === undefined ? "\u2014" : `Lv ${entry.level}`}
+			</span>
+			<span className="text-right tabular-nums">{"\u2014"}</span>
+		</div>
+	);
+}

-	const nameLabel = entry.source
-		? `${entry.combatant.name} (${entry.source})`
-		: entry.combatant.name;
+function NpcRow({
+	entry,
+	onToggleSide,
+}: {
+	entry: BreakdownCombatant;
+	onToggleSide: () => void;
+}) {
+	const { setCr } = useEncounterContext();
+	const isParty = entry.side === "party";
+	const targetSide = isParty ? "enemy" : "party";
+
+	let xpDisplay: string;
+	if (entry.xp == null) {
+		xpDisplay = "\u2014";
+	} else if (isParty && entry.cr) {
+		xpDisplay = `\u2212${formatXp(entry.xp)}`;
+	} else {
+		xpDisplay = formatXp(entry.xp);
+	}

 	return (
-		<div className="flex items-center justify-between gap-2 text-xs">
-			<span className="min-w-0 truncate" title={nameLabel}>
-				{nameLabel}
+		<div className="col-span-4 grid grid-cols-subgrid items-center text-xs">
+			<span className="min-w-0 truncate" title={entry.combatant.name}>
+				{entry.combatant.name}
 			</span>
-			<div className="flex shrink-0 items-center gap-2">
+			<Button
+				variant="ghost"
+				size="icon-sm"
+				onClick={onToggleSide}
+				aria-label={`Move ${entry.combatant.name} to ${targetSide} side`}
+			>
+				<ArrowLeftRight className="h-3 w-3" />
+			</Button>
+			<span>
 				{entry.editable ? (
 					<CrPicker
 						value={entry.cr}
@@ -39,13 +99,11 @@ function CombatantRow({ entry }: { entry: BreakdownCombatant }) {
 					/>
 				) : (
 					<span className="text-muted-foreground">
-						{entry.cr ? `CR ${entry.cr}` : "—"}
+						{entry.cr ? `CR ${entry.cr}` : "\u2014"}
 					</span>
 				)}
-				<span className="w-12 text-right tabular-nums">
-					{entry.xp == null ? "—" : formatXp(entry.xp)}
 			</span>
-			</div>
+			<span className="text-right tabular-nums">{xpDisplay}</span>
 		</div>
 	);
 }
@@ -53,16 +111,26 @@ function CombatantRow({ entry }: { entry: BreakdownCombatant }) {
 export function DifficultyBreakdownPanel({ onClose }: { onClose: () => void }) {
 	const ref = useRef<HTMLDivElement>(null);
 	useClickOutside(ref, onClose);
+	const { setSide } = useEncounterContext();
+	const { edition } = useRulesEditionContext();

 	const breakdown = useDifficultyBreakdown();
 	if (!breakdown) return null;

-	const tierConfig = TIER_LABELS[breakdown.tier];
+	const tierConfig = TIER_LABEL_MAP[edition][breakdown.tier];
+
+	const handleToggle = (entry: BreakdownCombatant) => {
+		const newSide = entry.side === "party" ? "enemy" : "party";
+		setSide(entry.combatant.id, newSide);
+	};
+
+	const isPC = (entry: BreakdownCombatant) =>
+		entry.combatant.playerCharacterId != null;

 	return (
 		<div
 			ref={ref}
-			className="absolute top-full right-0 z-50 mt-1 w-72 rounded-lg border border-border bg-card p-3 shadow-lg"
+			className="absolute top-full right-0 z-50 mt-1 w-80 rounded-lg border border-border bg-card p-3 shadow-lg max-sm:fixed max-sm:top-12 max-sm:right-3 max-sm:left-3 max-sm:w-auto"
 		>
 			<div className="mb-2 font-medium text-sm">
 				Encounter Difficulty:{" "}
@@ -75,35 +143,86 @@ export function DifficultyBreakdownPanel({ onClose }: { onClose: () => void }) {
 					{breakdown.pcCount === 1 ? "PC" : "PCs"})
 				</div>
 				<div className="flex gap-3 text-xs">
-					<span>
-						Low: <strong>{formatXp(breakdown.partyBudget.low)}</strong>
-					</span>
-					<span>
-						Mod: <strong>{formatXp(breakdown.partyBudget.moderate)}</strong>
-					</span>
-					<span>
-						High: <strong>{formatXp(breakdown.partyBudget.high)}</strong>
+					{breakdown.thresholds.map((t) => (
+						<span key={t.label}>
+							{shortLabel(t.label)}: <strong>{formatXp(t.value)}</strong>
 						</span>
+					))}
 				</div>
 			</div>

+			<div className="border-border border-t pt-2 pb-2 text-muted-foreground text-xs italic">
+				Allied NPC XP is subtracted from encounter difficulty
+			</div>
+
 			<div className="border-border border-t pt-2">
 				<div className="mb-1 flex justify-between text-muted-foreground text-xs">
-					<span>Monsters</span>
+					<span>Party</span>
 					<span>XP</span>
 				</div>
-				<div className="flex flex-col gap-1">
-					{breakdown.combatants.map((entry) => (
-						<CombatantRow key={entry.combatant.id} entry={entry} />
-					))}
+				<div className="grid grid-cols-[1fr_auto_auto_3.5rem] gap-x-2 gap-y-1">
+					{breakdown.partyCombatants.map((entry) =>
+						isPC(entry) ? (
+							<PcRow key={entry.combatant.id} entry={entry} />
+						) : (
+							<NpcRow
+								key={entry.combatant.id}
+								entry={entry}
+								onToggleSide={() => handleToggle(entry)}
+							/>
+						),
+					)}
 				</div>
+			</div>
+
+			<div className="mt-2 border-border border-t pt-2">
+				<div className="mb-1 flex justify-between text-muted-foreground text-xs">
+					<span>Enemy</span>
+					<span>XP</span>
+				</div>
+				<div className="grid grid-cols-[1fr_auto_auto_3.5rem] gap-x-2 gap-y-1">
+					{breakdown.enemyCombatants.map((entry) =>
+						isPC(entry) ? (
+							<PcRow key={entry.combatant.id} entry={entry} />
+						) : (
+							<NpcRow
+								key={entry.combatant.id}
+								entry={entry}
+								onToggleSide={() => handleToggle(entry)}
+							/>
+						),
+					)}
+				</div>
+			</div>
+
+			{breakdown.encounterMultiplier !== undefined &&
+			breakdown.adjustedXp !== undefined ? (
+				<div className="mt-2 border-border border-t pt-2">
+					<div className="flex justify-between font-medium text-xs">
+						<span>Monster XP</span>
+						<span className="tabular-nums">
+							{formatXp(breakdown.totalMonsterXp)}{" "}
+							<span className="text-muted-foreground">
+								&times;{breakdown.encounterMultiplier}
+							</span>{" "}
+							= {formatXp(breakdown.adjustedXp)}
+						</span>
+					</div>
+					{breakdown.partySizeAdjusted === true ? (
+						<div className="mt-0.5 text-muted-foreground text-xs italic">
+							Adjusted for {breakdown.pcCount}{" "}
+							{breakdown.pcCount === 1 ? "PC" : "PCs"}
+						</div>
+					) : null}
+				</div>
+			) : (
 				<div className="mt-2 flex justify-between border-border border-t pt-2 font-medium text-xs">
-					<span>Total Monster XP</span>
+					<span>Net Monster XP</span>
 					<span className="tabular-nums">
 						{formatXp(breakdown.totalMonsterXp)}
 					</span>
 				</div>
-			</div>
+			)}
 		</div>
 	);
 }
--- a/apps/web/src/components/difficulty-indicator.tsx
+++ b/apps/web/src/components/difficulty-indicator.tsx
@@ -1,27 +1,44 @@
 import type { DifficultyResult, DifficultyTier } from "@initiative/domain";
 import { cn } from "../lib/utils.js";

-const TIER_CONFIG: Record<
+export const TIER_LABELS_5_5E: Record<DifficultyTier, string> = {
+	0: "Trivial",
+	1: "Low",
+	2: "Moderate",
+	3: "High",
+};
+
+export const TIER_LABELS_2014: Record<DifficultyTier, string> = {
+	0: "Easy",
+	1: "Medium",
+	2: "Hard",
+	3: "Deadly",
+};
+
+const TIER_COLORS: Record<
 	DifficultyTier,
-	{ filledBars: number; color: string; label: string }
+	{ filledBars: number; color: string }
 > = {
-	trivial: { filledBars: 0, color: "", label: "Trivial" },
-	low: { filledBars: 1, color: "bg-green-500", label: "Low" },
-	moderate: { filledBars: 2, color: "bg-yellow-500", label: "Moderate" },
-	high: { filledBars: 3, color: "bg-red-500", label: "High" },
+	0: { filledBars: 0, color: "" },
+	1: { filledBars: 1, color: "bg-green-500" },
+	2: { filledBars: 2, color: "bg-yellow-500" },
+	3: { filledBars: 3, color: "bg-red-500" },
 };

 const BAR_HEIGHTS = ["h-2", "h-3", "h-4"] as const;

 export function DifficultyIndicator({
 	result,
+	labels,
 	onClick,
 }: {
 	result: DifficultyResult;
+	labels: Record<DifficultyTier, string>;
 	onClick?: () => void;
 }) {
-	const config = TIER_CONFIG[result.tier];
-	const tooltip = `${config.label} encounter difficulty`;
+	const config = TIER_COLORS[result.tier];
+	const label = labels[result.tier];
+	const tooltip = `${label} encounter difficulty`;

 	const Element = onClick ? "button" : "div";

--- a/apps/web/src/components/settings-modal.tsx
+++ b/apps/web/src/components/settings-modal.tsx
@@ -36,7 +36,7 @@ export function SettingsModal({ open, onClose }: Readonly<SettingsModalProps>) {
 			<div className="flex flex-col gap-5">
 				<div>
 					<span className="mb-2 block font-medium text-muted-foreground text-sm">
-						Conditions
+						Rules Edition
 					</span>
 					<div className="flex gap-1">
 						{EDITION_OPTIONS.map((opt) => (
--- a/apps/web/src/components/turn-navigation.tsx
+++ b/apps/web/src/components/turn-navigation.tsx
@@ -1,9 +1,14 @@
 import { Redo2, StepBack, StepForward, Trash2, Undo2 } from "lucide-react";
 import { useState } from "react";
 import { useEncounterContext } from "../contexts/encounter-context.js";
+import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
 import { useDifficulty } from "../hooks/use-difficulty.js";
 import { DifficultyBreakdownPanel } from "./difficulty-breakdown-panel.js";
-import { DifficultyIndicator } from "./difficulty-indicator.js";
+import {
+	DifficultyIndicator,
+	TIER_LABELS_5_5E,
+	TIER_LABELS_2014,
+} from "./difficulty-indicator.js";
 import { Button } from "./ui/button.js";
 import { ConfirmButton } from "./ui/confirm-button.js";

@@ -20,6 +25,8 @@ export function TurnNavigation() {
 	} = useEncounterContext();

 	const difficulty = useDifficulty();
+	const { edition } = useRulesEditionContext();
+	const tierLabels = edition === "5e" ? TIER_LABELS_2014 : TIER_LABELS_5_5E;
 	const [showBreakdown, setShowBreakdown] = useState(false);
 	const hasCombatants = encounter.combatants.length > 0;
 	const isAtStart = encounter.roundNumber === 1 && encounter.activeIndex === 0;
@@ -79,6 +86,7 @@ export function TurnNavigation() {
 					<div className="relative mr-1">
 						<DifficultyIndicator
 							result={difficulty}
+							labels={tierLabels}
 							onClick={() => setShowBreakdown((prev) => !prev)}
 						/>
 						{showBreakdown ? (
--- a/apps/web/src/hooks/tests/use-difficulty-breakdown.test.tsx
+++ b/apps/web/src/hooks/tests/use-difficulty-breakdown.test.tsx
@@ -12,6 +12,7 @@ import {
 } from "../../__tests__/factories/index.js";
 import { AllProviders } from "../../__tests__/test-providers.js";
 import { useDifficultyBreakdown } from "../use-difficulty-breakdown.js";
+import { useRulesEdition } from "../use-rules-edition.js";

 beforeAll(() => {
 	Object.defineProperty(globalThis, "matchMedia", {
@@ -106,7 +107,7 @@ describe("useDifficultyBreakdown", () => {
 		expect(result.current).toBeNull();
 	});

-	it("returns per-combatant entries with correct data", async () => {
+	it("returns per-combatant entries split by side", async () => {
 		const wrapper = makeWrapper({
 			encounter: buildEncounter({
 				combatants: [
@@ -145,29 +146,34 @@ describe("useDifficultyBreakdown", () => {
 			const breakdown = result.current;
 			expect(breakdown).not.toBeNull();
 			expect(breakdown?.pcCount).toBe(1);
-			// CR 1/4 = 50 + CR 2 = 450 → total 500
+			// CR 1/4 = 50 + CR 2 = 450 -> total 500
 			expect(breakdown?.totalMonsterXp).toBe(500);
-			expect(breakdown?.combatants).toHaveLength(3);

-			// Bestiary combatant
-			const goblin = breakdown?.combatants[0];
+			// PC in party column
+			expect(breakdown?.partyCombatants).toHaveLength(1);
+			expect(breakdown?.partyCombatants[0].combatant.name).toBe("Hero");
+			expect(breakdown?.partyCombatants[0].side).toBe("party");
+			expect(breakdown?.partyCombatants[0].level).toBe(5);
+
+			// Enemies: goblin, thug, bandit
+			expect(breakdown?.enemyCombatants).toHaveLength(3);
+
+			const goblin = breakdown?.enemyCombatants[0];
 			expect(goblin?.cr).toBe("1/4");
 			expect(goblin?.xp).toBe(50);
 			expect(goblin?.source).toBe("SRD");
 			expect(goblin?.editable).toBe(false);
+			expect(goblin?.side).toBe("enemy");

-			// Custom with CR
-			const thug = breakdown?.combatants[1];
+			const thug = breakdown?.enemyCombatants[1];
 			expect(thug?.cr).toBe("2");
 			expect(thug?.xp).toBe(450);
 			expect(thug?.source).toBeNull();
 			expect(thug?.editable).toBe(true);

-			// Custom without CR
-			const bandit = breakdown?.combatants[2];
+			const bandit = breakdown?.enemyCombatants[2];
 			expect(bandit?.cr).toBeNull();
 			expect(bandit?.xp).toBeNull();
-			expect(bandit?.source).toBeNull();
 			expect(bandit?.editable).toBe(true);
 		});
 	});
@@ -203,16 +209,15 @@ describe("useDifficultyBreakdown", () => {
 			wrapper,
 		});

-		// With no bestiary creatures loaded, the Ghost has null CR
 		const breakdown = result.current;
 		expect(breakdown).not.toBeNull();
-		const ghost = breakdown?.combatants[0];
+		const ghost = breakdown?.enemyCombatants[0];
 		expect(ghost?.cr).toBeNull();
 		expect(ghost?.xp).toBeNull();
 		expect(ghost?.editable).toBe(false);
 	});

-	it("excludes PC combatants from breakdown entries", async () => {
+	it("PC combatants appear in partyCombatants with level", async () => {
 		const wrapper = makeWrapper({
 			encounter: buildEncounter({
 				combatants: [
@@ -239,8 +244,105 @@ describe("useDifficultyBreakdown", () => {
 		});

 		await waitFor(() => {
-			expect(result.current?.combatants).toHaveLength(1);
-			expect(result.current?.combatants[0].combatant.name).toBe("Goblin");
+			expect(result.current?.partyCombatants).toHaveLength(1);
+			expect(result.current?.partyCombatants[0].combatant.name).toBe("Hero");
+			expect(result.current?.partyCombatants[0].level).toBe(1);
+			expect(result.current?.partyCombatants[0].side).toBe("party");
 		});
 	});
+
+	it("combatant with explicit side override is placed correctly", () => {
+		const wrapper = makeWrapper({
+			encounter: buildEncounter({
+				combatants: [
+					buildCombatant({
+						id: combatantId("c-1"),
+						name: "Hero",
+						playerCharacterId: pcId1,
+					}),
+					buildCombatant({
+						id: combatantId("c-2"),
+						name: "Allied Guard",
+						creatureId: goblinCreature.id,
+						side: "party",
+					}),
+					buildCombatant({
+						id: combatantId("c-3"),
+						name: "Thug",
+						cr: "1",
+					}),
+				],
+			}),
+			playerCharacters: [
+				{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 5 },
+			],
+			creatures: new Map([[goblinCreature.id, goblinCreature]]),
+		});
+
+		const { result } = renderHook(() => useDifficultyBreakdown(), {
+			wrapper,
+		});
+
+		const breakdown = result.current;
+		expect(breakdown).not.toBeNull();
+		// Allied Guard should be in party column
+		expect(breakdown?.partyCombatants).toHaveLength(2);
+		expect(breakdown?.partyCombatants[1].combatant.name).toBe("Allied Guard");
+		expect(breakdown?.partyCombatants[1].side).toBe("party");
+		// Thug in enemy column
+		expect(breakdown?.enemyCombatants).toHaveLength(1);
+		expect(breakdown?.enemyCombatants[0].combatant.name).toBe("Thug");
+	});
+
+	it("exposes encounterMultiplier and adjustedXp for 5e edition", async () => {
+		const wrapper = makeWrapper({
+			encounter: buildEncounter({
+				combatants: [
+					buildCombatant({
+						id: combatantId("c-1"),
+						name: "Hero",
+						playerCharacterId: pcId1,
+					}),
+					buildCombatant({
+						id: combatantId("c-2"),
+						name: "Goblin",
+						creatureId: goblinCreature.id,
+					}),
+					buildCombatant({
+						id: combatantId("c-3"),
+						name: "Thug",
+						cr: "1",
+					}),
+				],
+			}),
+			playerCharacters: [
+				{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 1 },
+			],
+			creatures: new Map([[goblinCreature.id, goblinCreature]]),
+		});
+
+		const { result: editionResult } = renderHook(() => useRulesEdition(), {
+			wrapper,
+		});
+		editionResult.current.setEdition("5e");
+
+		try {
+			const { result } = renderHook(() => useDifficultyBreakdown(), {
+				wrapper,
+			});
+
+			await waitFor(() => {
+				const breakdown = result.current;
+				expect(breakdown).not.toBeNull();
+				// 2 enemy monsters, 1 PC (<3) → base x1.5, shift up → x2
+				expect(breakdown?.encounterMultiplier).toBe(2);
+				// CR 1/4 (50) + CR 1 (200) = 250, x2 = 500
+				expect(breakdown?.totalMonsterXp).toBe(250);
+				expect(breakdown?.adjustedXp).toBe(500);
+				expect(breakdown?.thresholds).toHaveLength(4);
+			});
+		} finally {
+			editionResult.current.setEdition("5.5e");
+		}
+	});
 });
--- a/apps/web/src/hooks/tests/use-difficulty.test.ts
+++ b/apps/web/src/hooks/tests/use-difficulty.test.ts
@@ -1,220 +0,0 @@
-// @vitest-environment jsdom
-import type {
-	Combatant,
-	CreatureId,
-	Encounter,
-	PlayerCharacter,
-} from "@initiative/domain";
-import { combatantId, creatureId, playerCharacterId } from "@initiative/domain";
-import { renderHook } from "@testing-library/react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("../../contexts/encounter-context.js", () => ({
-	useEncounterContext: vi.fn(),
-}));
-
-vi.mock("../../contexts/player-characters-context.js", () => ({
-	usePlayerCharactersContext: vi.fn(),
-}));
-
-vi.mock("../../contexts/bestiary-context.js", () => ({
-	useBestiaryContext: vi.fn(),
-}));
-
-import { useBestiaryContext } from "../../contexts/bestiary-context.js";
-import { useEncounterContext } from "../../contexts/encounter-context.js";
-import { usePlayerCharactersContext } from "../../contexts/player-characters-context.js";
-import { useDifficulty } from "../use-difficulty.js";
-
-const mockEncounterContext = vi.mocked(useEncounterContext);
-const mockPlayerCharactersContext = vi.mocked(usePlayerCharactersContext);
-const mockBestiaryContext = vi.mocked(useBestiaryContext);
-
-const pcId1 = playerCharacterId("pc-1");
-const pcId2 = playerCharacterId("pc-2");
-const crId1 = creatureId("creature-1");
-const _crId2 = creatureId("creature-2");
-
-function setup(options: {
-	combatants: Combatant[];
-	characters: PlayerCharacter[];
-	creatures: Map<CreatureId, { cr: string }>;
-}) {
-	const encounter = {
-		combatants: options.combatants,
-		activeIndex: 0,
-		roundNumber: 1,
-	} as Encounter;
-
-	mockEncounterContext.mockReturnValue({
-		encounter,
-	} as ReturnType<typeof useEncounterContext>);
-
-	mockPlayerCharactersContext.mockReturnValue({
-		characters: options.characters,
-	} as ReturnType<typeof usePlayerCharactersContext>);
-
-	mockBestiaryContext.mockReturnValue({
-		getCreature: (id: CreatureId) => options.creatures.get(id),
-	} as ReturnType<typeof useBestiaryContext>);
-}
-
-beforeEach(() => {
-	vi.clearAllMocks();
-});
-
-describe("useDifficulty", () => {
-	it("returns difficulty result for leveled PCs and bestiary monsters", () => {
-		setup({
-			combatants: [
-				{ id: combatantId("c1"), name: "Hero", playerCharacterId: pcId1 },
-				{ id: combatantId("c2"), name: "Goblin", creatureId: crId1 },
-			],
-			characters: [{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 1 }],
-			creatures: new Map([[crId1, { cr: "1/4" }]]),
-		});
-
-		const { result } = renderHook(() => useDifficulty());
-
-		expect(result.current).not.toBeNull();
-		expect(result.current?.tier).toBe("low");
-		expect(result.current?.totalMonsterXp).toBe(50);
-	});
-
-	describe("returns null when data is insufficient (ED-2)", () => {
-		it("returns null when encounter has no combatants", () => {
-			setup({ combatants: [], characters: [], creatures: new Map() });
-
-			const { result } = renderHook(() => useDifficulty());
-			expect(result.current).toBeNull();
-		});
-
-		it("returns null when only custom combatants (no creatureId)", () => {
-			setup({
-				combatants: [
-					{
-						id: combatantId("c1"),
-						name: "Custom",
-						playerCharacterId: pcId1,
-					},
-				],
-				characters: [{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 5 }],
-				creatures: new Map(),
-			});
-
-			const { result } = renderHook(() => useDifficulty());
-			expect(result.current).toBeNull();
-		});
-
-		it("returns null when bestiary monsters present but no PC combatants", () => {
-			setup({
-				combatants: [
-					{ id: combatantId("c1"), name: "Goblin", creatureId: crId1 },
-				],
-				characters: [],
-				creatures: new Map([[crId1, { cr: "1" }]]),
-			});
-
-			const { result } = renderHook(() => useDifficulty());
-			expect(result.current).toBeNull();
-		});
-
-		it("returns null when PC combatants have no level", () => {
-			setup({
-				combatants: [
-					{
-						id: combatantId("c1"),
-						name: "Hero",
-						playerCharacterId: pcId1,
-					},
-					{ id: combatantId("c2"), name: "Goblin", creatureId: crId1 },
-				],
-				characters: [{ id: pcId1, name: "Hero", ac: 15, maxHp: 30 }],
-				creatures: new Map([[crId1, { cr: "1" }]]),
-			});
-
-			const { result } = renderHook(() => useDifficulty());
-			expect(result.current).toBeNull();
-		});
-
-		it("returns null when PC combatant references unknown player character", () => {
-			setup({
-				combatants: [
-					{
-						id: combatantId("c1"),
-						name: "Hero",
-						playerCharacterId: pcId2,
-					},
-					{ id: combatantId("c2"), name: "Goblin", creatureId: crId1 },
-				],
-				characters: [{ id: pcId1, name: "Other", ac: 15, maxHp: 30, level: 5 }],
-				creatures: new Map([[crId1, { cr: "1" }]]),
-			});
-
-			const { result } = renderHook(() => useDifficulty());
-			expect(result.current).toBeNull();
-		});
-	});
-
-	it("handles mixed combatants: only leveled PCs and bestiary monsters contribute", () => {
-		// Party: one leveled PC, one without level (excluded)
-		// Monsters: one bestiary creature, one custom (excluded)
-		setup({
-			combatants: [
-				{
-					id: combatantId("c1"),
-					name: "Leveled",
-					playerCharacterId: pcId1,
-				},
-				{
-					id: combatantId("c2"),
-					name: "No Level",
-					playerCharacterId: pcId2,
-				},
-				{ id: combatantId("c3"), name: "Goblin", creatureId: crId1 },
-				{ id: combatantId("c4"), name: "Custom Monster" },
-			],
-			characters: [
-				{ id: pcId1, name: "Leveled", ac: 15, maxHp: 30, level: 1 },
-				{ id: pcId2, name: "No Level", ac: 12, maxHp: 20 },
-			],
-			creatures: new Map([[crId1, { cr: "1" }]]),
-		});
-
-		const { result } = renderHook(() => useDifficulty());
-
-		expect(result.current).not.toBeNull();
-		// 1 level-1 PC: budget low=50, mod=75, high=100
-		// 1 CR 1 monster: 200 XP → high (200 >= 100)
-		expect(result.current?.tier).toBe("high");
-		expect(result.current?.totalMonsterXp).toBe(200);
-		expect(result.current?.partyBudget.low).toBe(50);
-	});
-
-	it("includes duplicate PC combatants in budget", () => {
-		// Same PC added twice → counts twice
-		setup({
-			combatants: [
-				{
-					id: combatantId("c1"),
-					name: "Hero 1",
-					playerCharacterId: pcId1,
-				},
-				{
-					id: combatantId("c2"),
-					name: "Hero 2",
-					playerCharacterId: pcId1,
-				},
-				{ id: combatantId("c3"), name: "Goblin", creatureId: crId1 },
-			],
-			characters: [{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 1 }],
-			creatures: new Map([[crId1, { cr: "1/4" }]]),
-		});
-
-		const { result } = renderHook(() => useDifficulty());
-
-		expect(result.current).not.toBeNull();
-		// 2x level 1: budget low=100
-		expect(result.current?.partyBudget.low).toBe(100);
-	});
-});
--- a/apps/web/src/hooks/tests/use-difficulty.test.tsx
+++ b/apps/web/src/hooks/tests/use-difficulty.test.tsx
@@ -0,0 +1,427 @@
+// @vitest-environment jsdom
+import type { Creature, CreatureId, PlayerCharacter } from "@initiative/domain";
+import { combatantId, creatureId, playerCharacterId } from "@initiative/domain";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import { createTestAdapters } from "../../__tests__/adapters/in-memory-adapters.js";
+import {
+	buildCombatant,
+	buildCreature,
+	buildEncounter,
+} from "../../__tests__/factories/index.js";
+import { AllProviders } from "../../__tests__/test-providers.js";
+import { useDifficulty } from "../use-difficulty.js";
+import { useRulesEdition } from "../use-rules-edition.js";
+
+beforeAll(() => {
+	Object.defineProperty(globalThis, "matchMedia", {
+		writable: true,
+		value: vi.fn().mockImplementation((query: string) => ({
+			matches: false,
+			media: query,
+			onchange: null,
+			addListener: vi.fn(),
+			removeListener: vi.fn(),
+			addEventListener: vi.fn(),
+			removeEventListener: vi.fn(),
+			dispatchEvent: vi.fn(),
+		})),
+	});
+});
+
+const pcId1 = playerCharacterId("pc-1");
+const pcId2 = playerCharacterId("pc-2");
+const crId1 = creatureId("srd:goblin");
+
+const goblinCreature = buildCreature({
+	id: crId1,
+	name: "Goblin",
+	cr: "1/4",
+});
+
+function makeWrapper(options: {
+	encounter: ReturnType<typeof buildEncounter>;
+	playerCharacters?: PlayerCharacter[];
+	creatures?: Map<CreatureId, Creature>;
+}) {
+	const adapters = createTestAdapters({
+		encounter: options.encounter,
+		playerCharacters: options.playerCharacters ?? [],
+		creatures: options.creatures,
+	});
+	return ({ children }: { children: ReactNode }) => (
+		<AllProviders adapters={adapters}>{children}</AllProviders>
+	);
+}
+
+describe("useDifficulty", () => {
+	it("returns difficulty result for leveled PCs and bestiary monsters", async () => {
+		const wrapper = makeWrapper({
+			encounter: buildEncounter({
+				combatants: [
+					buildCombatant({
+						id: combatantId("c1"),
+						name: "Hero",
+						playerCharacterId: pcId1,
+					}),
+					buildCombatant({
+						id: combatantId("c2"),
+						name: "Goblin",
+						creatureId: crId1,
+					}),
+				],
+			}),
+			playerCharacters: [
+				{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 1 },
+			],
+			creatures: new Map([[crId1, goblinCreature]]),
+		});
+
+		const { result } = renderHook(() => useDifficulty(), { wrapper });
+
+		await waitFor(() => {
+			expect(result.current).not.toBeNull();
+			expect(result.current?.tier).toBe(1);
+			expect(result.current?.totalMonsterXp).toBe(50);
+		});
+	});
+
+	describe("returns null when data is insufficient (ED-2)", () => {
+		it("returns null when encounter has no combatants", () => {
+			const wrapper = makeWrapper({
+				encounter: buildEncounter({ combatants: [] }),
+			});
+
+			const { result } = renderHook(() => useDifficulty(), { wrapper });
+			expect(result.current).toBeNull();
+		});
+
+		it("returns null when only custom combatants (no creatureId)", () => {
+			const wrapper = makeWrapper({
+				encounter: buildEncounter({
+					combatants: [
+						buildCombatant({
+							id: combatantId("c1"),
+							name: "Custom",
+							playerCharacterId: pcId1,
+						}),
+					],
+				}),
+				playerCharacters: [
+					{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 5 },
+				],
+			});
+
+			const { result } = renderHook(() => useDifficulty(), { wrapper });
+			expect(result.current).toBeNull();
+		});
+
+		it("returns null when bestiary monsters present but no PC combatants", () => {
+			const wrapper = makeWrapper({
+				encounter: buildEncounter({
+					combatants: [
+						buildCombatant({
+							id: combatantId("c1"),
+							name: "Goblin",
+							creatureId: crId1,
+						}),
+					],
+				}),
+				creatures: new Map([[crId1, goblinCreature]]),
+			});
+
+			const { result } = renderHook(() => useDifficulty(), { wrapper });
+			expect(result.current).toBeNull();
+		});
+
+		it("returns null when PC combatants have no level", () => {
+			const wrapper = makeWrapper({
+				encounter: buildEncounter({
+					combatants: [
+						buildCombatant({
+							id: combatantId("c1"),
+							name: "Hero",
+							playerCharacterId: pcId1,
+						}),
+						buildCombatant({
+							id: combatantId("c2"),
+							name: "Goblin",
+							creatureId: crId1,
+						}),
+					],
+				}),
+				playerCharacters: [{ id: pcId1, name: "Hero", ac: 15, maxHp: 30 }],
+				creatures: new Map([[crId1, goblinCreature]]),
+			});
+
+			const { result } = renderHook(() => useDifficulty(), { wrapper });
+			expect(result.current).toBeNull();
+		});
+
+		it("returns null when PC combatant references unknown player character", () => {
+			const wrapper = makeWrapper({
+				encounter: buildEncounter({
+					combatants: [
+						buildCombatant({
+							id: combatantId("c1"),
+							name: "Hero",
+							playerCharacterId: pcId2,
+						}),
+						buildCombatant({
+							id: combatantId("c2"),
+							name: "Goblin",
+							creatureId: crId1,
+						}),
+					],
+				}),
+				playerCharacters: [
+					{ id: pcId1, name: "Other", ac: 15, maxHp: 30, level: 5 },
+				],
+				creatures: new Map([[crId1, goblinCreature]]),
+			});
+
+			const { result } = renderHook(() => useDifficulty(), { wrapper });
+			expect(result.current).toBeNull();
+		});
+	});
+
+	it("handles mixed combatants: only leveled PCs and CR-bearing monsters contribute", async () => {
+		const wrapper = makeWrapper({
+			encounter: buildEncounter({
+				combatants: [
+					buildCombatant({
+						id: combatantId("c1"),
+						name: "Leveled",
+						playerCharacterId: pcId1,
+					}),
+					buildCombatant({
+						id: combatantId("c2"),
+						name: "No Level",
+						playerCharacterId: pcId2,
+					}),
+					buildCombatant({
+						id: combatantId("c3"),
+						name: "Goblin",
+						creatureId: crId1,
+					}),
+					buildCombatant({
+						id: combatantId("c4"),
+						name: "Custom Monster",
+					}),
+				],
+			}),
+			playerCharacters: [
+				{ id: pcId1, name: "Leveled", ac: 15, maxHp: 30, level: 1 },
+				{ id: pcId2, name: "No Level", ac: 12, maxHp: 20 },
+			],
+			creatures: new Map([[crId1, goblinCreature]]),
+		});
+
+		const { result } = renderHook(() => useDifficulty(), { wrapper });
+
+		await waitFor(() => {
+			expect(result.current).not.toBeNull();
+			// 1 level-1 PC: budget low=50, mod=75, high=100
+			// CR 1/4 = 50 XP -> low (50 >= 50)
+			expect(result.current?.tier).toBe(1);
+			expect(result.current?.totalMonsterXp).toBe(50);
+			expect(result.current?.thresholds[0].value).toBe(50);
+		});
+	});
+
+	it("includes duplicate PC combatants in budget", async () => {
+		const wrapper = makeWrapper({
+			encounter: buildEncounter({
+				combatants: [
+					buildCombatant({
+						id: combatantId("c1"),
+						name: "Hero 1",
+						playerCharacterId: pcId1,
+					}),
+					buildCombatant({
+						id: combatantId("c2"),
+						name: "Hero 2",
+						playerCharacterId: pcId1,
+					}),
+					buildCombatant({
+						id: combatantId("c3"),
+						name: "Goblin",
+						creatureId: crId1,
+					}),
+				],
+			}),
+			playerCharacters: [
+				{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 1 },
+			],
+			creatures: new Map([[crId1, goblinCreature]]),
+		});
+
+		const { result } = renderHook(() => useDifficulty(), { wrapper });
+
+		await waitFor(() => {
+			expect(result.current).not.toBeNull();
+			// 2x level 1: budget low=100
+			expect(result.current?.thresholds[0].value).toBe(100);
+		});
+	});
+
+	it("combatant toggled to party side subtracts XP", async () => {
+		const bugbear = buildCreature({
+			id: creatureId("srd:bugbear"),
+			name: "Bugbear",
+			cr: "1",
+		});
+		const wrapper = makeWrapper({
+			encounter: buildEncounter({
+				combatants: [
+					buildCombatant({
+						id: combatantId("c1"),
+						name: "Hero",
+						playerCharacterId: pcId1,
+					}),
+					buildCombatant({
+						id: combatantId("c2"),
+						name: "Allied Guard",
+						creatureId: bugbear.id,
+						side: "party",
+					}),
+					buildCombatant({
+						id: combatantId("c3"),
+						name: "Thug",
+						cr: "1",
+					}),
+				],
+			}),
+			playerCharacters: [
+				{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 1 },
+			],
+			creatures: new Map([[bugbear.id, bugbear]]),
+		});
+
+		const { result } = renderHook(() => useDifficulty(), { wrapper });
+
+		await waitFor(() => {
+			expect(result.current).not.toBeNull();
+			// Thug CR 1 = 200 XP, Allied Guard CR 1 = 200 XP subtracted, net = 0
+			expect(result.current?.totalMonsterXp).toBe(0);
+			expect(result.current?.tier).toBe(0);
+		});
+	});
+
+	it("default side resolution: PC -> party, non-PC -> enemy", async () => {
+		const wrapper = makeWrapper({
+			encounter: buildEncounter({
+				combatants: [
+					buildCombatant({
+						id: combatantId("c1"),
+						name: "Hero",
+						playerCharacterId: pcId1,
+					}),
+					buildCombatant({
+						id: combatantId("c2"),
+						name: "Goblin",
+						creatureId: crId1,
+					}),
+				],
+			}),
+			playerCharacters: [
+				{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 3 },
+			],
+			creatures: new Map([[crId1, goblinCreature]]),
+		});
+
+		const { result } = renderHook(() => useDifficulty(), { wrapper });
+
+		await waitFor(() => {
+			expect(result.current).not.toBeNull();
+			// Level 3 budget: low=150, mod=225, high=400
+			// CR 1/4 = 50 XP -> trivial
+			expect(result.current?.thresholds[0].value).toBe(150);
+			expect(result.current?.totalMonsterXp).toBe(50);
+			expect(result.current?.tier).toBe(0);
+		});
+	});
+
+	it("returns 2014 difficulty when edition is 5e", async () => {
+		const wrapper = makeWrapper({
+			encounter: buildEncounter({
+				combatants: [
+					buildCombatant({
+						id: combatantId("c1"),
+						name: "Hero",
+						playerCharacterId: pcId1,
+					}),
+					buildCombatant({
+						id: combatantId("c2"),
+						name: "Goblin",
+						creatureId: crId1,
+					}),
+				],
+			}),
+			playerCharacters: [
+				{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 1 },
+			],
+			creatures: new Map([[crId1, goblinCreature]]),
+		});
+
+		// Set edition via the hook's external store
+		const { result: editionResult } = renderHook(() => useRulesEdition(), {
+			wrapper,
+		});
+		editionResult.current.setEdition("5e");
+
+		try {
+			const { result } = renderHook(() => useDifficulty(), { wrapper });
+
+			await waitFor(() => {
+				expect(result.current).not.toBeNull();
+				// 2014: 4 thresholds with Easy/Medium/Hard/Deadly labels
+				expect(result.current?.thresholds).toHaveLength(4);
+				expect(result.current?.thresholds[0].label).toBe("Easy");
+				// CR 1/4 = 50 XP, 1 PC (<3) shifts x1 → x1.5, adjusted = 75
+				expect(result.current?.encounterMultiplier).toBe(1.5);
+				expect(result.current?.adjustedXp).toBe(75);
+			});
+		} finally {
+			editionResult.current.setEdition("5.5e");
+		}
+	});
+
+	it("custom combatant with CR on party side subtracts XP", async () => {
+		const wrapper = makeWrapper({
+			encounter: buildEncounter({
+				combatants: [
+					buildCombatant({
+						id: combatantId("c1"),
+						name: "Hero",
+						playerCharacterId: pcId1,
+					}),
+					buildCombatant({
+						id: combatantId("c2"),
+						name: "Ally",
+						cr: "2",
+						side: "party",
+					}),
+					buildCombatant({
+						id: combatantId("c3"),
+						name: "Goblin",
+						creatureId: crId1,
+					}),
+				],
+			}),
+			playerCharacters: [
+				{ id: pcId1, name: "Hero", ac: 15, maxHp: 30, level: 5 },
+			],
+			creatures: new Map([[crId1, goblinCreature]]),
+		});
+
+		const { result } = renderHook(() => useDifficulty(), { wrapper });
+
+		await waitFor(() => {
+			expect(result.current).not.toBeNull();
+			// CR 1/4 = 50 XP enemy, CR 2 = 450 XP ally subtracted, net = 0 (floored)
+			expect(result.current?.totalMonsterXp).toBe(0);
+		});
+	});
+});
--- a/apps/web/src/hooks/use-difficulty-breakdown.ts
+++ b/apps/web/src/hooks/use-difficulty-breakdown.ts
@@ -1,6 +1,7 @@
 import type {
 	Combatant,
 	CreatureId,
+	DifficultyThreshold,
 	DifficultyTier,
 	PlayerCharacter,
 } from "@initiative/domain";
@@ -9,6 +10,8 @@ import { useMemo } from "react";
 import { useBestiaryContext } from "../contexts/bestiary-context.js";
 import { useEncounterContext } from "../contexts/encounter-context.js";
 import { usePlayerCharactersContext } from "../contexts/player-characters-context.js";
+import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
+import { resolveSide } from "./use-difficulty.js";

 export interface BreakdownCombatant {
 	readonly combatant: Combatant;
@@ -16,125 +19,152 @@ export interface BreakdownCombatant {
 	readonly xp: number | null;
 	readonly source: string | null;
 	readonly editable: boolean;
+	readonly side: "party" | "enemy";
+	readonly level: number | undefined;
 }

 interface DifficultyBreakdown {
 	readonly tier: DifficultyTier;
 	readonly totalMonsterXp: number;
-	readonly partyBudget: {
-		readonly low: number;
-		readonly moderate: number;
-		readonly high: number;
-	};
+	readonly thresholds: readonly DifficultyThreshold[];
+	readonly encounterMultiplier: number | undefined;
+	readonly adjustedXp: number | undefined;
+	readonly partySizeAdjusted: boolean | undefined;
 	readonly pcCount: number;
-	readonly combatants: readonly BreakdownCombatant[];
+	readonly partyCombatants: readonly BreakdownCombatant[];
+	readonly enemyCombatants: readonly BreakdownCombatant[];
 }

 export function useDifficultyBreakdown(): DifficultyBreakdown | null {
 	const { encounter } = useEncounterContext();
 	const { characters } = usePlayerCharactersContext();
 	const { getCreature } = useBestiaryContext();
+	const { edition } = useRulesEditionContext();

 	return useMemo(() => {
-		const partyLevels = derivePartyLevels(encounter.combatants, characters);
-		const { entries, crs } = classifyCombatants(
-			encounter.combatants,
-			getCreature,
+		const { partyCombatants, enemyCombatants, descriptors, pcCount } =
+			classifyCombatants(encounter.combatants, characters, getCreature);
+
+		const hasPartyLevel = descriptors.some(
+			(d) => d.side === "party" && d.level !== undefined,
 		);
+		const hasCr = descriptors.some((d) => d.cr !== undefined);

-		if (partyLevels.length === 0 || crs.length === 0) {
-			return null;
-		}
+		if (!hasPartyLevel || !hasCr) return null;

-		const result = calculateEncounterDifficulty(partyLevels, crs);
+		const result = calculateEncounterDifficulty(descriptors, edition);

 		return {
 			...result,
-			pcCount: partyLevels.length,
-			combatants: entries,
+			pcCount,
+			partyCombatants,
+			enemyCombatants,
 		};
-	}, [encounter.combatants, characters, getCreature]);
+	}, [encounter.combatants, characters, getCreature, edition]);
 }

-function classifyBestiaryCombatant(
+type CreatureInfo = {
+	cr: string;
+	source: string;
+	sourceDisplayName: string;
+};
+
+function buildBreakdownEntry(
 	c: Combatant,
-	getCreature: (
-		id: CreatureId,
-	) => { cr: string; source: string; sourceDisplayName: string } | undefined,
-): { entry: BreakdownCombatant; cr: string | null } {
-	const creature = c.creatureId ? getCreature(c.creatureId) : undefined;
+	side: "party" | "enemy",
+	level: number | undefined,
+	creature: CreatureInfo | undefined,
+): BreakdownCombatant {
+	if (c.playerCharacterId) {
+		return {
+			combatant: c,
+			cr: null,
+			xp: null,
+			source: null,
+			editable: false,
+			side,
+			level,
+		};
+	}
 	if (creature) {
 		return {
-			entry: {
 			combatant: c,
 			cr: creature.cr,
 			xp: crToXp(creature.cr),
 			source: creature.sourceDisplayName ?? creature.source,
 			editable: false,
-			},
-			cr: creature.cr,
+			side,
+			level: undefined,
 		};
 	}
+	if (c.cr) {
 		return {
-		entry: {
-			combatant: c,
-			cr: null,
-			xp: null,
-			source: null,
-			editable: false,
-		},
-		cr: null,
-	};
-}
-
-function classifyCombatants(
-	combatants: readonly Combatant[],
-	getCreature: (
-		id: CreatureId,
-	) => { cr: string; source: string; sourceDisplayName: string } | undefined,
-): { entries: BreakdownCombatant[]; crs: string[] } {
-	const entries: BreakdownCombatant[] = [];
-	const crs: string[] = [];
-
-	for (const c of combatants) {
-		if (c.playerCharacterId) continue;
-
-		if (c.creatureId) {
-			const { entry, cr } = classifyBestiaryCombatant(c, getCreature);
-			entries.push(entry);
-			if (cr) crs.push(cr);
-		} else if (c.cr) {
-			crs.push(c.cr);
-			entries.push({
 			combatant: c,
 			cr: c.cr,
 			xp: crToXp(c.cr),
 			source: null,
 			editable: true,
-			});
-		} else {
-			entries.push({
+			side,
+			level: undefined,
+		};
+	}
+	return {
 		combatant: c,
 		cr: null,
 		xp: null,
 		source: null,
-				editable: true,
-			});
-		}
+		editable: !c.creatureId,
+		side,
+		level: undefined,
+	};
 }

-	return { entries, crs };
+function resolveLevel(
+	c: Combatant,
+	characters: readonly PlayerCharacter[],
+): number | undefined {
+	if (!c.playerCharacterId) return undefined;
+	return characters.find((p) => p.id === c.playerCharacterId)?.level;
 }

-function derivePartyLevels(
+function resolveCr(
+	c: Combatant,
+	getCreature: (id: CreatureId) => CreatureInfo | undefined,
+): { cr: string | null; creature: CreatureInfo | undefined } {
+	const creature = c.creatureId ? getCreature(c.creatureId) : undefined;
+	const cr = creature ? creature.cr : (c.cr ?? null);
+	return { cr, creature };
+}
+
+function classifyCombatants(
 	combatants: readonly Combatant[],
 	characters: readonly PlayerCharacter[],
-): number[] {
-	const levels: number[] = [];
+	getCreature: (id: CreatureId) => CreatureInfo | undefined,
+) {
+	const partyCombatants: BreakdownCombatant[] = [];
+	const enemyCombatants: BreakdownCombatant[] = [];
+	const descriptors: {
+		level?: number;
+		cr?: string;
+		side: "party" | "enemy";
+	}[] = [];
+	let pcCount = 0;
+
 	for (const c of combatants) {
-		if (!c.playerCharacterId) continue;
-		const pc = characters.find((p) => p.id === c.playerCharacterId);
-		if (pc?.level !== undefined) levels.push(pc.level);
+		const side = resolveSide(c);
+		const level = resolveLevel(c, characters);
+		if (level !== undefined) pcCount++;
+
+		const { cr, creature } = resolveCr(c, getCreature);
+
+		if (level !== undefined || cr != null) {
+			descriptors.push({ level, cr: cr ?? undefined, side });
 		}
-	return levels;
+
+		const entry = buildBreakdownEntry(c, side, level, creature);
+		const target = side === "party" ? partyCombatants : enemyCombatants;
+		target.push(entry);
+	}
+
+	return { partyCombatants, enemyCombatants, descriptors, pcCount };
 }
--- a/apps/web/src/hooks/use-difficulty.ts
+++ b/apps/web/src/hooks/use-difficulty.ts
@@ -1,5 +1,6 @@
 import type {
 	Combatant,
+	CombatantDescriptor,
 	CreatureId,
 	DifficultyResult,
 	PlayerCharacter,
@@ -9,49 +10,55 @@ import { useMemo } from "react";
 import { useBestiaryContext } from "../contexts/bestiary-context.js";
 import { useEncounterContext } from "../contexts/encounter-context.js";
 import { usePlayerCharactersContext } from "../contexts/player-characters-context.js";
+import { useRulesEditionContext } from "../contexts/rules-edition-context.js";

-function derivePartyLevels(
+export function resolveSide(c: Combatant): "party" | "enemy" {
+	if (c.side) return c.side;
+	return c.playerCharacterId ? "party" : "enemy";
+}
+
+function buildDescriptors(
 	combatants: readonly Combatant[],
 	characters: readonly PlayerCharacter[],
-): number[] {
-	const levels: number[] = [];
-	for (const c of combatants) {
-		if (!c.playerCharacterId) continue;
-		const pc = characters.find((p) => p.id === c.playerCharacterId);
-		if (pc?.level !== undefined) levels.push(pc.level);
-	}
-	return levels;
-}
-
-function deriveMonsterCrs(
-	combatants: readonly Combatant[],
 	getCreature: (id: CreatureId) => { cr: string } | undefined,
-): string[] {
-	const crs: string[] = [];
+): CombatantDescriptor[] {
+	const descriptors: CombatantDescriptor[] = [];
 	for (const c of combatants) {
-		if (c.creatureId) {
-			const creature = getCreature(c.creatureId);
-			if (creature) crs.push(creature.cr);
-		} else if (c.cr) {
-			crs.push(c.cr);
+		const side = resolveSide(c);
+		const level = c.playerCharacterId
+			? characters.find((p) => p.id === c.playerCharacterId)?.level
+			: undefined;
+		const cr = c.creatureId
+			? getCreature(c.creatureId)?.cr
+			: (c.cr ?? undefined);
+
+		if (level !== undefined || cr !== undefined) {
+			descriptors.push({ level, cr, side });
 		}
 	}
-	return crs;
+	return descriptors;
 }

 export function useDifficulty(): DifficultyResult | null {
 	const { encounter } = useEncounterContext();
 	const { characters } = usePlayerCharactersContext();
 	const { getCreature } = useBestiaryContext();
+	const { edition } = useRulesEditionContext();

 	return useMemo(() => {
-		const partyLevels = derivePartyLevels(encounter.combatants, characters);
-		const monsterCrs = deriveMonsterCrs(encounter.combatants, getCreature);
+		const descriptors = buildDescriptors(
+			encounter.combatants,
+			characters,
+			getCreature,
+		);

-		if (partyLevels.length === 0 || monsterCrs.length === 0) {
-			return null;
-		}
+		const hasPartyLevel = descriptors.some(
+			(d) => d.side === "party" && d.level !== undefined,
+		);
+		const hasCr = descriptors.some((d) => d.cr !== undefined);

-		return calculateEncounterDifficulty(partyLevels, monsterCrs);
-	}, [encounter.combatants, characters, getCreature]);
+		if (!hasPartyLevel || !hasCr) return null;
+
+		return calculateEncounterDifficulty(descriptors, edition);
+	}, [encounter.combatants, characters, getCreature, edition]);
 }
--- a/apps/web/src/hooks/use-encounter.ts
+++ b/apps/web/src/hooks/use-encounter.ts
@@ -12,6 +12,7 @@ import {
 	setCrUseCase,
 	setHpUseCase,
 	setInitiativeUseCase,
+	setSideUseCase,
 	setTempHpUseCase,
 	toggleConcentrationUseCase,
 	toggleConditionUseCase,
@@ -54,6 +55,7 @@ type EncounterAction =
 	| { type: "set-temp-hp"; id: CombatantId; tempHp: number | undefined }
 	| { type: "set-ac"; id: CombatantId; value: number | undefined }
 	| { type: "set-cr"; id: CombatantId; value: string | undefined }
+	| { type: "set-side"; id: CombatantId; value: "party" | "enemy" }
 	| {
 			type: "toggle-condition";
 			id: CombatantId;
@@ -321,6 +323,7 @@ function dispatchEncounterAction(
 		| { type: "set-temp-hp" }
 		| { type: "set-ac" }
 		| { type: "set-cr" }
+		| { type: "set-side" }
 		| { type: "toggle-condition" }
 		| { type: "toggle-concentration" }
 	>,
@@ -364,6 +367,9 @@ function dispatchEncounterAction(
 		case "set-cr":
 			result = setCrUseCase(store, action.id, action.value);
 			break;
+		case "set-side":
+			result = setSideUseCase(store, action.id, action.value);
+			break;
 		case "toggle-condition":
 			result = toggleConditionUseCase(store, action.id, action.conditionId);
 			break;
@@ -506,6 +512,11 @@ export function useEncounter() {
 				dispatch({ type: "set-cr", id, value }),
 			[],
 		),
+		setSide: useCallback(
+			(id: CombatantId, value: "party" | "enemy") =>
+				dispatch({ type: "set-side", id, value }),
+			[],
+		),
 		toggleCondition: useCallback(
 			(id: CombatantId, conditionId: ConditionId) =>
 				dispatch({ type: "toggle-condition", id, conditionId }),
--- a/apps/web/src/persistence/tests/encounter-storage.test.ts
+++ b/apps/web/src/persistence/tests/encounter-storage.test.ts
@@ -154,6 +154,47 @@ describe("loadEncounter", () => {
 		expect(loaded?.combatants[0].cr).toBe("2");
 	});

+	it("round-trip preserves combatant side field", () => {
+		const result = createEncounter(
+			[
+				{
+					id: combatantId("c-1"),
+					name: "Allied Guard",
+					cr: "2",
+					side: "party",
+				},
+				{
+					id: combatantId("c-2"),
+					name: "Goblin",
+					side: "enemy",
+				},
+			],
+			0,
+			1,
+		);
+		if (isDomainError(result)) throw new Error("unreachable");
+		saveEncounter(result);
+		const loaded = loadEncounter();
+
+		expect(loaded).not.toBeNull();
+		expect(loaded?.combatants[0].side).toBe("party");
+		expect(loaded?.combatants[1].side).toBe("enemy");
+	});
+
+	it("round-trip preserves combatant without side field as undefined", () => {
+		const result = createEncounter(
+			[{ id: combatantId("c-1"), name: "Custom" }],
+			0,
+			1,
+		);
+		if (isDomainError(result)) throw new Error("unreachable");
+		saveEncounter(result);
+		const loaded = loadEncounter();
+
+		expect(loaded).not.toBeNull();
+		expect(loaded?.combatants[0].side).toBeUndefined();
+	});
+
 	it("saving after modifications persists the latest state", () => {
 		const encounter = makeEncounter();
 		saveEncounter(encounter);
--- a/packages/application/src/index.ts
+++ b/packages/application/src/index.ts
@@ -24,6 +24,7 @@ export { setAcUseCase } from "./set-ac-use-case.js";
 export { setCrUseCase } from "./set-cr-use-case.js";
 export { setHpUseCase } from "./set-hp-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";
 export { toggleConcentrationUseCase } from "./toggle-concentration-use-case.js";
 export { toggleConditionUseCase } from "./toggle-condition-use-case.js";
--- a/packages/application/src/set-side-use-case.ts
+++ b/packages/application/src/set-side-use-case.ts
@@ -0,0 +1,18 @@
+import {
+	type CombatantId,
+	type DomainError,
+	type DomainEvent,
+	setSide,
+} from "@initiative/domain";
+import type { EncounterStore } from "./ports.js";
+import { runEncounterAction } from "./run-encounter-action.js";
+
+export function setSideUseCase(
+	store: EncounterStore,
+	combatantId: CombatantId,
+	value: "party" | "enemy",
+): DomainEvent[] | DomainError {
+	return runEncounterAction(store, (encounter) =>
+		setSide(encounter, combatantId, value),
+	);
+}
--- a/packages/domain/src/tests/encounter-difficulty.test.ts
+++ b/packages/domain/src/tests/encounter-difficulty.test.ts
@@ -36,98 +36,353 @@ describe("crToXp", () => {
 	});
 });

-describe("calculateEncounterDifficulty", () => {
-	it("returns trivial when monster XP is below Low threshold", () => {
+/** Helper to build party-side descriptors with level. */
+function party(level: number) {
+	return { level, side: "party" as const };
+}
+
+/** Helper to build enemy-side descriptors with CR. */
+function enemy(cr: string) {
+	return { cr, side: "enemy" as const };
+}
+
+describe("calculateEncounterDifficulty — 5.5e edition", () => {
+	it("returns tier 0 when monster XP is below Low threshold", () => {
 		// 4x level 1: Low = 200, Moderate = 300, High = 400
-		// 1x CR 0 = 0 XP → trivial
-		const result = calculateEncounterDifficulty([1, 1, 1, 1], ["0"]);
-		expect(result.tier).toBe("trivial");
+		// 1x CR 0 = 0 XP -> tier 0
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), party(1), party(1), enemy("0")],
+			"5.5e",
+		);
+		expect(result.tier).toBe(0);
 		expect(result.totalMonsterXp).toBe(0);
-		expect(result.partyBudget).toEqual({
-			low: 200,
-			moderate: 300,
-			high: 400,
-		});
+		expect(result.thresholds).toEqual([
+			{ label: "Low", value: 200 },
+			{ label: "Moderate", value: 300 },
+			{ label: "High", value: 400 },
+		]);
+		expect(result.encounterMultiplier).toBeUndefined();
+		expect(result.adjustedXp).toBeUndefined();
+		expect(result.partySizeAdjusted).toBeUndefined();
 	});

-	it("returns low for 4x level 1 vs Bugbear (CR 1)", () => {
-		// DMG example: 4x level 1 PCs vs 1 Bugbear (CR 1, 200 XP)
-		// Low = 200, Moderate = 300 → 200 >= 200 but < 300 → Low
-		const result = calculateEncounterDifficulty([1, 1, 1, 1], ["1"]);
-		expect(result.tier).toBe("low");
+	it("returns tier 1 for 4x level 1 vs Bugbear (CR 1)", () => {
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), party(1), party(1), enemy("1")],
+			"5.5e",
+		);
+		expect(result.tier).toBe(1);
 		expect(result.totalMonsterXp).toBe(200);
 	});

-	it("returns moderate for 5x level 3 vs 1125 XP", () => {
+	it("returns tier 2 for 5x level 3 vs 1150 XP", () => {
 		// 5x level 3: Low = 750, Moderate = 1125, High = 2000
-		// 1125 XP >= 1125 Moderate but < 2000 High → Moderate
-		// Using CR 3 (700) + CR 2 (450) = 1150 XP ≈ 1125 threshold
-		// Let's use exact: 5 * 225 = 1125 moderate budget
-		// Need monsters that sum exactly to 1125: CR 3 (700) + CR 2 (450) = 1150
-		const result = calculateEncounterDifficulty([3, 3, 3, 3, 3], ["3", "2"]);
-		expect(result.tier).toBe("moderate");
+		// CR 3 (700) + CR 2 (450) = 1150 XP >= 1125 Moderate
+		const result = calculateEncounterDifficulty(
+			[
+				party(3),
+				party(3),
+				party(3),
+				party(3),
+				party(3),
+				enemy("3"),
+				enemy("2"),
+			],
+			"5.5e",
+		);
+		expect(result.tier).toBe(2);
 		expect(result.totalMonsterXp).toBe(1150);
-		expect(result.partyBudget.moderate).toBe(1125);
+		expect(result.thresholds[1].value).toBe(1125);
 	});

-	it("returns high when XP meets High threshold", () => {
+	it("returns tier 3 when XP meets High threshold", () => {
 		// 4x level 1: High = 400
-		// 2x CR 1 = 400 XP → High
-		const result = calculateEncounterDifficulty([1, 1, 1, 1], ["1", "1"]);
-		expect(result.tier).toBe("high");
+		// 2x CR 1 = 400 XP -> tier 3
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), party(1), party(1), enemy("1"), enemy("1")],
+			"5.5e",
+		);
+		expect(result.tier).toBe(3);
 		expect(result.totalMonsterXp).toBe(400);
 	});

-	it("caps at high when XP far exceeds threshold", () => {
-		// 4x level 1: High = 400
-		// CR 30 = 155000 XP → still High (no tier above)
-		const result = calculateEncounterDifficulty([1, 1, 1, 1], ["30"]);
-		expect(result.tier).toBe("high");
+	it("caps at tier 3 when XP far exceeds threshold", () => {
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), party(1), party(1), enemy("30")],
+			"5.5e",
+		);
+		expect(result.tier).toBe(3);
 		expect(result.totalMonsterXp).toBe(155000);
 	});

 	it("handles mixed party levels", () => {
 		// 3x level 3 + 1x level 2
-		// level 3: low=150, mod=225, high=400 (x3 = 450, 675, 1200)
-		// level 2: low=100, mod=150, high=200 (x1 = 100, 150, 200)
 		// Total: low=550, mod=825, high=1400
-		const result = calculateEncounterDifficulty([3, 3, 3, 2], ["3"]);
-		expect(result.partyBudget).toEqual({
-			low: 550,
-			moderate: 825,
-			high: 1400,
-		});
+		const result = calculateEncounterDifficulty(
+			[party(3), party(3), party(3), party(2), enemy("3")],
+			"5.5e",
+		);
+		expect(result.thresholds).toEqual([
+			{ label: "Low", value: 550 },
+			{ label: "Moderate", value: 825 },
+			{ label: "High", value: 1400 },
+		]);
 		expect(result.totalMonsterXp).toBe(700);
-		expect(result.tier).toBe("low");
+		expect(result.tier).toBe(1);
 	});

-	it("returns trivial with empty monster array", () => {
-		const result = calculateEncounterDifficulty([5, 5], []);
-		expect(result.tier).toBe("trivial");
+	it("returns tier 0 with no enemies", () => {
+		const result = calculateEncounterDifficulty([party(5), party(5)], "5.5e");
+		expect(result.tier).toBe(0);
 		expect(result.totalMonsterXp).toBe(0);
 	});

-	it("returns high with empty party array (zero budget thresholds)", () => {
-		// Domain function treats empty party as zero budgets — any XP exceeds all thresholds.
-		// The useDifficulty hook guards this path by returning null when no leveled PCs exist.
-		const result = calculateEncounterDifficulty([], ["1"]);
-		expect(result.tier).toBe("high");
+	it("returns tier 3 with no party levels (zero budget thresholds)", () => {
+		const result = calculateEncounterDifficulty([enemy("1")], "5.5e");
+		expect(result.tier).toBe(3);
 		expect(result.totalMonsterXp).toBe(200);
-		expect(result.partyBudget).toEqual({ low: 0, moderate: 0, high: 0 });
+		expect(result.thresholds).toEqual([
+			{ label: "Low", value: 0 },
+			{ label: "Moderate", value: 0 },
+			{ label: "High", value: 0 },
+		]);
 	});

 	it("handles fractional CRs", () => {
 		const result = calculateEncounterDifficulty(
-			[1, 1, 1, 1],
-			["1/8", "1/4", "1/2"],
+			[
+				party(1),
+				party(1),
+				party(1),
+				party(1),
+				enemy("1/8"),
+				enemy("1/4"),
+				enemy("1/2"),
+			],
+			"5.5e",
 		);
 		expect(result.totalMonsterXp).toBe(175); // 25 + 50 + 100
-		expect(result.tier).toBe("trivial"); // 175 < 200 Low
+		expect(result.tier).toBe(0); // 175 < 200 Low
 	});

 	it("ignores unknown CRs (0 XP)", () => {
-		const result = calculateEncounterDifficulty([1, 1, 1, 1], ["unknown"]);
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), party(1), party(1), enemy("unknown")],
+			"5.5e",
+		);
 		expect(result.totalMonsterXp).toBe(0);
-		expect(result.tier).toBe("trivial");
+		expect(result.tier).toBe(0);
+	});
+
+	it("subtracts XP for party-side combatant with CR", () => {
+		// 4x level 1 party, 1 enemy CR 2 (450 XP), 1 party CR 1 (200 XP)
+		// Net = 450 - 200 = 250
+		const result = calculateEncounterDifficulty(
+			[
+				party(1),
+				party(1),
+				party(1),
+				party(1),
+				enemy("2"),
+				{ cr: "1", side: "party" },
+			],
+			"5.5e",
+		);
+		expect(result.totalMonsterXp).toBe(250);
+		expect(result.tier).toBe(1); // 250 >= 200 Low, < 300 Moderate
+	});
+
+	it("floors net monster XP at 0", () => {
+		// Party ally has more XP than enemy
+		const result = calculateEncounterDifficulty(
+			[
+				party(1),
+				{ cr: "5", side: "party" }, // 1800 XP subtracted
+				enemy("1"), // 200 XP added
+			],
+			"5.5e",
+		);
+		expect(result.totalMonsterXp).toBe(0);
+		expect(result.tier).toBe(0);
+	});
+
+	it("dual contribution: combatant with both level and CR on party side", () => {
+		// Party combatant with level 1 AND CR 1 on party side
+		// Level contributes to budget, CR subtracts from monster XP
+		const result = calculateEncounterDifficulty(
+			[
+				{ level: 1, cr: "1", side: "party" }, // budget += lv1, monsterXp -= 200
+				enemy("2"), // monsterXp += 450
+			],
+			"5.5e",
+		);
+		expect(result.thresholds).toEqual([
+			{ label: "Low", value: 50 },
+			{ label: "Moderate", value: 75 },
+			{ label: "High", value: 100 },
+		]);
+		expect(result.totalMonsterXp).toBe(250); // 450 - 200
+	});
+
+	it("enemy-side combatant with level does NOT contribute to budget", () => {
+		const result = calculateEncounterDifficulty(
+			[party(1), { level: 5, side: "enemy" }, enemy("1")],
+			"5.5e",
+		);
+		// Only level 1 party contributes to budget
+		expect(result.thresholds).toEqual([
+			{ label: "Low", value: 50 },
+			{ label: "Moderate", value: 75 },
+			{ label: "High", value: 100 },
+		]);
+		expect(result.totalMonsterXp).toBe(200);
+	});
+
+	it("mixed sides calculate correctly", () => {
+		// 2 party PCs (level 3), 1 party ally (CR 1, 200 XP), 2 enemies (CR 2, 450 each)
+		// Budget: 2x level 3 = low 300, mod 450, high 800
+		// Monster XP: 900 - 200 = 700
+		const result = calculateEncounterDifficulty(
+			[party(3), party(3), { cr: "1", side: "party" }, enemy("2"), enemy("2")],
+			"5.5e",
+		);
+		expect(result.thresholds).toEqual([
+			{ label: "Low", value: 300 },
+			{ label: "Moderate", value: 450 },
+			{ label: "High", value: 800 },
+		]);
+		expect(result.totalMonsterXp).toBe(700);
+		expect(result.tier).toBe(2); // 700 >= 450 Moderate, < 800 High
+	});
+});
+
+describe("calculateEncounterDifficulty — 2014 edition", () => {
+	it("uses 2014 XP thresholds table", () => {
+		// 4x level 1: Easy=100, Medium=200, Hard=300, Deadly=400
+		// 1 enemy CR 1 = 200 XP, x1 multiplier = 200 adjusted
+		// 200 >= 200 Medium → tier 1
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), party(1), party(1), enemy("1")],
+			"5e",
+		);
+		expect(result.tier).toBe(1);
+		expect(result.thresholds).toEqual([
+			{ label: "Easy", value: 100 },
+			{ label: "Medium", value: 200 },
+			{ label: "Hard", value: 300 },
+			{ label: "Deadly", value: 400 },
+		]);
+	});
+
+	it("applies encounter multiplier for 3 monsters (x2)", () => {
+		const result = calculateEncounterDifficulty(
+			[
+				party(1),
+				party(1),
+				party(1),
+				party(1),
+				enemy("1/8"),
+				enemy("1/8"),
+				enemy("1/8"),
+			],
+			"5e",
+		);
+		// Base: 75 XP, 3 monsters → x2 = 150 adjusted
+		expect(result.totalMonsterXp).toBe(75);
+		expect(result.encounterMultiplier).toBe(2);
+		expect(result.adjustedXp).toBe(150);
+	});
+
+	it("shifts multiplier up for fewer than 3 PCs", () => {
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), enemy("1")],
+			"5e",
+		);
+		// 1 monster, 2 PCs → base x1 shifts up to x1.5
+		expect(result.encounterMultiplier).toBe(1.5);
+		expect(result.partySizeAdjusted).toBe(true);
+	});
+
+	it("shifts multiplier down for 6+ PCs", () => {
+		const result = calculateEncounterDifficulty(
+			[
+				party(1),
+				party(1),
+				party(1),
+				party(1),
+				party(1),
+				party(1),
+				enemy("1"),
+				enemy("1"),
+				enemy("1"),
+			],
+			"5e",
+		);
+		// 3 monsters, 6 PCs → base x2 shifts down to x1.5
+		expect(result.encounterMultiplier).toBe(1.5);
+		expect(result.partySizeAdjusted).toBe(true);
+	});
+
+	it("shifts multiplier to x5 for 15+ monsters with <3 PCs", () => {
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), ...Array.from({ length: 15 }, () => enemy("0"))],
+			"5e",
+		);
+		// 15+ monsters = x4 base, shift up → x5
+		expect(result.encounterMultiplier).toBe(5);
+		expect(result.partySizeAdjusted).toBe(true);
+	});
+
+	it("shifts multiplier to x0.5 for 1 monster with 6+ PCs", () => {
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), party(1), party(1), party(1), party(1), enemy("1")],
+			"5e",
+		);
+		expect(result.encounterMultiplier).toBe(0.5);
+		expect(result.partySizeAdjusted).toBe(true);
+	});
+
+	it("only counts enemy-side combatants for monster count", () => {
+		const result = calculateEncounterDifficulty(
+			[
+				party(1),
+				party(1),
+				party(1),
+				party(1),
+				{ cr: "1", side: "party" },
+				enemy("1"),
+				enemy("1"),
+				enemy("1"),
+			],
+			"5e",
+		);
+		// 3 enemy monsters → x2, NOT 4
+		expect(result.encounterMultiplier).toBe(2);
+	});
+
+	it("returns tier 0 when adjusted XP meets Easy but not Medium", () => {
+		// 4x level 1: Easy=100, Medium=200
+		// 1 enemy CR 1/2 = 100 XP, x1 multiplier = 100 adjusted
+		// 100 >= Easy(100) but < Medium(200) → tier 0
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), party(1), party(1), enemy("1/2")],
+			"5e",
+		);
+		expect(result.tier).toBe(0);
+		expect(result.adjustedXp).toBe(100);
+	});
+
+	it("returns no party size adjustment for standard party (3-5)", () => {
+		const result = calculateEncounterDifficulty(
+			[party(1), party(1), party(1), party(1), enemy("1")],
+			"5e",
+		);
+		expect(result.partySizeAdjusted).toBe(false);
+	});
+
+	it("returns undefined multiplier/adjustedXp for 5.5e", () => {
+		const result = calculateEncounterDifficulty([party(1), enemy("1")], "5.5e");
+		expect(result.encounterMultiplier).toBeUndefined();
+		expect(result.adjustedXp).toBeUndefined();
 	});
 });
--- a/packages/domain/src/tests/rehydrate-combatant.test.ts
+++ b/packages/domain/src/tests/rehydrate-combatant.test.ts
@@ -241,6 +241,28 @@ describe("rehydrateCombatant", () => {
 			expect(result?.cr).toBeUndefined();
 		});

+		it("preserves valid side field", () => {
+			for (const side of ["party", "enemy"]) {
+				const result = rehydrateCombatant({ ...minimalCombatant(), side });
+				expect(result).not.toBeNull();
+				expect(result?.side).toBe(side);
+			}
+		});
+
+		it("drops invalid side field", () => {
+			for (const side of ["ally", "", 42, null, true]) {
+				const result = rehydrateCombatant({ ...minimalCombatant(), side });
+				expect(result).not.toBeNull();
+				expect(result?.side).toBeUndefined();
+			}
+		});
+
+		it("combatant without side rehydrates as before", () => {
+			const result = rehydrateCombatant(minimalCombatant());
+			expect(result).not.toBeNull();
+			expect(result?.side).toBeUndefined();
+		});
+
 		it("drops invalid tempHp — keeps combatant", () => {
 			for (const tempHp of [-1, 1.5, "3"]) {
 				const result = rehydrateCombatant({
--- a/packages/domain/src/tests/set-side.test.ts
+++ b/packages/domain/src/tests/set-side.test.ts
@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+import { setSide } from "../set-side.js";
+import type { Combatant, Encounter } from "../types.js";
+import { combatantId, isDomainError } from "../types.js";
+import { expectDomainError } from "./test-helpers.js";
+
+function makeCombatant(name: string, side?: "party" | "enemy"): Combatant {
+	return side === undefined
+		? { id: combatantId(name), name }
+		: { id: combatantId(name), name, side };
+}
+
+function enc(
+	combatants: Combatant[],
+	activeIndex = 0,
+	roundNumber = 1,
+): Encounter {
+	return { combatants, activeIndex, roundNumber };
+}
+
+function successResult(
+	encounter: Encounter,
+	id: string,
+	value: "party" | "enemy",
+) {
+	const result = setSide(encounter, combatantId(id), value);
+	if (isDomainError(result)) {
+		throw new Error(`Expected success, got error: ${result.message}`);
+	}
+	return result;
+}
+
+describe("setSide", () => {
+	it("sets side to party", () => {
+		const e = enc([makeCombatant("A"), makeCombatant("B")]);
+		const { encounter, events } = successResult(e, "A", "party");
+
+		expect(encounter.combatants[0].side).toBe("party");
+		expect(events).toEqual([
+			{
+				type: "SideSet",
+				combatantId: combatantId("A"),
+				previousSide: undefined,
+				newSide: "party",
+			},
+		]);
+	});
+
+	it("sets side to enemy", () => {
+		const e = enc([makeCombatant("A")]);
+		const { encounter } = successResult(e, "A", "enemy");
+
+		expect(encounter.combatants[0].side).toBe("enemy");
+	});
+
+	it("records previous side in event", () => {
+		const e = enc([makeCombatant("A", "party")]);
+		const { events } = successResult(e, "A", "enemy");
+
+		expect(events[0]).toMatchObject({
+			previousSide: "party",
+			newSide: "enemy",
+		});
+	});
+
+	it("returns error for nonexistent combatant", () => {
+		const e = enc([makeCombatant("A")]);
+		const result = setSide(e, combatantId("nonexistent"), "party");
+
+		expectDomainError(result, "combatant-not-found");
+	});
+
+	it("preserves other fields when setting side", () => {
+		const combatant: Combatant = {
+			id: combatantId("A"),
+			name: "Aria",
+			initiative: 15,
+			maxHp: 20,
+			currentHp: 18,
+			ac: 14,
+			cr: "2",
+		};
+		const e = enc([combatant]);
+		const { encounter } = successResult(e, "A", "party");
+
+		const updated = encounter.combatants[0];
+		expect(updated.side).toBe("party");
+		expect(updated.name).toBe("Aria");
+		expect(updated.initiative).toBe(15);
+		expect(updated.cr).toBe("2");
+	});
+
+	it("does not reorder combatants", () => {
+		const e = enc([makeCombatant("A"), makeCombatant("B")]);
+		const { encounter } = successResult(e, "B", "party");
+
+		expect(encounter.combatants[0].id).toBe(combatantId("A"));
+		expect(encounter.combatants[1].id).toBe(combatantId("B"));
+	});
+
+	it("preserves activeIndex and roundNumber", () => {
+		const e = enc([makeCombatant("A"), makeCombatant("B")], 1, 5);
+		const { encounter } = successResult(e, "A", "party");
+
+		expect(encounter.activeIndex).toBe(1);
+		expect(encounter.roundNumber).toBe(5);
+	});
+
+	it("does not mutate input encounter", () => {
+		const e = enc([makeCombatant("A")]);
+		const original = JSON.parse(JSON.stringify(e));
+		setSide(e, combatantId("A"), "party");
+		expect(e).toEqual(original);
+	});
+});
--- a/packages/domain/src/conditions.ts
+++ b/packages/domain/src/conditions.ts
@@ -17,7 +17,7 @@ export type ConditionId =
 	| "stunned"
 	| "unconscious";

-export type RulesEdition = "5e" | "5.5e";
+import type { RulesEdition } from "./rules-edition.js";

 export interface ConditionDefinition {
 	readonly id: ConditionId;
--- a/packages/domain/src/encounter-difficulty.ts
+++ b/packages/domain/src/encounter-difficulty.ts
@@ -1,13 +1,23 @@
-export type DifficultyTier = "trivial" | "low" | "moderate" | "high";
+import type { RulesEdition } from "./rules-edition.js";
+
+/** Abstract difficulty severity: 0 = negligible, 3 = maximum. Maps to filled bar count. */
+export type DifficultyTier = 0 | 1 | 2 | 3;
+
+export interface DifficultyThreshold {
+	readonly label: string;
+	readonly value: number;
+}

 export interface DifficultyResult {
 	readonly tier: DifficultyTier;
 	readonly totalMonsterXp: number;
-	readonly partyBudget: {
-		readonly low: number;
-		readonly moderate: number;
-		readonly high: number;
-	};
+	readonly thresholds: readonly DifficultyThreshold[];
+	/** 2014 only: the encounter multiplier applied to base monster XP. */
+	readonly encounterMultiplier: number | undefined;
+	/** 2014 only: monster XP after applying the encounter multiplier. */
+	readonly adjustedXp: number | undefined;
+	/** 2014 only: true when the multiplier was shifted due to party size (<3 or 6+). */
+	readonly partySizeAdjusted: boolean | undefined;
 }

 /** Maps challenge rating strings to XP values (standard 5e). */
@@ -74,6 +84,82 @@ const XP_BUDGET_PER_CHARACTER: Readonly<
 	20: { low: 6400, moderate: 13200, high: 22000 },
 };

+/** Maps character level (1-20) to XP thresholds (2014 DMG). */
+const XP_THRESHOLDS_2014: Readonly<
+	Record<number, { easy: number; medium: number; hard: number; deadly: number }>
+> = {
+	1: { easy: 25, medium: 50, hard: 75, deadly: 100 },
+	2: { easy: 50, medium: 100, hard: 150, deadly: 200 },
+	3: { easy: 75, medium: 150, hard: 225, deadly: 400 },
+	4: { easy: 125, medium: 250, hard: 375, deadly: 500 },
+	5: { easy: 250, medium: 500, hard: 750, deadly: 1100 },
+	6: { easy: 300, medium: 600, hard: 900, deadly: 1400 },
+	7: { easy: 350, medium: 750, hard: 1100, deadly: 1700 },
+	8: { easy: 450, medium: 900, hard: 1400, deadly: 2100 },
+	9: { easy: 550, medium: 1100, hard: 1600, deadly: 2400 },
+	10: { easy: 600, medium: 1200, hard: 1900, deadly: 2800 },
+	11: { easy: 800, medium: 1600, hard: 2400, deadly: 3600 },
+	12: { easy: 1000, medium: 2000, hard: 3000, deadly: 4500 },
+	13: { easy: 1100, medium: 2200, hard: 3400, deadly: 5100 },
+	14: { easy: 1250, medium: 2500, hard: 3800, deadly: 5700 },
+	15: { easy: 1400, medium: 2800, hard: 4300, deadly: 6400 },
+	16: { easy: 1600, medium: 3200, hard: 4800, deadly: 7200 },
+	17: { easy: 2000, medium: 3900, hard: 5900, deadly: 8800 },
+	18: { easy: 2100, medium: 4200, hard: 6300, deadly: 9500 },
+	19: { easy: 2400, medium: 4900, hard: 7300, deadly: 10900 },
+	20: { easy: 2800, medium: 5700, hard: 8500, deadly: 12700 },
+};
+
+/** 2014 encounter multiplier by number of enemy-side monsters. */
+const ENCOUNTER_MULTIPLIER_TABLE: readonly {
+	max: number;
+	multiplier: number;
+}[] = [
+	{ max: 1, multiplier: 1 },
+	{ max: 2, multiplier: 1.5 },
+	{ max: 6, multiplier: 2 },
+	{ max: 10, multiplier: 2.5 },
+	{ max: 14, multiplier: 3 },
+	{ max: Number.POSITIVE_INFINITY, multiplier: 4 },
+];
+
+/**
+ * Multiplier values in ascending order for party size shifting.
+ * Extends beyond the base table: x0.5 (6+ PCs, 1 monster) and x5 (<3 PCs, 15+ monsters)
+ * per 2014 DMG party size adjustment rules.
+ */
+const MULTIPLIER_STEPS = [0.5, 1, 1.5, 2, 2.5, 3, 4, 5] as const;
+
+/** Index into MULTIPLIER_STEPS for each base table entry (before party size adjustment). */
+const BASE_STEP_INDEX = [1, 2, 3, 4, 5, 6] as const;
+
+function getEncounterMultiplier(
+	monsterCount: number,
+	partySize: number,
+): { multiplier: number; partySizeAdjusted: boolean } {
+	const tableIndex = ENCOUNTER_MULTIPLIER_TABLE.findIndex(
+		(entry) => monsterCount <= entry.max,
+	);
+	let stepIndex: number =
+		BASE_STEP_INDEX[
+			tableIndex === -1 ? BASE_STEP_INDEX.length - 1 : tableIndex
+		];
+	let partySizeAdjusted = false;
+
+	if (partySize < 3) {
+		stepIndex = Math.min(stepIndex + 1, MULTIPLIER_STEPS.length - 1);
+		partySizeAdjusted = true;
+	} else if (partySize >= 6) {
+		stepIndex = Math.max(stepIndex - 1, 0);
+		partySizeAdjusted = true;
+	}
+
+	return {
+		multiplier: MULTIPLIER_STEPS[stepIndex] as number,
+		partySizeAdjusted,
+	};
+}
+
 /** All standard 5e challenge rating strings, in ascending order. */
 export const VALID_CR_VALUES: readonly string[] = Object.keys(CR_TO_XP);

@@ -82,48 +168,131 @@ export function crToXp(cr: string): number {
 	return CR_TO_XP[cr] ?? 0;
 }

-/**
- * Calculates encounter difficulty from party levels and monster CRs.
- * Both arrays should be pre-filtered (only PCs with levels, only bestiary-linked monsters).
- */
-export function calculateEncounterDifficulty(
-	partyLevels: readonly number[],
-	monsterCrs: readonly string[],
-): DifficultyResult {
-	let budgetLow = 0;
-	let budgetModerate = 0;
-	let budgetHigh = 0;
-
-	for (const level of partyLevels) {
-		const budget = XP_BUDGET_PER_CHARACTER[level];
-		if (budget) {
-			budgetLow += budget.low;
-			budgetModerate += budget.moderate;
-			budgetHigh += budget.high;
-		}
+export interface CombatantDescriptor {
+	readonly level?: number;
+	readonly cr?: string;
+	readonly side: "party" | "enemy";
 }

+function determineTier(
+	xp: number,
+	tierThresholds: readonly number[],
+): DifficultyTier {
+	for (let i = tierThresholds.length - 1; i >= 0; i--) {
+		if (xp >= tierThresholds[i]) return (i + 1) as DifficultyTier;
+	}
+	return 0;
+}
+
+function accumulateBudget5_5e(levels: readonly number[]) {
+	const budget = { low: 0, moderate: 0, high: 0 };
+	for (const level of levels) {
+		const b = XP_BUDGET_PER_CHARACTER[level];
+		if (b) {
+			budget.low += b.low;
+			budget.moderate += b.moderate;
+			budget.high += b.high;
+		}
+	}
+	return budget;
+}
+
+function accumulateBudget2014(levels: readonly number[]) {
+	const budget = { easy: 0, medium: 0, hard: 0, deadly: 0 };
+	for (const level of levels) {
+		const b = XP_THRESHOLDS_2014[level];
+		if (b) {
+			budget.easy += b.easy;
+			budget.medium += b.medium;
+			budget.hard += b.hard;
+			budget.deadly += b.deadly;
+		}
+	}
+	return budget;
+}
+
+function scanCombatants(combatants: readonly CombatantDescriptor[]) {
 	let totalMonsterXp = 0;
-	for (const cr of monsterCrs) {
-		totalMonsterXp += crToXp(cr);
-	}
+	let monsterCount = 0;
+	const partyLevels: number[] = [];

-	let tier: DifficultyTier = "trivial";
-	if (totalMonsterXp >= budgetHigh) {
-		tier = "high";
-	} else if (totalMonsterXp >= budgetModerate) {
-		tier = "moderate";
-	} else if (totalMonsterXp >= budgetLow) {
-		tier = "low";
+	for (const c of combatants) {
+		if (c.level !== undefined && c.side === "party") {
+			partyLevels.push(c.level);
+		}
+		if (c.cr !== undefined) {
+			const xp = crToXp(c.cr);
+			if (c.side === "enemy") {
+				totalMonsterXp += xp;
+				monsterCount++;
+			} else {
+				totalMonsterXp -= xp;
+			}
+		}
 	}

 	return {
-		tier,
-		totalMonsterXp,
-		partyBudget: {
-			low: budgetLow,
-			moderate: budgetModerate,
-			high: budgetHigh,
-		},
+		totalMonsterXp: Math.max(0, totalMonsterXp),
+		monsterCount,
+		partyLevels,
+	};
+}
+
+/**
+ * Calculates encounter difficulty from combatant descriptors.
+ * Party-side combatants with level contribute to the budget.
+ * Enemy-side combatants with CR add XP; party-side with CR subtract XP (floored at 0).
+ */
+export function calculateEncounterDifficulty(
+	combatants: readonly CombatantDescriptor[],
+	edition: RulesEdition,
+): DifficultyResult {
+	const { totalMonsterXp, monsterCount, partyLevels } =
+		scanCombatants(combatants);
+
+	if (edition === "5.5e") {
+		const budget = accumulateBudget5_5e(partyLevels);
+		const thresholds: DifficultyThreshold[] = [
+			{ label: "Low", value: budget.low },
+			{ label: "Moderate", value: budget.moderate },
+			{ label: "High", value: budget.high },
+		];
+		return {
+			tier: determineTier(totalMonsterXp, [
+				budget.low,
+				budget.moderate,
+				budget.high,
+			]),
+			totalMonsterXp,
+			thresholds,
+			encounterMultiplier: undefined,
+			adjustedXp: undefined,
+			partySizeAdjusted: undefined,
+		};
+	}
+
+	// 2014 edition
+	const budget = accumulateBudget2014(partyLevels);
+	const { multiplier: encounterMultiplier, partySizeAdjusted } =
+		getEncounterMultiplier(monsterCount, partyLevels.length);
+	const adjustedXp = Math.round(totalMonsterXp * encounterMultiplier);
+	const thresholds: DifficultyThreshold[] = [
+		{ label: "Easy", value: budget.easy },
+		{ label: "Medium", value: budget.medium },
+		{ label: "Hard", value: budget.hard },
+		{ label: "Deadly", value: budget.deadly },
+	];
+
+	return {
+		tier: determineTier(adjustedXp, [
+			budget.medium,
+			budget.hard,
+			budget.deadly,
+		]),
+		totalMonsterXp,
+		thresholds,
+		encounterMultiplier,
+		adjustedXp,
+		partySizeAdjusted,
 	};
 }
--- a/packages/domain/src/events.ts
+++ b/packages/domain/src/events.ts
@@ -101,6 +101,13 @@ export interface CrSet {
 	readonly newCr: string | undefined;
 }

+export interface SideSet {
+	readonly type: "SideSet";
+	readonly combatantId: CombatantId;
+	readonly previousSide: "party" | "enemy" | undefined;
+	readonly newSide: "party" | "enemy";
+}
+
 export interface ConditionAdded {
 	readonly type: "ConditionAdded";
 	readonly combatantId: CombatantId;
@@ -161,6 +168,7 @@ export type DomainEvent =
 	| RoundRetreated
 	| AcSet
 	| CrSet
+	| SideSet
 	| ConditionAdded
 	| ConditionRemoved
 	| ConcentrationStarted
--- a/packages/domain/src/index.ts
+++ b/packages/domain/src/index.ts
@@ -16,7 +16,6 @@ export {
 	type ConditionId,
 	getConditionDescription,
 	getConditionsForEdition,
-	type RulesEdition,
 	VALID_CONDITION_IDS,
 } from "./conditions.js";
 export {
@@ -49,9 +48,11 @@ export {
 	editPlayerCharacter,
 } from "./edit-player-character.js";
 export {
+	type CombatantDescriptor,
 	calculateEncounterDifficulty,
 	crToXp,
 	type DifficultyResult,
+	type DifficultyThreshold,
 	type DifficultyTier,
 	VALID_CR_VALUES,
 } from "./encounter-difficulty.js";
@@ -75,6 +76,7 @@ export type {
 	PlayerCharacterUpdated,
 	RoundAdvanced,
 	RoundRetreated,
+	SideSet,
 	TempHpSet,
 	TurnAdvanced,
 	TurnRetreated,
@@ -108,6 +110,7 @@ export {
 	rollInitiative,
 	selectRoll,
 } from "./roll-initiative.js";
+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";
@@ -115,6 +118,7 @@ export {
 	type SetInitiativeSuccess,
 	setInitiative,
 } from "./set-initiative.js";
+export { type SetSideSuccess, setSide } from "./set-side.js";
 export { type SetTempHpSuccess, setTempHp } from "./set-temp-hp.js";
 export {
 	type ToggleConcentrationSuccess,
--- a/packages/domain/src/rehydrate-combatant.ts
+++ b/packages/domain/src/rehydrate-combatant.ts
@@ -76,6 +76,14 @@ function validateCr(value: unknown): string | undefined {
 		: undefined;
 }

+const VALID_SIDES = new Set(["party", "enemy"]);
+
+function validateSide(value: unknown): "party" | "enemy" | undefined {
+	return typeof value === "string" && VALID_SIDES.has(value)
+		? (value as "party" | "enemy")
+		: undefined;
+}
+
 function parseOptionalFields(entry: Record<string, unknown>) {
 	return {
 		initiative: validateInteger(entry.initiative),
@@ -86,6 +94,7 @@ function parseOptionalFields(entry: Record<string, unknown>) {
 			? creatureId(entry.creatureId as string)
 			: undefined,
 		cr: validateCr(entry.cr),
+		side: validateSide(entry.side),
 		color: validateSetMember(entry.color, VALID_PLAYER_COLORS),
 		icon: validateSetMember(entry.icon, VALID_PLAYER_ICONS),
 		playerCharacterId: validateNonEmptyString(entry.playerCharacterId)
--- a/packages/domain/src/rules-edition.ts
+++ b/packages/domain/src/rules-edition.ts
@@ -0,0 +1 @@
+export type RulesEdition = "5e" | "5.5e";
--- a/packages/domain/src/set-side.ts
+++ b/packages/domain/src/set-side.ts
@@ -0,0 +1,54 @@
+import type { DomainEvent } from "./events.js";
+import {
+	type CombatantId,
+	type DomainError,
+	type Encounter,
+	findCombatant,
+	isDomainError,
+} from "./types.js";
+
+export interface SetSideSuccess {
+	readonly encounter: Encounter;
+	readonly events: DomainEvent[];
+}
+
+const VALID_SIDES = new Set(["party", "enemy"]);
+
+export function setSide(
+	encounter: Encounter,
+	combatantId: CombatantId,
+	value: "party" | "enemy",
+): SetSideSuccess | DomainError {
+	const found = findCombatant(encounter, combatantId);
+	if (isDomainError(found)) return found;
+
+	if (!VALID_SIDES.has(value)) {
+		return {
+			kind: "domain-error",
+			code: "invalid-side",
+			message: `Side must be "party" or "enemy", got "${value}"`,
+		};
+	}
+
+	const previousSide = found.combatant.side;
+
+	const updatedCombatants = encounter.combatants.map((c) =>
+		c.id === combatantId ? { ...c, side: value } : c,
+	);
+
+	return {
+		encounter: {
+			combatants: updatedCombatants,
+			activeIndex: encounter.activeIndex,
+			roundNumber: encounter.roundNumber,
+		},
+		events: [
+			{
+				type: "SideSet",
+				combatantId,
+				previousSide,
+				newSide: value,
+			},
+		],
+	};
+}
--- a/packages/domain/src/types.ts
+++ b/packages/domain/src/types.ts
@@ -21,6 +21,7 @@ export interface Combatant {
 	readonly isConcentrating?: boolean;
 	readonly creatureId?: CreatureId;
 	readonly cr?: string;
+	readonly side?: "party" | "enemy";
 	readonly color?: string;
 	readonly icon?: string;
 	readonly playerCharacterId?: PlayerCharacterId;
--- a/specs/008-encounter-difficulty/spec.md
+++ b/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)"
+**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"

 ## User Scenarios & Testing *(mandatory)*

@@ -33,6 +33,12 @@ A game master is building an encounter by adding monsters and player characters.

 7. **Given** the difficulty indicator is visible, **When** a PC combatant is added or removed, **Then** the indicator updates immediately to reflect the new party budget.

+8. **Given** the rules edition is set to 5e (2014), **When** the indicator renders at the Low-equivalent tier, **Then** the tooltip reads "Easy encounter difficulty". **When** set to 5.5e, **Then** it reads "Low encounter difficulty".
+
+9. **Given** the rules edition is set to 5e (2014), **When** the indicator renders at the highest tier, **Then** the tooltip reads "Deadly encounter difficulty". **When** set to 5.5e, **Then** it reads "High encounter difficulty".
+
+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.
+
 ---

 ### Indicator Visibility
@@ -101,10 +107,18 @@ The difficulty calculation uses the 2024 5.5e XP Budget per Character table and

 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).

-4. **Given** an encounter with bestiary-linked combatants, custom combatants with CR assigned, and custom combatants without CR, **When** the XP total is calculated, **Then** bestiary-linked combatants contribute XP from their creature CR and custom combatants with CR contribute XP from their assigned CR. Custom combatants without CR are excluded.
+4. **Given** an encounter with bestiary-linked combatants, custom combatants with CR assigned, and custom combatants without CR, **When** the XP total is calculated, **Then** enemy-side combatants with CR add XP to the monster total, party-side combatants with CR subtract XP from the monster total, and custom combatants without CR are excluded. The net monster XP is floored at 0.

 5. **Given** a PC combatant whose player character has no level, **When** the budget is calculated, **Then** that PC is excluded from the budget (as if they are not in the party).

+6. **Given** the rules edition is set to 5e (2014) and an encounter has 3 enemy-side monsters totaling 300 base XP, **When** the encounter multiplier is applied, **Then** the adjusted XP is 600 (3 monsters = ×2 multiplier).
+
+7. **Given** the rules edition is set to 5e (2014) and the party has fewer than 3 PCs, **When** the encounter multiplier is determined, **Then** the multiplier shifts one step higher (e.g., ×1.5 becomes ×2).
+
+8. **Given** the rules edition is set to 5e (2014) and the party has 6 or more PCs, **When** the encounter multiplier is determined, **Then** the multiplier shifts one step lower (e.g., ×2 becomes ×1.5, ×1 becomes ×0.5).
+
+9. **Given** the rules edition is set to 5e (2014), **When** facing monsters totaling 500 adjusted XP against a party of four level 3 PCs (Medium threshold: 150 each = 600 total), **Then** the difficulty is Easy (adjusted XP is below the Medium threshold).
+
 ---

 ### Difficulty Breakdown
@@ -119,7 +133,7 @@ The game master taps the difficulty indicator to open a breakdown panel. The pan

 **Acceptance Scenarios**:

-1. **Given** the difficulty indicator is visible, **When** the user taps the indicator, **Then** a breakdown panel opens showing party budget, per-combatant XP contributions, and total monster XP.
+1. **Given** the difficulty indicator is visible, **When** the user taps the indicator, **Then** a breakdown panel opens showing party budget, two columns (Party and Enemy) listing combatants with their XP contributions, a side toggle per combatant, and the net monster XP total.

 2. **Given** the breakdown panel is open, **When** the user taps outside the panel or taps a close control, **Then** the panel closes.

@@ -131,6 +145,12 @@ The game master taps the difficulty indicator to open a breakdown panel. The pan

 6. **Given** the breakdown panel is open, **When** a combatant is added or removed from the encounter, **Then** the panel content updates immediately.

+7. **Given** the breakdown panel is open, **When** the user toggles a combatant's side, **Then** it moves to the other column and the difficulty tier, monster XP total, and party budget update immediately.
+
+8. **Given** the rules edition is set to 5e (2014) and the breakdown panel is open, **When** viewing the monster XP section, **Then** the panel shows the base monster XP total, the encounter multiplier (e.g., "×2"), and the adjusted XP total used for threshold comparison.
+
+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).
+
 ---

 ### Manual CR Assignment
@@ -177,6 +197,62 @@ Bestiary-linked combatants derive their CR from the creature data. The breakdown

 ---

+### Side Assignment
+
+**Story ED-8 — Assign combatants to party or enemy side (Priority: P2)**
+
+A game master has allied NPCs fighting alongside the party. From the difficulty breakdown panel, they toggle an NPC to the party side. The NPC's XP is subtracted from the monster total instead of added, and the difficulty tier drops accordingly. PC combatants default to the party side and non-PC combatants default to the enemy side, so users who don't care about sides never interact with this feature.
+
+**Why this priority**: Extends the breakdown panel (ED-5) with side assignment. Without sides, allied NPCs inflate difficulty artificially.
+
+**Independent Test**: Can be tested by adding a leveled PC and two monsters, toggling one monster to party side, and verifying its XP is subtracted from the total.
+
+**Acceptance Scenarios**:
+
+1. **Given** the breakdown panel is open, **When** a non-PC combatant's side is toggled to party, **Then** its CR-derived XP is subtracted from the monster total instead of added, and the difficulty tier recalculates immediately.
+
+2. **Given** a combatant with both a level (from its player character) and a CR on the party side, **When** the difficulty is calculated, **Then** it contributes to the party budget via its level AND subtracts its CR XP from the monster total — both effects apply independently.
+
+3. **Given** party-side combatants whose total CR XP exceeds the enemy-side total, **When** the difficulty is calculated, **Then** the net monster XP is floored at 0 (difficulty cannot go negative).
+
+4. **Given** the breakdown panel is open, **When** the user views a PC combatant, **Then** it appears in the Party column by default. **When** the user views a non-PC combatant, **Then** it appears in the Enemy column by default. Both can be toggled.
+
+5. **Given** a combatant's side has been toggled, **When** the encounter is saved and the page is reloaded, **Then** the side assignment is restored.
+
+6. **Given** a combatant's side has been toggled, **When** the encounter is exported to JSON and re-imported, **Then** the side assignment is preserved.
+
+7. **Given** the breakdown panel is open, **Then** above the two columns a brief rules-oriented explanation is shown: "Allied NPC XP is subtracted from encounter difficulty" (tone is mechanical/rules-focused).
+
+---
+
+### 2014 Rules Edition
+
+**Story ED-9 — 2014 DMG encounter difficulty calculation (Priority: P2)**
+
+A game master who runs games using the 2014 (original 5e) rules selects "5e (2014)" in the Rules Edition setting. The difficulty indicator now uses the 2014 DMG calculation: monster XP is summed, an encounter multiplier is applied based on the number of enemy-side monsters, and the adjusted total is compared against Easy/Medium/Hard/Deadly thresholds derived from per-character XP budgets. The visual indicator maps identically — 0 bars for Easy, 1 green for Medium, 2 yellow for Hard, 3 red for Deadly — but tooltip labels and breakdown details reflect the 2014 terminology.
+
+**Why this priority**: The core indicator (ED-1) and 5.5e calculation (ED-4) must work first. 2014 support extends the existing system with an alternative calculation path.
+
+**Independent Test**: Can be tested by setting rules edition to 5e (2014), creating an encounter with leveled PCs and monsters, and verifying the indicator uses 2014 thresholds, multiplier, and labels.
+
+**Acceptance Scenarios**:
+
+1. **Given** the rules edition is set to 5e (2014) and an encounter has leveled PCs and enemy monsters, **When** the difficulty is calculated, **Then** the system uses the 2014 XP Thresholds by Character Level table (Easy/Medium/Hard/Deadly) instead of the 5.5e table (Low/Moderate/High).
+
+2. **Given** the rules edition is set to 5e (2014) and an encounter has 3 enemy-side monsters totaling 300 base XP, **When** the encounter multiplier is applied, **Then** the adjusted XP is 600 (3 monsters = ×2 multiplier).
+
+3. **Given** the rules edition is set to 5e (2014) and the party has fewer than 3 PCs, **When** the encounter multiplier is determined, **Then** the multiplier shifts one step higher (e.g., ×1.5 becomes ×2, ×1 becomes ×1.5).
+
+4. **Given** the rules edition is set to 5e (2014) and the party has 6 or more PCs, **When** the encounter multiplier is determined, **Then** the multiplier shifts one step lower (e.g., ×2 becomes ×1.5, ×1 becomes ×0.5).
+
+5. **Given** the rules edition is set to 5e (2014), **When** the indicator visual states are rendered, **Then** 0 bars = Easy, 1 green bar = Medium, 2 yellow bars = Hard, 3 red bars = Deadly.
+
+6. **Given** the user changes the rules edition from 5.5e to 5e (2014) while an encounter is open, **When** the setting is saved, **Then** the difficulty indicator updates immediately to reflect the 2014 calculation and labels.
+
+7. **Given** the rules edition is set to 5e (2014) and only enemy-side combatants count toward monster count, **When** a party-side NPC with CR is present, **Then** its XP is subtracted from the total but it does not inflate the encounter multiplier monster count.
+
+---
+
 ### 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."
@@ -190,6 +266,14 @@ Bestiary-linked combatants derive their CR from the creature data. The breakdown
 - **PCs without level silently excluded**: PC combatants whose player character has no level do not contribute to the budget and are not flagged.
 - **Indicator with empty encounter**: When the encounter has no combatants, the indicator is hidden (the top bar may not even render per existing behavior).
 - **Level field on existing player characters**: Existing player characters created before this feature will have no level. They are treated as "no level assigned" — no migration or default is needed.
+- **Net monster XP floored at 0**: If party-side combatant XP exceeds enemy-side combatant XP, the net monster XP is 0 (trivial), not negative.
+- **Dual contribution (level + CR on party side)**: A combatant with both a level and a CR on the party side contributes to the party budget via level and subtracts from monster XP via CR. These are independent effects.
+- **Side defaults preserve opt-in**: Because PCs default to party and others default to enemy, users who never assign sides see identical behavior to the pre-side-assignment calculation.
+- **2014 encounter multiplier with party-side NPCs**: Only enemy-side combatants count toward the monster count for determining the encounter multiplier. Party-side NPCs with CR subtract their XP from the total but do not increase the monster count.
+- **2014 party size adjustment boundaries**: Exactly 3 PCs uses the standard multiplier. Exactly 5 PCs uses the standard multiplier. The shift only applies at fewer than 3 or 6 or more.
+- **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.

 ---

@@ -206,11 +290,11 @@ The system MUST contain a CR-to-XP lookup table mapping all standard 5e challeng
 #### FR-003 — Party XP budget calculation
 The system MUST calculate the party's XP budget by summing the per-character budget for each PC combatant whose player character has a level assigned. PCs without a level are excluded from the sum.

-#### FR-004 — Monster XP total calculation
-The system MUST calculate the total monster XP by summing the XP value (derived from CR) for each 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.
+#### FR-004 — Net monster XP calculation
+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 against the party's Low, Moderate, and High thresholds. The tier is the highest threshold that the total XP meets or exceeds. If below Low, the encounter is trivial (no tier label).
+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.

 #### 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.
@@ -219,7 +303,7 @@ The system MUST display a 3-bar difficulty indicator in the top bar, positioned
 The indicator MUST display: three empty bars for trivial, one green filled bar for Low, two yellow filled bars for Moderate, three red filled bars for High.

 #### FR-008 — Tooltip on hover
-The indicator MUST show a tooltip on hover displaying the difficulty label (e.g., "Moderate encounter difficulty"). For the trivial state, the tooltip MUST read "Trivial encounter difficulty".
+The indicator MUST show a tooltip on hover displaying the edition-appropriate difficulty label. For 5.5e: "Trivial/Low/Moderate/High encounter difficulty". For 2014: "Easy/Medium/Hard/Deadly encounter difficulty".

 #### FR-009 — Live updates
 The indicator MUST update immediately when combatants are added to or removed from the encounter.
@@ -239,24 +323,60 @@ The player character level MUST be persisted and restored across sessions, consi
 #### 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.

-#### FR-015 — Optional CR field 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").
+#### 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"`.

 #### FR-016 — Tappable difficulty indicator
 The difficulty indicator MUST be tappable, opening a difficulty breakdown panel.

 #### FR-017 — Breakdown panel content
-The breakdown panel MUST display: the party XP budget (with Low, Moderate, High thresholds), a list of combatants showing name, CR, and XP contribution, and the total monster XP.
+The breakdown panel MUST display: the party XP budget (with edition-appropriate tier thresholds — Low/Moderate/High for 5.5e, Easy/Medium/Hard/Deadly for 2014), two stacked sections (Party and Enemy) using a columnar grid layout (name, toggle button, CR, XP) for aligned readability, the net monster XP total, and a brief rules-oriented explanation. When the rules edition is 5e (2014), the panel MUST additionally show the encounter multiplier value and the adjusted XP total. Source names are omitted from the panel to conserve horizontal space.

 #### FR-018 — CR picker for custom combatants
 The breakdown panel MUST provide a CR picker for custom combatants (those without `creatureId`) offering all standard 5e CR values: 0, 1/8, 1/4, 1/2, 1–30.

 #### FR-019 — Bestiary CR precedence
-When a combatant has a `creatureId`, the system MUST derive CR from the linked creature data. The manual `cr` field MUST be ignored. The breakdown panel MUST display bestiary-linked CRs as read-only with the source name visible.
+When a combatant has a `creatureId`, the system MUST derive CR from the linked creature data. The manual `cr` field MUST be ignored. The breakdown panel MUST display bestiary-linked CRs as read-only.

 #### FR-020 — CR persistence
 The `cr` field on `Combatant` MUST persist within the encounter across page reloads (via encounter storage) and MUST round-trip through JSON export/import.

+#### FR-021 — Side defaults
+When `side` is undefined, PC combatants MUST default to party side and all other combatants MUST default to enemy side. The `useDifficulty` hook resolves defaults before calling the domain function.
+
+#### FR-022 — Party-side CR subtraction
+Party-side combatants with CR MUST have their XP subtracted from the monster total. Party-side combatants with level MUST contribute to the party budget. These effects are independent — a combatant with both level and CR on party side contributes to budget AND subtracts from monster XP.
+
+#### FR-023 — Side toggle in breakdown panel
+The breakdown panel MUST provide a side toggle button per non-PC combatant to switch between party and enemy side. PC combatants are fixed to the party side and do not show a toggle. Toggling MUST immediately update the difficulty calculation. The toggle button uses an arrow icon with a hover background effect for discoverability.
+
+#### FR-024 — Side persistence
+The `side` field on `Combatant` MUST persist within the encounter across page reloads (via encounter storage) and MUST round-trip through JSON export/import.
+
+#### FR-025 — Domain function signature
+The `calculateEncounterDifficulty` domain function MUST accept combatant descriptors with `{ level?, cr?, side }` and a `RulesEdition` parameter so it can apply the correct calculation logic and threshold tables for the selected edition, replacing the current `partyLevels[]` / `monsterCrs[]` signature.
+
+#### FR-026 — 2014 XP Thresholds by Character Level table
+The system MUST contain the 2014 DMG XP Thresholds by Character Level lookup table mapping character levels 1-20 to four XP thresholds: Easy, Medium, Hard, and Deadly.
+
+#### FR-027 — 2014 Encounter Multiplier table
+The system MUST contain the 2014 DMG Encounter Multiplier lookup table: 1 monster = ×1, 2 monsters = ×1.5, 3-6 monsters = ×2, 7-10 monsters = ×2.5, 11-14 monsters = ×3, 15+ monsters = ×4.
+
+#### FR-028 — Party size multiplier adjustment
+When using 2014 rules, the system MUST adjust the encounter multiplier based on party size: fewer than 3 PCs shifts the multiplier one step higher (up to ×5), 6 or more PCs shifts it one step lower (down to ×0.5). Per the 2014 DMG: a single monster vs 6+ PCs uses ×0.5, and 15+ monsters vs fewer than 3 PCs uses ×5.
+
+#### FR-029 — 2014 adjusted XP calculation
+When using 2014 rules, the system MUST calculate adjusted XP by summing the base XP of all enemy-side combatants with CR, applying the encounter multiplier (based on enemy-side monster count and party size), and comparing the adjusted total against the party's Easy/Medium/Hard/Deadly thresholds. Only enemy-side combatants count toward the monster count for the multiplier. Party-side combatant XP subtraction is applied to the base total before the multiplier.
+
+#### FR-030 — Party size adjustment explanation in breakdown panel
+When using 2014 rules and the party size adjustment is active (fewer than 3 or 6 or more PCs), the breakdown panel MUST display a brief explanation near the multiplier (e.g., "×1.5 adjusted for 2 PCs" or "×1.5 adjusted for 6 PCs") so the GM understands why the multiplier differs from the base table.
+
+#### FR-031 — Edition switch updates indicator
+Switching the rules edition in settings MUST immediately update the difficulty indicator for the current encounter without requiring a page reload.
+
+#### 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.
+
 ### 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.
@@ -265,6 +385,9 @@ The `cr` field on `Combatant` MUST persist within the encounter across page relo
 - **DifficultyResult**: The output of the calculation containing the tier, total monster XP, and per-tier budget thresholds.
 - **PlayerCharacter.level**: An optional integer (1-20) added to the existing `PlayerCharacter` entity defined in spec 005.
 - **Combatant.cr**: An optional string field on the existing `Combatant` entity, accepting standard 5e CR values. Used for manual CR assignment on custom combatants. Ignored when the combatant has a `creatureId`.
+- **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).

 ---

@@ -281,6 +404,9 @@ The `cr` field on `Combatant` MUST persist within the encounter across page relo
 - **SC-007**: The optional level field integrates seamlessly into the existing player character create/edit workflow without disrupting existing functionality.
 - **SC-008**: The difficulty breakdown panel correctly displays per-combatant XP contributions and party budget that sum to the values used for tier determination.
 - **SC-009**: Custom combatants with manually assigned CR contribute correctly to the difficulty calculation, matching the same CR-to-XP mapping used for bestiary creatures.
+- **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.

 ---

@@ -293,6 +419,8 @@ The `cr` field on `Combatant` MUST persist within the encounter across page relo
 - Existing player characters without a level are treated as "no level assigned" with no migration.
 - The difficulty indicator occupies minimal horizontal space in the top bar and does not interfere with the combatant name truncation or other controls.
 - The breakdown panel is the sole UI surface for manual CR assignment — there is no CR field in the combatant create/edit forms.
- MVP baseline does not include assigning combatants to party/enemy sides — all combatants with CR are counted as enemies.
- MVP baseline does not include the 2014 DMG encounter multiplier mechanic or the four-tier (Easy/Medium/Hard/Deadly) system.
+- The 2014 DMG XP Thresholds and Encounter Multiplier tables are static data that do not change at runtime.
+- The existing `RulesEdition` type (`"5e" | "5.5e"`) already maps correctly — `"5e"` corresponds to the 2014 rules, `"5.5e"` to the 2024 rules. No new enum value is needed.
+- 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.