feat(template): the 5E fallback supplies definitions, not rules — stateful ledger 0, prototype 1

PeterB ruling (kirby-cost is 6E-only): an entry loaded from the
earlier-edition sibling keeps costs/options/adders but drops its
EXCLUDES/REQUIRES and its non-framework TYPEs — HD's own verdicts prove the
line (it allows DOUBLEENDCOST+ENDRESERVEOREND together, and a bare 5E
MULTIPLESFX on a plain Blast, on a Main6E character). Framework-binding
types (VPP/MP/EC/LIST) survive: they classify private-vs-common cost
propagation. A MULTIPLESFX sink state lets HD keep adjudicating.

Also: CustomPower ports its template-init base-cost floor
(CustomPower.java:324-325, if baseCost==0 -> 1; a stated BASECOST still
wins), closing the five prototype-END cells. REDUCEDEND-on-SHAPESHIFT is the
one cell left, honestly labelled unexplained (HD allows where its own
visible code path would refuse; suspect the clone at ReducedEND.java:130).

Stateful matrix: 0 ledgered of 9,867. Prototype: 1 of 8,395. Sink cost
ledger: 10. Parity 695/695, display 91,221, suite 1,728.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PrVDXgpDfQpzEGErZTLjEs

Author: pdbethke

kirby_cost/objects/powers/custom_power.py

@@ -82,6 +82,7 @@ def __init__(self):
         self.use_custom_column3: bool = False
 
     @property
+
     def levels(self) -> int:
         """CustomPower levels = roundUp(baseCost)."""
         return round_up(self._base_cost)
@@ -90,6 +91,17 @@ def levels(self) -> int:
     def levels(self, value) -> None:
         self._levels = value
 
+    def apply_template(self, tmpl, option_id: str = None) -> None:
+        """CustomPower.java:315-328 (template init): after the template is
+        read, `if (baseCost == 0) baseCost = 1` -- HD's prototype floors a
+        zero base cost at 1 point, which is why its prototype reports
+        active_cost 1 and END 1. The document restore runs AFTER init in HD
+        and overwrites the floor, so a stated BASECOST (even an explicit 0)
+        wins -- mirrored here with the _base_cost_from_xml guard."""
+        super().apply_template(tmpl, option_id)
+        if self.base_cost == 0 and not self._base_cost_from_xml:
+            self.base_cost = 1.0
+
     @property
     def active_cost(self) -> float:
         """Calculate the active cost."""

kirby_cost/template/hdt_provider.py

@@ -432,7 +432,14 @@ def __init__(self, path: Optional[str | Path] = None,
             extras = [s for p in chain for s in self._siblings(p)]
         for extra in extras:
             if extra.is_file():
-                self._load(extra)
+                # kirby-cost is 6E-only (the 2026-08 purge); the earlier-edition
+                # sibling supplies DEFINITIONS HD itself resolves through it
+                # (ARMOR, SUPPRESS, TRANSFER, SUCCOR, DAMAGERESISTANCE,
+                # ENDURANCERESERVEREC) -- never 5E applicability RULES. HD's
+                # own verdicts prove the line: it allows DOUBLEENDCOST +
+                # ENDRESERVEOREND together on a Main6E character even though
+                # Main.hdt declares them mutually exclusive.
+                self._load(extra, fallback=True)
 
     @staticmethod
     def _resolve_builtin(name: str, beside: Path) -> Optional[Path]:
@@ -502,8 +509,35 @@ def sense_xmlids(self) -> frozenset[str]:
         """
         return frozenset(self._sense_xmlids)
 
-    def _load(self, path: Path) -> None:
+    def _strip_5e_rules(self, data: "TemplateData") -> "TemplateData":
+        """Definitions-only fallback (PeterB ruling 2026-08-30): an entry
+        loaded from an earlier-edition sibling keeps its costs, options and
+        adders but drops EXCLUDES/REQUIRES -- 5E applicability rules a 6E
+        engine must not enforce. TYPE is kept: it feeds oracle-gated cost
+        propagation and HD gave no verdict against it."""
+        if not getattr(self, "_loading_fallback", False):
+            return data
+        strip = {}
+        if getattr(data, "excludes", ()) or getattr(data, "requires", ()):
+            strip.update(excludes=(), requires=(), requires_all=False)
+        # TYPE too, for MODIFIER entries: HD allows a bare 5E-fallback
+        # MULTIPLESFX on a plain Blast (the stateful fixture's verdict), so
+        # the type gate is an applicability rule the fallback must not carry.
+        # Power entries keep their types -- those feed type-matching and
+        # oracle-gated cost paths for definitions HD genuinely resolves
+        # through the sibling (ARMOR, SUPPRESS, TRANSFER...).
+        # ...but FRAMEWORK-binding types (VPP/MP/EC/LIST) survive: they
+        # classify a modifier as private-vs-common, which feeds cost
+        # propagation -- a cost fact, not an applicability rule.
+        if not getattr(data, "is_power", False) and getattr(data, "types", ()):
+            kept = tuple(t for t in data.types if t in ("VPP", "MP", "EC", "LIST"))
+            if kept != tuple(data.types):
+                strip["types"] = kept
+        return replace(data, **strip) if strip else data
+
+    def _load(self, path: Path, *, fallback: bool = False) -> None:
         parsed = _parse_cached(path)
+        self._loading_fallback = fallback
         nested_later: list = []
         groups = _sense_groups(parsed)
         self._index_maneuvers(parsed.get("martial_arts") or [])
@@ -527,9 +561,10 @@ def _load(self, path: Path) -> None:
                         # section's own definition is still the right one for
                         # a caller that knows which kind of object it holds.
                         self._by_section.setdefault(
-                            (section, xmlid), _template_data(entry, is_power=is_power))
+                            (section, xmlid),
+                            self._strip_5e_rules(_template_data(entry, is_power=is_power)))
                         continue
-                    data = _template_data(entry, is_power=is_power)
+                    data = self._strip_5e_rules(_template_data(entry, is_power=is_power))
                     synthetic = _sense_group_options(xmlid, entry, groups)
                     if synthetic:
                         data = replace(data, options=synthetic)