fix: the Brief lists a wagon once, not four times

A regression I introduced this morning, found by reading the page a model
actually gets rather than by running the suite.

`Furnishing` projects its footprint into four wall segments so movement,
line of sight, cover moves and Area Of Effect keep working --- they all
read `scene.walls`. `Brief.features` reads `scene.walls` too and was
never told the difference, so the page said:

    Photographer's wagon: 2.7m away, would give you cover 2/4
    Photographer's wagon: 1.6m away, would not shield you from where they are
    Photographer's wagon: 3.1m away, would give you cover 2/4
    Photographer's wagon: 4.1m away, would not shield you from where they are

Four entries for one wagon, at four distances, contradicting each other
about whether it is worth hiding behind --- because each is a different
EDGE and the far ones genuinely shield nobody. Sixteen of the twenty-two
lines in that section were the same three objects repeated.

One object, one line: nearest edge for the distance, best cover any edge
offers for the worth. Standing behind a wagon means standing behind the
side facing the shooting.

ONLY THE DERIVED EDGES FOLD, and getting that wrong cost a building. A
first cut folded on `part_of` alone and silently deleted "C.S. Fly's
photograph gallery" from the page, because it shares an owner with the
boarding house wall. Those two were AUTHORED separately --- somebody
named them separately because a fighter relates to them separately. A
furnishing's edges were never authored at all. The fold now matches on
ids that name a FURNISHING, which is the same distinction Krackle already
draws in `isFurnishingEdge`.

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

Author: pdbethke

kirby_combat/brief.py

@@ -221,6 +221,30 @@ def sightings(self) -> list[str]:
             p for p in (self.position_of(e.id) for e in self._enemies)
             if p is not None
         ]
+        # ONE THING, ONE LINE. A `Furnishing` projects its footprint into
+        # four wall segments so movement and line of sight keep working,
+        # and this reads `scene.walls` -- so a wagon arrived as four
+        # planks at four distances, two of them saying "would not shield
+        # you" because they are the far edges of the same object. A reader
+        # cannot act on that, and the page is what a chooser acts on.
+        #
+        # Folded by `part_of`, which already means "a face of that
+        # structure": nearest edge for the distance, best cover any edge
+        # offers for the worth. Standing behind a wagon means standing
+        # behind the side that faces the shooting.
+        # ONLY THE DERIVED EDGES FOLD. A `Furnishing`'s four edges were
+        # never authored --- they are one object's outline --- so they are
+        # one line. A BUILDING's faces were: somebody wrote "C.S. Fly's
+        # boarding house (west wall)" and "C.S. Fly's photograph gallery"
+        # as separate walls because a fighter relates to them separately,
+        # and folding them by `part_of` silently deleted the gallery from
+        # the page. The same distinction Krackle draws in
+        # `isFurnishingEdge`: an id that names a FURNISHING, not any
+        # `part_of` at all.
+        furnishing_ids = {
+            f.id for f in (getattr(self.scene, "furnishings", None) or [])
+        }
+        best: dict[str, tuple] = {}
         out = []
         for wall in self.features:
             name = getattr(wall, "name", None) or getattr(wall, "id", "?")
@@ -250,8 +274,18 @@ def sightings(self) -> list[str]:
                 hardness = f"; BODY {body} to break through"
             elif defense is not None:
                 hardness = f"; DEF {defense}"
-            out.append(f"{name}: {distance:.1f}m away, {worth}{hardness}")
-        return out
+            line = f"{name}: {distance:.1f}m away, {worth}{hardness}"
+            owner = getattr(wall, "part_of", None)
+            if owner not in furnishing_ids:
+                out.append(line)
+                continue
+            # Keep the best of the faces: more cover wins, and among equals
+            # the nearer one -- which is the face a mover would actually
+            # put between himself and the threat.
+            prior = best.get(owner)
+            if prior is None or (level, -distance) > (prior[0], -prior[1]):
+                best[owner] = (level, distance, line)
+        return out + [entry[2] for entry in best.values()]
 
     @property
     def bearings(self) -> list[EnemyBearing]:

tests/test_brief_lists_a_thing_once.py

@@ -0,0 +1,89 @@
+"""A wagon is one wagon on the page, not four planks.
+
+`Furnishing` projects its footprint into wall segments so that movement,
+line of sight, cover moves and Area Of Effect keep working -- they all
+read `scene.walls`. `Brief.features` reads `scene.walls` too, and it was
+never told the difference, so a Brief listed:
+
+    Photographer's wagon: 2.7m away, would give you cover 2/4
+    Photographer's wagon: 1.6m away, would not shield you from where they are
+    Photographer's wagon: 3.1m away, would give you cover 2/4
+    Photographer's wagon: 4.1m away, would not shield you from where they are
+
+Four entries for one wagon, at four distances, contradicting each other
+about whether it is worth hiding behind -- because each is a different
+EDGE of the same footprint and an edge on the far side genuinely does not
+shield you.
+
+A reader cannot act on that, and the page is what a chooser acts on. The
+whole object is one feature: the nearest edge is how far away it is, and
+the best cover any edge offers is what it is worth.
+
+Introduced by the footprint change on 2026-09-10 and caught by reading
+the page a model actually gets.
+"""
+from __future__ import annotations
+
+from kirby_combat.brief import Brief
+
+
+def _page():
+    from examples.the_shootout_we_can_publish import the_fight
+
+    pages: list[str] = []
+
+    class Peek:
+        def choose(self, situation):
+            if not pages:
+                pages.append(situation.brief().render())
+            return situation.menu[0].action_id
+
+    the_fight(59, chooser=Peek())
+    return pages[0]
+
+
+def _feature_lines(page: str) -> list[str]:
+    out, seen = [], False
+    for line in page.splitlines():
+        if line.startswith("What is around you:"):
+            seen = True
+            continue
+        if seen:
+            if not line.startswith("  "):
+                break
+            out.append(line.strip())
+    return out
+
+
+def test_each_thing_appears_once():
+    lines = _feature_lines(_page())
+    names = [line.split(":")[0] for line in lines]
+    duplicated = {n for n in names if names.count(n) > 1}
+    assert not duplicated, f"listed more than once: {sorted(duplicated)}"
+
+
+def test_the_wagon_is_still_there():
+    """Deduplicating must not delete the thing."""
+    names = [line.split(":")[0] for line in _feature_lines(_page())]
+    assert any("wagon" in n.lower() for n in names), names
+
+
+def test_a_thing_is_worth_the_best_cover_any_of_it_offers():
+    """One edge of a wagon faces away and shields nobody; standing behind
+    the wagon means standing behind the edge that does. Reporting the
+    useless edge would tell a reader the wagon is worthless."""
+    lines = _feature_lines(_page())
+    wagon = next(line for line in lines if "wagon" in line.lower())
+    assert "would give you cover" in wagon, wagon
+
+
+def test_a_buildings_named_faces_are_NOT_folded_together():
+    """Only the DERIVED edges fold. A furnishing's four edges were never
+    authored -- they are one object's outline. A building's faces were:
+    somebody wrote "C.S. Fly's boarding house (west wall)" and "C.S. Fly's
+    photograph gallery" as separate walls because a fighter relates to
+    them separately, and folding by `part_of` deleted the gallery from the
+    page entirely."""
+    names = [line.split(":")[0] for line in _feature_lines(_page())]
+    assert any("gallery" in n.lower() for n in names), names
+    assert any("boarding house" in n.lower() for n in names), names