Complete P2-P5: Perks, Feature Choices, Ancestry Traits, Caster Progression

- P2: Perks with changes[] arrays create Active Effects on drop/delete
- P3: Feature choice UI for Fighting Style (auto-grants Situational
  Awareness + selected training perk, ignoring prerequisites)
- P4: Ancestry traits apply Active Effects (Dwarf Darksight/Tough working)
- P5: Caster progression accumulates mana from class progression table

Key patterns:
- Manual UUID construction: Compendium.${pack.collection}.Item.${entry._id}
- ignorePrereqs flag for specific choices bypassing all prerequisites
- Mode 5 (OVERRIDE) for boolean senses like darkvision
- Form data merging with direct DOM reading for reliable selection capture

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

PROTOTYPE_PLAN.json

@@ -0,0 +1,124 @@
+{
+  "prototype": {
+    "name": "Class & Character Progression Prototype",
+    "branch": "prototype/class-level-system",
+    "description": "Proof-of-concept implementations for Active Effects automation across classes, perks, ancestries, and caster progression",
+    "created": "2024-12-16",
+    "status": "in_progress",
+    "design_doc": "NoteDiscovery: gaming/vagabond-rpg/class-level-system-design.md"
+  },
+  "tasks": [
+    {
+      "id": "P1",
+      "name": "Class Level-Up with Active Effects",
+      "description": "Class features with changes[] arrays automatically create Active Effects on drop and level-up",
+      "status": "complete",
+      "commit": "a7862be",
+      "files_changed": [
+        "module/documents/item.mjs",
+        "module/documents/actor.mjs",
+        "module/applications/level-up-dialog.mjs",
+        "module/sheets/base-actor-sheet.mjs",
+        "packs/_source/classes/fighter.json"
+      ],
+      "patterns_established": [
+        "Features with changes[] become ActiveEffects via applyClassFeatures()",
+        "updateClassFeatures() handles level-up incrementally",
+        "Idempotency via checking existing effect flags",
+        "dragDrop config in DEFAULT_OPTIONS (not manual listeners)",
+        "ActiveEffect flags: vagabond.classFeature, className, featureName, featureLevel"
+      ],
+      "tested": true,
+      "notes": "Fighter Valor I/II/III reduces crit threshold cumulatively. Fixed duplicate item creation bug."
+    },
+    {
+      "id": "P2",
+      "name": "Perk Active Effects",
+      "description": "Perks apply Active Effects when added to character, using same changes[] pattern as class features",
+      "status": "complete",
+      "dependencies": ["P1"],
+      "implementation_plan": [
+        "Add changes[] array to PerkData schema if not present",
+        "Update VagabondItem._onCreate() to handle type === 'perk'",
+        "Create test perk with mechanical effect (e.g., 'Tough' adds +5 HP)",
+        "Verify effect applies on drop and removes on delete",
+        "Update level-up dialog perk selection to show effect preview"
+      ],
+      "files_to_modify": [
+        "module/documents/item.mjs",
+        "module/data/perk.mjs",
+        "packs/_source/perks/ (create test perks)"
+      ],
+      "acceptance_criteria": [
+        "Dropping perk on character creates ActiveEffect",
+        "Deleting perk removes its ActiveEffect",
+        "Perk effects stack with class effects",
+        "Level-up dialog perk selection works end-to-end"
+      ]
+    },
+    {
+      "id": "P3",
+      "name": "Feature Choices (Fighting Style)",
+      "description": "Implement UI for features that require player choice, starting with Fighter's Fighting Style perk selection",
+      "status": "complete",
+      "dependencies": ["P2"],
+      "files_changed": [
+        "module/applications/level-up-dialog.mjs",
+        "module/documents/item.mjs",
+        "module/data/item/class.mjs",
+        "templates/dialog/level-up.hbs"
+      ],
+      "patterns_established": [
+        "Class features schema includes requiresChoice, choiceType, choiceFilter fields",
+        "_getFilteredPerksForChoice() filters perks by custom prerequisite text",
+        "ignorePrereqs flag allows bypassing all prerequisites for specific choices",
+        "Classes with choice features at level 1 show dialog on initial drop",
+        "_applyFightingStyle() auto-grants Situational Awareness + selected training perk",
+        "UUID must be constructed manually: Compendium.${pack.collection}.Item.${entry._id}"
+      ],
+      "tested": true,
+      "notes": "Fighting Style grants Situational Awareness AND one Melee/Ranged Training perk (ignoring prereqs). Fixed UUID null issue by constructing UUID from pack collection and entry ID."
+    },
+    {
+      "id": "P4",
+      "name": "Ancestry Traits as Active Effects",
+      "description": "Ancestry traits with mechanical effects apply as Active Effects when ancestry is added to character",
+      "status": "complete",
+      "dependencies": ["P1"],
+      "files_changed": [
+        "module/documents/item.mjs",
+        "module/data/item/ancestry.mjs",
+        "packs/_source/ancestries/dwarf.json"
+      ],
+      "patterns_established": [
+        "Ancestry traits use same changes[] pattern as class features",
+        "applyAncestryTraits() creates effects with vagabond.ancestryTrait flag",
+        "_removeAncestryEffects() cleans up on ancestry deletion/replacement",
+        "Mode 5 (OVERRIDE) for boolean senses like darkvision"
+      ],
+      "tested": true,
+      "notes": "Dwarf Darksight (+darkvision) and Tough (+3 HP bonus) traits verified working"
+    },
+    {
+      "id": "P5",
+      "name": "Caster Class Progression",
+      "description": "Verify mana and castingMax from class progression apply correctly for caster classes",
+      "status": "complete",
+      "dependencies": ["P1"],
+      "files_changed": ["module/sheets/base-actor-sheet.mjs"],
+      "patterns_established": [
+        "_applyClassProgression() accumulates mana from progression entries",
+        "Mana.value set to max only on initial grant (when value === 0)",
+        "Form submission cleanup via #cleanNumericFields() prevents empty string validation errors"
+      ],
+      "tested": true,
+      "notes": "Wizard Level 1 = 4 mana, Level 2 = 8 mana. Fixed validation error for empty numeric inputs."
+    }
+  ],
+  "merge_criteria": [
+    "All tasks complete and tested",
+    "No console errors in normal workflows",
+    "Design doc updated with new patterns",
+    "Compendiums rebuilt with test content"
+  ]
+}

module/applications/level-up-dialog.mjs

@@ -13,7 +13,7 @@
  */
 
 // Debug logging for level-up workflow - set to false to disable
-const DEBUG_LEVELUP = true;
+const DEBUG_LEVELUP = false;
 const debugLog = (...args) => {
   if (DEBUG_LEVELUP) console.log("[LevelUpDialog]", ...args);
 };
@@ -186,6 +186,23 @@ export default class LevelUpDialog extends HandlebarsApplicationMixin(Applicatio
       debugLog(`Loaded ${context.availablePerks?.length || 0} available perks`);
     }
 
+    // Load filtered perks for each choice feature
+    for (const choiceFeature of choiceFeatures) {
+      if (choiceFeature.choiceType === "perk" && choiceFeature.choiceFilter) {
+        debugLog(`Loading filtered perks for "${choiceFeature.name}"...`);
+        // Fighting Style ignores all prerequisites per the feature rules
+        const ignorePrereqs = choiceFeature.name === "Fighting Style";
+        choiceFeature.filteredPerks = await this._getFilteredPerksForChoice(
+          choiceFeature.choiceFilter,
+          ignorePrereqs
+        );
+        debugLog(
+          `Loaded ${choiceFeature.filteredPerks?.length || 0} filtered perks for "${choiceFeature.name}"`,
+          choiceFeature.filteredPerks?.map((p) => ({ name: p.name, uuid: p.uuid, id: p.id }))
+        );
+      }
+    }
+
     return context;
   }
 
@@ -223,7 +240,7 @@ export default class LevelUpDialog extends HandlebarsApplicationMixin(Applicatio
           uuid: perk.uuid,
           name: perk.name,
           description: perk.system.description,
-          prerequisites: perk.system.prerequisites || [],
+          prerequisites: perk.system.prerequisites || {},
           prerequisitesMet: met,
           missing: prereqResult?.missing || [],
         });
@@ -240,6 +257,79 @@ export default class LevelUpDialog extends HandlebarsApplicationMixin(Applicatio
     return perks;
   }
 
+  /**
+   * Get perks filtered for a specific choice feature.
+   * Filters by the choiceFilter.prerequisite array (matches against perk's custom prerequisite text).
+   *
+   * @param {Object} choiceFilter - The filter from the feature (e.g., { prerequisite: ["Melee Training", "Ranged Training"] })
+   * @param {boolean} ignorePrereqs - If true, mark all filtered perks as available (for features like Fighting Style)
+   * @returns {Promise<Object[]>} Filtered perk data
+   * @private
+   */
+  async _getFilteredPerksForChoice(choiceFilter, ignorePrereqs = false) {
+    const pack = game.packs.get("vagabond.perks");
+    if (!pack) return [];
+
+    const index = await pack.getIndex();
+    const perks = [];
+    const filterValues = choiceFilter?.prerequisite || [];
+
+    debugLog("Filtering perks for choice", { filterValues, ignorePrereqs });
+
+    for (const entry of index) {
+      const perk = await pack.getDocument(entry._id);
+      if (!perk) continue;
+
+      // Build the UUID from pack and entry info (more reliable than perk.uuid)
+      const perkUuid = `Compendium.${pack.collection}.Item.${entry._id}`;
+
+      // Check if perk matches the filter (by custom prerequisite text)
+      const customPrereq = perk.system.prerequisites?.custom || "";
+      const matchesFilter = filterValues.length === 0 || filterValues.includes(customPrereq);
+
+      if (!matchesFilter) {
+        debugLog(`Perk "${perk.name}" filtered out (custom: "${customPrereq}")`);
+        continue;
+      }
+
+      // Check prerequisites (optionally ignoring all for features like Fighting Style)
+      let met = true;
+      let missing = [];
+
+      if (ignorePrereqs) {
+        // Feature allows ignoring prerequisites - all filtered perks are selectable
+        met = true;
+        missing = [];
+      } else {
+        const prereqResult = perk.checkPrerequisites?.(this.actor);
+        met = prereqResult?.met ?? true;
+        missing = prereqResult?.missing || [];
+      }
+
+      // Check if actor already has this perk
+      const alreadyHas = this.actor.items.some((i) => i.type === "perk" && i.name === perk.name);
+
+      if (!alreadyHas) {
+        perks.push({
+          id: entry._id,
+          uuid: perkUuid,
+          name: perk.name,
+          description: perk.system.description,
+          prerequisites: perk.system.prerequisites || {},
+          prerequisitesMet: met,
+          missing,
+          customPrereq,
+        });
+        debugLog(`Perk "${perk.name}" added to choice list (met: ${met}, uuid: ${perkUuid})`);
+      }
+    }
+
+    // Sort alphabetically (all should be selectable for Fighting Style)
+    perks.sort((a, b) => a.name.localeCompare(b.name));
+
+    return perks;
+  }
+
   /* -------------------------------------------- */
   /*  Event Handlers                              */
   /* -------------------------------------------- */
@@ -263,14 +353,38 @@ export default class LevelUpDialog extends HandlebarsApplicationMixin(Applicatio
       });
     }
 
-    // Handle feature choice changes
+    // Handle feature choice changes - use 'input' event as well as 'change' for better capture
     const choiceSelects = this.element.querySelectorAll("[data-feature-choice]");
     debugLog(`Found ${choiceSelects.length} feature choice select elements`);
     for (const select of choiceSelects) {
-      select.addEventListener("change", (event) => {
+      // Log initial state
+      debugLog(`Select initial state for "${select.dataset.featureChoice}":`, {
+        value: select.value,
+        selectedIndex: select.selectedIndex,
+        optionsCount: select.options.length,
+      });
+
+      // Track both change and input events
+      const handleSelection = (event) => {
         const featureName = event.currentTarget.dataset.featureChoice;
-        this.choices.featureChoices[featureName] = event.currentTarget.value;
+        const newValue = event.currentTarget.value;
-        debugLog(`Feature choice changed: "${featureName}" = ${event.currentTarget.value}`);
+        const selectedIndex = event.currentTarget.selectedIndex;
+        const selectedText = event.currentTarget.options[selectedIndex]?.textContent;
+
+        this.choices.featureChoices[featureName] = newValue;
+        debugLog(
+          `Feature choice ${event.type}: "${featureName}" = "${newValue}" (index: ${selectedIndex}, text: "${selectedText}")`
+        );
+      };
+
+      select.addEventListener("change", handleSelection);
+      select.addEventListener("input", handleSelection);
+
+      // Also track focus/blur to see if something is resetting
+      select.addEventListener("blur", (event) => {
+        debugLog(
+          `Select blur for "${event.currentTarget.dataset.featureChoice}": value="${event.currentTarget.value}"`
+        );
       });
     }
   }
@@ -320,6 +434,40 @@ export default class LevelUpDialog extends HandlebarsApplicationMixin(Applicatio
     const data = foundry.utils.expandObject(formData.object);
     debugLog("Expanded form data:", data);
 
+    // Also read feature choice selects directly from the form (backup method)
+    const featureChoiceSelects = form.querySelectorAll("[data-feature-choice]");
+    const directChoices = {};
+    let missingRequiredChoice = false;
+
+    for (const select of featureChoiceSelects) {
+      const featureName = select.dataset.featureChoice;
+      const selectedValue = select.value;
+      const selectedIndex = select.selectedIndex;
+      const selectedOption = select.options[selectedIndex];
+
+      debugLog(`Direct select read: "${featureName}"`, {
+        value: selectedValue,
+        selectedIndex,
+        selectedOptionText: selectedOption?.textContent,
+        optionsCount: select.options.length,
+      });
+
+      directChoices[featureName] = selectedValue;
+
+      // Check if this is a required choice with no selection
+      if (!selectedValue) {
+        missingRequiredChoice = true;
+      }
+    }
+
+    // Warn if no choice was made
+    if (missingRequiredChoice) {
+      ui.notifications.warn("Please select a perk for Feature Choices before confirming.");
+      return; // Don't proceed with level up
+    }
+
+    data.directFeatureChoices = directChoices;
+
     // Apply the level up
     await dialog._applyLevelUp(data);
   }
@@ -332,11 +480,23 @@ export default class LevelUpDialog extends HandlebarsApplicationMixin(Applicatio
    * @private
    */
   async _applyLevelUp(formData) {
+    // Merge all sources of feature choices (direct DOM read takes priority)
+    const featureChoicesFromForm = formData.featureChoice || {};
+    const directFeatureChoices = formData.directFeatureChoices || {};
+    const mergedFeatureChoices = {
+      ...this.choices.featureChoices,
+      ...featureChoicesFromForm,
+      ...directFeatureChoices, // Direct DOM read is most reliable
+    };
+
     debugLog("_applyLevelUp called", {
       actorName: this.actor.name,
       oldLevel: this.oldLevel,
       newLevel: this.newLevel,
       choices: this.choices,
+      featureChoicesFromForm,
+      directFeatureChoices,
+      mergedFeatureChoices,
     });
 
     // 1. Update class features for all classes
@@ -376,12 +536,26 @@ export default class LevelUpDialog extends HandlebarsApplicationMixin(Applicatio
       }
     }
 
-    // 3. Handle feature choices
+    // 3. Handle feature choices (using merged form data + event-tracked choices)
-    debugLog(`Processing feature choices:`, this.choices.featureChoices);
+    debugLog(`Processing feature choices:`, mergedFeatureChoices);
-    for (const [featureName, choice] of Object.entries(this.choices.featureChoices)) {
+    for (const [featureName, choice] of Object.entries(mergedFeatureChoices)) {
       debugLog(`Feature choice for "${featureName}": ${choice}`);
-      // Feature choices can be complex - for now just log
+
-      // TODO: Implement specific handling for choice features (e.g., add selected perk)
+      // Handle Fighting Style specifically
+      if (featureName === "Fighting Style") {
+        await this._applyFightingStyle(choice);
+      } else if (choice) {
+        // Generic perk choice handling - add the selected perk
+        try {
+          const perkDoc = await fromUuid(choice);
+          if (perkDoc) {
+            debugLog(`Adding choice perk: "${perkDoc.name}"`);
+            await this.actor.createEmbeddedDocuments("Item", [perkDoc.toObject()]);
+          }
+        } catch (err) {
+          console.error(`Failed to add choice perk ${choice}:`, err);
+        }
+      }
     }
 
     // Log final actor state
@@ -398,6 +572,61 @@ export default class LevelUpDialog extends HandlebarsApplicationMixin(Applicatio
     ui.notifications.info(`${this.actor.name} advanced to level ${this.newLevel}!`);
   }
 
+  /**
+   * Apply the Fighting Style feature.
+   * Grants Situational Awareness perk AND the selected training perk.
+   *
+   * @param {string} selectedPerkUuid - UUID of the selected training perk
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _applyFightingStyle(selectedPerkUuid) {
+    debugLog("Applying Fighting Style feature");
+
+    const pack = game.packs.get("vagabond.perks");
+    if (!pack) {
+      debugWarn("Perks compendium not found, cannot apply Fighting Style");
+      return;
+    }
+
+    // 1. Auto-grant Situational Awareness
+    const index = await pack.getIndex();
+    const saEntry = index.find((e) => e.name === "Situational Awareness");
+
+    if (saEntry) {
+      const saPerk = await pack.getDocument(saEntry._id);
+      if (saPerk) {
+        // Check if actor already has it
+        const alreadyHas = this.actor.items.some(
+          (i) => i.type === "perk" && i.name === "Situational Awareness"
+        );
+        if (!alreadyHas) {
+          debugLog("Granting Situational Awareness perk");
+          await this.actor.createEmbeddedDocuments("Item", [saPerk.toObject()]);
+        } else {
+          debugLog("Actor already has Situational Awareness");
+        }
+      }
+    } else {
+      debugWarn("Situational Awareness perk not found in compendium");
+    }
+
+    // 2. Add the selected training perk
+    if (selectedPerkUuid) {
+      try {
+        const perkDoc = await fromUuid(selectedPerkUuid);
+        if (perkDoc) {
+          debugLog(`Granting selected training perk: "${perkDoc.name}"`);
+          await this.actor.createEmbeddedDocuments("Item", [perkDoc.toObject()]);
+        }
+      } catch (err) {
+        console.error(`Failed to add training perk ${selectedPerkUuid}:`, err);
+      }
+    } else {
+      debugWarn("No training perk selected for Fighting Style");
+    }
+  }
+
   /* -------------------------------------------- */
   /*  Static Methods                              */
   /* -------------------------------------------- */

module/data/item/ancestry.mjs

@@ -43,6 +43,15 @@ export default class AncestryData extends VagabondItemBase {
         new fields.SchemaField({
           name: new fields.StringField({ required: true }),
           description: new fields.HTMLField({ required: true }),
+          // Mechanical effects as Active Effect changes
+          changes: new fields.ArrayField(
+            new fields.SchemaField({
+              key: new fields.StringField({ required: true }),
+              mode: new fields.NumberField({ integer: true, initial: 2 }),
+              value: new fields.StringField({ required: true }),
+            }),
+            { initial: [] }
+          ),
         }),
         { initial: [] }
       ),

module/data/item/class.mjs

@@ -86,6 +86,10 @@ export default class ClassData extends VagabondItemBase {
             }),
             { initial: [] }
           ),
+          // Choice features - features that require player selection
+          requiresChoice: new fields.BooleanField({ initial: false }),
+          choiceType: new fields.StringField({ required: false, blank: true }), // "perk", "spell", etc.
+          choiceFilter: new fields.ObjectField({ required: false }), // Filter criteria for choices
         }),
         { initial: [] }
       ),

module/documents/item.mjs

@@ -1,5 +1,7 @@
+import LevelUpDialog from "../applications/level-up-dialog.mjs";
+
 // Debug logging for level-up workflow - set to false to disable
-const DEBUG_LEVELUP = true;
+const DEBUG_LEVELUP = false;
 const debugLog = (...args) => {
   if (DEBUG_LEVELUP) console.log("[VagabondItem]", ...args);
 };
@@ -53,7 +55,38 @@ export default class VagabondItem extends Item {
     // Apply class features when class is added to a character
     // Check that actor still exists (may be deleted in tests)
     if (this.type === "class" && this.parent?.type === "character" && this.actor?.id) {
-      debugLog("Class added to character - applying initial features...");
+      debugLog("Class added to character - checking for choice features...");
+
+      // Check if there are choice features at the actor's current level
+      const currentLevel = this.actor.system.level || 1;
+      const features = this.system.features || [];
+
+      debugLog(
+        "Features array:",
+        features.map((f) => ({
+          name: f.name,
+          level: f.level,
+          requiresChoice: f.requiresChoice,
+          hasRequiresChoice: "requiresChoice" in f,
+        }))
+      );
+
+      const choiceFeatures = features.filter(
+        (f) => f.level <= currentLevel && f.requiresChoice === true
+      );
+
+      if (choiceFeatures.length > 0) {
+        // Show level-up dialog for choice features
+        debugLog(`Found ${choiceFeatures.length} choice features, showing dialog...`);
+        try {
+          // Use oldLevel=0 to indicate this is initial class assignment
+          await LevelUpDialog.create(this.actor, currentLevel, 0);
+        } catch (err) {
+          console.error("Failed to show level-up dialog:", err);
+        }
+      } else {
+        // No choices needed, apply features directly
+        debugLog("No choice features - applying initial features directly...");
         try {
           const effects = await this.applyClassFeatures();
           debugLog(`Applied ${effects.length} initial Active Effects`);
@@ -65,8 +98,33 @@ export default class VagabondItem extends Item {
       }
     }
 
+    // Apply perk effects when perk is added to a character
+    if (this.type === "perk" && this.parent?.type === "character" && this.actor?.id) {
+      debugLog("Perk added to character - applying effects...");
+      try {
+        const effects = await this.applyPerkEffects();
+        debugLog(`Applied ${effects.length} perk Active Effects`);
+      } catch (err) {
+        if (!err.message?.includes("does not exist")) throw err;
+        debugWarn("Actor was deleted during perk effect application");
+      }
+    }
+
+    // Apply ancestry traits when ancestry is added to a character
+    if (this.type === "ancestry" && this.parent?.type === "character" && this.actor?.id) {
+      debugLog("Ancestry added to character - applying traits...");
+      try {
+        const effects = await this.applyAncestryTraits();
+        debugLog(`Applied ${effects.length} ancestry trait Active Effects`);
+      } catch (err) {
+        if (!err.message?.includes("does not exist")) throw err;
+        debugWarn("Actor was deleted during ancestry trait application");
+      }
+    }
+  }
+
   /**
-   * Handle item deletion. For class items, remove associated Active Effects.
+   * Handle item deletion. For class/perk/ancestry items, remove associated Active Effects.
    *
    * @override
    */
@@ -76,6 +134,16 @@ export default class VagabondItem extends Item {
       await this._removeClassEffects();
     }
 
+    // Remove perk effects before deletion
+    if (this.type === "perk" && this.parent?.type === "character") {
+      await this._removePerkEffects();
+    }
+
+    // Remove ancestry trait effects before deletion
+    if (this.type === "ancestry" && this.parent?.type === "character") {
+      await this._removeAncestryEffects();
+    }
+
     return super._preDelete(options, userId);
   }
 
@@ -475,58 +543,65 @@ export default class VagabondItem extends Item {
       return { met: true, missing: [] };
     }
 
-    const prereqs = this.system.prerequisites || [];
+    const prereqs = this.system.prerequisites;
+    if (!prereqs) {
+      return { met: true, missing: [] };
+    }
+
     const missing = [];
 
-    for (const prereq of prereqs) {
+    // Check stat requirements
-      let met = false;
+    if (prereqs.stats) {
-
+      for (const [stat, required] of Object.entries(prereqs.stats)) {
-      switch (prereq.type) {
+        if (required !== null && required > 0) {
-        case "stat": {
+          const actorStat = actor.system.stats?.[stat]?.value || 0;
-          // Check stat minimum
+          if (actorStat < required) {
-          const statValue = actor.system.stats?.[prereq.stat]?.value || 0;
+            const statLabel = stat.charAt(0).toUpperCase() + stat.slice(1);
-          met = statValue >= (prereq.value || 0);
+            missing.push({
-          break;
+              type: "stat",
+              stat,
+              value: required,
+              label: `${statLabel} ${required}`,
+            });
           }
-
-        case "training": {
-          // Check if trained in skill
-          const skillData = actor.system.skills?.[prereq.skill];
-          met = skillData?.trained === true;
-          break;
         }
-
-        case "spell": {
-          // Check if actor knows the spell
-          const knownSpells = actor.getSpells?.() || [];
-          met = knownSpells.some((s) => s.name === prereq.spellName);
-          break;
-        }
-
-        case "perk": {
-          // Check if actor has the prerequisite perk
-          const perks = actor.getPerks?.() || [];
-          met = perks.some((p) => p.name === prereq.perkName);
-          break;
-        }
-
-        case "level":
-          // Check minimum level
-          met = (actor.system.level || 1) >= (prereq.value || 1);
-          break;
-
-        case "class": {
-          // Check if actor has the class
-          const classes = actor.getClasses?.() || [];
-          met = classes.some((c) => c.name === prereq.className);
-          break;
       }
     }
 
-      if (!met) {
+    // Check skill training requirements
-        missing.push(prereq);
+    if (prereqs.trainedSkills) {
+      for (const skillId of prereqs.trainedSkills) {
+        const skill = actor.system.skills?.[skillId];
+        if (!skill?.trained) {
+          missing.push({ type: "training", skill: skillId, label: `Trained in ${skillId}` });
         }
       }
+    }
+
+    // Check spell requirements
+    if (prereqs.spells?.length > 0) {
+      const knownSpells = actor.items.filter((i) => i.type === "spell");
+      for (const spellName of prereqs.spells) {
+        if (!knownSpells.some((s) => s.name === spellName)) {
+          missing.push({ type: "spell", spellName, label: `Spell: ${spellName}` });
+        }
+      }
+    }
+
+    // Check perk requirements
+    if (prereqs.perks?.length > 0) {
+      const actorPerks = actor.items.filter((i) => i.type === "perk");
+      for (const perkName of prereqs.perks) {
+        if (!actorPerks.some((p) => p.name === perkName)) {
+          missing.push({ type: "perk", perkName, label: `Perk: ${perkName}` });
+        }
+      }
+    }
+
+    // Custom requirements are always flagged as missing (need manual review)
+    if (prereqs.custom) {
+      missing.push({ type: "custom", label: prereqs.custom });
+    }
 
     return {
       met: missing.length === 0,
@@ -788,6 +863,176 @@ export default class VagabondItem extends Item {
     }
   }
 
+  /* -------------------------------------------- */
+  /*  Perk Helpers                                */
+  /* -------------------------------------------- */
+
+  /**
+   * Apply perk effects as Active Effects when perk is added to character.
+   * This method is idempotent - it won't create duplicate effects.
+   *
+   * @returns {Promise<ActiveEffect[]>} Created effects
+   */
+  async applyPerkEffects() {
+    debugLog(`applyPerkEffects called for perk "${this.name}"`, {
+      hasChanges: this.system.changes?.length > 0,
+    });
+
+    if (this.type !== "perk" || !this.actor) {
+      debugWarn("applyPerkEffects: Not a perk or no actor");
+      return [];
+    }
+
+    const changes = this.system.changes || [];
+    if (changes.length === 0) {
+      debugLog("Perk has no mechanical changes - skipping effect creation");
+      return [];
+    }
+
+    // Check if effect already exists (idempotent)
+    const existingEffect = this.actor.effects.find((e) => e.origin === this.uuid);
+    if (existingEffect) {
+      debugLog("Perk effect already exists - skipping");
+      return [];
+    }
+
+    // Build Active Effect data
+    const effectData = {
+      name: this.name,
+      icon: this.img || "icons/svg/upgrade.svg",
+      origin: this.uuid,
+      changes: changes.map((change) => ({
+        key: change.key,
+        mode: change.mode ?? 2, // Default to ADD mode
+        value: String(change.value),
+        priority: change.priority ?? null,
+      })),
+      flags: {
+        vagabond: {
+          perkEffect: true,
+          perkName: this.name,
+        },
+      },
+    };
+
+    debugLog("Creating perk Active Effect:", {
+      name: effectData.name,
+      changes: effectData.changes,
+    });
+
+    const createdEffects = await this.actor.createEmbeddedDocuments("ActiveEffect", [effectData]);
+    debugLog(`Created ${createdEffects.length} perk Active Effects`);
+
+    return createdEffects;
+  }
+
+  /**
+   * Remove all Active Effects originating from this perk.
+   *
+   * @private
+   * @returns {Promise<void>}
+   */
+  async _removePerkEffects() {
+    if (!this.actor) return;
+
+    const perkEffects = this.actor.effects.filter((e) => e.origin === this.uuid);
+    if (perkEffects.length > 0) {
+      debugLog(`Removing ${perkEffects.length} perk effects for "${this.name}"`);
+      const ids = perkEffects.map((e) => e.id);
+      await this.actor.deleteEmbeddedDocuments("ActiveEffect", ids);
+    }
+  }
+
+  /* -------------------------------------------- */
+  /*  Ancestry Helpers                            */
+  /* -------------------------------------------- */
+
+  /**
+   * Apply ancestry trait effects as Active Effects when ancestry is added to character.
+   * Each trait with a changes[] array creates a separate Active Effect.
+   * This method is idempotent - it won't create duplicate effects.
+   *
+   * @returns {Promise<ActiveEffect[]>} Created effects
+   */
+  async applyAncestryTraits() {
+    debugLog(`applyAncestryTraits called for ancestry "${this.name}"`, {
+      traitsCount: this.system.traits?.length || 0,
+    });
+
+    if (this.type !== "ancestry" || !this.actor) {
+      debugWarn("applyAncestryTraits: Not an ancestry or no actor");
+      return [];
+    }
+
+    const traits = this.system.traits || [];
+    const traitsWithChanges = traits.filter((t) => t.changes?.length > 0);
+
+    if (traitsWithChanges.length === 0) {
+      debugLog("Ancestry has no traits with mechanical changes - skipping effect creation");
+      return [];
+    }
+
+    // Check for existing effects (idempotent)
+    const existingEffects = this.actor.effects.filter((e) => e.origin === this.uuid);
+    const existingTraitNames = new Set(existingEffects.map((e) => e.flags?.vagabond?.traitName));
+
+    const newTraits = traitsWithChanges.filter((t) => !existingTraitNames.has(t.name));
+    if (newTraits.length === 0) {
+      debugLog("All ancestry traits already applied - skipping");
+      return [];
+    }
+
+    // Build Active Effect data for each trait
+    const effectsData = newTraits.map((trait) => ({
+      name: `${this.name}: ${trait.name}`,
+      icon: this.img || "icons/svg/mystery-man.svg",
+      origin: this.uuid,
+      changes: trait.changes.map((change) => ({
+        key: change.key,
+        mode: change.mode ?? 2,
+        value: String(change.value),
+        priority: change.priority ?? null,
+      })),
+      flags: {
+        vagabond: {
+          ancestryTrait: true,
+          ancestryName: this.name,
+          traitName: trait.name,
+        },
+      },
+    }));
+
+    debugLog(
+      "Creating ancestry trait Active Effects:",
+      effectsData.map((e) => ({
+        name: e.name,
+        changes: e.changes,
+      }))
+    );
+
+    const createdEffects = await this.actor.createEmbeddedDocuments("ActiveEffect", effectsData);
+    debugLog(`Created ${createdEffects.length} ancestry trait Active Effects`);
+
+    return createdEffects;
+  }
+
+  /**
+   * Remove all Active Effects originating from this ancestry.
+   *
+   * @private
+   * @returns {Promise<void>}
+   */
+  async _removeAncestryEffects() {
+    if (!this.actor) return;
+
+    const ancestryEffects = this.actor.effects.filter((e) => e.origin === this.uuid);
+    if (ancestryEffects.length > 0) {
+      debugLog(`Removing ${ancestryEffects.length} ancestry effects for "${this.name}"`);
+      const ids = ancestryEffects.map((e) => e.id);
+      await this.actor.deleteEmbeddedDocuments("ActiveEffect", ids);
+    }
+  }
+
   /**
    * Apply class progression stats (mana, casting max) to the actor.
    *

module/sheets/base-actor-sheet.mjs

@@ -616,9 +616,40 @@ export default class VagabondActorSheet extends HandlebarsApplicationMixin(Actor
   static async #onFormSubmit(event, form, formData) {
     const sheet = this;
     const updateData = foundry.utils.expandObject(formData.object);
+
+    // Clean up numeric fields that may have empty string values
+    // This can happen when number inputs are cleared by the user
+    VagabondActorSheet.#cleanNumericFields(updateData);
+
     await sheet.actor.update(updateData);
   }
 
+  /**
+   * Recursively clean numeric fields in update data.
+   * Empty strings are converted to 0 for numeric resource fields.
+   * @param {Object} obj - Object to clean
+   * @param {string} path - Current path for debugging
+   * @private
+   */
+  static #cleanNumericFields(obj, path = "") {
+    if (!obj || typeof obj !== "object") return;
+
+    for (const [key, value] of Object.entries(obj)) {
+      const currentPath = path ? `${path}.${key}` : key;
+
+      if (typeof value === "object" && value !== null) {
+        // Recurse into nested objects
+        VagabondActorSheet.#cleanNumericFields(value, currentPath);
+      } else if (value === "" || value === null) {
+        // Check if this should be a numeric field based on common patterns
+        const numericKeys = ["value", "max", "bonus", "min", "base", "level", "castingMax"];
+        if (numericKeys.includes(key)) {
+          obj[key] = 0;
+        }
+      }
+    }
+  }
+
   /**
    * Handle skill roll action.
    * @param {PointerEvent} event

packs/_source/ancestries/dwarf.json

@@ -11,15 +11,30 @@
     "traits": [
       {
         "name": "Darksight",
-        "description": "<p>You can see in darkness as if it were dim light.</p>"
+        "description": "<p>You can see in darkness as if it were dim light.</p>",
+        "changes": [
+          {
+            "key": "system.senses.darkvision",
+            "mode": 5,
+            "value": "true"
+          }
+        ]
       },
       {
         "name": "Sturdy",
-        "description": "<p>You gain +1 to saves against Fear, Sickened, and Shove effects.</p>"
+        "description": "<p>You gain +1 to saves against Fear, Sickened, and Shove effects.</p>",
+        "changes": []
       },
       {
         "name": "Tough",
-        "description": "<p>You gain +Level additional maximum HP.</p>"
+        "description": "<p>You gain +3 additional maximum HP.</p>",
+        "changes": [
+          {
+            "key": "system.resources.hp.bonus",
+            "mode": 2,
+            "value": "3"
+          }
+        ]
       }
     ]
   }

packs/_source/perks/sharpshooter.json

@@ -0,0 +1,44 @@
+{
+  "_id": "vagabondPerkSharpshooter",
+  "name": "Sharpshooter",
+  "type": "perk",
+  "img": "icons/svg/target.svg",
+  "system": {
+    "description": "<p>You have trained extensively with ranged weapons. Your ranged attacks deal +1 damage.</p>",
+    "prerequisites": {
+      "stats": {
+        "might": null,
+        "dexterity": 4,
+        "awareness": null,
+        "reason": null,
+        "presence": null,
+        "luck": null
+      },
+      "trainedSkills": ["ranged"],
+      "spells": [],
+      "perks": [],
+      "custom": "Ranged Training"
+    },
+    "changes": [
+      {
+        "key": "system.attacks.ranged.damageBonus",
+        "mode": 2,
+        "value": "1"
+      }
+    ],
+    "passive": true,
+    "uses": {
+      "value": 0,
+      "max": 0,
+      "per": ""
+    },
+    "luckCost": 0,
+    "grantsLuck": 0,
+    "isRitual": false,
+    "ritualDuration": 0,
+    "ritualComponents": "",
+    "tags": ["combat", "ranged", "training"]
+  },
+  "effects": [],
+  "_key": "!items!vagabondPerkSharpshooter"
+}

packs/_source/perks/situational-awareness.json

@@ -0,0 +1,38 @@
+{
+  "_id": "vagabondPerkSituationalAwareness",
+  "name": "Situational Awareness",
+  "type": "perk",
+  "img": "icons/svg/eye.svg",
+  "system": {
+    "description": "<p>You are always alert to danger. You cannot be Surprised, and you have Favor on Initiative rolls.</p>",
+    "prerequisites": {
+      "stats": {
+        "might": null,
+        "dexterity": null,
+        "awareness": 4,
+        "reason": null,
+        "presence": null,
+        "luck": null
+      },
+      "trainedSkills": [],
+      "spells": [],
+      "perks": [],
+      "custom": ""
+    },
+    "changes": [],
+    "passive": true,
+    "uses": {
+      "value": 0,
+      "max": 0,
+      "per": ""
+    },
+    "luckCost": 0,
+    "grantsLuck": 0,
+    "isRitual": false,
+    "ritualDuration": 0,
+    "ritualComponents": "",
+    "tags": ["combat", "awareness"]
+  },
+  "effects": [],
+  "_key": "!items!vagabondPerkSituationalAwareness"
+}

packs/_source/perks/tough.json

@@ -0,0 +1,44 @@
+{
+  "_id": "vagabondPerkTough",
+  "name": "Tough",
+  "type": "perk",
+  "img": "icons/svg/shield.svg",
+  "system": {
+    "description": "<p>Your body is hardened through training or natural resilience. You gain +5 maximum HP.</p>",
+    "prerequisites": {
+      "stats": {
+        "might": 4,
+        "dexterity": null,
+        "awareness": null,
+        "reason": null,
+        "presence": null,
+        "luck": null
+      },
+      "trainedSkills": [],
+      "spells": [],
+      "perks": [],
+      "custom": ""
+    },
+    "changes": [
+      {
+        "key": "system.resources.hp.bonus",
+        "mode": 2,
+        "value": "5"
+      }
+    ],
+    "passive": true,
+    "uses": {
+      "value": 0,
+      "max": 0,
+      "per": ""
+    },
+    "luckCost": 0,
+    "grantsLuck": 0,
+    "isRitual": false,
+    "ritualDuration": 0,
+    "ritualComponents": "",
+    "tags": ["combat", "defensive"]
+  },
+  "effects": [],
+  "_key": "!items!vagabondPerkTough"
+}

packs/_source/perks/weapon-mastery.json

@@ -0,0 +1,44 @@
+{
+  "_id": "vagabondPerkWeaponMastery",
+  "name": "Weapon Mastery",
+  "type": "perk",
+  "img": "icons/svg/sword.svg",
+  "system": {
+    "description": "<p>You have trained extensively with melee weapons. Your melee attacks deal +1 damage.</p>",
+    "prerequisites": {
+      "stats": {
+        "might": 4,
+        "dexterity": null,
+        "awareness": null,
+        "reason": null,
+        "presence": null,
+        "luck": null
+      },
+      "trainedSkills": ["melee"],
+      "spells": [],
+      "perks": [],
+      "custom": "Melee Training"
+    },
+    "changes": [
+      {
+        "key": "system.attacks.melee.damageBonus",
+        "mode": 2,
+        "value": "1"
+      }
+    ],
+    "passive": true,
+    "uses": {
+      "value": 0,
+      "max": 0,
+      "per": ""
+    },
+    "luckCost": 0,
+    "grantsLuck": 0,
+    "isRitual": false,
+    "ritualDuration": 0,
+    "ritualComponents": "",
+    "tags": ["combat", "melee", "training"]
+  },
+  "effects": [],
+  "_key": "!items!vagabondPerkWeaponMastery"
+}

templates/dialog/level-up.hbs

@@ -44,13 +44,13 @@
       </label>
       <div class="feature-description">{{{description}}}</div>
 
-      {{!-- For perk choices --}}
+      {{!-- For perk choices with filtered list --}}
       {{#if (eq choiceType "perk")}}
-      <select data-feature-choice="{{name}}" class="perk-choice-select">
+      <select name="featureChoice.{{name}}" data-feature-choice="{{name}}" class="perk-choice-select">
         <option value="">-- Select a Perk --</option>
-        {{#each ../availablePerks}}
+        {{#each filteredPerks}}
-        <option value="{{uuid}}" {{#unless prerequisitesMet}}disabled{{/unless}}>
+        <option value="{{this.uuid}}" {{#unless this.prerequisitesMet}}disabled{{/unless}}>
-          {{name}}{{#unless prerequisitesMet}} (Prerequisites not met){{/unless}}
+          {{this.name}}{{#unless this.prerequisitesMet}} (Prerequisites not met){{/unless}}
         </option>
         {{/each}}
       </select>