[#739] Tile-trait beliefs out of MindGraph

Grazable and Drinkable are objective world facts derivable from terrain
type, not subjective beliefs. The audit on issue #739 showed perception
churned 717K HasTrait mutations on a 12-game-hour run, dominated by the
"agent walks in → asserts (Tile, HasTrait, Grazable) → walks out →
removes it" cycle, with N agents perceiving the same tile producing N
duplicate triples.

Replace the per-agent belief path with a direct WorldMap spatial query:

- Add TileType::has_trait(concept) and WorldMap::tiles_with_trait(...)
  that map terrain types to concepts (Grass→Grazable, water→Drinkable).
- target_enumeration::enumerate_tiles_with_trait now scans the world
  map within a planning radius of the agent — no MindGraph round-trip.
- Delete perceive_grass_tiles and perceive_water_tiles entirely. No
  legacy shim per the no-backwards-compat rule.

Subjective tile beliefs that are *not* derivable from terrain stay in
MindGraph: Unreachable (per-agent learned pathing failure with TTL),
Territory (per-agent claim, set once at spawn).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: milkyskies

src/agent/brains/rational.rs

@@ -265,7 +265,7 @@ pub fn update_rational_planning(
     >,
     tick: Res<crate::core::tick::TickCount>,
     ns_config: Res<crate::agent::nervous_system::config::NervousSystemConfig>,
-    _world_map: Res<WorldMap>,
+    world_map: Res<WorldMap>,
     action_registry: Res<crate::agent::actions::ActionRegistry>,
     mut game_log: ResMut<crate::core::GameLog>,
     affordances: Query<(
@@ -610,6 +610,8 @@ pub fn update_rational_planning(
             let action_candidates = collect_planning_actions(
                 &action_registry,
                 mind,
+                transform.translation.truncate(),
+                &world_map,
                 &affordances,
                 PlanningMode::Generate,
                 &capacities,
@@ -940,6 +942,8 @@ impl TargetInclusionReason {
 fn collect_planning_actions(
     action_registry: &crate::agent::actions::ActionRegistry,
     mind: &MindGraph,
+    agent_pos: Vec2,
+    world_map: &WorldMap,
     affordances: &Query<(
         &GlobalTransform,
         Option<&crate::agent::affordance::Affordance>,
@@ -964,7 +968,14 @@ fn collect_planning_actions(
         }
 
         let source = action.target_source();
-        for candidate in enumerate_targets(&source, action.action_type(), mind, affordances) {
+        for candidate in enumerate_targets(
+            &source,
+            action.action_type(),
+            mind,
+            agent_pos,
+            world_map,
+            affordances,
+        ) {
             let reason = match mode {
                 PlanningMode::Generate => {
                     if action.is_plan_valid(&candidate, mind) {

src/agent/brains/target_enumeration.rs

@@ -1,6 +1,7 @@
 //! Generic target enumeration: turn a `TargetSource` into concrete `TargetCandidate`s.
 //!
-//! Reads: MindGraph (Contains/HasTrait beliefs), Affordance components on world entities
+//! Reads: MindGraph (Contains/IsA beliefs), WorldMap (terrain-trait spatial queries),
+//!        Affordance components on world entities
 //! Writes: Vec<TargetCandidate> for the rational brain
 //! Upstream: rational brain (asks "what targets does action X have?")
 //! Downstream: rational brain (turns candidates into ActionTemplates)
@@ -17,7 +18,14 @@ use crate::agent::Dead;
 use crate::agent::actions::{ActionType, TargetCandidate, TargetSource};
 use crate::agent::affordance::Affordance;
 use crate::agent::mind::knowledge::{Concept, MindGraph, Node, Predicate, Value};
-use crate::world::map::TILE_SIZE;
+use crate::world::map::WorldMap;
+
+/// Spatial scope for `TargetSource::TileWithTrait`: the planner walks all
+/// tiles within this radius of the agent and keeps the ones whose terrain
+/// type matches the requested trait. Sized to comfortably cover an agent's
+/// vision range plus a planning buffer so a thirsty deer doesn't keep
+/// missing the river one tile past sight.
+const TILE_TRAIT_SEARCH_RADIUS: f32 = 256.0;
 
 /// Resolve a `TargetSource` into the concrete list of candidates for a given
 /// action and agent mind.
@@ -28,8 +36,8 @@ use crate::world::map::TILE_SIZE;
 ///   declares `action_type`
 /// - `TargetSource::EntityWithTrait(c)` → every perceived entity whose
 ///   inherited traits include `c` (e.g. Attack/Bite finding `HasTrait Prey`)
-/// - `TargetSource::TileWithTrait(c)` → every known tile matching
-///   `Tile(?) HasTrait c` in the MindGraph
+/// - `TargetSource::TileWithTrait(c)` → every nearby tile whose terrain type
+///   satisfies `c` per [`crate::world::map::TileType::has_trait`]
 ///
 /// The `affordances` query is a bare `&Query<...>` so Bevy's elided
 /// WorldQuery lifetimes flow through to callers without a type alias
@@ -38,6 +46,8 @@ pub fn enumerate_targets(
     source: &TargetSource,
     action_type: ActionType,
     mind: &MindGraph,
+    agent_pos: Vec2,
+    world_map: &WorldMap,
     affordances: &Query<(&GlobalTransform, Option<&Affordance>, Option<&Dead>)>,
 ) -> Vec<TargetCandidate> {
     match source {
@@ -52,7 +62,9 @@ pub fn enumerate_targets(
         TargetSource::DeadEntityWithTrait(concept) => {
             enumerate_entities_with_trait(*concept, mind, affordances, AliveOnly::No)
         }
-        TargetSource::TileWithTrait(concept) => enumerate_tiles_with_trait(*concept, mind),
+        TargetSource::TileWithTrait(concept) => {
+            enumerate_tiles_with_trait(*concept, agent_pos, world_map)
+        }
         TargetSource::EntityIsAConcept(concept) => {
             enumerate_entities_isa_concept(*concept, mind, affordances)
         }
@@ -222,35 +234,21 @@ fn candidate_is_lame(candidate: &TargetCandidate, mind: &MindGraph) -> bool {
     mind.has_trait(&Node::Entity(*entity), Concept::Lame)
 }
 
-/// Iterate tiles matching `Tile(?) HasTrait <concept>` in the MindGraph and
-/// emit one candidate per known tile. The world position is the tile centre
-/// so the planner's distance heuristic and the implicit Walk generator both
-/// have something to chew on.
+/// Iterate tiles within [`TILE_TRAIT_SEARCH_RADIUS`] of `agent_pos` whose
+/// terrain type satisfies `concept` and emit one candidate per match.
 ///
-/// Drink uses this with `Concept::Drinkable`. Future tile-trait actions
-/// (Fish, Forage, Bathe, Sleep-in-shelter) plug in here without touching
-/// the brain.
-fn enumerate_tiles_with_trait(concept: Concept, mind: &MindGraph) -> Vec<TargetCandidate> {
-    let mut candidates = Vec::new();
-
-    for triple in mind.query(
-        None,
-        Some(Predicate::HasTrait),
-        Some(&Value::Concept(concept)),
-    ) {
-        let Node::Tile((tx, ty)) = triple.subject else {
-            continue;
-        };
-
-        let pos = Vec2::new(
-            tx as f32 * TILE_SIZE + TILE_SIZE / 2.0,
-            ty as f32 * TILE_SIZE + TILE_SIZE / 2.0,
-        );
-        candidates.push(TargetCandidate::Tile {
-            tile: (tx, ty),
-            pos,
-        });
-    }
-
-    candidates
+/// Drink/Fish use this with `Concept::Drinkable`, Graze with `Grazable`.
+/// The query reads the world map directly: terrain traits are objective
+/// facts (grass is grazable, water is drinkable), so we don't run them
+/// through the agent's subjective belief store.
+fn enumerate_tiles_with_trait(
+    concept: Concept,
+    agent_pos: Vec2,
+    world_map: &WorldMap,
+) -> Vec<TargetCandidate> {
+    world_map
+        .tiles_with_trait(agent_pos, TILE_TRAIT_SEARCH_RADIUS, concept)
+        .into_iter()
+        .map(|(tile, pos)| TargetCandidate::Tile { tile, pos })
+        .collect()
 }

src/agent/mind/perception.rs

@@ -456,130 +456,6 @@ fn perceive_inventory(
     }
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// WATER PERCEPTION — Detect water tiles in vision range
-// ═══════════════════════════════════════════════════════════════════════════
-
-/// Water tiles are static terrain — scan infrequently (every 30 ticks per agent).
-pub fn perceive_water_tiles(
-    mut agents: Query<(Entity, &Transform, &Vision, &mut MindGraph), With<Agent>>,
-    world_map: Res<crate::world::map::WorldMap>,
-    light_level: Res<LightLevel>,
-    tick: Res<TickCount>,
-) {
-    let current_time = tick.current;
-
-    for (entity, transform, vision, mut mind) in agents.iter_mut() {
-        if !tick.should_run(entity, 30) {
-            continue;
-        }
-
-        let pos = transform.translation.truncate();
-        let view_range = vision.range * light_level.0;
-        let tile_range = (view_range / TILE_SIZE).ceil() as i32;
-
-        let center_tx = (pos.x / TILE_SIZE).floor() as i32;
-        let center_ty = (pos.y / TILE_SIZE).floor() as i32;
-
-        for dx in -tile_range..=tile_range {
-            for dy in -tile_range..=tile_range {
-                let tx = center_tx + dx;
-                let ty = center_ty + dy;
-                if tx < 0 || ty < 0 {
-                    continue;
-                }
-
-                let tile_world = world_map.tile_to_world(tx, ty);
-                if pos.distance(tile_world) > view_range {
-                    continue;
-                }
-
-                if let Some(tile_type) = world_map.get_tile(tx as u32, ty as u32)
-                    && tile_type.is_water()
-                {
-                    mind.assert(Triple::with_meta(
-                        Node::Tile((tx, ty)),
-                        Predicate::HasTrait,
-                        Value::Concept(Concept::Drinkable),
-                        Metadata::semantic(current_time),
-                    ));
-                }
-            }
-        }
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// GRASS PERCEPTION — Detect grazable tiles for herbivores
-// ═══════════════════════════════════════════════════════════════════════════
-
-/// Grass tiles are static terrain — scan infrequently (every 30 ticks per agent).
-///
-/// Gated to herbivores so the planner only considers grazing for species that
-/// would actually do it. Carnivores and omnivores never get `HasTrait Grazable`
-/// asserted, keeping their MindGraph free of useless noise and their rational
-/// brain from enumerating grass tiles as food candidates.
-pub fn perceive_grass_tiles(
-    mut agents: Query<
-        (
-            Entity,
-            &Transform,
-            &Vision,
-            &crate::agent::body::species::SpeciesProfile,
-            &mut MindGraph,
-        ),
-        With<Agent>,
-    >,
-    world_map: Res<crate::world::map::WorldMap>,
-    light_level: Res<LightLevel>,
-    tick: Res<TickCount>,
-) {
-    use crate::agent::body::species::Diet;
-    use crate::world::map::TileType;
-
-    let current_time = tick.current;
-
-    for (entity, transform, vision, species, mut mind) in agents.iter_mut() {
-        if !matches!(species.diet, Diet::Herbivore) {
-            continue;
-        }
-        if !tick.should_run(entity, 30) {
-            continue;
-        }
-
-        let pos = transform.translation.truncate();
-        let view_range = vision.range * light_level.0;
-        let tile_range = (view_range / TILE_SIZE).ceil() as i32;
-
-        let center_tx = (pos.x / TILE_SIZE).floor() as i32;
-        let center_ty = (pos.y / TILE_SIZE).floor() as i32;
-
-        for dx in -tile_range..=tile_range {
-            for dy in -tile_range..=tile_range {
-                let tx = center_tx + dx;
-                let ty = center_ty + dy;
-                if tx < 0 || ty < 0 {
-                    continue;
-                }
-
-                let tile_world = world_map.tile_to_world(tx, ty);
-                if pos.distance(tile_world) > view_range {
-                    continue;
-                }
-
-                if let Some(TileType::Grass) = world_map.get_tile(tx as u32, ty as u32) {
-                    mind.assert(Triple::with_meta(
-                        Node::Tile((tx, ty)),
-                        Predicate::HasTrait,
-                        Value::Concept(Concept::Grazable),
-                        Metadata::semantic(current_time),
-                    ));
-                }
-            }
-        }
-    }
-}
-
 // ═══════════════════════════════════════════════════════════════════════════
 // DANGER PERCEPTION — Contextual threat assessment produces Fear
 // ═══════════════════════════════════════════════════════════════════════════

src/agent/mod.rs

@@ -185,8 +185,6 @@ impl Plugin for AgentPlugin {
                 FixedUpdate,
                 (
                     mind::perception::update_body_perception,
-                    mind::perception::perceive_water_tiles,
-                    mind::perception::perceive_grass_tiles,
                     mind::perception::perceive_temperature,
                     mind::perception::perceive_hearing,
                     mind::perception::emit_alarm_calls,