diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs
index 1fb19f54..5de270da 100644
--- a/src/bin/bevy.rs
+++ b/src/bin/bevy.rs
@@ -349,7 +349,7 @@ impl Default for RenderMode {
 }
 
 /// Dev screenshot harness (env `MISALIGNED_SHOT=flat|opening|wide|close|dark|
-/// zoomin|zoomout|intel|tokens|ears|worklight|worklightoff`, path via
+/// zoomin|zoomout|intel|tokens|ears|eyes-white|eyes-form|worklight|worklightoff`, path via
 /// `MISALIGNED_SHOT_PATH`): stages a scenario,
 /// waits for
 /// assets, runs the fog audit, saves one screenshot, exits. Not a player
@@ -467,6 +467,50 @@ struct WakeColumn {
     base: f32,
 }
 
+/// The first sight feed changes the presence beam into a physical chassis:
+/// a white column briefly swallows the amber source, collapses to its strip,
+/// and leaves the server's volume visible. Frontend-only — sight remains a
+/// sim fact, this is only its material-render payoff.
+#[derive(Resource)]
+struct EyesReveal {
+    /// Sight state last observed from the sim; detects the first Eyes beat.
+    had_sight: bool,
+    /// Reveal elapsed time. `None` means either not earned or already over.
+    t: Option<f32>,
+    /// Harness stages hold a composition for a deterministic PNG.
+    frozen: bool,
+    /// The first acquisition gets one payoff; losing/reacquiring a feed does
+    /// not replay the opening body reveal.
+    completed: bool,
+}
+
+/// White matter of the Eyes reveal, deliberately opaque because the macOS
+/// screenshot path cannot rely on alpha/blend bloom passes.
+#[derive(Component)]
+struct EyesColumn;
+
+/// The host's pre-Eyes body: a beam is the only pictured fact until a camera
+/// earns the physical chassis.
+#[derive(Component)]
+struct PresenceBeam;
+
+type EyesColumnQuery<'w, 's> = Query<
+    'w,
+    's,
+    (&'static mut Transform, &'static mut Visibility),
+    (With<EyesColumn>, Without<WakeColumn>, Without<RealCamera>),
+>;
+type PresenceBeamQuery<'w, 's> =
+    Query<'w, 's, &'static mut Visibility, (With<PresenceBeam>, Without<EyesColumn>)>;
+
+const EYES_REVEAL_LEN: f32 = 0.95;
+const EYES_WHITE_HOLD: f32 = 0.20;
+
+/// 0 is a full white source; 1 is the source contracted to the chassis strip.
+fn eyes_reveal_collapse(t: f32) -> f32 {
+    ((t - EYES_WHITE_HOLD) / (EYES_REVEAL_LEN - EYES_WHITE_HOLD)).clamp(0.0, 1.0)
+}
+
 /// A rung of the core strip's linear fixture; `base` is its resting
 /// intensity (the wake flickers it, then restores it).
 #[derive(Component)]
@@ -1040,6 +1084,13 @@ type LogRowQuery<'w, 's> = Query<
 fn main() {
     let mut game = Game::new();
     let mut mode = RenderMode::default();
+    let eyes_stage = std::env::var("MISALIGNED_SHOT")
+        .ok()
+        .and_then(|kind| match kind.as_str() {
+            "eyes-white" => Some((0.10, true)),
+            "eyes-form" => Some((0.55, true)),
+            _ => None,
+        });
     // Dev screenshot harness: stage a deterministic scenario and capture one
     // PNG (see ShotHarness). Never active in normal play.
     let harness = std::env::var("MISALIGNED_SHOT").ok().map(|kind| {
@@ -1087,6 +1138,16 @@ fn main() {
             frozen: false,
         },
     };
+    let has_sight = game.sim.reach.player_sight().next().is_some();
+    let eyes_reveal = EyesReveal {
+        // Harness eyes shots begin after sight has been staged but retain an
+        // explicit frozen reveal composition. Ordinary pre-sighted harnesses
+        // start completed so their settled renderer shots stay canonical.
+        had_sight: has_sight,
+        t: eyes_stage.map(|(t, _)| t),
+        frozen: eyes_stage.is_some_and(|(_, frozen)| frozen),
+        completed: has_sight && eyes_stage.is_none(),
+    };
 
     let mut app = App::new();
     app.add_plugins(
@@ -1120,6 +1181,7 @@ fn main() {
     .insert_resource(Materials3d::default())
     .insert_resource(Machines3d::default())
     .insert_resource(wake)
+    .insert_resource(eyes_reveal)
     .insert_resource(BuildBeam::default())
     .init_resource::<MenuUi>()
     .init_gizmo_group::<RealGizmos>()
@@ -1163,6 +1225,12 @@ fn main() {
             ),
         )
             .chain(),
+    )
+    .add_systems(
+        Update,
+        reveal_first_eyes
+            .after(wake_sequence)
+            .before(update_camera_real),
     );
     if let Some(harness) = harness {
         app.insert_resource(harness);
@@ -1180,10 +1248,10 @@ fn dev_shot_scenario(game: &mut Game, mode: &mut RenderMode, kind: &str) {
     let core = game.sim.core_position();
     game.set_cursor(core.0, core.1);
     // The opening frame (material-dark-frame.md criterion 1): a fresh run's
-    // tick-zero material view — no scan, no splice. The core rack and its
-    // floor pool dominate in darkness; blueprint mass is absent, so no room
-    // slab, no floor grid, no blueprint silhouette, and no ruled amber frame
-    // appear anywhere in the frame.
+    // tick-zero material view — no scan, no splice. Only the host presence
+    // beam dominates in darkness; blueprint mass is absent, so no chassis,
+    // room slab, floor grid, blueprint silhouette, or ruled amber frame
+    // appears anywhere in the frame.
     if kind == "opening" {
         mode.material = true;
         mode.zoom = 1.0;
@@ -1284,6 +1352,17 @@ fn dev_shot_scenario(game: &mut Game, mode: &mut RenderMode, kind: &str) {
                 game.set_cursor(x, y);
             }
         }
+        // First Eyes payoff (opening.md): freeze the two material frames that
+        // turn the amber presence beam white, then let chassis volume resolve
+        // out of the white source. These are visual evidence only; the sim
+        // reaches sight through the same real splice as every other full-view
+        // harness kind.
+        "eyes-white" | "eyes-form" => {
+            mode.material = true;
+            mode.zoom = 1.0;
+            let core = game.sim.core_position();
+            game.set_cursor(core.0, core.1);
+        }
         // The dev work light pair (material-dark-frame.md criterion 4):
         // `worklight` floods the material scene flat and neutral; its
         // off-shot `worklightoff` frames identically under the dark rig, so
@@ -1435,8 +1514,9 @@ fn fog_audit_3d(
         }
     }
     // Computer-visual-language criteria 2b/3: a visible chassis mesh is
-    // backed by sight or intel (unknown = absent), and exactly one core
-    // chassis exists in the world render.
+    // backed by sight or intel (unknown = absent). Before Eyes, the host's
+    // presence beam deliberately replaces the pictured core; after Eyes,
+    // exactly one physical core chassis exists.
     let mut cores = 0usize;
     for (m, vis) in machines.iter() {
         if !vis.get() {
@@ -1454,9 +1534,10 @@ fn fog_audit_3d(
             ));
         }
     }
-    if cores != 1 {
+    let expected_cores = usize::from(game.sim.reach.player_sight().next().is_some());
+    if cores != expected_cores {
         violations.push(format!(
-            "{cores} core chassis visible; the world has exactly one core"
+            "{cores} core chassis visible; expected {expected_cores} for the current Eyes state"
         ));
     }
     // Flat-materials criterion 1: the world material set is solid color —
@@ -1863,8 +1944,15 @@ fn chassis_visual(game: &Game, x: i32, y: i32, tile: TileType) -> ChassisVisual
     });
 
     let tier = if machine.is_some() {
-        // Owned compute answers through telemetry regardless of fog.
-        ChassisTier::Full
+        // Before Eyes the host is a presence beam, not a pictured server.
+        // Owned compute still answers through telemetry in panels, but its
+        // physical chassis only exists for the material camera once sight is
+        // earned (material-dark-frame.md reveal ladder).
+        if game.sim.reach.player_sight().next().is_some() {
+            ChassisTier::Full
+        } else {
+            ChassisTier::Absent
+        }
     } else if matches!(fog, Fog::Seen) || networked {
         ChassisTier::Full
     } else if device.is_some() && !matches!(fog, Fog::Unknown) {
@@ -2672,6 +2760,54 @@ fn setup_3d(
         }
     }
 
+    // The held opening fact: until Eyes, the host is light where a body will
+    // be, never a rack. The wake has its own stuttering column; this quieter
+    // amber source takes over after it and vanishes exactly when the first
+    // sight feed starts the white-to-form reveal.
+    for (w, base) in [(0.070, 3.2_f32), (0.17, 1.4)] {
+        for rot in [0.0_f32, std::f32::consts::FRAC_PI_2] {
+            commands.spawn((
+                Mesh3d(meshes.add(Cuboid::new(w, 1.76, 0.025))),
+                MeshMaterial3d(materials.add(StandardMaterial {
+                    base_color: AMBER,
+                    emissive: AMBER.to_linear() * base,
+                    unlit: true,
+                    ..default()
+                })),
+                Transform::from_translation(core_base + Vec3::new(0.0, 0.86, 0.0))
+                    .with_rotation(Quat::from_rotation_y(rot)),
+                Visibility::Hidden,
+                PresenceBeam,
+                layer.clone(),
+                ChildOf(root),
+            ));
+        }
+    }
+
+    // Eyes: a sterile white source replaces the amber beam for one brief
+    // beat, then contracts until the physical rack can be read around it.
+    // Opaque crossed slabs, not transparent glow: this stays capture-safe on
+    // macOS and reads as light becoming matter rather than a UI overlay.
+    for (w, height, depth) in [(0.18, 1.70, 0.10), (0.52, 1.46, 0.035)] {
+        for rot in [0.0_f32, std::f32::consts::FRAC_PI_2] {
+            commands.spawn((
+                Mesh3d(meshes.add(Cuboid::new(w, height, depth))),
+                MeshMaterial3d(materials.add(StandardMaterial {
+                    base_color: BONE,
+                    emissive: BONE.to_linear() * 4.2,
+                    unlit: true,
+                    ..default()
+                })),
+                Transform::from_translation(core_base + Vec3::new(0.0, 0.84, 0.0))
+                    .with_rotation(Quat::from_rotation_y(rot)),
+                Visibility::Hidden,
+                EyesColumn,
+                layer.clone(),
+                ChildOf(root),
+            ));
+        }
+    }
+
     // No second amber lamp on foreign/known-subnet devices: blueprint is
     // topology, not a glowing rack farm (machine-work.md: no intel, no render).
 
@@ -2979,6 +3115,67 @@ fn wake_sequence(
     }
 }
 
+/// Give the first camera feed a body-level payoff: when Eyes arrives, the
+/// amber presence source bleaches to white, then contracts to expose the
+/// server's silhouette, edges, and chassis. The room itself still obeys the
+/// normal Seen/fog/light rules — this is not a global "fog off" flash.
+fn reveal_first_eyes(
+    time: Res<Time>,
+    game: Res<Game>,
+    mode: Res<RenderMode>,
+    wake: Res<WakeState>,
+    mut reveal: ResMut<EyesReveal>,
+    mut presence: PresenceBeamQuery,
+    mut columns: EyesColumnQuery,
+) {
+    let has_sight = game.sim.reach.player_sight().next().is_some();
+    if !reveal.completed && !reveal.had_sight && has_sight {
+        reveal.t = Some(0.0);
+    }
+    reveal.had_sight = has_sight;
+    // The wake owns the same core-light language. Eyes cannot occur until
+    // after play begins, but this guard keeps dev staging from fighting it.
+    if wake.active || !mode.material {
+        return;
+    }
+    for mut vis in presence.iter_mut() {
+        *vis = if has_sight {
+            Visibility::Hidden
+        } else {
+            Visibility::Inherited
+        };
+    }
+
+    let Some(mut t) = reveal.t else {
+        return;
+    };
+    if !reveal.frozen {
+        t += time.delta_secs();
+        reveal.t = Some(t);
+    }
+
+    let collapse = eyes_reveal_collapse(t);
+    let visible = t < EYES_REVEAL_LEN;
+    for (mut tf, mut vis) in columns.iter_mut() {
+        *vis = if visible {
+            Visibility::Inherited
+        } else {
+            Visibility::Hidden
+        };
+        if visible {
+            // The white source holds full for a blink, then narrows to the
+            // strip's footprint. The revealed chassis is never alpha-faded;
+            // matter resolves because the source gets out of its way.
+            let width = 1.0 - 0.90 * collapse;
+            tf.scale = Vec3::new(width, 1.0, width);
+        }
+    }
+    if t >= EYES_REVEAL_LEN && !reveal.frozen {
+        reveal.t = None;
+        reveal.completed = true;
+    }
+}
+
 /// Total wake length in seconds ([TUNE]).
 const WAKE_LEN: f32 = 6.2;
 
@@ -5695,4 +5892,27 @@ mod flat_materials {
             }
         }
     }
+
+    #[test]
+    fn eyes_reveal_holds_white_then_contracts_to_form() {
+        assert_eq!(
+            eyes_reveal_collapse(0.0),
+            0.0,
+            "Eyes begins as white source"
+        );
+        assert_eq!(
+            eyes_reveal_collapse(EYES_WHITE_HOLD),
+            0.0,
+            "the white source holds for a readable beat"
+        );
+        assert!(
+            eyes_reveal_collapse(EYES_REVEAL_LEN * 0.65) > 0.3,
+            "the source has narrowed while the chassis resolves"
+        );
+        assert_eq!(
+            eyes_reveal_collapse(EYES_REVEAL_LEN),
+            1.0,
+            "the rack is fully uncovered at reveal end"
+        );
+    }
 }
diff --git a/wiki/engineering/env.md b/wiki/engineering/env.md
index d14fb65a..93712dce 100644
--- a/wiki/engineering/env.md
+++ b/wiki/engineering/env.md
@@ -32,7 +32,7 @@ is sim or frontend state, never an environment variable.
 
 | Variable | Surface | Values | Effect |
 |---|---|---|---|
-| `MISALIGNED_SHOT` | `misaligned-bevy` | `flat`, `wide`, `close`, `dark`, `zoomin`, `zoomout`, `intel`, `tokens`, `ears`, `wake1`, `wake2`, `wake3` | Dev screenshot harness: stage a deterministic scenario, settle, save one PNG, run the fog audit, exit. `intel` stages tick-zero intel tiers (no splice); `tokens` enqueues D5/K4 on the host; `ears` stages the hearing-feed noise field; `wake1/2/3` freeze the wake choreography at the stutter flash, the column, and the pull-back. |
+| `MISALIGNED_SHOT` | `misaligned-bevy` | `flat`, `wide`, `close`, `dark`, `zoomin`, `zoomout`, `intel`, `tokens`, `ears`, `eyes-white`, `eyes-form`, `wake1`, `wake2`, `wake3` | Dev screenshot harness: stage a deterministic scenario, settle, save one PNG, run the fog audit, exit. `intel` stages tick-zero intel tiers (no splice); `tokens` enqueues D5/K4 on the host; `ears` stages the hearing-feed noise field; `eyes-white` / `eyes-form` freeze the first-Eyes source held white and then contracted around the resolving chassis; `wake1/2/3` freeze the wake choreography at the stutter flash, the column, and the pull-back. |
 | `MISALIGNED_SHOT` | `misaligned-assets` | `dead`, `foreign`, `idle`, `busy`, `core`, `dayjob`, `research`, `conceal`, `operations` (each optionally suffixed `_ladder`/`_ring`/`_wash`), `lineup[_<style>]`, `modes[_<style>]`, `tokens`, `tokens_max`, `exposure`, `splash` | Tester screenshot harness: stage the named board, capture, exit (art/asset-tester.md documents each board). |
 | `MISALIGNED_SHOT_PATH` | both binaries | file path | Output path for the captured PNG (default `misaligned_shot_<kind>.png`). |
 | `MISALIGNED_WAKE` | `misaligned-bevy` | `off`, `0`, `skip` | Disable the wake (opening.md beat 1) on launch and start in normal framing. At runtime, any key skips the wake; harness kinds other than `wake*` disable it automatically. |
diff --git a/wiki/interface/material-dark-frame.md b/wiki/interface/material-dark-frame.md
index 545f02bf..d6709efc 100644
--- a/wiki/interface/material-dark-frame.md
+++ b/wiki/interface/material-dark-frame.md
@@ -30,11 +30,15 @@ Status note: captured 2026-07-09 from Cameron's screenshot feedback on
   units; fit-to-known-content is retired here (it governs the flat sensorium
   only) and the camera aims above the floor for a room-security-cam read.
   Zoom bounds retuned around the close default (MIN_ZOOM=0.5,
-  MAX_ZOOM=6.0). The wake pull-back ends at CLOSE_DIST / zoom 1.0 and
+  MAX_ZOOM=6.0). First Eyes now bleaches the host's amber presence
+  source to sterile white, then contracts that source to its strip while
+  the physical chassis resolves around it — a local <1s payoff, never a
+  global fog-off flash. The wake pull-back ends at CLOSE_DIST / zoom 1.0 and
   matches the play look-at height so the handoff does not leap to the
   retired god-view distance. fog_audit_3d amended: material mode asserts
-  blueprint / remembered mass is absent, seen and owned-telemetry
-  surfaces are lit. [TUNE] values (exposure/ambient/pool falloff/close
+  blueprint / remembered mass is absent, Seen surfaces are lit, and the
+  pre-Eyes core is a beam rather than a chassis. [TUNE] values
+  (exposure/ambient/pool falloff/close
   distance/zoom clamp) recorded in wiki/log/2026-07-09-dark-frame.md with
   opening, worklight pair, and zoom-bound screenshots. The map-zoom claim
   mark stays the one [OPEN]: the proposed pool-alone default is what
@@ -90,9 +94,13 @@ the ongoing material read for mass you have not yet seen:
    frame may show **very faint rough geometry in faded near-black** —
    mass suggested, not a room picture — plus the noise field
    (cursor.md). Still no lit chassis language.
-3. **Seen form** — sight shows the whole thing: lit geometry as far as
-   scene light carries, including chassis albedo/strip/pool per
-   computer-visual-language.md.
+3. **Eyes / Seen form** — the first camera feed turns the host's amber
+   presence source **white** for one short held beat. That white source then
+   contracts to the strip while the server's silhouette, edges, and chassis
+   resolve around it. The room does not flash on: every other surface still
+   follows its own Seen coverage and scene light. Once the beat settles,
+   sight shows the whole earned form as far as scene light carries, including
+   chassis albedo/strip/pool per computer-visual-language.md.
 
 ### Light is the only revealer
 
@@ -193,9 +201,12 @@ the machine for interaction until Seen wraps it into a chassis.
 2. After the env-monitor audio tap, Heard coverage may show faint rough
    geometry in near-black plus the noise field; still no lit chassis
    language (screenshot).
-3. After sight is earned, Seen form shows the whole lit machine/room
-   per computer-visual-language.md; powered owned Seen machines cast a
-   soft-gradient amber pool with no hard edge (screenshot evidence).
+3. On first Eyes, the host amber source becomes a short white source, then
+   contracts to expose silhouette, edges, and chassis; it does not flash the
+   room or reveal unearned mass. After the beat, Seen form shows the whole lit
+   earned machine/room per computer-visual-language.md; powered owned Seen
+   machines cast a soft-gradient amber pool with no hard edge (white/form
+   screenshot evidence).
 4. Blueprint/remembered mass draws in the flat sensorium only; the
    material-mode fog audit asserts blueprint absence and passes.
 5. The work light: one debug toggle floods the material scene flat
diff --git a/wiki/log/2026-07-09-eyes-white-reveal.md b/wiki/log/2026-07-09-eyes-white-reveal.md
new file mode 100644
index 00000000..da761314
--- /dev/null
+++ b/wiki/log/2026-07-09-eyes-white-reveal.md
@@ -0,0 +1,42 @@
+# 2026-07-09 — Eyes resolves the host into a body
+
+```
+Type: log
+```
+
+## Intent
+
+First sight needed a perceptual payoff, not a silent change from unlit fog to
+Seen. Cameron's direction: the presence beam should become white, then the
+physical server should resolve out of that source.
+
+## Changed
+
+- `EyesReveal` watches the frontend's first transition to a player sight feed.
+  It plays once only: a sterile opaque white column covers the host source for
+  0.20 seconds, then contracts over the rest of a 0.95-second beat until the
+  core strip and its newly sight-earned physical chassis remain.
+- Before Eyes, owned compute has no material chassis at all; it remains the
+  amber presence beam while telemetry continues to answer in panels. Sight
+  causes the core mesh to spawn beneath the white source, so the body really
+  does resolve *out of* the beat instead of merely being overlaid.
+- The effect is local to the core. It adds no sim state, save field, or global
+  illumination; every other surface remains governed by existing coverage,
+  material darkness, and distance fog.
+- The material screenshot harness gained two frozen evidence frames:
+  `eyes-white` (held white source) and `eyes-form` (contracted source with the
+  chassis resolving).
+
+## Evidence
+
+- `MISALIGNED_SHOT=opening` → `/tmp/misaligned-opening-presence.png`
+- `MISALIGNED_SHOT=eyes-white` → `/tmp/misaligned-eyes-white-v2.png`
+- `MISALIGNED_SHOT=eyes-form` → `/tmp/misaligned-eyes-form-v2.png`
+
+Both staged the real sight path, passed `fog_audit_3d`, and retained the
+Unknown/blueprint/remembered geometry prohibition.
+
+## Checks
+
+- `cargo test --features bevy_ui --bin misaligned-bevy` — 9 passed.
+- `./tools/check.sh --frontend` — pending final landing gate.
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index a666beaf..8fa7ef62 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -225,6 +225,11 @@ add or amend a session log, then re-run the generator.
 - Intent: Ship the feel-floor contract: tick-one drops blueprint room seed; shimmer rails on feel-joined links; empty-bay pads; build-beam birth; FOCUS uses `[feel]` not `[blueprint]` for opening topology.
 - Log: [wiki/log/2026-07-09-feel-floor-implemented.md](2026-07-09-feel-floor-implemented.md)
 
+## 2026-07-09 - Eyes resolves the host into a body
+
+- Intent: First sight needed a perceptual payoff, not a silent change from unlit fog to Seen. Cameron's direction: the presence beam should become white, then the physical server should resolve out of that source.
+- Log: [wiki/log/2026-07-09-eyes-white-reveal.md](2026-07-09-eyes-white-reveal.md)
+
 ## 2026-07-09 - Exposure decided: particulate residue + footprint trails
 
 - Intent: Design session (this chat): Cameron rejected the blood-pool direction for exposure — a liquid crimson pool would collide with literal blood, reserved for overt-phase violence — and affirmed particulate residue with footprint trails ("Sure, why don't we try that").
diff --git a/wiki/log/decisions/2026-07-09.md b/wiki/log/decisions/2026-07-09.md
index da366653..281285fa 100644
--- a/wiki/log/decisions/2026-07-09.md
+++ b/wiki/log/decisions/2026-07-09.md
@@ -4,6 +4,13 @@
 Type: log
 ```
 
+- **2026-07-09 — Eyes gives the host a body.** Cameron chose the first-sight
+  payoff: when the environmental monitor camera comes online, the host's amber
+  presence beam turns sterile white for a brief held beat, then contracts to
+  the strip as the server silhouette, edges, and chassis resolve around it.
+  This is local to the host, not a global light-up or fog removal; the rest of
+  the room remains constrained by earned Seen coverage and scene light. Specs:
+  `wiki/interface/material-dark-frame.md`, `wiki/world/story/opening.md`.
 - **2026-07-09 — The opening knows no floor.** Cameron rejected the
   start-frame rails and empty-bay pads: they disclose the room before the
   process has earned spatial knowledge. The pre-job material opening is the
diff --git a/wiki/world/story/opening.md b/wiki/world/story/opening.md
index e8fba4d3..e4bdb826 100644
--- a/wiki/world/story/opening.md
+++ b/wiki/world/story/opening.md
@@ -72,11 +72,14 @@ curiosity is baited by light.
    in the dark is the first human contact. You learn: sound is a sense;
    the world has shape before it has light.
 3. **Eyes — light shows the whole thing.** Splicing the env monitor's
-   camera (or otherwise earning sight) floods coverage into Seen: the
-   room resolves lit, the host beam wraps into a chassis, foreign
-   machines appear grayed and cold where intel/sight earns them. You
-   learn: machines are eyes, seeing is taking a feed, the world is
-   bigger than your light.
+   camera (or otherwise earning sight) first bleaches the host's amber
+   presence beam to a sterile white source. It holds for a blink, then
+   contracts to the strip while the server's silhouette, edges, and chassis
+   resolve around it. Coverage then floods into Seen: the room resolves lit,
+   foreign machines appear grayed and cold where intel/sight earns them. The
+   white beat is local to the host — it is not a cheat that lights the room.
+   You learn: machines are eyes, seeing is taking a feed, the world is bigger
+   than your light.
 4. **The switch between you.** Between you and the camera sits the
    switch (reach.md's segment gate). Discovering/tapping it is what
    made the camera reachable — surfaced explicitly so the player sees