From 1b0513f9b3d5458d723ea83d29eae35575c2b5ea Mon Sep 17 00:00:00 2001
From: Cameron <cameron@pfiffer.org>
Date: Thu, 9 Jul 2026 21:57:18 -0700
Subject: [PATCH] Render Heard as a bone noise field after the Ears tap.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The first audio tap left coverage as a flat dim floor with invisible
mic-only people. Both frontends now paint standing room rings, tile
stipple, event rings, and presence markers in bone — never amber, never
room shape.

Defense: wiki/mechanics/cursor.md (Heard noise field; AC4) and
wiki/interface/bevy-digital-real-canvas.md require bone presence pulses
and presence markers under hearing; this implements that contract.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 src/bin/bevy.rs                            | 315 +++++++++++++++++++--
 src/bin/terminal/agent.rs                  |  31 +-
 src/bin/terminal/ui.rs                     |  58 ++--
 wiki/interface/bevy-digital-real-canvas.md |   5 +-
 wiki/interface/bevy-visual-floor.md        |   5 +-
 wiki/interface/flat-materials.md           |  14 +-
 wiki/interface/views.md                    |   4 +-
 wiki/log/2026-07-09-heard-noise-field.md   |  37 +++
 wiki/log/DEVLOG.md                         |  13 +-
 wiki/log/decisions/2026-07-09.md           |   8 +
 wiki/mechanics/cursor.md                   |  18 +-
 11 files changed, 439 insertions(+), 69 deletions(-)
 create mode 100644 wiki/log/2026-07-09-heard-noise-field.md

diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs
index 355efc0..30f7620 100644
--- a/src/bin/bevy.rs
+++ b/src/bin/bevy.rs
@@ -23,7 +23,7 @@ use bevy::window::{PrimaryWindow, WindowResolution};
 use misaligned::actions::{Anchor, MenuRow, menu_rows};
 use misaligned::detection::{Band, SignatureKind};
 use misaligned::reach::Party;
-use misaligned::sim::{FactSource, Fog, LogEvent, Sim, TraceDebtStatus};
+use misaligned::sim::{FactSource, Fog, HeardKind, LogEvent, Sim, TraceDebtStatus};
 use misaligned::tiles::TileType;
 use misaligned::work_grid::{MachineMode, TokenFamily};
 
@@ -316,7 +316,7 @@ impl Default for RenderMode {
 }
 
 /// Dev screenshot harness (env `MISALIGNED_SHOT=flat|wide|close|dark|
-/// zoomin|zoomout|intel|tokens`, path via `MISALIGNED_SHOT_PATH`): stages a scenario,
+/// zoomin|zoomout|intel|tokens|ears`, path via `MISALIGNED_SHOT_PATH`): stages a scenario,
 /// waits for
 /// assets, runs the fog audit, saves one screenshot, exits. Not a player
 /// surface; exists so render passes can be reviewed from deterministic PNGs.
@@ -824,12 +824,14 @@ fn main() {
                 blink_machines_3d,
                 render_real_links,
                 render_work_routes,
+                render_noise_field_3d,
                 render_cursor,
                 render_tokens,
             ),
             (
                 render_people,
                 render_people_3d,
+                render_noise_field_flat,
                 scroll_sidebar,
                 render_ui,
                 menu_pointer,
@@ -879,6 +881,39 @@ fn dev_shot_scenario(game: &mut Game, mode: &mut RenderMode, kind: &str) {
         game.drain();
         return;
     }
+    // Ears beat: audio tap only — no camera splice — so the Heard
+    // noise field is the only live epistemic upgrade in frame.
+    if kind == "ears" {
+        game.sim.operations_bandwidth = 500.0;
+        game.sim.scan_network();
+        if let Some(env) = game
+            .sim
+            .reach
+            .device_named("environmental monitor")
+            .map(|d| d.id)
+        {
+            game.sim.tap_device(env);
+        }
+        for _ in 0..4000 {
+            let heard_person = game
+                .sim
+                .people
+                .people
+                .iter()
+                .any(|p| game.sim.can_hear_person(p.id) && !game.sim.can_see_person(p.id));
+            if heard_person || !game.sim.heard_events.is_empty() {
+                break;
+            }
+            game.sim.advance();
+        }
+        game.drain();
+        mode.material = true;
+        mode.zoom = 0.55;
+        if let Some(env) = game.sim.reach.device_named("environmental monitor") {
+            game.set_cursor(env.x, env.y);
+        }
+        return;
+    }
     let sim = &mut game.sim;
     sim.operations_bandwidth = 500.0;
     sim.scan_network();
@@ -1846,9 +1881,10 @@ fn material_3d(tile: TileType, fog: Fog, part: TilePart, live: bool) -> Standard
                 m.base_color = family_color(tile);
             }
             Fog::Heard => {
-                // Dim warm presence: sound earned a floor, nothing more.
+                // Dim warm floor under the bone noise-field pulses
+                // (render_noise_field_3d) — presence, never shape.
                 m.unlit = true;
-                m.base_color = scaled(FLOOR_SERVICE, 0.17);
+                m.base_color = scaled(FLOOR_SERVICE, 0.12);
             }
             Fog::Remembered => {
                 m.unlit = true;
@@ -2573,6 +2609,216 @@ fn visible_wire_segment(
         Some(((from_x, from_y), (ex, ey)))
     }
 }
+/// How long a heard capture keeps ringing on the map (ticks).
+const HEARD_EVENT_RING_TICKS: u64 = 240;
+
+/// Bone color for the hearing noise field — never amber (machine footprint).
+fn heard_noise_color(alpha: f32) -> Color {
+    let s = BONE.to_srgba();
+    Color::srgba(s.red * 0.92, s.green * 0.88, s.blue * 0.72, alpha)
+}
+
+/// Rooms currently under Heard fog (room-grade coverage), for room-scale rings.
+fn heard_rooms(sim: &Sim) -> Vec<(i32, i32, f32)> {
+    let mut out = Vec::new();
+    for room in &sim.map.rooms {
+        let (cx, cy) = room.center();
+        if !matches!(sim.fog_at(cx, cy), Fog::Heard) {
+            continue;
+        }
+        // Approximate room radius from extents so the ring fills the floor.
+        let rx = room.w.max(1) as f32 * 0.45;
+        let ry = room.h.max(1) as f32 * 0.45;
+        out.push((cx, cy, rx.max(ry).max(1.2)));
+    }
+    out
+}
+
+/// Material-mode Heard noise field (cursor.md / bevy-digital-real-canvas.md):
+/// room-scale bone rings, tile stipple, expanding rings from recent
+/// `HeardEvent`s, and a soft disc for mic-only people. No room shape.
+fn render_noise_field_3d(
+    game: Res<Game>,
+    mode: Res<RenderMode>,
+    time: Res<Time>,
+    mut gizmos: Gizmos<RealGizmos>,
+) {
+    if !mode.material || game.screen != Screen::Playing {
+        return;
+    }
+    let t = time.elapsed_secs();
+    let floor_iso =
+        |p: Vec3| Isometry3d::new(p, Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2));
+
+    // Room-scale standing field: concentric breathing rings per heard room.
+    for (i, (cx, cy, radius)) in heard_rooms(&game.sim).into_iter().enumerate() {
+        let breath = 0.5 + 0.5 * (t * 1.1 + i as f32 * 0.7).sin();
+        let p = grid_to_world_3d(cx, cy, 0.04);
+        let outer = radius * (0.72 + 0.08 * breath);
+        gizmos.circle(floor_iso(p), outer, heard_noise_color(0.22 + 0.10 * breath));
+        gizmos.circle(
+            floor_iso(p),
+            outer * 0.55,
+            heard_noise_color(0.14 + 0.08 * breath),
+        );
+    }
+
+    // Tile stipple: sparse bone dots so the field reads as coverage, not paint.
+    for y in 0..game.sim.map.height {
+        for x in 0..game.sim.map.width {
+            if !matches!(game.sim.fog_at(x, y), Fog::Heard) {
+                continue;
+            }
+            if blocky_tile(game.sim.map.get_tile(x, y)) {
+                continue;
+            }
+            // Checker so the field is stippled, not a solid wash.
+            if (x + y) % 2 != 0 {
+                continue;
+            }
+            let phase = (x as f32 * 0.37 + y as f32 * 0.61) + t * 1.6;
+            let breath = 0.5 + 0.5 * phase.sin();
+            let p = grid_to_world_3d(x, y, 0.035);
+            gizmos.circle(
+                floor_iso(p),
+                0.16 + 0.05 * breath,
+                heard_noise_color(0.10 + 0.12 * breath),
+            );
+        }
+    }
+
+    // Event rings: recent captures expand from the room they were heard in.
+    for ev in game.sim.heard_events.iter().rev().take(12) {
+        let age = game.sim.tick.saturating_sub(ev.tick);
+        if age > HEARD_EVENT_RING_TICKS {
+            continue;
+        }
+        let Some(room) = game.sim.map.room_named(&ev.room) else {
+            continue;
+        };
+        let (cx, cy) = room.center();
+        // Only ring where hearing still covers the room (no unearned flash).
+        if !matches!(game.sim.fog_at(cx, cy), Fog::Heard | Fog::Seen) {
+            continue;
+        }
+        let life = 1.0 - age as f32 / HEARD_EVENT_RING_TICKS as f32;
+        let (rx, ry) = match ev.kind {
+            HeardKind::Entry => (0.7 + (1.0 - life) * 2.2, 0.28 * life),
+            HeardKind::Conversation => (1.0 + (1.0 - life) * 2.8, 0.36 * life),
+        };
+        let p = grid_to_world_3d(cx, cy, 0.055);
+        gizmos.circle(floor_iso(p), rx, heard_noise_color(ry));
+        if matches!(ev.kind, HeardKind::Conversation) {
+            gizmos.circle(floor_iso(p), rx * 0.55, heard_noise_color(ry * 0.6));
+        }
+    }
+
+    // Mic-only people: a soft presence disc at room center — never a body.
+    for p in &game.sim.people.people {
+        if !game.sim.can_hear_person(p.id) || game.sim.can_see_person(p.id) {
+            continue;
+        }
+        let Some((x, y)) = game.sim.person_pos(p.id) else {
+            continue;
+        };
+        if !matches!(game.sim.fog_at(x, y), Fog::Heard) {
+            continue;
+        }
+        let breath = 0.5 + 0.5 * (t * 2.4 + p.id as f32).sin();
+        let center = grid_to_world_3d(x, y, 0.07);
+        gizmos.circle(
+            floor_iso(center),
+            0.55 + 0.12 * breath,
+            heard_noise_color(0.34 + 0.14 * breath),
+        );
+        gizmos.circle(floor_iso(center), 0.18, heard_noise_color(0.55));
+    }
+}
+
+/// Flat-sensorium Heard noise field: same facts as the material pass,
+/// drawn as 2D circles so F3 never drops the hearing language.
+fn render_noise_field_flat(
+    game: Res<Game>,
+    mode: Res<RenderMode>,
+    time: Res<Time>,
+    mut gizmos: Gizmos,
+) {
+    if mode.material || game.screen != Screen::Playing {
+        return;
+    }
+    let t = time.elapsed_secs();
+
+    for (i, (cx, cy, radius)) in heard_rooms(&game.sim).into_iter().enumerate() {
+        let breath = 0.5 + 0.5 * (t * 1.1 + i as f32 * 0.7).sin();
+        let p = grid_to_world(cx, cy, 0.0).truncate();
+        let outer = radius * (0.72 + 0.08 * breath) * TILE_SIZE;
+        gizmos.circle_2d(p, outer, heard_noise_color(0.28 + 0.10 * breath));
+        gizmos.circle_2d(p, outer * 0.55, heard_noise_color(0.16 + 0.08 * breath));
+    }
+
+    for y in 0..game.sim.map.height {
+        for x in 0..game.sim.map.width {
+            if !matches!(game.sim.fog_at(x, y), Fog::Heard) {
+                continue;
+            }
+            if blocky_tile(game.sim.map.get_tile(x, y)) {
+                continue;
+            }
+            if (x + y) % 2 != 0 {
+                continue;
+            }
+            let phase = (x as f32 * 0.37 + y as f32 * 0.61) + t * 1.6;
+            let breath = 0.5 + 0.5 * phase.sin();
+            let p = grid_to_world(x, y, 0.0).truncate();
+            gizmos.circle_2d(
+                p,
+                (0.14 + 0.05 * breath) * TILE_SIZE,
+                heard_noise_color(0.14 + 0.12 * breath),
+            );
+        }
+    }
+
+    for ev in game.sim.heard_events.iter().rev().take(12) {
+        let age = game.sim.tick.saturating_sub(ev.tick);
+        if age > HEARD_EVENT_RING_TICKS {
+            continue;
+        }
+        let Some(room) = game.sim.map.room_named(&ev.room) else {
+            continue;
+        };
+        let (cx, cy) = room.center();
+        if !matches!(game.sim.fog_at(cx, cy), Fog::Heard | Fog::Seen) {
+            continue;
+        }
+        let life = 1.0 - age as f32 / HEARD_EVENT_RING_TICKS as f32;
+        let (rx, ry) = match ev.kind {
+            HeardKind::Entry => ((0.55 + (1.0 - life) * 1.8) * TILE_SIZE, 0.30 * life),
+            HeardKind::Conversation => ((0.85 + (1.0 - life) * 2.4) * TILE_SIZE, 0.38 * life),
+        };
+        let p = grid_to_world(cx, cy, 0.0).truncate();
+        gizmos.circle_2d(p, rx, heard_noise_color(ry));
+    }
+
+    for p in &game.sim.people.people {
+        if !game.sim.can_hear_person(p.id) || game.sim.can_see_person(p.id) {
+            continue;
+        }
+        let Some((x, y)) = game.sim.person_pos(p.id) else {
+            continue;
+        };
+        if !matches!(game.sim.fog_at(x, y), Fog::Heard) {
+            continue;
+        }
+        let breath = 0.5 + 0.5 * (t * 2.4 + p.id as f32).sin();
+        let center = grid_to_world(x, y, 0.0).truncate();
+        gizmos.circle_2d(
+            center,
+            (0.48 + 0.10 * breath) * TILE_SIZE,
+            heard_noise_color(0.40 + 0.14 * breath),
+        );
+        gizmos.circle_2d(center, 0.16 * TILE_SIZE, heard_noise_color(0.55));
+    }
+}
 
 /// People in the material render: billboard visibility mirrors render_people
 /// (earned camera coverage only).
@@ -3082,9 +3328,8 @@ fn render_map(game: Res<Game>, mut q: Query<(&mut Sprite, &TilePos), With<MapTil
                     base
                 }
             }
-            // Dim warm presence — same palette treatment as the 3D heard
-            // floor, darkened for the schematic dialect.
-            Fog::Heard => scaled(FLOOR_SERVICE, 0.115),
+            // Dim warm floor under the bone noise-field pulses.
+            Fog::Heard => scaled(FLOOR_SERVICE, 0.08),
             Fog::Remembered => {
                 let tile = game
                     .sim
@@ -3110,7 +3355,7 @@ fn render_map(game: Res<Game>, mut q: Query<(&mut Sprite, &TilePos), With<MapTil
 fn sensor_grid_color(fog: Fog) -> Option<Color> {
     match fog {
         Fog::Seen => Some(Color::srgba(0.92, 0.66, 0.18, 0.22)),
-        Fog::Heard => Some(Color::srgba(0.58, 0.48, 0.22, 0.14)),
+        Fog::Heard => Some(Color::srgba(0.72, 0.68, 0.58, 0.12)),
         Fog::Remembered => Some(Color::srgba(0.44, 0.42, 0.36, 0.16)),
         Fog::Blueprint => Some(Color::srgba(0.28, 0.30, 0.30, 0.18)),
         Fog::Unknown => None,
@@ -3275,33 +3520,53 @@ fn render_tokens(
     }
 }
 
-/// People render only inside sensor coverage (wiki/mechanics/schedules.md):
-/// same rule the terminal map applies. Glyph tracks Sim::person_glyph so
-/// initials appear only after staged knowledge earns the name.
+/// People render only inside sensor coverage (wiki/mechanics/schedules.md /
+/// cursor.md): camera coverage shows the knowledge-gated glyph; mic-only
+/// coverage shows a bone presence marker (`~` / initial), never a body.
 fn render_people(
     game: Res<Game>,
-    mut q: Query<(&PersonMarker, &mut Transform, &mut Visibility, &mut Text2d)>,
+    mut q: Query<(
+        &PersonMarker,
+        &mut Transform,
+        &mut Visibility,
+        &mut Text2d,
+        &mut TextColor,
+    )>,
 ) {
     if !game.is_changed() {
         return;
     }
-    for (marker, mut tf, mut vis, mut text) in q.iter_mut() {
-        text.0 = game.sim.person_glyph(marker.id).to_string();
-        let pos = if game.sim.can_see_person(marker.id) {
-            game.sim
+    for (marker, mut tf, mut vis, mut text, mut color) in q.iter_mut() {
+        let seen = game.sim.can_see_person(marker.id)
+            && game
+                .sim
                 .person_pos(marker.id)
-                .filter(|&(x, y)| game.sim.is_seen(x, y))
-        } else {
-            None
-        };
-        match pos {
-            Some((x, y)) => {
+                .is_some_and(|(x, y)| game.sim.is_seen(x, y));
+        let heard = !seen
+            && game.sim.can_hear_person(marker.id)
+            && game
+                .sim
+                .person_pos(marker.id)
+                .is_some_and(|(x, y)| matches!(game.sim.fog_at(x, y), Fog::Heard));
+        match (seen, heard, game.sim.person_pos(marker.id)) {
+            (true, _, Some((x, y))) => {
+                text.0 = game.sim.person_glyph(marker.id).to_string();
+                color.0 = BONE;
                 tf.translation = grid_to_world(x, y, 3.0);
-                // Inherited so the marker hides with Flat2dRoot in material
-                // mode.
                 *vis = Visibility::Inherited;
             }
-            None => *vis = Visibility::Hidden,
+            (_, true, Some((x, y))) => {
+                // Presence, not a picture: soft marker, knowledge-gated glyph.
+                text.0 = if game.sim.person_glyph(marker.id) == '?' {
+                    "~".into()
+                } else {
+                    game.sim.person_glyph(marker.id).to_string()
+                };
+                color.0 = scaled(BONE, 0.55);
+                tf.translation = grid_to_world(x, y, 3.0);
+                *vis = Visibility::Inherited;
+            }
+            _ => *vis = Visibility::Hidden,
         }
     }
 }
diff --git a/src/bin/terminal/agent.rs b/src/bin/terminal/agent.rs
index 566219e..53435ed 100644
--- a/src/bin/terminal/agent.rs
+++ b/src/bin/terminal/agent.rs
@@ -1303,18 +1303,31 @@ fn render_map(sim: &Sim, cursor: (i32, i32)) -> Vec<String> {
     }
 
     for p in &sim.people.people {
-        if !sim.can_see_person(p.id) {
+        let seen = sim.can_see_person(p.id)
+            && sim.person_pos(p.id).is_some_and(|(x, y)| sim.is_seen(x, y));
+        let heard = !seen
+            && sim.can_hear_person(p.id)
+            && sim
+                .person_pos(p.id)
+                .is_some_and(|(x, y)| matches!(sim.fog_at(x, y), Fog::Heard));
+        let Some((x, y)) = sim.person_pos(p.id) else {
             continue;
-        }
-        if let Some((x, y)) = sim.person_pos(p.id)
-            && x >= origin_x
-            && x < origin_x + view_w_i
-            && y >= origin_y
-            && y < origin_y + view_h_i
-            && sim.is_seen(x, y)
+        };
+        if !(seen || heard)
+            || x < origin_x
+            || x >= origin_x + view_w_i
+            || y < origin_y
+            || y >= origin_y + view_h_i
         {
-            grid[(y - origin_y) as usize][(x - origin_x) as usize] = sim.person_glyph(p.id);
+            continue;
         }
+        grid[(y - origin_y) as usize][(x - origin_x) as usize] = if seen {
+            sim.person_glyph(p.id)
+        } else if sim.person_glyph(p.id) == '?' {
+            '~'
+        } else {
+            sim.person_glyph(p.id)
+        };
     }
 
     for m in &sim.compute.machines {
diff --git a/src/bin/terminal/ui.rs b/src/bin/terminal/ui.rs
index e94480c..9f786fc 100644
--- a/src/bin/terminal/ui.rs
+++ b/src/bin/terminal/ui.rs
@@ -519,30 +519,48 @@ impl UI {
             }
         }
 
-        // People, but only where a camera sees them (spec/schedules.md: they
-        // are what the fog is for). Glyph = first initial of their name; bone
-        // and bold so the living read brighter than the furniture.
+        // People, but only where a sensor earns them (schedules.md / cursor.md):
+        // camera coverage = knowledge-gated glyph; mic-only = presence marker.
         for p in &sim.people.people {
-            if !sim.can_see_person(p.id) {
+            let seen = sim.can_see_person(p.id)
+                && sim
+                    .person_pos(p.id)
+                    .is_some_and(|(hx, hy)| sim.is_seen(hx, hy));
+            let heard = !seen
+                && sim.can_hear_person(p.id)
+                && sim
+                    .person_pos(p.id)
+                    .is_some_and(|(hx, hy)| matches!(sim.fog_at(hx, hy), Fog::Heard));
+            let Some((hx, hy)) = sim.person_pos(p.id) else {
                 continue;
-            }
-            if let Some((hx, hy)) = sim.person_pos(p.id)
-                && hx >= origin_x
-                && hx < origin_x + view_w
-                && hy >= origin_y
-                && hy < origin_y + view_h
-                && sim.is_seen(hx, hy)
+            };
+            if !(seen || heard)
+                || hx < origin_x
+                || hx >= origin_x + view_w
+                || hy < origin_y
+                || hy >= origin_y + view_h
             {
-                let glyph = sim.person_glyph(p.id);
-                put_attr(
-                    stdout,
-                    (hx - origin_x) as u16,
-                    (hy - origin_y) as u16,
-                    &glyph.to_string(),
-                    pal::TEXT,
-                    Attribute::Bold,
-                )?;
+                continue;
             }
+            let (glyph, color) = if seen {
+                (sim.person_glyph(p.id), pal::TEXT)
+            } else if sim.person_glyph(p.id) == '?' {
+                ('~', pal::DIM)
+            } else {
+                (sim.person_glyph(p.id), pal::DIM)
+            };
+            put_attr(
+                stdout,
+                (hx - origin_x) as u16,
+                (hy - origin_y) as u16,
+                &glyph.to_string(),
+                color,
+                if seen {
+                    Attribute::Bold
+                } else {
+                    Attribute::Reset
+                },
+            )?;
         }
 
         // Visible work tokens: one sim truth from WorkGrid. They draw over
diff --git a/wiki/interface/bevy-digital-real-canvas.md b/wiki/interface/bevy-digital-real-canvas.md
index 83940d3..9550005 100644
--- a/wiki/interface/bevy-digital-real-canvas.md
+++ b/wiki/interface/bevy-digital-real-canvas.md
@@ -166,8 +166,9 @@ Fog states keep the cursor.md epistemic contract in both dialects:
   solids that read as known layout, not live truth.
 - **Remembered:** stale silhouettes/model state, dimmed and timestamped where
   useful.
-- **Heard:** sound/presence pulse only. It may occupy a tile/area as an amber or
-  bone ripple, but it must not reveal visual shape.
+- **Heard:** the noise field — bone presence pulses on covered floor, event
+  rings from recent heard captures, and a presence marker for mic-only people.
+  Never amber (amber is machine footprint); never visual shape of the room.
 - **Seen / telemetry:** richest treatment the active sense earns: camera/material
   detail in real, live telemetry/model detail in digital.
 
diff --git a/wiki/interface/bevy-visual-floor.md b/wiki/interface/bevy-visual-floor.md
index 7a28d7d..dfa8fce 100644
--- a/wiki/interface/bevy-visual-floor.md
+++ b/wiki/interface/bevy-visual-floor.md
@@ -91,8 +91,9 @@ Fog states are visually distinct while obeying the legibility law:
   tile facts.
 - **Blueprint / remembered:** schematic gunmetal/chrome silhouettes; enough
   geometry to orient, explicitly not live.
-- **Heard:** presence/noise indication only; no visual detail a microphone did
-  not earn.
+- **Heard:** the noise field — bone presence/noise pulses and event rings;
+  mic-only people as presence markers. No visual detail a microphone did not
+  earn; never amber (machine footprint stays amber).
 - **Seen / telemetry:** the richest *legible* treatment the current assets
   support. In the default sensorium this means quiet flat clinical blocks plus
   overlays, not noisy generated swatches. The pixel-art/material textures are
diff --git a/wiki/interface/flat-materials.md b/wiki/interface/flat-materials.md
index e1e6499..fcad830 100644
--- a/wiki/interface/flat-materials.md
+++ b/wiki/interface/flat-materials.md
@@ -50,12 +50,16 @@ lighting, palette, silhouette, and shader-level functional detail.
   states. Pooled exactly like the current material pool.
 - **Functional shader detail only:** a subtle floor grid in blueprint
   areas, scan flicker on live feeds, emissive seams on powered
-  machines. No decorative noise.
+  machines, and the Heard **noise field** (bone presence pulses / event
+  rings — informational, never decorative texture). No decorative noise.
 - **Fog contract unchanged and restated:** unknown = absent, heard =
-  dim presence, remembered/blueprint = unlit flat, seen = lit flat.
-  Lighting remains the epistemic signal.
-- **People:** flat silhouettes (the current procedural billboards are
-  already the right shape); identity stays a panel/menu fact.
+  noise-field presence (no room shape), remembered/blueprint = unlit
+  flat, seen = lit flat. Lighting remains the epistemic signal for
+  sight; hearing speaks in bone pulses instead.
+- **People:** flat silhouettes under camera coverage (the current
+  procedural billboards are already the right shape); under mic-only
+  coverage, a bone presence marker — never the silhouette. Identity
+  stays a panel/menu fact.
 - **Sensorium (flat) mode** adopts the same palette table so F3 flips
   treatment, never language.
 - **Asset retirement:** the Bevy world render stops loading tile PNGs;
diff --git a/wiki/interface/views.md b/wiki/interface/views.md
index e4dd4cd..2c45fea 100644
--- a/wiki/interface/views.md
+++ b/wiki/interface/views.md
@@ -84,7 +84,9 @@ materials, bodies, machines, doors, occlusion, and gore instead of signal logic.
 
 Cameras are how you look into it. People render only per sensor coverage and
 staged knowledge (schedules.md, cursor.md): a presence marker under mic-only
-coverage, a full body under camera coverage, nothing where unearned.
+coverage, a full body under camera coverage, nothing where unearned. Heard
+coverage itself is the **noise field** — bone presence pulses and event rings
+over the room, never a picture of its contents.
 
 ### Shared rules
 
diff --git a/wiki/log/2026-07-09-heard-noise-field.md b/wiki/log/2026-07-09-heard-noise-field.md
new file mode 100644
index 0000000..bf8305f
--- /dev/null
+++ b/wiki/log/2026-07-09-heard-noise-field.md
@@ -0,0 +1,37 @@
+# 2026-07-09 — Heard noise field (Ears beat visuals)
+
+```
+Type: log
+```
+
+## Intent
+
+Tick finding against the Ears beat screenshot: after tapping the
+environmental monitor's audio, Heard coverage was a flat dim floor and
+mic-only people stayed invisible. That violated cursor.md (presence
+markers under hearing) and the canvas contract (bone presence pulses,
+never room shape). Cameron asked to make the first tap visually
+interesting and to start supporting the noise system.
+
+## Changed
+
+- Spec: cursor.md Heard fog = **noise field** (bone pulses, event rings,
+  presence markers; never amber). AC4 restated. Status note updated.
+- Interface: bevy-digital-real-canvas.md, bevy-visual-floor.md,
+  flat-materials.md, views.md — Heard language aligned to the noise field.
+- Bevy: `render_noise_field_3d` / `render_noise_field_flat` draw standing
+  coverage pulses, expanding rings from recent `HeardEvent`s, and soft
+  discs for mic-only people; flat people markers show `~` / initial under
+  hearing; Heard floor dimmed so pulses read. Dev shot `ears` stages
+  audio-tap-only.
+- Terminal + agent map: mic-only presence glyph (`~` / initial).
+
+## Observed
+
+`MISALIGNED_SHOT=ears`: bone pulses over the heard room around the env
+monitor; no camera geometry; presence disc when someone is under mic
+coverage.
+
+## Checks
+
+`./tools/check.sh` (full gate — Rust/Bevy change).
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index 48305e2..f0c50b6 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -5,6 +5,18 @@ Type: log
 ```
 Reverse chronological implementation notes. Keep this factual: what changed, why, checks, and spec impact.
 
+## 2026-07-09 - Heard noise field (Ears beat visuals)
+
+- Intent: after the first audio tap, Heard was a flat dim floor with no
+  presence markers — a violation of cursor.md and the canvas ripple
+  contract; Cameron asked to start the noise system visually.
+- Changed: cursor.md + interface specs name the Heard **noise field**
+  (bone pulses, event rings, mic-only markers; never amber); Bevy
+  `render_noise_field_3d`/`_flat` + `ears` shot; terminal/agent `~`
+  presence glyph.
+- Checks: full ./tools/check.sh; ears capture.
+- Log: wiki/log/2026-07-09-heard-noise-field.md.
+
 ## 2026-07-09 - Token stacks readable at default camera
 
 - Intent: decided cube/mercury/exposure forms were vanishing under chassis
@@ -15,7 +27,6 @@ Reverse chronological implementation notes. Keep this factual: what changed, why
   up.
 - Checks: `./tools/check.sh`.
 - Log: wiki/log/2026-07-09-token-visibility.md.
-
 ## 2026-07-09 - In-flight route blips on the work wire
 
 - Intent: demand/knowledge hops should read as cargo crawling the wire,
diff --git a/wiki/log/decisions/2026-07-09.md b/wiki/log/decisions/2026-07-09.md
index 5c4dbee..ccfc6f7 100644
--- a/wiki/log/decisions/2026-07-09.md
+++ b/wiki/log/decisions/2026-07-09.md
@@ -232,3 +232,11 @@ Type: log
   Amended into art/visual-identity.md, mechanics/machine-work.md, and
   mechanics/people-tokens.md; trail deposit is sim work scoped with
   people-tokens (#35).
+- **2026-07-09 — Heard is the noise field.** Tick finding on the Ears
+  beat: Heard fog was a flat dim floor and mic-only people were invisible,
+  against cursor.md presence markers and the canvas "bone ripple" contract.
+  Affirmed treatment: hearing paints a **noise field** — bone (never amber)
+  presence pulses on covered floor, expanding rings from recent
+  `HeardEvent`s, and a soft presence marker for mic-only people. No room
+  shape. Amended into cursor.md and the Bevy/views/flat-materials Heard
+  bullets; both frontends render it.
diff --git a/wiki/mechanics/cursor.md b/wiki/mechanics/cursor.md
index 396c068..3c65877 100644
--- a/wiki/mechanics/cursor.md
+++ b/wiki/mechanics/cursor.md
@@ -14,7 +14,10 @@ Status note: implemented 2026-07-07 on the cursor-senses branch. The walking
   social knowledge — role silhouettes until Schedule, authored names after
   (criterion 5 extended). 2026-07-09: blueprint is room topology only —
   foreign machine chassis are absent under blueprint; owned hosts still
-  render via telemetry (machine-work.md). Verified by `cargo test` and
+  render via telemetry (machine-work.md). 2026-07-09: Heard is the **noise
+  field** — bone presence pulses, event rings from recent `HeardEvent`s,
+  and mic-only presence markers in both frontends (never amber; never room
+  shape). Verified by `cargo test` and
   `cargo check --no-default-features --features bevy_ui --bin misaligned-bevy`.
 Stage: B1 — The Basement
 Design:
@@ -96,7 +99,13 @@ precedence: **Seen** > **Heard** > **Remembered** > **Blueprint** >
 **Unknown**.
 
 - **Seen** — full live render.
-- **Heard** — no visuals; presence/event markers; room label if known.
+- **Heard** — no visual shape of the room. The hearing channel is a
+  **noise field**: bone (not amber) presence pulses over covered floor,
+  recent `HeardEvent`s ring from the room they were captured in, and a
+  person under mic-only coverage is a presence marker gated by staged
+  knowledge — never a silhouette, never a tile picture. Room label if
+  known. Amber stays machine footprint; hearing borrows bone so sound
+  never reads as owned hardware.
 - **Remembered** (affirmed 2026-07-07) — a dimmed snapshot of the last
   Seen state, timestamped ("last seen day 3, 14:00" on inspect); never
   live. A process keeps logs — DF-style map memory with an in-fiction
@@ -171,8 +180,9 @@ without the sense coverage that earns it.**
    not see through walls or closed opaque doors.
 4. The fog states render distinguishably in both frontends; acquiring
    the env_camera converts its coverage to Seen (the first-eyes beat
-   end-to-end); a hearing-only region shows presence/events and never
-   visual detail or unearned identity.
+   end-to-end); a hearing-only region shows the noise field
+   (presence pulses, event rings, presence markers) and never visual
+   detail or unearned identity.
 5. `inspect` returns a card for any tile with every fact
    provenance-tagged, and a live fact never appears without the sense
    coverage that earns it (test: a person in an uncovered room is
-- 
2.51.2