refactor(campaign): rename the context manager, correct the reader count

`campaign_rules` -> `use_campaign_rules` (controller's ruling): it collided
with `EngineContext.campaign_rules()`, the getter, and
tests/test_campaign_active.py imports both into one module. Six call sites,
no behavioural change.

I4 -- `active_template` has EIGHT readers, not nine. Counted and named in
context.py so the next reader does not have to re-count: continuous,
nonpersistent, norangemodifier, persistent, disadvantage, combat_sense,
simulate_death, universal_translator. base.py:1814 mentions the slot in prose
and does not read it. Corrected in both context.py and test_campaign_active.py.

M1 -- dropped the redundant local `import os` / `import pytest` from the
`provider` fixture; both are already module-level.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Xof4ZUS5n6A5ibX3PXNYbs

Author: pdbethke

kirby_cost/campaign/__init__.py

@@ -1,5 +1,5 @@
 """A campaign's own rules: what this GM changed about the HERO template."""
-from kirby_cost.campaign.active import campaign_rules
+from kirby_cost.campaign.active import use_campaign_rules
 from kirby_cost.campaign.rules import CampaignRules, OVERRIDABLE_FIELDS
 
-__all__ = ["CampaignRules", "OVERRIDABLE_FIELDS", "campaign_rules"]
+__all__ = ["CampaignRules", "OVERRIDABLE_FIELDS", "use_campaign_rules"]

kirby_cost/campaign/active.py

@@ -20,8 +20,14 @@
 
 
 @contextmanager
-def campaign_rules(rules: Optional["CampaignRules"]):
-    """Run a block with *rules* active, restoring the previous value after."""
+def use_campaign_rules(rules: Optional["CampaignRules"]):
+    """Run a block with *rules* active, restoring the previous value after.
+
+    Named `use_` rather than plainly `campaign_rules` because the latter
+    collides with `EngineContext.campaign_rules()`, the GETTER -- and a module
+    that needs both (tests/test_campaign_active.py does) ends up importing two
+    different things under one name.
+    """
     previous = EngineContext.campaign_rules()
     EngineContext.set_campaign_rules(rules)
     try:

kirby_cost/core/context.py

@@ -67,17 +67,20 @@ def set_active_template(cls, template: Optional['Template']) -> None:
     def campaign_rules(cls) -> Optional['CampaignRules']:
         """The active campaign's rule overrides, or None.
 
-        DELIBERATELY separate from `active_template`. That slot has nine
+        DELIBERATELY separate from `active_template`. That slot has EIGHT
         readers whose branches were never finished -- they only ever ran their
-        None side -- so populating it would switch nine stubs on at once. See
-        the campaign-rule-overrides spec, section 7.
+        None side -- so populating it would switch eight stubs on at once
+        (counted 2026-08-25: continuous, nonpersistent, norangemodifier,
+        persistent, disadvantage, combat_sense, simulate_death,
+        universal_translator; base.py:1814 mentions the slot in prose and does
+        not read it). See the campaign-rule-overrides spec, section 7.
         """
         return cls.get_instance()._campaign_rules
 
     @classmethod
     def set_campaign_rules(cls, rules: Optional['CampaignRules']) -> None:
         """Set the active campaign's rule overrides. Prefer the
-        `kirby_cost.campaign.campaign_rules` context manager, which restores
+        `kirby_cost.campaign.use_campaign_rules` context manager, which restores
         the previous value."""
         cls.get_instance()._campaign_rules = rules
 

tests/conftest.py

@@ -317,8 +317,6 @@ def make_adder(
 def provider():
     """The configured HDT provider, or skip. Rules validate against a real
     template, so authoring them needs one resolvable."""
-    import os
-    import pytest
     from kirby_cost.template.hdt_provider import HDTTemplateProvider
     if not os.environ.get("KIRBY_COST_HDT"):
         pytest.skip("KIRBY_COST_HDT is not set")

tests/test_campaign_active.py

@@ -8,7 +8,7 @@
 
 import pytest
 
-from kirby_cost.campaign import CampaignRules, campaign_rules
+from kirby_cost.campaign import CampaignRules, use_campaign_rules
 from kirby_cost.core.context import EngineContext
 
 
@@ -19,32 +19,32 @@ def test_the_slot_starts_empty():
 def test_the_block_sets_and_restores(provider):
     rules = CampaignRules(provider=provider)
     assert EngineContext.campaign_rules() is None
-    with campaign_rules(rules):
+    with use_campaign_rules(rules):
         assert EngineContext.campaign_rules() is rules
     assert EngineContext.campaign_rules() is None
 
 
 def test_the_block_restores_even_when_the_body_raises(provider):
     rules = CampaignRules(provider=provider)
     with pytest.raises(RuntimeError):
-        with campaign_rules(rules):
+        with use_campaign_rules(rules):
             raise RuntimeError("boom")
     assert EngineContext.campaign_rules() is None
 
 
 def test_blocks_nest_and_restore_the_outer_value(provider):
     outer, inner = CampaignRules(provider=provider), CampaignRules(provider=provider)
-    with campaign_rules(outer):
-        with campaign_rules(inner):
+    with use_campaign_rules(outer):
+        with use_campaign_rules(inner):
             assert EngineContext.campaign_rules() is inner
         assert EngineContext.campaign_rules() is outer
     assert EngineContext.campaign_rules() is None
 
 
 def test_the_active_template_slot_is_left_alone(provider):
-    """active_template has nine readers whose branches are unfinished stubs
+    """active_template has EIGHT readers whose branches are unfinished stubs
     (`if template: # Would check if template is 6E; return True`). Setting it
-    would flip all nine on at once. This feature must not touch it."""
+    would flip all eight on at once. This feature must not touch it."""
     rules = CampaignRules(provider=provider)
-    with campaign_rules(rules):
+    with use_campaign_rules(rules):
         assert EngineContext.active_template() is None