Add force, void, spirit, vitality, and piercing persistent damage types

Expands persistent damage from 7 to 12 types to cover all PF2e damage
types that have verified persistent damage sources in published content.

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

.claude/skills/commit/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: commit
 description: Create a git commit with pre-commit hooks (bypasses sandbox restrictions).
-disable-model-invocation: true
 allowed-tools: Bash(git *), Bash(pnpm *)
 ---
 

.claude/skills/ship/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: ship
+description: Commit, tag with the next version, and push to remote.
+disable-model-invocation: true
+allowed-tools: Bash(git *), Bash(pnpm *), Skill
+---
+
+## Instructions
+
+Commit current changes, create the next version tag, and push everything to remote.
+
+### Step 1 — Commit
+
+Use the `/commit` skill to stage and commit changes. Pass along any user arguments as the commit message.
+
+```
+/commit $ARGUMENTS
+```
+
+### Step 2 — Tag
+
+Get the latest tag and increment the patch number (e.g., `0.9.27` → `0.9.28`). Create the tag:
+
+```bash
+git tag --sort=-v:refname | head -1
+```
+
+```bash
+git tag <next-version>
+```
+
+### Step 3 — Push
+
+Push the commit and tag to remote:
+
+```bash
+git push && git push --tags
+```
+
+### Step 4 — Verify
+
+Confirm the tag exists on the pushed commit:
+
+```bash
+git log --oneline -1 --decorate
+```
+
+## User arguments
+
+```text
+$ARGUMENTS
+```
+
+If the user provided arguments, treat them as the commit message or guidance for what to commit.

apps/web/src/__tests__/adapters/in-memory-adapters.ts

@@ -116,6 +116,7 @@ export function createTestAdapters(options?: {
 				`https://example.com/creatures-${sourceCode.toLowerCase()}.json`,
 			getSourceDisplayName: (sourceCode) => sourceCode,
 			getCreaturePathsForSource: () => [],
+			getCreatureNamesByPaths: () => new Map(),
 		},
 	};
 }

apps/web/src/__tests__/app-integration.test.tsx

@@ -33,8 +33,7 @@ async function addCombatant(
 	opts?: { maxHp?: string },
 ) {
 	const inputs = screen.getAllByPlaceholderText("+ Add combatants");
-	// biome-ignore lint/style/noNonNullAssertion: getAllBy always returns at least one
+	const input = inputs.at(-1) ?? inputs[0];
-	const input = inputs.at(-1)!;
 	await user.type(input, name);
 
 	if (opts?.maxHp) {

apps/web/src/__tests__/confirm-button.test.tsx

@@ -198,21 +198,23 @@ describe("ConfirmButton", () => {
 
 	it("Enter/Space keydown stops propagation to prevent parent handlers", () => {
 		const parentHandler = vi.fn();
-		render(
+		function Wrapper() {
-			// biome-ignore lint/a11y/noStaticElementInteractions: test wrapper
+			return (
-			// biome-ignore lint/a11y/noNoninteractiveElementInteractions: test wrapper
+				<button type="button" onKeyDown={parentHandler}>
-			<div onKeyDown={parentHandler}>
+					<ConfirmButton
-				<ConfirmButton
+						icon={<XIcon />}
-					icon={<XIcon />}
+						label="Remove combatant"
-					label="Remove combatant"
+						onConfirm={vi.fn()}
-					onConfirm={vi.fn()}
+					/>
-				/>
+				</button>
-			</div>,
+			);
-		);
+		}
-		const button = screen.getByRole("button");
+		render(<Wrapper />);
+		const buttons = screen.getAllByRole("button");
+		const confirmButton = buttons.at(-1) ?? buttons[0];
 
-		fireEvent.keyDown(button, { key: "Enter" });
+		fireEvent.keyDown(confirmButton, { key: "Enter" });
-		fireEvent.keyDown(button, { key: " " });
+		fireEvent.keyDown(confirmButton, { key: " " });
 
 		expect(parentHandler).not.toHaveBeenCalled();
 	});

apps/web/src/__tests__/stat-block-collapse-pin.test.tsx

@@ -16,12 +16,18 @@ vi.mock("../contexts/bestiary-context.js", () => ({
 	useBestiaryContext: vi.fn(),
 }));
 
+vi.mock("../contexts/encounter-context.js", () => ({
+	useEncounterContext: vi.fn(),
+}));
+
 import { StatBlockPanel } from "../components/stat-block-panel.js";
 import { useBestiaryContext } from "../contexts/bestiary-context.js";
+import { useEncounterContext } from "../contexts/encounter-context.js";
 import { useSidePanelContext } from "../contexts/side-panel-context.js";
 
 const mockUseSidePanelContext = vi.mocked(useSidePanelContext);
 const mockUseBestiaryContext = vi.mocked(useBestiaryContext);
+const mockUseEncounterContext = vi.mocked(useEncounterContext);
 
 const CLOSE_REGEX = /close/i;
 const COLLAPSE_REGEX = /collapse/i;
@@ -82,6 +88,7 @@ function setupMocks(overrides: PanelOverrides = {}) {
 
 	mockUseSidePanelContext.mockReturnValue({
 		selectedCreatureId: panelRole === "browse" ? creatureId : null,
+		selectedCombatantId: null,
 		pinnedCreatureId: panelRole === "pinned" ? creatureId : null,
 		isRightPanelCollapsed: panelRole === "browse" ? isCollapsed : false,
 		isWideDesktop: false,
@@ -110,6 +117,11 @@ function setupMocks(overrides: PanelOverrides = {}) {
 		refreshCache: vi.fn(),
 	} as ReturnType<typeof useBestiaryContext>);
 
+	mockUseEncounterContext.mockReturnValue({
+		encounter: { combatants: [], activeIndex: 0, roundNumber: 1 },
+		setCreatureAdjustment: vi.fn(),
+	} as unknown as ReturnType<typeof useEncounterContext>);
+
 	return { onToggleCollapse, onPin, onUnpin, onDismiss };
 }
 

apps/web/src/adapters/__tests__/bestiary-adapter.test.ts

@@ -181,17 +181,20 @@ describe("normalizeBestiary", () => {
 		expect(sc?.name).toBe("Spellcasting");
 		expect(sc?.headerText).toContain("DC 15");
 		expect(sc?.headerText).not.toContain("{@");
-		expect(sc?.atWill).toEqual(["Detect Magic", "Mage Hand"]);
+		expect(sc?.atWill).toEqual([
+			{ name: "Detect Magic" },
+			{ name: "Mage Hand" },
+		]);
 		expect(sc?.daily).toHaveLength(2);
 		expect(sc?.daily).toContainEqual({
 			uses: 2,
 			each: true,
-			spells: ["Fireball"],
+			spells: [{ name: "Fireball" }],
 		});
 		expect(sc?.daily).toContainEqual({
 			uses: 1,
 			each: false,
-			spells: ["Dimension Door"],
+			spells: [{ name: "Dimension Door" }],
 		});
 	});
 

apps/web/src/adapters/__tests__/pf2e-bestiary-adapter.test.ts

@@ -131,6 +131,39 @@ describe("normalizeFoundryCreature", () => {
 			);
 			expect(creature.senses).toBe("Scent 60 feet");
 		});
+
+		it("extracts perception details", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					system: {
+						...minimalCreature().system,
+						perception: {
+							mod: 35,
+							details: "smoke vision",
+							senses: [{ type: "darkvision" }],
+						},
+					},
+				}),
+			);
+			expect(creature.perceptionDetails).toBe("smoke vision");
+			expect(creature.senses).toBe("Darkvision");
+		});
+
+		it("omits perception details when empty", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					system: {
+						...minimalCreature().system,
+						perception: {
+							mod: 8,
+							details: "",
+							senses: [{ type: "darkvision" }],
+						},
+					},
+				}),
+			);
+			expect(creature.perceptionDetails).toBeUndefined();
+		});
 	});
 
 	describe("languages formatting", () => {
@@ -386,6 +419,101 @@ describe("normalizeFoundryCreature", () => {
 				}),
 			);
 		});
+
+		it("includes attack effects in damage text", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "atk1",
+							name: "talon",
+							type: "melee",
+							system: {
+								bonus: { value: 14 },
+								damageRolls: {
+									abc: {
+										damage: "1d10+6",
+										damageType: "piercing",
+									},
+								},
+								traits: { value: [] },
+								attackEffects: { value: ["grab"] },
+							},
+						},
+					],
+				}),
+			);
+			const attack = creature.attacks?.[0];
+			expect(attack?.segments[0]).toEqual({
+				type: "text",
+				value: "+14, 1d10+6 piercing plus Grab",
+			});
+		});
+
+		it("joins multiple attack effects with 'and'", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "atk1",
+							name: "claw",
+							type: "melee",
+							system: {
+								bonus: { value: 18 },
+								damageRolls: {
+									abc: {
+										damage: "2d8+6",
+										damageType: "slashing",
+									},
+								},
+								traits: { value: [] },
+								attackEffects: {
+									value: ["grab", "knockdown"],
+								},
+							},
+						},
+					],
+				}),
+			);
+			const attack = creature.attacks?.[0];
+			expect(attack?.segments[0]).toEqual({
+				type: "text",
+				value: "+18, 2d8+6 slashing plus Grab and Knockdown",
+			});
+		});
+
+		it("strips creature-name prefix from attack effect slugs", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					name: "Lich",
+					items: [
+						{
+							_id: "atk1",
+							name: "hand",
+							type: "melee",
+							system: {
+								bonus: { value: 24 },
+								damageRolls: {
+									abc: {
+										damage: "2d12+7",
+										damageType: "negative",
+									},
+								},
+								traits: { value: [] },
+								attackEffects: {
+									value: ["lich-siphon-life"],
+								},
+							},
+						},
+					],
+				}),
+			);
+			const attack = creature.attacks?.[0];
+			expect(attack?.segments[0]).toEqual({
+				type: "text",
+				value: "+24, 2d12+7 negative plus Siphon Life",
+			});
+		});
 	});
 
 	describe("ability normalization", () => {
@@ -539,6 +667,396 @@ describe("normalizeFoundryCreature", () => {
 					: undefined,
 			).toBe("(Concentrate, Polymorph) Takes a new form.");
 		});
+
+		it("extracts frequency from ability", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "a1",
+							name: "Drain Soul Cage",
+							type: "action",
+							system: {
+								category: "offensive",
+								actionType: { value: "free" },
+								actions: { value: null },
+								traits: { value: [] },
+								description: { value: "<p>Drains the soul.</p>" },
+								frequency: { max: 1, per: "day" },
+							},
+						},
+					],
+				}),
+			);
+			expect(creature.abilitiesBot?.[0]?.frequency).toBe("1/day");
+		});
+
+		it("strips redundant frequency line from description", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "a1",
+							name: "Consult the Text",
+							type: "action",
+							system: {
+								category: "offensive",
+								actionType: { value: "action" },
+								actions: { value: 1 },
+								traits: { value: [] },
+								description: {
+									value:
+										"<p><strong>Frequency</strong> once per day</p>\n<hr />\n<p><strong>Effect</strong> The lich opens their spell tome.</p>",
+								},
+								frequency: { max: 1, per: "day" },
+							},
+						},
+					],
+				}),
+			);
+			const text =
+				creature.abilitiesBot?.[0]?.segments[0]?.type === "text"
+					? creature.abilitiesBot[0].segments[0].value
+					: "";
+			expect(text).not.toContain("Frequency");
+			expect(text).toContain("The lich opens their spell tome.");
+		});
+
+		it("strips frequency line even when preceded by other text", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "a1",
+							name: "Drain Soul Cage",
+							type: "action",
+							system: {
+								category: "offensive",
+								actionType: { value: "free" },
+								actions: { value: null },
+								traits: { value: [] },
+								description: {
+									value:
+										"<p>6th rank</p>\n<hr />\n<p><strong>Frequency</strong> once per day</p>\n<hr />\n<p><strong>Effect</strong> The lich taps into their soul cage.</p>",
+								},
+								frequency: { max: 1, per: "day" },
+							},
+						},
+					],
+				}),
+			);
+			const text =
+				creature.abilitiesBot?.[0]?.segments[0]?.type === "text"
+					? creature.abilitiesBot[0].segments[0].value
+					: "";
+			expect(text).not.toContain("Frequency");
+			expect(text).toContain("6th rank");
+			expect(text).toContain("The lich taps into their soul cage.");
+		});
+
+		it("omits frequency when not present", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "a1",
+							name: "Strike",
+							type: "action",
+							system: {
+								category: "offensive",
+								actionType: { value: "action" },
+								actions: { value: 1 },
+								traits: { value: [] },
+								description: { value: "<p>Strikes.</p>" },
+							},
+						},
+					],
+				}),
+			);
+			expect(creature.abilitiesBot?.[0]?.frequency).toBeUndefined();
+		});
+	});
+
+	describe("equipment normalization", () => {
+		it("normalizes a weapon with traits and description", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "w1",
+							name: "Flaming Longsword",
+							type: "weapon",
+							system: {
+								level: { value: 5 },
+								traits: { value: ["magical", "fire"] },
+								description: {
+									value: "<p>This sword blazes with fire.</p>",
+								},
+							},
+						},
+					],
+				}),
+			);
+			expect(creature.equipment).toHaveLength(1);
+			const item = creature.equipment?.[0];
+			expect(item?.name).toBe("Flaming Longsword");
+			expect(item?.level).toBe(5);
+			expect(item?.traits).toEqual(["magical", "fire"]);
+			expect(item?.description).toBe("This sword blazes with fire.");
+		});
+
+		it("normalizes a consumable potion with description", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "c1",
+							name: "Healing Potion (Moderate)",
+							type: "consumable",
+							system: {
+								level: { value: 6 },
+								traits: { value: ["consumable", "healing", "magical"] },
+								description: {
+									value: "<p>Restores 3d8+10 Hit Points.</p>",
+								},
+								category: "potion",
+							},
+						},
+					],
+				}),
+			);
+			expect(creature.equipment).toHaveLength(1);
+			const item = creature.equipment?.[0];
+			expect(item?.name).toBe("Healing Potion (Moderate)");
+			expect(item?.category).toBe("potion");
+			expect(item?.description).toBe("Restores 3d8+10 Hit Points.");
+		});
+
+		it("extracts scroll embedded spell name and rank", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "s1",
+							name: "Scroll of Teleport (Rank 6)",
+							type: "consumable",
+							system: {
+								level: { value: 11 },
+								traits: { value: ["consumable", "magical", "scroll"] },
+								description: { value: "<p>A scroll.</p>" },
+								category: "scroll",
+								spell: {
+									name: "Teleport",
+									system: { level: { value: 6 } },
+								},
+							},
+						},
+					],
+				}),
+			);
+			const item = creature.equipment?.[0];
+			expect(item?.spellName).toBe("Teleport");
+			expect(item?.spellRank).toBe(6);
+		});
+
+		it("extracts wand embedded spell name and rank", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "w1",
+							name: "Wand of Dispel Magic (Rank 2)",
+							type: "consumable",
+							system: {
+								level: { value: 5 },
+								traits: { value: ["consumable", "magical", "wand"] },
+								description: { value: "<p>A wand.</p>" },
+								category: "wand",
+								spell: {
+									name: "Dispel Magic",
+									system: { level: { value: 2 } },
+								},
+							},
+						},
+					],
+				}),
+			);
+			const item = creature.equipment?.[0];
+			expect(item?.spellName).toBe("Dispel Magic");
+			expect(item?.spellRank).toBe(2);
+		});
+
+		it("filters magical equipment into equipment field", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "e1",
+							name: "Ring of Energy Resistance (Fire)",
+							type: "equipment",
+							system: {
+								level: { value: 6 },
+								traits: { value: ["magical", "invested"] },
+								description: {
+									value: "<p>Grants fire resistance 5.</p>",
+								},
+							},
+						},
+					],
+				}),
+			);
+			expect(creature.equipment).toHaveLength(1);
+			expect(creature.equipment?.[0]?.name).toBe(
+				"Ring of Energy Resistance (Fire)",
+			);
+			expect(creature.items).toBeUndefined();
+		});
+
+		it("filters mundane items into items string", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "w1",
+							name: "Longsword",
+							type: "weapon",
+							system: {
+								level: { value: 0 },
+								traits: { value: [] },
+								description: { value: "" },
+							},
+						},
+						{
+							_id: "a1",
+							name: "Leather Armor",
+							type: "armor",
+							system: {
+								level: { value: 0 },
+								traits: { value: [] },
+								description: { value: "" },
+							},
+						},
+					],
+				}),
+			);
+			expect(creature.items).toBe("Longsword, Leather Armor");
+			expect(creature.equipment).toBeUndefined();
+		});
+
+		it("omits equipment when no detailed items exist", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "w1",
+							name: "Dagger",
+							type: "weapon",
+							system: {
+								level: { value: 0 },
+								traits: { value: [] },
+								description: { value: "" },
+							},
+						},
+					],
+				}),
+			);
+			expect(creature.equipment).toBeUndefined();
+		});
+
+		it("omits items when no mundane items exist", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "c1",
+							name: "Giant Wasp Venom",
+							type: "consumable",
+							system: {
+								level: { value: 7 },
+								traits: { value: ["consumable", "poison"] },
+								description: {
+									value: "<p>A deadly poison.</p>",
+								},
+								category: "poison",
+							},
+						},
+					],
+				}),
+			);
+			expect(creature.items).toBeUndefined();
+			expect(creature.equipment).toHaveLength(1);
+		});
+
+		it("includes armor with special material in equipment", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "a1",
+							name: "Adamantine Full Plate",
+							type: "armor",
+							system: {
+								level: { value: 0 },
+								traits: { value: [] },
+								description: {
+									value: "<p>Full plate made of adamantine.</p>",
+								},
+								material: { type: "adamantine", grade: "standard" },
+							},
+						},
+					],
+				}),
+			);
+			expect(creature.equipment).toHaveLength(1);
+			expect(creature.equipment?.[0]?.name).toBe("Adamantine Full Plate");
+		});
+
+		it("excludes mundane armor from equipment (goes to items)", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "a1",
+							name: "Chain Mail",
+							type: "armor",
+							system: {
+								level: { value: 0 },
+								traits: { value: [] },
+								description: { value: "" },
+							},
+						},
+					],
+				}),
+			);
+			expect(creature.equipment).toBeUndefined();
+			expect(creature.items).toBe("Chain Mail");
+		});
+
+		it("strips Foundry HTML tags from equipment descriptions", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "c1",
+							name: "Potion of Speed",
+							type: "consumable",
+							system: {
+								level: { value: 10 },
+								traits: { value: ["consumable", "magical"] },
+								description: {
+									value:
+										"<p>Gain @UUID[Compendium.pf2e.conditionitems.Item.Quickened]{quickened} for 1 minute.</p>",
+								},
+								category: "potion",
+							},
+						},
+					],
+				}),
+			);
+			const desc = creature.equipment?.[0]?.description;
+			expect(desc).toBe("Gain quickened for 1 minute.");
+			expect(desc).not.toContain("@UUID");
+		});
 	});
 
 	describe("spellcasting normalization", () => {
@@ -593,11 +1111,12 @@ describe("normalizeFoundryCreature", () => {
 			const sc = creature.spellcasting?.[0];
 			expect(sc?.name).toBe("Primal Prepared Spells");
 			expect(sc?.headerText).toBe("DC 30, attack +22");
-			expect(sc?.daily).toEqual([
+			expect(sc?.daily?.map((d) => d.uses)).toEqual([6, 3]);
-				{ uses: 6, each: true, spells: ["Earthquake"] },
+			expect(sc?.daily?.[0]?.spells.map((s) => s.name)).toEqual(["Earthquake"]);
-				{ uses: 3, each: true, spells: ["Heal"] },
+			expect(sc?.daily?.[1]?.spells.map((s) => s.name)).toEqual(["Heal"]);
-			]);
+			expect(sc?.atWill?.map((s) => s.name)).toEqual(["Detect Magic"]);
-			expect(sc?.atWill).toEqual(["Detect Magic"]);
+			// Cantrip rank auto-heightens to ceil(creatureLevel / 2) = ceil(3/2) = 2
+			expect(sc?.atWill?.[0]?.rank).toBe(2);
 		});
 
 		it("normalizes innate spells with uses", () => {
@@ -633,13 +1152,334 @@ describe("normalizeFoundryCreature", () => {
 			);
 			const sc = creature.spellcasting?.[0];
 			expect(sc?.headerText).toBe("DC 32");
-			expect(sc?.daily).toEqual([
+			expect(sc?.daily).toHaveLength(1);
-				{
+			const spell = sc?.daily?.[0]?.spells[0];
-					uses: 1,
+			expect(spell?.name).toBe("Sure Strike");
-					each: true,
+			expect(spell?.usesPerDay).toBe(3);
-					spells: ["Sure Strike (\u00d73)"],
+			expect(spell?.rank).toBe(1);
-				},
+		});
-			]);
+
+		it("preserves full spell data including description and heightening", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "entry1",
+							name: "Divine Innate Spells",
+							type: "spellcastingEntry",
+							system: {
+								tradition: { value: "divine" },
+								prepared: { value: "innate" },
+								spelldc: { dc: 35, value: 27 },
+							},
+						},
+						{
+							_id: "s1",
+							name: "Heal",
+							type: "spell",
+							system: {
+								slug: "heal",
+								location: { value: "entry1" },
+								level: { value: 6 },
+								traits: {
+									rarity: "common",
+									value: ["healing", "vitality"],
+									traditions: ["divine", "primal"],
+								},
+								description: {
+									value:
+										"<p>You channel @UUID[Compendium.pf2e.spells.Item.Heal]{positive} energy to heal the living. The target regains @Damage[2d8[vitality]] Hit Points.</p>",
+								},
+								range: { value: "30 feet" },
+								target: { value: "1 willing creature" },
+								duration: { value: "" },
+								defense: undefined,
+								time: { value: "1" },
+								heightening: {
+									type: "interval",
+									interval: 1,
+									damage: { value: "2d8" },
+								},
+							},
+						},
+						{
+							_id: "s2",
+							name: "Force Barrage",
+							type: "spell",
+							system: {
+								location: { value: "entry1" },
+								level: { value: 1 },
+								traits: { value: ["concentrate", "manipulate"] },
+							},
+						},
+					],
+				}),
+			);
+			const sc = creature.spellcasting?.[0];
+			expect(sc).toBeDefined();
+			const heal = sc?.daily
+				?.flatMap((d) => d.spells)
+				.find((s) => s.name === "Heal");
+			expect(heal).toBeDefined();
+			expect(heal?.slug).toBe("heal");
+			expect(heal?.rank).toBe(6);
+			expect(heal?.range).toBe("30 feet");
+			expect(heal?.target).toBe("1 willing creature");
+			expect(heal?.traits).toEqual(["healing", "vitality"]);
+			expect(heal?.traditions).toEqual(["divine", "primal"]);
+			expect(heal?.actionCost).toBe("1");
+			// Foundry tags stripped from description
+			expect(heal?.description).toContain("positive");
+			expect(heal?.description).not.toContain("@UUID");
+			expect(heal?.description).not.toContain("@Damage");
+			// Interval heightening formatted and not duplicated in description
+			expect(heal?.heightening).toBe("Heightened (+1) damage increases by 2d8");
+
+			// Spell without optional data still has name + rank
+			const fb = sc?.daily
+				?.flatMap((d) => d.spells)
+				.find((s) => s.name === "Force Barrage");
+			expect(fb).toBeDefined();
+			expect(fb?.rank).toBe(1);
+			expect(fb?.description).toBeUndefined();
+			expect(fb?.usesPerDay).toBeUndefined();
+		});
+
+		it("formats fixed-type heightening levels", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "entry1",
+							name: "Divine Prepared Spells",
+							type: "spellcastingEntry",
+							system: {
+								tradition: { value: "divine" },
+								prepared: { value: "prepared" },
+								spelldc: { dc: 30 },
+							},
+						},
+						{
+							_id: "s1",
+							name: "Magic Missile",
+							type: "spell",
+							system: {
+								location: { value: "entry1" },
+								level: { value: 1 },
+								traits: { value: [] },
+								heightening: {
+									type: "fixed",
+									levels: {
+										"3": { text: "<p>You shoot two more missiles.</p>" },
+										"5": { text: "<p>You shoot four more missiles.</p>" },
+									},
+								},
+							},
+						},
+					],
+				}),
+			);
+			const spell = creature.spellcasting?.[0]?.daily
+				?.flatMap((d) => d.spells)
+				.find((s) => s.name === "Magic Missile");
+			expect(spell?.heightening).toContain(
+				"Heightened (3) You shoot two more missiles.",
+			);
+			expect(spell?.heightening).toContain(
+				"Heightened (5) You shoot four more missiles.",
+			);
+		});
+
+		it("formats save defense", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "entry1",
+							name: "Arcane Innate Spells",
+							type: "spellcastingEntry",
+							system: {
+								tradition: { value: "arcane" },
+								prepared: { value: "innate" },
+								spelldc: { dc: 25 },
+							},
+						},
+						{
+							_id: "s1",
+							name: "Fireball",
+							type: "spell",
+							system: {
+								location: { value: "entry1" },
+								level: { value: 3 },
+								traits: { value: ["fire"] },
+								area: { type: "burst", value: 20 },
+								defense: {
+									save: { statistic: "reflex", basic: true },
+								},
+							},
+						},
+					],
+				}),
+			);
+			const fireball = creature.spellcasting?.[0]?.daily
+				?.flatMap((d) => d.spells)
+				.find((s) => s.name === "Fireball");
+			expect(fireball?.defense).toBe("basic Reflex");
+			expect(fireball?.area).toBe("20-foot burst");
+		});
+
+		it("strips inline heightening text from description when structured heightening exists", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "entry1",
+							name: "Arcane Prepared Spells",
+							type: "spellcastingEntry",
+							system: {
+								tradition: { value: "arcane" },
+								prepared: { value: "prepared" },
+								spelldc: { dc: 30 },
+							},
+						},
+						{
+							_id: "s1",
+							name: "Chain Lightning",
+							type: "spell",
+							system: {
+								location: { value: "entry1" },
+								level: { value: 6 },
+								traits: { value: ["electricity"] },
+								description: {
+									value:
+										"<p>You discharge a bolt of lightning. The damage is 8d12.</p><p>Heightened (+1) The damage increases by 1d12.</p>",
+								},
+								heightening: {
+									type: "interval",
+									interval: 1,
+									damage: { value: "1d12" },
+								},
+							},
+						},
+					],
+				}),
+			);
+			const spell = creature.spellcasting?.[0]?.daily
+				?.flatMap((d) => d.spells)
+				.find((s) => s.name === "Chain Lightning");
+			expect(spell?.description).toBe(
+				"You discharge a bolt of lightning. The damage is 8d12.",
+			);
+			expect(spell?.description).not.toContain("Heightened");
+			expect(spell?.heightening).toBe(
+				"Heightened (+1) damage increases by 1d12",
+			);
+		});
+
+		it("formats overlays when heightening is absent", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "entry1",
+							name: "Arcane Innate Spells",
+							type: "spellcastingEntry",
+							system: {
+								tradition: { value: "arcane" },
+								prepared: { value: "innate" },
+								spelldc: { dc: 28 },
+							},
+						},
+						{
+							_id: "s1",
+							name: "Force Barrage",
+							type: "spell",
+							system: {
+								location: { value: "entry1" },
+								level: { value: 1 },
+								traits: { value: ["force", "manipulate"] },
+								description: {
+									value: "<p>You fire darts of force.</p>",
+								},
+								overlays: {
+									variant1: {
+										name: "2 actions",
+										system: {
+											description: {
+												value: "<p>You fire two darts.</p>",
+											},
+										},
+									},
+									variant2: {
+										name: "3 actions",
+										system: {
+											description: {
+												value: "<p>You fire three darts.</p>",
+											},
+										},
+									},
+								},
+							},
+						},
+					],
+				}),
+			);
+			const spell = creature.spellcasting?.[0]?.daily
+				?.flatMap((d) => d.spells)
+				.find((s) => s.name === "Force Barrage");
+			expect(spell?.heightening).toContain("2 actions: You fire two darts.");
+			expect(spell?.heightening).toContain("3 actions: You fire three darts.");
+		});
+
+		it("prefers heightening over overlays when both present", () => {
+			const creature = normalizeFoundryCreature(
+				minimalCreature({
+					items: [
+						{
+							_id: "entry1",
+							name: "Arcane Prepared Spells",
+							type: "spellcastingEntry",
+							system: {
+								tradition: { value: "arcane" },
+								prepared: { value: "prepared" },
+								spelldc: { dc: 30 },
+							},
+						},
+						{
+							_id: "s1",
+							name: "Test Spell",
+							type: "spell",
+							system: {
+								location: { value: "entry1" },
+								level: { value: 1 },
+								traits: { value: [] },
+								heightening: {
+									type: "interval",
+									interval: 2,
+									damage: { value: "1d6" },
+								},
+								overlays: {
+									variant1: {
+										name: "Variant",
+										system: {
+											description: {
+												value: "<p>Should be ignored.</p>",
+											},
+										},
+									},
+								},
+							},
+						},
+					],
+				}),
+			);
+			const spell = creature.spellcasting?.[0]?.daily
+				?.flatMap((d) => d.spells)
+				.find((s) => s.name === "Test Spell");
+			expect(spell?.heightening).toBe(
+				"Heightened (+2) damage increases by 1d6",
+			);
+			expect(spell?.heightening).not.toContain("Should be ignored");
 		});
 	});
 });

apps/web/src/adapters/__tests__/strip-foundry-tags.test.ts

@@ -99,9 +99,15 @@ describe("stripFoundryTags", () => {
 			expect(stripFoundryTags("before<hr />after")).toBe("before\nafter");
 		});
 
-		it("strips strong and em tags", () => {
+		it("preserves strong and em tags", () => {
 			expect(stripFoundryTags("<strong>bold</strong> <em>italic</em>")).toBe(
-				"bold italic",
+				"<strong>bold</strong> <em>italic</em>",
+			);
+		});
+
+		it("preserves list tags", () => {
+			expect(stripFoundryTags("<ul><li>first</li><li>second</li></ul>")).toBe(
+				"<ul><li>first</li><li>second</li></ul>",
 			);
 		});
 

apps/web/src/adapters/bestiary-adapter.ts

@@ -4,6 +4,7 @@ import type {
 	DailySpells,
 	LegendaryBlock,
 	SpellcastingBlock,
+	SpellReference,
 	TraitBlock,
 	TraitListItem,
 	TraitSegment,
@@ -385,7 +386,7 @@ function normalizeSpellcasting(
 		const block: {
 			name: string;
 			headerText: string;
-			atWill?: string[];
+			atWill?: SpellReference[];
 			daily?: DailySpells[];
 			restLong?: DailySpells[];
 		} = {
@@ -396,7 +397,7 @@ function normalizeSpellcasting(
 		const hidden = new Set(sc.hidden ?? []);
 
 		if (sc.will && !hidden.has("will")) {
-			block.atWill = sc.will.map((s) => stripTags(s));
+			block.atWill = sc.will.map((s) => ({ name: stripTags(s) }));
 		}
 
 		if (sc.daily) {
@@ -418,7 +419,7 @@ function parseDailyMap(map: Record<string, string[]>): DailySpells[] {
 		return {
 			uses,
 			each,
-			spells: spells.map((s) => stripTags(s)),
+			spells: spells.map((s) => ({ name: stripTags(s) })),
 		};
 	});
 }

apps/web/src/adapters/bestiary-cache.ts

@@ -3,7 +3,8 @@ import { type IDBPDatabase, openDB } from "idb";
 
 const DB_NAME = "initiative-bestiary";
 const STORE_NAME = "sources";
-const DB_VERSION = 5;
+// v8 (2026-04-10): Attack effects, ability frequency, perception details added to PF2e creatures
+const DB_VERSION = 8;
 
 interface CachedSourceInfo {
 	readonly sourceCode: string;

apps/web/src/adapters/pf2e-bestiary-adapter.ts

@@ -1,7 +1,9 @@
 import type {
 	CreatureId,
+	EquipmentItem,
 	Pf2eCreature,
 	SpellcastingBlock,
+	SpellReference,
 	TraitBlock,
 } from "@initiative/domain";
 import { creatureId } from "@initiative/domain";
@@ -61,6 +63,7 @@ interface MeleeSystem {
 	bonus?: { value: number };
 	damageRolls?: Record<string, { damage: string; damageType: string }>;
 	traits?: { value: string[] };
+	attackEffects?: { value: string[] };
 }
 
 interface ActionSystem {
@@ -69,6 +72,7 @@ interface ActionSystem {
 	actions?: { value: number | null };
 	traits?: { value: string[] };
 	description?: { value: string };
+	frequency?: { max: number; per: string };
 }
 
 interface SpellcastingEntrySystem {
@@ -78,13 +82,106 @@ interface SpellcastingEntrySystem {
 }
 
 interface SpellSystem {
+	slug?: string;
 	location?: {
 		value: string;
 		heightenedLevel?: number;
 		uses?: { max: number; value: number };
 	};
+	level?: { value: number };
+	traits?: { rarity?: string; value: string[]; traditions?: string[] };
+	description?: { value: string };
+	range?: { value: string };
+	target?: { value: string };
+	area?: { type?: string; value?: number; details?: string };
+	duration?: { value: string; sustained?: boolean };
+	time?: { value: string };
+	defense?: {
+		save?: { statistic: string; basic?: boolean };
+		passive?: { statistic: string };
+	};
+	heightening?:
+		| {
+				type: "fixed";
+				levels: Record<string, { text?: string }>;
+		  }
+		| {
+				type: "interval";
+				interval: number;
+				damage?: { value: string };
+		  }
+		| undefined;
+	overlays?: Record<
+		string,
+		{ name?: string; system?: { description?: { value: string } } }
+	>;
+}
+
+interface ConsumableSystem {
 	level?: { value: number };
 	traits?: { value: string[] };
+	description?: { value: string };
+	category?: string;
+	spell?: {
+		name: string;
+		system?: { level?: { value: number } };
+	} | null;
+}
+
+const EQUIPMENT_TYPES = new Set(["weapon", "consumable", "equipment", "armor"]);
+
+/** Items shown in the Equipment section with popovers. */
+function isDetailedEquipment(item: RawFoundryItem): boolean {
+	if (!EQUIPMENT_TYPES.has(item.type)) return false;
+	const sys = item.system;
+	const level = (sys.level as { value: number } | undefined)?.value ?? 0;
+	const traits = (sys.traits as { value: string[] } | undefined)?.value ?? [];
+	// All consumables are tactically relevant (potions, scrolls, poisons, etc.)
+	if (item.type === "consumable") return true;
+	// Magical/invested items
+	if (traits.includes("magical") || traits.includes("invested")) return true;
+	// Special material armor/equipment
+	const material = sys.material as { type: string | null } | undefined;
+	if (material?.type) return true;
+	// Higher-level items
+	if (level > 0) return true;
+	return false;
+}
+
+/** Items shown on the "Items" line as plain names. */
+function isMundaneItem(item: RawFoundryItem): boolean {
+	return EQUIPMENT_TYPES.has(item.type) && !isDetailedEquipment(item);
+}
+
+function normalizeEquipmentItem(item: RawFoundryItem): EquipmentItem {
+	const sys = item.system;
+	const level = (sys.level as { value: number } | undefined)?.value ?? 0;
+	const traits = (sys.traits as { value: string[] } | undefined)?.value;
+	const rawDesc = (sys.description as { value: string } | undefined)?.value;
+	const description = rawDesc
+		? stripFoundryTags(rawDesc) || undefined
+		: undefined;
+	const category = sys.category as string | undefined;
+
+	let spellName: string | undefined;
+	let spellRank: number | undefined;
+	if (item.type === "consumable") {
+		const spell = (sys as unknown as ConsumableSystem).spell;
+		if (spell) {
+			spellName = spell.name;
+			spellRank = spell.system?.level?.value;
+		}
+	}
+
+	return {
+		name: item.name,
+		level,
+		category: category || undefined,
+		traits: traits && traits.length > 0 ? traits : undefined,
+		description,
+		spellName,
+		spellRank,
+	};
 }
 
 const SIZE_MAP: Record<string, string> = {
@@ -247,7 +344,17 @@ function formatSpeed(speed: {
 
 // -- Attack normalization --
 
-function normalizeAttack(item: RawFoundryItem): TraitBlock {
+/** Format an attack effect slug to display text: "grab" → "Grab", "lich-siphon-life" → "Siphon Life". */
+function formatAttackEffect(slug: string, creatureName: string): string {
+	const prefix = `${creatureName.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-")}-`;
+	const stripped = slug.startsWith(prefix) ? slug.slice(prefix.length) : slug;
+	return stripped.split("-").map(capitalize).join(" ");
+}
+
+function normalizeAttack(
+	item: RawFoundryItem,
+	creatureName: string,
+): TraitBlock {
 	const sys = item.system as unknown as MeleeSystem;
 	const bonus = sys.bonus?.value ?? 0;
 	const traits = sys.traits?.value ?? [];
@@ -257,13 +364,18 @@ function normalizeAttack(item: RawFoundryItem): TraitBlock {
 		.join(" plus ");
 	const traitStr =
 		traits.length > 0 ? ` (${traits.map(formatTrait).join(", ")})` : "";
+	const effects = sys.attackEffects?.value ?? [];
+	const effectStr =
+		effects.length > 0
+			? ` plus ${effects.map((e) => formatAttackEffect(e, creatureName)).join(" and ")}`
+			: "";
 	return {
 		name: capitalize(item.name),
 		activity: { number: 1, unit: "action" },
 		segments: [
 			{
 				type: "text",
-				value: `+${bonus}${traitStr}, ${damage}`,
+				value: `+${bonus}${traitStr}, ${damage}${effectStr}`,
 			},
 		],
 	};
@@ -287,15 +399,31 @@ function parseActivity(
 
 // -- Ability normalization --
 
+const FREQUENCY_LINE = /(<strong>)?Frequency(<\/strong>)?\s+[^\n]+\n*/i;
+
+/** Strip the "Frequency once per day" line from ability descriptions when structured frequency data exists. */
+function stripFrequencyLine(text: string): string {
+	return text.replace(FREQUENCY_LINE, "").trimStart();
+}
+
 function normalizeAbility(item: RawFoundryItem): TraitBlock {
 	const sys = item.system as unknown as ActionSystem;
 	const actionType = sys.actionType?.value;
 	const actionCount = sys.actions?.value;
-	const description = stripFoundryTags(sys.description?.value ?? "");
+	let description = stripFoundryTags(sys.description?.value ?? "");
 	const traits = sys.traits?.value ?? [];
 
 	const activity = parseActivity(actionType, actionCount);
 
+	const frequency =
+		sys.frequency?.max != null && sys.frequency.per
+			? `${sys.frequency.max}/${sys.frequency.per}`
+			: undefined;
+
+	if (frequency) {
+		description = stripFrequencyLine(description);
+	}
+
 	const traitStr =
 		traits.length > 0
 			? `(${traits.map((t) => capitalize(formatTrait(t))).join(", ")}) `
@@ -306,28 +434,122 @@ function normalizeAbility(item: RawFoundryItem): TraitBlock {
 		? [{ type: "text", value: text }]
 		: [];
 
-	return { name: item.name, activity, segments };
+	return { name: item.name, activity, frequency, segments };
 }
 
 // -- Spellcasting normalization --
 
-function classifySpell(spell: RawFoundryItem): {
+function formatRange(range: { value: string } | undefined): string | undefined {
-	isCantrip: boolean;
+	if (!range?.value) return undefined;
-	rank: number;
+	return range.value;
-	label: string;
+}
-} {
+
-	const sys = spell.system as unknown as SpellSystem;
+function formatArea(
-	const isCantrip = (sys.traits?.value ?? []).includes("cantrip");
+	area: { type?: string; value?: number; details?: string } | undefined,
-	const rank = sys.location?.heightenedLevel ?? sys.level?.value ?? 0;
+): string | undefined {
-	const uses = sys.location?.uses;
+	if (!area) return undefined;
-	const label =
+	if (area.value && area.type) return `${area.value}-foot ${area.type}`;
-		uses && uses.max > 1 ? `${spell.name} (\u00d7${uses.max})` : spell.name;
+	return area.details ?? undefined;
-	return { isCantrip, rank, label };
+}
+
+function formatDefense(defense: SpellSystem["defense"]): string | undefined {
+	if (!defense) return undefined;
+	if (defense.save) {
+		const stat = capitalize(defense.save.statistic);
+		return defense.save.basic ? `basic ${stat}` : stat;
+	}
+	if (defense.passive) return capitalize(defense.passive.statistic);
+	return undefined;
+}
+
+function formatHeightening(
+	heightening: SpellSystem["heightening"],
+): string | undefined {
+	if (!heightening) return undefined;
+	if (heightening.type === "fixed") {
+		const parts = Object.entries(heightening.levels)
+			.filter(([, lvl]) => lvl.text)
+			.map(
+				([rank, lvl]) =>
+					`Heightened (${rank}) ${stripFoundryTags(lvl.text as string)}`,
+			);
+		return parts.length > 0 ? parts.join("\n") : undefined;
+	}
+	if (heightening.type === "interval") {
+		const dmg = heightening.damage?.value
+			? ` damage increases by ${heightening.damage.value}`
+			: "";
+		return `Heightened (+${heightening.interval})${dmg}`;
+	}
+	return undefined;
+}
+
+function formatOverlays(overlays: SpellSystem["overlays"]): string | undefined {
+	if (!overlays) return undefined;
+	const parts: string[] = [];
+	for (const overlay of Object.values(overlays)) {
+		const desc = overlay.system?.description?.value;
+		if (!desc) continue;
+		const label = overlay.name ? `${overlay.name}: ` : "";
+		parts.push(`${label}${stripFoundryTags(desc)}`);
+	}
+	return parts.length > 0 ? parts.join("\n") : undefined;
+}
+
+/**
+ * Foundry descriptions often include heightening rules inline at the end.
+ * When we extract heightening into a structured field, strip that trailing
+ * text to avoid duplication.
+ */
+const HEIGHTENED_SUFFIX = /\s*Heightened\s*\([^)]*\)[\s\S]*$/;
+
+function normalizeSpell(
+	item: RawFoundryItem,
+	creatureLevel: number,
+): SpellReference {
+	const sys = item.system as unknown as SpellSystem;
+	const usesMax = sys.location?.uses?.max;
+	const isCantrip = sys.traits?.value?.includes("cantrip") ?? false;
+	const rank =
+		sys.location?.heightenedLevel ??
+		(isCantrip ? Math.ceil(creatureLevel / 2) : (sys.level?.value ?? 0));
+	const heightening =
+		formatHeightening(sys.heightening) ?? formatOverlays(sys.overlays);
+
+	let description: string | undefined;
+	if (sys.description?.value) {
+		let text = stripFoundryTags(sys.description.value);
+		// Resolve Foundry Roll formula references to the spell's actual rank.
+		// The parenthesized form (e.g., "(@item.level)d4") is most common.
+		text = text.replaceAll(/\(?@item\.(?:rank|level)\)?/g, String(rank));
+		if (heightening) {
+			text = text.replace(HEIGHTENED_SUFFIX, "").trim();
+		}
+		description = text || undefined;
+	}
+
+	return {
+		name: item.name,
+		slug: sys.slug,
+		rank,
+		description,
+		traits: sys.traits?.value,
+		traditions: sys.traits?.traditions,
+		range: formatRange(sys.range),
+		target: sys.target?.value || undefined,
+		area: formatArea(sys.area),
+		duration: sys.duration?.value || undefined,
+		defense: formatDefense(sys.defense),
+		actionCost: sys.time?.value || undefined,
+		heightening,
+		usesPerDay: usesMax && usesMax > 1 ? usesMax : undefined,
+	};
 }
 
 function normalizeSpellcastingEntry(
 	entry: RawFoundryItem,
 	allSpells: readonly RawFoundryItem[],
+	creatureLevel: number,
 ): SpellcastingBlock {
 	const sys = entry.system as unknown as SpellcastingEntrySystem;
 	const tradition = capitalize(sys.tradition?.value ?? "");
@@ -342,26 +564,31 @@ function normalizeSpellcastingEntry(
 		(s) => (s.system as unknown as SpellSystem).location?.value === entry._id,
 	);
 
-	const byRank = new Map<number, string[]>();
+	const byRank = new Map<number, SpellReference[]>();
-	const cantrips: string[] = [];
+	const cantrips: SpellReference[] = [];
 
 	for (const spell of linkedSpells) {
-		const { isCantrip, rank, label } = classifySpell(spell);
+		const ref = normalizeSpell(spell, creatureLevel);
+		const isCantrip =
+			(spell.system as unknown as SpellSystem).traits?.value?.includes(
+				"cantrip",
+			) ?? false;
 		if (isCantrip) {
-			cantrips.push(spell.name);
+			cantrips.push(ref);
 			continue;
 		}
+		const rank = ref.rank ?? 0;
 		const existing = byRank.get(rank) ?? [];
-		existing.push(label);
+		existing.push(ref);
 		byRank.set(rank, existing);
 	}
 
 	const daily = [...byRank.entries()]
 		.sort(([a], [b]) => b - a)
-		.map(([rank, spellNames]) => ({
+		.map(([rank, spells]) => ({
 			uses: rank,
 			each: true,
-			spells: spellNames,
+			spells,
 		}));
 
 	return {
@@ -374,10 +601,13 @@ function normalizeSpellcastingEntry(
 
 function normalizeSpellcasting(
 	items: readonly RawFoundryItem[],
+	creatureLevel: number,
 ): SpellcastingBlock[] {
 	const entries = items.filter((i) => i.type === "spellcastingEntry");
 	const spells = items.filter((i) => i.type === "spell");
-	return entries.map((entry) => normalizeSpellcastingEntry(entry, spells));
+	return entries.map((entry) =>
+		normalizeSpellcastingEntry(entry, spells, creatureLevel),
+	);
 }
 
 // -- Main normalization --
@@ -487,6 +717,7 @@ export function normalizeFoundryCreature(
 		level: sys.details?.level?.value ?? 0,
 		traits: buildTraits(sys.traits),
 		perception: sys.perception?.mod ?? 0,
+		perceptionDetails: sys.perception?.details || undefined,
 		senses: formatSenses(sys.perception?.senses),
 		languages: formatLanguages(sys.details?.languages),
 		skills: formatSkills(sys.skills),
@@ -504,7 +735,9 @@ export function normalizeFoundryCreature(
 		weaknesses: formatWeaknesses(sys.attributes.weaknesses),
 		speed: formatSpeed(sys.attributes.speed),
 		attacks: orUndefined(
-			items.filter((i) => i.type === "melee").map(normalizeAttack),
+			items
+				.filter((i) => i.type === "melee")
+				.map((i) => normalizeAttack(i, r.name)),
 		),
 		abilitiesTop: orUndefined(actionsByCategory(items, "interaction")),
 		abilitiesMid: orUndefined(
@@ -516,7 +749,17 @@ export function normalizeFoundryCreature(
 			),
 		),
 		abilitiesBot: orUndefined(actionsByCategory(items, "offensive")),
-		spellcasting: orUndefined(normalizeSpellcasting(items)),
+		spellcasting: orUndefined(
+			normalizeSpellcasting(items, sys.details?.level?.value ?? 0),
+		),
+		items:
+			items
+				.filter(isMundaneItem)
+				.map((i) => i.name)
+				.join(", ") || undefined,
+		equipment: orUndefined(
+			items.filter(isDetailedEquipment).map(normalizeEquipmentItem),
+		),
 	};
 }
 

apps/web/src/adapters/pf2e-bestiary-index-adapter.ts

@@ -69,6 +69,18 @@ export function getCreaturePathsForSource(sourceCode: string): string[] {
 	return compact.creatures.filter((c) => c.s === sourceCode).map((c) => c.f);
 }
 
+export function getCreatureNamesByPaths(paths: string[]): Map<string, string> {
+	const compact = rawIndex as unknown as CompactIndex;
+	const pathSet = new Set(paths);
+	const result = new Map<string, string>();
+	for (const c of compact.creatures) {
+		if (pathSet.has(c.f)) {
+			result.set(c.f, c.n);
+		}
+	}
+	return result;
+}
+
 export function getPf2eSourceDisplayName(sourceCode: string): string {
 	const index = loadPf2eBestiaryIndex();
 	return index.sources[sourceCode] ?? sourceCode;

apps/web/src/adapters/ports.ts

@@ -57,4 +57,5 @@ export interface Pf2eBestiaryIndexPort {
 	getDefaultFetchUrl(sourceCode: string, baseUrl?: string): string;
 	getSourceDisplayName(sourceCode: string): string;
 	getCreaturePathsForSource(sourceCode: string): string[];
+	getCreatureNamesByPaths(paths: string[]): Map<string, string>;
 }

apps/web/src/adapters/production-adapters.ts

@@ -48,5 +48,6 @@ export const productionAdapters: Adapters = {
 		getDefaultFetchUrl: pf2eBestiaryIndex.getDefaultPf2eFetchUrl,
 		getSourceDisplayName: pf2eBestiaryIndex.getPf2eSourceDisplayName,
 		getCreaturePathsForSource: pf2eBestiaryIndex.getCreaturePathsForSource,
+		getCreatureNamesByPaths: pf2eBestiaryIndex.getCreatureNamesByPaths,
 	},
 };

apps/web/src/adapters/strip-foundry-tags.ts

@@ -8,7 +8,13 @@
 
 function formatDamage(params: string): string {
 	// "3d6+10[fire]" → "3d6+10 fire"
-	return params.replaceAll(/\[([^\]]*)\]/g, " $1").trim();
+	// "d4[persistent,fire]" → "d4 persistent fire"
+	return params
+		.replaceAll(
+			/\[([^\]]*)\]/g,
+			(_, type: string) => ` ${type.replaceAll(",", " ")}`,
+		)
+		.trim();
 }
 
 function formatCheck(params: string): string {
@@ -80,11 +86,11 @@ export function stripFoundryTags(html: string): string {
 	// Strip action-glyph spans (content is a number the renderer handles)
 	result = result.replaceAll(/<span class="action-glyph">[^<]*<\/span>/gi, "");
 
-	// Strip HTML tags
+	// Strip HTML tags (preserve <strong> for UI rendering)
 	result = result.replaceAll(/<br\s*\/?>/gi, "\n");
 	result = result.replaceAll(/<hr\s*\/?>/gi, "\n");
 	result = result.replaceAll(/<\/p>\s*<p[^>]*>/gi, "\n");
-	result = result.replaceAll(/<[^>]+>/g, "");
+	result = result.replaceAll(/<(?!\/?(?:strong|em|ul|ol|li)\b)[^>]+>/g, "");
 
 	// Decode common HTML entities
 	result = result.replaceAll("&amp;", "&");
@@ -92,6 +98,11 @@ export function stripFoundryTags(html: string): string {
 	result = result.replaceAll("&gt;", ">");
 	result = result.replaceAll("&quot;", '"');
 
+	// Collapse whitespace around list tags so they don't create extra
+	// line breaks when rendered with whitespace-pre-line
+	result = result.replaceAll(/\s*(<\/?(?:ul|ol)>)\s*/g, "$1");
+	result = result.replaceAll(/\s*(<\/?li>)\s*/g, "$1");
+
 	// Collapse whitespace
 	result = result.replaceAll(/[ \t]+/g, " ");
 	result = result.replaceAll(/\n\s*\n/g, "\n");

apps/web/src/components/__tests__/condition-picker.test.tsx

@@ -5,43 +5,73 @@ import {
 	type ConditionEntry,
 	type ConditionId,
 	getConditionsForEdition,
+	type PersistentDamageEntry,
+	type PersistentDamageType,
+	type RulesEdition,
 } from "@initiative/domain";
 import { cleanup, render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
-import { createRef, type RefObject } from "react";
+import { createRef, type ReactNode, type RefObject, useEffect } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { RulesEditionProvider } from "../../contexts/index.js";
+import { useRulesEditionContext } from "../../contexts/rules-edition-context.js";
 import { ConditionPicker } from "../condition-picker";
 
 afterEach(cleanup);
 
+function EditionSetter({
+	edition,
+	children,
+}: {
+	edition: RulesEdition;
+	children: ReactNode;
+}) {
+	const { setEdition } = useRulesEditionContext();
+	useEffect(() => {
+		setEdition(edition);
+	}, [edition, setEdition]);
+	return <>{children}</>;
+}
+
 function renderPicker(
 	overrides: Partial<{
 		activeConditions: readonly ConditionEntry[];
+		activePersistentDamage: readonly PersistentDamageEntry[];
 		onToggle: (conditionId: ConditionId) => void;
 		onSetValue: (conditionId: ConditionId, value: number) => void;
+		onAddPersistentDamage: (
+			damageType: PersistentDamageType,
+			formula: string,
+		) => void;
 		onClose: () => void;
+		edition: RulesEdition;
 	}> = {},
 ) {
 	const onToggle = overrides.onToggle ?? vi.fn();
 	const onSetValue = overrides.onSetValue ?? vi.fn();
+	const onAddPersistentDamage = overrides.onAddPersistentDamage ?? vi.fn();
 	const onClose = overrides.onClose ?? vi.fn();
+	const edition = overrides.edition ?? "5.5e";
 	const anchorRef = createRef<HTMLElement>() as RefObject<HTMLElement>;
 	const anchor = document.createElement("div");
 	document.body.appendChild(anchor);
 	(anchorRef as { current: HTMLElement }).current = anchor;
 	const result = render(
 		<RulesEditionProvider>
-			<ConditionPicker
+			<EditionSetter edition={edition}>
-				anchorRef={anchorRef}
+				<ConditionPicker
-				activeConditions={overrides.activeConditions ?? []}
+					anchorRef={anchorRef}
-				onToggle={onToggle}
+					activeConditions={overrides.activeConditions ?? []}
-				onSetValue={onSetValue}
+					activePersistentDamage={overrides.activePersistentDamage}
-				onClose={onClose}
+					onToggle={onToggle}
-			/>
+					onSetValue={onSetValue}
+					onAddPersistentDamage={onAddPersistentDamage}
+					onClose={onClose}
+				/>
+			</EditionSetter>
 		</RulesEditionProvider>,
 	);
-	return { ...result, onToggle, onSetValue, onClose };
+	return { ...result, onToggle, onSetValue, onAddPersistentDamage, onClose };
 }
 
 describe("ConditionPicker", () => {
@@ -77,4 +107,111 @@ describe("ConditionPicker", () => {
 		const label = screen.getByText("Charmed");
 		expect(label.className).toContain("text-foreground");
 	});
+
+	describe("Valued conditions (PF2e)", () => {
+		it("clicking a valued condition opens the counter editor", async () => {
+			const user = userEvent.setup();
+			renderPicker({ edition: "pf2e" });
+			await user.click(screen.getByText("Frightened"));
+			// Counter editor shows value badge and [-]/[+] buttons
+			expect(screen.getByText("1")).toBeInTheDocument();
+			expect(
+				screen
+					.getAllByRole("button")
+					.some((b) => b.querySelector(".lucide-minus")),
+			).toBe(true);
+		});
+
+		it("increment and decrement adjust the counter value", async () => {
+			const user = userEvent.setup();
+			renderPicker({ edition: "pf2e" });
+			await user.click(screen.getByText("Frightened"));
+			// Value starts at 1; click [+] to go to 2
+			const plusButtons = screen.getAllByRole("button");
+			const plusButton = plusButtons.find((b) =>
+				b.querySelector(".lucide-plus"),
+			);
+			if (!plusButton) throw new Error("Plus button not found");
+			await user.click(plusButton);
+			expect(screen.getByText("2")).toBeInTheDocument();
+			// Click [-] to go back to 1
+			const minusButton = plusButtons.find((b) =>
+				b.querySelector(".lucide-minus"),
+			);
+			if (!minusButton) throw new Error("Minus button not found");
+			await user.click(minusButton);
+			expect(screen.getByText("1")).toBeInTheDocument();
+		});
+
+		it("confirm button calls onSetValue with condition and value", async () => {
+			const user = userEvent.setup();
+			const { onSetValue } = renderPicker({ edition: "pf2e" });
+			await user.click(screen.getByText("Frightened"));
+			// Increment to 2, then confirm
+			const plusButton = screen
+				.getAllByRole("button")
+				.find((b) => b.querySelector(".lucide-plus"));
+			if (!plusButton) throw new Error("Plus button not found");
+			await user.click(plusButton);
+			const checkButton = screen
+				.getAllByRole("button")
+				.find((b) => b.querySelector(".lucide-check"));
+			if (!checkButton) throw new Error("Check button not found");
+			await user.click(checkButton);
+			expect(onSetValue).toHaveBeenCalledWith("frightened", 2);
+		});
+
+		it("shows active value badge for existing valued condition", () => {
+			renderPicker({
+				edition: "pf2e",
+				activeConditions: [{ id: "frightened", value: 3 }],
+			});
+			expect(screen.getByText("3")).toBeInTheDocument();
+		});
+
+		it("pre-fills counter with existing value when editing", async () => {
+			const user = userEvent.setup();
+			renderPicker({
+				edition: "pf2e",
+				activeConditions: [{ id: "frightened", value: 3 }],
+			});
+			await user.click(screen.getByText("Frightened"));
+			expect(screen.getByText("3")).toBeInTheDocument();
+		});
+
+		it("disables increment at maxValue", async () => {
+			const user = userEvent.setup();
+			renderPicker({
+				edition: "pf2e",
+				activeConditions: [{ id: "doomed", value: 3 }],
+			});
+			// Doomed has maxValue: 3, click to edit
+			await user.click(screen.getByText("Doomed"));
+			const plusButton = screen
+				.getAllByRole("button")
+				.find((b) => b.querySelector(".lucide-plus"));
+			expect(plusButton).toBeDisabled();
+		});
+	});
+
+	describe("Persistent Damage (PF2e)", () => {
+		it("shows 'Persistent Damage' entry when edition is pf2e", () => {
+			renderPicker({ edition: "pf2e" });
+			expect(screen.getByText("Persistent Damage")).toBeInTheDocument();
+		});
+
+		it("clicking 'Persistent Damage' opens sub-picker", async () => {
+			const user = userEvent.setup();
+			renderPicker({ edition: "pf2e" });
+			await user.click(screen.getByText("Persistent Damage"));
+			expect(screen.getByPlaceholderText("2d6")).toBeInTheDocument();
+		});
+	});
+
+	describe("Persistent Damage (D&D)", () => {
+		it("hides 'Persistent Damage' entry when edition is D&D", () => {
+			renderPicker({ edition: "5.5e" });
+			expect(screen.queryByText("Persistent Damage")).not.toBeInTheDocument();
+		});
+	});
 });

apps/web/src/components/__tests__/equipment-detail-popover.test.tsx

@@ -0,0 +1,107 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom/vitest";
+
+import type { EquipmentItem } from "@initiative/domain";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { EquipmentDetailPopover } from "../equipment-detail-popover.js";
+
+afterEach(cleanup);
+
+const POISON: EquipmentItem = {
+	name: "Giant Wasp Venom",
+	level: 7,
+	category: "poison",
+	traits: ["consumable", "poison", "injury"],
+	description: "A deadly poison extracted from giant wasps.",
+};
+
+const SCROLL: EquipmentItem = {
+	name: "Scroll of Teleport",
+	level: 11,
+	category: "scroll",
+	traits: ["consumable", "magical", "scroll"],
+	description: "A scroll containing Teleport.",
+	spellName: "Teleport",
+	spellRank: 6,
+};
+
+const ANCHOR: DOMRect = new DOMRect(100, 100, 50, 20);
+const SCROLL_SPELL_REGEX = /Teleport \(Rank 6\)/;
+const DIALOG_LABEL_REGEX = /Equipment details: Giant Wasp Venom/;
+
+beforeEach(() => {
+	Object.defineProperty(globalThis, "matchMedia", {
+		writable: true,
+		configurable: true,
+		value: vi.fn().mockImplementation(() => ({
+			matches: true,
+			media: "(min-width: 1024px)",
+			onchange: null,
+			addEventListener: vi.fn(),
+			removeEventListener: vi.fn(),
+			addListener: vi.fn(),
+			removeListener: vi.fn(),
+			dispatchEvent: vi.fn(),
+		})),
+	});
+});
+
+describe("EquipmentDetailPopover", () => {
+	it("renders item name, level, traits, and description", () => {
+		render(
+			<EquipmentDetailPopover
+				item={POISON}
+				anchorRect={ANCHOR}
+				onClose={() => {}}
+			/>,
+		);
+		expect(screen.getByText("Giant Wasp Venom")).toBeInTheDocument();
+		expect(screen.getByText("7")).toBeInTheDocument();
+		expect(screen.getByText("consumable")).toBeInTheDocument();
+		expect(screen.getByText("poison")).toBeInTheDocument();
+		expect(screen.getByText("injury")).toBeInTheDocument();
+		expect(
+			screen.getByText("A deadly poison extracted from giant wasps."),
+		).toBeInTheDocument();
+	});
+
+	it("renders scroll/wand spell info", () => {
+		render(
+			<EquipmentDetailPopover
+				item={SCROLL}
+				anchorRect={ANCHOR}
+				onClose={() => {}}
+			/>,
+		);
+		expect(screen.getByText(SCROLL_SPELL_REGEX)).toBeInTheDocument();
+	});
+
+	it("calls onClose when Escape is pressed", () => {
+		const onClose = vi.fn();
+		render(
+			<EquipmentDetailPopover
+				item={POISON}
+				anchorRect={ANCHOR}
+				onClose={onClose}
+			/>,
+		);
+		fireEvent.keyDown(document, { key: "Escape" });
+		expect(onClose).toHaveBeenCalledTimes(1);
+	});
+
+	it("uses the dialog role with the item name as label", () => {
+		render(
+			<EquipmentDetailPopover
+				item={POISON}
+				anchorRect={ANCHOR}
+				onClose={() => {}}
+			/>,
+		);
+		expect(
+			screen.getByRole("dialog", {
+				name: DIALOG_LABEL_REGEX,
+			}),
+		).toBeInTheDocument();
+	});
+});

apps/web/src/components/__tests__/persistent-damage-picker.test.tsx

@@ -0,0 +1,76 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom/vitest";
+
+import { cleanup, render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { PersistentDamagePicker } from "../persistent-damage-picker.js";
+
+afterEach(cleanup);
+
+function renderPicker(
+	overrides: Partial<{
+		activeEntries: { type: string; formula: string }[];
+		onAdd: (damageType: string, formula: string) => void;
+		onClose: () => void;
+	}> = {},
+) {
+	const onAdd = overrides.onAdd ?? vi.fn();
+	const onClose = overrides.onClose ?? vi.fn();
+	const result = render(
+		<PersistentDamagePicker
+			activeEntries={
+				(overrides.activeEntries as Parameters<
+					typeof PersistentDamagePicker
+				>[0]["activeEntries"]) ?? undefined
+			}
+			onAdd={onAdd as Parameters<typeof PersistentDamagePicker>[0]["onAdd"]}
+			onClose={onClose}
+		/>,
+	);
+	return { ...result, onAdd, onClose };
+}
+
+describe("PersistentDamagePicker", () => {
+	it("renders damage type dropdown and formula input", () => {
+		renderPicker();
+		expect(screen.getByRole("combobox")).toBeInTheDocument();
+		expect(screen.getByPlaceholderText("2d6")).toBeInTheDocument();
+	});
+
+	it("confirm button is disabled when formula is empty", () => {
+		renderPicker();
+		expect(
+			screen.getByRole("button", { name: "Add persistent damage" }),
+		).toBeDisabled();
+	});
+
+	it("submitting calls onAdd with selected type and formula", async () => {
+		const user = userEvent.setup();
+		const { onAdd } = renderPicker();
+		await user.type(screen.getByPlaceholderText("2d6"), "3d6");
+		await user.click(
+			screen.getByRole("button", { name: "Add persistent damage" }),
+		);
+		expect(onAdd).toHaveBeenCalledWith("fire", "3d6");
+	});
+
+	it("Enter in formula input confirms", async () => {
+		const user = userEvent.setup();
+		const { onAdd } = renderPicker();
+		await user.type(screen.getByPlaceholderText("2d6"), "2d6{Enter}");
+		expect(onAdd).toHaveBeenCalledWith("fire", "2d6");
+	});
+
+	it("pre-fills formula for existing active entry", async () => {
+		const user = userEvent.setup();
+		renderPicker({
+			activeEntries: [{ type: "fire", formula: "2d6" }],
+		});
+		expect(screen.getByPlaceholderText("2d6")).toHaveValue("2d6");
+
+		// Change type to one without active entry
+		await user.selectOptions(screen.getByRole("combobox"), "bleed");
+		expect(screen.getByPlaceholderText("2d6")).toHaveValue("");
+	});
+});

apps/web/src/components/__tests__/persistent-damage-tags.test.tsx

@@ -0,0 +1,66 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom/vitest";
+
+import type {
+	PersistentDamageEntry,
+	PersistentDamageType,
+} 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 { PersistentDamageTags } from "../persistent-damage-tags.js";
+
+afterEach(cleanup);
+
+function renderTags(
+	entries: readonly PersistentDamageEntry[] | undefined,
+	onRemove = vi.fn(),
+) {
+	const result = render(
+		<PersistentDamageTags entries={entries} onRemove={onRemove} />,
+	);
+	return { ...result, onRemove };
+}
+
+describe("PersistentDamageTags", () => {
+	it("renders nothing when entries undefined", () => {
+		const { container } = renderTags(undefined);
+		expect(container.innerHTML).toBe("");
+	});
+
+	it("renders nothing when entries is empty array", () => {
+		const { container } = renderTags([]);
+		expect(container.innerHTML).toBe("");
+	});
+
+	it("renders tag per entry with icon and formula text", () => {
+		renderTags([
+			{ type: "fire", formula: "2d6" },
+			{ type: "bleed", formula: "1d4" },
+		]);
+		expect(screen.getByText("2d6")).toBeInTheDocument();
+		expect(screen.getByText("1d4")).toBeInTheDocument();
+	});
+
+	it("click calls onRemove with correct damage type", async () => {
+		const user = userEvent.setup();
+		const { onRemove } = renderTags([{ type: "fire", formula: "2d6" }]);
+		await user.click(
+			screen.getByRole("button", {
+				name: "Remove persistent Fire damage",
+			}),
+		);
+		expect(onRemove).toHaveBeenCalledWith(
+			"fire" satisfies PersistentDamageType,
+		);
+	});
+
+	it("tooltip shows full description", () => {
+		renderTags([{ type: "fire", formula: "2d6" }]);
+		expect(
+			screen.getByRole("button", {
+				name: "Remove persistent Fire damage",
+			}),
+		).toBeInTheDocument();
+	});
+});

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

@@ -4,11 +4,14 @@ import "@testing-library/jest-dom/vitest";
 import type { Pf2eCreature } from "@initiative/domain";
 import { creatureId } from "@initiative/domain";
 import { cleanup, render, screen } from "@testing-library/react";
-import { afterEach, describe, expect, it } from "vitest";
+import userEvent from "@testing-library/user-event";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { Pf2eStatBlock } from "../pf2e-stat-block.js";
 
 afterEach(cleanup);
 
+const USES_PER_DAY_REGEX = /×3/;
+const HEAL_DESCRIPTION_REGEX = /channel positive energy/;
 const PERCEPTION_SENSES_REGEX = /\+2.*Darkvision/;
 const SKILLS_REGEX = /Acrobatics \+5.*Stealth \+5/;
 const SAVE_CONDITIONAL_REGEX = /\+12.*\+1 status to all saves vs\. magic/;
@@ -22,6 +25,13 @@ const ABILITY_MID_NAME_REGEX = /Goblin Scuttle/;
 const ABILITY_MID_DESC_REGEX = /The goblin Steps\./;
 const CANTRIPS_REGEX = /Cantrips:/;
 const AC_REGEX = /16/;
+const RK_DC_13_REGEX = /DC 13/;
+const RK_DC_15_REGEX = /DC 15/;
+const RK_DC_25_REGEX = /DC 25/;
+const RK_HUMANOID_SOCIETY_REGEX = /Humanoid \(Society\)/;
+const RK_UNDEAD_RELIGION_REGEX = /Undead \(Religion\)/;
+const RK_BEAST_SKILLS_REGEX = /Beast \(Arcana\/Nature\)/;
+const SCROLL_NAME_REGEX = /Scroll of Teleport/;
 
 const GOBLIN_WARRIOR: Pf2eCreature = {
 	system: "pf2e",
@@ -90,9 +100,13 @@ const NAUNET: Pf2eCreature = {
 			name: "Divine Innate Spells",
 			headerText: "DC 25, attack +17",
 			daily: [
-				{ uses: 4, each: true, spells: ["Unfettered Movement (Constant)"] },
+				{
+					uses: 4,
+					each: true,
+					spells: [{ name: "Unfettered Movement (Constant)" }],
+				},
 			],
-			atWill: ["Detect Magic"],
+			atWill: [{ name: "Detect Magic" }],
 		},
 	],
 };
@@ -147,6 +161,53 @@ describe("Pf2eStatBlock", () => {
 		});
 	});
 
+	describe("recall knowledge", () => {
+		it("renders Recall Knowledge line for a creature with a recognized type trait", () => {
+			renderStatBlock(GOBLIN_WARRIOR);
+			expect(screen.getByText("Recall Knowledge")).toBeInTheDocument();
+			expect(screen.getByText(RK_DC_13_REGEX)).toBeInTheDocument();
+			expect(screen.getByText(RK_HUMANOID_SOCIETY_REGEX)).toBeInTheDocument();
+		});
+
+		it("adjusts DC for uncommon rarity", () => {
+			const uncommonCreature: Pf2eCreature = {
+				...GOBLIN_WARRIOR,
+				traits: ["uncommon", "small", "humanoid"],
+			};
+			renderStatBlock(uncommonCreature);
+			expect(screen.getByText(RK_DC_15_REGEX)).toBeInTheDocument();
+		});
+
+		it("adjusts DC for rare rarity", () => {
+			const rareCreature: Pf2eCreature = {
+				...GOBLIN_WARRIOR,
+				level: 5,
+				traits: ["rare", "medium", "undead"],
+			};
+			renderStatBlock(rareCreature);
+			expect(screen.getByText(RK_DC_25_REGEX)).toBeInTheDocument();
+			expect(screen.getByText(RK_UNDEAD_RELIGION_REGEX)).toBeInTheDocument();
+		});
+
+		it("shows multiple skills for types with dual skill mapping", () => {
+			const beastCreature: Pf2eCreature = {
+				...GOBLIN_WARRIOR,
+				traits: ["small", "beast"],
+			};
+			renderStatBlock(beastCreature);
+			expect(screen.getByText(RK_BEAST_SKILLS_REGEX)).toBeInTheDocument();
+		});
+
+		it("omits Recall Knowledge when no type trait is recognized", () => {
+			const noTypeCreature: Pf2eCreature = {
+				...GOBLIN_WARRIOR,
+				traits: ["small", "goblin"],
+			};
+			renderStatBlock(noTypeCreature);
+			expect(screen.queryByText("Recall Knowledge")).not.toBeInTheDocument();
+		});
+	});
+
 	describe("perception and senses", () => {
 		it("renders perception modifier and senses", () => {
 			renderStatBlock(GOBLIN_WARRIOR);
@@ -277,4 +338,160 @@ describe("Pf2eStatBlock", () => {
 			expect(screen.queryByText(CANTRIPS_REGEX)).not.toBeInTheDocument();
 		});
 	});
+
+	describe("equipment section", () => {
+		const CREATURE_WITH_EQUIPMENT: Pf2eCreature = {
+			...GOBLIN_WARRIOR,
+			id: creatureId("test:equipped"),
+			name: "Equipped NPC",
+			items: "longsword, leather armor",
+			equipment: [
+				{
+					name: "Giant Wasp Venom",
+					level: 7,
+					category: "poison",
+					traits: ["consumable", "poison"],
+					description: "A deadly poison extracted from giant wasps.",
+				},
+				{
+					name: "Scroll of Teleport",
+					level: 11,
+					category: "scroll",
+					traits: ["consumable", "magical", "scroll"],
+					description: "A scroll containing Teleport.",
+					spellName: "Teleport",
+					spellRank: 6,
+				},
+				{
+					name: "Plain Talisman",
+					level: 1,
+					traits: ["magical"],
+				},
+			],
+		};
+
+		it("renders Equipment section with item names", () => {
+			renderStatBlock(CREATURE_WITH_EQUIPMENT);
+			expect(
+				screen.getByRole("heading", { name: "Equipment" }),
+			).toBeInTheDocument();
+			expect(screen.getByText("Giant Wasp Venom")).toBeInTheDocument();
+		});
+
+		it("renders scroll name as-is from Foundry data", () => {
+			renderStatBlock(CREATURE_WITH_EQUIPMENT);
+			expect(screen.getByText(SCROLL_NAME_REGEX)).toBeInTheDocument();
+		});
+
+		it("does not render Equipment section when creature has no equipment", () => {
+			renderStatBlock(GOBLIN_WARRIOR);
+			expect(
+				screen.queryByRole("heading", { name: "Equipment" }),
+			).not.toBeInTheDocument();
+		});
+
+		it("renders equipment items with descriptions as clickable buttons", () => {
+			renderStatBlock(CREATURE_WITH_EQUIPMENT);
+			expect(
+				screen.getByRole("button", { name: "Giant Wasp Venom" }),
+			).toBeInTheDocument();
+		});
+
+		it("renders equipment items without descriptions as plain text", () => {
+			renderStatBlock(CREATURE_WITH_EQUIPMENT);
+			expect(
+				screen.queryByRole("button", { name: "Plain Talisman" }),
+			).not.toBeInTheDocument();
+			expect(screen.getByText("Plain Talisman")).toBeInTheDocument();
+		});
+
+		it("renders Items line with mundane item names", () => {
+			renderStatBlock(CREATURE_WITH_EQUIPMENT);
+			expect(screen.getByText("Items")).toBeInTheDocument();
+			expect(screen.getByText("longsword, leather armor")).toBeInTheDocument();
+		});
+	});
+
+	describe("clickable spells", () => {
+		const SPELLCASTER: Pf2eCreature = {
+			...NAUNET,
+			id: creatureId("test:spellcaster"),
+			name: "Spellcaster",
+			spellcasting: [
+				{
+					name: "Divine Innate Spells",
+					headerText: "DC 30, attack +20",
+					atWill: [{ name: "Detect Magic", rank: 1 }],
+					daily: [
+						{
+							uses: 4,
+							each: true,
+							spells: [
+								{
+									name: "Heal",
+									description: "You channel positive energy to heal.",
+									rank: 4,
+									usesPerDay: 3,
+								},
+								{ name: "Restoration", rank: 4 },
+							],
+						},
+					],
+				},
+			],
+		};
+
+		beforeEach(() => {
+			Object.defineProperty(globalThis, "matchMedia", {
+				writable: true,
+				configurable: true,
+				value: vi.fn().mockImplementation(() => ({
+					matches: true,
+					media: "(min-width: 1024px)",
+					onchange: null,
+					addEventListener: vi.fn(),
+					removeEventListener: vi.fn(),
+					addListener: vi.fn(),
+					removeListener: vi.fn(),
+					dispatchEvent: vi.fn(),
+				})),
+			});
+		});
+
+		it("renders a spell with a description as a clickable button", () => {
+			renderStatBlock(SPELLCASTER);
+			expect(screen.getByRole("button", { name: "Heal" })).toBeInTheDocument();
+		});
+
+		it("renders a spell without description as plain text (not a button)", () => {
+			renderStatBlock(SPELLCASTER);
+			expect(
+				screen.queryByRole("button", { name: "Restoration" }),
+			).not.toBeInTheDocument();
+			expect(screen.getByText("Restoration")).toBeInTheDocument();
+		});
+
+		it("renders usesPerDay as plain text alongside the spell button", () => {
+			renderStatBlock(SPELLCASTER);
+			expect(screen.getByText(USES_PER_DAY_REGEX)).toBeInTheDocument();
+		});
+
+		it("opens the spell popover when a spell button is clicked", async () => {
+			const user = userEvent.setup();
+			renderStatBlock(SPELLCASTER);
+			await user.click(screen.getByRole("button", { name: "Heal" }));
+			expect(screen.getByText(HEAL_DESCRIPTION_REGEX)).toBeInTheDocument();
+		});
+
+		it("closes the popover when Escape is pressed", async () => {
+			const user = userEvent.setup();
+			renderStatBlock(SPELLCASTER);
+			await user.click(screen.getByRole("button", { name: "Heal" }));
+			expect(screen.getByText(HEAL_DESCRIPTION_REGEX)).toBeInTheDocument();
+			await user.keyboard("{Escape}");
+			expect(
+				screen.queryByText(HEAL_DESCRIPTION_REGEX),
+			).not.toBeInTheDocument();
+		});
+	});
 });

apps/web/src/components/__tests__/source-fetch-prompt.test.tsx

@@ -65,7 +65,7 @@ describe("SourceFetchPrompt", () => {
 	});
 
 	it("Load calls fetchAndCacheSource and onSourceLoaded on success", async () => {
-		mockFetchAndCacheSource.mockResolvedValueOnce(undefined);
+		mockFetchAndCacheSource.mockResolvedValueOnce({ skippedNames: [] });
 		const user = userEvent.setup();
 		const { onSourceLoaded } = renderPrompt();
 

apps/web/src/components/__tests__/source-manager.test.tsx

@@ -28,7 +28,7 @@ beforeAll(() => {
 
 afterEach(cleanup);
 
-function renderWithSources(sources: CachedSourceInfo[] = []) {
+function renderWithSources(sources: CachedSourceInfo[] = []): void {
 	const adapters = createTestAdapters();
 	// Wire getCachedSources to return the provided sources initially,
 	// then empty after clear operations
@@ -57,14 +57,14 @@ function renderWithSources(sources: CachedSourceInfo[] = []) {
 
 describe("SourceManager", () => {
 	it("shows 'No cached sources' empty state when no sources", async () => {
-		void renderWithSources([]);
+		renderWithSources([]);
 		await waitFor(() => {
 			expect(screen.getByText("No cached sources")).toBeInTheDocument();
 		});
 	});
 
 	it("lists cached sources with display name and creature count", async () => {
-		void renderWithSources([
+		renderWithSources([
 			{
 				sourceCode: "mm",
 				displayName: "Monster Manual",
@@ -88,7 +88,7 @@ describe("SourceManager", () => {
 
 	it("Clear All button removes all sources", async () => {
 		const user = userEvent.setup();
-		void renderWithSources([
+		renderWithSources([
 			{
 				sourceCode: "mm",
 				displayName: "Monster Manual",
@@ -110,7 +110,7 @@ describe("SourceManager", () => {
 
 	it("individual source delete button removes that source", async () => {
 		const user = userEvent.setup();
-		void renderWithSources([
+		renderWithSources([
 			{
 				sourceCode: "mm",
 				displayName: "Monster Manual",

apps/web/src/components/__tests__/spell-detail-popover.test.tsx

@@ -0,0 +1,158 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom/vitest";
+
+import type { SpellReference } from "@initiative/domain";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { SpellDetailPopover } from "../spell-detail-popover.js";
+
+afterEach(cleanup);
+
+const FIREBALL: SpellReference = {
+	name: "Fireball",
+	slug: "fireball",
+	rank: 3,
+	description: "A spark leaps from your fingertip to the target.",
+	traits: ["fire", "manipulate"],
+	traditions: ["arcane", "primal"],
+	range: "500 feet",
+	area: "20-foot burst",
+	defense: "basic Reflex",
+	actionCost: "2",
+	heightening: "Heightened (+1) The damage increases by 2d6.",
+};
+
+const ANCHOR: DOMRect = new DOMRect(100, 100, 50, 20);
+
+const SPARK_LEAPS_REGEX = /spark leaps/;
+const HEIGHTENED_REGEX = /Heightened.*2d6/;
+const RANGE_REGEX = /500 feet/;
+const AREA_REGEX = /20-foot burst/;
+const DEFENSE_REGEX = /basic Reflex/;
+const NO_DESCRIPTION_REGEX = /No description available/;
+const DIALOG_LABEL_REGEX = /Spell details: Fireball/;
+
+beforeEach(() => {
+	// Force desktop variant in jsdom
+	Object.defineProperty(globalThis, "matchMedia", {
+		writable: true,
+		configurable: true,
+		value: vi.fn().mockImplementation(() => ({
+			matches: true,
+			media: "(min-width: 1024px)",
+			onchange: null,
+			addEventListener: vi.fn(),
+			removeEventListener: vi.fn(),
+			addListener: vi.fn(),
+			removeListener: vi.fn(),
+			dispatchEvent: vi.fn(),
+		})),
+	});
+});
+
+describe("SpellDetailPopover", () => {
+	it("renders spell name, rank, traits, and description", () => {
+		render(
+			<SpellDetailPopover
+				spell={FIREBALL}
+				anchorRect={ANCHOR}
+				onClose={() => {}}
+			/>,
+		);
+		expect(screen.getByText("Fireball")).toBeInTheDocument();
+		expect(screen.getByText("3rd")).toBeInTheDocument();
+		expect(screen.getByText("fire")).toBeInTheDocument();
+		expect(screen.getByText("manipulate")).toBeInTheDocument();
+		expect(screen.getByText(SPARK_LEAPS_REGEX)).toBeInTheDocument();
+	});
+
+	it("renders heightening rules when present", () => {
+		render(
+			<SpellDetailPopover
+				spell={FIREBALL}
+				anchorRect={ANCHOR}
+				onClose={() => {}}
+			/>,
+		);
+		expect(screen.getByText(HEIGHTENED_REGEX)).toBeInTheDocument();
+	});
+
+	it("renders range, area, and defense", () => {
+		render(
+			<SpellDetailPopover
+				spell={FIREBALL}
+				anchorRect={ANCHOR}
+				onClose={() => {}}
+			/>,
+		);
+		expect(screen.getByText(RANGE_REGEX)).toBeInTheDocument();
+		expect(screen.getByText(AREA_REGEX)).toBeInTheDocument();
+		expect(screen.getByText(DEFENSE_REGEX)).toBeInTheDocument();
+	});
+
+	it("calls onClose when Escape is pressed", () => {
+		const onClose = vi.fn();
+		render(
+			<SpellDetailPopover
+				spell={FIREBALL}
+				anchorRect={ANCHOR}
+				onClose={onClose}
+			/>,
+		);
+		fireEvent.keyDown(document, { key: "Escape" });
+		expect(onClose).toHaveBeenCalledTimes(1);
+	});
+
+	it("shows placeholder when description is missing", () => {
+		const spell: SpellReference = { name: "Mystery", rank: 1 };
+		render(
+			<SpellDetailPopover
+				spell={spell}
+				anchorRect={ANCHOR}
+				onClose={() => {}}
+			/>,
+		);
+		expect(screen.getByText(NO_DESCRIPTION_REGEX)).toBeInTheDocument();
+	});
+
+	it("renders the action cost as an icon when it is a numeric action count", () => {
+		render(
+			<SpellDetailPopover
+				spell={FIREBALL}
+				anchorRect={ANCHOR}
+				onClose={() => {}}
+			/>,
+		);
+		// Action cost "2" renders as an SVG ActivityIcon (portaled to body)
+		const dialog = screen.getByRole("dialog");
+		expect(dialog.querySelector("svg")).toBeInTheDocument();
+	});
+
+	it("renders non-numeric action cost as text", () => {
+		const spell: SpellReference = {
+			...FIREBALL,
+			actionCost: "1 minute",
+		};
+		render(
+			<SpellDetailPopover
+				spell={spell}
+				anchorRect={ANCHOR}
+				onClose={() => {}}
+			/>,
+		);
+		expect(screen.getByText("1 minute")).toBeInTheDocument();
+	});
+
+	it("uses the dialog role with the spell name as label", () => {
+		render(
+			<SpellDetailPopover
+				spell={FIREBALL}
+				anchorRect={ANCHOR}
+				onClose={() => {}}
+			/>,
+		);
+		expect(
+			screen.getByRole("dialog", { name: DIALOG_LABEL_REGEX }),
+		).toBeInTheDocument();
+	});
+});

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

@@ -111,9 +111,15 @@ const DRAGON: Creature = {
 		{
 			name: "Innate Spellcasting",
 			headerText: "The dragon's spellcasting ability is Charisma.",
-			atWill: ["detect magic", "suggestion"],
+			atWill: [{ name: "detect magic" }, { name: "suggestion" }],
-			daily: [{ uses: 3, each: true, spells: ["fireball", "wall of fire"] }],
+			daily: [
-			restLong: [{ uses: 1, each: false, spells: ["wish"] }],
+				{
+					uses: 3,
+					each: true,
+					spells: [{ name: "fireball" }, { name: "wall of fire" }],
+				},
+			],
+			restLong: [{ uses: 1, each: false, spells: [{ name: "wish" }] }],
 		},
 	],
 };

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

@@ -3,6 +3,7 @@ import {
 	type ConditionEntry,
 	type CreatureId,
 	deriveHpStatus,
+	type PersistentDamageEntry,
 	type PlayerIcon,
 	type RollMode,
 } from "@initiative/domain";
@@ -10,6 +11,7 @@ import { Brain, Pencil, X } from "lucide-react";
 import { type Ref, useCallback, useEffect, useRef, useState } from "react";
 import { useEncounterContext } from "../contexts/encounter-context.js";
 import { useInitiativeRollsContext } from "../contexts/initiative-rolls-context.js";
+import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
 import { useSidePanelContext } from "../contexts/side-panel-context.js";
 import { useLongPress } from "../hooks/use-long-press.js";
 import { cn } from "../lib/utils.js";
@@ -18,6 +20,7 @@ import { ConditionPicker } from "./condition-picker.js";
 import { ConditionTags } from "./condition-tags.js";
 import { D20Icon } from "./d20-icon.js";
 import { HpAdjustPopover } from "./hp-adjust-popover.js";
+import { PersistentDamageTags } from "./persistent-damage-tags.js";
 import { PLAYER_COLOR_HEX, PLAYER_ICON_MAP } from "./player-icon-map.js";
 import { RollModeMenu } from "./roll-mode-menu.js";
 import { ConfirmButton } from "./ui/confirm-button.js";
@@ -32,6 +35,7 @@ interface Combatant {
 	readonly tempHp?: number;
 	readonly ac?: number;
 	readonly conditions?: readonly ConditionEntry[];
+	readonly persistentDamage?: readonly PersistentDamageEntry[];
 	readonly isConcentrating?: boolean;
 	readonly color?: string;
 	readonly icon?: string;
@@ -415,12 +419,14 @@ function InitiativeDisplay({
 function rowBorderClass(
 	isActive: boolean,
 	isConcentrating: boolean | undefined,
+	isPf2e: boolean,
 ): string {
-	if (isActive && isConcentrating)
+	const showConcentration = isConcentrating && !isPf2e;
+	if (isActive && showConcentration)
 		return "border border-l-2 border-active-row-border border-l-purple-400 bg-active-row-bg card-glow";
 	if (isActive)
 		return "border border-l-2 border-active-row-border bg-active-row-bg card-glow";
-	if (isConcentrating)
+	if (showConcentration)
 		return "border border-l-2 border-transparent border-l-purple-400";
 	return "border border-l-2 border-transparent";
 }
@@ -451,13 +457,23 @@ export function CombatantRow({
 		setConditionValue,
 		decrementCondition,
 		toggleConcentration,
+		addPersistentDamage,
+		removePersistentDamage,
 	} = useEncounterContext();
-	const { selectedCreatureId, showCreature, toggleCollapse } =
+	const {
-		useSidePanelContext();
+		selectedCreatureId,
+		selectedCombatantId,
+		showCreature,
+		toggleCollapse,
+	} = useSidePanelContext();
 	const { handleRollInitiative } = useInitiativeRollsContext();
+	const { edition } = useRulesEditionContext();
+	const isPf2e = edition === "pf2e";
 
 	// Derive what was previously conditional props
-	const isStatBlockOpen = combatant.creatureId === selectedCreatureId;
+	const isStatBlockOpen =
+		combatant.creatureId === selectedCreatureId &&
+		combatant.id === selectedCombatantId;
 	const { creatureId } = combatant;
 	const hasStatBlock = !!creatureId;
 	const onToggleStatBlock = hasStatBlock
@@ -465,7 +481,7 @@ export function CombatantRow({
 				if (isStatBlockOpen) {
 					toggleCollapse();
 				} else {
-					showCreature(creatureId);
+					showCreature(creatureId, combatant.id);
 				}
 			}
 		: undefined;
@@ -495,12 +511,16 @@ export function CombatantRow({
 		const tempHpDropped =
 			prevTempHp !== undefined && (combatant.tempHp ?? 0) < prevTempHp;
 
-		if ((realHpDropped || tempHpDropped) && combatant.isConcentrating) {
+		if (
+			(realHpDropped || tempHpDropped) &&
+			combatant.isConcentrating &&
+			!isPf2e
+		) {
 			setIsPulsing(true);
 			clearTimeout(pulseTimerRef.current);
 			pulseTimerRef.current = setTimeout(() => setIsPulsing(false), 1200);
 		}
-	}, [currentHp, combatant.tempHp, combatant.isConcentrating]);
+	}, [currentHp, combatant.tempHp, combatant.isConcentrating, isPf2e]);
 
 	useEffect(() => {
 		if (!combatant.isConcentrating) {
@@ -518,24 +538,33 @@ export function CombatantRow({
 			ref={ref}
 			className={cn(
 				"group rounded-lg pr-3 transition-colors",
-				rowBorderClass(isActive, combatant.isConcentrating),
+				rowBorderClass(isActive, combatant.isConcentrating, isPf2e),
 				isPulsing && "animate-concentration-pulse",
 			)}
 		>
-			<div className="grid grid-cols-[2rem_3rem_auto_1fr_auto_2rem] items-center gap-1.5 py-3 sm:grid-cols-[2rem_3.5rem_auto_1fr_auto_2rem] sm:gap-3 sm:py-2">
+			<div
-				{/* Concentration */}
+				className={cn(
-				<button
+					"grid items-center gap-1.5 py-3 sm:gap-3 sm:py-2",
-					type="button"
+					isPf2e
-					onClick={() => toggleConcentration(id)}
+						? "grid-cols-[3rem_auto_1fr_auto_2rem] pl-3 sm:grid-cols-[3.5rem_auto_1fr_auto_2rem]"
-					title="Concentrating"
+						: "grid-cols-[2rem_3rem_auto_1fr_auto_2rem] sm:grid-cols-[2rem_3.5rem_auto_1fr_auto_2rem]",
-					aria-label="Toggle concentration"
+				)}
-					className={cn(
+			>
-						"-my-2 -ml-[2px] flex w-full items-center justify-center self-stretch pl-[14px] transition-opacity hover:text-hover-neutral hover:opacity-100",
+				{/* Concentration — hidden in PF2e mode */}
-						concentrationIconClass(combatant.isConcentrating, dimmed),
+				{!isPf2e && (
-					)}
+					<button
-				>
+						type="button"
-					<Brain size={16} />
+						onClick={() => toggleConcentration(id)}
-				</button>
+						title="Concentrating"
+						aria-label="Toggle concentration"
+						className={cn(
+							"-my-2 -ml-[2px] flex w-full items-center justify-center self-stretch pl-[14px] transition-opacity hover:text-hover-neutral hover:opacity-100",
+							concentrationIconClass(combatant.isConcentrating, dimmed),
+						)}
+					>
+						<Brain size={16} />
+					</button>
+				)}
 
 				{/* Initiative */}
 				<div className="rounded-md bg-muted/30 px-1">
@@ -591,14 +620,24 @@ export function CombatantRow({
 							onOpenPicker={() => setPickerOpen((prev) => !prev)}
 						/>
 					</div>
+					{isPf2e && (
+						<PersistentDamageTags
+							entries={combatant.persistentDamage}
+							onRemove={(damageType) => removePersistentDamage(id, damageType)}
+						/>
+					)}
 					{!!pickerOpen && (
 						<ConditionPicker
 							anchorRef={conditionAnchorRef}
 							activeConditions={combatant.conditions}
+							activePersistentDamage={combatant.persistentDamage}
 							onToggle={(conditionId) => toggleCondition(id, conditionId)}
 							onSetValue={(conditionId, value) =>
 								setConditionValue(id, conditionId, value)
 							}
+							onAddPersistentDamage={(damageType, formula) =>
+								addPersistentDamage(id, damageType, formula)
+							}
 							onClose={() => setPickerOpen(false)}
 						/>
 					)}

apps/web/src/components/condition-picker.tsx

@@ -3,9 +3,11 @@ import {
 	type ConditionId,
 	getConditionDescription,
 	getConditionsForEdition,
+	type PersistentDamageEntry,
+	type PersistentDamageType,
 } from "@initiative/domain";
-import { Check, Minus, Plus } from "lucide-react";
+import { Check, Flame, Minus, Plus } from "lucide-react";
-import { useLayoutEffect, useRef, useState } from "react";
+import React, { useLayoutEffect, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { useRulesEditionContext } from "../contexts/rules-edition-context.js";
 import { useClickOutside } from "../hooks/use-click-outside.js";
@@ -14,21 +16,29 @@ import {
 	CONDITION_COLOR_CLASSES,
 	CONDITION_ICON_MAP,
 } from "./condition-styles.js";
+import { PersistentDamagePicker } from "./persistent-damage-picker.js";
 import { Tooltip } from "./ui/tooltip.js";
 
 interface ConditionPickerProps {
 	anchorRef: React.RefObject<HTMLElement | null>;
 	activeConditions: readonly ConditionEntry[] | undefined;
+	activePersistentDamage?: readonly PersistentDamageEntry[];
 	onToggle: (conditionId: ConditionId) => void;
 	onSetValue: (conditionId: ConditionId, value: number) => void;
+	onAddPersistentDamage?: (
+		damageType: PersistentDamageType,
+		formula: string,
+	) => void;
 	onClose: () => void;
 }
 
 export function ConditionPicker({
 	anchorRef,
 	activeConditions,
+	activePersistentDamage,
 	onToggle,
 	onSetValue,
+	onAddPersistentDamage,
 	onClose,
 }: Readonly<ConditionPickerProps>) {
 	const ref = useRef<HTMLDivElement>(null);
@@ -42,6 +52,7 @@ export function ConditionPicker({
 		id: ConditionId;
 		value: number;
 	} | null>(null);
+	const [showPersistentDamage, setShowPersistentDamage] = useState(false);
 
 	useLayoutEffect(() => {
 		const anchor = anchorRef.current;
@@ -71,6 +82,51 @@ export function ConditionPicker({
 	const activeMap = new Map(
 		(activeConditions ?? []).map((e) => [e.id, e.value]),
 	);
+	const showPersistentDamageEntry =
+		edition === "pf2e" && !!onAddPersistentDamage;
+	const persistentDamageInsertIndex = showPersistentDamageEntry
+		? conditions.findIndex(
+				(d) => d.label.localeCompare("Persistent Damage") > 0,
+			)
+		: -1;
+
+	const persistentDamageEntry = showPersistentDamageEntry ? (
+		<React.Fragment key="persistent-damage">
+			<div
+				className={cn(
+					"flex w-full items-center gap-2 rounded px-2 py-1 text-sm transition-colors",
+					showPersistentDamage && "bg-card/50",
+				)}
+			>
+				<button
+					type="button"
+					className="flex flex-1 items-center gap-2"
+					onClick={() => setShowPersistentDamage((prev) => !prev)}
+				>
+					<Flame
+						size={14}
+						className={
+							showPersistentDamage ? "text-orange-400" : "text-muted-foreground"
+						}
+					/>
+					<span
+						className={
+							showPersistentDamage ? "text-foreground" : "text-muted-foreground"
+						}
+					>
+						Persistent Damage
+					</span>
+				</button>
+			</div>
+			{!!showPersistentDamage && (
+				<PersistentDamagePicker
+					activeEntries={activePersistentDamage}
+					onAdd={onAddPersistentDamage}
+					onClose={() => setShowPersistentDamage(false)}
+				/>
+			)}
+		</React.Fragment>
+	) : null;
 
 	return createPortal(
 		<div
@@ -82,7 +138,7 @@ export function ConditionPicker({
 					: { visibility: "hidden" as const }
 			}
 		>
-			{conditions.map((def) => {
+			{conditions.map((def, index) => {
 				const Icon = CONDITION_ICON_MAP[def.iconName];
 				if (!Icon) return null;
 				const isActive = activeMap.has(def.id);
@@ -104,96 +160,116 @@ export function ConditionPicker({
 				};
 
 				return (
-					<Tooltip
+					<React.Fragment key={def.id}>
-						key={def.id}
+						{index === persistentDamageInsertIndex && persistentDamageEntry}
-						content={getConditionDescription(def, edition)}
+						<Tooltip
-						className="block"
+							content={getConditionDescription(def, edition)}
-					>
+							className="block"
-						<div
-							className={cn(
-								"flex w-full items-center gap-2 rounded px-2 py-1 text-sm transition-colors",
-								(isActive || isEditing) && "bg-card/50",
-							)}
 						>
-							<button
+							<div
-								type="button"
+								className={cn(
-								className="flex flex-1 items-center gap-2"
+									"flex w-full items-center gap-2 rounded px-2 py-1 text-sm transition-colors",
-								onClick={handleClick}
+									(isActive || isEditing) && "bg-card/50",
+								)}
 							>
-								<Icon
+								<button
-									size={14}
+									type="button"
-									className={
+									className="flex flex-1 items-center gap-2"
-										isActive || isEditing ? colorClass : "text-muted-foreground"
+									onClick={handleClick}
-									}
-								/>
-								<span
-									className={
-										isActive || isEditing
-											? "text-foreground"
-											: "text-muted-foreground"
-									}
 								>
-									{def.label}
+									<Icon
-								</span>
+										size={14}
-							</button>
+										className={
-							{isActive && def.valued && edition === "pf2e" && !isEditing && (
+											isActive || isEditing
-								<span className="min-w-5 rounded-full bg-accent px-1.5 py-0.5 text-center font-medium text-primary-foreground text-xs">
+												? colorClass
-									{activeValue}
+												: "text-muted-foreground"
-								</span>
+										}
-							)}
+									/>
-							{isEditing && (
+									<span
-								<div className="flex items-center gap-0.5">
+										className={
-									<button
+											isActive || isEditing
-										type="button"
+												? "text-foreground"
-										className="rounded p-0.5 text-foreground hover:bg-accent/40"
+												: "text-muted-foreground"
-										onMouseDown={(e) => e.preventDefault()}
+										}
-										onClick={(e) => {
-											e.stopPropagation();
-											if (editing.value > 1) {
-												setEditing({
-													...editing,
-													value: editing.value - 1,
-												});
-											}
-										}}
 									>
-										<Minus className="h-3 w-3" />
+										{def.label}
-									</button>
-									<span className="min-w-5 rounded-full bg-accent px-1.5 py-0.5 text-center font-medium text-primary-foreground text-xs">
-										{editing.value}
 									</span>
-									<button
+								</button>
-										type="button"
+								{isActive && def.valued && edition === "pf2e" && !isEditing && (
-										className="rounded p-0.5 text-foreground hover:bg-accent/40"
+									<span className="min-w-5 rounded-full bg-accent px-1.5 py-0.5 text-center font-medium text-primary-foreground text-xs">
-										onMouseDown={(e) => e.preventDefault()}
+										{activeValue}
-										onClick={(e) => {
+									</span>
-											e.stopPropagation();
+								)}
-											setEditing({
+								{isEditing && (
-												...editing,
+									<div className="flex items-center gap-0.5">
-												value: editing.value + 1,
+										<button
-											});
+											type="button"
-										}}
+											className="rounded p-0.5 text-foreground hover:bg-accent/40"
-									>
+											onMouseDown={(e) => e.preventDefault()}
-										<Plus className="h-3 w-3" />
+											onClick={(e) => {
-									</button>
+												e.stopPropagation();
-									<button
+												if (editing.value > 1) {
-										type="button"
+													setEditing({
-										className="ml-0.5 rounded p-0.5 text-foreground hover:bg-accent/40"
+														...editing,
-										onMouseDown={(e) => e.preventDefault()}
+														value: editing.value - 1,
-										onClick={(e) => {
+													});
-											e.stopPropagation();
+												}
-											onSetValue(editing.id, editing.value);
+											}}
-											setEditing(null);
+										>
-										}}
+											<Minus className="h-3 w-3" />
-									>
+										</button>
-										<Check className="h-3.5 w-3.5" />
+										<span className="min-w-5 rounded-full bg-accent px-1.5 py-0.5 text-center font-medium text-primary-foreground text-xs">
-									</button>
+											{editing.value}
-								</div>
+										</span>
-							)}
+										{(() => {
-						</div>
+											const atMax =
-					</Tooltip>
+												def.maxValue !== undefined &&
+												editing.value >= def.maxValue;
+											return (
+												<button
+													type="button"
+													className={cn(
+														"rounded p-0.5",
+														atMax
+															? "cursor-not-allowed text-muted-foreground opacity-50"
+															: "text-foreground hover:bg-accent/40",
+													)}
+													disabled={atMax}
+													onMouseDown={(e) => e.preventDefault()}
+													onClick={(e) => {
+														e.stopPropagation();
+														if (!atMax) {
+															setEditing({
+																...editing,
+																value: editing.value + 1,
+															});
+														}
+													}}
+												>
+													<Plus className="h-3 w-3" />
+												</button>
+											);
+										})()}
+										<button
+											type="button"
+											className="ml-0.5 rounded p-0.5 text-foreground hover:bg-accent/40"
+											onMouseDown={(e) => e.preventDefault()}
+											onClick={(e) => {
+												e.stopPropagation();
+												onSetValue(editing.id, editing.value);
+												setEditing(null);
+											}}
+										>
+											<Check className="h-3.5 w-3.5" />
+										</button>
+									</div>
+								)}
+							</div>
+						</Tooltip>
+					</React.Fragment>
 				);
 			})}
+			{persistentDamageInsertIndex === -1 && persistentDamageEntry}
 		</div>,
 		document.body,
 	);

apps/web/src/components/condition-styles.ts

@@ -11,8 +11,11 @@ import {
 	Droplet,
 	Droplets,
 	EarOff,
+	Eclipse,
 	Eye,
 	EyeOff,
+	Flame,
+	FlaskConical,
 	Footprints,
 	Gem,
 	Ghost,
@@ -22,15 +25,20 @@ import {
 	HeartPulse,
 	Link,
 	Moon,
+	Orbit,
 	PersonStanding,
 	ShieldMinus,
 	ShieldOff,
 	Siren,
 	Skull,
 	Snail,
+	Snowflake,
+	Sparkle,
 	Sparkles,
 	Sun,
+	Sword,
 	TrendingDown,
+	Wind,
 	Zap,
 	ZapOff,
 } from "lucide-react";
@@ -47,8 +55,11 @@ export const CONDITION_ICON_MAP: Record<string, LucideIcon> = {
 	Droplet,
 	Droplets,
 	EarOff,
+	Eclipse,
 	Eye,
 	EyeOff,
+	Flame,
+	FlaskConical,
 	Footprints,
 	Gem,
 	Ghost,
@@ -58,15 +69,20 @@ export const CONDITION_ICON_MAP: Record<string, LucideIcon> = {
 	HeartPulse,
 	Link,
 	Moon,
+	Orbit,
 	PersonStanding,
 	ShieldMinus,
 	ShieldOff,
 	Siren,
 	Skull,
 	Snail,
+	Snowflake,
+	Sparkle,
 	Sparkles,
 	Sun,
+	Sword,
 	TrendingDown,
+	Wind,
 	Zap,
 	ZapOff,
 };
@@ -81,6 +97,7 @@ export const CONDITION_COLOR_CLASSES: Record<string, string> = {
 	yellow: "text-yellow-400",
 	slate: "text-slate-400",
 	green: "text-green-400",
+	lime: "text-lime-400",
 	indigo: "text-indigo-400",
 	sky: "text-sky-400",
 	red: "text-red-400",

apps/web/src/components/detail-popover.tsx

@@ -0,0 +1,141 @@
+import type { ReactNode } from "react";
+import { useEffect, useLayoutEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { useClickOutside } from "../hooks/use-click-outside.js";
+import { useSwipeToDismissDown } from "../hooks/use-swipe-to-dismiss.js";
+import { cn } from "../lib/utils.js";
+
+interface DetailPopoverProps {
+	readonly anchorRect: DOMRect;
+	readonly onClose: () => void;
+	readonly ariaLabel: string;
+	readonly children: ReactNode;
+}
+
+function DesktopPanel({
+	anchorRect,
+	onClose,
+	ariaLabel,
+	children,
+}: Readonly<DetailPopoverProps>) {
+	const ref = useRef<HTMLDivElement>(null);
+	const [pos, setPos] = useState<{ top: number; left: number } | null>(null);
+
+	useLayoutEffect(() => {
+		const el = ref.current;
+		if (!el) return;
+		const popover = el.getBoundingClientRect();
+		const vw = document.documentElement.clientWidth;
+		const vh = document.documentElement.clientHeight;
+		// Prefer placement to the LEFT of the anchor (panel is on the right edge)
+		let left = anchorRect.left - popover.width - 8;
+		if (left < 8) {
+			left = anchorRect.right + 8;
+		}
+		if (left + popover.width > vw - 8) {
+			left = vw - popover.width - 8;
+		}
+		let top = anchorRect.top;
+		if (top + popover.height > vh - 8) {
+			top = vh - popover.height - 8;
+		}
+		if (top < 8) top = 8;
+		setPos({ top, left });
+	}, [anchorRect]);
+
+	useClickOutside(ref, onClose);
+
+	return (
+		<div
+			ref={ref}
+			className="card-glow fixed z-50 max-h-[calc(100vh-16px)] w-80 max-w-[calc(100vw-16px)] overflow-y-auto rounded-lg border border-border bg-card p-4 shadow-lg"
+			style={pos ? { top: pos.top, left: pos.left } : { visibility: "hidden" }}
+			role="dialog"
+			aria-label={ariaLabel}
+		>
+			{children}
+		</div>
+	);
+}
+
+function MobileSheet({
+	onClose,
+	ariaLabel,
+	children,
+}: Readonly<Omit<DetailPopoverProps, "anchorRect">>) {
+	const { offsetY, isSwiping, handlers } = useSwipeToDismissDown(onClose);
+
+	useEffect(() => {
+		const handler = (e: KeyboardEvent) => {
+			if (e.key === "Escape") onClose();
+		};
+		document.addEventListener("keydown", handler);
+		return () => document.removeEventListener("keydown", handler);
+	}, [onClose]);
+
+	return (
+		<div className="fixed inset-0 z-50">
+			<button
+				type="button"
+				className="fade-in absolute inset-0 animate-in bg-black/50"
+				onClick={onClose}
+				aria-label="Close details"
+			/>
+			<div
+				className={cn(
+					"panel-glow absolute right-0 bottom-0 left-0 max-h-[80vh] rounded-t-2xl border-border border-t bg-card",
+					!isSwiping && "animate-slide-in-bottom",
+				)}
+				style={
+					isSwiping ? { transform: `translateY(${offsetY}px)` } : undefined
+				}
+				{...handlers}
+				role="dialog"
+				aria-label={ariaLabel}
+			>
+				<div className="flex justify-center pt-2 pb-1">
+					<div className="h-1 w-10 rounded-full bg-muted-foreground/40" />
+				</div>
+				<div className="max-h-[calc(80vh-24px)] overflow-y-auto p-4">
+					{children}
+				</div>
+			</div>
+		</div>
+	);
+}
+
+export function DetailPopover({
+	anchorRect,
+	onClose,
+	ariaLabel,
+	children,
+}: Readonly<DetailPopoverProps>) {
+	const [isDesktop, setIsDesktop] = useState(
+		() => globalThis.matchMedia("(min-width: 1024px)").matches,
+	);
+
+	useEffect(() => {
+		const mq = globalThis.matchMedia("(min-width: 1024px)");
+		const handler = (e: MediaQueryListEvent) => setIsDesktop(e.matches);
+		mq.addEventListener("change", handler);
+		return () => mq.removeEventListener("change", handler);
+	}, []);
+
+	// Portal to document.body to escape any CSS transforms on ancestors
+	// (the side panel uses translate-x for collapse animation, which would
+	// otherwise become the containing block for fixed-positioned children).
+	const content = isDesktop ? (
+		<DesktopPanel
+			anchorRect={anchorRect}
+			onClose={onClose}
+			ariaLabel={ariaLabel}
+		>
+			{children}
+		</DesktopPanel>
+	) : (
+		<MobileSheet onClose={onClose} ariaLabel={ariaLabel}>
+			{children}
+		</MobileSheet>
+	);
+	return createPortal(content, document.body);
+}

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

@@ -134,7 +134,7 @@ export function DndStatBlock({ creature }: Readonly<DndStatBlockProps>) {
 							{sc.atWill && sc.atWill.length > 0 && (
 								<div className="pl-2">
 									<span className="font-semibold">At Will:</span>{" "}
-									{sc.atWill.join(", ")}
+									{sc.atWill.map((s) => s.name).join(", ")}
 								</div>
 							)}
 							{sc.daily?.map((d) => (
@@ -143,7 +143,7 @@ export function DndStatBlock({ creature }: Readonly<DndStatBlockProps>) {
 										{d.uses}/day
 										{d.each ? " each" : ""}:
 									</span>{" "}
-									{d.spells.join(", ")}
+									{d.spells.map((s) => s.name).join(", ")}
 								</div>
 							))}
 							{sc.restLong?.map((d) => (
@@ -155,7 +155,7 @@ export function DndStatBlock({ creature }: Readonly<DndStatBlockProps>) {
 										{d.uses}/long rest
 										{d.each ? " each" : ""}:
 									</span>{" "}
-									{d.spells.join(", ")}
+									{d.spells.map((s) => s.name).join(", ")}
 								</div>
 							))}
 						</div>

apps/web/src/components/equipment-detail-popover.tsx

@@ -0,0 +1,72 @@
+import type { EquipmentItem } from "@initiative/domain";
+import { DetailPopover } from "./detail-popover.js";
+import { RichDescription } from "./rich-description.js";
+
+interface EquipmentDetailPopoverProps {
+	readonly item: EquipmentItem;
+	readonly anchorRect: DOMRect;
+	readonly onClose: () => void;
+}
+
+function EquipmentDetailContent({ item }: Readonly<{ item: EquipmentItem }>) {
+	return (
+		<div className="space-y-2 text-sm">
+			<h3 className="font-bold text-lg text-stat-heading">{item.name}</h3>
+			{item.traits && item.traits.length > 0 && (
+				<div className="flex flex-wrap gap-1">
+					{item.traits.map((t) => (
+						<span
+							key={t}
+							className="rounded border border-border bg-card px-1.5 py-0.5 text-foreground text-xs"
+						>
+							{t}
+						</span>
+					))}
+				</div>
+			)}
+			<div className="space-y-0.5 text-xs">
+				<div>
+					<span className="font-semibold">Level</span> {item.level}
+				</div>
+				{item.category ? (
+					<div>
+						<span className="font-semibold">Category</span>{" "}
+						{item.category.charAt(0).toUpperCase() + item.category.slice(1)}
+					</div>
+				) : null}
+				{item.spellName ? (
+					<div>
+						<span className="font-semibold">Spell</span> {item.spellName}
+						{item.spellRank === undefined ? "" : ` (Rank ${item.spellRank})`}
+					</div>
+				) : null}
+			</div>
+			{item.description ? (
+				<RichDescription
+					text={item.description}
+					className="whitespace-pre-line text-foreground"
+				/>
+			) : (
+				<p className="text-muted-foreground italic">
+					No description available.
+				</p>
+			)}
+		</div>
+	);
+}
+
+export function EquipmentDetailPopover({
+	item,
+	anchorRect,
+	onClose,
+}: Readonly<EquipmentDetailPopoverProps>) {
+	return (
+		<DetailPopover
+			anchorRect={anchorRect}
+			onClose={onClose}
+			ariaLabel={`Equipment details: ${item.name}`}
+		>
+			<EquipmentDetailContent item={item} />
+		</DetailPopover>
+	);
+}

apps/web/src/components/persistent-damage-picker.tsx

@@ -0,0 +1,97 @@
+import {
+	PERSISTENT_DAMAGE_DEFINITIONS,
+	type PersistentDamageEntry,
+	type PersistentDamageType,
+} from "@initiative/domain";
+import { Check } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+
+interface PersistentDamagePickerProps {
+	activeEntries: readonly PersistentDamageEntry[] | undefined;
+	onAdd: (damageType: PersistentDamageType, formula: string) => void;
+	onClose: () => void;
+}
+
+export function PersistentDamagePicker({
+	activeEntries,
+	onAdd,
+	onClose,
+}: Readonly<PersistentDamagePickerProps>) {
+	const [selectedType, setSelectedType] = useState<PersistentDamageType>(
+		PERSISTENT_DAMAGE_DEFINITIONS[0].type,
+	);
+	const activeFormula =
+		activeEntries?.find((e) => e.type === selectedType)?.formula ?? "";
+	const [formula, setFormula] = useState(activeFormula);
+	const inputRef = useRef<HTMLInputElement>(null);
+
+	useEffect(() => {
+		inputRef.current?.focus();
+	}, []);
+
+	useEffect(() => {
+		const existing = activeEntries?.find(
+			(e) => e.type === selectedType,
+		)?.formula;
+		setFormula(existing ?? "");
+	}, [selectedType, activeEntries]);
+
+	const canSubmit = formula.trim().length > 0;
+
+	function handleSubmit() {
+		if (canSubmit) {
+			onAdd(selectedType, formula);
+			onClose();
+		}
+	}
+
+	function handleEscape(e: React.KeyboardEvent) {
+		if (e.key === "Escape") {
+			e.stopPropagation();
+			onClose();
+		}
+	}
+
+	return (
+		<div className="flex items-center gap-1.5 py-1 pr-2 pl-6">
+			<select
+				value={selectedType}
+				onChange={(e) =>
+					setSelectedType(e.target.value as PersistentDamageType)
+				}
+				onKeyDown={handleEscape}
+				className="h-7 rounded border border-border bg-background px-1 text-foreground text-xs"
+			>
+				{PERSISTENT_DAMAGE_DEFINITIONS.map((def) => (
+					<option key={def.type} value={def.type}>
+						{def.label}
+					</option>
+				))}
+			</select>
+			<input
+				ref={inputRef}
+				type="text"
+				value={formula}
+				placeholder="2d6"
+				className="h-7 w-16 rounded border border-border bg-background px-1.5 text-foreground text-xs"
+				onChange={(e) => setFormula(e.target.value)}
+				onKeyDown={(e) => {
+					if (e.key === "Enter") {
+						e.preventDefault();
+						handleSubmit();
+					}
+					handleEscape(e);
+				}}
+			/>
+			<button
+				type="button"
+				disabled={!canSubmit}
+				onClick={handleSubmit}
+				className="rounded p-0.5 text-foreground hover:bg-accent/40 disabled:cursor-not-allowed disabled:opacity-50"
+				aria-label="Add persistent damage"
+			>
+				<Check className="h-3.5 w-3.5" />
+			</button>
+		</div>
+	);
+}

apps/web/src/components/persistent-damage-tags.tsx

@@ -0,0 +1,63 @@
+import {
+	PERSISTENT_DAMAGE_DEFINITIONS,
+	type PersistentDamageEntry,
+	type PersistentDamageType,
+} from "@initiative/domain";
+import { cn } from "../lib/utils.js";
+import {
+	CONDITION_COLOR_CLASSES,
+	CONDITION_ICON_MAP,
+} from "./condition-styles.js";
+import { Tooltip } from "./ui/tooltip.js";
+
+interface PersistentDamageTagsProps {
+	entries: readonly PersistentDamageEntry[] | undefined;
+	onRemove: (damageType: PersistentDamageType) => void;
+}
+
+export function PersistentDamageTags({
+	entries,
+	onRemove,
+}: Readonly<PersistentDamageTagsProps>) {
+	if (!entries || entries.length === 0) return null;
+
+	return (
+		<>
+			{entries.map((entry) => {
+				const def = PERSISTENT_DAMAGE_DEFINITIONS.find(
+					(d) => d.type === entry.type,
+				);
+				if (!def) return null;
+				const Icon = CONDITION_ICON_MAP[def.iconName];
+				if (!Icon) return null;
+				const colorClass =
+					CONDITION_COLOR_CLASSES[def.color] ?? "text-muted-foreground";
+
+				return (
+					<Tooltip
+						key={entry.type}
+						content={`Persistent ${def.label} ${entry.formula}\nTake damage at end of turn. DC 15 flat check to end.`}
+					>
+						<button
+							type="button"
+							aria-label={`Remove persistent ${def.label} damage`}
+							className={cn(
+								"inline-flex items-center gap-0.5 rounded p-0.5 transition-colors hover:bg-hover-neutral-bg",
+								colorClass,
+							)}
+							onClick={(e) => {
+								e.stopPropagation();
+								onRemove(entry.type);
+							}}
+						>
+							<Icon size={14} />
+							<span className="font-medium text-xs leading-none">
+								{entry.formula}
+							</span>
+						</button>
+					</Tooltip>
+				);
+			})}
+		</>
+	);
+}

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

@@ -1,5 +1,15 @@
-import type { Pf2eCreature } from "@initiative/domain";
+import type {
-import { formatInitiativeModifier } from "@initiative/domain";
+	CombatantId,
+	EquipmentItem,
+	Pf2eCreature,
+	SpellReference,
+} from "@initiative/domain";
+import { formatInitiativeModifier, recallKnowledge } from "@initiative/domain";
+import { ChevronDown, ChevronUp } from "lucide-react";
+import { useCallback, useRef, useState } from "react";
+import { cn } from "../lib/utils.js";
+import { EquipmentDetailPopover } from "./equipment-detail-popover.js";
+import { SpellDetailPopover } from "./spell-detail-popover.js";
 import {
 	PropertyLine,
 	SectionDivider,
@@ -8,6 +18,14 @@ import {
 
 interface Pf2eStatBlockProps {
 	creature: Pf2eCreature;
+	adjustment?: "weak" | "elite";
+	combatantId?: CombatantId;
+	baseCreature?: Pf2eCreature;
+	onSetAdjustment?: (
+		id: CombatantId,
+		adj: "weak" | "elite" | undefined,
+		base: Pf2eCreature,
+	) => void;
 }
 
 const ALIGNMENTS = new Set([
@@ -34,7 +52,137 @@ function formatMod(mod: number): string {
 	return mod >= 0 ? `+${mod}` : `${mod}`;
 }
 
-export function Pf2eStatBlock({ creature }: Readonly<Pf2eStatBlockProps>) {
+/** Returns the text color class for stats affected by weak/elite adjustment. */
+function adjustmentColor(adjustment: "weak" | "elite" | undefined): string {
+	if (adjustment === "elite") return "text-blue-400";
+	if (adjustment === "weak") return "text-red-400";
+	return "";
+}
+
+interface SpellLinkProps {
+	readonly spell: SpellReference;
+	readonly onOpen: (spell: SpellReference, rect: DOMRect) => void;
+}
+
+function UsesPerDay({ count }: Readonly<{ count: number | undefined }>) {
+	if (count === undefined || count <= 1) return null;
+	return <span> (×{count})</span>;
+}
+
+function SpellLink({ spell, onOpen }: Readonly<SpellLinkProps>) {
+	const ref = useRef<HTMLButtonElement>(null);
+	const handleClick = useCallback(() => {
+		if (!spell.description) return;
+		const rect = ref.current?.getBoundingClientRect();
+		if (rect) onOpen(spell, rect);
+	}, [spell, onOpen]);
+
+	if (!spell.description) {
+		return (
+			<span>
+				{spell.name}
+				<UsesPerDay count={spell.usesPerDay} />
+			</span>
+		);
+	}
+
+	return (
+		<>
+			<button
+				ref={ref}
+				type="button"
+				onClick={handleClick}
+				className="cursor-pointer text-foreground underline decoration-dotted underline-offset-2 hover:text-hover-neutral"
+			>
+				{spell.name}
+			</button>
+			<UsesPerDay count={spell.usesPerDay} />
+		</>
+	);
+}
+
+interface SpellListLineProps {
+	readonly label: string;
+	readonly spells: readonly SpellReference[];
+	readonly onOpen: (spell: SpellReference, rect: DOMRect) => void;
+}
+
+function SpellListLine({
+	label,
+	spells,
+	onOpen,
+}: Readonly<SpellListLineProps>) {
+	return (
+		<div className="pl-2">
+			<span className="font-semibold">{label}:</span>{" "}
+			{spells.map((spell, i) => (
+				<span key={spell.slug ?? spell.name}>
+					{i > 0 ? ", " : ""}
+					<SpellLink spell={spell} onOpen={onOpen} />
+				</span>
+			))}
+		</div>
+	);
+}
+
+interface EquipmentLinkProps {
+	readonly item: EquipmentItem;
+	readonly onOpen: (item: EquipmentItem, rect: DOMRect) => void;
+}
+
+function EquipmentLink({ item, onOpen }: Readonly<EquipmentLinkProps>) {
+	const ref = useRef<HTMLButtonElement>(null);
+	const handleClick = useCallback(() => {
+		if (!item.description) return;
+		const rect = ref.current?.getBoundingClientRect();
+		if (rect) onOpen(item, rect);
+	}, [item, onOpen]);
+
+	if (!item.description) {
+		return <span>{item.name}</span>;
+	}
+
+	return (
+		<button
+			ref={ref}
+			type="button"
+			onClick={handleClick}
+			className="cursor-pointer text-foreground underline decoration-dotted underline-offset-2 hover:text-hover-neutral"
+		>
+			{item.name}
+		</button>
+	);
+}
+
+export function Pf2eStatBlock({
+	creature,
+	adjustment,
+	combatantId,
+	baseCreature,
+	onSetAdjustment,
+}: Readonly<Pf2eStatBlockProps>) {
+	const [openSpell, setOpenSpell] = useState<{
+		spell: SpellReference;
+		rect: DOMRect;
+	} | null>(null);
+	const handleOpenSpell = useCallback(
+		(spell: SpellReference, rect: DOMRect) => setOpenSpell({ spell, rect }),
+		[],
+	);
+	const handleCloseSpell = useCallback(() => setOpenSpell(null), []);
+	const [openEquipment, setOpenEquipment] = useState<{
+		item: EquipmentItem;
+		rect: DOMRect;
+	} | null>(null);
+	const handleOpenEquipment = useCallback(
+		(item: EquipmentItem, rect: DOMRect) => setOpenEquipment({ item, rect }),
+		[],
+	);
+	const handleCloseEquipment = useCallback(() => setOpenEquipment(null), []);
+
+	const rk = recallKnowledge(creature.level, creature.traits);
+	const adjColor = adjustmentColor(adjustment);
+
 	const abilityEntries = [
 		{ label: "Str", mod: creature.abilityMods.str },
 		{ label: "Dex", mod: creature.abilityMods.dex },
@@ -49,13 +197,46 @@ export function Pf2eStatBlock({ creature }: Readonly<Pf2eStatBlockProps>) {
 			{/* Header */}
 			<div>
 				<div className="flex items-baseline justify-between gap-2">
-					<h2 className="font-bold text-stat-heading text-xl">
+					<h2 className="flex items-center gap-1.5 font-bold text-stat-heading text-xl">
+						{adjustment === "elite" && (
+							<ChevronUp className="h-5 w-5 shrink-0 text-blue-400" />
+						)}
+						{adjustment === "weak" && (
+							<ChevronDown className="h-5 w-5 shrink-0 text-red-400" />
+						)}
 						{creature.name}
 					</h2>
-					<span className="shrink-0 font-semibold text-sm">
+					<span className={cn("shrink-0 font-semibold text-sm", adjColor)}>
 						Level {creature.level}
 					</span>
 				</div>
+				{combatantId != null &&
+					onSetAdjustment != null &&
+					baseCreature != null && (
+						<div className="mt-1 flex gap-1">
+							{(["weak", "normal", "elite"] as const).map((opt) => {
+								const value = opt === "normal" ? undefined : opt;
+								const isActive = adjustment === value;
+								return (
+									<button
+										key={opt}
+										type="button"
+										className={cn(
+											"rounded px-2 py-0.5 font-medium text-xs capitalize",
+											isActive
+												? "bg-accent text-primary-foreground"
+												: "bg-card text-muted-foreground hover:bg-accent/30",
+										)}
+										onClick={() =>
+											onSetAdjustment(combatantId, value, baseCreature)
+										}
+									>
+										{opt}
+									</button>
+								);
+							})}
+						</div>
+					)}
 				<div className="mt-1 flex flex-wrap gap-1">
 					{displayTraits(creature.traits).map((trait) => (
 						<span
@@ -69,16 +250,24 @@ export function Pf2eStatBlock({ creature }: Readonly<Pf2eStatBlockProps>) {
 				<p className="mt-1 text-muted-foreground text-xs">
 					{creature.sourceDisplayName}
 				</p>
+				{rk && (
+					<p className="mt-1 text-sm">
+						<span className="font-semibold">Recall Knowledge</span> DC {rk.dc}{" "}
+						&bull; {capitalize(rk.type)} ({rk.skills.join("/")})
+					</p>
+				)}
 			</div>
 
 			<SectionDivider />
 
 			{/* Perception, Languages, Skills */}
 			<div className="space-y-0.5 text-sm">
-				<div>
+				<div className={adjColor}>
 					<span className="font-semibold">Perception</span>{" "}
 					{formatInitiativeModifier(creature.perception)}
-					{creature.senses ? `; ${creature.senses}` : ""}
+					{creature.senses || creature.perceptionDetails
+						? `; ${[creature.senses, creature.perceptionDetails].filter(Boolean).join(", ")}`
+						: ""}
 				</div>
 				<PropertyLine label="Languages" value={creature.languages} />
 				<PropertyLine label="Skills" value={creature.skills} />
@@ -105,7 +294,7 @@ export function Pf2eStatBlock({ creature }: Readonly<Pf2eStatBlockProps>) {
 
 			{/* Defenses */}
 			<div className="space-y-0.5 text-sm">
-				<div>
+				<div className={adjColor}>
 					<span className="font-semibold">AC</span> {creature.ac}
 					{creature.acConditional ? ` (${creature.acConditional})` : ""};{" "}
 					<span className="font-semibold">Fort</span>{" "}
@@ -116,7 +305,7 @@ export function Pf2eStatBlock({ creature }: Readonly<Pf2eStatBlockProps>) {
 					{formatMod(creature.saveWill)}
 					{creature.saveConditional ? `; ${creature.saveConditional}` : ""}
 				</div>
-				<div>
+				<div className={adjColor}>
 					<span className="font-semibold">HP</span> {creature.hp}
 					{creature.hpDetails ? ` (${creature.hpDetails})` : ""}
 				</div>
@@ -152,23 +341,51 @@ export function Pf2eStatBlock({ creature }: Readonly<Pf2eStatBlockProps>) {
 								{sc.headerText}
 							</div>
 							{sc.daily?.map((d) => (
-								<div key={d.uses} className="pl-2">
+								<SpellListLine
-									<span className="font-semibold">
+									key={d.uses}
-										{d.uses === 0 ? "Cantrips" : `Rank ${d.uses}`}:
+									label={d.uses === 0 ? "Cantrips" : `Rank ${d.uses}`}
-									</span>{" "}
+									spells={d.spells}
-									{d.spells.join(", ")}
+									onOpen={handleOpenSpell}
-								</div>
+								/>
 							))}
 							{sc.atWill && sc.atWill.length > 0 && (
-								<div className="pl-2">
+								<SpellListLine
-									<span className="font-semibold">Cantrips:</span>{" "}
+									label="Cantrips"
-									{sc.atWill.join(", ")}
+									spells={sc.atWill}
-								</div>
+									onOpen={handleOpenSpell}
+								/>
 							)}
 						</div>
 					))}
 				</>
 			)}
+			{creature.equipment && creature.equipment.length > 0 && (
+				<>
+					<SectionDivider />
+					<h3 className="font-bold text-base text-stat-heading">Equipment</h3>
+					<div className="space-y-1 text-sm">
+						{creature.equipment.map((item) => (
+							<div key={item.name}>
+								<EquipmentLink item={item} onOpen={handleOpenEquipment} />
+							</div>
+						))}
+					</div>
+				</>
+			)}
+			{openSpell ? (
+				<SpellDetailPopover
+					spell={openSpell.spell}
+					anchorRect={openSpell.rect}
+					onClose={handleCloseSpell}
+				/>
+			) : null}
+			{openEquipment ? (
+				<EquipmentDetailPopover
+					item={openEquipment.item}
+					anchorRect={openEquipment.rect}
+					onClose={handleCloseEquipment}
+				/>
+			) : null}
 		</div>
 	);
 }

apps/web/src/components/rich-description.tsx

@@ -0,0 +1,20 @@
+import { cn } from "../lib/utils.js";
+
+/**
+ * Renders text containing safe HTML formatting tags (strong, em, ul, ol, li)
+ * preserved by the stripFoundryTags pipeline. All other HTML is already
+ * stripped before reaching this component.
+ */
+export function RichDescription({
+	text,
+	className,
+}: Readonly<{ text: string; className?: string }>) {
+	const props = {
+		className: cn(
+			"[&_ol]:list-decimal [&_ol]:pl-4 [&_ul]:list-disc [&_ul]:pl-4",
+			className,
+		),
+		dangerouslySetInnerHTML: { __html: text },
+	};
+	return <div {...props} />;
+}

apps/web/src/components/source-fetch-prompt.tsx

@@ -8,7 +8,7 @@ import { Input } from "./ui/input.js";
 
 interface SourceFetchPromptProps {
 	sourceCode: string;
-	onSourceLoaded: () => void;
+	onSourceLoaded: (skippedNames: string[]) => void;
 }
 
 export function SourceFetchPrompt({
@@ -32,8 +32,9 @@ export function SourceFetchPrompt({
 		setStatus("fetching");
 		setError("");
 		try {
-			await fetchAndCacheSource(sourceCode, url);
+			const { skippedNames } = await fetchAndCacheSource(sourceCode, url);
-			onSourceLoaded();
+			setStatus("idle");
+			onSourceLoaded(skippedNames);
 		} catch (e) {
 			setStatus("error");
 			setError(e instanceof Error ? e.message : "Failed to fetch source data");
@@ -51,7 +52,7 @@ export function SourceFetchPrompt({
 			const text = await file.text();
 			const json = JSON.parse(text);
 			await uploadAndCacheSource(sourceCode, json);
-			onSourceLoaded();
+			onSourceLoaded([]);
 		} catch (err) {
 			setStatus("error");
 			setError(

apps/web/src/components/spell-detail-popover.tsx

@@ -0,0 +1,178 @@
+import type { ActivityCost, SpellReference } from "@initiative/domain";
+import { DetailPopover } from "./detail-popover.js";
+import { RichDescription } from "./rich-description.js";
+import { ActivityIcon } from "./stat-block-parts.js";
+
+interface SpellDetailPopoverProps {
+	readonly spell: SpellReference;
+	readonly anchorRect: DOMRect;
+	readonly onClose: () => void;
+}
+
+const RANK_LABELS = [
+	"Cantrip",
+	"1st",
+	"2nd",
+	"3rd",
+	"4th",
+	"5th",
+	"6th",
+	"7th",
+	"8th",
+	"9th",
+	"10th",
+];
+
+function formatRank(rank: number | undefined): string {
+	if (rank === undefined) return "";
+	return RANK_LABELS[rank] ?? `Rank ${rank}`;
+}
+
+function parseActionCost(cost: string): ActivityCost | null {
+	if (cost === "free") return { number: 1, unit: "free" };
+	if (cost === "reaction") return { number: 1, unit: "reaction" };
+	const n = Number(cost);
+	if (n >= 1 && n <= 3) return { number: n, unit: "action" };
+	return null;
+}
+
+function SpellActionCost({ cost }: Readonly<{ cost: string | undefined }>) {
+	if (!cost) return null;
+	const activity = parseActionCost(cost);
+	if (activity) {
+		return (
+			<span className="shrink-0 text-lg">
+				<ActivityIcon activity={activity} />
+			</span>
+		);
+	}
+	return <span className="shrink-0 text-muted-foreground text-xs">{cost}</span>;
+}
+
+function SpellHeader({ spell }: Readonly<{ spell: SpellReference }>) {
+	return (
+		<div className="flex items-center justify-between gap-2">
+			<h3 className="font-bold text-lg text-stat-heading">{spell.name}</h3>
+			<SpellActionCost cost={spell.actionCost} />
+		</div>
+	);
+}
+
+function SpellTraits({ traits }: Readonly<{ traits: readonly string[] }>) {
+	if (traits.length === 0) return null;
+	return (
+		<div className="flex flex-wrap gap-1">
+			{traits.map((t) => (
+				<span
+					key={t}
+					className="rounded border border-border bg-card px-1.5 py-0.5 text-foreground text-xs"
+				>
+					{t}
+				</span>
+			))}
+		</div>
+	);
+}
+
+function LabeledValue({
+	label,
+	value,
+}: Readonly<{ label: string; value: string }>) {
+	return (
+		<>
+			<span className="font-semibold">{label}</span> {value}
+		</>
+	);
+}
+
+function SpellRangeLine({ spell }: Readonly<{ spell: SpellReference }>) {
+	const items: { label: string; value: string }[] = [];
+	if (spell.range) items.push({ label: "Range", value: spell.range });
+	if (spell.target) items.push({ label: "Target", value: spell.target });
+	if (spell.area) items.push({ label: "Area", value: spell.area });
+
+	if (items.length === 0) return null;
+	return (
+		<div>
+			{items.map((item, i) => (
+				<span key={item.label}>
+					{i > 0 ? "; " : ""}
+					<LabeledValue label={item.label} value={item.value} />
+				</span>
+			))}
+		</div>
+	);
+}
+
+function SpellMeta({ spell }: Readonly<{ spell: SpellReference }>) {
+	const hasTraditions =
+		spell.traditions !== undefined && spell.traditions.length > 0;
+	return (
+		<div className="space-y-0.5 text-xs">
+			{spell.rank === undefined ? null : (
+				<div>
+					<span className="font-semibold">{formatRank(spell.rank)}</span>
+					{hasTraditions ? (
+						<span className="text-muted-foreground">
+							{" "}
+							({spell.traditions?.join(", ")})
+						</span>
+					) : null}
+				</div>
+			)}
+			<SpellRangeLine spell={spell} />
+			{spell.duration ? (
+				<div>
+					<LabeledValue label="Duration" value={spell.duration} />
+				</div>
+			) : null}
+			{spell.defense ? (
+				<div>
+					<LabeledValue label="Defense" value={spell.defense} />
+				</div>
+			) : null}
+		</div>
+	);
+}
+
+function SpellDetailContent({ spell }: Readonly<{ spell: SpellReference }>) {
+	return (
+		<div className="space-y-2 text-sm">
+			<SpellHeader spell={spell} />
+			<SpellTraits traits={spell.traits ?? []} />
+			<SpellMeta spell={spell} />
+			{spell.description ? (
+				<RichDescription
+					text={spell.description}
+					className="whitespace-pre-line text-foreground"
+				/>
+			) : (
+				<p className="text-muted-foreground italic">
+					No description available.
+				</p>
+			)}
+			{spell.heightening ? (
+				<RichDescription
+					text={spell.heightening}
+					className="whitespace-pre-line text-foreground text-xs"
+				/>
+			) : null}
+		</div>
+	);
+}
+
+export function SpellDetailPopover({
+	spell,
+	anchorRect,
+	onClose,
+}: Readonly<SpellDetailPopoverProps>) {
+	return (
+		<DetailPopover
+			anchorRect={anchorRect}
+			onClose={onClose}
+			ariaLabel={`Spell details: ${spell.name}`}
+		>
+			<SpellDetailContent spell={spell} />
+		</DetailPopover>
+	);
+}

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

@@ -1,8 +1,17 @@
-import type { Creature, CreatureId } from "@initiative/domain";
+import type {
+	AnyCreature,
+	Combatant,
+	CombatantId,
+	Creature,
+	CreatureId,
+	Pf2eCreature,
+} from "@initiative/domain";
+import { applyPf2eAdjustment } from "@initiative/domain";
 import { PanelRightClose, Pin, PinOff } from "lucide-react";
 import type { ReactNode } from "react";
 import { useEffect, useState } from "react";
 import { useBestiaryContext } from "../contexts/bestiary-context.js";
+import { useEncounterContext } from "../contexts/encounter-context.js";
 import { useSidePanelContext } from "../contexts/side-panel-context.js";
 import { useSwipeToDismiss } from "../hooks/use-swipe-to-dismiss.js";
 import { cn } from "../lib/utils.js";
@@ -11,6 +20,7 @@ import { DndStatBlock } from "./dnd-stat-block.js";
 import { Pf2eStatBlock } from "./pf2e-stat-block.js";
 import { SourceFetchPrompt } from "./source-fetch-prompt.js";
 import { SourceManager } from "./source-manager.js";
+import { Toast } from "./toast.js";
 import { Button } from "./ui/button.js";
 
 interface StatBlockPanelProps {
@@ -215,6 +225,7 @@ function MobileDrawer({
 function usePanelRole(panelRole: "browse" | "pinned") {
 	const sidePanel = useSidePanelContext();
 	const { getCreature } = useBestiaryContext();
+	const { encounter, setCreatureAdjustment } = useEncounterContext();
 
 	const creatureId =
 		panelRole === "browse"
@@ -222,10 +233,18 @@ function usePanelRole(panelRole: "browse" | "pinned") {
 			: sidePanel.pinnedCreatureId;
 	const creature = creatureId ? (getCreature(creatureId) ?? null) : null;
 
+	const combatantId =
+		panelRole === "browse" ? sidePanel.selectedCombatantId : null;
+	const combatant = combatantId
+		? (encounter.combatants.find((c) => c.id === combatantId) ?? null)
+		: null;
+
 	const isBrowse = panelRole === "browse";
 	return {
 		creatureId,
 		creature,
+		combatant,
+		setCreatureAdjustment,
 		isCollapsed: isBrowse ? sidePanel.isRightPanelCollapsed : false,
 		onToggleCollapse: isBrowse ? sidePanel.toggleCollapse : () => {},
 		onDismiss: isBrowse ? sidePanel.dismissPanel : () => {},
@@ -237,14 +256,42 @@ function usePanelRole(panelRole: "browse" | "pinned") {
 	};
 }
 
+function renderStatBlock(
+	creature: AnyCreature,
+	combatant: Combatant | null,
+	setCreatureAdjustment: (
+		id: CombatantId,
+		adj: "weak" | "elite" | undefined,
+		base: Pf2eCreature,
+	) => void,
+) {
+	if ("system" in creature && creature.system === "pf2e") {
+		const baseCreature = creature;
+		const adjusted = combatant?.creatureAdjustment
+			? applyPf2eAdjustment(baseCreature, combatant.creatureAdjustment)
+			: baseCreature;
+		return (
+			<Pf2eStatBlock
+				creature={adjusted}
+				adjustment={combatant?.creatureAdjustment}
+				combatantId={combatant?.id}
+				baseCreature={baseCreature}
+				onSetAdjustment={setCreatureAdjustment}
+			/>
+		);
+	}
+	return <DndStatBlock creature={creature as Creature} />;
+}
+
 export function StatBlockPanel({
 	panelRole,
 	side,
 }: Readonly<StatBlockPanelProps>) {
-	const { isSourceCached } = useBestiaryContext();
 	const {
 		creatureId,
 		creature,
+		combatant,
+		setCreatureAdjustment,
 		isCollapsed,
 		onToggleCollapse,
 		onDismiss,
@@ -260,6 +307,7 @@ export function StatBlockPanel({
 	);
 	const [needsFetch, setNeedsFetch] = useState(false);
 	const [checkingCache, setCheckingCache] = useState(false);
+	const [skippedToast, setSkippedToast] = useState<string | null>(null);
 
 	useEffect(() => {
 		const mq = globalThis.matchMedia("(min-width: 1024px)");
@@ -280,19 +328,23 @@ export function StatBlockPanel({
 			return;
 		}
 
-		setCheckingCache(true);
+		// Show fetch prompt both when source is uncached AND when the source is
-		void isSourceCached(sourceCode).then((cached) => {
+		// cached but this specific creature is missing (e.g. skipped by ad blocker).
-			setNeedsFetch(!cached);
+		setNeedsFetch(true);
-			setCheckingCache(false);
+		setCheckingCache(false);
-		});
+	}, [creatureId, creature]);
-	}, [creatureId, creature, isSourceCached]);
 
 	if (!creatureId && !bulkImportMode && !sourceManagerMode) return null;
 
 	const sourceCode = creatureId ? extractSourceCode(creatureId) : "";
 
-	const handleSourceLoaded = () => {
+	const handleSourceLoaded = (skippedNames: string[]) => {
-		setNeedsFetch(false);
+		if (skippedNames.length > 0) {
+			const names = skippedNames.join(", ");
+			setSkippedToast(
+				`${skippedNames.length} creature(s) skipped (ad blocker?): ${names}`,
+			);
+		}
 	};
 
 	const renderContent = () => {
@@ -311,10 +363,7 @@ export function StatBlockPanel({
 		}
 
 		if (creature) {
-			if ("system" in creature && creature.system === "pf2e") {
+			return renderStatBlock(creature, combatant, setCreatureAdjustment);
-				return <Pf2eStatBlock creature={creature} />;
-			}
-			return <DndStatBlock creature={creature as Creature} />;
 		}
 
 		if (needsFetch && sourceCode) {
@@ -338,24 +387,36 @@ export function StatBlockPanel({
 	else if (bulkImportMode) fallbackName = "Import All Sources";
 	const creatureName = creature?.name ?? fallbackName;
 
+	const toast = skippedToast ? (
+		<Toast message={skippedToast} onDismiss={() => setSkippedToast(null)} />
+	) : null;
+
 	if (isDesktop) {
 		return (
-			<DesktopPanel
+			<>
-				isCollapsed={isCollapsed}
+				<DesktopPanel
-				side={side}
+					isCollapsed={isCollapsed}
-				creatureName={creatureName}
+					side={side}
-				panelRole={panelRole}
+					creatureName={creatureName}
-				showPinButton={showPinButton}
+					panelRole={panelRole}
-				onToggleCollapse={onToggleCollapse}
+					showPinButton={showPinButton}
-				onPin={onPin}
+					onToggleCollapse={onToggleCollapse}
-				onUnpin={onUnpin}
+					onPin={onPin}
-			>
+					onUnpin={onUnpin}
-				{renderContent()}
+				>
-			</DesktopPanel>
+					{renderContent()}
+				</DesktopPanel>
+				{toast}
+			</>
 		);
 	}
 
 	if (panelRole === "pinned" || isCollapsed) return null;
 
-	return <MobileDrawer onDismiss={onDismiss}>{renderContent()}</MobileDrawer>;
+	return (
+		<>
+			<MobileDrawer onDismiss={onDismiss}>{renderContent()}</MobileDrawer>
+			{toast}
+		</>
+	);
 }

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

@@ -3,6 +3,7 @@ import type {
 	TraitBlock,
 	TraitSegment,
 } from "@initiative/domain";
+import { RichDescription } from "./rich-description.js";
 
 export function PropertyLine({
 	label,
@@ -39,20 +40,22 @@ function TraitSegments({
 			{segments.map((seg, i) => {
 				if (seg.type === "text") {
 					return (
-						<span key={segmentKey(seg)}>
+						<RichDescription
-							{i === 0 ? ` ${seg.value}` : seg.value}
+							key={segmentKey(seg)}
-						</span>
+							text={i === 0 ? ` ${seg.value}` : seg.value}
+							className="inline whitespace-pre-line"
+						/>
 					);
 				}
 				return (
 					<div key={segmentKey(seg)} className="mt-1 space-y-0.5">
 						{seg.items.map((item) => (
-							<p key={item.label ?? item.text}>
+							<div key={item.label ?? item.text}>
 								{item.label != null && (
 									<span className="font-semibold">{item.label}. </span>
 								)}
-								{item.text}
+								<RichDescription text={item.text} className="inline" />
-							</p>
+							</div>
 						))}
 					</div>
 				);
@@ -61,15 +64,19 @@ function TraitSegments({
 	);
 }
 
-const ACTION_DIAMOND = "M50 2 L96 50 L50 98 L4 50 Z M48 28 L78 50 L48 72 Z";
+const ACTION_DIAMOND = "M50 2 L96 50 L50 98 L4 50 Z M48 27 L71 50 L48 73 Z";
 const ACTION_DIAMOND_SOLID = "M50 2 L96 50 L50 98 L4 50 Z";
+const ACTION_DIAMOND_OUTLINE =
+	"M90 2 L136 50 L90 98 L44 50 Z M90 29 L111 50 L90 71 L69 50 Z";
 const FREE_ACTION_DIAMOND =
 	"M50 2 L96 50 L50 98 L4 50 Z M50 12 L12 50 L50 88 L88 50 Z";
-const FREE_ACTION_CHEVRON = "M48 28 L78 50 L48 72 Z";
+const FREE_ACTION_CHEVRON = "M48 27 L71 50 L48 73 Z";
 const REACTION_ARROW =
 	"M75 15 A42 42 0 1 0 85 55 L72 55 A30 30 0 1 1 65 25 L65 40 L92 20 L65 0 L65 15 Z";
 
-function ActivityIcon({ activity }: Readonly<{ activity: ActivityCost }>) {
+export function ActivityIcon({
+	activity,
+}: Readonly<{ activity: ActivityCost }>) {
 	const cls = "inline-block h-[1em] align-[-0.1em]";
 	if (activity.unit === "free") {
 		return (
@@ -101,7 +108,7 @@ function ActivityIcon({ activity }: Readonly<{ activity: ActivityCost }>) {
 			<svg aria-hidden="true" className={cls} viewBox="0 0 140 100">
 				<path d={ACTION_DIAMOND_SOLID} fill="currentColor" />
 				<path
-					d="M90 2 L136 50 L90 98 L44 50 Z M88 28 L118 50 L88 72 Z"
+					d={ACTION_DIAMOND_OUTLINE}
 					fill="currentColor"
 					fillRule="evenodd"
 				/>
@@ -113,7 +120,7 @@ function ActivityIcon({ activity }: Readonly<{ activity: ActivityCost }>) {
 			<path d={ACTION_DIAMOND_SOLID} fill="currentColor" />
 			<path d="M90 2 L136 50 L90 98 L44 50 Z" fill="currentColor" />
 			<path
-				d="M130 2 L176 50 L130 98 L84 50 Z M128 28 L158 50 L128 72 Z"
+				d="M130 2 L176 50 L130 98 L84 50 Z M130 29 L151 50 L130 71 L109 50 Z"
 				fill="currentColor"
 				fillRule="evenodd"
 			/>
@@ -134,6 +141,7 @@ export function TraitEntry({ trait }: Readonly<{ trait: TraitBlock }>) {
 					</>
 				) : null}
 			</span>
+			{trait.frequency ? ` (${trait.frequency})` : null}
 			{trait.trigger ? (
 				<>
 					{" "}

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

@@ -0,0 +1,238 @@
+import type { Pf2eCreature } from "@initiative/domain";
+import {
+	combatantId,
+	creatureId,
+	EMPTY_UNDO_REDO_STATE,
+} from "@initiative/domain";
+import { describe, expect, it } from "vitest";
+import { type EncounterState, encounterReducer } from "../use-encounter.js";
+
+const BASE_CREATURE: Pf2eCreature = {
+	system: "pf2e",
+	id: creatureId("b1:goblin-warrior"),
+	name: "Goblin Warrior",
+	source: "B1",
+	sourceDisplayName: "Bestiary",
+	level: 5,
+	traits: ["humanoid"],
+	perception: 12,
+	abilityMods: { str: 4, dex: 2, con: 3, int: 0, wis: 1, cha: -1 },
+	ac: 22,
+	saveFort: 14,
+	saveRef: 11,
+	saveWill: 9,
+	hp: 75,
+	speed: "25 feet",
+};
+
+function stateWithCreature(
+	name: string,
+	hp: number,
+	ac: number,
+	adj?: "weak" | "elite",
+): EncounterState {
+	return {
+		encounter: {
+			combatants: [
+				{
+					id: combatantId("c-1"),
+					name,
+					maxHp: hp,
+					currentHp: hp,
+					ac,
+					creatureId: creatureId("b1:goblin-warrior"),
+					...(adj !== undefined && { creatureAdjustment: adj }),
+				},
+			],
+			activeIndex: 0,
+			roundNumber: 1,
+		},
+		undoRedoState: EMPTY_UNDO_REDO_STATE,
+		events: [],
+		nextId: 1,
+		lastCreatureId: null,
+	};
+}
+
+describe("set-creature-adjustment", () => {
+	it("Normal → Elite: HP increases, AC +2, name prefixed, adjustment stored", () => {
+		const state = stateWithCreature("Goblin Warrior", 75, 22);
+		const next = encounterReducer(state, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-1"),
+			adjustment: "elite",
+			baseCreature: BASE_CREATURE,
+		});
+
+		const c = next.encounter.combatants[0];
+		expect(c.maxHp).toBe(95); // 75 + 20 (level 5 bracket)
+		expect(c.currentHp).toBe(95);
+		expect(c.ac).toBe(24);
+		expect(c.name).toBe("Elite Goblin Warrior");
+		expect(c.creatureAdjustment).toBe("elite");
+	});
+
+	it("Normal → Weak: HP decreases, AC −2, name prefixed", () => {
+		const state = stateWithCreature("Goblin Warrior", 75, 22);
+		const next = encounterReducer(state, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-1"),
+			adjustment: "weak",
+			baseCreature: BASE_CREATURE,
+		});
+
+		const c = next.encounter.combatants[0];
+		expect(c.maxHp).toBe(55); // 75 - 20
+		expect(c.currentHp).toBe(55);
+		expect(c.ac).toBe(20);
+		expect(c.name).toBe("Weak Goblin Warrior");
+		expect(c.creatureAdjustment).toBe("weak");
+	});
+
+	it("Elite → Normal: HP/AC/name revert", () => {
+		const state = stateWithCreature("Elite Goblin Warrior", 95, 24, "elite");
+		const next = encounterReducer(state, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-1"),
+			adjustment: undefined,
+			baseCreature: BASE_CREATURE,
+		});
+
+		const c = next.encounter.combatants[0];
+		expect(c.maxHp).toBe(75);
+		expect(c.currentHp).toBe(75);
+		expect(c.ac).toBe(22);
+		expect(c.name).toBe("Goblin Warrior");
+		expect(c.creatureAdjustment).toBeUndefined();
+	});
+
+	it("Elite → Weak: full swing applied in one step", () => {
+		const state = stateWithCreature("Elite Goblin Warrior", 95, 24, "elite");
+		const next = encounterReducer(state, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-1"),
+			adjustment: "weak",
+			baseCreature: BASE_CREATURE,
+		});
+
+		const c = next.encounter.combatants[0];
+		expect(c.maxHp).toBe(55); // 95 - 40 (revert +20, apply -20)
+		expect(c.currentHp).toBe(55);
+		expect(c.ac).toBe(20); // 24 - 4
+		expect(c.name).toBe("Weak Goblin Warrior");
+		expect(c.creatureAdjustment).toBe("weak");
+	});
+
+	it("toggle with damage taken: currentHp shifted by delta, clamped to 0", () => {
+		const state: EncounterState = {
+			...stateWithCreature("Goblin Warrior", 75, 22),
+		};
+		// Simulate damage: currentHp = 10
+		const damaged: EncounterState = {
+			...state,
+			encounter: {
+				...state.encounter,
+				combatants: [{ ...state.encounter.combatants[0], currentHp: 10 }],
+			},
+		};
+
+		const next = encounterReducer(damaged, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-1"),
+			adjustment: "weak",
+			baseCreature: BASE_CREATURE,
+		});
+
+		const c = next.encounter.combatants[0];
+		expect(c.maxHp).toBe(55);
+		// currentHp = 10 - 20 = -10, clamped to 0
+		expect(c.currentHp).toBe(0);
+	});
+
+	it("toggle with temp HP: temp HP unchanged", () => {
+		const state = stateWithCreature("Goblin Warrior", 75, 22);
+		const withTemp: EncounterState = {
+			...state,
+			encounter: {
+				...state.encounter,
+				combatants: [{ ...state.encounter.combatants[0], tempHp: 10 }],
+			},
+		};
+
+		const next = encounterReducer(withTemp, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-1"),
+			adjustment: "elite",
+			baseCreature: BASE_CREATURE,
+		});
+
+		expect(next.encounter.combatants[0].tempHp).toBe(10);
+	});
+
+	it("name with auto-number suffix: 'Goblin 2' → 'Elite Goblin 2'", () => {
+		const state = stateWithCreature("Goblin 2", 75, 22);
+		const next = encounterReducer(state, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-1"),
+			adjustment: "elite",
+			baseCreature: BASE_CREATURE,
+		});
+
+		expect(next.encounter.combatants[0].name).toBe("Elite Goblin 2");
+	});
+
+	it("manually renamed combatant: prefix not found, name unchanged", () => {
+		// Combatant was elite but manually renamed to "Big Boss"
+		const state = stateWithCreature("Big Boss", 95, 24, "elite");
+		const next = encounterReducer(state, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-1"),
+			adjustment: undefined,
+			baseCreature: BASE_CREATURE,
+		});
+
+		// No "Elite " prefix found, so name stays as is
+		expect(next.encounter.combatants[0].name).toBe("Big Boss");
+	});
+
+	it("emits CreatureAdjustmentSet event", () => {
+		const state = stateWithCreature("Goblin Warrior", 75, 22);
+		const next = encounterReducer(state, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-1"),
+			adjustment: "elite",
+			baseCreature: BASE_CREATURE,
+		});
+
+		const event = next.events.find((e) => e.type === "CreatureAdjustmentSet");
+		expect(event).toEqual({
+			type: "CreatureAdjustmentSet",
+			combatantId: "c-1",
+			adjustment: "elite",
+		});
+	});
+
+	it("returns unchanged state when adjustment is the same", () => {
+		const state = stateWithCreature("Elite Goblin Warrior", 95, 24, "elite");
+		const next = encounterReducer(state, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-1"),
+			adjustment: "elite",
+			baseCreature: BASE_CREATURE,
+		});
+
+		expect(next).toBe(state);
+	});
+
+	it("returns unchanged state for unknown combatant", () => {
+		const state = stateWithCreature("Goblin Warrior", 75, 22);
+		const next = encounterReducer(state, {
+			type: "set-creature-adjustment",
+			id: combatantId("c-99"),
+			adjustment: "elite",
+			baseCreature: BASE_CREATURE,
+		});
+
+		expect(next).toBe(state);
+	});
+});

apps/web/src/hooks/use-auto-stat-block.ts

@@ -6,8 +6,8 @@ export function useAutoStatBlock(): void {
 	const { encounter } = useEncounterContext();
 	const { panelView, updateCreature } = useSidePanelContext();
 
-	const activeCreatureId =
+	const activeCombatant = encounter.combatants[encounter.activeIndex];
-		encounter.combatants[encounter.activeIndex]?.creatureId;
+	const activeCreatureId = activeCombatant?.creatureId;
 	const prevActiveIndexRef = useRef(encounter.activeIndex);
 
 	useEffect(() => {
@@ -21,7 +21,13 @@ export function useAutoStatBlock(): void {
 			activeCreatureId &&
 			panelView.mode === "creature"
 		) {
-			updateCreature(activeCreatureId);
+			updateCreature(activeCreatureId, activeCombatant.id);
 		}
-	}, [encounter.activeIndex, activeCreatureId, panelView.mode, updateCreature]);
+	}, [
+		encounter.activeIndex,
+		activeCreatureId,
+		activeCombatant?.id,
+		panelView.mode,
+		updateCreature,
+	]);
 }

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

@@ -28,7 +28,10 @@ interface BestiaryHook {
 	getCreature: (id: CreatureId) => AnyCreature | undefined;
 	isLoaded: boolean;
 	isSourceCached: (sourceCode: string) => Promise<boolean>;
-	fetchAndCacheSource: (sourceCode: string, url: string) => Promise<void>;
+	fetchAndCacheSource: (
+		sourceCode: string,
+		url: string,
+	) => Promise<{ skippedNames: string[] }>;
 	uploadAndCacheSource: (
 		sourceCode: string,
 		jsonData: unknown,
@@ -36,6 +39,108 @@ interface BestiaryHook {
 	refreshCache: () => Promise<void>;
 }
 
+interface BatchResult {
+	readonly responses: unknown[];
+	readonly failed: string[];
+}
+
+async function fetchJson(url: string, path: string): Promise<unknown> {
+	const response = await fetch(url);
+	if (!response.ok) {
+		throw new Error(
+			`Failed to fetch ${path}: ${response.status} ${response.statusText}`,
+		);
+	}
+	return response.json();
+}
+
+async function fetchWithRetry(
+	url: string,
+	path: string,
+	retries = 2,
+): Promise<unknown> {
+	try {
+		return await fetchJson(url, path);
+	} catch (error) {
+		if (retries <= 0) throw error;
+		await new Promise<void>((r) => setTimeout(r, 500));
+		return fetchWithRetry(url, path, retries - 1);
+	}
+}
+
+async function fetchBatch(
+	baseUrl: string,
+	paths: string[],
+): Promise<BatchResult> {
+	const settled = await Promise.allSettled(
+		paths.map((path) => fetchWithRetry(`${baseUrl}${path}`, path)),
+	);
+	const responses: unknown[] = [];
+	const failed: string[] = [];
+	for (let i = 0; i < settled.length; i++) {
+		const result = settled[i];
+		if (result.status === "fulfilled") {
+			responses.push(result.value);
+		} else {
+			failed.push(paths[i]);
+		}
+	}
+	return { responses, failed };
+}
+
+async function fetchInBatches(
+	paths: string[],
+	baseUrl: string,
+	concurrency: number,
+): Promise<BatchResult> {
+	const batches: string[][] = [];
+	for (let i = 0; i < paths.length; i += concurrency) {
+		batches.push(paths.slice(i, i + concurrency));
+	}
+	const accumulated = await batches.reduce<Promise<BatchResult>>(
+		async (prev, batch) => {
+			const acc = await prev;
+			const result = await fetchBatch(baseUrl, batch);
+			return {
+				responses: [...acc.responses, ...result.responses],
+				failed: [...acc.failed, ...result.failed],
+			};
+		},
+		Promise.resolve({ responses: [], failed: [] }),
+	);
+	return accumulated;
+}
+
+interface Pf2eFetchResult {
+	creatures: AnyCreature[];
+	skippedNames: string[];
+}
+
+async function fetchPf2eSource(
+	paths: string[],
+	url: string,
+	sourceCode: string,
+	displayName: string,
+	resolveNames: (failedPaths: string[]) => Map<string, string>,
+): Promise<Pf2eFetchResult> {
+	const baseUrl = url.endsWith("/") ? url : `${url}/`;
+	const { responses, failed } = await fetchInBatches(paths, baseUrl, 6);
+	if (responses.length === 0) {
+		throw new Error(
+			`Failed to fetch any creatures (${failed.length} failed). This may be caused by an ad blocker — try disabling it for this site or use file upload instead.`,
+		);
+	}
+	const nameMap = failed.length > 0 ? resolveNames(failed) : new Map();
+	const skippedNames = failed.map((p) => nameMap.get(p) ?? p);
+	if (skippedNames.length > 0) {
+		console.warn("Skipped creatures (ad blocker?):", skippedNames);
+	}
+	return {
+		creatures: normalizeFoundryCreatures(responses, sourceCode, displayName),
+		skippedNames,
+	};
+}
+
 export function useBestiary(): BestiaryHook {
 	const { bestiaryCache, bestiaryIndex, pf2eBestiaryIndex } = useAdapters();
 	const { edition } = useRulesEditionContext();
@@ -108,30 +213,25 @@ export function useBestiary(): BestiaryHook {
 	);
 
 	const fetchAndCacheSource = useCallback(
-		async (sourceCode: string, url: string): Promise<void> => {
+		async (
+			sourceCode: string,
+			url: string,
+		): Promise<{ skippedNames: string[] }> => {
 			let creatures: AnyCreature[];
+			let skippedNames: string[] = [];
 
 			if (edition === "pf2e") {
-				// PF2e: url is a base URL; fetch each creature file in parallel
 				const paths = pf2eBestiaryIndex.getCreaturePathsForSource(sourceCode);
-				const baseUrl = url.endsWith("/") ? url : `${url}/`;
-				const responses = await Promise.all(
-					paths.map(async (path) => {
-						const response = await fetch(`${baseUrl}${path}`);
-						if (!response.ok) {
-							throw new Error(
-								`Failed to fetch ${path}: ${response.status} ${response.statusText}`,
-							);
-						}
-						return response.json();
-					}),
-				);
 				const displayName = pf2eBestiaryIndex.getSourceDisplayName(sourceCode);
-				creatures = normalizeFoundryCreatures(
+				const result = await fetchPf2eSource(
-					responses,
+					paths,
+					url,
 					sourceCode,
 					displayName,
+					pf2eBestiaryIndex.getCreatureNamesByPaths,
 				);
+				creatures = result.creatures;
+				skippedNames = result.skippedNames;
 			} else {
 				const response = await fetch(url);
 				if (!response.ok) {
@@ -160,6 +260,7 @@ export function useBestiary(): BestiaryHook {
 				}
 				return next;
 			});
+			return { skippedNames };
 		},
 		[bestiaryCache, bestiaryIndex, pf2eBestiaryIndex, edition, system],
 	);

apps/web/src/hooks/use-bulk-import.ts

@@ -22,7 +22,10 @@ interface BulkImportHook {
 	state: BulkImportState;
 	startImport: (
 		baseUrl: string,
-		fetchAndCacheSource: (sourceCode: string, url: string) => Promise<void>,
+		fetchAndCacheSource: (
+			sourceCode: string,
+			url: string,
+		) => Promise<{ skippedNames: string[] }>,
 		isSourceCached: (sourceCode: string) => Promise<boolean>,
 		refreshCache: () => Promise<void>,
 	) => void;
@@ -39,7 +42,10 @@ export function useBulkImport(): BulkImportHook {
 	const startImport = useCallback(
 		(
 			baseUrl: string,
-			fetchAndCacheSource: (sourceCode: string, url: string) => Promise<void>,
+			fetchAndCacheSource: (
+				sourceCode: string,
+				url: string,
+			) => Promise<{ skippedNames: string[] }>,
 			isSourceCached: (sourceCode: string) => Promise<boolean>,
 			refreshCache: () => Promise<void>,
 		) => {

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

@@ -1,6 +1,7 @@
 import type { EncounterStore, UndoRedoStore } from "@initiative/application";
 import {
 	addCombatantUseCase,
+	addPersistentDamageUseCase,
 	adjustHpUseCase,
 	advanceTurnUseCase,
 	clearEncounterUseCase,
@@ -8,6 +9,7 @@ import {
 	editCombatantUseCase,
 	redoUseCase,
 	removeCombatantUseCase,
+	removePersistentDamageUseCase,
 	retreatTurnUseCase,
 	setAcUseCase,
 	setConditionValueUseCase,
@@ -28,12 +30,16 @@ import type {
 	DomainError,
 	DomainEvent,
 	Encounter,
+	PersistentDamageType,
+	Pf2eCreature,
 	PlayerCharacter,
 	UndoRedoState,
 } from "@initiative/domain";
 import {
+	acDelta,
 	clearHistory,
 	combatantId,
+	hpDelta,
 	isDomainError,
 	creatureId as makeCreatureId,
 	pushUndo,
@@ -75,6 +81,17 @@ type EncounterAction =
 			conditionId: ConditionId;
 	  }
 	| { type: "toggle-concentration"; id: CombatantId }
+	| {
+			type: "add-persistent-damage";
+			id: CombatantId;
+			damageType: PersistentDamageType;
+			formula: string;
+	  }
+	| {
+			type: "remove-persistent-damage";
+			id: CombatantId;
+			damageType: PersistentDamageType;
+	  }
 	| { type: "clear-encounter" }
 	| { type: "undo" }
 	| { type: "redo" }
@@ -84,6 +101,12 @@ type EncounterAction =
 			entry: SearchResult;
 			count: number;
 	  }
+	| {
+			type: "set-creature-adjustment";
+			id: CombatantId;
+			adjustment: "weak" | "elite" | undefined;
+			baseCreature: Pf2eCreature;
+	  }
 	| { type: "add-from-player-character"; pc: PlayerCharacter }
 	| {
 			type: "import";
@@ -279,6 +302,76 @@ function handleAddFromPlayerCharacter(
 	};
 }
 
+function applyNamePrefix(
+	name: string,
+	oldAdj: "weak" | "elite" | undefined,
+	newAdj: "weak" | "elite" | undefined,
+): string {
+	let base = name;
+	if (oldAdj === "weak" && name.startsWith("Weak ")) base = name.slice(5);
+	else if (oldAdj === "elite" && name.startsWith("Elite "))
+		base = name.slice(6);
+	if (newAdj === "weak") return `Weak ${base}`;
+	if (newAdj === "elite") return `Elite ${base}`;
+	return base;
+}
+
+function handleSetCreatureAdjustment(
+	state: EncounterState,
+	id: CombatantId,
+	adjustment: "weak" | "elite" | undefined,
+	baseCreature: Pf2eCreature,
+): EncounterState {
+	const combatant = state.encounter.combatants.find((c) => c.id === id);
+	if (!combatant) return state;
+
+	const oldAdj = combatant.creatureAdjustment;
+	if (oldAdj === adjustment) return state;
+
+	const baseLevel = baseCreature.level;
+	const oldHpDelta = oldAdj ? hpDelta(baseLevel, oldAdj) : 0;
+	const newHpDelta = adjustment ? hpDelta(baseLevel, adjustment) : 0;
+	const netHpDelta = newHpDelta - oldHpDelta;
+
+	const oldAcDelta = oldAdj ? acDelta(oldAdj) : 0;
+	const newAcDelta = adjustment ? acDelta(adjustment) : 0;
+	const netAcDelta = newAcDelta - oldAcDelta;
+
+	const newMaxHp =
+		combatant.maxHp === undefined ? undefined : combatant.maxHp + netHpDelta;
+	const newCurrentHp =
+		combatant.currentHp === undefined || newMaxHp === undefined
+			? undefined
+			: Math.max(0, Math.min(combatant.currentHp + netHpDelta, newMaxHp));
+	const newAc =
+		combatant.ac === undefined ? undefined : combatant.ac + netAcDelta;
+	const newName = applyNamePrefix(combatant.name, oldAdj, adjustment);
+
+	const updatedCombatant: typeof combatant = {
+		...combatant,
+		name: newName,
+		...(newMaxHp !== undefined && { maxHp: newMaxHp }),
+		...(newCurrentHp !== undefined && { currentHp: newCurrentHp }),
+		...(newAc !== undefined && { ac: newAc }),
+		...(adjustment === undefined
+			? { creatureAdjustment: undefined }
+			: { creatureAdjustment: adjustment }),
+	};
+
+	const combatants = state.encounter.combatants.map((c) =>
+		c.id === id ? updatedCombatant : c,
+	);
+
+	return {
+		...state,
+		encounter: { ...state.encounter, combatants },
+		events: [
+			...state.events,
+			{ type: "CreatureAdjustmentSet", combatantId: id, adjustment },
+		],
+	};
+}
+
 // -- Reducer --
 
 export function encounterReducer(
@@ -310,6 +403,13 @@ export function encounterReducer(
 				lastCreatureId: null,
 			};
 		}
+		case "set-creature-adjustment":
+			return handleSetCreatureAdjustment(
+				state,
+				action.id,
+				action.adjustment,
+				action.baseCreature,
+			);
 		case "add-from-bestiary":
 			return handleAddFromBestiary(state, action.entry, 1);
 		case "add-multiple-from-bestiary":
@@ -341,6 +441,8 @@ function dispatchEncounterAction(
 		| { type: "set-condition-value" }
 		| { type: "decrement-condition" }
 		| { type: "toggle-concentration" }
+		| { type: "add-persistent-damage" }
+		| { type: "remove-persistent-damage" }
 	>,
 ): EncounterState {
 	const { store, getEncounter } = makeStoreFromState(state);
@@ -402,6 +504,21 @@ function dispatchEncounterAction(
 		case "toggle-concentration":
 			result = toggleConcentrationUseCase(store, action.id);
 			break;
+		case "add-persistent-damage":
+			result = addPersistentDamageUseCase(
+				store,
+				action.id,
+				action.damageType,
+				action.formula,
+			);
+			break;
+		case "remove-persistent-damage":
+			result = removePersistentDamageUseCase(
+				store,
+				action.id,
+				action.damageType,
+			);
+			break;
 	}
 
 	if (isDomainError(result)) return state;
@@ -421,7 +538,10 @@ function dispatchEncounterAction(
 export function useEncounter() {
 	const { encounterPersistence, undoRedoPersistence } = useAdapters();
 	const [state, dispatch] = useReducer(encounterReducer, null, () =>
-		initializeState(encounterPersistence.load, undoRedoPersistence.load),
+		initializeState(
+			() => encounterPersistence.load(),
+			() => undoRedoPersistence.load(),
+		),
 	);
 	const { encounter, undoRedoState, events } = state;
 
@@ -562,6 +682,30 @@ export function useEncounter() {
 			(id: CombatantId) => dispatch({ type: "toggle-concentration", id }),
 			[],
 		),
+		addPersistentDamage: useCallback(
+			(id: CombatantId, damageType: PersistentDamageType, formula: string) =>
+				dispatch({ type: "add-persistent-damage", id, damageType, formula }),
+			[],
+		),
+		removePersistentDamage: useCallback(
+			(id: CombatantId, damageType: PersistentDamageType) =>
+				dispatch({ type: "remove-persistent-damage", id, damageType }),
+			[],
+		),
+		setCreatureAdjustment: useCallback(
+			(
+				id: CombatantId,
+				adjustment: "weak" | "elite" | undefined,
+				baseCreature: Pf2eCreature,
+			) =>
+				dispatch({
+					type: "set-creature-adjustment",
+					id,
+					adjustment,
+					baseCreature,
+				}),
+			[],
+		),
 		clearEncounter: useCallback(
 			() => dispatch({ type: "clear-encounter" }),
 			[],

apps/web/src/hooks/use-side-panel-state.ts

@@ -1,15 +1,16 @@
-import type { CreatureId } from "@initiative/domain";
+import type { CombatantId, CreatureId } from "@initiative/domain";
 import { useCallback, useEffect, useState } from "react";
 
 type PanelView =
 	| { mode: "closed" }
-	| { mode: "creature"; creatureId: CreatureId }
+	| { mode: "creature"; creatureId: CreatureId; combatantId?: CombatantId }
 	| { mode: "bulk-import" }
 	| { mode: "source-manager" };
 
 interface SidePanelState {
 	panelView: PanelView;
 	selectedCreatureId: CreatureId | null;
+	selectedCombatantId: CombatantId | null;
 	bulkImportMode: boolean;
 	sourceManagerMode: boolean;
 	isRightPanelCollapsed: boolean;
@@ -18,8 +19,8 @@ interface SidePanelState {
 }
 
 interface SidePanelActions {
-	showCreature: (creatureId: CreatureId) => void;
+	showCreature: (creatureId: CreatureId, combatantId?: CombatantId) => void;
-	updateCreature: (creatureId: CreatureId) => void;
+	updateCreature: (creatureId: CreatureId, combatantId?: CombatantId) => void;
 	showBulkImport: () => void;
 	showSourceManager: () => void;
 	dismissPanel: () => void;
@@ -48,14 +49,23 @@ export function useSidePanelState(): SidePanelState & SidePanelActions {
 	const selectedCreatureId =
 		panelView.mode === "creature" ? panelView.creatureId : null;
 
-	const showCreature = useCallback((creatureId: CreatureId) => {
+	const selectedCombatantId =
-		setPanelView({ mode: "creature", creatureId });
+		panelView.mode === "creature" ? (panelView.combatantId ?? null) : null;
-		setIsRightPanelCollapsed(false);
-	}, []);
 
-	const updateCreature = useCallback((creatureId: CreatureId) => {
+	const showCreature = useCallback(
-		setPanelView({ mode: "creature", creatureId });
+		(creatureId: CreatureId, combatantId?: CombatantId) => {
-	}, []);
+			setPanelView({ mode: "creature", creatureId, combatantId });
+			setIsRightPanelCollapsed(false);
+		},
+		[],
+	);
+
+	const updateCreature = useCallback(
+		(creatureId: CreatureId, combatantId?: CombatantId) => {
+			setPanelView({ mode: "creature", creatureId, combatantId });
+		},
+		[],
+	);
 
 	const showBulkImport = useCallback(() => {
 		setPanelView({ mode: "bulk-import" });
@@ -90,6 +100,7 @@ export function useSidePanelState(): SidePanelState & SidePanelActions {
 	return {
 		panelView,
 		selectedCreatureId,
+		selectedCombatantId,
 		bulkImportMode: panelView.mode === "bulk-import",
 		sourceManagerMode: panelView.mode === "source-manager",
 		isRightPanelCollapsed,

apps/web/src/hooks/use-swipe-to-dismiss.ts

@@ -70,3 +70,72 @@ export function useSwipeToDismiss(onDismiss: () => void) {
 		handlers: { onTouchStart, onTouchMove, onTouchEnd },
 	};
 }
+
+/**
+ * Vertical (down-only) variant for dismissing bottom sheets via swipe-down.
+ * Mirrors `useSwipeToDismiss` but locks to vertical direction and tracks
+ * the sheet height instead of width.
+ */
+export function useSwipeToDismissDown(onDismiss: () => void) {
+	const [swipe, setSwipe] = useState<SwipeState>({
+		offsetX: 0,
+		isSwiping: false,
+	});
+	const startX = useRef(0);
+	const startY = useRef(0);
+	const startTime = useRef(0);
+	const sheetHeight = useRef(0);
+	const directionLocked = useRef<"horizontal" | "vertical" | null>(null);
+
+	const onTouchStart = useCallback((e: React.TouchEvent) => {
+		const touch = e.touches[0];
+		startX.current = touch.clientX;
+		startY.current = touch.clientY;
+		startTime.current = Date.now();
+		directionLocked.current = null;
+		const el = e.currentTarget as HTMLElement;
+		sheetHeight.current = el.getBoundingClientRect().height;
+	}, []);
+
+	const onTouchMove = useCallback((e: React.TouchEvent) => {
+		const touch = e.touches[0];
+		const dx = touch.clientX - startX.current;
+		const dy = touch.clientY - startY.current;
+
+		if (!directionLocked.current) {
+			if (Math.abs(dx) < 10 && Math.abs(dy) < 10) return;
+			directionLocked.current =
+				Math.abs(dy) > Math.abs(dx) ? "vertical" : "horizontal";
+		}
+
+		if (directionLocked.current === "horizontal") return;
+
+		const clampedY = Math.max(0, dy);
+		// `offsetX` is reused as the vertical offset to keep SwipeState shared.
+		setSwipe({ offsetX: clampedY, isSwiping: true });
+	}, []);
+
+	const onTouchEnd = useCallback(() => {
+		if (directionLocked.current !== "vertical") {
+			setSwipe({ offsetX: 0, isSwiping: false });
+			return;
+		}
+
+		const elapsed = (Date.now() - startTime.current) / 1000;
+		const velocity = swipe.offsetX / elapsed / sheetHeight.current;
+		const ratio =
+			sheetHeight.current > 0 ? swipe.offsetX / sheetHeight.current : 0;
+
+		if (ratio > DISMISS_THRESHOLD || velocity > VELOCITY_THRESHOLD) {
+			onDismiss();
+		}
+
+		setSwipe({ offsetX: 0, isSwiping: false });
+	}, [swipe.offsetX, onDismiss]);
+
+	return {
+		offsetY: swipe.offsetX,
+		isSwiping: swipe.isSwiping,
+		handlers: { onTouchStart, onTouchMove, onTouchEnd },
+	};
+}

apps/web/src/index.css

@@ -103,6 +103,19 @@
 	animation: slide-in-right 200ms ease-out;
 }
 
+@keyframes slide-in-bottom {
+	from {
+		transform: translateY(100%);
+	}
+	to {
+		transform: translateY(0);
+	}
+}
+
+@utility animate-slide-in-bottom {
+	animation: slide-in-bottom 200ms ease-out;
+}
+
 @keyframes confirm-pulse {
 	0% {
 		scale: 1;

package.json

@@ -31,7 +31,7 @@
 		"knip": "knip",
 		"jscpd": "jscpd",
 		"jsinspect": "jsinspect -c .jsinspectrc apps/web/src packages/domain/src packages/application/src",
-		"oxlint": "oxlint --tsconfig apps/web/tsconfig.json --type-aware --deny warnings",
+		"oxlint": "oxlint --tsconfig apps/web/tsconfig.json --type-aware --deny-warnings",
 		"check:ignores": "node scripts/check-lint-ignores.mjs",
 		"check:classnames": "node scripts/check-cn-classnames.mjs",
 		"check:props": "node scripts/check-component-props.mjs",

packages/application/src/add-persistent-damage-use-case.ts

@@ -0,0 +1,20 @@
+import {
+	addPersistentDamage,
+	type CombatantId,
+	type DomainError,
+	type DomainEvent,
+	type PersistentDamageType,
+} from "@initiative/domain";
+import type { EncounterStore } from "./ports.js";
+import { runEncounterAction } from "./run-encounter-action.js";
+
+export function addPersistentDamageUseCase(
+	store: EncounterStore,
+	combatantId: CombatantId,
+	damageType: PersistentDamageType,
+	formula: string,
+): DomainEvent[] | DomainError {
+	return runEncounterAction(store, (encounter) =>
+		addPersistentDamage(encounter, combatantId, damageType, formula),
+	);
+}

packages/application/src/index.ts

@@ -1,4 +1,5 @@
 export { addCombatantUseCase } from "./add-combatant-use-case.js";
+export { addPersistentDamageUseCase } from "./add-persistent-damage-use-case.js";
 export { adjustHpUseCase } from "./adjust-hp-use-case.js";
 export { advanceTurnUseCase } from "./advance-turn-use-case.js";
 export { clearEncounterUseCase } from "./clear-encounter-use-case.js";
@@ -15,6 +16,7 @@ export type {
 } from "./ports.js";
 export { redoUseCase } from "./redo-use-case.js";
 export { removeCombatantUseCase } from "./remove-combatant-use-case.js";
+export { removePersistentDamageUseCase } from "./remove-persistent-damage-use-case.js";
 export { retreatTurnUseCase } from "./retreat-turn-use-case.js";
 export {
 	type RollAllResult,

packages/application/src/remove-persistent-damage-use-case.ts

@@ -0,0 +1,19 @@
+import {
+	type CombatantId,
+	type DomainError,
+	type DomainEvent,
+	type PersistentDamageType,
+	removePersistentDamage,
+} from "@initiative/domain";
+import type { EncounterStore } from "./ports.js";
+import { runEncounterAction } from "./run-encounter-action.js";
+
+export function removePersistentDamageUseCase(
+	store: EncounterStore,
+	combatantId: CombatantId,
+	damageType: PersistentDamageType,
+): DomainEvent[] | DomainError {
+	return runEncounterAction(store, (encounter) =>
+		removePersistentDamage(encounter, combatantId, damageType),
+	);
+}

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

@@ -47,8 +47,8 @@ describe("getConditionDescription", () => {
 				(d.systems.includes("5e") && d.systems.includes("5.5e")),
 		);
 		for (const def of sharedDndConditions) {
-			expect(def.description, `${def.id} missing description`).toBeTruthy();
+			expect(def.description).toBeTruthy();
-			expect(def.description5e, `${def.id} missing description5e`).toBeTruthy();
+			expect(def.description5e).toBeTruthy();
 		}
 	});
 

packages/domain/src/__tests__/persistent-damage.test.ts

@@ -0,0 +1,237 @@
+import { describe, expect, it } from "vitest";
+import {
+	addPersistentDamage,
+	type PersistentDamageType,
+	removePersistentDamage,
+} from "../persistent-damage.js";
+import type { Encounter } from "../types.js";
+import { combatantId } from "../types.js";
+
+const goblinId = combatantId("goblin-1");
+
+function buildEncounter(overrides: Partial<Encounter> = {}): Encounter {
+	return {
+		combatants: [
+			{
+				id: goblinId,
+				name: "Goblin",
+				...overrides.combatants?.[0],
+			},
+		],
+		activeIndex: overrides.activeIndex ?? 0,
+		roundNumber: overrides.roundNumber ?? 1,
+	};
+}
+
+describe("addPersistentDamage", () => {
+	it("adds persistent fire damage to combatant", () => {
+		const encounter = buildEncounter();
+		const result = addPersistentDamage(encounter, goblinId, "fire", "2d6");
+
+		expect(result).not.toHaveProperty("kind");
+		if ("kind" in result) return;
+
+		const target = result.encounter.combatants[0];
+		expect(target.persistentDamage).toEqual([{ type: "fire", formula: "2d6" }]);
+		expect(result.events).toEqual([
+			{
+				type: "PersistentDamageAdded",
+				combatantId: goblinId,
+				damageType: "fire",
+				formula: "2d6",
+			},
+		]);
+	});
+
+	it("replaces existing entry of same type with new formula", () => {
+		const encounter = buildEncounter({
+			combatants: [
+				{
+					id: goblinId,
+					name: "Goblin",
+					persistentDamage: [{ type: "fire", formula: "2d6" }],
+				},
+			],
+		});
+		const result = addPersistentDamage(encounter, goblinId, "fire", "3d6");
+
+		expect(result).not.toHaveProperty("kind");
+		if ("kind" in result) return;
+
+		expect(result.encounter.combatants[0].persistentDamage).toEqual([
+			{ type: "fire", formula: "3d6" },
+		]);
+	});
+
+	it("allows multiple different damage types", () => {
+		const encounter = buildEncounter({
+			combatants: [
+				{
+					id: goblinId,
+					name: "Goblin",
+					persistentDamage: [{ type: "fire", formula: "2d6" }],
+				},
+			],
+		});
+		const result = addPersistentDamage(encounter, goblinId, "bleed", "1d4");
+
+		expect(result).not.toHaveProperty("kind");
+		if ("kind" in result) return;
+
+		expect(result.encounter.combatants[0].persistentDamage).toEqual([
+			{ type: "fire", formula: "2d6" },
+			{ type: "bleed", formula: "1d4" },
+		]);
+	});
+
+	it("sorts entries by definition order", () => {
+		const encounter = buildEncounter({
+			combatants: [
+				{
+					id: goblinId,
+					name: "Goblin",
+					persistentDamage: [{ type: "cold", formula: "1d6" }],
+				},
+			],
+		});
+		const result = addPersistentDamage(encounter, goblinId, "fire", "2d6");
+
+		expect(result).not.toHaveProperty("kind");
+		if ("kind" in result) return;
+
+		const types = result.encounter.combatants[0].persistentDamage?.map(
+			(e) => e.type,
+		);
+		expect(types).toEqual(["fire", "cold"]);
+	});
+
+	it("returns domain error for empty formula", () => {
+		const encounter = buildEncounter();
+		const result = addPersistentDamage(encounter, goblinId, "fire", "  ");
+
+		expect(result).toHaveProperty("kind", "domain-error");
+		if (!("kind" in result)) return;
+		expect(result.code).toBe("empty-formula");
+	});
+
+	it("returns domain error for unknown damage type", () => {
+		const encounter = buildEncounter();
+		const result = addPersistentDamage(
+			encounter,
+			goblinId,
+			"radiant" as PersistentDamageType,
+			"2d6",
+		);
+
+		expect(result).toHaveProperty("kind", "domain-error");
+		if (!("kind" in result)) return;
+		expect(result.code).toBe("unknown-damage-type");
+	});
+
+	it("returns domain error for unknown combatant", () => {
+		const encounter = buildEncounter();
+		const result = addPersistentDamage(
+			encounter,
+			combatantId("nonexistent"),
+			"fire",
+			"2d6",
+		);
+
+		expect(result).toHaveProperty("kind", "domain-error");
+		if (!("kind" in result)) return;
+		expect(result.code).toBe("combatant-not-found");
+	});
+
+	it("trims formula whitespace", () => {
+		const encounter = buildEncounter();
+		const result = addPersistentDamage(encounter, goblinId, "fire", "  2d6  ");
+
+		expect(result).not.toHaveProperty("kind");
+		if ("kind" in result) return;
+
+		expect(result.encounter.combatants[0].persistentDamage?.[0].formula).toBe(
+			"2d6",
+		);
+	});
+
+	it("does not mutate input encounter", () => {
+		const encounter = buildEncounter();
+		const originalCombatants = encounter.combatants;
+		addPersistentDamage(encounter, goblinId, "fire", "2d6");
+
+		expect(encounter.combatants).toBe(originalCombatants);
+		expect(encounter.combatants[0].persistentDamage).toBeUndefined();
+	});
+});
+
+describe("removePersistentDamage", () => {
+	it("removes existing persistent damage entry", () => {
+		const encounter = buildEncounter({
+			combatants: [
+				{
+					id: goblinId,
+					name: "Goblin",
+					persistentDamage: [
+						{ type: "fire", formula: "2d6" },
+						{ type: "bleed", formula: "1d4" },
+					],
+				},
+			],
+		});
+		const result = removePersistentDamage(encounter, goblinId, "fire");
+
+		expect(result).not.toHaveProperty("kind");
+		if ("kind" in result) return;
+
+		expect(result.encounter.combatants[0].persistentDamage).toEqual([
+			{ type: "bleed", formula: "1d4" },
+		]);
+		expect(result.events).toEqual([
+			{
+				type: "PersistentDamageRemoved",
+				combatantId: goblinId,
+				damageType: "fire",
+			},
+		]);
+	});
+
+	it("sets persistentDamage to undefined when last entry removed", () => {
+		const encounter = buildEncounter({
+			combatants: [
+				{
+					id: goblinId,
+					name: "Goblin",
+					persistentDamage: [{ type: "fire", formula: "2d6" }],
+				},
+			],
+		});
+		const result = removePersistentDamage(encounter, goblinId, "fire");
+
+		expect(result).not.toHaveProperty("kind");
+		if ("kind" in result) return;
+
+		expect(result.encounter.combatants[0].persistentDamage).toBeUndefined();
+	});
+
+	it("returns domain error when damage type not active", () => {
+		const encounter = buildEncounter();
+		const result = removePersistentDamage(encounter, goblinId, "fire");
+
+		expect(result).toHaveProperty("kind", "domain-error");
+		if (!("kind" in result)) return;
+		expect(result.code).toBe("persistent-damage-not-active");
+	});
+
+	it("returns domain error for unknown combatant", () => {
+		const encounter = buildEncounter();
+		const result = removePersistentDamage(
+			encounter,
+			combatantId("nonexistent"),
+			"fire",
+		);
+
+		expect(result).toHaveProperty("kind", "domain-error");
+		if (!("kind" in result)) return;
+		expect(result.code).toBe("combatant-not-found");
+	});
+});

packages/domain/src/__tests__/pf2e-adjustments.test.ts

@@ -0,0 +1,270 @@
+import { describe, expect, it } from "vitest";
+import type { Pf2eCreature } from "../creature-types.js";
+import { creatureId } from "../creature-types.js";
+import {
+	acDelta,
+	adjustedLevel,
+	applyPf2eAdjustment,
+	hpDelta,
+	modDelta,
+} from "../pf2e-adjustments.js";
+
+describe("adjustedLevel", () => {
+	it("elite on level 5 → 6", () => {
+		expect(adjustedLevel(5, "elite")).toBe(6);
+	});
+
+	it("elite on level 0 → 2 (double bump)", () => {
+		expect(adjustedLevel(0, "elite")).toBe(2);
+	});
+
+	it("elite on level −1 → 1 (double bump)", () => {
+		expect(adjustedLevel(-1, "elite")).toBe(1);
+	});
+
+	it("weak on level 5 → 4", () => {
+		expect(adjustedLevel(5, "weak")).toBe(4);
+	});
+
+	it("weak on level 1 → −1 (double drop)", () => {
+		expect(adjustedLevel(1, "weak")).toBe(-1);
+	});
+
+	it("weak on level 0 → −1", () => {
+		expect(adjustedLevel(0, "weak")).toBe(-1);
+	});
+});
+
+describe("hpDelta", () => {
+	it("level 1 elite → +10", () => {
+		expect(hpDelta(1, "elite")).toBe(10);
+	});
+
+	it("level 1 weak → −10", () => {
+		expect(hpDelta(1, "weak")).toBe(-10);
+	});
+
+	it("level 3 elite → +15", () => {
+		expect(hpDelta(3, "elite")).toBe(15);
+	});
+
+	it("level 3 weak → −15", () => {
+		expect(hpDelta(3, "weak")).toBe(-15);
+	});
+
+	it("level 10 elite → +20", () => {
+		expect(hpDelta(10, "elite")).toBe(20);
+	});
+
+	it("level 10 weak → −20", () => {
+		expect(hpDelta(10, "weak")).toBe(-20);
+	});
+
+	it("level 25 elite → +30", () => {
+		expect(hpDelta(25, "elite")).toBe(30);
+	});
+
+	it("level 25 weak → −30", () => {
+		expect(hpDelta(25, "weak")).toBe(-30);
+	});
+});
+
+describe("acDelta", () => {
+	it("elite → +2", () => {
+		expect(acDelta("elite")).toBe(2);
+	});
+
+	it("weak → −2", () => {
+		expect(acDelta("weak")).toBe(-2);
+	});
+});
+
+describe("modDelta", () => {
+	it("elite → +2", () => {
+		expect(modDelta("elite")).toBe(2);
+	});
+
+	it("weak → −2", () => {
+		expect(modDelta("weak")).toBe(-2);
+	});
+});
+
+function baseCreature(overrides?: Partial<Pf2eCreature>): Pf2eCreature {
+	return {
+		system: "pf2e",
+		id: creatureId("test-creature"),
+		name: "Test Creature",
+		source: "test-source",
+		sourceDisplayName: "Test Source",
+		level: 5,
+		traits: ["humanoid"],
+		perception: 12,
+		skills: "Athletics +14",
+		abilityMods: {
+			str: 4,
+			dex: 2,
+			con: 3,
+			int: 0,
+			wis: 1,
+			cha: -1,
+		},
+		ac: 22,
+		saveFort: 14,
+		saveRef: 11,
+		saveWill: 9,
+		hp: 75,
+		speed: "25 feet",
+		...overrides,
+	};
+}
+
+describe("applyPf2eAdjustment", () => {
+	it("adjusts all numeric stats for elite", () => {
+		const creature = baseCreature();
+		const result = applyPf2eAdjustment(creature, "elite");
+
+		expect(result.level).toBe(6);
+		expect(result.ac).toBe(24);
+		expect(result.hp).toBe(95); // 75 + 20 (level 5 bracket)
+		expect(result.perception).toBe(14);
+		expect(result.saveFort).toBe(16);
+		expect(result.saveRef).toBe(13);
+		expect(result.saveWill).toBe(11);
+	});
+
+	it("adjusts all numeric stats for weak", () => {
+		const creature = baseCreature();
+		const result = applyPf2eAdjustment(creature, "weak");
+
+		expect(result.level).toBe(4);
+		expect(result.ac).toBe(20);
+		expect(result.hp).toBe(55); // 75 - 20 (level 5 bracket)
+		expect(result.perception).toBe(10);
+		expect(result.saveFort).toBe(12);
+		expect(result.saveRef).toBe(9);
+		expect(result.saveWill).toBe(7);
+	});
+
+	it("adjusts attack bonuses and damage", () => {
+		const creature = baseCreature({
+			attacks: [
+				{
+					name: "Melee",
+					activity: { number: 1, unit: "action" },
+					segments: [
+						{
+							type: "text",
+							value: "+15 [+10/+5] (agile), 2d12+7 piercing plus Grab",
+						},
+					],
+				},
+			],
+		});
+
+		const result = applyPf2eAdjustment(creature, "elite");
+		const text = result.attacks?.[0].segments[0];
+		expect(text).toEqual({
+			type: "text",
+			value: "+17 [+12/+7] (agile), 2d12+9 piercing plus Grab",
+		});
+	});
+
+	it("adjusts attack damage for weak", () => {
+		const creature = baseCreature({
+			attacks: [
+				{
+					name: "Melee",
+					activity: { number: 1, unit: "action" },
+					segments: [
+						{
+							type: "text",
+							value: "+15 (agile), 2d12+7 piercing plus Grab",
+						},
+					],
+				},
+			],
+		});
+
+		const result = applyPf2eAdjustment(creature, "weak");
+		const text = result.attacks?.[0].segments[0];
+		expect(text).toEqual({
+			type: "text",
+			value: "+13 (agile), 2d12+5 piercing plus Grab",
+		});
+	});
+
+	it("handles damage bonus becoming zero", () => {
+		const creature = baseCreature({
+			attacks: [
+				{
+					name: "Melee",
+					activity: { number: 1, unit: "action" },
+					segments: [{ type: "text", value: "+10, 1d4+2 slashing" }],
+				},
+			],
+		});
+
+		const result = applyPf2eAdjustment(creature, "weak");
+		const text = result.attacks?.[0].segments[0];
+		expect(text).toEqual({
+			type: "text",
+			value: "+8, 1d4 slashing",
+		});
+	});
+
+	it("handles damage bonus becoming negative", () => {
+		const creature = baseCreature({
+			attacks: [
+				{
+					name: "Melee",
+					activity: { number: 1, unit: "action" },
+					segments: [{ type: "text", value: "+10, 1d4+1 slashing" }],
+				},
+			],
+		});
+
+		const result = applyPf2eAdjustment(creature, "weak");
+		const text = result.attacks?.[0].segments[0];
+		expect(text).toEqual({
+			type: "text",
+			value: "+8, 1d4-1 slashing",
+		});
+	});
+
+	it("does not modify non-attack abilities", () => {
+		const creature = baseCreature({
+			abilitiesTop: [
+				{
+					name: "Darkvision",
+					segments: [{ type: "text", value: "Can see in darkness." }],
+				},
+			],
+		});
+
+		const result = applyPf2eAdjustment(creature, "elite");
+		expect(result.abilitiesTop).toEqual(creature.abilitiesTop);
+	});
+
+	it("preserves non-text segments in attacks", () => {
+		const creature = baseCreature({
+			attacks: [
+				{
+					name: "Melee",
+					activity: { number: 1, unit: "action" },
+					segments: [
+						{
+							type: "list",
+							items: [{ text: "some list item" }],
+						},
+					],
+				},
+			],
+		});
+
+		const result = applyPf2eAdjustment(creature, "elite");
+		expect(result.attacks?.[0].segments[0]).toEqual({
+			type: "list",
+			items: [{ text: "some list item" }],
+		});
+	});
+});

packages/domain/src/__tests__/recall-knowledge.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from "vitest";
+import { recallKnowledge } from "../recall-knowledge.js";
+
+describe("recallKnowledge", () => {
+	it("returns null when no type trait is recognized", () => {
+		expect(recallKnowledge(5, ["small", "goblin"])).toBeNull();
+	});
+
+	it("calculates DC for a common creature from the DC-by-level table", () => {
+		const result = recallKnowledge(5, ["humanoid"]);
+		expect(result).toEqual({ dc: 20, type: "humanoid", skills: ["Society"] });
+	});
+
+	it("calculates DC for level -1", () => {
+		const result = recallKnowledge(-1, ["humanoid"]);
+		expect(result).toEqual({ dc: 13, type: "humanoid", skills: ["Society"] });
+	});
+
+	it("calculates DC for level 0", () => {
+		const result = recallKnowledge(0, ["animal"]);
+		expect(result).toEqual({ dc: 14, type: "animal", skills: ["Nature"] });
+	});
+
+	it("calculates DC for level 25 (max table entry)", () => {
+		const result = recallKnowledge(25, ["dragon"]);
+		expect(result).toEqual({ dc: 50, type: "dragon", skills: ["Arcana"] });
+	});
+
+	it("clamps DC for levels beyond the table", () => {
+		const result = recallKnowledge(30, ["dragon"]);
+		expect(result).toEqual({ dc: 50, type: "dragon", skills: ["Arcana"] });
+	});
+
+	it("adjusts DC for uncommon rarity (+2)", () => {
+		const result = recallKnowledge(5, ["uncommon", "medium", "undead"]);
+		expect(result).toEqual({
+			dc: 22,
+			type: "undead",
+			skills: ["Religion"],
+		});
+	});
+
+	it("adjusts DC for rare rarity (+5)", () => {
+		const result = recallKnowledge(5, ["rare", "large", "dragon"]);
+		expect(result).toEqual({ dc: 25, type: "dragon", skills: ["Arcana"] });
+	});
+
+	it("adjusts DC for unique rarity (+10)", () => {
+		const result = recallKnowledge(5, ["unique", "medium", "humanoid"]);
+		expect(result).toEqual({
+			dc: 30,
+			type: "humanoid",
+			skills: ["Society"],
+		});
+	});
+
+	it("returns multiple skills for beast type", () => {
+		const result = recallKnowledge(3, ["beast"]);
+		expect(result).toEqual({
+			dc: 18,
+			type: "beast",
+			skills: ["Arcana", "Nature"],
+		});
+	});
+
+	it("returns multiple skills for construct type", () => {
+		const result = recallKnowledge(1, ["construct"]);
+		expect(result).toEqual({
+			dc: 15,
+			type: "construct",
+			skills: ["Arcana", "Crafting"],
+		});
+	});
+
+	it("matches type traits case-insensitively", () => {
+		const result = recallKnowledge(5, ["Humanoid"]);
+		expect(result).toEqual({ dc: 20, type: "Humanoid", skills: ["Society"] });
+	});
+
+	it("uses the first matching type trait when multiple are present", () => {
+		const result = recallKnowledge(7, ["large", "monitor", "protean"]);
+		expect(result).toEqual({
+			dc: 23,
+			type: "monitor",
+			skills: ["Religion"],
+		});
+	});
+
+	it("preserves original trait casing in the returned type", () => {
+		const result = recallKnowledge(1, ["Fey"]);
+		expect(result?.type).toBe("Fey");
+	});
+
+	it("ignores common rarity (no adjustment)", () => {
+		// "common" is not included in traits by the normalization pipeline
+		const result = recallKnowledge(5, ["medium", "humanoid"]);
+		expect(result?.dc).toBe(20);
+	});
+});

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

@@ -301,6 +301,52 @@ describe("rehydrateCombatant", () => {
 			expect(result?.side).toBeUndefined();
 		});
 
+		it("preserves valid persistent damage entries", () => {
+			const result = rehydrateCombatant({
+				...minimalCombatant(),
+				persistentDamage: [
+					{ type: "fire", formula: "2d6" },
+					{ type: "bleed", formula: "1d4" },
+				],
+			});
+			expect(result?.persistentDamage).toEqual([
+				{ type: "fire", formula: "2d6" },
+				{ type: "bleed", formula: "1d4" },
+			]);
+		});
+
+		it("filters out invalid persistent damage entries", () => {
+			const result = rehydrateCombatant({
+				...minimalCombatant(),
+				persistentDamage: [
+					{ type: "fire", formula: "2d6" },
+					{ type: "radiant", formula: "1d4" },
+					{ type: "bleed", formula: "" },
+					{ type: "acid" },
+					{ formula: "1d6" },
+				],
+			});
+			expect(result?.persistentDamage).toEqual([
+				{ type: "fire", formula: "2d6" },
+			]);
+		});
+
+		it("returns undefined persistentDamage for non-array value", () => {
+			const result = rehydrateCombatant({
+				...minimalCombatant(),
+				persistentDamage: "fire",
+			});
+			expect(result?.persistentDamage).toBeUndefined();
+		});
+
+		it("returns undefined persistentDamage for empty array", () => {
+			const result = rehydrateCombatant({
+				...minimalCombatant(),
+				persistentDamage: [],
+			});
+			expect(result?.persistentDamage).toBeUndefined();
+		});
+
 		it("drops invalid tempHp — keeps combatant", () => {
 			for (const tempHp of [-1, 1.5, "3"]) {
 				const result = rehydrateCombatant({

packages/domain/src/__tests__/toggle-condition.test.ts

@@ -169,6 +169,60 @@ describe("setConditionValue", () => {
 		);
 		expectDomainError(result, "unknown-condition");
 	});
+
+	it("clamps value to maxValue for capped conditions", () => {
+		const e = enc([makeCombatant("A")]);
+		const result = setConditionValue(e, combatantId("A"), "dying", 6);
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toEqual([
+			{ id: "dying", value: 4 },
+		]);
+		expect(result.events[0]).toMatchObject({
+			type: "ConditionAdded",
+			value: 4,
+		});
+	});
+
+	it("allows value at exactly the max", () => {
+		const e = enc([makeCombatant("A")]);
+		const result = setConditionValue(e, combatantId("A"), "doomed", 3);
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toEqual([
+			{ id: "doomed", value: 3 },
+		]);
+	});
+
+	it("allows value below the max", () => {
+		const e = enc([makeCombatant("A")]);
+		const result = setConditionValue(e, combatantId("A"), "wounded", 2);
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toEqual([
+			{ id: "wounded", value: 2 },
+		]);
+	});
+
+	it("does not cap conditions without a maxValue", () => {
+		const e = enc([makeCombatant("A")]);
+		const result = setConditionValue(e, combatantId("A"), "frightened", 10);
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toEqual([
+			{ id: "frightened", value: 10 },
+		]);
+	});
+
+	it("clamps when updating an existing capped condition", () => {
+		const e = enc([makeCombatant("A", [{ id: "slowed-pf2e", value: 2 }])]);
+		const result = setConditionValue(e, combatantId("A"), "slowed-pf2e", 5);
+		if (isDomainError(result)) throw new Error(result.message);
+
+		expect(result.encounter.combatants[0].conditions).toEqual([
+			{ id: "slowed-pf2e", value: 3 },
+		]);
+	});
 });
 
 describe("decrementCondition", () => {

packages/domain/src/add-combatant.ts

@@ -14,6 +14,7 @@ export interface CombatantInit {
 	readonly ac?: number;
 	readonly initiative?: number;
 	readonly creatureId?: CreatureId;
+	readonly creatureAdjustment?: "weak" | "elite";
 	readonly color?: string;
 	readonly icon?: string;
 	readonly playerCharacterId?: PlayerCharacterId;
@@ -67,6 +68,9 @@ function buildCombatant(
 		...(init?.ac !== undefined && { ac: init.ac }),
 		...(init?.initiative !== undefined && { initiative: init.initiative }),
 		...(init?.creatureId !== undefined && { creatureId: init.creatureId }),
+		...(init?.creatureAdjustment !== undefined && {
+			creatureAdjustment: init.creatureAdjustment,
+		}),
 		...(init?.color !== undefined && { color: init.color }),
 		...(init?.icon !== undefined && { icon: init.icon }),
 		...(init?.playerCharacterId !== undefined && {

packages/domain/src/auto-number.ts

@@ -1,3 +1,28 @@
+const DIGITS_ONLY = /^\d+$/;
+
+function scanExisting(
+	baseName: string,
+	existingNames: readonly string[],
+): { exactMatches: number[]; maxNumber: number } {
+	const exactMatches: number[] = [];
+	let maxNumber = 0;
+	const prefix = `${baseName} `;
+
+	for (let i = 0; i < existingNames.length; i++) {
+		const name = existingNames[i];
+		if (name === baseName) {
+			exactMatches.push(i);
+		} else if (name.startsWith(prefix)) {
+			const suffix = name.slice(prefix.length);
+			if (DIGITS_ONLY.test(suffix)) {
+				const num = Number.parseInt(suffix, 10);
+				if (num > maxNumber) maxNumber = num;
+			}
+		}
+	}
+	return { exactMatches, maxNumber };
+}
+
 /**
  * Resolves a creature name against existing combatant names,
  * handling auto-numbering for duplicates.
@@ -14,25 +39,7 @@ export function resolveCreatureName(
 	newName: string;
 	renames: ReadonlyArray<{ from: string; to: string }>;
 } {
-	// Find exact matches and numbered matches (e.g., "Goblin 1", "Goblin 2")
+	const { exactMatches, maxNumber } = scanExisting(baseName, existingNames);
-	const exactMatches: number[] = [];
-	let maxNumber = 0;
-
-	for (let i = 0; i < existingNames.length; i++) {
-		const name = existingNames[i];
-		if (name === baseName) {
-			exactMatches.push(i);
-		} else {
-			const match = new RegExp(
-				String.raw`^${escapeRegExp(baseName)} (\d+)$`,
-			).exec(name);
-			// biome-ignore lint/nursery/noUnnecessaryConditions: RegExp.exec() returns null on no match — false positive
-			if (match) {
-				const num = Number.parseInt(match[1], 10);
-				if (num > maxNumber) maxNumber = num;
-			}
-		}
-	}
 
 	// No conflict at all
 	if (exactMatches.length === 0 && maxNumber === 0) {
@@ -51,7 +58,3 @@ export function resolveCreatureName(
 	const nextNumber = Math.max(maxNumber, exactMatches.length) + 1;
 	return { newName: `${baseName} ${nextNumber}`, renames: [] };
 }
-
-function escapeRegExp(s: string): string {
-	return s.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-}

packages/domain/src/conditions.ts

@@ -57,6 +57,8 @@ export interface ConditionDefinition {
 	/** When set, the condition only appears in these systems' pickers. */
 	readonly systems?: readonly RulesEdition[];
 	readonly valued?: boolean;
+	/** Rule-defined maximum value for PF2e valued conditions. */
+	readonly maxValue?: number;
 }
 
 export function getConditionDescription(
@@ -329,6 +331,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 		color: "red",
 		systems: ["pf2e"],
 		valued: true,
+		maxValue: 3,
 	},
 	{
 		id: "drained",
@@ -353,6 +356,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 		color: "red",
 		systems: ["pf2e"],
 		valued: true,
+		maxValue: 4,
 	},
 	{
 		id: "enfeebled",
@@ -475,6 +479,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 		color: "sky",
 		systems: ["pf2e"],
 		valued: true,
+		maxValue: 3,
 	},
 	{
 		id: "stupefied",
@@ -510,6 +515,7 @@ export const CONDITION_DEFINITIONS: readonly ConditionDefinition[] = [
 		color: "red",
 		systems: ["pf2e"],
 		valued: true,
+		maxValue: 3,
 	},
 ] as const;
 

packages/domain/src/creature-types.ts

@@ -23,6 +23,7 @@ export interface TraitBlock {
 	readonly name: string;
 	readonly activity?: ActivityCost;
 	readonly trigger?: string;
+	readonly frequency?: string;
 	readonly segments: readonly TraitSegment[];
 }
 
@@ -31,16 +32,84 @@ export interface LegendaryBlock {
 	readonly entries: readonly TraitBlock[];
 }
 
+/**
+ * A single spell entry within a creature's spellcasting block.
+ *
+ * `name` is always populated. All other fields are optional and are only
+ * populated for PF2e creatures (sourced from embedded Foundry VTT spell items).
+ * D&D 5e creatures populate only `name`.
+ */
+export interface SpellReference {
+	readonly name: string;
+
+	/** Stable slug from Foundry VTT (e.g. "magic-missile"). PF2e only. */
+	readonly slug?: string;
+
+	/** Plain-text description with Foundry enrichment tags stripped. */
+	readonly description?: string;
+
+	/** Spell rank/level (0 = cantrip). */
+	readonly rank?: number;
+
+	/** Trait slugs (e.g. ["concentrate", "manipulate", "force"]). */
+	readonly traits?: readonly string[];
+
+	/** Tradition labels (e.g. ["arcane", "occult"]). */
+	readonly traditions?: readonly string[];
+
+	/** Range (e.g. "30 feet", "touch"). */
+	readonly range?: string;
+
+	/** Target (e.g. "1 creature"). */
+	readonly target?: string;
+
+	/** Area (e.g. "20-foot burst"). */
+	readonly area?: string;
+
+	/** Duration (e.g. "1 minute", "sustained up to 1 minute"). */
+	readonly duration?: string;
+
+	/** Defense / save (e.g. "basic Reflex", "Will"). */
+	readonly defense?: string;
+
+	/** Action cost. PF2e: number = action count, "reaction", "free", or
+	 *  "1 minute" / "10 minutes" for cast time. */
+	readonly actionCost?: string;
+
+	/**
+	 * Heightening rules text. May come from `system.heightening` (fixed
+	 * intervals) or `system.overlays` (variant casts). Plain text after
+	 * tag stripping.
+	 */
+	readonly heightening?: string;
+
+	/** Uses per day for "(×N)" rendering, when > 1. PF2e only. */
+	readonly usesPerDay?: number;
+}
+
+/** A carried equipment item on a PF2e creature (weapon, consumable, magic item, etc.). */
+export interface EquipmentItem {
+	readonly name: string;
+	readonly level: number;
+	readonly category?: string;
+	readonly traits?: readonly string[];
+	readonly description?: string;
+	/** For scrolls/wands: the embedded spell name. */
+	readonly spellName?: string;
+	/** For scrolls/wands: the embedded spell rank. */
+	readonly spellRank?: number;
+}
+
 export interface DailySpells {
 	readonly uses: number;
 	readonly each: boolean;
-	readonly spells: readonly string[];
+	readonly spells: readonly SpellReference[];
 }
 
 export interface SpellcastingBlock {
 	readonly name: string;
 	readonly headerText: string;
-	readonly atWill?: readonly string[];
+	readonly atWill?: readonly SpellReference[];
 	readonly daily?: readonly DailySpells[];
 	readonly restLong?: readonly DailySpells[];
 }
@@ -117,6 +186,7 @@ export interface Pf2eCreature {
 	readonly level: number;
 	readonly traits: readonly string[];
 	readonly perception: number;
+	readonly perceptionDetails?: string;
 	readonly senses?: string;
 	readonly languages?: string;
 	readonly skills?: string;
@@ -146,6 +216,7 @@ export interface Pf2eCreature {
 	readonly abilitiesMid?: readonly TraitBlock[];
 	readonly abilitiesBot?: readonly TraitBlock[];
 	readonly spellcasting?: readonly SpellcastingBlock[];
+	readonly equipment?: readonly EquipmentItem[];
 }
 
 export type AnyCreature = Creature | Pf2eCreature;

packages/domain/src/events.ts

@@ -1,5 +1,6 @@
 import type { ConditionId } from "./conditions.js";
 import type { CreatureId } from "./creature-types.js";
+import type { PersistentDamageType } from "./persistent-damage.js";
 import type { PlayerCharacterId } from "./player-character-types.js";
 import type { CombatantId } from "./types.js";
 
@@ -132,6 +133,25 @@ export interface ConcentrationEnded {
 	readonly combatantId: CombatantId;
 }
 
+export interface PersistentDamageAdded {
+	readonly type: "PersistentDamageAdded";
+	readonly combatantId: CombatantId;
+	readonly damageType: PersistentDamageType;
+	readonly formula: string;
+}
+
+export interface PersistentDamageRemoved {
+	readonly type: "PersistentDamageRemoved";
+	readonly combatantId: CombatantId;
+	readonly damageType: PersistentDamageType;
+}
+
+export interface CreatureAdjustmentSet {
+	readonly type: "CreatureAdjustmentSet";
+	readonly combatantId: CombatantId;
+	readonly adjustment: "weak" | "elite" | undefined;
+}
+
 export interface EncounterCleared {
 	readonly type: "EncounterCleared";
 	readonly combatantCount: number;
@@ -175,6 +195,9 @@ export type DomainEvent =
 	| ConditionRemoved
 	| ConcentrationStarted
 	| ConcentrationEnded
+	| PersistentDamageAdded
+	| PersistentDamageRemoved
+	| CreatureAdjustmentSet
 	| EncounterCleared
 	| PlayerCharacterCreated
 	| PlayerCharacterUpdated

packages/domain/src/index.ts

@@ -33,12 +33,14 @@ export {
 	type CreatureId,
 	creatureId,
 	type DailySpells,
+	type EquipmentItem,
 	type LegendaryBlock,
 	type Pf2eBestiaryIndex,
 	type Pf2eBestiaryIndexEntry,
 	type Pf2eCreature,
 	proficiencyBonus,
 	type SpellcastingBlock,
+	type SpellReference,
 	type TraitBlock,
 	type TraitListItem,
 	type TraitSegment,
@@ -73,12 +75,15 @@ export type {
 	ConcentrationStarted,
 	ConditionAdded,
 	ConditionRemoved,
+	CreatureAdjustmentSet,
 	CrSet,
 	CurrentHpAdjusted,
 	DomainEvent,
 	EncounterCleared,
 	InitiativeSet,
 	MaxHpSet,
+	PersistentDamageAdded,
+	PersistentDamageRemoved,
 	PlayerCharacterCreated,
 	PlayerCharacterDeleted,
 	PlayerCharacterUpdated,
@@ -97,6 +102,25 @@ export {
 	formatInitiativeModifier,
 	type InitiativeResult,
 } from "./initiative.js";
+export {
+	addPersistentDamage,
+	PERSISTENT_DAMAGE_DEFINITIONS,
+	PERSISTENT_DAMAGE_TYPES,
+	type PersistentDamageDefinition,
+	type PersistentDamageEntry,
+	type PersistentDamageSuccess,
+	type PersistentDamageType,
+	removePersistentDamage,
+	VALID_PERSISTENT_DAMAGE_TYPES,
+} from "./persistent-damage.js";
+export {
+	acDelta,
+	adjustedLevel,
+	applyPf2eAdjustment,
+	type CreatureAdjustment,
+	hpDelta,
+	modDelta,
+} from "./pf2e-adjustments.js";
 export {
 	type PlayerCharacter,
 	type PlayerCharacterId,
@@ -107,6 +131,10 @@ export {
 	VALID_PLAYER_COLORS,
 	VALID_PLAYER_ICONS,
 } from "./player-character-types.js";
+export {
+	type RecallKnowledge,
+	recallKnowledge,
+} from "./recall-knowledge.js";
 export { rehydrateCombatant } from "./rehydrate-combatant.js";
 export { rehydratePlayerCharacter } from "./rehydrate-player-character.js";
 export {

packages/domain/src/persistent-damage.ts

@@ -0,0 +1,185 @@
+import type { DomainEvent } from "./events.js";
+import {
+	type CombatantId,
+	type DomainError,
+	type Encounter,
+	findCombatant,
+	isDomainError,
+} from "./types.js";
+
+export const PERSISTENT_DAMAGE_TYPES = [
+	"fire",
+	"bleed",
+	"acid",
+	"cold",
+	"electricity",
+	"poison",
+	"mental",
+	"force",
+	"void",
+	"spirit",
+	"vitality",
+	"piercing",
+] as const;
+
+export type PersistentDamageType = (typeof PERSISTENT_DAMAGE_TYPES)[number];
+
+export const VALID_PERSISTENT_DAMAGE_TYPES: ReadonlySet<string> = new Set(
+	PERSISTENT_DAMAGE_TYPES,
+);
+
+export interface PersistentDamageEntry {
+	readonly type: PersistentDamageType;
+	readonly formula: string;
+}
+
+export interface PersistentDamageDefinition {
+	readonly type: PersistentDamageType;
+	readonly label: string;
+	readonly iconName: string;
+	readonly color: string;
+}
+
+export const PERSISTENT_DAMAGE_DEFINITIONS: readonly PersistentDamageDefinition[] =
+	[
+		{ type: "fire", label: "Fire", iconName: "Flame", color: "orange" },
+		{ type: "bleed", label: "Bleed", iconName: "Droplets", color: "red" },
+		{
+			type: "acid",
+			label: "Acid",
+			iconName: "FlaskConical",
+			color: "lime",
+		},
+		{ type: "cold", label: "Cold", iconName: "Snowflake", color: "sky" },
+		{
+			type: "electricity",
+			label: "Electricity",
+			iconName: "Zap",
+			color: "yellow",
+		},
+		{
+			type: "poison",
+			label: "Poison",
+			iconName: "Droplet",
+			color: "green",
+		},
+		{
+			type: "mental",
+			label: "Mental",
+			iconName: "BrainCog",
+			color: "pink",
+		},
+		{ type: "force", label: "Force", iconName: "Orbit", color: "indigo" },
+		{ type: "void", label: "Void", iconName: "Eclipse", color: "slate" },
+		{ type: "spirit", label: "Spirit", iconName: "Wind", color: "neutral" },
+		{
+			type: "vitality",
+			label: "Vitality",
+			iconName: "Sparkle",
+			color: "amber",
+		},
+		{
+			type: "piercing",
+			label: "Piercing",
+			iconName: "Sword",
+			color: "neutral",
+		},
+	];
+
+export interface PersistentDamageSuccess {
+	readonly encounter: Encounter;
+	readonly events: DomainEvent[];
+}
+
+function applyPersistentDamage(
+	encounter: Encounter,
+	combatantId: CombatantId,
+	newEntries: readonly PersistentDamageEntry[] | undefined,
+): Encounter {
+	return {
+		combatants: encounter.combatants.map((c) =>
+			c.id === combatantId ? { ...c, persistentDamage: newEntries } : c,
+		),
+		activeIndex: encounter.activeIndex,
+		roundNumber: encounter.roundNumber,
+	};
+}
+
+export function addPersistentDamage(
+	encounter: Encounter,
+	combatantId: CombatantId,
+	damageType: PersistentDamageType,
+	formula: string,
+): PersistentDamageSuccess | DomainError {
+	if (!VALID_PERSISTENT_DAMAGE_TYPES.has(damageType)) {
+		return {
+			kind: "domain-error",
+			code: "unknown-damage-type",
+			message: `Unknown persistent damage type "${damageType}"`,
+		};
+	}
+	if (formula.trim().length === 0) {
+		return {
+			kind: "domain-error",
+			code: "empty-formula",
+			message: "Persistent damage formula must not be empty",
+		};
+	}
+
+	const found = findCombatant(encounter, combatantId);
+	if (isDomainError(found)) return found;
+	const { combatant: target } = found;
+	const current = target.persistentDamage ?? [];
+
+	// Replace existing entry of same type, or append
+	const filtered = current.filter((e) => e.type !== damageType);
+	const newEntries = [
+		...filtered,
+		{ type: damageType, formula: formula.trim() },
+	];
+
+	// Sort by definition order
+	const order = PERSISTENT_DAMAGE_DEFINITIONS.map((d) => d.type);
+	newEntries.sort((a, b) => order.indexOf(a.type) - order.indexOf(b.type));
+
+	return {
+		encounter: applyPersistentDamage(encounter, combatantId, newEntries),
+		events: [
+			{
+				type: "PersistentDamageAdded",
+				combatantId,
+				damageType,
+				formula: formula.trim(),
+			},
+		],
+	};
+}
+
+export function removePersistentDamage(
+	encounter: Encounter,
+	combatantId: CombatantId,
+	damageType: PersistentDamageType,
+): PersistentDamageSuccess | DomainError {
+	const found = findCombatant(encounter, combatantId);
+	if (isDomainError(found)) return found;
+	const { combatant: target } = found;
+	const current = target.persistentDamage ?? [];
+
+	if (!current.some((e) => e.type === damageType)) {
+		return {
+			kind: "domain-error",
+			code: "persistent-damage-not-active",
+			message: `Persistent ${damageType} damage is not active`,
+		};
+	}
+
+	const filtered = current.filter((e) => e.type !== damageType);
+	return {
+		encounter: applyPersistentDamage(
+			encounter,
+			combatantId,
+			filtered.length > 0 ? filtered : undefined,
+		),
+		events: [{ type: "PersistentDamageRemoved", combatantId, damageType }],
+	};
+}

packages/domain/src/pf2e-adjustments.ts

@@ -0,0 +1,110 @@
+import type {
+	Pf2eCreature,
+	TraitBlock,
+	TraitSegment,
+} from "./creature-types.js";
+
+export type CreatureAdjustment = "weak" | "elite";
+
+/** HP bracket delta by creature level (standard PF2e table). */
+function hpBracketDelta(level: number): number {
+	if (level <= 1) return 10;
+	if (level <= 4) return 15;
+	if (level <= 19) return 20;
+	return 30;
+}
+
+/** Level shift: elite +1 (or +2 if level ≤ 0), weak −1 (or −2 if level is 1). */
+export function adjustedLevel(
+	baseLevel: number,
+	adjustment: CreatureAdjustment,
+): number {
+	if (adjustment === "elite") {
+		return baseLevel <= 0 ? baseLevel + 2 : baseLevel + 1;
+	}
+	return baseLevel === 1 ? baseLevel - 2 : baseLevel - 1;
+}
+
+/** Signed HP delta for a given base level and adjustment. */
+export function hpDelta(
+	baseLevel: number,
+	adjustment: CreatureAdjustment,
+): number {
+	const delta = hpBracketDelta(baseLevel);
+	return adjustment === "elite" ? delta : -delta;
+}
+
+/** AC delta: +2 for elite, −2 for weak. */
+export function acDelta(adjustment: CreatureAdjustment): number {
+	return adjustment === "elite" ? 2 : -2;
+}
+
+/** Generic ±2 modifier delta. Used for saves, Perception, attacks, damage. */
+export function modDelta(adjustment: CreatureAdjustment): number {
+	return adjustment === "elite" ? 2 : -2;
+}
+
+const ATTACK_BONUS_RE = /^([+-])(\d+)/;
+const MAP_RE = /\[([+-]\d+)\/([+-]\d+)\]/g;
+const DAMAGE_BONUS_RE = /(\d+d\d+)([+-])(\d+)/g;
+
+/**
+ * Adjust attack bonus in a formatted attack string.
+ * "+15 (agile), 2d12+7 piercing plus Grab" → "+17 (agile), 2d12+9 piercing plus Grab"
+ */
+function adjustAttackText(text: string, delta: number): string {
+	// Adjust leading attack bonus: "+15" → "+17"
+	let result = text.replace(ATTACK_BONUS_RE, (_, sign, num) => {
+		const adjusted = (sign === "+" ? 1 : -1) * Number(num) + delta;
+		return adjusted >= 0 ? `+${adjusted}` : `${adjusted}`;
+	});
+	// Adjust MAP values in brackets: "[+10/+5]" → "[+12/+7]"
+	result = result.replace(MAP_RE, (_, m1, m2) => {
+		const a1 = Number(m1) + delta;
+		const a2 = Number(m2) + delta;
+		const f = (n: number) => (n >= 0 ? `+${n}` : `${n}`);
+		return `[${f(a1)}/${f(a2)}]`;
+	});
+	// Adjust damage bonus in "NdN+N type" patterns
+	result = result.replace(DAMAGE_BONUS_RE, (_, dice, sign, num) => {
+		const current = (sign === "+" ? 1 : -1) * Number(num);
+		const adjusted = current + delta;
+		if (adjusted === 0) return dice as string;
+		return adjusted > 0 ? `${dice}+${adjusted}` : `${dice}${adjusted}`;
+	});
+	return result;
+}
+
+function adjustTraitBlock(block: TraitBlock, delta: number): TraitBlock {
+	return {
+		...block,
+		segments: block.segments.map(
+			(seg): TraitSegment =>
+				seg.type === "text"
+					? { type: "text", value: adjustAttackText(seg.value, delta) }
+					: seg,
+		),
+	};
+}
+
+/**
+ * Apply a weak or elite adjustment to a full PF2e creature.
+ * Returns a new Pf2eCreature with all numeric stats adjusted.
+ */
+export function applyPf2eAdjustment(
+	creature: Pf2eCreature,
+	adjustment: CreatureAdjustment,
+): Pf2eCreature {
+	const d = modDelta(adjustment);
+	return {
+		...creature,
+		level: adjustedLevel(creature.level, adjustment),
+		ac: creature.ac + d,
+		hp: creature.hp + hpDelta(creature.level, adjustment),
+		perception: creature.perception + d,
+		saveFort: creature.saveFort + d,
+		saveRef: creature.saveRef + d,
+		saveWill: creature.saveWill + d,
+		attacks: creature.attacks?.map((a) => adjustTraitBlock(a, d)),
+	};
+}

packages/domain/src/recall-knowledge.ts

@@ -0,0 +1,118 @@
+/**
+ * PF2e Recall Knowledge DC calculation and type-to-skill mapping.
+ *
+ * DC is derived from creature level using the standard DC-by-level table
+ * (Player Core / GM Core), adjusted for rarity.
+ */
+
+/** Standard DC-by-level table from PF2e GM Core. Index = level + 1 (level -1 → index 0). */
+const DC_BY_LEVEL: readonly number[] = [
+	13, // level -1
+	14, // level 0
+	15, // level 1
+	16, // level 2
+	18, // level 3
+	19, // level 4
+	20, // level 5
+	22, // level 6
+	23, // level 7
+	24, // level 8
+	26, // level 9
+	27, // level 10
+	28, // level 11
+	30, // level 12
+	31, // level 13
+	32, // level 14
+	34, // level 15
+	35, // level 16
+	36, // level 17
+	38, // level 18
+	39, // level 19
+	40, // level 20
+	42, // level 21
+	44, // level 22
+	46, // level 23
+	48, // level 24
+	50, // level 25
+];
+
+const RARITY_ADJUSTMENT: Readonly<Record<string, number>> = {
+	uncommon: 2,
+	rare: 5,
+	unique: 10,
+};
+
+/**
+ * Mapping from PF2e creature type traits to the skill(s) used for
+ * Recall Knowledge. Types that map to multiple skills list all of them.
+ */
+const TYPE_TO_SKILLS: Readonly<Record<string, readonly string[]>> = {
+	aberration: ["Occultism"],
+	animal: ["Nature"],
+	astral: ["Occultism"],
+	beast: ["Arcana", "Nature"],
+	celestial: ["Religion"],
+	construct: ["Arcana", "Crafting"],
+	dragon: ["Arcana"],
+	dream: ["Occultism"],
+	elemental: ["Arcana", "Nature"],
+	ethereal: ["Occultism"],
+	fey: ["Nature"],
+	fiend: ["Religion"],
+	fungus: ["Nature"],
+	giant: ["Society"],
+	humanoid: ["Society"],
+	monitor: ["Religion"],
+	ooze: ["Occultism"],
+	plant: ["Nature"],
+	undead: ["Religion"],
+};
+
+export interface RecallKnowledge {
+	readonly dc: number;
+	readonly type: string;
+	readonly skills: readonly string[];
+}
+
+/**
+ * Calculate Recall Knowledge DC, type, and skill(s) for a PF2e creature.
+ *
+ * Returns `null` when no recognized type trait is found in the creature's
+ * traits array, indicating the Recall Knowledge line should be omitted.
+ */
+export function recallKnowledge(
+	level: number,
+	traits: readonly string[],
+): RecallKnowledge | null {
+	// Find the first type trait that maps to a skill
+	let matchedType: string | undefined;
+	let skills: readonly string[] | undefined;
+
+	for (const trait of traits) {
+		const lower = trait.toLowerCase();
+		const mapped = TYPE_TO_SKILLS[lower];
+		if (mapped) {
+			matchedType = trait;
+			skills = mapped;
+			break;
+		}
+	}
+
+	if (!matchedType || !skills) return null;
+
+	// Calculate DC from level
+	const clampedIndex = Math.max(0, Math.min(level + 1, DC_BY_LEVEL.length - 1));
+	let dc = DC_BY_LEVEL[clampedIndex];
+
+	// Apply rarity adjustment (rarity traits are included in the traits array
+	// for non-common creatures by the normalization pipeline)
+	for (const trait of traits) {
+		const adjustment = RARITY_ADJUSTMENT[trait.toLowerCase()];
+		if (adjustment) {
+			dc += adjustment;
+			break;
+		}
+	}
+
+	return { dc, type: matchedType, skills };
+}

packages/domain/src/rehydrate-combatant.ts

@@ -2,6 +2,8 @@ import type { ConditionEntry, ConditionId } from "./conditions.js";
 import { VALID_CONDITION_IDS } from "./conditions.js";
 import { creatureId } from "./creature-types.js";
 import { VALID_CR_VALUES } from "./encounter-difficulty.js";
+import type { PersistentDamageEntry } from "./persistent-damage.js";
+import { VALID_PERSISTENT_DAMAGE_TYPES } from "./persistent-damage.js";
 import {
 	playerCharacterId,
 	VALID_PLAYER_COLORS,
@@ -42,6 +44,32 @@ function validateConditions(value: unknown): ConditionEntry[] | undefined {
 	return entries.length > 0 ? entries : undefined;
 }
 
+function validatePersistentDamage(
+	value: unknown,
+): PersistentDamageEntry[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const entries: PersistentDamageEntry[] = [];
+	for (const item of value) {
+		if (
+			typeof item === "object" &&
+			item !== null &&
+			typeof (item as Record<string, unknown>).type === "string" &&
+			VALID_PERSISTENT_DAMAGE_TYPES.has(
+				(item as Record<string, unknown>).type as string,
+			) &&
+			typeof (item as Record<string, unknown>).formula === "string" &&
+			((item as Record<string, unknown>).formula as string).length > 0
+		) {
+			entries.push({
+				type: (item as Record<string, unknown>)
+					.type as PersistentDamageEntry["type"],
+				formula: (item as Record<string, unknown>).formula as string,
+			});
+		}
+	}
+	return entries.length > 0 ? entries : undefined;
+}
+
 function validateHp(
 	rawMaxHp: unknown,
 	rawCurrentHp: unknown,
@@ -93,6 +121,7 @@ function validateCr(value: unknown): string | undefined {
 		: undefined;
 }
 
+const VALID_ADJUSTMENTS = new Set(["weak", "elite"]);
 const VALID_SIDES = new Set(["party", "enemy"]);
 
 function validateSide(value: unknown): "party" | "enemy" | undefined {
@@ -106,10 +135,15 @@ function parseOptionalFields(entry: Record<string, unknown>) {
 		initiative: validateInteger(entry.initiative),
 		ac: validateAc(entry.ac),
 		conditions: validateConditions(entry.conditions),
+		persistentDamage: validatePersistentDamage(entry.persistentDamage),
 		isConcentrating: entry.isConcentrating === true ? true : undefined,
 		creatureId: validateNonEmptyString(entry.creatureId)
 			? creatureId(entry.creatureId as string)
 			: undefined,
+		creatureAdjustment: validateSetMember(
+			entry.creatureAdjustment,
+			VALID_ADJUSTMENTS,
+		) as "weak" | "elite" | undefined,
 		cr: validateCr(entry.cr),
 		side: validateSide(entry.side),
 		color: validateSetMember(entry.color, VALID_PLAYER_COLORS),

packages/domain/src/toggle-condition.ts

@@ -92,7 +92,11 @@ export function setConditionValue(
 	const { combatant: target } = found;
 	const current = target.conditions ?? [];
 
-	if (value <= 0) {
+	const def = CONDITION_DEFINITIONS.find((d) => d.id === conditionId);
+	const clampedValue =
+		def?.maxValue === undefined ? value : Math.min(value, def.maxValue);
+
+	if (clampedValue <= 0) {
 		const filtered = current.filter((c) => c.id !== conditionId);
 		const newConditions = filtered.length > 0 ? filtered : undefined;
 		return {
@@ -106,7 +110,7 @@ export function setConditionValue(
 	const existing = current.find((c) => c.id === conditionId);
 	if (existing) {
 		const updated = current.map((c) =>
-			c.id === conditionId ? { ...c, value } : c,
+			c.id === conditionId ? { ...c, value: clampedValue } : c,
 		);
 		return {
 			encounter: applyConditions(encounter, combatantId, updated),
@@ -115,17 +119,25 @@ export function setConditionValue(
 					type: "ConditionAdded",
 					combatantId,
 					condition: conditionId,
-					value,
+					value: clampedValue,
 				},
 			],
 		};
 	}
 
-	const added = sortByDefinitionOrder([...current, { id: conditionId, value }]);
+	const added = sortByDefinitionOrder([
+		...current,
+		{ id: conditionId, value: clampedValue },
+	]);
 	return {
 		encounter: applyConditions(encounter, combatantId, added),
 		events: [
-			{ type: "ConditionAdded", combatantId, condition: conditionId, value },
+			{
+				type: "ConditionAdded",
+				combatantId,
+				condition: conditionId,
+				value: clampedValue,
+			},
 		],
 	};
 }

packages/domain/src/types.ts

@@ -7,6 +7,7 @@ export function combatantId(id: string): CombatantId {
 
 import type { ConditionEntry } from "./conditions.js";
 import type { CreatureId } from "./creature-types.js";
+import type { PersistentDamageEntry } from "./persistent-damage.js";
 import type { PlayerCharacterId } from "./player-character-types.js";
 
 export interface Combatant {
@@ -18,8 +19,10 @@ export interface Combatant {
 	readonly tempHp?: number;
 	readonly ac?: number;
 	readonly conditions?: readonly ConditionEntry[];
+	readonly persistentDamage?: readonly PersistentDamageEntry[];
 	readonly isConcentrating?: boolean;
 	readonly creatureId?: CreatureId;
+	readonly creatureAdjustment?: "weak" | "elite";
 	readonly cr?: string;
 	readonly side?: "party" | "enemy";
 	readonly color?: string;

scripts/check-lint-ignores.mjs

@@ -1,29 +1,14 @@
 /**
- * Backpressure check for biome-ignore comments.
+ * Zero-tolerance check for biome-ignore comments.
  *
- * 1. Ratcheting cap — source and test files have separate max counts.
+ * Any `biome-ignore` in tracked .ts/.tsx files fails the build.
- *    Lower these numbers as you fix ignores; they can never go up silently.
+ * Fix the underlying issue instead of suppressing the rule.
- * 2. Banned rules — ignoring certain rule categories is never allowed.
- * 3. Justification — every ignore must have a non-empty explanation after
- *    the rule name.
  */
 
 import { execSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 
-// ── Configuration ──────────────────────────────────────────────────────
+const IGNORE_PATTERN = /biome-ignore\s+([\w/]+)/;
-const MAX_SOURCE_IGNORES = 2;
-const MAX_TEST_IGNORES = 3;
-
-/** Rule prefixes that must never be suppressed. */
-const BANNED_PREFIXES = [
-	"lint/security/",
-	"lint/correctness/noGlobalObjectCalls",
-	"lint/correctness/noUnsafeFinally",
-];
-// ───────────────────────────────────────────────────────────────────────
-
-const IGNORE_PATTERN = /biome-ignore\s+([\w/]+)(?::\s*(.*))?/;
 
 function findFiles() {
 	return execSync("git ls-files -- '*.ts' '*.tsx'", { encoding: "utf-8" })
@@ -32,17 +17,7 @@ function findFiles() {
 		.filter(Boolean);
 }
 
-function isTestFile(path) {
+let count = 0;
-	return (
-		path.includes("__tests__/") ||
-		path.endsWith(".test.ts") ||
-		path.endsWith(".test.tsx")
-	);
-}
-
-let errors = 0;
-let sourceCount = 0;
-let testCount = 0;
 
 for (const file of findFiles()) {
 	const lines = readFileSync(file, "utf-8").split("\n");
@@ -51,58 +26,16 @@ for (const file of findFiles()) {
 		const match = lines[i].match(IGNORE_PATTERN);
 		if (!match) continue;
 
-		const rule = match[1];
+		count++;
-		const justification = (match[2] ?? "").trim();
+		console.error(`FORBIDDEN: ${file}:${i + 1} — biome-ignore ${match[1]}`);
-		const loc = `${file}:${i + 1}`;
-
-		// Count by category
-		if (isTestFile(file)) {
-			testCount++;
-		} else {
-			sourceCount++;
-		}
-
-		// Banned rules
-		for (const prefix of BANNED_PREFIXES) {
-			if (rule.startsWith(prefix)) {
-				console.error(`BANNED: ${loc} — ${rule} must not be suppressed`);
-				errors++;
-			}
-		}
-
-		// Justification required
-		if (!justification) {
-			console.error(
-				`MISSING JUSTIFICATION: ${loc} — biome-ignore ${rule} needs an explanation after the colon`,
-			);
-			errors++;
-		}
 	}
 }
 
-// Ratcheting caps
+if (count > 0) {
-if (sourceCount > MAX_SOURCE_IGNORES) {
 	console.error(
-		`SOURCE CAP EXCEEDED: ${sourceCount} biome-ignore comments in source (max ${MAX_SOURCE_IGNORES}). Fix issues and lower the cap.`,
+		`\n${count} biome-ignore comment(s) found. Fix the issue or restructure the code.`,
 	);
-	errors++;
-}
-
-if (testCount > MAX_TEST_IGNORES) {
-	console.error(
-		`TEST CAP EXCEEDED: ${testCount} biome-ignore comments in tests (max ${MAX_TEST_IGNORES}). Fix issues and lower the cap.`,
-	);
-	errors++;
-}
-
-// Summary
-console.log(
-	`biome-ignore: ${sourceCount} source (max ${MAX_SOURCE_IGNORES}), ${testCount} test (max ${MAX_TEST_IGNORES})`,
-);
-
-if (errors > 0) {
-	console.error(`\n${errors} problem(s) found.`);
 	process.exit(1);
 } else {
-	console.log("All checks passed.");
+	console.log("biome-ignore: 0 — all clear.");
 }

specs/001-combatant-management/spec.md

@@ -128,6 +128,22 @@ A user wants to rename a combatant. Clicking the combatant's name immediately en
 
 4. **Given** a bestiary combatant row and a custom combatant row, **When** the user clicks either combatant's name, **Then** the behavior is identical — inline edit mode is entered immediately in both cases.
 
+**Story C4 — Name Updates on Weak/Elite Toggle (Priority: P2)**
+
+When a PF2e weak/elite adjustment is toggled on a bestiary-linked combatant, the name automatically gains or loses a "Weak" or "Elite" prefix. Auto-numbered suffixes are preserved (e.g., "Goblin 2" → "Elite Goblin 2"). Toggling back to Normal removes the prefix. Existing auto-numbering of other combatants is not affected.
+
+**Acceptance Scenarios**:
+
+1. **Given** a combatant named "Iron Hag", **When** the DM toggles to "Elite", **Then** the name becomes "Elite Iron Hag".
+
+2. **Given** a combatant named "Goblin 2", **When** the DM toggles to "Weak", **Then** the name becomes "Weak Goblin 2".
+
+3. **Given** a combatant named "Elite Iron Hag", **When** the DM toggles back to "Normal", **Then** the name becomes "Iron Hag".
+
+4. **Given** "Goblin 1" and "Goblin 2" exist, **When** the DM toggles "Goblin 1" to "Elite", **Then** it becomes "Elite Goblin 1" and "Goblin 2" is not renamed.
+
+5. **Given** a combatant named "Elite Goblin 1", **When** the DM manually renames it to "Big Boss", **Then** the rename proceeds normally (manual names override the prefix convention).
+
 ---
 
 ### Clearing the Encounter
@@ -291,6 +307,12 @@ EditCombatant MUST preserve the combatant's position in the list, `activeIndex`,
 #### FR-024 — Edit: UI
 The UI MUST provide an inline name-edit mechanism for each combatant, activated by a single click on the name. Clicking the name MUST enter inline edit mode immediately — no delay, no timer, consistent for all combatant types. The name MUST display a `cursor-text` cursor on hover to signal editability. The updated name MUST be immediately visible after submission. The 250ms click timer and double-click detection logic MUST be removed entirely.
 
+#### FR-041 — Edit: Weak/Elite name prefix
+When a PF2e weak/elite adjustment is toggled on a bestiary-linked combatant (see `specs/004-bestiary/spec.md`, FR-101), the system MUST prepend "Weak " or "Elite " to the combatant's name, preserving any auto-numbered suffix. Toggling to "Normal" MUST remove the prefix. Switching directly between "Weak" and "Elite" MUST swap the prefix.
+
+#### FR-042 — Edit: Prefix does not trigger re-numbering
+Adding or removing a weak/elite prefix MUST NOT trigger auto-numbering recalculation for other combatants. "Goblin 1" becoming "Elite Goblin 1" does not cause "Goblin 2" to be renumbered.
+
 #### FR-025 — ConfirmButton: Reusable component
 The system MUST provide a reusable `ConfirmButton` component that wraps any icon button to add a two-step confirmation flow.
 
@@ -363,6 +385,7 @@ All domain events MUST be returned as plain data values from operations, not dis
 - **ConfirmButton: two instances in confirm state simultaneously**: Each manages its own state independently.
 - **ConfirmButton: combatant row re-renders while in confirm state**: Confirm state persists through re-renders as long as combatant identity is stable.
 - **Name click behavior is uniform**: A single click on any combatant's name enters inline edit mode immediately. There is no gesture disambiguation (no timer, no double-click detection). Stat block access is handled via the dedicated book icon on bestiary rows (see `specs/004-bestiary/spec.md`, FR-062).
+- **Weak/elite prefix on a manually renamed combatant**: If the user manually renames "Elite Goblin" to "Big Boss" and then toggles to Normal, the prefix "Elite " is not present to remove — the name "Big Boss" remains unchanged.
 
 ---
 

specs/003-combatant-state/spec.md

@@ -25,6 +25,7 @@ interface Combatant {
   readonly ac?: number;               // non-negative integer
   readonly conditions?: readonly ConditionEntry[];
   readonly isConcentrating?: boolean;
+  readonly persistentDamage?: readonly PersistentDamageEntry[];  // PF2e only
   readonly creatureId?: CreatureId;   // link to bestiary entry
 }
 
@@ -32,6 +33,11 @@ interface ConditionEntry {
   readonly id: ConditionId;
   readonly value?: number;  // PF2e valued conditions (e.g., Clumsy 2); undefined for D&D
 }
+
+interface PersistentDamageEntry {
+  readonly type: PersistentDamageType;  // "fire" | "bleed" | "acid" | "cold" | "electricity" | "poison" | "mental"
+  readonly formula: string;             // e.g., "2d6", "1d4+2"
+}
 ```
 
 ---
@@ -115,6 +121,15 @@ Acceptance scenarios:
 7. **Given** no combatant has temp HP, **When** viewing the encounter, **Then** no extra space is reserved for temp HP display.
 8. **Given** one combatant has temp HP, **When** viewing the encounter, **Then** all rows reserve space for the temp HP display to maintain column alignment.
 
+**Story HP-8 — HP Adjusts on Weak/Elite Toggle (P2)**
+As a game master toggling a PF2e creature between weak, normal, and elite, I want the combatant's max HP and current HP to update automatically so that the tracker reflects the adjusted creature's durability.
+
+Acceptance scenarios:
+1. **Given** a combatant with 75/75 HP (Normal), **When** the DM toggles to "Elite" (HP bracket +20), **Then** maxHp becomes 95 and currentHp becomes 95.
+2. **Given** a combatant with 65/75 HP (Normal, 10 damage taken), **When** the DM toggles to "Elite" (HP bracket +20), **Then** maxHp becomes 95 and currentHp becomes 85 (shifted by +20, preserving the 10-damage deficit).
+3. **Given** a combatant with 5/75 HP (Normal), **When** the DM toggles to "Weak" (HP bracket −20), **Then** maxHp becomes 55 and currentHp becomes 0 (clamped, since 5−20 < 0).
+4. **Given** a combatant with 95/95 HP (Elite), **When** the DM toggles back to "Normal" (HP bracket −20), **Then** maxHp becomes 75 and currentHp becomes 75.
+
 ### Requirements
 
 - **FR-001**: Each combatant MAY have an optional `maxHp` value (positive integer >= 1). HP tracking is optional per combatant.
@@ -148,6 +163,8 @@ Acceptance scenarios:
 - **FR-029**: When any combatant in the encounter has temp HP > 0, all rows MUST reserve space for the temp HP display to maintain column alignment. When no combatant has temp HP, no space is reserved.
 - **FR-030**: The HP adjustment popover MUST include a third button (Shield icon) for setting temp HP.
 - **FR-031**: Temp HP MUST persist across page reloads via the existing persistence mechanism.
+- **FR-113**: When a PF2e weak/elite adjustment is toggled (see `specs/004-bestiary/spec.md`, FR-101), `maxHp` MUST be updated by the HP bracket delta for the creature's base level: ±10 (level ≤ 1), ±15 (level 2–4), ±20 (level 5–19), ±30 (level 20+). When switching directly between weak and elite, the full swing (reverse + apply) MUST be computed as a single delta.
+- **FR-114**: When `maxHp` changes due to a weak/elite toggle, `currentHp` MUST shift by the same delta as `maxHp`, clamped to [0, new `maxHp`]. Temp HP is unaffected.
 
 ### Edge Cases
 
@@ -166,6 +183,7 @@ Acceptance scenarios:
 - There is no death/unconscious game mechanic triggered at 0 HP; the system displays the state only.
 - There is no damage type tracking, resistance/vulnerability calculation, or hit log in the MVP baseline.
 - There is no undo/redo for HP changes in the MVP baseline.
+- Weak/elite toggle when combatant has temp HP: temp HP is unaffected; only maxHp and currentHp change. A combatant at 10+5/75 toggled to Elite becomes 30+5/95.
 
 ---
 
@@ -192,6 +210,14 @@ Acceptance scenarios:
 4. **Given** the inline AC edit is active, **When** the user presses Escape, **Then** the edit is cancelled and the original value is preserved.
 5. **Given** the inline AC edit is active, **When** the user clears the field and presses Enter, **Then** AC is unset and the shield shows an empty state.
 
+**Story AC-3 — AC Adjusts on Weak/Elite Toggle (P2)**
+As a game master toggling a PF2e creature between weak, normal, and elite, I want the combatant's AC to update automatically so that the tracker reflects the adjusted creature's defenses.
+
+Acceptance scenarios:
+1. **Given** a combatant with AC 22 (Normal), **When** the DM toggles to "Elite", **Then** AC becomes 24.
+2. **Given** a combatant with AC 24 (Elite), **When** the DM toggles to "Weak", **Then** AC becomes 20 (base 22, −2 for weak).
+3. **Given** a combatant with AC 20 (Weak), **When** the DM toggles to "Normal", **Then** AC becomes 22.
+
 ### Requirements
 
 - **FR-023**: Each combatant MAY have an optional `ac` value, a non-negative integer (>= 0).
@@ -203,6 +229,8 @@ Acceptance scenarios:
 - **FR-029**: AC MUST reject negative values. Zero is a valid AC.
 - **FR-030**: AC values MUST persist via the existing persistence mechanism.
 - **FR-031**: The AC shield MUST scale appropriately for single-digit, double-digit, and any valid AC values.
+- **FR-115**: When a PF2e weak/elite adjustment is toggled (see `specs/004-bestiary/spec.md`, FR-101), `ac` MUST be updated by ±2. When switching directly between weak and elite, the full swing (±4) MUST be applied as a single update.
+- **FR-116**: AC changes from weak/elite toggles MUST persist via the existing persistence mechanism, consistent with FR-030.
 
 ### Edge Cases
 
@@ -260,6 +288,8 @@ Acceptance scenarios:
 4. **Given** concentration is active and the row is not hovered, **Then** the Brain icon remains visible.
 5. **Given** concentration is active, **When** the user clicks the Brain icon again, **Then** concentration deactivates and the icon hides (unless the row is still hovered).
 6. **Given** the Brain icon is visible, **When** the user hovers over it, **Then** a tooltip reading "Concentrating" appears.
+7. **Given** the game system is Pathfinder 2e, **When** viewing any combatant row (hovered or not), **Then** the Brain icon is not shown — even if `isConcentrating` is true.
+8. **Given** a combatant has `isConcentrating` true and the game system is PF2e, **When** the user switches to a D&D system, **Then** the Brain icon appears with active styling (concentration state was preserved).
 
 **Story CC-6 — Visual Feedback for Concentration (P2)**
 As a DM, I want concentrating combatants to have a visible row accent so I can identify them at a glance without interacting.
@@ -268,6 +298,7 @@ Acceptance scenarios:
 1. **Given** concentration is active, **When** viewing the encounter tracker, **Then** the combatant row shows a colored left border accent (`border-l-purple-400`).
 2. **Given** concentration is inactive, **Then** no concentration accent is shown.
 3. **Given** concentration is toggled off, **Then** the left border accent disappears immediately.
+4. **Given** the game system is Pathfinder 2e and a combatant has `isConcentrating` true, **When** viewing the encounter tracker, **Then** no purple left border accent is shown on that row.
 
 **Story CC-7 — Damage Pulse Alert (P3)**
 As a DM, I want a visual alert when a concentrating combatant takes damage so I remember to call for a concentration check.
@@ -277,6 +308,7 @@ Acceptance scenarios:
 2. **Given** a combatant is concentrating, **When** the combatant is healed, **Then** no pulse/flash occurs.
 3. **Given** a combatant is NOT concentrating, **When** damage is taken, **Then** no pulse/flash occurs.
 4. **Given** a concentrating combatant takes damage, **When** the animation completes, **Then** the row returns to its normal concentration-active appearance.
+5. **Given** the game system is Pathfinder 2e and a combatant has `isConcentrating` true, **When** the combatant takes damage, **Then** no pulse/flash animation occurs.
 
 **Story CC-8 — Game System Setting (P2)**
 As a DM who runs games across D&D 5e, 5.5e, and Pathfinder 2e, I want to choose which game system the tracker uses so that conditions, bestiary search, stat block layout, and initiative calculation all match the game I am running.
@@ -310,6 +342,29 @@ Acceptance scenarios:
 9. **Given** a combatant has Clumsy 3, **When** the user hovers over the condition icon, **Then** the tooltip shows the condition name, the current value, and the PF2e rules description.
 10. **Given** a valued condition counter is showing, **When** the user clicks a different valued condition, **Then** the previous counter is replaced (only one counter at a time).
 
+**Story CC-10 — Condition Value Maximums (P2)**
+As a DM running a PF2e encounter, I want valued conditions to be capped at their rule-defined maximum so I cannot accidentally increment them beyond their meaningful range.
+
+Acceptance scenarios:
+1. **Given** the game system is Pathfinder 2e, **When** a valued condition reaches its maximum (dying 4, doomed 3, wounded 3, slowed 3), **Then** the `[+]` button in the condition picker counter is disabled.
+2. **Given** a combatant has Dying 4, **When** the user opens the condition picker, **Then** the counter shows 4 and `[+]` is disabled; `[-]` and `[✓]` remain active.
+3. **Given** a combatant has Slowed 3, **When** the user clicks the Slowed icon tag on the row, **Then** the value decrements to 2 (decrement is unaffected by the cap).
+4. **Given** the game system is D&D (5e or 5.5e), **When** interacting with conditions, **Then** no maximum enforcement is applied.
+5. **Given** a PF2e valued condition without a defined maximum (e.g., Frightened, Clumsy), **When** incrementing, **Then** no cap is enforced — the value can increase without limit.
+
+**Story CC-11 — Persistent Damage Tags (P2)**
+As a DM running a PF2e encounter, I want to apply persistent damage to a combatant as a compact tag showing a damage type icon and formula so I can track ongoing damage effects without manual bookkeeping.
+
+Acceptance scenarios:
+1. **Given** the game system is Pathfinder 2e and the condition picker is open, **When** the user clicks "Persistent Damage", **Then** a sub-picker opens with a damage type dropdown (fire, bleed, acid, cold, electricity, poison, mental, force, void, spirit, vitality, piercing) and a formula text input.
+2. **Given** the sub-picker is open, **When** the user selects "fire" and types "2d6" and confirms, **Then** a compact tag appears on the combatant row showing a fire icon and "2d6".
+3. **Given** a combatant has persistent fire 2d6, **When** the user adds persistent bleed 1d4, **Then** both tags appear on the row simultaneously.
+4. **Given** a combatant has persistent fire 2d6, **When** the user adds persistent fire 3d6, **Then** the existing fire entry is replaced with 3d6 (one instance per type).
+5. **Given** a combatant has a persistent damage tag, **When** the user clicks the tag on the row, **Then** the persistent damage entry is removed.
+6. **Given** a combatant has a persistent damage tag, **When** the user hovers over it, **Then** a tooltip shows the full description (e.g., "Persistent Fire 2d6 — Take damage at end of turn. DC 15 flat check to end.").
+7. **Given** the game system is D&D (5e or 5.5e), **When** viewing the condition picker, **Then** no "Persistent Damage" option is available.
+8. **Given** a combatant has persistent damage entries, **When** the page is reloaded, **Then** all entries are restored exactly.
+
 ### Requirements
 
 - **FR-032**: When a D&D game system is active, the system MUST support the following 15 standard D&D 5e/5.5e conditions: blinded, charmed, deafened, exhaustion, frightened, grappled, incapacitated, invisible, paralyzed, petrified, poisoned, prone, restrained, stunned, unconscious. When Pathfinder 2e is active, the system MUST support the PF2e condition set (see FR-103).
@@ -360,6 +415,20 @@ Acceptance scenarios:
 - **FR-105**: For PF2e valued conditions, the condition icon tag MUST display the current value as a small numeric badge (e.g., "2" next to the Frightened icon). Non-valued PF2e conditions display without a badge.
 - **FR-106**: The condition data model MUST use `ConditionEntry` objects (`{ id: ConditionId, value?: number }`) instead of bare `ConditionId` values. D&D conditions MUST be stored without a `value` field (backwards-compatible).
 - **FR-107**: Switching the game system MUST NOT clear existing combatant conditions. Conditions from the previous game system that are not valid in the new system remain stored but are hidden from display until the user switches back.
+- **FR-108**: The following PF2e valued conditions MUST have maximum values enforced: dying (max 4), doomed (max 3), wounded (max 3), slowed (max 3). All other valued conditions have no enforced maximum.
+- **FR-109**: When a PF2e valued condition is at its maximum value, the `[+]` increment button in the condition picker counter MUST be disabled (visually dimmed and non-interactive).
+- **FR-110**: Maximum value enforcement MUST only apply when the Pathfinder 2e game system is active. D&D conditions are unaffected.
+- **FR-111**: When Pathfinder 2e is the active game system, the concentration UI (Brain icon toggle, purple left border accent, damage pulse animation) MUST be hidden entirely. The Brain icon MUST NOT be shown on hover or at rest, and the concentration toggle MUST NOT be interactive.
+- **FR-112**: Switching the game system MUST NOT clear or modify `isConcentrating` state on any combatant. The state MUST be preserved in storage and restored to the UI when switching back to a D&D game system.
+- **FR-117**: When Pathfinder 2e is active, the condition picker MUST include a "Persistent Damage" entry that opens a sub-picker instead of toggling directly.
+- **FR-118**: The persistent damage sub-picker MUST contain a dropdown of PF2e damage types (fire, bleed, acid, cold, electricity, poison, mental, force, void, spirit, vitality, piercing) and a text input for the damage formula (e.g., "2d6").
+- **FR-119**: Each persistent damage entry MUST be displayed as a compact tag on the combatant row showing a damage type icon and the formula text (e.g., fire icon + "2d6").
+- **FR-120**: Only one persistent damage entry per damage type is allowed per combatant. Adding the same damage type MUST replace the existing formula.
+- **FR-121**: Clicking a persistent damage tag on the combatant row MUST remove that entry.
+- **FR-122**: Hovering a persistent damage tag MUST show a tooltip with the full description: "{Type} {formula} — Take damage at end of turn. DC 15 flat check to end."
+- **FR-123**: Persistent damage MUST NOT be available when a D&D game system is active.
+- **FR-124**: Persistent damage entries MUST persist across page reloads via the existing persistence mechanism.
+- **FR-125**: Persistent damage tags MUST be displayed inline after condition icons, following the same wrapping behavior as conditions (FR-041).
 
 ### Edge Cases
 
@@ -375,8 +444,13 @@ Acceptance scenarios:
 - The settings modal is app-level UI; it does not interact with encounter state.
 - When the game system is switched from D&D to PF2e, existing D&D conditions on combatants are hidden (not deleted). Switching back to D&D restores them.
 - PF2e valued condition at value 0 is treated as removed — it MUST NOT appear on the row.
-- Dying 4 in PF2e has special mechanical significance (death), but the system does not enforce this automatically — it displays the value only.
+- Dying, doomed, wounded, and slowed have enforced maximum values in PF2e (4, 3, 3, 3 respectively). The `[+]` button is disabled at the cap. The dynamic dying cap based on doomed value (dying max = 4 − doomed) is not enforced — only the static maximum applies.
-- Persistent damage is excluded from the PF2e MVP condition set. It can be added as a follow-up feature.
+- Persistent damage tags are separate from the `conditions` array — they use a dedicated `persistentDamage` field on `Combatant`.
+- Adding persistent damage with an empty formula is rejected; the formula field must be non-empty.
+- When the game system is switched from PF2e to D&D, existing persistent damage entries are preserved in storage but hidden from display, consistent with condition behavior (FR-107).
+- Persistent damage has no automation — the system does not auto-apply damage or prompt for flat checks. It is a visual reminder only.
+- The persistent damage sub-picker closes when the user clicks outside of it or confirms an entry.
+- When PF2e is active, concentration state (`isConcentrating`) is preserved in storage but the entire concentration UI is hidden. Switching back to D&D restores Brain icons, purple borders, and pulse behavior without data loss.
 
 ---
 
@@ -580,3 +654,5 @@ Acceptance scenarios:
 - **SC-035**: PF2e valued conditions display their current value and can be incremented/decremented within 1 click each.
 - **SC-036**: Switching game system immediately changes the available conditions, bestiary search results, stat block layout, and initiative calculation — no page reload required.
 - **SC-037**: The game system preference survives a full page reload.
+- **SC-038**: A persistent damage entry can be added to a combatant in 3 clicks or fewer (click "+", click "Persistent Damage", select type + enter formula + confirm).
+- **SC-039**: Persistent damage tags are visually distinguishable from conditions by their icon + formula format.

specs/004-bestiary/spec.md

@@ -98,10 +98,30 @@ A view button in the search bar (repurposed from the current search icon) opens
 **US-D3 — Responsive Layout (P4)**
 As a DM using the app on different devices, I want the layout to adapt between side-by-side (desktop) and drawer (mobile) so that the stat block is usable regardless of screen size.
 
+**US-D4 — View Spell Descriptions Inline (P2)**
+As a DM running a PF2e encounter, I want to click a spell name in a creature's stat block to see the spell's full description without leaving the stat block, so I can quickly resolve what a spell does mid-combat without consulting external tools.
+
+A click on any spell name in the spellcasting section opens a popover (desktop) or bottom sheet (mobile) showing the spell's description, level, traits, range, action cost, target/area, duration, defense/save, and heightening rules. The data is read directly from the cached creature data (already embedded in NPC JSON from Foundry VTT) — no additional network fetch is required, and the feature works offline once the source has been loaded. Dismiss with click-outside, Escape, or (on mobile) swipe-down.
+
+**US-D5 — View Recall Knowledge DC and Skill (P2)**
+As a DM running a PF2e encounter, I want to see the Recall Knowledge DC and associated skill on a creature's stat block so I can quickly tell players the DC and which skill to roll without looking it up in external tools.
+
+The Recall Knowledge line appears below the trait tags, showing the DC (calculated from the creature's level using the PF2e standard DC-by-level table, adjusted for rarity) and the skill determined by the creature's type trait. The line is omitted for creatures with no recognized type trait and never shown for D&D creatures.
+
+**US-D6 — View NPC Equipment and Consumables (P2)**
+As a DM running a PF2e encounter, I want to see a creature's carried equipment — magic weapons, potions, scrolls, wands, and other items — displayed on its stat block so I can use these tactical options in combat without consulting external tools.
+
+An "Equipment" section appears on the stat block listing each carried item with its name and relevant details (level, traits, activation description). Scrolls additionally show the embedded spell name and rank (e.g., "Scroll of Teleport (Rank 6)"). The section is omitted entirely for creatures that carry no equipment. Equipment data is extracted from the existing cached creature JSON — no additional fetch is required.
+
+**US-D7 — Toggle Weak/Elite Adjustment on PF2e Stat Block (P2)**
+As a DM running a PF2e encounter, I want to toggle a weak or elite adjustment on a bestiary-linked combatant's stat block so that the standard PF2e stat modifications are applied to that specific combatant and reflected in both the stat block and the tracker.
+
+When viewing a PF2e creature's stat block, a Weak/Normal/Elite toggle appears in the header. Selecting "Elite" or "Weak" applies the standard PF2e adjustments: ±2 to AC, saves, Perception, attack rolls, and strike damage; HP adjusted by the standard level bracket table; level shifted. The combatant's stored HP and AC update accordingly (see `specs/003-combatant-state/spec.md`, FR-113–FR-116), and its name gains a prefix (see `specs/001-combatant-management/spec.md`, FR-041–FR-042). The toggle defaults to "Normal" and is not shown for D&D creatures. A visual indicator (the same icon used in the toggle) appears next to the creature name in the header.
+
 ### Requirements
 
 - **FR-016**: The system MUST display a stat block panel with full creature information when a creature is selected.
-- **FR-017**: For D&D creatures, the stat block MUST include: name, size, type, alignment, AC (with armor source if applicable), HP (average + formula), speed, ability scores with modifiers, saving throws, skills, damage vulnerabilities, damage resistances, damage immunities, condition immunities, senses, languages, challenge rating, proficiency bonus, passive perception, traits, actions, bonus actions, reactions, spellcasting, and legendary actions. For PF2e creatures, the stat block MUST include: name, level, traits (as tags), Perception and senses, languages, skills, ability modifiers (Str/Dex/Con/Int/Wis/Cha as modifiers, not scores), items, AC, saving throws (Fort/Ref/Will), HP (with optional immunities/resistances/weaknesses), speed, attacks, top abilities, mid abilities (reactions/auras), bot abilities (active), and spellcasting.
+- **FR-017**: For D&D creatures, the stat block MUST include: name, size, type, alignment, AC (with armor source if applicable), HP (average + formula), speed, ability scores with modifiers, saving throws, skills, damage vulnerabilities, damage resistances, damage immunities, condition immunities, senses, languages, challenge rating, proficiency bonus, passive perception, traits, actions, bonus actions, reactions, spellcasting, and legendary actions. For PF2e creatures, the stat block MUST include: name, level, traits (as tags), Perception (with details text such as "smoke vision" alongside senses), languages, skills, ability modifiers (Str/Dex/Con/Int/Wis/Cha as modifiers, not scores), items, AC, saving throws (Fort/Ref/Will), HP (with optional immunities/resistances/weaknesses), speed, attacks (with inline on-hit effects), abilities with frequency limits where applicable, top abilities, mid abilities (reactions/auras), bot abilities (active), spellcasting, and equipment (weapons, consumables, and other carried items).
 - **FR-018**: Optional stat block sections (traits, legendary actions, bonus actions, reactions, etc.) MUST be omitted entirely when the creature has none.
 - **FR-019**: The system MUST strip bestiary markup tags (spell references, dice notation, attack tags) and render them as plain readable text (e.g., `{@spell fireball|XPHB}` -> "fireball", `{@dice 3d6}` -> "3d6").
 - **FR-020**: On wide viewports (desktop), the layout MUST be side-by-side with the encounter tracker on the left and stat block on the right.
@@ -116,6 +136,21 @@ As a DM using the app on different devices, I want the layout to adapt between s
 - **FR-067**: PF2e stat blocks MUST organize abilities into three sections: top (above defenses), mid (reactions and auras), and bot (active abilities), matching the Foundry VTT PF2e item categorization.
 - **FR-068**: PF2e stat blocks MUST strip HTML tags from Foundry VTT ability descriptions and render them as plain readable text. The HTML-to-text conversion serves the same role as the D&D tag-stripping approach (FR-019).
 - **FR-062**: Bestiary-linked combatant rows MUST display a small book icon (Lucide `BookOpen`) as the dedicated stat block trigger. The icon MUST have a tooltip ("View stat block") and an `aria-label="View stat block"` for accessibility. The book icon is the only way to manually open a stat block from the tracker — clicking the combatant name always enters inline rename mode. Non-bestiary combatant rows MUST NOT display the book icon.
+- **FR-077**: PF2e stat blocks MUST render each spell name in the spellcasting section as an interactive element (clickable button), not as plain joined text.
+- **FR-078**: Clicking a spell name MUST open a popover (desktop) or bottom sheet (mobile) displaying the spell's description, level, traits, range, time/actions, target/area, duration, defense/save, and heightening rules.
+- **FR-079**: The spell description popover/sheet MUST render content from the spell data already embedded in the cached creature JSON — no additional network fetch is required.
+- **FR-080**: The spell description popover/sheet MUST be dismissible by clicking outside, pressing Escape, or (on mobile) swiping the sheet down.
+- **FR-081**: Spell descriptions MUST be processed through the existing Foundry tag-stripping utility before display (consistent with FR-068).
+- **FR-082**: When a spell name has a parenthetical modifier (e.g., "Heal (×3)", "Unfettered Movement (Constant)"), only the spell name portion MUST be the click target; the modifier MUST remain as adjacent plain text.
+- **FR-083**: The spell description display MUST handle both representations of heightening present in Foundry VTT data: `system.heightening` and `system.overlays`.
+- **FR-101**: PF2e stat blocks MUST include a Weak/Normal/Elite toggle in the header, defaulting to "Normal".
+- **FR-102**: The Weak/Normal/Elite toggle MUST NOT be shown for D&D creatures or non-bestiary combatants.
+- **FR-103**: Selecting "Elite" MUST display the stat block with the standard PF2e elite adjustment applied: +2 to AC, saving throws, Perception, and attack rolls; +2 to strike damage; HP increase by level bracket (per the standard PF2e table); level +1 (or +2 if base level ≤ 0).
+- **FR-104**: Selecting "Weak" MUST display the stat block with the standard PF2e weak adjustment applied: −2 to AC, saving throws, Perception, and attack rolls; −2 to strike damage; HP decrease by level bracket (per the standard PF2e table); level −1 (or −2 if base level is 1).
+- **FR-105**: Toggling the adjustment MUST update the combatant's stored maxHp and ac to the adjusted values (see `specs/003-combatant-state/spec.md`, FR-113–FR-116). The combatant's currentHp MUST shift by the same delta as maxHp, clamped to [0, new maxHp].
+- **FR-106**: Toggling the adjustment MUST update the combatant's name with the appropriate prefix — "Weak" or "Elite" — or remove the prefix when returning to "Normal" (see `specs/001-combatant-management/spec.md`, FR-041–FR-042).
+- **FR-107**: The stat block header MUST display a visual indicator (the same icon used in the toggle) next to the creature name when the creature has a weak or elite adjustment.
+- **FR-108**: The adjustment MUST be stored on the combatant as a `creatureAdjustment` field and persist across page reloads.
 
 ### Acceptance Scenarios
 
@@ -131,12 +166,56 @@ As a DM using the app on different devices, I want the layout to adapt between s
 10. **Given** a bestiary-linked combatant row is visible, **When** the user clicks the combatant's name, **Then** inline rename mode is entered — the stat block does NOT open.
 11. **Given** a PF2e creature is selected, **When** the stat block opens, **Then** it displays: name, level, traits as tags, Perception, senses, languages, skills, ability modifiers, AC, Fort/Ref/Will saves, HP, speed, attacks, abilities (top/mid/bot sections), and spellcasting (if applicable). No CR, no ability scores, no legendary actions.
 12. **Given** a PF2e creature with conditional AC (e.g., "with shield raised"), **When** viewing the stat block, **Then** both the standard AC and conditional AC are shown.
+13. **Given** a PF2e creature with spellcasting is displayed in the stat block panel, **When** the DM clicks a spell name in the spellcasting section, **Then** a popover (desktop) or bottom sheet (mobile) opens showing the spell's description, level, traits, range, action cost, and any heightening rules.
+14. **Given** the spell description popover is open, **When** the DM clicks outside it or presses Escape, **Then** the popover dismisses.
+15. **Given** the spell description bottom sheet is open on mobile, **When** the DM swipes the sheet down, **Then** the sheet dismisses.
+16. **Given** a creature from a legacy (non-remastered) PF2e source has spells with pre-remaster names (e.g., "Magic Missile", "True Strike"), **When** the DM clicks one of those spell names, **Then** the spell description still displays correctly using the embedded data.
+17. **Given** a spell name appears as "Heal (×3)" in the stat block, **When** the DM looks at the rendered output, **Then** "Heal" is the clickable element and "(×3)" appears as plain text next to it.
+18. **Given** a PF2e creature with level 5 and common rarity is displayed, **When** the DM views the stat block, **Then** a "Recall Knowledge" line appears below the trait tags showing the DC calculated from level 5 (DC 20) and the skill derived from the creature's type trait.
+19. **Given** a PF2e creature with rare rarity is displayed, **When** the DM views the stat block, **Then** the Recall Knowledge DC is the standard DC for its level +5.
+20. **Given** a PF2e creature with the "Undead" type trait is displayed, **When** the DM views the stat block, **Then** the Recall Knowledge line shows "Religion" as the associated skill.
+21. **Given** a D&D creature is displayed, **When** the DM views the stat block, **Then** no Recall Knowledge line is shown.
+22. **Given** a PF2e creature carrying a Staff of Fire and an Invisibility Potion is displayed, **When** the DM views the stat block, **Then** an "Equipment" section appears listing both items with their names and relevant details.
+23. **Given** a PF2e creature carrying a Scroll of Teleport Rank 6 is displayed, **When** the DM views the stat block, **Then** the Equipment section shows the scroll with the embedded spell name and rank (e.g., "Scroll of Teleport (Rank 6)").
+24. **Given** a PF2e creature with no equipment items is displayed, **When** the DM views the stat block, **Then** no Equipment section is shown.
+25. **Given** a PF2e creature with equipment is displayed, **When** the DM views the stat block, **Then** equipment item descriptions have HTML tags stripped and render as plain readable text.
+26. **Given** a D&D creature is displayed, **When** the DM views the stat block, **Then** no Equipment section is shown (equipment display is PF2e-only).
+27. **Given** a PF2e creature with a melee attack that has `attackEffects: ["grab"]`, **When** the DM views the stat block, **Then** the attack line shows the damage followed by "plus Grab".
+28. **Given** a PF2e creature with a melee attack that has no attack effects, **When** the DM views the stat block, **Then** the attack line shows only the damage with no "plus" suffix.
+29. **Given** a PF2e creature with an ability that has `frequency: {max: 1, per: "day"}`, **When** the DM views the stat block, **Then** the ability name is followed by "(1/day)".
+30. **Given** a PF2e creature with an ability that has no frequency limit, **When** the DM views the stat block, **Then** the ability name renders without any frequency annotation.
+31. **Given** a PF2e creature with `perception.details: "smoke vision"`, **When** the DM views the stat block, **Then** the perception line shows "smoke vision" alongside the senses.
+32. **Given** a PF2e creature with no perception details, **When** the DM views the stat block, **Then** the perception line shows only the modifier and senses as before.
+33. **Given** a PF2e creature's stat block is open, **When** the DM views the header, **Then** a Weak/Normal/Elite toggle is visible, set to "Normal" by default.
+34. **Given** a D&D creature's stat block is open, **When** the DM views the header, **Then** no Weak/Normal/Elite toggle is shown.
+35. **Given** a PF2e creature (level 5, AC 22, HP 75) stat block is open, **When** the DM selects "Elite", **Then** the stat block shows AC 24, HP 95 (75+20 for level 5 bracket), level 6, and all saves/Perception/attacks are adjusted by +2.
+36. **Given** a PF2e creature (level 5, AC 22, HP 75) stat block is open, **When** the DM selects "Weak", **Then** the stat block shows AC 20, HP 55 (75−20 for level 5 bracket), level 4, and all saves/Perception/attacks are adjusted by −2.
+37. **Given** a PF2e creature with level 0 stat block is open, **When** the DM selects "Elite", **Then** the level increases by 2 (not 1).
+38. **Given** a PF2e creature with level 1 stat block is open, **When** the DM selects "Weak", **Then** the level decreases by 2 (to −1, not 0).
+39. **Given** a PF2e combatant was set to "Elite" and the page is reloaded, **When** the DM opens the stat block, **Then** the toggle shows "Elite" and the stat block displays adjusted stats.
+40. **Given** a PF2e combatant was set to "Elite", **When** the DM toggles back to "Normal", **Then** the stat block reverts to base stats, the combatant's HP/AC revert, and the name prefix is removed.
 
 ### Edge Cases
 
 - Creatures with no traits or legendary actions: those sections are omitted from the stat block display.
 - Very long content (e.g., a Lich with extensive spellcasting): the stat block panel scrolls independently of the encounter tracker.
 - Viewport resized from wide to narrow while stat block is open: the layout transitions from panel to drawer.
+- Embedded spell item missing description text: the popover/sheet shows the available metadata (level, traits, range, etc.) and a placeholder note for the missing description.
+- Scroll item with missing or empty `system.spell` data: the scroll is displayed by name only, without spell name or rank.
+- Equipment item with empty description: the item is displayed with its name and metadata (level, traits) but no description text.
+- Cached source data from before the spell description feature was added: existing cached entries lack the new per-spell data fields. The IndexedDB schema version MUST be bumped to invalidate old caches and trigger re-fetch (re-normalization from raw Foundry data is not possible because the original raw JSON is not retained).
+- Creature with no recognized type trait (e.g., a creature whose only traits are not in the type-to-skill mapping): the Recall Knowledge line is omitted entirely.
+- Weak adjustment on a level 1 creature: level becomes −1 (special case, −2 instead of −1).
+- Elite adjustment on a level ≤ 0 creature: level increases by 2 instead of 1.
+- HP bracket table: HP adjustments follow the standard PF2e weak/elite HP adjustment table keyed by creature level (1 or lower: ±10, 2–4: ±15, 5–19: ±20, 20+: ±30).
+- Toggling from Elite to Weak: applies the full swing (reverts elite, then applies weak) in a single operation.
+- Combatant has taken damage before toggle: currentHp shifts by the maxHp delta, clamped to [0, new maxHp]. E.g., 65/75 HP → Elite → 85/95 HP.
+- Source data not yet cached when toggling: toggle is disabled until source data is loaded (adjustment requires full creature data to compute).
+- Recall Knowledge DC updates based on adjusted level.
+- Creature with a type trait that maps to multiple skills (e.g., Beast → Arcana/Nature): both skills are shown.
+- Attack with multiple on-hit effects (e.g., `["grab", "knockdown"]`): all effects shown, joined with "and" (e.g., "plus Grab and Knockdown").
+- Attack effect slug with creature-name prefix (e.g., `"lich-siphon-life"` on a Lich): the creature-name prefix is stripped, rendering as "Siphon Life".
+- Frequency `per` value variations (e.g., "day", "round", "turn"): the value is rendered as-is in the "(N/per)" format.
 
 ---
 
@@ -197,6 +276,23 @@ A DM wants to see which sources are cached, find a specific source, clear a spec
 - **FR-074**: The PF2e index MUST exclude legacy/pre-remaster creatures based on the `publication.remaster` field — only remaster-era content is included by default.
 - **FR-075**: PF2e creature abilities MUST have complete descriptive text in stat blocks. Stubs, generic feat references, and unresolved copy entries are not acceptable.
 - **FR-076**: The PF2e index SHOULD carry per-creature license tagging (ORC/OGL) derived from the Foundry VTT source data.
+- **FR-084**: The PF2e normalization pipeline MUST preserve per-spell data (slug, level, traits, range, time, target, area, duration, defense, description, heightening/overlays) from embedded `items[type=spell]` entries on NPCs, in addition to the spell name. This data MUST be stored in the cached source data and persisted across browser sessions.
+- **FR-085**: PF2e stat blocks MUST display a "Recall Knowledge" line below the trait tags showing the DC and the associated skill (e.g., "Recall Knowledge DC 18 • Undead (Religion)").
+- **FR-086**: The Recall Knowledge DC MUST be calculated from the creature's level using the PF2e standard DC-by-level table, adjusted for rarity: uncommon +2, rare +5, unique +10.
+- **FR-087**: The Recall Knowledge skill MUST be derived from the creature's type trait using the standard PF2e mapping (e.g., Aberration → Occultism, Animal → Nature, Astral → Occultism, Beast → Arcana/Nature, Celestial → Religion, Construct → Arcana/Crafting, Dragon → Arcana, Dream → Occultism, Elemental → Arcana/Nature, Ethereal → Occultism, Fey → Nature, Fiend → Religion, Fungus → Nature, Giant → Society, Humanoid → Society, Monitor → Religion, Ooze → Occultism, Plant → Nature, Undead → Religion).
+- **FR-088**: Creatures with no recognized type trait MUST omit the Recall Knowledge line entirely rather than showing incorrect data.
+- **FR-089**: The Recall Knowledge line MUST NOT be shown for D&D creatures.
+- **FR-090**: The PF2e normalization pipeline MUST extract `weapon` and `consumable` item types from the Foundry VTT `items[]` array, in addition to the existing `melee`, `action`, `spell`, and `spellcastingEntry` types. Each extracted equipment item MUST include name, level, traits, and description text.
+- **FR-091**: PF2e stat blocks MUST display an "Equipment" section listing all extracted equipment items. Each item MUST show its name and relevant details (e.g., level, traits, activation description).
+- **FR-092**: For scroll items, the stat block MUST display the embedded spell name and rank derived from the `system.spell` data on the item (e.g., "Scroll of Teleport (Rank 6)").
+- **FR-093**: The Equipment section MUST be omitted entirely when the creature has no equipment items, consistent with FR-018 (optional sections omitted when empty).
+- **FR-094**: Equipment item descriptions MUST be processed through the existing Foundry tag-stripping utility before display, consistent with FR-068 and FR-081.
+- **FR-095**: The PF2e normalization pipeline MUST extract `system.attackEffects.value` (an array of slug strings, e.g., `["grab"]`, `["lich-siphon-life"]`) from melee items and include them in the normalized attack data.
+- **FR-096**: PF2e attack lines MUST display inline on-hit effects after the damage text (e.g., "2d12+7 piercing plus Grab"). Effect slugs MUST be converted to title case with hyphens replaced by spaces; creature-name prefixes (e.g., "lich-" in "lich-siphon-life") MUST be stripped. Multiple effects MUST be joined with "plus" (e.g., "plus Grab and Knockdown"). Attacks without on-hit effects MUST render unchanged.
+- **FR-097**: The PF2e normalization pipeline MUST extract `system.frequency` (with `max` and `per` fields, e.g., `{max: 1, per: "day"}`) from action items and include it in the normalized ability data.
+- **FR-098**: PF2e abilities with a frequency limit MUST display it alongside the ability name as "(N/per)" (e.g., "(1/day)", "(1/round)"). Abilities without a frequency limit MUST render unchanged.
+- **FR-099**: The PF2e normalization pipeline MUST extract `system.perception.details` (a string, e.g., "smoke vision") and include it in the normalized creature perception data.
+- **FR-100**: PF2e stat blocks MUST display perception details text on the perception line alongside senses (e.g., "Perception +12; darkvision, smoke vision"). When no perception details are present, the perception line MUST render unchanged.
 
 ### Acceptance Scenarios
 
@@ -298,9 +394,9 @@ As a DM with a creature pinned, I want to collapse the right (browse) panel inde
 - **Search Index (D&D)** (`BestiaryIndex`): Pre-shipped lightweight dataset keyed by name + source, containing mechanical facts (name, source code, AC, HP average, DEX score, CR, initiative proficiency multiplier, size, type) for all creatures. Sufficient for adding combatants; insufficient for rendering a full stat block.
 - **Search Index (PF2e)** (`Pf2eBestiaryIndex`): Pre-shipped lightweight dataset for PF2e creatures, containing name, source code, AC, HP, level, Perception modifier, size, and creature type. Parallel to the D&D search index but with PF2e-specific fields (level instead of CR, Perception instead of DEX/proficiency).
 - **Source** (`BestiarySource`): A D&D or PF2e publication identified by a code (e.g., "XMM") with a display name (e.g., "Monster Manual (2025)"). Caching and fetching operate at the source level.
-- **Creature (Full)** (`Creature`): A complete creature record with all stat block data (traits, actions, legendary actions, spellcasting, etc.), available only after source data is fetched/uploaded and cached. Identified by a branded `CreatureId`.
+- **Creature (Full)** (`Creature`): A complete creature record with all stat block data (traits, actions, legendary actions, spellcasting, etc.), available only after source data is fetched/uploaded and cached. Identified by a branded `CreatureId`. For PF2e creatures, each spell entry inside `spellcasting` carries full per-spell data (slug, level, traits, range, action cost, target/area, duration, defense, description, heightening) extracted from the embedded `items[type=spell]` data on the source NPC, enabling inline spell description display without additional fetches. PF2e creatures also carry an `equipment` list of carried items (weapons, consumables) extracted from `items[type=weapon]` and `items[type=consumable]` entries, each with name, level, traits, description, and (for scrolls) embedded spell data. PF2e attack entries carry an optional `attackEffects` list of on-hit effect names. PF2e ability entries carry an optional `frequency` with `max` and `per` fields. PF2e creature perception carries an optional `details` string (e.g., "smoke vision").
 - **Cached Source Data**: The full normalized bestiary data for a single source, stored in IndexedDB. Contains complete creature stat blocks.
-- **Combatant** (extended): Gains an optional `creatureId` reference to a `Creature`, enabling stat block lookup and stat pre-fill on creation.
+- **Combatant** (extended): Gains an optional `creatureId` reference to a `Creature`, enabling stat block lookup and stat pre-fill on creation. PF2e bestiary-linked combatants may also carry a `creatureAdjustment` (`"weak" | "elite"`) indicating the active PF2e weak/elite adjustment, persisted across reloads.
 - **Queued Creature**: Transient UI-only state representing a bestiary creature selected for batch-add, containing the creature reference and a count (1+). Not persisted.
 - **Bulk Import Operation**: Tracks total sources, completed count, failed count, and current status (idle / loading / complete / partial-failure).
 - **Toast Notification**: Lightweight custom UI element at bottom-center of screen with text, optional progress bar, and optional dismiss button.
@@ -331,3 +427,5 @@ As a DM with a creature pinned, I want to collapse the right (browse) panel inde
 - **SC-019**: PF2e stat blocks render the correct layout (level, three saves, ability modifiers, ability sections) for all PF2e creatures — no D&D-specific fields (CR, ability scores, legendary actions) are shown.
 - **SC-020**: Switching game system immediately changes which creatures appear in search — no page reload required.
 - **SC-021**: Both D&D and PF2e search indexes ship bundled with the app; no network fetch is required to search creatures in either system.
+- **SC-022**: Clicking any spell in a PF2e creature's stat block opens its description display within 100ms — no network I/O is performed.
+- **SC-023**: PF2e spell descriptions are available offline once the bestiary source containing the creature has been cached.