M6.5: StepSkills + ability-bonus breakdown + Aside redesign

The skills step lands as the last data-driven character creation step
(only Sign — name + confirm — remains for M6.6). Brought a few cross-
cutting refactors with it.

Scenes/Steps/StepSkills.cs:
  Direct port of StepSkills in src/steps.jsx — all 18 skills laid out
  in 6 ability-grouped panels (STR/DEX/CON/INT/WIS/CHA), 2-column
  grid. Background-granted skills appear pre-checked and locked;
  user picks `class.SkillsChoose` more from `class.SkillOptions`.
  Hover the skill name → popover with the codex flavor description
  (limited to the title only — hovering checkboxes / source tags
  doesn't trigger the popover, avoids interference with adjacent
  rows' click targets). Fixed-width [✓] / [ ] / [—] checkbox slot
  so toggling doesn't shift the row layout.

UI/SkillsCatalog.cs (new):
  Static skill table — JSON id, display label, governing ability,
  and the codex SKILL_DESC text ported verbatim from src/data.jsx.
  Mirrors Theriapolis.Core.Rules.Stats.SkillId; descriptions live
  here because backgrounds.json and classes.json don't carry them.

UI/AbilityCalc.cs (new):
  Final-score math — base assignment + clade and species mods, with
  per-source breakdown for the bonus popover ("+1 from Canidae · +2
  from Wolf"). Hybrid mode tags each clade source with its lineage
  ("(sire)" / "(dam)"). Used by both StepStats and the Aside so the
  two views can never disagree on what a +N badge means.

UI/BackgroundAvailability.cs (new):
  Extracted from StepBackground — shared rules table for hybrid-only
  and clade-restricted backgrounds. Now also consulted by StepClade
  when the player changes lineage: the currently-selected background
  is auto-cleared if the new lineage no longer satisfies its rule
  (e.g., Pack-Raised clears when switching from Canidae to Felidae,
  Passer clears when toggling Hybrid off). Implemented via
  Resource.Duplicate + Patch on the duplicate to evaluate the
  hypothetical post-patch state without committing prematurely.

StepStats.cs:
  Per-row layout extended: ability label | slot | bonus chip | final
  | d20 mod. Bonus chip is a TraitChip with the per-source breakdown
  in its hover description. Auto-assign now sorts empty abilities by
  AbilityCalc.TotalBonus DESCENDING (with class.PrimaryAbility as
  tiebreaker) — biggest pool value lands on the ability already
  receiving the biggest lineage bonus, maximising final scores.

Aside.cs (significant redesign):
  - Name centered at top.
  - Lineage details: 2-column grid, full-width.
    - Purebred:  Clade | Species, then Calling | Background, then
                 Subclass | (empty).
    - Hybrid:    SIRE ★ | DAM (centered + underlined column heads),
                 Clade | Clade, Species | Species, then the same
                 calling/background/subclass rows.
  - Attributes: STR/DEX/CON/INT/WIS/CHA each with bonus chip (omitted
    when +0), final score, d20 modifier. Self-contained min-width
    table so it can't widen the panel beyond its alloc.
  - Pills: traits, detriments, level-1 features, background feature,
    skill chips (BG-locked + user-chosen). All hoverable for descriptions.
  - Whole panel wraps in a ScrollContainer so an over-tall summary
    scrolls in place instead of pushing the wizard layout off-screen.
  - Width nudged 320 → 360px. Smaller font on label tags, autowrap
    on value labels so long names ("Hybrid Underground") wrap rather
    than push the panel wider.

Card grids: changed all five card-grid steps (Clade, Species, Class,
Subclass, Background) from SizeFlagsHorizontal.ExpandFill →
ShrinkCenter. Cards stay at their CustomMinimumSize 200 wide and
the grid horizontally centers in PageMain. The right-side gap
between content and Aside is now uniform regardless of how many
cards or whether the last row is partial — fixes the "Clade tab
feels too padded, Background tab too tight" perception.

Closes M6.5. Per guide §12, what's left in M6: M6.6 (StepReview —
name + summary + Confirm handoff per guide §11) and M6.7 (parchment
Theme pass).

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

Theriapolis.Godot/Scenes/Steps/StepBackground.cs

@@ -43,7 +43,7 @@ public partial class StepBackground : VBoxContainer, IStep
             AutowrapMode = TextServer.AutowrapMode.WordSmart,
         });
 
-        _grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ExpandFill };
+        _grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ShrinkCenter };
         _grid.AddThemeConstantOverride("h_separation", 16);
         _grid.AddThemeConstantOverride("v_separation", 16);
         AddChild(_grid);
@@ -51,37 +51,13 @@ public partial class StepBackground : VBoxContainer, IStep
         Refresh();
     }
 
-    /// <summary>
-    /// Background-availability rules. The backgrounds.json schema doesn't
-    /// carry restriction fields — the gating lives in flavor text only —
-    /// so they're hardcoded here. Each predicate returns true when the
-    /// background is available to the given draft; missing entries are
-    /// universally available.
-    ///
-    /// If backgrounds.json ever gains structured restriction fields,
-    /// swap these out for a property-driven check.
-    /// </summary>
-    private static readonly System.Collections.Generic.Dictionary<string, System.Func<UI.CharacterDraft, bool>> AvailabilityRules = new()
-    {
-        // Hybrid-only backgrounds — flavor text explicitly hybrid.
-        { "passer",             d => d.IsHybrid },
-        { "hybrid_underground", d => d.IsHybrid },
-        { "former_chattel",     d => d.IsHybrid },
-
-        // Clade-restricted backgrounds.
-        { "warren_runner",      d => d.HasClade("leporidae") },
-        { "pack_raised",        d => d.HasClade("canidae") },
-        { "herd_city_born",     d => d.HasAnyCladeOfKind("prey") },
-    };
-
     private void Refresh()
     {
         if (_grid is null) return;
         foreach (var c in _grid.GetChildren()) c.QueueFree();
         foreach (var bg in CodexContent.Backgrounds)
         {
-            if (AvailabilityRules.TryGetValue(bg.Id, out var rule) && !rule(_draft))
-                continue;
+            if (!BackgroundAvailability.IsAvailable(bg.Id, _draft)) continue;
             _grid.AddChild(BuildCard(bg));
         }
     }

Theriapolis.Godot/Scenes/Steps/StepClade.cs

@@ -101,7 +101,7 @@ public partial class StepClade : VBoxContainer, IStep
 
     private static GridContainer MakeGrid()
     {
-        var grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ExpandFill };
+        var grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ShrinkCenter };
         grid.AddThemeConstantOverride("h_separation", 16);
         grid.AddThemeConstantOverride("v_separation", 16);
         return grid;
@@ -132,6 +132,7 @@ public partial class StepClade : VBoxContainer, IStep
             patch["dam_clade_id"] = "";
             patch["dam_species_id"] = "";
         }
+        ClearBackgroundIfInvalidated(patch);
         _draft.Patch(patch);
     }
 
@@ -172,11 +173,13 @@ public partial class StepClade : VBoxContainer, IStep
         var sp = CodexContent.SpeciesById(speciesId);
         if (sp is null || !string.Equals(sp.CladeId, cladeId, System.StringComparison.OrdinalIgnoreCase))
             speciesId = "";
-        _draft.Patch(new Godot.Collections.Dictionary
+        var patch = new Godot.Collections.Dictionary
         {
             { "clade_id",   cladeId },
             { "species_id", speciesId },
-        });
+        };
+        ClearBackgroundIfInvalidated(patch);
+        _draft.Patch(patch);
     }
 
     private void OnLineageCladePicked(string lineage, string cladeId)
@@ -189,9 +192,28 @@ public partial class StepClade : VBoxContainer, IStep
         var sp = CodexContent.SpeciesById(currentSpecies);
         if (sp is null || !string.Equals(sp.CladeId, cladeId, System.StringComparison.OrdinalIgnoreCase))
             patch[lineage + "_species_id"] = "";
+        ClearBackgroundIfInvalidated(patch);
         _draft.Patch(patch);
     }
 
+    /// <summary>
+    /// Clade changes can make a previously-valid background unavailable
+    /// (e.g. picking Felidae while Pack-Raised is selected). Build the
+    /// hypothetical post-patch state via Resource.Duplicate, run it
+    /// through BackgroundAvailability, and clear background_id in the
+    /// patch if the rule no longer matches.
+    /// </summary>
+    private void ClearBackgroundIfInvalidated(Godot.Collections.Dictionary patch)
+    {
+        if (string.IsNullOrEmpty(_draft.BackgroundId)) return;
+
+        var future = (CharacterDraft)_draft.Duplicate();
+        // Apply the same patch we're about to commit, in-place on the copy.
+        future.Patch(patch);
+        if (!BackgroundAvailability.IsAvailable(_draft.BackgroundId, future))
+            patch["background_id"] = "";
+    }
+
     private PanelContainer BuildCard(CladeDef clade, System.Action<string> onClick)
     {
         var card = new PanelContainer

Theriapolis.Godot/Scenes/Steps/StepClass.cs

@@ -47,7 +47,7 @@ public partial class StepClass : VBoxContainer, IStep
             AutowrapMode = TextServer.AutowrapMode.WordSmart,
         });
 
-        _grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ExpandFill };
+        _grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ShrinkCenter };
         _grid.AddThemeConstantOverride("h_separation", 16);
         _grid.AddThemeConstantOverride("v_separation", 16);
         AddChild(_grid);

Theriapolis.Godot/Scenes/Steps/StepSkills.cs

@@ -0,0 +1,233 @@
+using Godot;
+using System.Collections.Generic;
+using Theriapolis.GodotHost.Scenes.Widgets;
+using Theriapolis.GodotHost.UI;
+
+namespace Theriapolis.GodotHost.Scenes.Steps;
+
+/// <summary>
+/// Step VII — Skills. Direct port of <c>StepSkills</c> in
+/// <c>src/steps.jsx</c>: 18 skills laid out in 6 ability groups
+/// (STR / DEX / CON / INT / WIS / CHA). Background-granted skills are
+/// pre-checked and locked; the user picks <c>class.SkillsChoose</c>
+/// more from <c>class.SkillOptions</c>. Hover any skill row → popover
+/// with the description.
+///
+/// State:
+///   - "locked"      → granted by background, can't toggle (✓ shown)
+///   - "checked"     → user-picked from class options (✓ shown)
+///   - "available"   → in class options, unchecked
+///   - "unavailable" → not in class options, dimmed and unclickable
+/// </summary>
+public partial class StepSkills : VBoxContainer, IStep
+{
+    private CharacterDraft _draft = null!;
+    private Label _countLabel = null!;
+    private Label _classBgLabel = null!;
+    private GridContainer _groupsGrid = null!;
+
+    public void Bind(CharacterDraft draft)
+    {
+        _draft = draft;
+        _draft.Changed += () => Callable.From(Refresh).CallDeferred();
+        Build();
+    }
+
+    public string? Validate() => WizardValidation.Validate(6, _draft);
+
+    private void Build()
+    {
+        AddThemeConstantOverride("separation", 16);
+
+        var intro = new VBoxContainer();
+        intro.AddThemeConstantOverride("separation", 6);
+        AddChild(intro);
+        intro.AddChild(new Label { Text = "FOLIO VII · SKILLS" });
+        intro.AddChild(new Label { Text = "Choose Your Skills" });
+        intro.AddChild(new Label
+        {
+            Text = "Your background grants two skills automatically (sealed). From your "
+                 + "calling's offered list, choose the rest. Hover any skill for its codex "
+                 + "reading.",
+            AutowrapMode = TextServer.AutowrapMode.WordSmart,
+        });
+
+        var meta = new HBoxContainer();
+        meta.AddThemeConstantOverride("separation", 24);
+        AddChild(meta);
+        _countLabel = new Label { Text = "0 / 0 chosen" };
+        meta.AddChild(_countLabel);
+        var spacer = new Control { SizeFlagsHorizontal = SizeFlags.ExpandFill };
+        meta.AddChild(spacer);
+        _classBgLabel = new Label { Text = "" };
+        meta.AddChild(_classBgLabel);
+
+        _groupsGrid = new GridContainer
+        {
+            Columns = 2,
+            SizeFlagsHorizontal = SizeFlags.ExpandFill,
+        };
+        _groupsGrid.AddThemeConstantOverride("h_separation", 18);
+        _groupsGrid.AddThemeConstantOverride("v_separation", 18);
+        AddChild(_groupsGrid);
+
+        Refresh();
+    }
+
+    private void Refresh()
+    {
+        if (_groupsGrid is null) return;
+
+        var cls = CodexContent.Class(_draft.ClassId);
+        var bg  = CodexContent.Background(_draft.BackgroundId);
+        int required = cls?.SkillsChoose ?? 0;
+
+        var lockedFromBg = new HashSet<string>(bg?.SkillProficiencies ?? System.Array.Empty<string>());
+        var classOptions = new HashSet<string>(cls?.SkillOptions ?? System.Array.Empty<string>());
+        var chosen = new HashSet<string>(_draft.ChosenSkills);
+
+        _countLabel.Text = $"{chosen.Count} / {required} chosen   +{lockedFromBg.Count} sealed by background";
+        _classBgLabel.Text = (cls is null ? "Pick a calling first." :
+            $"Calling: {cls.Name}   ·   History: {bg?.Name ?? "—"}").ToUpperInvariant();
+
+        foreach (var c in _groupsGrid.GetChildren()) c.QueueFree();
+
+        if (cls is null) return;
+
+        foreach (var ability in SkillsCatalog.Abilities)
+            _groupsGrid.AddChild(BuildAbilityGroup(ability, lockedFromBg, classOptions, chosen, required));
+    }
+
+    private Control BuildAbilityGroup(string ability,
+                                       HashSet<string> lockedFromBg,
+                                       HashSet<string> classOptions,
+                                       HashSet<string> chosen,
+                                       int required)
+    {
+        var panel = new PanelContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill };
+        var col = new VBoxContainer();
+        col.AddThemeConstantOverride("separation", 4);
+        panel.AddChild(col);
+
+        // Header — full ability name + abbreviation.
+        var header = new HBoxContainer();
+        header.AddThemeConstantOverride("separation", 8);
+        col.AddChild(header);
+        header.AddChild(new Label { Text = SkillsCatalog.AbilityFullName[ability] });
+        var spacer = new Control { SizeFlagsHorizontal = SizeFlags.ExpandFill };
+        header.AddChild(spacer);
+        header.AddChild(new Label { Text = ability });
+
+        foreach (var s in SkillsCatalog.ByAbility(ability))
+            col.AddChild(BuildSkillRow(s, lockedFromBg, classOptions, chosen, required));
+
+        return panel;
+    }
+
+    private Control BuildSkillRow(SkillsCatalog.SkillEntry skill,
+                                   HashSet<string> lockedFromBg,
+                                   HashSet<string> classOptions,
+                                   HashSet<string> chosen,
+                                   int required)
+    {
+        bool fromBg     = lockedFromBg.Contains(skill.JsonId);
+        bool fromClass  = classOptions.Contains(skill.JsonId);
+        bool isChecked  = chosen.Contains(skill.JsonId);
+        bool clickable  = fromClass && !fromBg;
+
+        var row = new PanelContainer
+        {
+            MouseFilter = MouseFilterEnum.Stop,
+        };
+
+        // Visual state: dim unavailable rows, gild-tint background-locked,
+        // brighten chosen. Theming pass will replace Modulate with proper
+        // styleboxes per state.
+        if (fromBg)
+            row.Modulate = new Color(1f, 0.95f, 0.7f);
+        else if (!fromClass)
+            row.Modulate = new Color(1f, 1f, 1f, 0.4f);
+        else if (isChecked)
+            row.Modulate = new Color(0.95f, 1f, 0.95f);
+
+        var rowH = new HBoxContainer { MouseFilter = MouseFilterEnum.Pass };
+        rowH.AddThemeConstantOverride("separation", 8);
+        row.AddChild(rowH);
+
+        // Fixed-width slot for the checkbox so the name doesn't jump
+        // horizontally when toggling — "[✓]" and "[ ]" render at slightly
+        // different widths in proportional fonts.
+        var checkbox = new Label
+        {
+            Text = (fromBg || isChecked) ? "[✓]" : (clickable ? "[ ]" : "[—]"),
+            CustomMinimumSize = new Vector2(36, 0),
+            HorizontalAlignment = HorizontalAlignment.Center,
+            MouseFilter = MouseFilterEnum.Ignore,
+        };
+        rowH.AddChild(checkbox);
+
+        // Skill name — the only hover trigger for the popover. MouseFilter
+        // = Stop so MouseEntered/Exited fire on this label specifically;
+        // GuiInput handles click here too so toggling works whether you
+        // click the name or the row's other areas.
+        var nameLabel = new Label
+        {
+            Text = skill.Label,
+            SizeFlagsHorizontal = SizeFlags.ExpandFill,
+            MouseFilter = MouseFilterEnum.Stop,
+        };
+        rowH.AddChild(nameLabel);
+        nameLabel.MouseEntered += () =>
+            PopoverLayer.Instance?.ShowFor(nameLabel, skill.Label, skill.Description, skill.Ability, false);
+        nameLabel.MouseExited += () =>
+            PopoverLayer.Instance?.ScheduleClose();
+        if (clickable)
+        {
+            nameLabel.GuiInput += (InputEvent e) =>
+            {
+                if (e is InputEventMouseButton mb && mb.Pressed && mb.ButtonIndex == MouseButton.Left)
+                    Toggle(skill.JsonId, isChecked, required);
+            };
+        }
+
+        rowH.AddChild(new Label
+        {
+            Text = fromBg ? "BG" : (fromClass ? "CLASS" : "—"),
+            MouseFilter = MouseFilterEnum.Ignore,
+        });
+
+        // Click anywhere else on the row → also toggles. Hover here doesn't
+        // trigger the popover; only the name label does.
+        if (clickable)
+        {
+            row.GuiInput += (InputEvent e) =>
+            {
+                if (e is InputEventMouseButton mb && mb.Pressed && mb.ButtonIndex == MouseButton.Left)
+                    Toggle(skill.JsonId, isChecked, required);
+            };
+        }
+
+        return row;
+    }
+
+    private void Toggle(string skillId, bool isCurrentlyChecked, int required)
+    {
+        var newChosen = new Godot.Collections.Array<string>(_draft.ChosenSkills);
+        if (isCurrentlyChecked)
+        {
+            newChosen.Remove(skillId);
+        }
+        else if (newChosen.Count < required)
+        {
+            newChosen.Add(skillId);
+        }
+        else
+        {
+            return; // already at the cap; no-op
+        }
+        _draft.Patch(new Godot.Collections.Dictionary
+        {
+            { "chosen_skills", newChosen },
+        });
+    }
+}

Theriapolis.Godot/Scenes/Steps/StepSpecies.cs

@@ -72,7 +72,7 @@ public partial class StepSpecies : VBoxContainer, IStep
 
     private static GridContainer MakeGrid()
     {
-        var grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ExpandFill };
+        var grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ShrinkCenter };
         grid.AddThemeConstantOverride("h_separation", 16);
         grid.AddThemeConstantOverride("v_separation", 16);
         return grid;

Theriapolis.Godot/Scenes/Steps/StepStats.cs

@@ -33,6 +33,9 @@ public partial class StepStats : VBoxContainer, IStep
     private CharacterDraft _draft = null!;
     private AbilityPool _pool = null!;
     private readonly Dictionary<string, AbilitySlot> _slots = new();
+    private readonly Dictionary<string, TraitChip> _bonusChips = new();
+    private readonly Dictionary<string, Label> _finalLabels = new();
+    private readonly Dictionary<string, Label> _dModLabels = new();
     private Button _arrayBtn = null!;
     private Button _rollBtn = null!;
     private Button _rerollBtn = null!;
@@ -125,6 +128,34 @@ public partial class StepStats : VBoxContainer, IStep
                 => HandleSlotDrop(payload, captured);
             _slots[captured] = slot;
             row.AddChild(slot);
+
+            // Bonus chip — hover for the per-source breakdown.
+            var bonus = new TraitChip { TraitName = "+0", Description = "" };
+            bonus.CustomMinimumSize = new Vector2(56, 0);
+            _bonusChips[captured] = bonus;
+            row.AddChild(bonus);
+
+            // Final score (= base + total bonus).
+            var finalLbl = new Label
+            {
+                Text = "—",
+                CustomMinimumSize = new Vector2(48, 0),
+                HorizontalAlignment = HorizontalAlignment.Right,
+                VerticalAlignment = VerticalAlignment.Center,
+            };
+            _finalLabels[captured] = finalLbl;
+            row.AddChild(finalLbl);
+
+            // d20 modifier from final score.
+            var dModLbl = new Label
+            {
+                Text = "",
+                CustomMinimumSize = new Vector2(48, 0),
+                HorizontalAlignment = HorizontalAlignment.Right,
+                VerticalAlignment = VerticalAlignment.Center,
+            };
+            _dModLabels[captured] = dModLbl;
+            row.AddChild(dModLbl);
         }
 
         Refresh();
@@ -161,6 +192,23 @@ public partial class StepStats : VBoxContainer, IStep
             _pool.AddChild(token);
         }
 
+        // Bonus / final / d20 mod per ability — updated in place from the
+        // computed mod sources so the row stays stable across drops.
+        foreach (var ab in Abilities)
+        {
+            int bonus = AbilityCalc.TotalBonus(ab, _draft);
+            int baseScore = AbilityCalc.BaseScore(ab, _draft);
+            int final = baseScore + bonus;
+            int dMod = AbilityCalc.D20Modifier(final);
+
+            _bonusChips[ab].SetTrait(
+                AbilityCalc.FormatSigned(bonus),
+                AbilityCalc.FormatBreakdown(AbilityCalc.Sources(ab, _draft)),
+                tag: "bonus");
+            _finalLabels[ab].Text = baseScore == 0 ? "—" : final.ToString();
+            _dModLabels[ab].Text = baseScore == 0 ? "" : AbilityCalc.FormatSigned(dMod);
+        }
+
         // Slots: token if assigned, otherwise dash placeholder.
         foreach (var (ab, slot) in _slots)
         {
@@ -265,12 +313,16 @@ public partial class StepStats : VBoxContainer, IStep
     {
         if (_draft.StatPool.Count == 0) return;
 
-        // Empty slots, ordered by class primary abilities first.
+        // Empty slots, ordered DESCENDING by their clade+species bonus —
+        // highest pool value goes to the ability with the highest bonus
+        // already coming in, maximising the final score on each. Ties
+        // broken by class.PrimaryAbility order.
         var cls = CodexContent.Class(_draft.ClassId);
         var primary = cls?.PrimaryAbility ?? System.Array.Empty<string>();
         var emptyAbilities = Abilities
             .Where(a => !_draft.StatAssign.ContainsKey(a))
-            .OrderBy(a =>
+            .OrderByDescending(a => AbilityCalc.TotalBonus(a, _draft))
+            .ThenBy(a =>
             {
                 int idx = System.Array.IndexOf(primary, a);
                 return idx < 0 ? 99 : idx;

Theriapolis.Godot/Scenes/Steps/StepSubclass.cs

@@ -50,7 +50,7 @@ public partial class StepSubclass : VBoxContainer, IStep
             AutowrapMode = TextServer.AutowrapMode.WordSmart,
         });
 
-        _grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ExpandFill };
+        _grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ShrinkCenter };
         _grid.AddThemeConstantOverride("h_separation", 16);
         _grid.AddThemeConstantOverride("v_separation", 16);
         AddChild(_grid);