Render structured list and table entries in stat block traits

Stat block traits containing 5etools list (e.g. Confusing Burble d4 effects) or table entries were silently dropped. The adapter now produces structured TraitSegment[] instead of flat text, preserving lists and tables as first-class data. The stat block component renders labeled list items inline (bold label + flowing text) matching the 5etools layout. Also fixes support for the singular "entry" field on list items and bumps the bestiary cache version to force re-normalize. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Add 2014 DMG encounter difficulty calculation
2026-04-04 22:09:11 +02:00 · 2026-04-04 14:52:23 +02:00
23 changed files with 1227 additions and 294 deletions
--- a/apps/web/src/adapters/tests/bestiary-adapter.test.ts
+++ b/apps/web/src/adapters/tests/bestiary-adapter.test.ts
@@ -1,9 +1,23 @@
+import type { TraitBlock } from "@initiative/domain";
 import { beforeAll, describe, expect, it } from "vitest";
 import {
 	normalizeBestiary,
 	setSourceDisplayNames,
 } from "../bestiary-adapter.js";

+/** Flatten segments to a single string for simple text assertions. */
+function flatText(trait: TraitBlock): string {
+	return trait.segments
+		.map((s) =>
+			s.type === "text"
+				? s.value
+				: s.items
+						.map((i) => (i.label ? `${i.label}. ${i.text}` : i.text))
+						.join(" "),
+		)
+		.join(" ");
+}
+
 beforeAll(() => {
 	setSourceDisplayNames({ XMM: "MM 2024" });
 });
@@ -74,11 +88,11 @@ describe("normalizeBestiary", () => {
 		expect(c.senses).toBe("Darkvision 60 ft.");
 		expect(c.languages).toBe("Common, Goblin");
 		expect(c.actions).toHaveLength(1);
-		expect(c.actions?.[0].text).toContain("Melee Attack Roll:");
-		expect(c.actions?.[0].text).not.toContain("{@");
+		expect(flatText(c.actions![0])).toContain("Melee Attack Roll:");
+		expect(flatText(c.actions![0])).not.toContain("{@");
 		expect(c.bonusActions).toHaveLength(1);
-		expect(c.bonusActions?.[0].text).toContain("Disengage");
-		expect(c.bonusActions?.[0].text).not.toContain("{@");
+		expect(flatText(c.bonusActions![0])).toContain("Disengage");
+		expect(flatText(c.bonusActions![0])).not.toContain("{@");
 	});

 	it("normalizes a creature with legendary actions", () => {
@@ -333,9 +347,9 @@ describe("normalizeBestiary", () => {

 		const creatures = normalizeBestiary(raw);
 		const bite = creatures[0].actions?.[0];
-		expect(bite?.text).toContain("Melee Weapon Attack:");
-		expect(bite?.text).not.toContain("mw");
-		expect(bite?.text).not.toContain("{@");
+		expect(flatText(bite!)).toContain("Melee Weapon Attack:");
+		expect(flatText(bite!)).not.toContain("mw");
+		expect(flatText(bite!)).not.toContain("{@");
 	});

 	it("handles fly speed with hover condition", () => {
@@ -368,4 +382,129 @@ describe("normalizeBestiary", () => {
 		const creatures = normalizeBestiary(raw);
 		expect(creatures[0].speed).toBe("10 ft., fly 90 ft. (hover)");
 	});
+
+	it("renders list items with singular entry field (e.g. Confusing Burble d4 effects)", () => {
+		const raw = {
+			monster: [
+				{
+					name: "Jabberwock",
+					source: "WBtW",
+					size: ["H"],
+					type: "dragon",
+					ac: [18],
+					hp: { average: 115, formula: "10d12 + 50" },
+					speed: { walk: 30 },
+					str: 22,
+					dex: 15,
+					con: 20,
+					int: 8,
+					wis: 14,
+					cha: 16,
+					passive: 12,
+					cr: "13",
+					trait: [
+						{
+							name: "Confusing Burble",
+							entries: [
+								"The jabberwock burbles unless {@condition incapacitated}. Roll a {@dice d4}:",
+								{
+									type: "list",
+									style: "list-hang-notitle",
+									items: [
+										{
+											type: "item",
+											name: "1-2",
+											entry: "The creature does nothing.",
+										},
+										{
+											type: "item",
+											name: "3",
+											entry:
+												"The creature uses all its movement to move in a random direction.",
+										},
+										{
+											type: "item",
+											name: "4",
+											entry:
+												"The creature makes one melee attack against a random creature.",
+										},
+									],
+								},
+							],
+						},
+					],
+				},
+			],
+		};
+
+		const creatures = normalizeBestiary(raw);
+		const trait = creatures[0].traits![0];
+		expect(trait.name).toBe("Confusing Burble");
+		expect(trait.segments).toHaveLength(2);
+		expect(trait.segments[0]).toEqual({
+			type: "text",
+			value: expect.stringContaining("d4"),
+		});
+		expect(trait.segments[1]).toEqual({
+			type: "list",
+			items: [
+				{ label: "1-2", text: "The creature does nothing." },
+				{
+					label: "3",
+					text: expect.stringContaining("random direction"),
+				},
+				{ label: "4", text: expect.stringContaining("melee attack") },
+			],
+		});
+	});
+
+	it("renders table entries as structured list segments", () => {
+		const raw = {
+			monster: [
+				{
+					name: "Test Creature",
+					source: "XMM",
+					size: ["M"],
+					type: "humanoid",
+					ac: [12],
+					hp: { average: 40, formula: "9d8" },
+					speed: { walk: 30 },
+					str: 10,
+					dex: 10,
+					con: 10,
+					int: 10,
+					wis: 10,
+					cha: 10,
+					passive: 10,
+					cr: "1",
+					trait: [
+						{
+							name: "Random Effect",
+							entries: [
+								"Roll on the table:",
+								{
+									type: "table",
+									colLabels: ["d4", "Effect"],
+									rows: [
+										["1", "Nothing happens."],
+										["2", "Something happens."],
+									],
+								},
+							],
+						},
+					],
+				},
+			],
+		};
+
+		const creatures = normalizeBestiary(raw);
+		const trait = creatures[0].traits![0];
+		expect(trait.segments[1]).toEqual({
+			type: "list",
+			items: [
+				{ label: "1", text: "Nothing happens." },
+				{ label: "2", text: "Something happens." },
+			],
+		});
+	});
 });
--- a/apps/web/src/adapters/bestiary-adapter.ts
+++ b/apps/web/src/adapters/bestiary-adapter.ts
@@ -5,6 +5,8 @@ import type {
 	LegendaryBlock,
 	SpellcastingBlock,
 	TraitBlock,
+	TraitListItem,
+	TraitSegment,
 } from "@initiative/domain";
 import { creatureId, proficiencyBonus } from "@initiative/domain";
 import { stripTags } from "./strip-tags.js";
@@ -63,11 +65,18 @@ interface RawEntryObject {
 	type: string;
 	items?: (
 		| string
-		| { type: string; name?: string; entries?: (string | RawEntryObject)[] }
+		| {
+				type: string;
+				name?: string;
+				entry?: string;
+				entries?: (string | RawEntryObject)[];
+		  }
 	)[];
 	style?: string;
 	name?: string;
 	entries?: (string | RawEntryObject)[];
+	colLabels?: string[];
+	rows?: (string | RawEntryObject)[][];
 }

 interface RawSpellcasting {
@@ -257,23 +266,34 @@ function formatConditionImmunities(
 		.join(", ");
 }

-function renderListItem(item: string | RawEntryObject): string | undefined {
+function toListItem(
+	item:
+		| string
+		| {
+				type: string;
+				name?: string;
+				entry?: string;
+				entries?: (string | RawEntryObject)[];
+		  },
+): TraitListItem | undefined {
 	if (typeof item === "string") {
-		return `• ${stripTags(item)}`;
+		return { text: stripTags(item) };
 	}
 	if (item.name && item.entries) {
-		return `• ${stripTags(item.name)}: ${renderEntries(item.entries)}`;
+		return { label: stripTags(item.name), text: renderEntries(item.entries) };
+	}
+	if (item.name && item.entry) {
+		return { label: stripTags(item.name), text: stripTags(item.entry) };
 	}
 	return undefined;
 }

 function renderEntryObject(entry: RawEntryObject, parts: string[]): void {
-	if (entry.type === "list") {
-		for (const item of entry.items ?? []) {
-			const rendered = renderListItem(item);
-			if (rendered) parts.push(rendered);
-		}
-	} else if (entry.type === "item" && entry.name && entry.entries) {
+	if (entry.type === "list" || entry.type === "table") {
+		// Handled structurally in segmentizeEntries
+		return;
+	}
+	if (entry.type === "item" && entry.name && entry.entries) {
 		parts.push(`${stripTags(entry.name)}: ${renderEntries(entry.entries)}`);
 	} else if (entry.entries) {
 		parts.push(renderEntries(entry.entries));
@@ -292,11 +312,67 @@ function renderEntries(entries: (string | RawEntryObject)[]): string {
 	return parts.join(" ");
 }

+function tableRowToListItem(row: (string | RawEntryObject)[]): TraitListItem {
+	return {
+		label: typeof row[0] === "string" ? stripTags(row[0]) : undefined,
+		text: row
+			.slice(1)
+			.map((cell) =>
+				typeof cell === "string" ? stripTags(cell) : renderEntries([cell]),
+			)
+			.join(" "),
+	};
+}
+
+function entryToListSegment(entry: RawEntryObject): TraitSegment | undefined {
+	if (entry.type === "list") {
+		const items = (entry.items ?? [])
+			.map(toListItem)
+			.filter((i): i is TraitListItem => i !== undefined);
+		return items.length > 0 ? { type: "list", items } : undefined;
+	}
+	if (entry.type === "table" && entry.rows) {
+		const items = entry.rows.map(tableRowToListItem);
+		return items.length > 0 ? { type: "list", items } : undefined;
+	}
+	return undefined;
+}
+
+function segmentizeEntries(
+	entries: (string | RawEntryObject)[],
+): TraitSegment[] {
+	const segments: TraitSegment[] = [];
+	const textParts: string[] = [];
+
+	const flushText = () => {
+		if (textParts.length > 0) {
+			segments.push({ type: "text", value: textParts.join(" ") });
+			textParts.length = 0;
+		}
+	};
+
+	for (const entry of entries) {
+		if (typeof entry === "string") {
+			textParts.push(stripTags(entry));
+			continue;
+		}
+		const listSeg = entryToListSegment(entry);
+		if (listSeg) {
+			flushText();
+			segments.push(listSeg);
+		} else {
+			renderEntryObject(entry, textParts);
+		}
+	}
+	flushText();
+	return segments;
+}
+
 function normalizeTraits(raw?: RawEntry[]): TraitBlock[] | undefined {
 	if (!raw || raw.length === 0) return undefined;
 	return raw.map((t) => ({
 		name: stripTags(t.name),
-		text: renderEntries(t.entries),
+		segments: segmentizeEntries(t.entries),
 	}));
 }

@@ -361,7 +437,7 @@ function normalizeLegendary(
 		preamble,
 		entries: raw.map((e) => ({
 			name: stripTags(e.name),
-			text: renderEntries(e.entries),
+			segments: segmentizeEntries(e.entries),
 		})),
 	};
 }
--- a/apps/web/src/adapters/bestiary-cache.ts
+++ b/apps/web/src/adapters/bestiary-cache.ts
@@ -3,7 +3,7 @@ import { type IDBPDatabase, openDB } from "idb";

 const DB_NAME = "initiative-bestiary";
 const STORE_NAME = "sources";
-const DB_VERSION = 2;
+const DB_VERSION = 3;

 interface CachedSourceInfo {
 	readonly sourceCode: string;
@@ -38,8 +38,11 @@ async function getDb(): Promise<IDBPDatabase | null> {
 						keyPath: "sourceCode",
 					});
 				}
-				if (oldVersion < 2 && database.objectStoreNames.contains(STORE_NAME)) {
-					// Clear cached creatures to pick up improved tag processing
+				if (
+					oldVersion < DB_VERSION &&
+					database.objectStoreNames.contains(STORE_NAME)
+				) {
+					// Clear cached creatures so they get re-normalized with latest rendering
 					void transaction.objectStore(STORE_NAME).clear();
 				}
 			},
--- 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(() => {
@@ -279,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/tests/stat-block.test.tsx
+++ b/apps/web/src/components/tests/stat-block.test.tsx
@@ -46,10 +46,30 @@ const GOBLIN: Creature = {
 	skills: "Stealth +6",
 	senses: "darkvision 60 ft., passive Perception 9",
 	languages: "Common, Goblin",
-	traits: [{ name: "Nimble Escape", text: "Disengage or Hide as bonus." }],
-	actions: [{ name: "Scimitar", text: "Melee: +4 to hit, 5 slashing." }],
-	bonusActions: [{ name: "Nimble", text: "Disengage or Hide." }],
-	reactions: [{ name: "Redirect", text: "Redirect attack to ally." }],
+	traits: [
+		{
+			name: "Nimble Escape",
+			segments: [{ type: "text", value: "Disengage or Hide as bonus." }],
+		},
+	],
+	actions: [
+		{
+			name: "Scimitar",
+			segments: [{ type: "text", value: "Melee: +4 to hit, 5 slashing." }],
+		},
+	],
+	bonusActions: [
+		{
+			name: "Nimble",
+			segments: [{ type: "text", value: "Disengage or Hide." }],
+		},
+	],
+	reactions: [
+		{
+			name: "Redirect",
+			segments: [{ type: "text", value: "Redirect attack to ally." }],
+		},
+	],
 };

 const DRAGON: Creature = {
@@ -75,8 +95,16 @@ const DRAGON: Creature = {
 	legendaryActions: {
 		preamble: "The dragon can take 3 legendary actions.",
 		entries: [
-			{ name: "Detect", text: "Wisdom (Perception) check." },
-			{ name: "Tail Attack", text: "Tail attack." },
+			{
+				name: "Detect",
+				segments: [
+					{ type: "text" as const, value: "Wisdom (Perception) check." },
+				],
+			},
+			{
+				name: "Tail Attack",
+				segments: [{ type: "text" as const, value: "Tail attack." }],
+			},
 		],
 	},
 	spellcasting: [
--- a/apps/web/src/components/difficulty-breakdown-panel.tsx
+++ b/apps/web/src/components/difficulty-breakdown-panel.tsx
@@ -1,7 +1,8 @@
-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,
@@ -10,13 +11,34 @@ import {
 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();
 }
@@ -90,11 +112,12 @@ 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";
@@ -120,15 +143,11 @@ 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>
-					</span>
+					{breakdown.thresholds.map((t) => (
+						<span key={t.label}>
+							{shortLabel(t.label)}: <strong>{formatXp(t.value)}</strong>
+						</span>
+					))}
 				</div>
 			</div>

@@ -176,12 +195,34 @@ export function DifficultyBreakdownPanel({ onClose }: { onClose: () => void }) {
 				</div>
 			</div>

-			<div className="mt-2 flex justify-between border-border border-t pt-2 font-medium text-xs">
-				<span>Net Monster XP</span>
-				<span className="tabular-nums">
-					{formatXp(breakdown.totalMonsterXp)}
-				</span>
-			</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>Net Monster XP</span>
+					<span className="tabular-nums">
+						{formatXp(breakdown.totalMonsterXp)}
+					</span>
+				</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/stat-block.tsx
+++ b/apps/web/src/components/stat-block.tsx
@@ -1,5 +1,5 @@
+import type { Creature, TraitBlock, TraitSegment } from "@initiative/domain";
 import {
-	type Creature,
 	calculateInitiative,
 	formatInitiativeModifier,
 } from "@initiative/domain";
@@ -34,11 +34,56 @@ function SectionDivider() {
 	);
 }

+function segmentKey(seg: TraitSegment): string {
+	return seg.type === "text"
+		? seg.value.slice(0, 40)
+		: seg.items.map((i) => i.label ?? i.text.slice(0, 20)).join(",");
+}
+
+function TraitSegments({
+	segments,
+}: Readonly<{ segments: readonly TraitSegment[] }>) {
+	return (
+		<>
+			{segments.map((seg, i) => {
+				if (seg.type === "text") {
+					return (
+						<span key={segmentKey(seg)}>
+							{i === 0 ? ` ${seg.value}` : seg.value}
+						</span>
+					);
+				}
+				return (
+					<div key={segmentKey(seg)} className="mt-1 space-y-0.5">
+						{seg.items.map((item) => (
+							<p key={item.label ?? item.text}>
+								{item.label != null && (
+									<span className="font-semibold">{item.label}. </span>
+								)}
+								{item.text}
+							</p>
+						))}
+					</div>
+				);
+			})}
+		</>
+	);
+}
+
+function TraitEntry({ trait }: Readonly<{ trait: TraitBlock }>) {
+	return (
+		<div className="text-sm">
+			<span className="font-semibold italic">{trait.name}.</span>
+			<TraitSegments segments={trait.segments} />
+		</div>
+	);
+}
+
 function TraitSection({
 	entries,
 	heading,
 }: Readonly<{
-	entries: readonly { name: string; text: string }[] | undefined;
+	entries: readonly TraitBlock[] | undefined;
 	heading?: string;
 }>) {
 	if (!entries || entries.length === 0) return null;
@@ -50,9 +95,7 @@ function TraitSection({
 			) : null}
 			<div className="space-y-2">
 				{entries.map((e) => (
-					<div key={e.name} className="text-sm">
-						<span className="font-semibold italic">{e.name}.</span> {e.text}
-					</div>
+					<TraitEntry key={e.name} trait={e} />
 				))}
 			</div>
 		</>
@@ -219,9 +262,7 @@ export function StatBlock({ creature }: Readonly<StatBlockProps>) {
 					</p>
 					<div className="space-y-2">
 						{creature.legendaryActions.entries.map((a) => (
-							<div key={a.name} className="text-sm">
-								<span className="font-semibold italic">{a.name}.</span> {a.text}
-							</div>
+							<TraitEntry key={a.name} trait={a} />
 						))}
 					</div>
 				</>
--- 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", {
@@ -292,4 +293,56 @@ describe("useDifficultyBreakdown", () => {
 		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.tsx
+++ b/apps/web/src/hooks/tests/use-difficulty.test.tsx
@@ -12,6 +12,7 @@ import {
 } 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", {
@@ -81,7 +82,7 @@ describe("useDifficulty", () => {

 		await waitFor(() => {
 			expect(result.current).not.toBeNull();
-			expect(result.current?.tier).toBe("low");
+			expect(result.current?.tier).toBe(1);
 			expect(result.current?.totalMonsterXp).toBe(50);
 		});
 	});
@@ -223,9 +224,9 @@ describe("useDifficulty", () => {
 			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("low");
+			expect(result.current?.tier).toBe(1);
 			expect(result.current?.totalMonsterXp).toBe(50);
-			expect(result.current?.partyBudget.low).toBe(50);
+			expect(result.current?.thresholds[0].value).toBe(50);
 		});
 	});

@@ -261,7 +262,7 @@ describe("useDifficulty", () => {
 		await waitFor(() => {
 			expect(result.current).not.toBeNull();
 			// 2x level 1: budget low=100
-			expect(result.current?.partyBudget.low).toBe(100);
+			expect(result.current?.thresholds[0].value).toBe(100);
 		});
 	});

@@ -304,7 +305,7 @@ describe("useDifficulty", () => {
 			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("trivial");
+			expect(result.current?.tier).toBe(0);
 		});
 	});

@@ -336,12 +337,57 @@ describe("useDifficulty", () => {
 			expect(result.current).not.toBeNull();
 			// Level 3 budget: low=150, mod=225, high=400
 			// CR 1/4 = 50 XP -> trivial
-			expect(result.current?.partyBudget.low).toBe(150);
+			expect(result.current?.thresholds[0].value).toBe(150);
 			expect(result.current?.totalMonsterXp).toBe(50);
-			expect(result.current?.tier).toBe("trivial");
+			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({
--- 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,7 @@ 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 {
@@ -24,11 +26,10 @@ export interface BreakdownCombatant {
 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 partyCombatants: readonly BreakdownCombatant[];
 	readonly enemyCombatants: readonly BreakdownCombatant[];
@@ -38,6 +39,7 @@ export function useDifficultyBreakdown(): DifficultyBreakdown | null {
 	const { encounter } = useEncounterContext();
 	const { characters } = usePlayerCharactersContext();
 	const { getCreature } = useBestiaryContext();
+	const { edition } = useRulesEditionContext();

 	return useMemo(() => {
 		const { partyCombatants, enemyCombatants, descriptors, pcCount } =
@@ -50,7 +52,7 @@ export function useDifficultyBreakdown(): DifficultyBreakdown | null {

 		if (!hasPartyLevel || !hasCr) return null;

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

 		return {
 			...result,
@@ -58,7 +60,7 @@ export function useDifficultyBreakdown(): DifficultyBreakdown | null {
 			partyCombatants,
 			enemyCombatants,
 		};
-	}, [encounter.combatants, characters, getCreature]);
+	}, [encounter.combatants, characters, getCreature, edition]);
 }

 type CreatureInfo = {
--- a/apps/web/src/hooks/use-difficulty.ts
+++ b/apps/web/src/hooks/use-difficulty.ts
@@ -10,6 +10,7 @@ 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";

 export function resolveSide(c: Combatant): "party" | "enemy" {
 	if (c.side) return c.side;
@@ -42,6 +43,7 @@ export function useDifficulty(): DifficultyResult | null {
 	const { encounter } = useEncounterContext();
 	const { characters } = usePlayerCharactersContext();
 	const { getCreature } = useBestiaryContext();
+	const { edition } = useRulesEditionContext();

 	return useMemo(() => {
 		const descriptors = buildDescriptors(
@@ -57,6 +59,6 @@ export function useDifficulty(): DifficultyResult | null {

 		if (!hasPartyLevel || !hasCr) return null;

-		return calculateEncounterDifficulty(descriptors);
-	}, [encounter.combatants, characters, getCreature]);
+		return calculateEncounterDifficulty(descriptors, edition);
+	}, [encounter.combatants, characters, getCreature, edition]);
 }
--- a/packages/domain/src/tests/encounter-difficulty.test.ts
+++ b/packages/domain/src/tests/encounter-difficulty.test.ts
@@ -46,185 +46,195 @@ function enemy(cr: string) {
 	return { cr, side: "enemy" as const };
 }

-describe("calculateEncounterDifficulty", () => {
-	it("returns trivial when monster XP is below Low threshold", () => {
+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([
-			party(1),
-			party(1),
-			party(1),
-			party(1),
-			enemy("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)", () => {
-		const result = calculateEncounterDifficulty([
-			party(1),
-			party(1),
-			party(1),
-			party(1),
-			enemy("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 1150 XP", () => {
+	it("returns tier 2 for 5x level 3 vs 1150 XP", () => {
 		// 5x level 3: Low = 750, Moderate = 1125, High = 2000
 		// 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"),
-		]);
-		expect(result.tier).toBe("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([
-			party(1),
-			party(1),
-			party(1),
-			party(1),
-			enemy("1"),
-			enemy("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", () => {
-		const result = calculateEncounterDifficulty([
-			party(1),
-			party(1),
-			party(1),
-			party(1),
-			enemy("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
 		// Total: low=550, mod=825, high=1400
-		const result = calculateEncounterDifficulty([
-			party(3),
-			party(3),
-			party(3),
-			party(2),
-			enemy("3"),
+		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.partyBudget).toEqual({
-			low: 550,
-			moderate: 825,
-			high: 1400,
-		});
 		expect(result.totalMonsterXp).toBe(700);
-		expect(result.tier).toBe("low");
+		expect(result.tier).toBe(1);
 	});

-	it("returns trivial with no enemies", () => {
-		const result = calculateEncounterDifficulty([party(5), party(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 no party levels (zero budget thresholds)", () => {
-		const result = calculateEncounterDifficulty([enemy("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([
-			party(1),
-			party(1),
-			party(1),
-			party(1),
-			enemy("1/8"),
-			enemy("1/4"),
-			enemy("1/2"),
-		]);
+		const result = calculateEncounterDifficulty(
+			[
+				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([
-			party(1),
-			party(1),
-			party(1),
-			party(1),
-			enemy("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" },
-		]);
+		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("low"); // 250 >= 200 Low, < 300 Moderate
+		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
-		]);
+		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("trivial");
+		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
+		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.partyBudget).toEqual({ low: 50, moderate: 75, high: 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" }, // should not add to budget
-			enemy("1"),
-		]);
+		const result = calculateEncounterDifficulty(
+			[party(1), { level: 5, side: "enemy" }, enemy("1")],
+			"5.5e",
+		);
 		// Only level 1 party contributes to budget
-		expect(result.partyBudget).toEqual({ low: 50, moderate: 75, high: 100 });
+		expect(result.thresholds).toEqual([
+			{ label: "Low", value: 50 },
+			{ label: "Moderate", value: 75 },
+			{ label: "High", value: 100 },
+		]);
 		expect(result.totalMonsterXp).toBe(200);
 	});

@@ -232,19 +242,147 @@ describe("calculateEncounterDifficulty", () => {
 		// 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"),
+		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.partyBudget).toEqual({
-			low: 300,
-			moderate: 450,
-			high: 800,
-		});
 		expect(result.totalMonsterXp).toBe(700);
-		expect(result.tier).toBe("moderate"); // 700 >= 450 Moderate, < 800 High
+		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/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/creature-types.ts
+++ b/packages/domain/src/creature-types.ts
@@ -5,9 +5,18 @@ export function creatureId(id: string): CreatureId {
 	return id as CreatureId;
 }

+export type TraitSegment =
+	| { readonly type: "text"; readonly value: string }
+	| { readonly type: "list"; readonly items: readonly TraitListItem[] };
+
+export interface TraitListItem {
+	readonly label?: string;
+	readonly text: string;
+}
+
 export interface TraitBlock {
 	readonly name: string;
-	readonly text: string;
+	readonly segments: readonly TraitSegment[];
 }

 export interface LegendaryBlock {
--- 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);

@@ -90,14 +176,66 @@ export interface CombatantDescriptor {

 function determineTier(
 	xp: number,
-	low: number,
-	moderate: number,
-	high: number,
+	tierThresholds: readonly number[],
 ): DifficultyTier {
-	if (xp >= high) return "high";
-	if (xp >= moderate) return "moderate";
-	if (xp >= low) return "low";
-	return "trivial";
+	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;
+	let monsterCount = 0;
+	const partyLevels: number[] = [];
+
+	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 {
+		totalMonsterXp: Math.max(0, totalMonsterXp),
+		monsterCount,
+		partyLevels,
+	};
 }

 /**
@@ -107,41 +245,54 @@ function determineTier(
 */
 export function calculateEncounterDifficulty(
 	combatants: readonly CombatantDescriptor[],
+	edition: RulesEdition,
 ): DifficultyResult {
-	let budgetLow = 0;
-	let budgetModerate = 0;
-	let budgetHigh = 0;
-	let totalMonsterXp = 0;
+	const { totalMonsterXp, monsterCount, partyLevels } =
+		scanCombatants(combatants);

-	for (const c of combatants) {
-		if (c.level !== undefined && c.side === "party") {
-			const budget = XP_BUDGET_PER_CHARACTER[c.level];
-			if (budget) {
-				budgetLow += budget.low;
-				budgetModerate += budget.moderate;
-				budgetHigh += budget.high;
-			}
-		}
-
-		if (c.cr !== undefined) {
-			const xp = crToXp(c.cr);
-			if (c.side === "enemy") {
-				totalMonsterXp += xp;
-			} else {
-				totalMonsterXp -= xp;
-			}
-		}
+	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,
+		};
 	}

-	totalMonsterXp = Math.max(0, totalMonsterXp);
+	// 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(totalMonsterXp, budgetLow, budgetModerate, budgetHigh),
+		tier: determineTier(adjustedXp, [
+			budget.medium,
+			budget.hard,
+			budget.deadly,
+		]),
 		totalMonsterXp,
-		partyBudget: {
-			low: budgetLow,
-			moderate: budgetModerate,
-			high: budgetHigh,
-		},
+		thresholds,
+		encounterMultiplier,
+		adjustedXp,
+		partySizeAdjusted,
 	};
 }
--- 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 {
@@ -35,6 +34,8 @@ export {
 	proficiencyBonus,
 	type SpellcastingBlock,
 	type TraitBlock,
+	type TraitListItem,
+	type TraitSegment,
 } from "./creature-types.js";
 export {
 	type DeletePlayerCharacterSuccess,
@@ -53,6 +54,7 @@ export {
 	calculateEncounterDifficulty,
 	crToXp,
 	type DifficultyResult,
+	type DifficultyThreshold,
 	type DifficultyTier,
 	VALID_CR_VALUES,
 } from "./encounter-difficulty.js";
@@ -110,6 +112,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";
--- a/packages/domain/src/rules-edition.ts
+++ b/packages/domain/src/rules-edition.ts
@@ -0,0 +1 @@
+export type RulesEdition = "5e" | "5.5e";
--- 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)", Gitea issue #22 — "Combatant side assignment for encounter difficulty"
+**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
@@ -105,6 +111,14 @@ The difficulty calculation uses the 2024 5.5e XP Budget per Character table and

 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
@@ -133,6 +147,10 @@ The game master taps the difficulty indicator to open a breakdown panel. The pan

 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
@@ -207,6 +225,34 @@ A game master has allied NPCs fighting alongside the party. From the difficulty

 ---

+### 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."
@@ -223,6 +269,11 @@ A game master has allied NPCs fighting alongside the party. From the difficulty
 - **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.

 ---

@@ -243,7 +294,7 @@ The system MUST calculate the party's XP budget by summing the per-character bud
 The system MUST calculate the net monster XP by summing the XP value (derived from CR) for each enemy-side combatant that has a CR and subtracting the XP value for each party-side combatant that has a CR. For bestiary-linked combatants, CR is derived from the creature data via `creatureId`. For custom combatants, CR comes from the optional `cr` field. Combatants with neither `creatureId` nor `cr` are excluded. The net monster XP MUST be floored at 0.

 #### FR-005 — Difficulty tier determination
-The system MUST determine the encounter difficulty tier by comparing total monster XP 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.
@@ -252,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.
@@ -279,7 +330,7 @@ The `Combatant` entity MUST support an optional `cr` field accepting standard 5e
 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), 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 (e.g., "Allied NPC XP is subtracted from encounter difficulty"). Source names are omitted from the panel to conserve horizontal space.
+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.
@@ -303,7 +354,28 @@ The breakdown panel MUST provide a side toggle button per non-PC combatant to sw
 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 }` so it can partition combatants internally, replacing the current `partyLevels[]` / `monsterCrs[]` 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

@@ -314,6 +386,8 @@ The `calculateEncounterDifficulty` domain function MUST accept combatant descrip
 - **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).

 ---

@@ -331,6 +405,8 @@ The `calculateEncounterDifficulty` domain function MUST accept combatant descrip
 - **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.

 ---

@@ -343,5 +419,8 @@ The `calculateEncounterDifficulty` domain function MUST accept combatant descrip
 - 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 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.