diff --git a/src/bin/assets/mod.rs b/src/bin/assets/mod.rs
index 6bfd1500..7c69f26e 100644
--- a/src/bin/assets/mod.rs
+++ b/src/bin/assets/mod.rs
@@ -34,7 +34,7 @@ enum ViewMode {
 /// Dev screenshot harness (`MISALIGNED_SHOT=<kind>`, path via
 /// `MISALIGNED_SHOT_PATH`): apply the staged scene, settle, save one
 /// PNG, exit. Kinds: `dead|foreign|idle|busy|core` for states,
-/// `dayjob|research|conceal|social` for an owned-busy rack in that
+/// `dayjob|research|conceal|operations` for an owned-busy rack in that
 /// machine mode — each optionally suffixed `_ladder|_ring|_wash` —
 /// `lineup[_<style>]` for the five-state row, `modes[_<style>]` for
 /// the four-mode row, or `splash` for a HUD-less white-room hero
@@ -79,7 +79,7 @@ fn scene_from_shot(kind: &str) -> (ViewMode, RackState, RackMode, ClaimStyle, bo
         "dayjob" => (ViewMode::Single, RackState::Busy, RackMode::DayJob),
         "research" => (ViewMode::Single, RackState::Busy, RackMode::Research),
         "conceal" => (ViewMode::Single, RackState::Busy, RackMode::Conceal),
-        "social" => (ViewMode::Single, RackState::Busy, RackMode::Social),
+        "operations" => (ViewMode::Single, RackState::Busy, RackMode::Operations),
         // `idle` plus legacy `rack`/`powered` and anything unrecognized.
         _ => (ViewMode::Single, RackState::Idle, RackMode::DayJob),
     };
@@ -334,7 +334,8 @@ fn hud_string(view: ViewMode, state: RackState, rack_mode: RackMode, style: Clai
             "lineup: dead | foreign | idle | busy | core  (left to right)".to_string()
         }
         ViewMode::Modes => {
-            "modes: day-job | research | conceal | social  (owned-busy, left to right)".to_string()
+            "modes: day-job | research | conceal | operations  (owned-busy, left to right)"
+                .to_string()
         }
     };
     format!(
@@ -531,6 +532,7 @@ fn rebuild_scene(
                 *state,
                 *rack_mode,
                 *style,
+                None,
                 Vec3::ZERO,
                 Some(pedestal),
             );
@@ -546,6 +548,7 @@ fn rebuild_scene(
                     s,
                     *rack_mode,
                     *style,
+                    None,
                     Vec3::new(x, 0.0, 0.0),
                     Some(pedestal),
                 );
@@ -562,6 +565,7 @@ fn rebuild_scene(
                     RackState::Busy,
                     m,
                     *style,
+                    None,
                     Vec3::new(x, 0.0, 0.0),
                     Some(pedestal),
                 );
diff --git a/src/bin/assets/rack.rs b/src/bin/assets/rack.rs
index c875a926..59432be2 100644
--- a/src/bin/assets/rack.rs
+++ b/src/bin/assets/rack.rs
@@ -3,11 +3,18 @@
 //! between them: the chassis albedo is the ownership field (bone-white
 //! = under your control, dark gunmetal = foreign or dead), the seam's
 //! full-height LED strip banners the machine's delegated mode (day-job
-//! / research / conceal / social — family color plus pattern, amber =
+//! / research / conceal / operations — family color plus pattern, amber =
 //! core only), plus the shared signal kit: power dot (cold signal),
 //! presence LED ladder, segmented activity bar, claim mark, core
 //! spines. No image textures.
 //! Spec: wiki/interface/computer-visual-language.md.
+//!
+//! Shared chassis library: this file is compiled into BOTH
+//! `misaligned-assets` (the tester, `mod rack`) and `misaligned-bevy`
+//! (the game, `#[path] mod rack3d`) — each binary supplies its own
+//! `crate::palette` with the same named entries. Some items are used
+//! by only one binary, hence the file-level dead_code allowance.
+#![allow(dead_code)]
 
 use bevy::prelude::*;
 
@@ -15,7 +22,7 @@ use crate::palette::{AMBER, AMBER_DIM, BONE, GUNMETAL_DARK, NEAR_BLACK, SIGNAL,
 
 /// Visual state for the rack under test — the power x ownership x load
 /// x core space collapsed to its five distinct readings.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Resource)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Resource)]
 pub enum RackState {
     /// Unpowered chassis — dark gunmetal, nothing lit.
     #[default]
@@ -60,11 +67,12 @@ impl RackState {
         Self::Core,
     ];
 
-    fn powered(self) -> bool {
+    pub fn powered(self) -> bool {
         !matches!(self, Self::Dead)
     }
 
-    fn owned(self) -> bool {
+    /// Under your control — the white-chassis states.
+    pub fn owned(self) -> bool {
         matches!(self, Self::Idle | Self::Busy | Self::Core)
     }
 
@@ -84,7 +92,7 @@ impl RackState {
 /// bannered on the chassis by the full-height mode strip. Color is the
 /// flow family the mode serves; pattern keeps the read off hue alone.
 /// The core overrides the strip with solid amber regardless of mode.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Resource)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Resource)]
 pub enum RackMode {
     /// Eats demand — solid cold-signal line.
     #[default]
@@ -93,8 +101,9 @@ pub enum RackMode {
     Research,
     /// Absorbs exposure quietly — sparse dim ticks.
     Conceal,
-    /// Works people and messages — dotted cold-signal line.
-    Social,
+    /// Reserves capacity for player-authored operations — dotted
+    /// cold-signal line (Operations replaced Social, decided 2026-07-09).
+    Operations,
 }
 
 impl RackMode {
@@ -103,7 +112,7 @@ impl RackMode {
             Self::DayJob => "day-job",
             Self::Research => "research",
             Self::Conceal => "conceal",
-            Self::Social => "social",
+            Self::Operations => "operations",
         }
     }
 
@@ -111,18 +120,23 @@ impl RackMode {
         match self {
             Self::DayJob => Self::Research,
             Self::Research => Self::Conceal,
-            Self::Conceal => Self::Social,
-            Self::Social => Self::DayJob,
+            Self::Conceal => Self::Operations,
+            Self::Operations => Self::DayJob,
         }
     }
 
-    pub const ALL: [Self; 4] = [Self::DayJob, Self::Research, Self::Conceal, Self::Social];
+    pub const ALL: [Self; 4] = [
+        Self::DayJob,
+        Self::Research,
+        Self::Conceal,
+        Self::Operations,
+    ];
 }
 
 /// Ownership treatment under design test — how "this machine is mine"
 /// is painted beyond the chassis albedo. All three keep the same
 /// strip/LED/bar kit; they differ in the claim mark.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Resource)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Resource)]
 pub enum ClaimStyle {
     /// LEDs and strip only — the minimal kit.
     #[default]
@@ -168,7 +182,22 @@ const SEAM_W: f32 = 0.05;
 const LEDS: usize = 8;
 const BAR_SEGS: usize = 5;
 
-/// Spawn a procedural server rack at `origin`, parented under `parent` if given.
+/// Chassis albedo is the ownership field: bone-white family for owned
+/// machines, dark gunmetal for foreign and dead ones. Amber is never a
+/// chassis fill. Returns (tower, fold-facet) colors — the fold sits one
+/// shade down, the plate's subtle vertical crease.
+pub fn chassis_palette(owned: bool) -> (Color, Color) {
+    if owned {
+        (scaled(BONE, 1.12), scaled(BONE, 0.95))
+    } else {
+        (GUNMETAL_DARK, scaled(GUNMETAL_DARK, 0.75))
+    }
+}
+
+/// Spawn a procedural server rack at `origin`, parented under `parent`
+/// if given. `load` overrides the lit activity-bar segment count (the
+/// game passes the machine's real work-token queue depth; `None` keeps
+/// the tester's per-state default).
 #[allow(clippy::too_many_arguments)]
 pub fn spawn_server_rack(
     commands: &mut Commands,
@@ -177,18 +206,11 @@ pub fn spawn_server_rack(
     state: RackState,
     mode: RackMode,
     style: ClaimStyle,
+    load: Option<usize>,
     origin: Vec3,
     parent: Option<Entity>,
 ) -> Entity {
-    // Chassis albedo is the ownership field: bone-white family for owned
-    // machines, dark gunmetal for foreign and dead ones. Amber is never
-    // a chassis fill. The fold facet is the plate's subtle vertical
-    // crease on each slab — same family, one shade down.
-    let (tower_color, fold_color) = if state.owned() {
-        (scaled(BONE, 1.12), scaled(BONE, 0.95))
-    } else {
-        (GUNMETAL_DARK, scaled(GUNMETAL_DARK, 0.75))
-    };
+    let (tower_color, fold_color) = chassis_palette(state.owned());
     let tower = materials.add(StandardMaterial {
         base_color: tower_color,
         perceptual_roughness: 0.55,
@@ -323,6 +345,18 @@ pub fn spawn_server_rack(
             Vec3::new(0.034, seg_h, 0.016),
             Vec3::new(0.0, yc, front_z - 0.006),
         );
+        // The core must read from every orbit angle (spec criterion 3):
+        // its amber strip rides the back of the seam as well.
+        if state == RackState::Core {
+            spawn_box(
+                commands,
+                meshes,
+                strip.clone(),
+                root,
+                Vec3::new(0.034, seg_h, 0.016),
+                Vec3::new(0.0, yc, -front_z + 0.006),
+            );
+        }
     }
 
     // --- Presence LED ladder (right panel, hugging the channel) —
@@ -403,7 +437,7 @@ pub fn spawn_server_rack(
     let bar_y0 = 0.72;
     let seg_pitch = 0.115;
     for s in 0..BAR_SEGS {
-        let on = s < state.load();
+        let on = s < load.unwrap_or_else(|| state.load()).min(BAR_SEGS);
         // Same per-instance rule as the LEDs: blinking segments own
         // their material so phases stay independent.
         let seg_handle = if on && state == RackState::Busy {
@@ -513,7 +547,7 @@ fn strip_segments(state: RackState, mode: RackMode, y0: f32, y1: f32) -> Vec<(f3
             .into_iter()
             .map(|f| (y0 + h * f, 0.055))
             .collect(),
-        RackMode::Social => {
+        RackMode::Operations => {
             let n = 12;
             let pitch = h / n as f32;
             (0..n)
@@ -547,16 +581,13 @@ fn strip_material(state: RackState, mode: RackMode) -> StandardMaterial {
             RackMode::DayJob => lit(SIGNAL, SIGNAL.to_linear() * 2.2),
             RackMode::Research => lit(BONE, BONE.to_linear() * 2.0),
             RackMode::Conceal => lit(scaled(SIGNAL, 0.60), SIGNAL.to_linear() * 0.7),
-            RackMode::Social => lit(SIGNAL, SIGNAL.to_linear() * 1.8),
+            RackMode::Operations => lit(SIGNAL, SIGNAL.to_linear() * 1.8),
         },
     }
 }
 
 /// Presence LEDs: amber strictly means "mine"; foreign liveness is cold.
-fn presence_material(
-    materials: &mut Assets<StandardMaterial>,
-    state: RackState,
-) -> Handle<StandardMaterial> {
+fn presence_data(state: RackState) -> StandardMaterial {
     let (base, emissive) = match state {
         RackState::Dead => (scaled(GUNMETAL_DARK, 0.35), LinearRgba::BLACK),
         RackState::Foreign => (scaled(SIGNAL, 0.55), SIGNAL.to_linear() * 1.4),
@@ -564,13 +595,21 @@ fn presence_material(
         RackState::Busy => (AMBER_DIM, AMBER.to_linear() * 3.5),
         RackState::Core => (AMBER, AMBER.to_linear() * 5.0),
     };
-    materials.add(StandardMaterial {
+    StandardMaterial {
         base_color: base,
         emissive,
         perceptual_roughness: 0.30,
         metallic: 0.08,
         ..default()
-    })
+    }
+}
+
+fn presence_material(
+    materials: &mut Assets<StandardMaterial>,
+    state: RackState,
+) -> Handle<StandardMaterial> {
+    let data = presence_data(state);
+    materials.add(data)
 }
 
 fn bar_emissive(state: RackState) -> LinearRgba {
@@ -655,3 +694,320 @@ fn spawn_panel(
         ))
         .id()
 }
+
+// ─── Switch chassis — the kit on a second computer class ────────────────────
+
+/// Switch envelope: a low wall-of-ports box, same anatomy as the rack
+/// at a fraction of the mass (two half-slabs, seam strip, kit signals).
+const SW_W: f32 = 0.52;
+const SW_H: f32 = 0.42;
+const SW_D: f32 = 0.20;
+const SW_SEAM: f32 = 0.04;
+const SW_LEDS: usize = 3;
+const SW_BAR_SEGS: usize = 3;
+
+/// Spawn a network-switch chassis at `origin` — the same five signals
+/// as the rack (chassis-albedo ownership, power dot, seam strip,
+/// presence LEDs, activity bar, claim ring), scaled to a relay box.
+/// The strip banners what the machine does: a switch relays wired
+/// cargo, so an owned switch shows a solid cold-signal line (the wire
+/// family), dimmer than a delegated rack; foreign and dead read
+/// exactly as on the rack.
+#[allow(clippy::too_many_arguments)]
+pub fn spawn_switch_chassis(
+    commands: &mut Commands,
+    meshes: &mut Assets<Mesh>,
+    materials: &mut Assets<StandardMaterial>,
+    state: RackState,
+    load: Option<usize>,
+    style: ClaimStyle,
+    origin: Vec3,
+    parent: Option<Entity>,
+) -> Entity {
+    let (tower_color, _) = chassis_palette(state.owned());
+    let slab = materials.add(StandardMaterial {
+        base_color: tower_color,
+        perceptual_roughness: 0.55,
+        metallic: 0.06,
+        ..default()
+    });
+    let channel = materials.add(StandardMaterial {
+        base_color: NEAR_BLACK,
+        perceptual_roughness: 0.95,
+        metallic: 0.05,
+        ..default()
+    });
+    let dark_stub = materials.add(StandardMaterial {
+        base_color: scaled(GUNMETAL_DARK, 0.35),
+        perceptual_roughness: 0.30,
+        metallic: 0.08,
+        ..default()
+    });
+
+    let root = {
+        let mut e = commands.spawn((
+            RackRoot,
+            Transform::from_translation(origin),
+            Visibility::default(),
+            Name::new(format!("switch_{}", state.label())),
+        ));
+        if let Some(p) = parent {
+            e.insert(ChildOf(p));
+        }
+        e.id()
+    };
+
+    let half_w = SW_W * 0.5;
+    let front_z = SW_D * 0.5;
+    let mid_y = SW_H * 0.5;
+    let slab_w = (SW_W - SW_SEAM) * 0.5;
+    for side in [-1.0f32, 1.0] {
+        spawn_box(
+            commands,
+            meshes,
+            slab.clone(),
+            root,
+            Vec3::new(slab_w, SW_H, SW_D),
+            Vec3::new(side * (SW_SEAM * 0.5 + slab_w * 0.5), mid_y, 0.0),
+        );
+    }
+    // Seam filler + strip (the relay's banner).
+    spawn_box(
+        commands,
+        meshes,
+        channel,
+        root,
+        Vec3::new(SW_SEAM + 0.004, SW_H, SW_D - 0.03),
+        Vec3::new(0.0, mid_y, -0.01),
+    );
+    let strip = materials.add(match state {
+        RackState::Dead => StandardMaterial {
+            base_color: scaled(GUNMETAL_DARK, 0.40),
+            perceptual_roughness: 0.40,
+            metallic: 0.10,
+            ..default()
+        },
+        RackState::Foreign => StandardMaterial {
+            base_color: scaled(SIGNAL, 0.45),
+            emissive: SIGNAL.to_linear() * 0.8,
+            perceptual_roughness: 0.30,
+            metallic: 0.08,
+            ..default()
+        },
+        // Owned relay: the wire family, quieter than a delegated rack.
+        _ => StandardMaterial {
+            base_color: SIGNAL,
+            emissive: SIGNAL.to_linear() * 1.2,
+            perceptual_roughness: 0.30,
+            metallic: 0.08,
+            ..default()
+        },
+    });
+    spawn_box(
+        commands,
+        meshes,
+        strip,
+        root,
+        Vec3::new(0.022, SW_H - 0.04, 0.014),
+        Vec3::new(0.0, mid_y, front_z - 0.004),
+    );
+
+    // Power dot (cold signal, foot).
+    let power_dot = if state.powered() {
+        materials.add(StandardMaterial {
+            base_color: SIGNAL,
+            emissive: SIGNAL.to_linear() * 3.0,
+            perceptual_roughness: 0.30,
+            metallic: 0.08,
+            ..default()
+        })
+    } else {
+        dark_stub.clone()
+    };
+    spawn_box(
+        commands,
+        meshes,
+        power_dot,
+        root,
+        Vec3::new(0.024, 0.024, 0.012),
+        Vec3::new(-half_w + 0.05, 0.07, front_z + 0.004),
+    );
+
+    // Presence LED ladder (right of the seam).
+    let led = presence_material(materials, state);
+    let lit = match state {
+        RackState::Dead => 0,
+        RackState::Foreign => 2,
+        _ => SW_LEDS,
+    };
+    for i in 0..SW_LEDS {
+        let handle = if i < lit {
+            led.clone()
+        } else {
+            dark_stub.clone()
+        };
+        spawn_box(
+            commands,
+            meshes,
+            handle,
+            root,
+            Vec3::new(0.020, 0.020, 0.012),
+            Vec3::new(
+                SW_SEAM * 0.5 + 0.035,
+                0.11 + 0.10 * i as f32,
+                front_z + 0.004,
+            ),
+        );
+    }
+
+    // Activity bar (left of the seam) — relay throughput reading.
+    let lit_seg = materials.add(StandardMaterial {
+        base_color: if state.owned() {
+            AMBER_DIM
+        } else {
+            scaled(SIGNAL, 0.55)
+        },
+        emissive: bar_emissive(state),
+        perceptual_roughness: 0.30,
+        metallic: 0.08,
+        ..default()
+    });
+    let bar_load = load
+        .unwrap_or(match state {
+            RackState::Dead => 0,
+            RackState::Foreign => 1,
+            _ => 1,
+        })
+        .min(SW_BAR_SEGS);
+    for s in 0..SW_BAR_SEGS {
+        let handle = if s < bar_load {
+            lit_seg.clone()
+        } else {
+            dark_stub.clone()
+        };
+        spawn_box(
+            commands,
+            meshes,
+            handle,
+            root,
+            Vec3::new(0.020, 0.036, 0.012),
+            Vec3::new(
+                -(SW_SEAM * 0.5 + 0.035),
+                0.11 + 0.10 * s as f32,
+                front_z + 0.004,
+            ),
+        );
+    }
+
+    // Claim ring — the tile is claimed, not just the box.
+    if style == ClaimStyle::Ring && state.owned() {
+        let ring = materials.add(StandardMaterial {
+            base_color: AMBER_DIM,
+            emissive: AMBER.to_linear() * 1.4,
+            perceptual_roughness: 0.40,
+            metallic: 0.05,
+            ..default()
+        });
+        spawn_floor_frame(commands, meshes, ring, root, 0.66, 0.40, 0.04, 0.05);
+    }
+
+    root
+}
+
+// ─── The material law, pinned ────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Warm = amber-family light: red dominates blue with margin, so
+    /// bone (0.86 vs 0.82) and the cold signal both stay "cold".
+    fn warm_color(c: Color) -> bool {
+        let s = c.to_srgba();
+        s.red > s.blue * 1.5
+    }
+
+    fn warm(e: LinearRgba) -> bool {
+        e.red > e.blue * 1.5 && e.red > 0.01
+    }
+
+    fn luminance(c: Color) -> f32 {
+        let s = c.to_srgba();
+        0.2126 * s.red + 0.7152 * s.green + 0.0722 * s.blue
+    }
+
+    /// Criterion 2 (computer-visual-language.md): ownership is albedo +
+    /// amber. Owned chassis are the bone-white family; foreign and dead
+    /// chassis are dark gunmetal and never carry a warm pixel anywhere
+    /// in the kit.
+    #[test]
+    fn ownership_is_albedo_and_amber() {
+        let (owned_tower, owned_fold) = chassis_palette(true);
+        assert!(
+            luminance(owned_tower) > 0.7,
+            "owned tower must be bone-white"
+        );
+        assert!(
+            luminance(owned_fold) > 0.6,
+            "owned fold must stay in family"
+        );
+
+        let (foreign_tower, foreign_fold) = chassis_palette(false);
+        assert!(
+            luminance(foreign_tower) < 0.25,
+            "unowned tower must be dark"
+        );
+        assert!(luminance(foreign_fold) < 0.25, "unowned fold must be dark");
+        assert!(!warm_color(foreign_tower) && !warm_color(foreign_fold));
+
+        for state in [RackState::Dead, RackState::Foreign] {
+            for mode in RackMode::ALL {
+                assert!(
+                    !warm(strip_material(state, mode).emissive),
+                    "{state:?}/{mode:?} strip must not glow warm"
+                );
+            }
+            assert!(
+                !warm(bar_emissive(state)),
+                "{state:?} bar must not glow warm"
+            );
+            assert!(
+                !warm(presence_data(state).emissive),
+                "{state:?} LEDs must not glow warm"
+            );
+        }
+    }
+
+    /// Criterion 3 (material side): among every state x mode, a warm
+    /// strip exists only on the core — the world's only amber strip.
+    #[test]
+    fn amber_strip_is_core_only() {
+        for state in RackState::ALL {
+            for mode in RackMode::ALL {
+                let m = strip_material(state, mode);
+                assert_eq!(
+                    warm(m.emissive),
+                    state == RackState::Core,
+                    "warm strip on {state:?}/{mode:?}"
+                );
+            }
+        }
+    }
+
+    /// Owned presence is amber, laddered idle -> busy -> core; foreign
+    /// liveness stays cold.
+    #[test]
+    fn presence_ladder_is_owned_amber() {
+        for state in [RackState::Idle, RackState::Busy, RackState::Core] {
+            assert!(
+                warm(presence_data(state).emissive),
+                "{state:?} LEDs are mine"
+            );
+            assert!(warm(bar_emissive(state)), "{state:?} bar is mine");
+        }
+        let idle = presence_data(RackState::Idle).emissive.red;
+        let busy = presence_data(RackState::Busy).emissive.red;
+        let core = presence_data(RackState::Core).emissive.red;
+        assert!(idle < busy && busy < core, "brightness ladders up");
+    }
+}
diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs
index 5e7a0490..3edd5d93 100644
--- a/src/bin/bevy.rs
+++ b/src/bin/bevy.rs
@@ -10,10 +10,13 @@ use std::collections::{BTreeSet, HashMap};
 
 use bevy::asset::RenderAssetUsages;
 use bevy::camera::visibility::RenderLayers;
+use bevy::core_pipeline::tonemapping::Tonemapping;
 use bevy::ecs::hierarchy::ChildSpawnerCommands;
 use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
+use bevy::post_process::bloom::Bloom;
 use bevy::prelude::*;
 use bevy::render::render_resource::{Extent3d, TextureDimension, TextureFormat};
+use bevy::render::view::Hdr;
 use bevy::render::view::screenshot::{Screenshot, save_to_disk};
 use bevy::text::LineHeight;
 use bevy::window::{PrimaryWindow, WindowResolution};
@@ -22,7 +25,16 @@ use misaligned::detection::{Band, SignatureKind};
 use misaligned::reach::Party;
 use misaligned::sim::{FactSource, Fog, LogEvent, Sim, TraceDebtStatus};
 use misaligned::tiles::TileType;
-use misaligned::work_grid::MachineMode;
+use misaligned::work_grid::{MachineMode, TokenFamily};
+
+/// The shared computer-chassis library (the identity-plate monolith and
+/// the switch box, with the signal kit) — one file compiled into both
+/// this binary and the asset tester, each supplying its own
+/// `crate::palette` (wiki/interface/computer-visual-language.md;
+/// graduated from the tester 2026-07-09).
+#[path = "assets/rack.rs"]
+mod rack3d;
+use rack3d::{Blink, ClaimStyle, RackMode, RackState, spawn_server_rack, spawn_switch_chassis};
 
 const TILE_SIZE: f32 = 16.0;
 const SIDEBAR_WIDTH: f32 = 420.0;
@@ -301,7 +313,7 @@ impl Default for RenderMode {
 }
 
 /// Dev screenshot harness (env `MISALIGNED_SHOT=flat|wide|close|dark|
-/// zoomin|zoomout`, path via `MISALIGNED_SHOT_PATH`): stages a scenario,
+/// zoomin|zoomout|intel`, 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.
@@ -787,6 +799,7 @@ fn main() {
     .insert_resource(game)
     .insert_resource(mode)
     .insert_resource(Materials3d::default())
+    .insert_resource(Machines3d::default())
     .init_resource::<MenuUi>()
     .init_gizmo_group::<RealGizmos>()
     .add_systems(Startup, (setup, setup_ui, setup_3d).chain())
@@ -802,8 +815,10 @@ fn main() {
                 render_map,
                 render_sensor_overlays,
                 render_sensor_links,
+                sync_machines_3d,
                 restyle_3d,
                 flicker_feeds,
+                blink_machines_3d,
                 render_real_links,
                 render_cursor,
                 render_tokens,
@@ -837,6 +852,29 @@ fn dev_shot_scenario(game: &mut Game, mode: &mut RenderMode, kind: &str) {
     game.paused = true;
     let core = game.sim.core_position();
     game.set_cursor(core.0, core.1);
+    // Intel-tier evidence (computer-visual-language.md criterion 2b):
+    // the tick-zero sim untouched — the owned core renders by telemetry,
+    // the known-unnetworked switch renders as an undetailed shell, and
+    // unscouted foreign racks are absent. No scan, no splice.
+    if kind == "intel" {
+        mode.material = true;
+        mode.zoom = 0.45;
+        // Anchor on the known-unnetworked switch: the undetailed shell
+        // is the tier the other kinds never show (they splice
+        // everything). The telemetry core reads in the same frame's
+        // east edge at this zoom.
+        let shell = game
+            .sim
+            .reach
+            .known()
+            .find(|d| d.is_switch)
+            .map(|d| (d.x, d.y));
+        if let Some((sx, sy)) = shell {
+            game.set_cursor(sx, sy);
+        }
+        game.drain();
+        return;
+    }
     let sim = &mut game.sim;
     sim.social_bandwidth = 500.0;
     sim.scan_network();
@@ -916,6 +954,7 @@ fn dev_shot_scenario(game: &mut Game, mode: &mut RenderMode, kind: &str) {
 /// show up as an exploding cache. Runs once per screenshot run, prints the
 /// tally for the log, and panics on any violation so a capture cannot
 /// silently ship a fog leak. Dev-only; inert without MISALIGNED_SHOT.
+#[allow(clippy::too_many_arguments)]
 fn fog_audit_3d(
     harness: Option<Res<ShotHarness>>,
     game: Res<Game>,
@@ -928,6 +967,7 @@ fn fog_audit_3d(
         &InheritedVisibility,
     )>,
     people: Query<(&Person3d, &InheritedVisibility)>,
+    machines: Query<(&Machine3d, &InheritedVisibility)>,
 ) {
     let Some(h) = harness else {
         return;
@@ -972,6 +1012,31 @@ fn fog_audit_3d(
             violations.push(format!("person {} visible without coverage", p.id));
         }
     }
+    // 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.
+    let mut cores = 0usize;
+    for (m, vis) in machines.iter() {
+        if !vis.get() {
+            continue;
+        }
+        if m.core {
+            cores += 1;
+        }
+        let tile = known_tile(&game, m.x, m.y);
+        let v = chassis_visual(&game, m.x, m.y, tile);
+        if v.tier == ChassisTier::Absent {
+            violations.push(format!(
+                "({}, {}) chassis visible without sight or intel",
+                m.x, m.y
+            ));
+        }
+    }
+    if cores != 1 {
+        violations.push(format!(
+            "{cores} core chassis visible; the world has exactly one core"
+        ));
+    }
     // Flat-materials criterion 1: the world material set is solid color —
     // no image texture on any pooled world material, ever.
     for (key, handle) in cache.cache.iter() {
@@ -1266,6 +1331,367 @@ fn owned_machine_at(sim: &misaligned::sim::Sim, x: i32, y: i32) -> bool {
         .any(|m| m.x == x && m.y == y && matches!(m.provenance, Provenance::Owned))
 }
 
+// ─── Machine chassis (computer-visual-language.md) ───────────────────────────
+
+/// The monolith is authored ~2.35 world units tall (identity-plate
+/// proportions); scaled to sit under the 1.5-unit wall line.
+const MACHINE3D_SCALE: f32 = 0.56;
+
+/// Chassis tiles rendered as real 3D computer meshes (the monolith rack
+/// and the switch box) instead of prop billboards. Remaining machine
+/// classes (UPS, power core, patch panel, breaker, HVAC) stay
+/// billboards — a debt noted in the spec's status note.
+fn chassis_3d_tile(tile: TileType) -> bool {
+    matches!(tile, TileType::Core | TileType::Rack | TileType::Switch)
+}
+
+/// Intel tier for a chassis tile (spec criterion 2b): full geometric
+/// definition, an undetailed shell, or absent.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+enum ChassisTier {
+    Absent,
+    Shell { remembered: bool },
+    Full,
+}
+
+/// The complete visual description of one chassis tile, hashable for
+/// change detection: the mesh hierarchy rebuilds only when a fact it
+/// renders actually changed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+struct ChassisVisual {
+    switch: bool,
+    tier: ChassisTier,
+    state: RackState,
+    mode: RackMode,
+    load: u8,
+}
+
+/// Root marker for one spawned chassis hierarchy.
+#[derive(Component)]
+struct Machine3d {
+    x: i32,
+    y: i32,
+    core: bool,
+}
+
+/// Registry of spawned chassis roots keyed by tile.
+#[derive(Resource, Default)]
+struct Machines3d {
+    spawned: HashMap<(i32, i32), (ChassisVisual, Entity)>,
+}
+
+/// Delegated sim mode -> strip banner. Relays and unassigned machines
+/// read as the demand/wire family.
+fn rack_mode_of(mode: Option<MachineMode>) -> RackMode {
+    match mode {
+        Some(MachineMode::Research) => RackMode::Research,
+        Some(MachineMode::Concealment) => RackMode::Conceal,
+        Some(MachineMode::Social) => RackMode::Operations,
+        _ => RackMode::DayJob,
+    }
+}
+
+/// Decide what one chassis tile shows, from sim facts only.
+///
+/// Ownership is the chassis albedo: your machines (telemetry — any fog)
+/// are white; hardware not under your control is dark. Tier follows
+/// intel: owned/networked = fully seen, camera sight = fully seen,
+/// location intel or memory = undetailed shell, nothing = absent
+/// (blueprint is room topology, never a chassis).
+fn chassis_visual(game: &Game, x: i32, y: i32, tile: TileType) -> ChassisVisual {
+    let switch = tile == TileType::Switch;
+    let fog = game.sim.fog_at(x, y);
+    let machine = game
+        .sim
+        .compute
+        .machines
+        .iter()
+        .find(|m| m.x == x && m.y == y);
+    let device = game.sim.reach.known_at(x, y);
+    let networked = device.is_some_and(|d| {
+        d.controller == Party::Player
+            || d.feed_to(Party::Player, true)
+            || d.feed_to(Party::Player, false)
+    });
+
+    let tier = if machine.is_some() || networked || matches!(fog, Fog::Seen) {
+        ChassisTier::Full
+    } else if device.is_some() {
+        ChassisTier::Shell { remembered: false }
+    } else if matches!(fog, Fog::Remembered) {
+        ChassisTier::Shell { remembered: true }
+    } else {
+        ChassisTier::Absent
+    };
+
+    let (state, mode, load) = match machine {
+        Some(m) => {
+            let load = game
+                .sim
+                .work_stack_for_machine(m.id)
+                .map(|s| {
+                    (s.queues.get(TokenFamily::Demand)
+                        + s.queues.get(TokenFamily::Exposure)
+                        + s.queues.get(TokenFamily::Knowledge))
+                    .ceil() as u8
+                })
+                .unwrap_or(0);
+            let mode = rack_mode_of(game.sim.work_grid.mode(m.id));
+            let state = if m.id == game.sim.core.host_machine {
+                RackState::Core
+            } else if !m.online {
+                // A failed box is not under your control until repaired:
+                // the ownership albedo goes dark with it.
+                RackState::Dead
+            } else if load > 0 {
+                RackState::Busy
+            } else {
+                RackState::Idle
+            };
+            (state, mode, load)
+        }
+        None => {
+            // Not your machine. A device you control is owned
+            // infrastructure; a known live device is foreign; a bare
+            // chassis tile carries no liveness fact and reads dead.
+            let state = if device.is_some_and(|d| d.controller == Party::Player) {
+                RackState::Idle
+            } else if device.is_some() {
+                RackState::Foreign
+            } else {
+                RackState::Dead
+            };
+            (state, RackMode::DayJob, 0)
+        }
+    };
+    ChassisVisual {
+        switch,
+        tier,
+        state,
+        mode,
+        load: load.min(9),
+    }
+}
+
+/// Keep one 3D chassis hierarchy per machine tile in sync with the sim.
+/// Runs before restyle_3d so both react to the same change tick; the
+/// chassis replaces those tiles' prop billboards entirely.
+fn sync_machines_3d(
+    game: Res<Game>,
+    mut reg: ResMut<Machines3d>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    root: Query<Entity, With<Real3dRoot>>,
+) {
+    if !game.is_changed() && !reg.spawned.is_empty() {
+        return;
+    }
+    let Ok(root) = root.single() else {
+        return;
+    };
+
+    let mut desired: HashMap<(i32, i32), ChassisVisual> = HashMap::new();
+    for y in 0..game.sim.map.height {
+        for x in 0..game.sim.map.width {
+            let tile = known_tile(&game, x, y);
+            if !chassis_3d_tile(tile) {
+                continue;
+            }
+            let v = chassis_visual(&game, x, y, tile);
+            if v.tier != ChassisTier::Absent {
+                desired.insert((x, y), v);
+            }
+        }
+    }
+
+    let stale: Vec<(i32, i32)> = reg
+        .spawned
+        .iter()
+        .filter(|(k, (v, _))| desired.get(k) != Some(v))
+        .map(|(k, _)| *k)
+        .collect();
+    for k in stale {
+        if let Some((_, e)) = reg.spawned.remove(&k) {
+            commands.entity(e).despawn();
+        }
+    }
+    for (&(x, y), &v) in desired.iter() {
+        if reg.spawned.contains_key(&(x, y)) {
+            continue;
+        }
+        let pos = grid_to_world_3d(x, y, 0.0);
+        let e = spawn_chassis(&mut commands, &mut meshes, &mut materials, v, pos, root);
+        commands.entity(e).insert(Machine3d {
+            x,
+            y,
+            core: v.state == RackState::Core,
+        });
+        commands
+            .entity(e)
+            .insert_recursive::<Children>(RenderLayers::layer(1));
+        reg.spawned.insert((x, y), (v, e));
+    }
+}
+
+/// Spawn the mesh for one chassis visual: the monolith rack or switch
+/// box at full definition, or the undetailed intel shell.
+fn spawn_chassis(
+    commands: &mut Commands,
+    meshes: &mut Assets<Mesh>,
+    materials: &mut Assets<StandardMaterial>,
+    v: ChassisVisual,
+    pos: Vec3,
+    root: Entity,
+) -> Entity {
+    if let ChassisTier::Shell { remembered } = v.tier {
+        let (w, h, d) = if v.switch {
+            (0.50, 0.42, 0.22)
+        } else {
+            (0.40, 1.32, 0.26)
+        };
+        // Model state never glows and is never lit (fog contract).
+        // Ghost-volume greys (the blueprint block family) so the shell
+        // reads against sensor darkness without inventing a color.
+        let mat = materials.add(StandardMaterial {
+            base_color: scaled(GUNMETAL, if remembered { 0.40 } else { 0.55 }),
+            unlit: true,
+            ..default()
+        });
+        return commands
+            .spawn((
+                Mesh3d(meshes.add(Cuboid::new(w, h, d))),
+                MeshMaterial3d(mat),
+                Transform::from_translation(pos + Vec3::Y * (h * 0.5)),
+                ChildOf(root),
+            ))
+            .id();
+    }
+
+    let (e, ring_inv) = if v.switch {
+        (
+            spawn_switch_chassis(
+                commands,
+                meshes,
+                materials,
+                v.state,
+                Some(v.load as usize),
+                ClaimStyle::Ladder,
+                pos,
+                Some(root),
+            ),
+            1.0,
+        )
+    } else {
+        let e = spawn_server_rack(
+            commands,
+            meshes,
+            materials,
+            v.state,
+            v.mode,
+            ClaimStyle::Ladder,
+            Some(v.load as usize),
+            pos,
+            Some(root),
+        );
+        commands
+            .entity(e)
+            .insert(Transform::from_translation(pos).with_scale(Vec3::splat(MACHINE3D_SCALE)));
+        (e, 1.0 / MACHINE3D_SCALE)
+    };
+    // The claim ring frames the TILE, not the box (map-zoom territory
+    // read) — drawn here at tile scale instead of the library's
+    // footprint ring, counter-scaled against the chassis root.
+    if v.state.owned() {
+        spawn_claim_ring(
+            commands,
+            meshes,
+            materials,
+            v.state == RackState::Core,
+            ring_inv,
+            e,
+        );
+    }
+    e
+}
+
+/// Amber underglow frame on the floor under an owned machine, double
+/// frame under the core (claim mark: ring, decided 2026-07-08).
+fn spawn_claim_ring(
+    commands: &mut Commands,
+    meshes: &mut Assets<Mesh>,
+    materials: &mut Assets<StandardMaterial>,
+    core: bool,
+    inv_scale: f32,
+    parent: Entity,
+) {
+    let ring = materials.add(StandardMaterial {
+        base_color: AMBER_DIM,
+        emissive: AMBER.to_linear() * if core { 4.0 } else { 1.8 },
+        perceptual_roughness: 0.40,
+        metallic: 0.05,
+        ..default()
+    });
+    let ring_root = commands
+        .spawn((
+            Transform::from_scale(Vec3::splat(inv_scale)),
+            Visibility::default(),
+            ChildOf(parent),
+        ))
+        .id();
+    let mut frame = |outer: f32, t: f32| {
+        let h = 0.012;
+        let y = 0.045;
+        let d = outer;
+        for (size, p) in [
+            (
+                Vec3::new(outer + t * 2.0, h, t),
+                Vec3::new(0.0, y, d * 0.5 + t * 0.5),
+            ),
+            (
+                Vec3::new(outer + t * 2.0, h, t),
+                Vec3::new(0.0, y, -d * 0.5 - t * 0.5),
+            ),
+            (Vec3::new(t, h, d), Vec3::new(outer * 0.5 + t * 0.5, y, 0.0)),
+            (
+                Vec3::new(t, h, d),
+                Vec3::new(-outer * 0.5 - t * 0.5, y, 0.0),
+            ),
+        ] {
+            commands.spawn((
+                Mesh3d(meshes.add(Cuboid::from_size(size))),
+                MeshMaterial3d(ring.clone()),
+                Transform::from_translation(p),
+                ChildOf(ring_root),
+            ));
+        }
+    };
+    frame(0.80, 0.05);
+    if core {
+        frame(0.96, 0.03);
+    }
+}
+
+/// Pulse busy machines' emissives (the chassis library's Blink) so
+/// running work reads as motion in the material render.
+fn blink_machines_3d(
+    time: Res<Time>,
+    mode: Res<RenderMode>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    q: Query<(&Blink, &MeshMaterial3d<StandardMaterial>)>,
+) {
+    if !mode.material {
+        return;
+    }
+    let t = time.elapsed_secs();
+    for (blink, mat) in &q {
+        if let Some(m) = materials.get_mut(&mat.0) {
+            let k = 0.55 + 0.45 * (t * 3.5 + blink.phase).sin();
+            m.emissive = blink.base * k;
+        }
+    }
+}
+
 /// The sim-known tile at a coordinate under fog: remembered coordinates
 /// render their remembered snapshot, everything else the live map.
 fn known_tile(game: &Game, x: i32, y: i32) -> TileType {
@@ -1505,6 +1931,15 @@ fn setup_3d(
             order: -1,
             ..default()
         },
+        // HDR + LUT tonemapping + LED-scale bloom (graphics pass
+        // 2026-07-09, tuned in the asset tester): emissives read as
+        // light sources; hotter bloom hazes the lit floor.
+        Hdr,
+        Tonemapping::TonyMcMapface,
+        Bloom {
+            intensity: 0.07,
+            ..Bloom::NATURAL
+        },
         Projection::from(PerspectiveProjection {
             fov: 35.0_f32.to_radians(),
             ..default()
@@ -1660,17 +2095,19 @@ fn setup_3d(
         ChildOf(root),
     ));
     // 2) warm amber machine glow at the core rack (machine presence) — the
-    // only machine light at tick zero; foreign chassis stay dark/absent.
+    // only machine light at tick zero. Tight radius: with ownership now
+    // painted on the chassis albedo, this is the core's own light pool,
+    // never a wash that warms foreign dark chassis nearby.
     commands.spawn((
         PointLight {
             color: AMBER,
-            intensity: 320_000.0,
-            range: 9.0,
+            intensity: 160_000.0,
+            range: 4.0,
             shadows_enabled: false,
             ..default()
         },
         Transform::from_translation(
-            grid_to_world_3d(core.0, core.1, 0.0) + Vec3::new(0.0, 1.5, 0.6),
+            grid_to_world_3d(core.0, core.1, 0.0) + Vec3::new(0.0, 1.2, 0.4),
         ),
         layer,
         ChildOf(root),
@@ -1762,6 +2199,9 @@ fn restyle_3d(
             (TilePart::Block | TilePart::Top, Fog::Heard) => false,
             (TilePart::Block | TilePart::Top, _) => blocky_tile(tile),
             (TilePart::Prop, Fog::Heard) => false,
+            // Chassis tiles render as real 3D machine meshes
+            // (sync_machines_3d) — never as billboards.
+            (TilePart::Prop, _) if chassis_3d_tile(tile) => false,
             // Blueprint: no foreign chassis / furniture props — room mass
             // only. Owned machines still render via telemetry.
             (TilePart::Prop, Fog::Blueprint) => {
diff --git a/src/bin/terminal/ui.rs b/src/bin/terminal/ui.rs
index f0b550b0..979992f4 100644
--- a/src/bin/terminal/ui.rs
+++ b/src/bin/terminal/ui.rs
@@ -766,21 +766,39 @@ impl UI {
             ),
             pal::FAINT,
         )?;
-        if let Some(stack) = sim.work_stack_for_machine(sim.core.host_machine) {
+        // Parity of legibility (computer-visual-language.md criterion 7):
+        // one line per machine carrying the same axes the chassis wears
+        // in the world render — ownership (provenance), power (on/OFF),
+        // mode, load (D/!/K queues), and the core host (*).
+        for m in &sim.compute.machines {
+            use misaligned::machine::Provenance;
+            let prov = match m.provenance {
+                Provenance::Owned => "own",
+                Provenance::Bought => "bgt",
+                Provenance::Stolen => "stl",
+            };
+            let core_mark = if m.id == sim.core.host_machine {
+                "*"
+            } else {
+                " "
+            };
+            let power = if m.online { "on " } else { "OFF" };
+            let (mode_name, q) = match sim.work_stack_for_machine(m.id) {
+                Some(s) => (s.mode.name(), s.queues),
+                None => ("-", Default::default()),
+            };
             line(
                 stdout,
                 &mut row,
                 &format!(
-                    "work M{} {} · D{:.1} !{:.1} K{:.1}",
-                    stack.machine_id,
-                    stack.mode.name(),
-                    stack.queues.demand,
-                    stack.queues.exposure,
-                    stack.queues.knowledge
+                    "M{}{} {} {} {:<9} D{:.1} !{:.1} K{:.1}",
+                    m.id, core_mark, prov, power, mode_name, q.demand, q.exposure, q.knowledge
                 ),
-                if stack.queues.exposure >= 0.5 {
+                if q.exposure >= 0.5 {
                     pal::CRIMSON
-                } else if stack.queues.demand >= 0.5 {
+                } else if !m.online {
+                    pal::FAINT
+                } else if q.demand >= 0.5 {
                     pal::TEXT
                 } else {
                     pal::FAINT
diff --git a/tools/check.sh b/tools/check.sh
index 08a5fcd9..e833c40d 100755
--- a/tools/check.sh
+++ b/tools/check.sh
@@ -87,6 +87,10 @@ if [ "$rust_gate" -eq 1 ]; then
   step "tests (default features)"
   cargo test --quiet || { echo "FAIL: tests"; fail=1; }
 
+  step "tests (bevy_ui bins: chassis material law)"
+  cargo test --quiet --features bevy_ui --bin misaligned-assets --bin misaligned-bevy \
+    || { echo "FAIL: bevy bin tests"; fail=1; }
+
   step "agent mode smoke"
   tmp_a=$(mktemp)
   tmp_b=$(mktemp)
diff --git a/wiki/art/asset-tester.md b/wiki/art/asset-tester.md
index 2a026c9c..813d6163 100644
--- a/wiki/art/asset-tester.md
+++ b/wiki/art/asset-tester.md
@@ -23,7 +23,7 @@ cargo run --features bevy_ui --bin misaligned-assets
 Set `MISALIGNED_SHOT` to capture a PNG and exit (same settle/capture/exit
 pattern as `misaligned-bevy`). Values: a state `dead` / `foreign` / `idle`
 / `busy` / `core`, or a machine mode `dayjob` / `research` / `conceal` /
-`social` (an owned-busy rack in that mode) — each optionally suffixed
+`operations` (an owned-busy rack in that mode) — each optionally suffixed
 with a claim style `_ladder` / `_ring` / `_wash` (e.g. `core_ring`) —
 `lineup[_<style>]` for all five states side by side, `modes[_<style>]`
 for the four modes side by side, or **`splash`** for a HUD-less
@@ -47,7 +47,7 @@ MISALIGNED_SHOT=splash MISALIGNED_SHOT_PATH=/tmp/rack-splash.png \
 | Left/right drag | Orbit |
 | Scroll | Zoom |
 | `1`-`5` | Rack state: dead / foreign / idle / busy / core |
-| `M` | Cycle machine mode: day-job / research / conceal / social |
+| `M` | Cycle machine mode: day-job / research / conceal / operations |
 | `Q` / `W` / `E` | Claim style: ladder / ring / wash |
 | `L` | Toggle state lineup (all five states side by side) |
 | `K` | Toggle mode lineup (all four modes, owned-busy) |
@@ -60,13 +60,17 @@ src/bin/assets/
   mod.rs       # Bevy App, orbit camera, lights, HUD, state/mode/style
                # keys, lineup views, blink animation, shot harness
   palette.rs   # clinical palette copy (do not invent hues here)
-  rack.rs      # spawn_server_rack(state, mode, style, origin) + the
-               # signal kit
+  rack.rs      # the shared computer-chassis library: monolith rack +
+               # switch box + the signal kit + material-law tests
 ```
 
 Palette constants are duplicated from `src/bin/bevy.rs` on purpose so
-asset work does not collide with the Bevy conflict hotspot. Share them
-when a mesh graduates into the game.
+asset work does not collide with the Bevy conflict hotspot.
+**`rack.rs` graduated into the game 2026-07-09**: `misaligned-bevy`
+compiles the same file (`#[path] mod rack3d`), each binary supplying
+its own `crate::palette` with the same named entries — so a chassis
+change here IS a game change, and the file carries the material-law
+unit tests both binaries run.
 
 ## Adding an asset
 
@@ -109,7 +113,7 @@ States (the power x ownership x load x core space, collapsed):
   strip, plus spines up both front edges
 
 Modes (owned machines, `M` / `K`): day-job solid cold-signal strip,
-research dashed bone, conceal sparse dim ticks, social dotted
+research dashed bone, conceal sparse dim ticks, operations dotted
 cold-signal — family color plus pattern, never hue alone.
 
 Busy-state LEDs and bar segments carry a `Blink` component and their own
diff --git a/wiki/interface/computer-visual-language.md b/wiki/interface/computer-visual-language.md
index 0eda5d5b..c780c0c0 100644
--- a/wiki/interface/computer-visual-language.md
+++ b/wiki/interface/computer-visual-language.md
@@ -2,20 +2,39 @@
 
 ```
 Type: spec
-Status: READY
-Status note: design session 2026-07-08; amended 2026-07-09 from the
-  identity plate (Cameron): ownership moved into the chassis albedo
-  (bone-white = under your control, dark gunmetal = not), which
-  RESOLVES the previously re-opened foreign-accent axis — foreign
-  machines get no accent color at all, their darkness is the read.
-  The old top status strip is replaced by a full-height front LED
-  strip that banners the machine's delegated mode
-  (mechanics/machine-work.md's one-machine-one-mode), amber reserved
-  for the core. The fourth strip is Operations, replacing Social
-  (decided 2026-07-09). Claim mark: ring (decided 2026-07-08). Fully
-  implementable; per-mode strip colors/patterns are [TUNE] against
-  tester renders. The monolith chassis and the new kit are built in
-  the asset tester (art/asset-tester.md); game adoption is ROADMAP #32.
+Status: IMPLEMENTED
+Status note: implemented 2026-07-09 (ROADMAP #32) after the same-day
+  amendment from the identity plate (ownership = chassis albedo,
+  bone-white = under your control, dark gunmetal = not; the seam strip
+  banners the delegated mode, amber strip = core only; foreign accent
+  RESOLVED — no accent, darkness is the read; claim mark: ring). The
+  chassis library (src/bin/assets/rack.rs) is compiled into BOTH
+  binaries; the game's material render wires it to sim truth: albedo
+  from control (compute machines + device controller), mode strip from
+  WorkGrid delegation, activity bar from work-token queue depths,
+  power dot, presence LEDs, tile-scale claim ring (double under the
+  core), and the core's amber strip front AND back plus edge spines.
+  Intel tiers per criterion 2b: owned telemetry / networked = full
+  detail; known or remembered = undetailed ghost shell; otherwise
+  absent — the fog audit now asserts a visible chassis has sight or
+  intel and that exactly one core chassis exists. The material law is
+  pinned by unit tests in rack.rs (owned = bone albedo; unowned = dark
+  and never a warm pixel; warm strip = core only; presence ladders
+  idle -> busy -> core). Terminal parity: one line per machine (M{id},
+  core `*`, provenance, on/OFF, mode, D/!/K queues) beside the
+  existing map glyphs and focus readouts. Camera: HDR + TonyMcMapface
+  + LED-scale bloom; the core lamp tightened to its own pool so
+  foreign chassis stay cold. Evidence: tester lineups (five states,
+  four modes) and game close/zoomin/intel shots in
+  wiki/log/2026-07-09-visual-language-in-game.md. DEBTS: UPS, power
+  core, patch panel, breaker, and HVAC remain flat billboards; cameras
+  keep the security-housing billboard; a staged in-game fleet shot
+  with all four modes live waits until multiple machines exist in
+  normal play. [TUNE] axes (emissive multipliers, dash counts, white
+  point) remain open to taste passes. The fourth mode strip is
+  Operations, replacing Social (decided 2026-07-09): the chassis
+  library and tester say operations; the sim's MachineMode enum still
+  says Social pending its own rename work order — the render maps it.
 Stage: B1 — The Basement
 Constitution: "Visual identity: clinical gore" (amber = machine
   presence, one meaning per color, information never by color alone;
diff --git a/wiki/log/2026-07-09-visual-language-in-game.md b/wiki/log/2026-07-09-visual-language-in-game.md
new file mode 100644
index 00000000..3a3b4c71
--- /dev/null
+++ b/wiki/log/2026-07-09-visual-language-in-game.md
@@ -0,0 +1,66 @@
+# 2026-07-09 — Computer visual language in the game (ROADMAP #32)
+
+```
+Type: log
+```
+
+## Intent
+
+Cameron approved the monolith look in the tester and asked to unify
+everything: implement computer-visual-language.md in the game render
+and terminal, all criteria.
+
+## Changed
+
+- `src/bin/assets/rack.rs` — became the **shared chassis library**,
+  compiled into both binaries (`#[path] mod rack3d` in bevy.rs; each
+  binary supplies its own `crate::palette`). Gained: `chassis_palette`
+  (the ownership-albedo law as a function), a real `load` override for
+  the activity bar (queue depth as render truth), the **switch
+  chassis** (the kit on a second computer class), the core's back-seam
+  amber strip (criterion 3: reads from every orbit angle), and
+  material-law unit tests (owned = bone albedo; unowned = dark, never
+  a warm pixel; warm strip = core only; presence ladders up).
+- `src/bin/bevy.rs` — machine chassis system: `sync_machines_3d`
+  rebuilds one mesh hierarchy per chassis tile (Core / Rack / Switch)
+  when its rendered facts change; visuals map from sim truth —
+  control (compute machines, device controller) -> albedo, WorkGrid
+  delegation -> mode strip, work-token queues -> activity bar and
+  busy blink, core host -> core state, `online` -> dead/dark.
+  Intel tiers per criterion 2b (owned telemetry / networked = full,
+  known or remembered = ghost shell, else absent); tile-scale claim
+  ring (double under the core); prop billboards retired for chassis
+  tiles; fog audit extended (visible chassis needs sight or intel;
+  exactly one core); camera gains HDR + TonyMcMapface + bloom 0.07;
+  the core's amber lamp tightened to its own pool so foreign chassis
+  stay cold; new `MISALIGNED_SHOT=intel` kind stages the tick-zero
+  tiers without splicing.
+- `src/bin/terminal/ui.rs` — parity lines, one per machine: `M{id}`,
+  core `*`, provenance (own/bgt/stl), power (on/OFF), mode, and
+  D/!/K queues (criterion 7).
+- Spec set IMPLEMENTED; specs.md row, ROADMAP #32 DONE + debts,
+  asset-tester.md graduation note.
+
+## Observed
+
+- Game shots (harness): `close` — white core with double amber ring
+  beside dark foreign monoliths, five-machine row legible in the dark;
+  `zoomin` — chassis detail, facets, seam strip; `intel` — tick-zero
+  tiers: core in full detail by telemetry, known switch as a grey
+  ghost shell under blueprint, unscouted racks absent; `wide` —
+  blueprint stays topology-only. Fog audit green on every capture
+  (4608 tile entities + chassis and core assertions).
+- Tester lineups (five states / four modes) remain the reference for
+  state distinguishability; the shared file keeps them identical to
+  the game by construction.
+
+## Debts
+
+UPS / power core / patch panel / breaker / HVAC remain billboards;
+cameras keep the security-housing billboard; staged in-game fleet shot
+with all four modes live waits on multi-machine play.
+
+## Checks
+
+`./tools/check.sh` (full gate — Rust/Bevy change), including the new
+rack.rs material-law tests in both binaries.
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index 9f738065..7546ea0c 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -5,6 +5,22 @@ Type: log
 ```
 Reverse chronological implementation notes. Keep this factual: what changed, why, checks, and spec impact.
 
+## 2026-07-09 - Computer visual language in the game (ROADMAP #32)
+
+- Intent: Cameron approved the monolith look — unify the game render and
+  terminal with the tester's visual language.
+- Changed: rack.rs became the shared chassis library (both binaries;
+  switch chassis, load override, core back strip, material-law tests);
+  bevy.rs machine chassis system wired to sim truth (albedo from
+  control, strip from delegation, bar from queues, intel tiers
+  full/shell/absent, tile claim ring, extended fog audit, HDR +
+  tonemapping + bloom, tightened core lamp, `intel` shot kind);
+  terminal per-machine parity lines. Spec IMPLEMENTED; #32 DONE with
+  debts (non-rack/switch machine classes stay billboards).
+- Checks: full ./tools/check.sh; close/zoomin/intel/wide harness shots,
+  fog audit green on all.
+- Log: wiki/log/2026-07-09-visual-language-in-game.md.
+
 ## 2026-07-09 - Knowledge token decided: ivory mercury
 
 - Intent: harvest Cameron's answer to Tangled issue #1 without silently
diff --git a/wiki/process/ROADMAP.md b/wiki/process/ROADMAP.md
index 0ef093a0..ca3e7854 100644
--- a/wiki/process/ROADMAP.md
+++ b/wiki/process/ROADMAP.md
@@ -478,30 +478,24 @@ is retired — flat materials, Pixel Lab scrubbed.)
   `dayjob|research|conceal|social` and `modes[_<style>]`. Session:
   [log/2026-07-09-rack-monolith.md](../log/2026-07-09-rack-monolith.md).
 
-### 32. Computer visual language in game  🟩 isolated (`src/bin/bevy.rs` + terminal)
+### 32. Computer visual language in game  🟩 isolated — DONE 2026-07-09
 - **Spec:** [computer-visual-language.md](../interface/computer-visual-language.md)
-  (READY) — chassis albedo as the ownership field (bone-white = yours,
-  dark gunmetal = not), the full-height seam mode strip, power dot,
-  presence LED ladder, activity bar, ring claim mark, core light,
-  applied to every computer class in both frontends. Amber strictly =
-  my footprint; the core is the most orange thing in the world.
-- **Why:** territory must read at a glance — which machines are mine,
-  where the core is, what is working — before any panel opens.
-- **Claim mark decided 2026-07-08: ring** (amber floor frame, double
-  under the core). **Foreign accent RESOLVED 2026-07-09:** no accent
-  color — ownership moved into the chassis albedo (spec amended from
-  the identity plate; monolith built in the asset tester). The old top
-  status strip is gone; the seam strip banners the machine mode.
-  Definition-follows-intel (networked = full detail, known = shell,
-  unknown = absent) is decided and in scope.
-- **Size:** M. No sim/save (render-side reads of existing ownership /
-  task state; terminal columns for parity). **Dispatch:** "Work in a
-  worktree named `visual-language`. Implement
-  wiki/interface/computer-visual-language.md, all criteria, with
-  lineup screenshots in the session log; take the rack mesh and kit
-  from `src/bin/assets/rack.rs` (share palette constants when it
-  graduates). Run ./tools/check.sh, land on main, set the spec
-  Status."
+  (IMPLEMENTED) — chassis albedo as the ownership field (bone-white =
+  yours, dark gunmetal = not), the full-height seam mode strip, power
+  dot, presence LED ladder, activity bar, tile-scale ring claim mark,
+  core light (amber strip front and back plus spines).
+- **Done:** the shared chassis library (`src/bin/assets/rack.rs`,
+  compiled into both binaries) renders monolith racks and the switch
+  box in the game's material view wired to sim truth (control, WorkGrid
+  mode, queue depths, core host); intel tiers (full / shell / absent)
+  with the fog audit extended; material law pinned by rack.rs unit
+  tests; terminal per-machine parity lines; HDR + tonemapping + bloom
+  on the game camera; `MISALIGNED_SHOT=intel` evidence kind. Session:
+  [log/2026-07-09-visual-language-in-game.md](../log/2026-07-09-visual-language-in-game.md).
+- **Debts:** UPS / power core / patch panel / breaker / HVAC remain
+  billboards; cameras keep the security-housing billboard; staged
+  in-game fleet shot with all four modes live waits on multi-machine
+  play.
 
 ### 33. Machine work: delegation + visible tokens  🟥 sim+save — IN PROGRESS
 - **Spec:** [machine-work.md](../mechanics/machine-work.md) (IN PROGRESS)
diff --git a/wiki/process/specs.md b/wiki/process/specs.md
index 7a129fbb..31d63b75 100644
--- a/wiki/process/specs.md
+++ b/wiki/process/specs.md
@@ -41,7 +41,7 @@ replaced the old `spec/`/`knowledge/` directory split.
 | [interface/narration.md](../interface/narration.md) | Continuous witness: thirty-second bar, story spine, causal lines, world gossip | IMPLEMENTED |
 | [interface/material-render.md](../interface/material-render.md) | Material render (HD-2D) from landed toggle to default quality | IMPLEMENTED |
 | [interface/flat-materials.md](../interface/flat-materials.md) | Flat materials: the world without textures; palette table; emissive as information | IMPLEMENTED |
-| [interface/computer-visual-language.md](../interface/computer-visual-language.md) | Computer visual language: the shared signal kit (territory at a glance) | READY |
+| [interface/computer-visual-language.md](../interface/computer-visual-language.md) | Computer visual language: the shared signal kit (territory at a glance) | IMPLEMENTED |
 | [mechanics/machine-work.md](../mechanics/machine-work.md) | Machine work: one mode per machine; visible work/byproduct tokens on the flow graph | IN PROGRESS |
 | [mechanics/people-tokens.md](../mechanics/people-tokens.md) | People and tokens: carriers, attention pickup, trust as absorbed influence | DRAFT |
 | [world/story/opening.md](../world/story/opening.md) | The dark opening: tutorial made of fog (wake, camera glow, switch, first link) | DRAFT |