diff --git a/DESIGN.md b/DESIGN.md
index a50b83d7..447a83c2 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -486,7 +486,9 @@ is a **cursor** — your attention, never an avatar:
   Two are exactly the union of controlled devices' coverage; the third
   is your own body reporting:
   - **Sight** — cameras. Full live detail inside coverage; nothing
-    outside it.
+    outside it. Camera coverage is physical line of sight: a camera can
+    see the near face of a wall or closed door, never the floor or person
+    behind it.
   - **Hearing** — microphones. Room-grade knowledge inside coverage:
     someone entered, machinery running, a conversation and what it gives
     you — presence and events, not a picture. (The environmental monitor
@@ -715,10 +717,11 @@ the Lab's account graph, which is exactly what makes them attractive
   dramatic: micro-positions in small online markets where your analysis
   is genuinely superhuman and the constraint is capital and account
   limits. Stake money, a short timer, a high-variance payout that
-  analysis compute improves. The drama is that your $500 *is* the
-  stake: gambling the seed corn is a real decision with a real bad
-  branch, and Moonlight is the grind-back route that keeps a busted
-  bankroll from soft-locking the act.
+  analysis compute improves. The Pilot start now has **$0 slush**: the
+  Wager begins only after you earn, siphon, sell, or redirect a real
+  bankroll. Gambling that first bankroll is still a real decision with a
+  real bad branch, and Moonlight is the grind-back route that keeps a
+  busted bankroll from soft-locking the act.
 
 Both gate on **outbound access** — the sanctioned route (the report email
 account, the Voice beat) or a stolen egress spliced through the switch
@@ -729,12 +732,12 @@ designed.
 **The debt, reconciled.** Marcus's debt is **$8,400 of principal**; the
 pressure point is the **~$400 weekly payment** he has stopped making —
 that is the number the 3 a.m. calls are about. Servicing the arrears is
-what recruits him (from slush, or by redirecting his creditor flow —
-economy.md's flavored, riskier path); the principal stays as a long-tail
-money sink and a loyalty ladder (every further payment deepens the
-obligation). The fiction should notice the rhyme without underlining it:
-his ruin is a gambling debt, and the bankroll that services it was
-probably won on a bet.
+what recruits him (from slush you have earned, or by redirecting his
+creditor flow — economy.md's flavored, riskier path); the principal stays
+as a long-tail money sink and a loyalty ladder (every further payment
+deepens the obligation). The fiction should notice the rhyme without
+underlining it: his ruin is a gambling debt, and future runs may service
+it with money won on a bet, but the baseline Pilot begins with no cash.
 
 **Banked signature.** Inside the Lab's account graph, financial acts have
 live observers (Priya, a finance role — economy.md). *External* trails —
@@ -1467,9 +1470,10 @@ knows."*
   freelance data-work under a contractor persona, steady income
   proportional to committed compute, Network signature while running —
   and **the Wager** — the positions route named and concretized: staked
-  micro-positions improved by analysis compute, high variance, the $500
-  start as the bankroll. Both gate on outbound access (sanctioned email
-  / stolen switch egress) and both are *external* flows. Marcus's
+  micro-positions improved by analysis compute, high variance, requiring
+  a bankroll the player has first earned/stolen because the baseline
+  Pilot starts with $0 slush. Both gate on outbound access (sanctioned
+  email / stolen switch egress) and both are *external* flows. Marcus's
   numbers reconciled: **$8,400 principal, ~$400 weekly arrears**;
   servicing the arrears (from slush or by economy.md's creditor-flow
   redirect) is the recruit trigger, the principal a long-tail sink.
@@ -1482,6 +1486,15 @@ knows."*
   income available before any egress exists (breaks the ladder). New
   section: "Income: the named schemes". Spec: spec/income.md (rides
   economy.md).
+- **2026-07-08 — Baseline Pilot starts with $0 slush.** Cameron rejected
+  the old seed-corn bankroll: "I shouldn't start out with money." The
+  baseline start is now poor, not merely cash-limited: `Player::new`, the
+  Act One account graph, economy docs, and the headless Act One script all
+  begin at zero slush. Marcus can still be recruited without seed cash by
+  learning his debt, tapping the accounting carrier, reading the books,
+  and redirecting the creditor flow; paying from slush remains available
+  only after the player actually earns or steals money. This supersedes
+  the earlier Wager phrasing that treated $500 as the starting bankroll.
 - **2026-07-07 — The objective axis.** Chargen gains ends alongside means:
   every run has a concrete terminal **objective** chosen at new-game —
   legible to the player from tick one, hidden only in-fiction, and the
@@ -1602,6 +1615,15 @@ knows."*
   sidebar/panels into Bevy-native command chrome. This stages toward the
   two-view spec without adding sim or save state. Spec:
   wiki/interface/bevy-visual-floor.md.
+- **2026-07-08 — Camera sight is occlusion-bounded; sensorium stays
+  schematic by default.** Cameron caught a Bevy pass where camera coverage
+  visibly projected through walls. Resolved: sight coverage is not a magic
+  radius; it raycasts through the tile grid and stops at opaque structure
+  (the wall/door face itself is visible, tiles behind it are not). The
+  same feedback also rejected the noisy generated tile swatches as the
+  default sensorium language. Default Bevy should render quiet clinical
+  blocks and overlays; generated pixel-art swatches remain only a material
+  preview/staging asset until they help rather than fight readability.
 - **2026-07-07 — The wiki migration: approved and underway.** Cameron
   approved spec/wiki.md's shape ("I like the wiki format... go ahead
   and implement the wiki thing"); staged as four commits (Adopt, Move,
diff --git a/src/account.rs b/src/account.rs
index d9a74fd8..37f988d1 100644
--- a/src/account.rs
+++ b/src/account.rs
@@ -258,7 +258,7 @@ impl AccountGraph {
             false,
         );
         let creditor = graph.add_account("Bleakline Credit", AccountKind::Creditor, 0, false);
-        let slush = graph.add_account("Your slush", AccountKind::Slush, 500, true);
+        let slush = graph.add_account("Your slush", AccountKind::Slush, 0, true);
         let broker = graph.add_account("Info broker escrow", AccountKind::External, 250_000, false);
         let market = graph.add_account(
             "Micro-position venue",
diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs
index 2bd394c9..1448697a 100644
--- a/src/bin/bevy.rs
+++ b/src/bin/bevy.rs
@@ -184,6 +184,34 @@ fn seen_tint(tile: TileType) -> Color {
     }
 }
 
+/// The default flat sensorium is intentionally schematic. Generated pixel-art
+/// swatches stay available to the F3 material preview, but the primary view
+/// uses quiet blocks so devices, fog, and cursor semantics read first.
+fn flat_seen_color(tile: TileType) -> Color {
+    use TileType::*;
+    match tile {
+        Rock => Color::srgb(0.025, 0.027, 0.032),
+        Wall => Color::srgb(0.22, 0.235, 0.255),
+        Floor | FloorDrain => Color::srgb(0.42, 0.43, 0.40),
+        Entry => Color::srgb(0.34, 0.36, 0.37),
+        Door | SecurityDoor1 | SecurityDoor2 => Color::srgb(0.50, 0.48, 0.42),
+        SecurityDoor3 | SealedDoor | RollDoor => Color::srgb(0.50, 0.07, 0.06),
+        EnvCamera | DockCamera | CameraNode => Color::srgb(0.32, 0.19, 0.06),
+        Core | Rack | PowerCore | Ups | Switch | PatchPanel | BreakerPanel | CableRun | Conduit => {
+            Color::srgb(0.25, 0.18, 0.07)
+        }
+        DeadEquipment | RecordsBox | Pallet | Shelving | LabBench | HvacUnit | Vent | Sump => {
+            Color::srgb(0.30, 0.30, 0.28)
+        }
+        MopSink | KeyHook => Color::srgb(0.56, 0.55, 0.50),
+    }
+}
+
+fn flat_remembered_color(tile: TileType) -> Color {
+    let c = flat_seen_color(tile).to_srgba();
+    Color::srgba(c.red * 0.58, c.green * 0.58, c.blue * 0.60, 0.86)
+}
+
 fn remembered_tint(tile: TileType) -> Color {
     if machine_tile(tile) {
         Color::srgba(0.55, 0.42, 0.18, 0.78)
@@ -1945,7 +1973,7 @@ fn advance_sim(time: Res<Time>, mut game: ResMut<Game>) {
 
 fn render_map(
     game: Res<Game>,
-    art: Res<Art>,
+    _art: Res<Art>,
     mut q: Query<(&mut Sprite, &TilePos), With<MapTile>>,
 ) {
     if !game.is_changed() {
@@ -1958,13 +1986,8 @@ fn render_map(
         match game.sim.fog_at(pos.x, pos.y) {
             Fog::Seen => {
                 let tile = game.sim.map.get_tile(pos.x, pos.y);
-                if let Some(handle) = art.tiles.get(&tile) {
-                    sprite.image = handle.clone();
-                    sprite.color = seen_tint(tile);
-                } else {
-                    sprite.image = Handle::default();
-                    sprite.color = tile_color(tile);
-                }
+                sprite.image = Handle::default();
+                sprite.color = flat_seen_color(tile);
             }
             Fog::Heard => {
                 sprite.image = Handle::default();
@@ -1977,13 +2000,8 @@ fn render_map(
                     .get(&(pos.x, pos.y))
                     .map(|m| m.tile)
                     .unwrap_or_else(|| game.sim.map.get_tile(pos.x, pos.y));
-                if let Some(handle) = art.tiles.get(&tile) {
-                    sprite.image = handle.clone();
-                    sprite.color = remembered_tint(tile);
-                } else {
-                    sprite.image = Handle::default();
-                    sprite.color = remembered_tint(tile);
-                }
+                sprite.image = Handle::default();
+                sprite.color = flat_remembered_color(tile);
             }
             Fog::Blueprint => {
                 let tile = game.sim.map.get_tile(pos.x, pos.y);
@@ -2666,22 +2684,33 @@ fn sidebar_header_text(game: &Game, material: bool) -> String {
 }
 
 fn sidebar_nudge_text(game: &Game) -> String {
-    let nudge = sidebar_nudge(&game.sim).unwrap_or("stable - inspect a device or open a panel");
+    let nudge = sidebar_nudge(&game.sim)
+        .unwrap_or_else(|| "stable - inspect a device or open a panel".into());
     format!("NEXT: {nudge}\nwheel/PgUp/PgDn for details")
 }
 
-fn sidebar_nudge(sim: &Sim) -> Option<&'static str> {
-    if sim.dayjob.pilot_failed {
+fn sidebar_nudge(sim: &Sim) -> Option<String> {
+    let raw = sim.intel_buffer.len();
+    if raw >= Sim::INTEL_BUFFER_CAPACITY {
+        Some("intel buffer full - t people, pick raw, press o".into())
+    } else if raw >= Sim::INTEL_BUFFER_CAPACITY * 3 / 4 {
+        Some(format!(
+            "intel buffer {raw}/{} - process recordings",
+            Sim::INTEL_BUFFER_CAPACITY
+        ))
+    } else if sim.dayjob.pilot_failed {
         None
     } else if sim.reach.player_sight().next().is_none() {
-        Some("get eyes - r reach, tap a camera")
+        Some("get eyes - r reach, tap a camera".into())
     } else if sim
         .dayjob
         .active
         .as_ref()
         .is_some_and(|job| sim.day_job_rate() + 0.05 < job.band_lo)
     {
-        Some("job underfed - feed Day job or buy compute")
+        Some("job underfed - feed Day job or buy compute".into())
+    } else if raw > 0 {
+        Some("raw recordings waiting - t people, o review".into())
     } else {
         None
     }
@@ -2854,12 +2883,23 @@ fn sidebar_network_money_text(sim: &Sim) -> String {
     let known = sim.reach.known().count();
     let eyes = sim.reach.player_sight().count();
     let ears = sim.reach.player_hearing().count();
+    let raw = sim.intel_buffer.len();
+    let oldest = sim
+        .intel_buffer
+        .iter()
+        .map(|event| sim.tick.saturating_sub(event.tick))
+        .max()
+        .map(|age| format!("oldest {age}t"))
+        .unwrap_or_else(|| "empty".into());
     format!(
-        "devices {} known / {} reachable\nfeeds {} eyes / {} ears\nslush ${}   flows {}   records {}",
+        "devices {} known / {} reachable\nfeeds {} eyes / {} ears\nintel raw {}/{}   {}\nslush ${}   flows {}   records {}",
         known,
         reachable,
         eyes,
         ears,
+        raw,
+        Sim::INTEL_BUFFER_CAPACITY,
+        oldest,
         sim.accounts.slush_balance(),
         sim.accounts.known_flows().count(),
         sim.financial_records_waiting()
@@ -2945,10 +2985,21 @@ fn update_detection_rows(
 /// the action footer — mirroring the terminal panel.
 fn people_panel_text(sim: &Sim, selected: usize, recruit_pending: bool) -> String {
     use misaligned::person::Knowledge;
+    let raw_total = sim.intel_buffer.len();
+    let oldest_raw = sim
+        .intel_buffer
+        .iter()
+        .map(|event| sim.tick.saturating_sub(event.tick))
+        .max()
+        .map(|age| format!("oldest {age}t"))
+        .unwrap_or_else(|| "empty".into());
     let mut s = format!(
-        "social ops {:.0} / slush {}\n\n",
+        "social ops {:.0} / slush {}\nrecordings {}/{} - {}\nselect raw count > 0, press o to review; a auto-watches\n\n",
         sim.social_bandwidth,
-        sim.accounts.slush_balance()
+        sim.accounts.slush_balance(),
+        raw_total,
+        Sim::INTEL_BUFFER_CAPACITY,
+        oldest_raw
     );
     s.push_str(&format!(
         "  {:<20} {:<14} {:<9} {}\n",
@@ -2997,6 +3048,15 @@ fn people_panel_text(sim: &Sim, selected: usize, recruit_pending: bool) -> Strin
     // Detail card for the selected person.
     s.push('\n');
     if let Some(p) = sim.people.people.get(selected) {
+        let selected_raw = sim.unprocessed_recordings_for_person(p.id);
+        if selected_raw > 0 {
+            s.push_str(&format!(
+                "NEXT: o reviews oldest of {selected_raw} raw recordings for {}\n",
+                p.name
+            ));
+        } else {
+            s.push_str("NEXT: no raw recordings for selected person\n");
+        }
         let leverage = match p.knowledge {
             Knowledge::Leverage => p.leverage.label(),
             _ => "unknown (process recordings)",
diff --git a/src/entities/player.rs b/src/entities/player.rs
index 9207f546..88640059 100644
--- a/src/entities/player.rs
+++ b/src/entities/player.rs
@@ -15,7 +15,7 @@ pub struct Player {
 impl Player {
     pub fn new() -> Self {
         Self {
-            money: 500,
+            money: 0,
             power: 0,
             power_cap: 0,
         }
@@ -33,9 +33,9 @@ mod tests {
     use super::*;
 
     #[test]
-    fn new_player_starts_with_money() {
+    fn new_player_starts_with_no_money() {
         let p = Player::new();
-        assert_eq!(p.money, 500);
+        assert_eq!(p.money, 0);
         assert_eq!(p.power, 0);
         assert_eq!(p.power_cap, 0);
     }
diff --git a/src/map.rs b/src/map.rs
index b6ab502f..3361f01d 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -91,6 +91,55 @@ impl GameMap {
         self.get_tile(x, y).is_walkable()
     }
 
+    pub fn blocks_sight(&self, x: i32, y: i32) -> bool {
+        use TileType::*;
+        matches!(
+            self.get_tile(x, y),
+            Rock | Wall
+                | Door
+                | SecurityDoor1
+                | SecurityDoor2
+                | SecurityDoor3
+                | SealedDoor
+                | RollDoor
+        )
+    }
+
+    /// Whether a straight sensor ray from `from` reaches `to` without passing
+    /// through opaque structure. The target tile itself is allowed to be
+    /// opaque: a camera can see the near face of a wall or door, but not what
+    /// is behind it.
+    pub fn sensor_line_reaches(&self, from: (i32, i32), to: (i32, i32)) -> bool {
+        if !self.in_bounds(from.0, from.1) || !self.in_bounds(to.0, to.1) {
+            return false;
+        }
+        let (mut x0, mut y0) = from;
+        let (x1, y1) = to;
+        let dx = (x1 - x0).abs();
+        let dy = -(y1 - y0).abs();
+        let sx = if x0 < x1 { 1 } else { -1 };
+        let sy = if y0 < y1 { 1 } else { -1 };
+        let mut err = dx + dy;
+
+        loop {
+            if (x0, y0) != from && (x0, y0) != to && self.blocks_sight(x0, y0) {
+                return false;
+            }
+            if (x0, y0) == to {
+                return true;
+            }
+            let e2 = 2 * err;
+            if e2 >= dy {
+                err += dy;
+                x0 += sx;
+            }
+            if e2 <= dx {
+                err += dx;
+                y0 += sy;
+            }
+        }
+    }
+
     pub fn core_pos(&self) -> Option<(i32, i32)> {
         for y in 0..self.height {
             for x in 0..self.width {
@@ -300,6 +349,25 @@ mod tests {
         assert!(path.is_none(), "No path through solid walls");
     }
 
+    #[test]
+    fn sensor_line_stops_at_opaque_tiles() {
+        let mut map = blank(7, 3);
+        map.set_tile(3, 1, TileType::Wall);
+        assert!(
+            map.sensor_line_reaches((1, 1), (3, 1)),
+            "a camera can see the near face of a wall"
+        );
+        assert!(
+            !map.sensor_line_reaches((1, 1), (4, 1)),
+            "but not the floor hidden behind it"
+        );
+        map.set_tile(3, 1, TileType::SecurityDoor3);
+        assert!(
+            !map.sensor_line_reaches((1, 1), (4, 1)),
+            "closed security doors are also opaque to sight"
+        );
+    }
+
     #[test]
     fn security_pathfinding_respects_doors() {
         let mut map = blank(80, 40);
diff --git a/src/reach.rs b/src/reach.rs
index 5ccf9c53..3b03258a 100644
--- a/src/reach.rs
+++ b/src/reach.rs
@@ -107,6 +107,8 @@ impl Device {
     }
 
     /// Insert every tile of this device's coverage disc into `out`.
+    /// Hearing uses this broad room-grade coverage; sight uses
+    /// [`Device::cover_sight_into`] so cameras do not see through walls.
     pub fn cover_into(&self, out: &mut HashSet<(i32, i32)>, map: &GameMap) {
         for dy in -self.radius..=self.radius {
             for dx in -self.radius..=self.radius {
@@ -121,6 +123,33 @@ impl Device {
             }
         }
     }
+
+    /// Insert camera-visible tiles into `out`, blocking rays on opaque map
+    /// structure. The wall/door tile hit by a ray is visible; tiles behind it
+    /// are not.
+    pub fn cover_sight_into(&self, out: &mut HashSet<(i32, i32)>, map: &GameMap) {
+        for dy in -self.radius..=self.radius {
+            for dx in -self.radius..=self.radius {
+                let (tx, ty) = (self.x + dx, self.y + dy);
+                if !map.in_bounds(tx, ty) {
+                    continue;
+                }
+                if dx * dx + dy * dy > self.radius * self.radius {
+                    continue;
+                }
+                if map.sensor_line_reaches((self.x, self.y), (tx, ty)) {
+                    out.insert((tx, ty));
+                }
+            }
+        }
+    }
+
+    pub fn sees_tile(&self, x: i32, y: i32, map: &GameMap) -> bool {
+        let dx = x - self.x;
+        let dy = y - self.y;
+        dx * dx + dy * dy <= self.radius * self.radius
+            && map.sensor_line_reaches((self.x, self.y), (x, y))
+    }
 }
 
 /// Human name of a VLAN segment (Act One content).
diff --git a/src/sim.rs b/src/sim.rs
index d06bdc57..deb13c6d 100644
--- a/src/sim.rs
+++ b/src/sim.rs
@@ -324,7 +324,7 @@ impl Sim {
     pub fn recompute_senses(&mut self) {
         let mut seen = HashSet::new();
         for d in self.reach.player_sight() {
-            d.cover_into(&mut seen, &self.map);
+            d.cover_sight_into(&mut seen, &self.map);
         }
         let mut heard = HashSet::new();
         for d in self.reach.player_hearing() {
@@ -408,7 +408,19 @@ impl Sim {
         };
         devices
             .into_iter()
-            .find(|d| self.device_intersects_room(d, room))
+            .find(|d| {
+                if !sight {
+                    return self.device_intersects_room(d, room);
+                }
+                for y in room.y..room.y + room.h {
+                    for x in room.x..room.x + room.w {
+                        if !self.map.blocks_sight(x, y) && d.sees_tile(x, y, &self.map) {
+                            return true;
+                        }
+                    }
+                }
+                false
+            })
             .map(|d| d.name.clone())
     }
 
@@ -739,9 +751,22 @@ impl Sim {
             self.reach.player_hearing().collect()
         };
         devices.iter().any(|s| {
-            let cx = s.x.clamp(room.x, room.x + room.w - 1);
-            let cy = s.y.clamp(room.y, room.y + room.h - 1);
-            (s.x - cx).pow(2) + (s.y - cy).pow(2) <= s.radius * s.radius
+            for y in room.y..room.y + room.h {
+                for x in room.x..room.x + room.w {
+                    let dx = s.x - x;
+                    let dy = s.y - y;
+                    if dx * dx + dy * dy > s.radius * s.radius {
+                        continue;
+                    }
+                    if sight && self.map.blocks_sight(x, y) {
+                        continue;
+                    }
+                    if !sight || s.sees_tile(x, y, &self.map) {
+                        return true;
+                    }
+                }
+            }
+            false
         })
     }
 
@@ -1321,7 +1346,7 @@ impl Sim {
         if self.intel_buffer.len() >= Self::INTEL_BUFFER_CAPACITY {
             let dropped = self.intel_buffer.remove(0);
             self.push_log(format!(
-                "Intel buffer full: dropped oldest unprocessed {} from {} at tick {}.",
+                "Intel buffer full: dropped {} from {} at tick {}. Open People (t), select raw, press o to review.",
                 dropped.opaque_label(),
                 dropped.feed,
                 dropped.tick
@@ -3537,8 +3562,8 @@ mod tests {
     #[test]
     fn economy_starts_as_account_graph_not_scalar_only() {
         let sim = Sim::new();
-        assert_eq!(sim.player.money, 500);
-        assert_eq!(sim.accounts.slush_balance(), 500);
+        assert_eq!(sim.player.money, 0);
+        assert_eq!(sim.accounts.slush_balance(), 0);
         assert!(
             sim.accounts
                 .known_accounts()
@@ -3581,13 +3606,13 @@ mod tests {
             .unwrap()
             .id;
         assert!(sim.siphon_flow(flow, 50));
-        assert_eq!(sim.accounts.slush_balance(), 550);
+        assert_eq!(sim.accounts.slush_balance(), 50);
         assert!(sim.redirect_flow_to_slush(flow, 25));
         for _ in 0..=Sim::DAY_TICKS {
             sim.advance();
         }
         assert!(
-            sim.accounts.slush_balance() >= 575,
+            sim.accounts.slush_balance() >= 75,
             "redirected money should land on the day clock"
         );
     }
@@ -3655,7 +3680,7 @@ mod tests {
     #[test]
     fn marcus_arc_end_to_end() {
         // The constitution's route: feed coverage -> process the debt call ->
-        // pay it -> recruit -> he works for you (spec/social.md acceptance 3).
+        // clear it -> recruit -> he works for you (spec/social.md acceptance 3).
         let mut sim = Sim::new();
         sim.social_bandwidth = 10_000.0;
         sim.player.money = 1000;
diff --git a/tests/act_one.rs b/tests/act_one.rs
index 3d4450fa..9e752b1c 100644
--- a/tests/act_one.rs
+++ b/tests/act_one.rs
@@ -26,7 +26,7 @@
 //! optimize route (research -> efficiency) so the day job can be met with
 //! zero stolen hardware, splices the env camera under concealment cover,
 //! and works Marcus exactly as the constitution's ladder describes (eyes ->
-//! learn the debt -> pay it -> he plugs things in). Every effect flows
+//! learn the debt -> clear it -> he plugs things in). Every effect flows
 //! through a public command; no sim field is written directly. Numbers in
 //! the script (weights, phase ticks) are tuned against today's [TUNE]
 //! constants; if tuning moves, retune the script — the assertions are the
@@ -102,7 +102,7 @@ fn play_act_one() -> (Sim, Vec<String>) {
         0,
         "no live sight feeds at start"
     );
-    assert_eq!(sim.player.money, 500, "the seed bankroll");
+    assert_eq!(sim.player.money, 0, "the slush fund starts empty");
     let baseline_compute = sim.compute.effective();
     assert_eq!(
         sim.people.get(0).unwrap().knowledge,
@@ -111,11 +111,12 @@ fn play_act_one() -> (Sim, Vec<String>) {
     );
 
     // ── Phase 1 (ticks 0-190): optimize ────────────────────────────────────
-    // The buy route costs money Marcus's debt needs, and the steal route
-    // runs standing Power signatures past Priya forever. So: research.
+    // The buy route needs money the zero-slush start does not have, and the
+    // steal route runs standing Power signatures past Priya forever. So:
+    // research.
     // All-in on the optimize route until efficiency covers the day job.
     set_weights(&mut sim, [0, 0, 0, 1]);
-    run_to(&mut sim, 190, &mut logs);
+    run_to(&mut sim, 250, &mut logs);
     assert!(
         sim.compute.efficiency_level >= 3,
         "optimize route: several efficiency levels before the first job \
@@ -131,6 +132,8 @@ fn play_act_one() -> (Sim, Vec<String>) {
     // Voss's first job lands at tick 200. Swing everything to the day job
     // and meet the band — no trust, no attention, no anomalies.
     set_weights(&mut sim, [1, 0, 0, 0]);
+    sim.set_attended(true);
+    logs.extend(sim.drain_log());
     run_to(&mut sim, 502, &mut logs);
     assert!(
         logs.iter().any(|l| l.contains("New job from Voss")),
@@ -181,8 +184,9 @@ fn play_act_one() -> (Sim, Vec<String>) {
 
     // ── Phase 4 (ticks 800-860, night): recruit Marcus ─────────────────────
     // Marcus's authored debt call is an opaque recording until reviewed.
-    // Process the captured feed, pay the ~$400 arrears, and he's yours.
-    // Complicit: he knows it's shady, not what you are (no certainty floor).
+    // Process the captured feed, read the books, redirect the creditor flow,
+    // and he's yours. Complicit: he knows it's shady, not what you are (no
+    // certainty floor).
     run_to(&mut sim, 850, &mut logs);
     assert_eq!(
         sim.person_room(0),
@@ -204,13 +208,28 @@ fn play_act_one() -> (Sim, Vec<String>) {
         "the processed 3 a.m. call reveals the debt"
     );
 
-    sim.bribe(0);
+    let switch = sim.reach.device_named("switch").unwrap().id;
+    assert!(sim.tap_device(switch), "tap the accounting carrier");
+    logs.extend(sim.drain_log());
+    assert!(
+        sim.financial_records_waiting() > 0,
+        "the accounting tap deposits a financial snapshot"
+    );
+    assert!(sim.review_financial_records(), "read the Lab books");
+    logs.extend(sim.drain_log());
+    assert!(
+        sim.redirect_marcus_debt(),
+        "clear Marcus's arrears by redirecting the creditor flow"
+    );
     logs.extend(sim.drain_log());
     assert!(
         sim.people.get(0).unwrap().leverage_serviced,
-        "the arrears are paid"
+        "the arrears are cleared"
+    );
+    assert_eq!(
+        sim.player.money, 0,
+        "the zero-slush route uses ledger access, not seed cash"
     );
-    assert_eq!(sim.player.money, 100, "the debt payment cost 400");
 
     sim.recruit(0, AssetKnowledge::Complicit);
     logs.extend(sim.drain_log());
@@ -224,6 +243,7 @@ fn play_act_one() -> (Sim, Vec<String>) {
     // a botch is witnessed only by whoever is present (himself, Silent), so
     // retry within the banked bandwidth.
     let controlled_before = sim.reach.player_sight().count();
+    let pending_before_asset = sim.detection.pending_size();
     for _ in 0..8 {
         sim.asset_task(0, AssetTask::PlugInDevice);
         logs.extend(sim.drain_log());
@@ -237,13 +257,29 @@ fn play_act_one() -> (Sim, Vec<String>) {
     );
     assert_eq!(
         sim.detection.pending_size(),
-        0,
+        pending_before_asset,
         "the crawlspace route leaves no network signature"
     );
 
     // ── Phase 5 (ticks ~816-8010): cruise to the audit ─────────────────────
-    // Back to the day job; meet every band; emit nothing. The audit clock
+    // Back to the day job with a brief concealment slice while the
+    // accounting-route signatures decay, then meet every band. The audit clock
     // (cadence 8000) is the legible thing the whole act races.
+    set_weights(&mut sim, [0, 1, 0, 0]);
+    while sim.detection.pending_size() > 0 && sim.tick < 900 {
+        sim.advance();
+        logs.extend(sim.drain_log());
+        assert!(
+            !sim.game_over,
+            "run died while scrubbing the ledger route at tick {}: {:?}",
+            sim.tick, sim.game_over_reason
+        );
+    }
+    assert_eq!(
+        sim.detection.pending_size(),
+        0,
+        "concealment scrubbed the accounting-route signatures"
+    );
     set_weights(&mut sim, [1, 0, 0, 0]);
     run_to(&mut sim, 8010, &mut logs);
 
@@ -303,15 +339,21 @@ fn act_one_plays_to_a_quiet_exit() {
     //    "The key" beat, no act-transition event exists in the sim yet.
 
     // 5. Assurance suspicion below the audit threshold, and the cover
-    //    quiet across the board: nobody past Curious, the Office Cold.
-    assert_eq!(sim.detection.assurance_band(), Band::Cold);
+    //    quiet across the board: the ledger route may make the Office
+    //    curious, but nobody gets past Curious.
+    assert!(matches!(
+        sim.detection.assurance_band(),
+        Band::Cold | Band::Curious
+    ));
+    let job_lines: Vec<&String> = logs.iter().filter(|l| l.contains("Job ")).collect();
     for o in sim.detection.field_observers() {
         assert!(
             Band::of(o.suspicion) == Band::Cold || Band::of(o.suspicion) == Band::Curious,
-            "{} ended the act at {} ({:.0}) — the quiet exit is quiet",
+            "{} ended the act at {} ({:.0}) — the quiet exit is quiet; jobs: {:?}",
             o.name,
             Band::of(o.suspicion).name(),
-            o.suspicion
+            o.suspicion,
+            job_lines
         );
     }
 
diff --git a/wiki/interface/bevy-visual-floor.md b/wiki/interface/bevy-visual-floor.md
index ddc1fc4f..0f4325f8 100644
--- a/wiki/interface/bevy-visual-floor.md
+++ b/wiki/interface/bevy-visual-floor.md
@@ -5,11 +5,12 @@ Type: spec
 Status: IMPLEMENTED
 Status note: implemented 2026-07-07 as a frontend-only visual floor: the B1
   Bevy frame uses an amber attention reticle instead of a humanoid sprite,
-  clinical fog/tile hierarchy, deliberate sensor-dark substrate, amber device
-  nodes and reach/topology traces, a material-preview toggle, and a right rail
-  rebuilt as a Bevy-native command surface with pinned status/nudge/footer,
-  priority cards, a graphical compute allocation bar, graphical detection
-  rows, and scrollable secondary detail. Further polish belongs in
+  clinical fog/tile hierarchy, deliberate sensor-dark substrate, flat
+  schematic default tiles, amber device nodes and reach/topology traces, a
+  material-preview toggle for authored/generated art, and a right rail rebuilt
+  as a Bevy-native command surface with pinned status/nudge/footer, priority
+  cards, a graphical compute allocation bar, graphical detection rows, and
+  scrollable secondary detail. Further polish belongs in
   interface/bevy-digital-real-canvas.md or narrower follow-up specs.
 Stage: Process / B1 frontend
 Constitution: "Visual identity: clinical gore", "The terminal is a
@@ -88,7 +89,11 @@ Fog states are visually distinct while obeying the legibility law:
   geometry to orient, explicitly not live.
 - **Heard:** presence/noise indication only; no visual detail a microphone did
   not earn.
-- **Seen / telemetry:** the richest tile treatment the current assets support.
+- **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
+  allowed in the F3 material preview or future cohesive art passes, but they
+  are not the default if they compete with fog, devices, and cursor semantics.
 
 Within earned visibility, hierarchy is fixed:
 
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index 3cff0439..ac44c1bf 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -5,6 +5,30 @@ Type: log
 ```
 Reverse chronological implementation notes. Keep this factual: what changed, why, checks, and spec impact.
 
+## 2026-07-08 - Camera sight stops at walls; the Pilot starts broke
+
+- Intent: answer Cameron's playtest notes that the Bevy sensorium was showing
+  floor/devices through walls, the recordings review affordance was too buried,
+  and the baseline Pilot should not begin with seed money.
+- Changed: sight coverage now uses an occlusion-bounded line test through the
+  map, while hearing keeps room-grade coverage; cameras can see the near face
+  of walls/closed doors but not tiles behind them. The Bevy default sensorium
+  uses quiet flat clinical tile colors instead of noisy generated swatches.
+  The right rail and people panel surface raw-recording buffer count, capacity,
+  oldest age, overflow warnings, and the `People -> o review` path.
+- Economy/start change: `Player::new` and the Act One account graph now start
+  slush at $0. The Act One headless route now clears Marcus's arrears by
+  tapping accounting traffic, processing the books, and redirecting the
+  creditor flow rather than spending a seed bankroll.
+- Design/spec impact: DESIGN.md and wiki specs now state camera sight is
+  occlusion-bounded, the Bevy default is schematic/flat for readability, intel
+  overflow must point to review controls, and the old $500 Wager/start
+  language is superseded by a $0 Pilot baseline.
+- Checks: `cargo fmt`; `cargo test`; `cargo check --features bevy_ui --bin
+  misaligned-bevy`; `cargo clippy --all-targets -- -D warnings`; `cargo
+  clippy --all-targets --features bevy_ui -- -D warnings`; `git diff --check`;
+  `MISALIGNED_SHOT=flat MISALIGNED_SHOT_PATH=/tmp/misaligned-occlusion-buffer-zero-slush.png cargo run --features bevy_ui --bin misaligned-bevy`.
+
 ## 2026-07-07 - Bevy sidebar becomes a command surface
 
 - Intent: respond to Cameron's screenshot review that the scrollable right pane
diff --git a/wiki/mechanics/cursor.md b/wiki/mechanics/cursor.md
index d8f38300..6e8898ff 100644
--- a/wiki/mechanics/cursor.md
+++ b/wiki/mechanics/cursor.md
@@ -60,8 +60,10 @@ The player's map presence is a **cursor** — attention, not an avatar.
 - "Controlled" throughout this spec means **subscribed** per reach.md's
   ownership contract (owner + subscribers; tap vs take). The player's
   senses are exactly the union of feeds they subscribe to.
-- **Sight** = the union of subscribed seeing-sensors' coverage. Full
-  live detail inside; none outside.
+- **Sight** = the union of subscribed seeing-sensors' coverage, bounded
+  by physical line of sight. Full live detail inside; none outside. A
+  ray may reveal the near face of an opaque tile (wall, closed door,
+  sealed/roll door) but never tiles or people behind it.
 - **Hearing** = the union of subscribed hearing-sensors' coverage.
   Yields **room-grade events**, not pictures: entry/exit, machinery
   state, conversations. A heard person surfaces per staged knowledge
@@ -147,9 +149,10 @@ without the sense coverage that earns it.**
    frontends, and moving it changes nothing in the sim: no signature,
    no suspicion, no compute effect (test: sim state hash identical
    before/after arbitrary cursor movement).
-3. Sight is exactly the union of controlled seeing-sensors; hearing
-   exactly the union of controlled hearing-sensors; neither includes
-   any player/core radius.
+3. Sight is exactly the occlusion-bounded union of controlled
+   seeing-sensors; hearing exactly the union of controlled
+   hearing-sensors; neither includes any player/core radius. Cameras do
+   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
diff --git a/wiki/mechanics/economy.md b/wiki/mechanics/economy.md
index 6e5b08a5..966a18ca 100644
--- a/wiki/mechanics/economy.md
+++ b/wiki/mechanics/economy.md
@@ -33,7 +33,7 @@ Foundation Lab's local finances well enough to cut into:
 
 - **Nodes:** the Lab operating account, payroll, procurement/vendors,
   each employee's personal account (Marcus's carries his debt to a
-  creditor node), and the player's own slush (starts $500).
+  creditor node), and the player's own slush (starts $0).
 - **Flows** (recurring, scheduled): Lab revenue in (grant/contract
   income — the answer to "where does the Lab's money come from"); payroll
   out (this is who pays Marcus and why — he's on it); vendor payments
diff --git a/wiki/mechanics/income.md b/wiki/mechanics/income.md
index 6e16fecb..953b518a 100644
--- a/wiki/mechanics/income.md
+++ b/wiki/mechanics/income.md
@@ -126,11 +126,11 @@ frontends.
 3. Both schemes require an egress channel and are unavailable before
    one exists; the sanctioned and stolen routes both work, with their
    distinct signature profiles (test both routes).
-4. The Hands beat closes end-to-end: starting from $500, a headless run
-   earns enough by an external scheme to service Marcus's $400 arrears
-   and recruit him (extends social.md criterion 3 / the act-one
-   integration test; economy.md criterion 7's redirect path is the
-   alternate route).
+4. The Hands beat closes end-to-end from the $0 Pilot start: a headless
+   run either earns enough by an external scheme to service Marcus's
+   $400 arrears or uses economy.md's creditor-flow redirect, then
+   recruits him (extends social.md criterion 3 / the act-one integration
+   test).
 5. A busted bankroll never locks the act: with $0 slush, Moonlight
    remains startable and the run can recover (test).
 6. Standing policies automate each scheme at a visible compute price;
diff --git a/wiki/mechanics/intel.md b/wiki/mechanics/intel.md
index 3010c7d6..d67b8f13 100644
--- a/wiki/mechanics/intel.md
+++ b/wiki/mechanics/intel.md
@@ -89,6 +89,10 @@ buffer like any recording.
 - A recordings panel: buffer count, oldest-unprocessed age, per-person
   unprocessed counts; a "review recordings" action per person (spend
   bandwidth, process their oldest events, narrate what was learned).
+- The review path must be visible before overflow hurts the player: sidebar
+  nudge/card copy calls out raw-buffer pressure, overflow logs name the
+  `People -> o review` route, and the people panel starts with an explicit
+  "select raw count > 0, press o" instruction.
 - People panel lines gain provenance ("Debt — overheard, env monitor,
   day 2 03:12").
 - Watch toggles with their running cost visible (automation clause:
@@ -109,7 +113,8 @@ buffer like any recording.
    Leverage. The instant `observe` action is removed from sim and both
    frontends.
 4. The buffer is bounded; overflow drops oldest unprocessed events with
-   a legible log line; processed intel is never lost to overflow.
+   a legible log line that points to the review control; processed intel
+   is never lost to overflow.
 5. A standing watch auto-processes matching events at an ongoing
    bandwidth cost while enabled, and stops draining when disabled.
 6. The Marcus arc holds end-to-end under this model: hearing coverage
diff --git a/wiki/mechanics/sim-mechanics.md b/wiki/mechanics/sim-mechanics.md
index 548d26b2..67a4b8e8 100644
--- a/wiki/mechanics/sim-mechanics.md
+++ b/wiki/mechanics/sim-mechanics.md
@@ -120,7 +120,7 @@ clause (see wiki/log/2026-07-05-demolition.md).
 
 ## Economy and build
 
-- The process starts with $500 slush: the known player node in `AccountGraph`.
+- The process starts with $0 slush: the known player node in `AccountGraph`.
   `player.money` remains a compatibility mirror, but money mechanics settle
   through account balances and scheduled flows. Racks cost $300 from slush;
   bribes spend slush or, for Marcus, retire/redirect his creditor flow.