feat(tests): the kitchen sink -- every 6E rule no corpus character takes, oracle-verified

PeterB: "the objects are derived from the rules -- not the corpus. so
regardless if a char exercises it, it needs to be future-proofed. there
are some obscure powers no one ever takes. but someone will some day."

Measured against the full registry and all 655 oracle fixtures, 24
registered 6E rules appeared in no character at all: seven powers
(ADJACENT, ADJACENTFIXED, DIFFERINGMODIFIER, DIMENSIONALALL,
DIMENSIONALGROUP, ENDURANCERESERVEREC, RAPID), thirteen modifiers
(CANBEMISSILEDEFLECTED, CUMULATIVE, DELAYEDEFFECT, EXPLOSION,
HALFRANGEMODIFIER, NND, NOTTHROUGHMINDLINK, ONLYONAPPROPRIATETERRAIN,
ONLYTOSTARTING, SUBJECTTORANGEMODIFIER, TIMELIMIT, TURNMODE, VISIBLE),
CUSTOMTALENT, FAVOR, RESOURCE_POOL and RANGEDDC.

tests/kitchen_sink.py generates one character carrying all of them.
Deterministic (fixed ids, no timestamps), written to a temp dir at
collection, so it is never redistributed and never skips -- it is
nobody's build. tests/fixtures/authored/KitchenSink.json is the Java
oracle's verdict on it, compared per object by the same harness as
Ravel, Bokor and PowerLad: 41 objects, 0 mismatches on cost or display,
468 = 468 total points.

It found two defects on its first run, neither reachable from the corpus:

  * DIFFERINGMODIFIER charged 5 real where HD charges 0. The port never
    implemented getRealCostPreList, whose last line is `ret -=
    getLevels()`: the levels are points already paid for, only the
    increment is charged. Its display was never ported either.
  * RAPID printed "Rapid ( x10)" without " with Sight Group". Its display
    override read _selected_option, always None for a sense adder --
    the base class's own docstring says so and uses option_alias.

Also restored PowerLad.hdc to the authored directory (it was on the
Desktop), so the no-skips guard's four skips are gone.

1615 passed, 0 skipped.

Author: pdbethke

kirby_cost/objects/powers/differing_modifier.py

@@ -6,6 +6,7 @@
 Differing modifier power.
 """
 
+from kirby_cost.objects.base import GenericObject
 from kirby_cost.objects.powers.power import Power
 from kirby_cost.util.rounder import round_half_down
 
@@ -50,3 +51,78 @@ def active_cost(self) -> float:
 
         return active_cost
 
+    @property
+    def real_cost_pre_list(self) -> float:
+        """Ported from DifferingModifier.getRealCostPreList.
+
+        The shape is the ordinary one -- limitations divide the active
+        cost, then the multiplier, then the quantity doublings -- with one
+        line at the end that makes this power what it is: ``ret -=
+        getLevels()``. A Differing Modifier's levels are the points of the
+        underlying power it re-modifies, and the character has already
+        paid for those; what he pays here is only the INCREMENT the new
+        modifiers add. Five levels with no modifiers therefore cost 5
+        active and 0 real.
+
+        The base Power's real cost had no such subtraction, so this read 5
+        where HD reads 0. Found by the kitchen-sink fixture, 2026-08-29: no
+        corpus character had ever bought one.
+        """
+        ret = self.active_cost
+        limitation_total = 0.0
+        for mod in self.assigned_modifiers:
+            if mod.total_value <= 0.0:
+                limitation_total += mod.total_value
+
+        parent = self._parent
+        if parent is not None and hasattr(parent, "assigned_modifiers"):
+            from kirby_cost.objects.frameworks.multipower import Multipower
+            for mod in parent.assigned_modifiers:
+                if mod.types and "VPP" in mod.types:
+                    continue
+                if mod.xmlid == "CHARGES" and isinstance(parent, Multipower):
+                    continue
+                if (GenericObject.find_object_by_id(self.assigned_modifiers, mod.xmlid) is None
+                        or mod.xmlid in ("GENERIC_OBJECT", "CUSTOM_MODIFIER")):
+                    if mod.total_value < 0.0:
+                        limitation_total += mod.total_value
+
+        if limitation_total != 0.0:
+            ret = round_half_down(ret / (1.0 + abs(limitation_total)))
+
+        if self.multiplier != 1.0:
+            ret = round_half_down(ret * self.multiplier)
+        elif parent is not None and getattr(parent, "multiplier", 1.0) != 1.0:
+            ret = round_half_down(ret * parent.multiplier)
+
+        if self._quantity > 1:
+            q = float(self._quantity)
+            doublings = 0
+            while q > 1.0:
+                doublings += 1
+                q /= 2.0
+            ret += doublings * 5
+
+        ret -= self._levels
+        return ret
+
+    @property
+    def column2_output(self) -> str:
+        """``(5 Active Points) for up to 5 Points of Blast`` --
+        DifferingModifier.getColumn2Output. The line leads with the modifier
+        string rather than the alias, names the levels as points of the
+        power given in INPUT, and falls back to the alias plus
+        ``[unknown]`` when no input was recorded.
+        """
+        ret = self.modifier_string or ""
+        if self.input and self.input.strip():
+            ret += f" for up to {self._levels} Points of {self.input}"
+        else:
+            ret = f"{self.alias}: {ret} for up to {self._levels} Points of [unknown]"
+        if self._name and self._name.strip():
+            ret = f"<i>{self._name}:</i>  {ret}"
+        ret = ret.strip()
+        adders = self.adder_string or ""
+        if adders.strip():
+            ret += f" ({adders})"
+        return ret + self._end_reserve_note()

kirby_cost/objects/powers/rapid.py

@@ -36,10 +36,19 @@ def column2_output(self) -> str:
         if self._name and self._name.strip():
             output = f"<i>{self._name}:</i>  {output}"
 
-        # Build "with" string
+        # Build "with" string. The sense this applies to is the document's
+        # OPTION ("Sight Group"), and a sense adder's template lists no
+        # options, so `_selected_option` is None here -- exactly the bug
+        # SenseAdder.column2_output documents and fixes with `option_alias`.
+        # This override still read `_selected_option`, so "Rapid ( x10)"
+        # printed without its " with Sight Group" while every sibling kept
+        # it. Found by the kitchen-sink fixture, 2026-08-29: no corpus
+        # character had ever bought Rapid.
+        from kirby_cost.objects.base import option_alias
         with_str = " with "
-        if self._selected_option:
-            with_str += self._selected_option.alias
+        option = (option_alias(self) or "").strip()
+        if option:
+            with_str += option
             adder_str = self.adder_string
             if adder_str and adder_str.strip():
                 with_str += ", " + adder_str