feat: implement Jessica's skill tree — 34 abilities across 7 categories

Add SkillAbilities.res with 28 generic abilities (7 categories x 4 ranks)
and 6 background-exclusive Expert abilities. Transform SkillTreeScreen from
linear XP bars to branching tree with ability nodes, connector lines, rank
colours, and exclusive star markers. Wire into PlayerState.hasAbility for
gameplay queries.

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

Author: hyperpolymath

__tests__/SkillAbilities_test.res

@@ -0,0 +1,384 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// SkillAbilities_test.res  Unit tests for Jessica's skill ability system.
+//
+// Tests cover:
+//   genericAbilities   — correct count and structure
+//   exclusiveAbilities — correct count and background assignments
+//   getAbilitiesForCategory — returns abilities for one category
+//   getUnlockedAbilities — rank-gated unlocking logic
+//   isAbilityUnlocked  — individual ability checks
+//   background exclusivity — exclusive abilities only for correct background
+//   rank progression    — Novice unlocks nothing, Expert unlocks all 4
+
+// ===========================================================================
+// Generic abilities — 28 total (7 categories x 4 ranks)
+// ===========================================================================
+
+let testGenericAbilitiesCount = (): promise<bool> => {
+  Promise.resolve(Array.length(SkillAbilities.genericAbilities) == 28)
+}
+
+let testExclusiveAbilitiesCount = (): promise<bool> => {
+  Promise.resolve(Array.length(SkillAbilities.exclusiveAbilities) == 6)
+}
+
+let testAllAbilitiesCount = (): promise<bool> => {
+  // 28 generic + 6 exclusive = 34 total
+  Promise.resolve(Array.length(SkillAbilities.allAbilities) == 34)
+}
+
+// ===========================================================================
+// getAbilitiesForCategory — returns all abilities for one category
+// ===========================================================================
+
+/// Each category has exactly 4 generic abilities. Some categories also have
+/// exclusive abilities (Combat, Observation, TechLiteracy, Fieldcraft,
+/// Composure each have 1; TechLiteracy has 2 — Engineer and Signals).
+let testAbilitiesForInfiltration = (): promise<bool> => {
+  let abilities = SkillAbilities.getAbilitiesForCategory(Infiltration)
+  // 4 generic, 0 exclusive
+  Promise.resolve(Array.length(abilities) == 4)
+}
+
+let testAbilitiesForCombat = (): promise<bool> => {
+  let abilities = SkillAbilities.getAbilitiesForCategory(CombatSkill)
+  // 4 generic + 1 exclusive (Blitz for Assault)
+  Promise.resolve(Array.length(abilities) == 5)
+}
+
+let testAbilitiesForTechLiteracy = (): promise<bool> => {
+  let abilities = SkillAbilities.getAbilitiesForCategory(TechLiteracy)
+  // 4 generic + 2 exclusive (Improvise for Engineer, Override for Signals)
+  Promise.resolve(Array.length(abilities) == 6)
+}
+
+let testAbilitiesForCategoryAndBackground = (): promise<bool> => {
+  // Assault operative sees 4 generic + 1 exclusive for Combat
+  let abilities = SkillAbilities.getAbilitiesForCategoryAndBackground(CombatSkill, Assault)
+  Promise.resolve(Array.length(abilities) == 5)
+}
+
+let testAbilitiesForCategoryExcludesOtherBackground = (): promise<bool> => {
+  // Recon operative sees only 4 generic for Combat (no Blitz)
+  let abilities = SkillAbilities.getAbilitiesForCategoryAndBackground(CombatSkill, Recon)
+  Promise.resolve(Array.length(abilities) == 4)
+}
+
+// ===========================================================================
+// Novice rank unlocks nothing
+// ===========================================================================
+
+let testNoviceUnlocksNothing = (): promise<bool> => {
+  // All skills at Novice (default for a non-specialist category)
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  // Assault starts combat at Trained, but infiltration at Novice
+  let infiltrationAbilities = SkillAbilities.getUnlockedAbilities(
+    skills,
+    ~background=Assault,
+  )->Array.filter(a => a.category == Infiltration)
+  Promise.resolve(Array.length(infiltrationAbilities) == 0)
+}
+
+// ===========================================================================
+// Trained rank unlocks exactly 1 ability per category
+// ===========================================================================
+
+let testTrainedUnlocksOne = (): promise<bool> => {
+  // Assault starts with combat at Trained
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  let combatAbilities = SkillAbilities.getUnlockedAbilities(
+    skills,
+    ~background=Assault,
+  )->Array.filter(a => a.category == CombatSkill)
+  // Trained unlocks Quick Strike (1 ability)
+  Promise.resolve(Array.length(combatAbilities) == 1)
+}
+
+let testTrainedUnlocksCorrectAbility = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  let isUnlocked = SkillAbilities.isAbilityUnlocked(
+    skills,
+    ~background=Assault,
+    "combat_trained_quick_strike",
+  )
+  Promise.resolve(isUnlocked)
+}
+
+// ===========================================================================
+// Expert rank unlocks all 4 abilities per category
+// ===========================================================================
+
+let testExpertUnlocksAll = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  // Manually promote infiltration to Expert
+  skills.infiltration.rank = Expert
+  let infiltrationAbilities = SkillAbilities.getUnlockedAbilities(
+    skills,
+    ~background=Assault,
+  )->Array.filter(a => a.category == Infiltration)
+  // Expert unlocks all 4 generic abilities (no exclusive for Infiltration+Assault)
+  Promise.resolve(Array.length(infiltrationAbilities) == 4)
+}
+
+let testExpertUnlocksIncludingExclusive = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  // Promote combat to Expert (Assault specialism)
+  skills.combat.rank = Expert
+  let combatAbilities = SkillAbilities.getUnlockedAbilities(
+    skills,
+    ~background=Assault,
+  )->Array.filter(a => a.category == CombatSkill)
+  // 4 generic + 1 exclusive (Blitz) = 5
+  Promise.resolve(Array.length(combatAbilities) == 5)
+}
+
+// ===========================================================================
+// Background-exclusive abilities only show for correct background
+// ===========================================================================
+
+let testExclusiveAbilityCorrectBackground = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  skills.combat.rank = Expert
+  let isUnlocked = SkillAbilities.isAbilityUnlocked(
+    skills,
+    ~background=Assault,
+    "combat_expert_blitz",
+  )
+  Promise.resolve(isUnlocked)
+}
+
+let testExclusiveAbilityWrongBackground = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Recon)
+  skills.combat.rank = Expert
+  // Recon operative at Expert Combat still cannot use Blitz
+  let isUnlocked = SkillAbilities.isAbilityUnlocked(
+    skills,
+    ~background=Recon,
+    "combat_expert_blitz",
+  )
+  Promise.resolve(!isUnlocked)
+}
+
+let testExclusiveAbilityNoBackground = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  skills.combat.rank = Expert
+  // Without specifying background, exclusive abilities are locked
+  let isUnlocked = SkillAbilities.isAbilityUnlocked(
+    skills,
+    "combat_expert_blitz",
+  )
+  Promise.resolve(!isUnlocked)
+}
+
+let testOmniscienceOnlyForRecon = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Recon)
+  skills.observation.rank = Expert
+  let recon = SkillAbilities.isAbilityUnlocked(
+    skills,
+    ~background=Recon,
+    "observation_expert_omniscience",
+  )
+  let assault = SkillAbilities.isAbilityUnlocked(
+    skills,
+    ~background=Assault,
+    "observation_expert_omniscience",
+  )
+  Promise.resolve(recon && !assault)
+}
+
+let testPhoenixOnlyForMedic = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Medic)
+  skills.composure.rank = Expert
+  let medic = SkillAbilities.isAbilityUnlocked(
+    skills,
+    ~background=Medic,
+    "composure_expert_phoenix",
+  )
+  let assault = SkillAbilities.isAbilityUnlocked(
+    skills,
+    ~background=Assault,
+    "composure_expert_phoenix",
+  )
+  Promise.resolve(medic && !assault)
+}
+
+let testResupplyDropOnlyForLogistics = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Logistics)
+  skills.fieldcraft.rank = Expert
+  let logistics = SkillAbilities.isAbilityUnlocked(
+    skills,
+    ~background=Logistics,
+    "fieldcraft_expert_resupply_drop",
+  )
+  let recon = SkillAbilities.isAbilityUnlocked(
+    skills,
+    ~background=Recon,
+    "fieldcraft_expert_resupply_drop",
+  )
+  Promise.resolve(logistics && !recon)
+}
+
+// ===========================================================================
+// getUnlockedAbilities returns correct count for various skill states
+// ===========================================================================
+
+let testUnlockedCountAllNovice = (): promise<bool> => {
+  // Assault starts combat at Trained => 1 ability unlocked
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  let unlocked = SkillAbilities.getUnlockedAbilities(skills, ~background=Assault)
+  Promise.resolve(Array.length(unlocked) == 1)
+}
+
+let testUnlockedCountMixedRanks = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Recon)
+  // Recon starts observation at Trained (1 ability)
+  // Promote infiltration to Proficient (2 abilities)
+  skills.infiltration.rank = Proficient
+  let unlocked = SkillAbilities.getUnlockedAbilities(skills, ~background=Recon)
+  // 1 (observation Trained) + 2 (infiltration Trained+Proficient) = 3
+  Promise.resolve(Array.length(unlocked) == 3)
+}
+
+let testUnlockedCountFullExpert = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  // Promote all skills to Expert
+  skills.infiltration.rank = Expert
+  skills.combat.rank = Expert
+  skills.athletics.rank = Expert
+  skills.observation.rank = Expert
+  skills.techLiteracy.rank = Expert
+  skills.fieldcraft.rank = Expert
+  skills.composure.rank = Expert
+  let unlocked = SkillAbilities.getUnlockedAbilities(skills, ~background=Assault)
+  // 28 generic + 1 exclusive (Blitz for Assault/Combat) = 29
+  Promise.resolve(Array.length(unlocked) == 29)
+}
+
+// ===========================================================================
+// isAbilityUnlocked — unknown ability returns false
+// ===========================================================================
+
+let testUnknownAbilityReturnsFalse = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  let isUnlocked = SkillAbilities.isAbilityUnlocked(
+    skills,
+    ~background=Assault,
+    "nonexistent_ability",
+  )
+  Promise.resolve(!isUnlocked)
+}
+
+// ===========================================================================
+// findAbility — lookup by ID
+// ===========================================================================
+
+let testFindAbilityExists = (): promise<bool> => {
+  switch SkillAbilities.findAbility("infiltration_trained_silent_walk") {
+  | Some(a) => Promise.resolve(a.name == "Silent Walk")
+  | None => Promise.resolve(false)
+  }
+}
+
+let testFindAbilityMissing = (): promise<bool> => {
+  Promise.resolve(SkillAbilities.findAbility("nonexistent") == None)
+}
+
+// ===========================================================================
+// Rank progression — proficient unlocks 2, veteran unlocks 3
+// ===========================================================================
+
+let testProficientUnlocksTwo = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  skills.infiltration.rank = Proficient
+  let infiltrationAbilities = SkillAbilities.getUnlockedAbilities(
+    skills,
+    ~background=Assault,
+  )->Array.filter(a => a.category == Infiltration)
+  Promise.resolve(Array.length(infiltrationAbilities) == 2)
+}
+
+let testVeteranUnlocksThree = (): promise<bool> => {
+  let skills = JessicaBackground.makeSkillSet(Assault)
+  skills.infiltration.rank = Veteran
+  let infiltrationAbilities = SkillAbilities.getUnlockedAbilities(
+    skills,
+    ~background=Assault,
+  )->Array.filter(a => a.category == Infiltration)
+  Promise.resolve(Array.length(infiltrationAbilities) == 3)
+}
+
+// ===========================================================================
+// Each exclusive ability has correct category mapping
+// ===========================================================================
+
+let testAllExclusivesHaveBackground = (): promise<bool> => {
+  let allHaveBg = SkillAbilities.exclusiveAbilities->Array.every(a =>
+    a.exclusiveBackground != None
+  )
+  Promise.resolve(allHaveBg)
+}
+
+let testAllExclusivesAreExpert = (): promise<bool> => {
+  let allExpert = SkillAbilities.exclusiveAbilities->Array.every(a =>
+    a.requiredRank == Expert
+  )
+  Promise.resolve(allExpert)
+}
+
+let testAllGenericHaveNoBackground = (): promise<bool> => {
+  let allNone = SkillAbilities.genericAbilities->Array.every(a =>
+    a.exclusiveBackground == None
+  )
+  Promise.resolve(allNone)
+}
+
+// ===========================================================================
+// Unique IDs — no duplicates
+// ===========================================================================
+
+let testUniqueIds = (): promise<bool> => {
+  let ids = SkillAbilities.allAbilities->Array.map(a => a.id)
+  let uniqueIds = Set.fromArray(ids)
+  Promise.resolve(Set.size(uniqueIds) == Array.length(ids))
+}
+
+// ===========================================================================
+// Suite
+// ===========================================================================
+
+let suite: TestRunner.suite = {
+  name: "SkillAbilities (Jessica's skill ability tree)",
+  cases: [
+    {name: "genericAbilities: 28 total (7 categories x 4 ranks)", run: testGenericAbilitiesCount},
+    {name: "exclusiveAbilities: 6 total (one per background)", run: testExclusiveAbilitiesCount},
+    {name: "allAbilities: 34 total (28 + 6)", run: testAllAbilitiesCount},
+    {name: "getAbilitiesForCategory: Infiltration = 4", run: testAbilitiesForInfiltration},
+    {name: "getAbilitiesForCategory: Combat = 5 (4 generic + 1 exclusive)", run: testAbilitiesForCombat},
+    {name: "getAbilitiesForCategory: TechLiteracy = 6 (4 generic + 2 exclusive)", run: testAbilitiesForTechLiteracy},
+    {name: "getAbilitiesForCategoryAndBackground: Assault/Combat = 5", run: testAbilitiesForCategoryAndBackground},
+    {name: "getAbilitiesForCategoryAndBackground: excludes other bg", run: testAbilitiesForCategoryExcludesOtherBackground},
+    {name: "Novice rank unlocks nothing", run: testNoviceUnlocksNothing},
+    {name: "Trained rank unlocks exactly 1 ability", run: testTrainedUnlocksOne},
+    {name: "Trained rank unlocks correct ability (Quick Strike)", run: testTrainedUnlocksCorrectAbility},
+    {name: "Proficient rank unlocks 2 abilities", run: testProficientUnlocksTwo},
+    {name: "Veteran rank unlocks 3 abilities", run: testVeteranUnlocksThree},
+    {name: "Expert rank unlocks all 4 generic abilities", run: testExpertUnlocksAll},
+    {name: "Expert rank unlocks generic + exclusive", run: testExpertUnlocksIncludingExclusive},
+    {name: "exclusive: Blitz only for Assault", run: testExclusiveAbilityCorrectBackground},
+    {name: "exclusive: Blitz locked for Recon", run: testExclusiveAbilityWrongBackground},
+    {name: "exclusive: Blitz locked without background", run: testExclusiveAbilityNoBackground},
+    {name: "exclusive: Omniscience only for Recon", run: testOmniscienceOnlyForRecon},
+    {name: "exclusive: Phoenix only for Medic", run: testPhoenixOnlyForMedic},
+    {name: "exclusive: Resupply Drop only for Logistics", run: testResupplyDropOnlyForLogistics},
+    {name: "getUnlockedAbilities: Assault default = 1", run: testUnlockedCountAllNovice},
+    {name: "getUnlockedAbilities: mixed ranks = 3", run: testUnlockedCountMixedRanks},
+    {name: "getUnlockedAbilities: full Expert = 29", run: testUnlockedCountFullExpert},
+    {name: "isAbilityUnlocked: unknown ability = false", run: testUnknownAbilityReturnsFalse},
+    {name: "findAbility: exists", run: testFindAbilityExists},
+    {name: "findAbility: missing = None", run: testFindAbilityMissing},
+    {name: "all exclusives have a background", run: testAllExclusivesHaveBackground},
+    {name: "all exclusives require Expert rank", run: testAllExclusivesAreExpert},
+    {name: "all generics have no background restriction", run: testAllGenericHaveNoBackground},
+    {name: "all ability IDs are unique", run: testUniqueIds},
+  ],
+}