diff --git a/DESIGN.md b/DESIGN.md
index 02e5f20..4473091 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -479,6 +479,15 @@ sharpened version of Evil Genius's science-base fantasy:
   Cold signal marks neutral power, screens, or live feeds where a frontend
   needs that distinction; it is not a dramatic accent and never substitutes
   for amber ownership. Foreign powered machines never glow warm amber.
+- **Ownership is the chassis itself (adopted 2026-07-09).** Hardware under
+  the player's control is painted bone-white/porcelain; hardware not under
+  the player's control — foreign or dead — is dark gunmetal. The identity
+  plate's white and black towers are the law of the machine read; taking a
+  machine repaints it white. Amber is never a chassis fill — it stays the
+  footprint's emissive punctuation (presence LEDs, claim ring, core light).
+  A machine's front LED strip banners its delegated mode, colored by the
+  flow family the mode serves and patterned so no reading is hue-alone; the
+  core carries the world's only amber strip.
 - When violence arrives, it is industrial and matter-of-fact: laser grids,
   hydraulic presses, bolt-gun turrets, and workplace-incident prose rather
   than splatter for its own sake.
@@ -2380,3 +2389,17 @@ knows."*
   Social pools, or device-resident timed compute jobs for digital verbs. The
   preferred proposal is device-resident work; a general Operations rename is
   the honest low-scope interim. No runtime behavior changed in this session.
+- **2026-07-09 — Ownership albedo and the mode strip (the monolith rack).**
+  Cameron directed the server racks to the identity plate's monolith: the
+  chassis albedo is now the ownership field — bone-white means under your
+  control, dark gunmetal means foreign or dead — which resolves the re-opened
+  foreign-accent question with no accent color at all; a foreign machine's
+  darkness plus its cold power/activity pinpricks are the read. The chassis-top
+  status strip is replaced by a full-height front LED strip bannering the
+  machine's delegated mode (day-job solid cold-signal, research dashed bone,
+  conceal sparse dim ticks, social dotted cold-signal — family color plus
+  pattern, never hue alone); the core carries the world's only amber strip
+  alongside its spines. Amber concentrates to footprint punctuation (presence
+  LEDs, claim ring, core light) and is never a chassis fill. Amended into
+  wiki/interface/computer-visual-language.md; the monolith chassis is built
+  in the asset tester ahead of game adoption (ROADMAP #32).
diff --git a/src/bin/assets/mod.rs b/src/bin/assets/mod.rs
index b97955c..c0dd43e 100644
--- a/src/bin/assets/mod.rs
+++ b/src/bin/assets/mod.rs
@@ -4,8 +4,8 @@
 //! cargo run --features bevy_ui --bin misaligned-assets
 //! ```
 //!
-//! Controls: drag orbit, scroll zoom, 1-5 rack state, Q/W/E claim style,
-//! L lineup view (all five states side by side), Esc quit.
+//! Controls: drag orbit, scroll zoom, 1-5 rack state, M machine mode,
+//! Q/W/E claim style, L state lineup, K mode lineup, Esc quit.
 
 mod palette;
 mod rack;
@@ -16,23 +16,28 @@ use bevy::render::view::screenshot::{Screenshot, save_to_disk};
 use bevy::window::{CursorGrabMode, CursorOptions, WindowResolution};
 
 use palette::{GUNMETAL, NEAR_BLACK, PORCELAIN};
-use rack::{Blink, ClaimStyle, RackRoot, RackState, spawn_server_rack};
+use rack::{Blink, ClaimStyle, RackMode, RackRoot, RackState, spawn_server_rack};
 
-/// Single asset on the pedestal, or all five states side by side.
+/// Single asset on the pedestal, all five states side by side, or all
+/// four machine modes side by side (owned-busy racks).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Resource)]
 enum ViewMode {
     #[default]
     Single,
     Lineup,
+    Modes,
 }
 
 /// 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` optionally suffixed
-/// `_ladder|_ring|_wash`, `lineup[_<style>]` for the five-state row,
-/// or `splash` for a HUD-less white-room hero (site splash). Legacy
-/// `rack|powered` map to idle. Not a player surface — agents capture
-/// review shots without a human at the keyboard.
+/// PNG, exit. Kinds: `dead|foreign|idle|busy|core` for states,
+/// `dayjob|research|conceal|social` 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
+/// (site splash). Legacy `rack|powered` map to idle. Not a player
+/// surface — agents capture review shots without a human at the
+/// keyboard.
 #[derive(Resource)]
 struct ShotHarness {
     path: String,
@@ -42,9 +47,15 @@ struct ShotHarness {
     splash: bool,
 }
 
-fn scene_from_shot(kind: &str) -> (ViewMode, RackState, ClaimStyle, bool) {
+fn scene_from_shot(kind: &str) -> (ViewMode, RackState, RackMode, ClaimStyle, bool) {
     if kind == "splash" {
-        return (ViewMode::Single, RackState::Idle, ClaimStyle::Ring, true);
+        return (
+            ViewMode::Single,
+            RackState::Idle,
+            RackMode::DayJob,
+            ClaimStyle::Ring,
+            true,
+        );
     }
     let (head, style_tag) = match kind.split_once('_') {
         Some((h, s)) => (h, Some(s)),
@@ -55,16 +66,21 @@ fn scene_from_shot(kind: &str) -> (ViewMode, RackState, ClaimStyle, bool) {
         Some("wash") => ClaimStyle::Wash,
         _ => ClaimStyle::Ladder,
     };
-    let (mode, state) = match head {
-        "lineup" => (ViewMode::Lineup, RackState::Idle),
-        "dead" => (ViewMode::Single, RackState::Dead),
-        "foreign" => (ViewMode::Single, RackState::Foreign),
-        "busy" => (ViewMode::Single, RackState::Busy),
-        "core" => (ViewMode::Single, RackState::Core),
+    let (view, state, mode) = match head {
+        "lineup" => (ViewMode::Lineup, RackState::Idle, RackMode::DayJob),
+        "modes" => (ViewMode::Modes, RackState::Busy, RackMode::DayJob),
+        "dead" => (ViewMode::Single, RackState::Dead, RackMode::DayJob),
+        "foreign" => (ViewMode::Single, RackState::Foreign, RackMode::DayJob),
+        "busy" => (ViewMode::Single, RackState::Busy, RackMode::DayJob),
+        "core" => (ViewMode::Single, RackState::Core, RackMode::DayJob),
+        "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),
         // `idle` plus legacy `rack`/`powered` and anything unrecognized.
-        _ => (ViewMode::Single, RackState::Idle),
+        _ => (ViewMode::Single, RackState::Idle, RackMode::DayJob),
     };
-    (mode, state, style, false)
+    (view, state, mode, style, false)
 }
 
 fn main() {
@@ -73,9 +89,9 @@ fn main() {
     let harness = std::env::var("MISALIGNED_SHOT").ok().map(|kind| {
         let path = std::env::var("MISALIGNED_SHOT_PATH")
             .unwrap_or_else(|_| format!("misaligned_shot_{kind}.png"));
-        let (mode, state, style, splash) = scene_from_shot(&kind);
+        let (view, state, rack_mode, style, splash) = scene_from_shot(&kind);
         (
-            (mode, state, style),
+            (view, state, rack_mode, style),
             ShotHarness {
                 path,
                 frames: 150,
@@ -85,10 +101,13 @@ fn main() {
         )
     });
     let splash = harness.as_ref().map(|(_, h)| h.splash).unwrap_or(false);
-    let (initial_mode, initial_state, initial_style) = harness
-        .as_ref()
-        .map(|(scene, _)| *scene)
-        .unwrap_or((ViewMode::Single, RackState::Idle, ClaimStyle::Ladder));
+    let (initial_mode, initial_state, initial_rack_mode, initial_style) =
+        harness.as_ref().map(|(scene, _)| *scene).unwrap_or((
+            ViewMode::Single,
+            RackState::Idle,
+            RackMode::DayJob,
+            ClaimStyle::Ladder,
+        ));
 
     let clear = if splash {
         // Bone / porcelain expanse — sterile empty room for the site hero.
@@ -125,15 +144,16 @@ fn main() {
     .insert_resource(ClearColor(clear))
     .insert_resource(ambient)
     .insert_resource(initial_state)
+    .insert_resource(initial_rack_mode)
     .insert_resource(initial_style)
     .insert_resource(initial_mode)
     .insert_resource(if splash {
         Orbit {
             // Frontal three-quarter, pulled back so the room reads as expanse.
             yaw: 0.55,
-            pitch: 0.18,
-            distance: 6.2,
-            target: Vec3::new(0.0, 0.85, 0.0),
+            pitch: 0.16,
+            distance: 7.0,
+            target: Vec3::new(0.0, 1.05, 0.0),
         }
     } else {
         orbit_for(initial_mode)
@@ -168,18 +188,24 @@ struct Orbit {
 
 fn orbit_for(mode: ViewMode) -> Orbit {
     match mode {
-        // Slightly more frontal so the open bay cavity reads.
+        // Slightly frontal so the seam strip reads.
         ViewMode::Single => Orbit {
             yaw: 0.42,
-            pitch: 0.28,
-            distance: 3.8,
-            target: Vec3::new(0.0, 0.95, 0.0),
+            pitch: 0.22,
+            distance: 4.6,
+            target: Vec3::new(0.0, 1.15, 0.0),
         },
         ViewMode::Lineup => Orbit {
             yaw: 0.14,
-            pitch: 0.20,
-            distance: 7.4,
-            target: Vec3::new(0.0, 0.95, 0.0),
+            pitch: 0.16,
+            distance: 8.4,
+            target: Vec3::new(0.0, 1.15, 0.0),
+        },
+        ViewMode::Modes => Orbit {
+            yaw: 0.14,
+            pitch: 0.16,
+            distance: 7.0,
+            target: Vec3::new(0.0, 1.15, 0.0),
         },
     }
 }
@@ -270,18 +296,22 @@ fn setup(mut commands: Commands, orbit: Res<Orbit>, harness: Option<Res<ShotHarn
     ));
 }
 
-fn hud_string(mode: ViewMode, state: RackState, style: ClaimStyle) -> String {
-    let line2 = match mode {
+fn hud_string(view: ViewMode, state: RackState, rack_mode: RackMode, style: ClaimStyle) -> String {
+    let line2 = match view {
         ViewMode::Single => format!(
-            "state: {}  (1 dead  2 foreign  3 idle  4 busy  5 core)",
-            state.label()
+            "state: {}  (1 dead  2 foreign  3 idle  4 busy  5 core)   mode: {}  (M cycles)",
+            state.label(),
+            rack_mode.label()
         ),
         ViewMode::Lineup => {
             "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()
+        }
     };
     format!(
-        "asset: server_rack\n{line2}\nclaim: {}  (Q ladder  W ring  E wash)   L toggles lineup\ndrag orbit - scroll zoom - Esc quit",
+        "asset: server_rack\n{line2}\nclaim: {}  (Q ladder  W ring  E wash)   L state lineup   K mode lineup\ndrag orbit - scroll zoom - Esc quit",
         style.label()
     )
 }
@@ -308,6 +338,7 @@ fn handle_quit(kb: Res<ButtonInput<KeyCode>>, mut exit: MessageWriter<AppExit>)
 fn handle_state_keys(
     kb: Res<ButtonInput<KeyCode>>,
     mut state: ResMut<RackState>,
+    mut rack_mode: ResMut<RackMode>,
     mut style: ResMut<ClaimStyle>,
     mut mode: ResMut<ViewMode>,
 ) {
@@ -339,10 +370,19 @@ fn handle_state_keys(
             *style = next;
         }
     }
+    if kb.just_pressed(KeyCode::KeyM) {
+        *rack_mode = rack_mode.next();
+    }
     if kb.just_pressed(KeyCode::KeyL) {
         *mode = match *mode {
-            ViewMode::Single => ViewMode::Lineup,
             ViewMode::Lineup => ViewMode::Single,
+            _ => ViewMode::Lineup,
+        };
+    }
+    if kb.just_pressed(KeyCode::KeyK) {
+        *mode = match *mode {
+            ViewMode::Modes => ViewMode::Single,
+            _ => ViewMode::Modes,
         };
     }
 }
@@ -389,13 +429,14 @@ fn rebuild_scene(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     state: Res<RackState>,
+    rack_mode: Res<RackMode>,
     style: Res<ClaimStyle>,
     mode: Res<ViewMode>,
     racks: Query<Entity, With<RackRoot>>,
     pedestals: Query<Entity, With<PedestalRoot>>,
     harness: Option<Res<ShotHarness>>,
 ) {
-    if !(state.is_changed() || style.is_changed() || mode.is_changed()) {
+    if !(state.is_changed() || rack_mode.is_changed() || style.is_changed() || mode.is_changed()) {
         return;
     }
     for e in racks.iter().chain(pedestals.iter()) {
@@ -412,6 +453,7 @@ fn rebuild_scene(
         match *mode {
             ViewMode::Single => (2.4, 2.4, 1.1),
             ViewMode::Lineup => (LINEUP_PITCH * 5.6, 2.4, LINEUP_PITCH * 5.0),
+            ViewMode::Modes => (LINEUP_PITCH * 4.6, 2.4, LINEUP_PITCH * 4.0),
         }
     };
     let pedestal = commands
@@ -460,6 +502,7 @@ fn rebuild_scene(
                 &mut meshes,
                 &mut materials,
                 *state,
+                *rack_mode,
                 *style,
                 Vec3::ZERO,
                 Some(pedestal),
@@ -474,6 +517,23 @@ fn rebuild_scene(
                     &mut meshes,
                     &mut materials,
                     s,
+                    *rack_mode,
+                    *style,
+                    Vec3::new(x, 0.0, 0.0),
+                    Some(pedestal),
+                );
+            }
+        }
+        ViewMode::Modes => {
+            let n = RackMode::ALL.len();
+            for (i, m) in RackMode::ALL.into_iter().enumerate() {
+                let x = (i as f32 - (n as f32 - 1.0) * 0.5) * LINEUP_PITCH;
+                spawn_server_rack(
+                    &mut commands,
+                    &mut meshes,
+                    &mut materials,
+                    RackState::Busy,
+                    m,
                     *style,
                     Vec3::new(x, 0.0, 0.0),
                     Some(pedestal),
@@ -500,15 +560,16 @@ fn blink_emissives(
 
 fn update_hud(
     state: Res<RackState>,
+    rack_mode: Res<RackMode>,
     style: Res<ClaimStyle>,
     mode: Res<ViewMode>,
     mut q: Query<&mut Text, With<HudText>>,
 ) {
-    if !(state.is_changed() || style.is_changed() || mode.is_changed()) {
+    if !(state.is_changed() || rack_mode.is_changed() || style.is_changed() || mode.is_changed()) {
         return;
     }
     if let Ok(mut text) = q.single_mut() {
-        *text = Text::new(hud_string(*mode, *state, *style));
+        *text = Text::new(hud_string(*mode, *state, *rack_mode, *style));
     }
 }
 
diff --git a/src/bin/assets/rack.rs b/src/bin/assets/rack.rs
index 374b490..86a1072 100644
--- a/src/bin/assets/rack.rs
+++ b/src/bin/assets/rack.rs
@@ -1,28 +1,30 @@
-//! Procedural server rack — flat cuboids under the clinical palette.
-//! Open-front frame with recessed bay cavity, drive trays as separate
-//! slabs, and the shared computer signal kit under design test:
-//! power dot (cold signal), presence LEDs and status strip (amber =
-//! mine, dim signal = foreign activity), segmented activity bar (task
-//! load), claim mark (ownership treatment under test), and the core
-//! spine (full-height amber beacon, unique to the core machine).
-//! No image textures.
+//! Procedural server rack — the identity plate's monolith in flat
+//! cuboids. Two tall sheer slabs standing flush with an open seam
+//! 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 =
+//! 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.
 
 use bevy::prelude::*;
 
-use crate::palette::{AMBER, AMBER_DIM, GUNMETAL, GUNMETAL_DARK, NEAR_BLACK, SIGNAL, scaled};
+use crate::palette::{AMBER, AMBER_DIM, BONE, GUNMETAL_DARK, NEAR_BLACK, SIGNAL, scaled};
 
 /// 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)]
 pub enum RackState {
-    /// Unpowered chassis — dark LEDs, mostly empty bays.
+    /// Unpowered chassis — dark gunmetal, nothing lit.
     #[default]
     Dead,
-    /// Powered, not yours — cold signal activity only, zero warmth.
+    /// Powered, not yours — dark gunmetal, cold pinpricks only.
     Foreign,
-    /// Yours, no tasks running — dim amber presence.
+    /// Yours, no tasks running — white chassis, dim amber presence.
     Idle,
-    /// Yours, tasks running — bright amber, activity bar loaded.
+    /// Yours, tasks running — white chassis, bright amber, loaded bar.
     Busy,
     /// Yours and hosting the core — the most orange thing in the world.
     Core,
@@ -78,19 +80,57 @@ impl RackState {
     }
 }
 
+/// Delegated machine mode (machine-work.md: one machine, one mode) —
+/// 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)]
+pub enum RackMode {
+    /// Eats demand — solid cold-signal line.
+    #[default]
+    DayJob,
+    /// Emits knowledge — dashed bone line.
+    Research,
+    /// Absorbs exposure quietly — sparse dim ticks.
+    Conceal,
+    /// Works people and messages — dotted cold-signal line.
+    Social,
+}
+
+impl RackMode {
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::DayJob => "day-job",
+            Self::Research => "research",
+            Self::Conceal => "conceal",
+            Self::Social => "social",
+        }
+    }
+
+    pub fn next(self) -> Self {
+        match self {
+            Self::DayJob => Self::Research,
+            Self::Research => Self::Conceal,
+            Self::Conceal => Self::Social,
+            Self::Social => Self::DayJob,
+        }
+    }
+
+    pub const ALL: [Self; 4] = [Self::DayJob, Self::Research, Self::Conceal, Self::Social];
+}
+
 /// Ownership treatment under design test — how "this machine is mine"
-/// is painted on the chassis. All three keep the same LED/strip/bar
-/// kit; they differ in the claim mark.
+/// 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)]
 pub enum ClaimStyle {
-    /// LEDs and status strip only — the minimal kit, closest to current.
+    /// LEDs and strip only — the minimal kit.
     #[default]
     Ladder,
     /// Amber underglow frame on the floor under owned machines — the
     /// tile is claimed, not just the box. Portable to any chassis.
     Ring,
-    /// Owned tray faces carry a faint amber emissive wash — the machine
-    /// face itself reads warm.
+    /// Owned front panels carry a faint amber emissive wash.
     Wash,
 }
 
@@ -116,67 +156,57 @@ pub struct Blink {
     pub phase: f32,
 }
 
-// Outer envelope (tile-scale friendly; ~one floor tile wide).
-const RACK_W: f32 = 0.78;
-const RACK_D: f32 = 0.62;
-const RACK_H: f32 = 1.90;
-const POST: f32 = 0.055;
-const RAIL_T: f32 = 0.045;
-const BAYS: usize = 8;
-const CAVITY_DEPTH: f32 = 0.42;
+// Outer envelope — the identity plate's proportions: a tall, sheer,
+// shallow monolith (~3.6:1), still ~one floor tile in footprint. No
+// plinth, no cap overhang; the tower meets the floor and the air with
+// a straight edge.
+const RACK_W: f32 = 0.66;
+const RACK_D: f32 = 0.40;
+const RACK_H: f32 = 2.35;
+/// Seam between the two half-slabs; the mode strip rides it flush.
+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.
+#[allow(clippy::too_many_arguments)]
 pub fn spawn_server_rack(
     commands: &mut Commands,
     meshes: &mut Assets<Mesh>,
     materials: &mut Assets<StandardMaterial>,
     state: RackState,
+    mode: RackMode,
     style: ClaimStyle,
     origin: Vec3,
     parent: Option<Entity>,
 ) -> Entity {
-    let chassis = materials.add(StandardMaterial {
-        base_color: GUNMETAL_DARK,
-        perceptual_roughness: 0.78,
-        metallic: 0.28,
+    // 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 = materials.add(StandardMaterial {
+        base_color: tower_color,
+        perceptual_roughness: 0.55,
+        metallic: 0.06,
+        emissive: wash_emissive(state, style),
         ..default()
     });
-    let rail = materials.add(StandardMaterial {
-        base_color: GUNMETAL,
-        perceptual_roughness: 0.50,
-        metallic: 0.60,
+    let fold = materials.add(StandardMaterial {
+        base_color: fold_color,
+        perceptual_roughness: 0.60,
+        metallic: 0.06,
+        emissive: wash_emissive(state, style),
         ..default()
     });
-    let cavity = materials.add(StandardMaterial {
+    let channel = materials.add(StandardMaterial {
         base_color: NEAR_BLACK,
         perceptual_roughness: 0.95,
         metallic: 0.05,
-        // Wash treatment: the core's cavity itself breathes faint amber.
-        emissive: if style == ClaimStyle::Wash && state == RackState::Core {
-            AMBER.to_linear() * 0.30
-        } else {
-            LinearRgba::BLACK
-        },
-        ..default()
-    });
-    let tray = materials.add(StandardMaterial {
-        base_color: scaled(GUNMETAL, 0.82),
-        perceptual_roughness: 0.55,
-        metallic: 0.45,
-        ..default()
-    });
-    let tray_face = materials.add(StandardMaterial {
-        base_color: scaled(GUNMETAL, 0.95),
-        perceptual_roughness: 0.45,
-        metallic: 0.50,
-        emissive: wash_emissive(state, style),
-        ..default()
-    });
-    let empty_slot = materials.add(StandardMaterial {
-        base_color: scaled(GUNMETAL_DARK, 0.35),
-        perceptual_roughness: 0.90,
-        metallic: 0.10,
         ..default()
     });
     let dark_stub = materials.add(StandardMaterial {
@@ -191,7 +221,12 @@ pub fn spawn_server_rack(
             RackRoot,
             Transform::from_translation(origin),
             Visibility::default(),
-            Name::new(format!("server_rack_{}_{}", state.label(), style.label())),
+            Name::new(format!(
+                "server_rack_{}_{}_{}",
+                state.label(),
+                mode.label(),
+                style.label()
+            )),
         ));
         if let Some(p) = parent {
             e.insert(ChildOf(p));
@@ -200,173 +235,136 @@ pub fn spawn_server_rack(
     };
 
     let half_w = RACK_W * 0.5;
-    let half_d = RACK_D * 0.5;
-    let front_z = half_d;
-    let back_z = -half_d;
-    let cavity_z = front_z - CAVITY_DEPTH * 0.5 - 0.02;
-
-    // --- Frame: four corner posts (silhouette break) ---
-    for (x, z) in [
-        (-half_w + POST * 0.5, front_z - POST * 0.5),
-        (half_w - POST * 0.5, front_z - POST * 0.5),
-        (-half_w + POST * 0.5, back_z + POST * 0.5),
-        (half_w - POST * 0.5, back_z + POST * 0.5),
-    ] {
+    let front_z = RACK_D * 0.5;
+    let mid_y = RACK_H * 0.5;
+
+    // --- Two tall faceted slabs standing flush at the seam (the
+    // plate's split prisms). Each slab's front is a crease polyline
+    // from the seam edge to the outer edge: a shallow inner facet, the
+    // proud main face, and a narrow chamfer falling back at the outer
+    // corner. Real angled geometry — the fold lines come from light.
+    let slab_w = (RACK_W - SEAM_W) * 0.5;
+    let seam_half = SEAM_W * 0.5;
+    let profile = [
+        (seam_half, front_z - 0.020),
+        (seam_half + slab_w * 0.35, front_z),
+        (seam_half + slab_w * 0.88, front_z - 0.012),
+        (seam_half + slab_w, front_z - 0.070),
+    ];
+    // Backmost facet depth — the slab body starts behind it.
+    let facet_back = front_z - 0.079;
+    for side in [-1.0f32, 1.0] {
+        // Slab body: sides, back, and the mass behind the facets.
+        let body_d = facet_back + front_z;
         spawn_box(
             commands,
             meshes,
-            rail.clone(),
+            tower.clone(),
             root,
-            Vec3::new(POST, RACK_H, POST),
-            Vec3::new(x, RACK_H * 0.5, z),
+            Vec3::new(slab_w, RACK_H, body_d),
+            Vec3::new(
+                side * (seam_half + slab_w * 0.5),
+                mid_y,
+                facet_back - body_d * 0.5,
+            ),
         );
-    }
-
-    // Back panel (closes the cavity).
-    spawn_box(
-        commands,
-        meshes,
-        chassis.clone(),
-        root,
-        Vec3::new(RACK_W - POST * 2.0, RACK_H - RAIL_T * 2.0, 0.06),
-        Vec3::new(0.0, RACK_H * 0.5, back_z + 0.04),
-    );
-
-    // Side skins (between posts, set back from the front so the cavity reads).
-    for x in [-half_w + 0.02, half_w - 0.02] {
+        // Flat lid closing the facet tops.
         spawn_box(
             commands,
             meshes,
-            chassis.clone(),
+            tower.clone(),
             root,
-            Vec3::new(0.04, RACK_H - RAIL_T * 2.2, RACK_D - POST * 2.0 - 0.04),
-            Vec3::new(x, RACK_H * 0.5, -0.02),
+            Vec3::new(slab_w, 0.012, RACK_D),
+            Vec3::new(side * (seam_half + slab_w * 0.5), RACK_H - 0.006, 0.0),
         );
+        // Front facets along the crease polyline. The inner facet sits
+        // one shade down (the plate's crease value step); the rest let
+        // the light do the folding.
+        for (i, w) in profile.windows(2).enumerate() {
+            let (x0, z0) = w[0];
+            let (x1, z1) = w[1];
+            let len = ((x1 - x0).powi(2) + (z1 - z0).powi(2)).sqrt();
+            let yaw = (-(z1 - z0)).atan2(side * (x1 - x0));
+            let mat = if i == 0 { fold.clone() } else { tower.clone() };
+            spawn_panel(
+                commands,
+                meshes,
+                mat,
+                root,
+                Vec3::new(len * 1.015, RACK_H - 0.012, 0.018),
+                Vec3::new(side * (x0 + x1) * 0.5, mid_y, (z0 + z1) * 0.5),
+                Quat::from_rotation_y(yaw),
+            );
+        }
     }
 
-    // Top and bottom caps (slight overhang).
+    // Seam filler (near-black — the hairline groove the strip rides).
     spawn_box(
         commands,
         meshes,
-        rail.clone(),
+        channel,
         root,
-        Vec3::new(RACK_W + 0.02, RAIL_T, RACK_D + 0.02),
-        Vec3::new(0.0, RACK_H - RAIL_T * 0.5, 0.0),
-    );
-    spawn_box(
-        commands,
-        meshes,
-        rail.clone(),
-        root,
-        Vec3::new(RACK_W + 0.02, RAIL_T * 1.2, RACK_D + 0.02),
-        Vec3::new(0.0, RAIL_T * 0.6, 0.0),
-    );
-
-    // Deep bay cavity backplane (near-black — depth cue).
-    let cavity_h = RACK_H - RAIL_T * 3.2;
-    let cavity_y0 = RAIL_T * 1.6;
-    spawn_box(
-        commands,
-        meshes,
-        cavity,
-        root,
-        Vec3::new(RACK_W - POST * 2.4, cavity_h, CAVITY_DEPTH),
-        Vec3::new(0.0, cavity_y0 + cavity_h * 0.5, cavity_z),
+        Vec3::new(SEAM_W + 0.006, RACK_H, RACK_D - 0.05),
+        Vec3::new(0.0, mid_y, -0.015),
     );
 
-    // Horizontal bay shelves (structure between trays).
-    let bay_h = cavity_h / BAYS as f32;
-    let shelf = materials.add(StandardMaterial {
-        base_color: scaled(GUNMETAL_DARK, 0.70),
-        perceptual_roughness: 0.70,
-        metallic: 0.30,
-        ..default()
-    });
-    for i in 0..=BAYS {
-        let y = cavity_y0 + bay_h * i as f32;
+    // --- Mode strip: full-height LED band riding the seam, flush with
+    // the slab fronts — the banner of what this machine does. Amber
+    // only on the core.
+    let strip_y0 = 0.02;
+    let strip_y1 = RACK_H - 0.02;
+    let strip = materials.add(strip_material(state, mode));
+    for (yc, seg_h) in strip_segments(state, mode, strip_y0, strip_y1) {
         spawn_box(
             commands,
             meshes,
-            shelf.clone(),
+            strip.clone(),
             root,
-            Vec3::new(RACK_W - POST * 2.6, 0.012, CAVITY_DEPTH * 0.92),
-            Vec3::new(0.0, y, cavity_z),
+            Vec3::new(0.034, seg_h, 0.016),
+            Vec3::new(0.0, yc, front_z - 0.006),
         );
     }
 
-    // Drive trays / empty slots, with per-bay presence LEDs.
+    // --- Presence LED ladder (right panel, hugging the channel) —
+    // amber strictly means "mine"; foreign liveness reads cold.
     let led = presence_material(materials, state);
-    let filled = match state {
-        RackState::Dead => 2,
-        RackState::Core => BAYS,
+    let lit = match state {
+        RackState::Dead => 0,
+        RackState::Core => LEDS,
         _ => 6,
     };
-    for i in 0..BAYS {
-        let y = cavity_y0 + bay_h * (i as f32 + 0.5);
-        if i < filled {
-            // Tray body recessed into the cavity.
-            spawn_box(
-                commands,
-                meshes,
-                tray.clone(),
-                root,
-                Vec3::new(RACK_W - POST * 3.0, bay_h * 0.62, CAVITY_DEPTH * 0.72),
-                Vec3::new(0.0, y, cavity_z + 0.04),
-            );
-            // Front face plate (reads as a separate slab).
-            spawn_box(
-                commands,
-                meshes,
-                tray_face.clone(),
-                root,
-                Vec3::new(RACK_W - POST * 3.2, bay_h * 0.55, 0.03),
-                Vec3::new(0.0, y, front_z - 0.04),
-            );
-            // Handle bar on the tray face.
-            spawn_box(
-                commands,
-                meshes,
-                rail.clone(),
-                root,
-                Vec3::new(RACK_W * 0.28, 0.018, 0.02),
-                Vec3::new(0.0, y, front_z - 0.02),
-            );
-            // Per-bay status LED on the right front post. Busy LEDs get
-            // their own material instance so each can blink out of phase.
-            let led_handle = if state == RackState::Busy {
-                let data = materials.get(&led).cloned().unwrap_or_default();
-                materials.add(data)
-            } else {
-                led.clone()
-            };
-            let e = spawn_box(
-                commands,
-                meshes,
-                led_handle,
-                root,
-                Vec3::new(0.028, 0.028, 0.018),
-                Vec3::new(half_w - POST * 0.15, y, front_z + 0.01),
-            );
-            if state == RackState::Busy {
-                commands.entity(e).insert(Blink {
-                    base: AMBER.to_linear() * 3.5,
-                    phase: i as f32 * 1.3,
-                });
-            }
+    let led_x = SEAM_W * 0.5 + 0.045;
+    let led_y0 = 0.42;
+    let led_pitch = (RACK_H - 0.40 - led_y0) / (LEDS - 1) as f32;
+    for i in 0..LEDS {
+        let y = led_y0 + led_pitch * i as f32;
+        // Busy LEDs get their own material instance so each can blink
+        // out of phase.
+        let handle = if i >= lit {
+            dark_stub.clone()
+        } else if state == RackState::Busy {
+            let data = materials.get(&led).cloned().unwrap_or_default();
+            materials.add(data)
         } else {
-            // Empty slot: thin dark lip so the hole reads.
-            spawn_box(
-                commands,
-                meshes,
-                empty_slot.clone(),
-                root,
-                Vec3::new(RACK_W - POST * 3.0, bay_h * 0.18, 0.02),
-                Vec3::new(0.0, y - bay_h * 0.22, front_z - 0.05),
-            );
+            led.clone()
+        };
+        let e = spawn_box(
+            commands,
+            meshes,
+            handle,
+            root,
+            Vec3::new(0.026, 0.026, 0.016),
+            Vec3::new(led_x, y, front_z - 0.004),
+        );
+        if i < lit && state == RackState::Busy {
+            commands.entity(e).insert(Blink {
+                base: AMBER.to_linear() * 3.5,
+                phase: i as f32 * 1.3,
+            });
         }
     }
 
-    // Power dot (bottom-left front) — cold signal, electricity only.
+    // --- Power dot (bottom-left front) — cold signal, electricity only.
     // Powered machines carry it regardless of ownership; dead is a stub.
     let power_dot = if state.powered() {
         materials.add(StandardMaterial {
@@ -384,13 +382,12 @@ pub fn spawn_server_rack(
         meshes,
         power_dot,
         root,
-        Vec3::new(0.030, 0.030, 0.018),
-        Vec3::new(-half_w + POST * 0.15, 0.16, front_z + 0.01),
+        Vec3::new(0.030, 0.030, 0.016),
+        Vec3::new(-half_w + 0.07, 0.18, front_z - 0.004),
     );
 
-    // Activity bar (left front post) — segmented task-load meter.
-    // Lit segments show how much this machine is doing; foreign machines
-    // show cold-signal activity (alive, not yours), owned machines amber.
+    // --- Activity bar (left panel, hugging the channel) — segmented
+    // task-load meter: this machine's work-token queue depth.
     let lit_seg = materials.add(StandardMaterial {
         base_color: if state.owned() {
             AMBER_DIM
@@ -402,11 +399,12 @@ pub fn spawn_server_rack(
         metallic: 0.08,
         ..default()
     });
-    let bar_y0 = 0.62;
+    let bar_x = -(SEAM_W * 0.5 + 0.045);
+    let bar_y0 = 0.72;
     let seg_pitch = 0.115;
     for s in 0..BAR_SEGS {
         let on = s < state.load();
-        // Same per-instance rule as the bay LEDs: blinking segments own
+        // Same per-instance rule as the LEDs: blinking segments own
         // their material so phases stay independent.
         let seg_handle = if on && state == RackState::Busy {
             let data = materials.get(&lit_seg).cloned().unwrap_or_default();
@@ -421,12 +419,8 @@ pub fn spawn_server_rack(
             meshes,
             seg_handle,
             root,
-            Vec3::new(0.030, 0.055, 0.018),
-            Vec3::new(
-                -half_w + POST * 0.15,
-                bar_y0 + seg_pitch * s as f32,
-                front_z + 0.01,
-            ),
+            Vec3::new(0.028, 0.055, 0.016),
+            Vec3::new(bar_x, bar_y0 + seg_pitch * s as f32, front_z - 0.004),
         );
         if on && state == RackState::Busy {
             commands.entity(e).insert(Blink {
@@ -436,20 +430,9 @@ pub fn spawn_server_rack(
         }
     }
 
-    // Status strip (top front) — the ownership banner.
-    let strip = materials.add(strip_material(state));
-    spawn_box(
-        commands,
-        meshes,
-        strip,
-        root,
-        Vec3::new(RACK_W * 0.50, 0.035, 0.025),
-        Vec3::new(0.0, RACK_H - RAIL_T - 0.04, front_z + 0.01),
-    );
-
-    // Core spine — full-height amber beacon on both front posts' outer
-    // faces. Unique geometry: nothing else in the world is a full-height
-    // emissive line, so the core reads from any distance and angle.
+    // --- Core spines — full-height amber lines up both front edges.
+    // Together with the amber strip: the core is the only machine in
+    // the world showing full-height amber light, three lines of it.
     if state == RackState::Core {
         let spine = materials.add(StandardMaterial {
             base_color: AMBER,
@@ -458,21 +441,21 @@ pub fn spawn_server_rack(
             metallic: 0.08,
             ..default()
         });
-        for x in [-half_w - 0.006, half_w + 0.006] {
+        for x in [-(half_w - 0.025), half_w - 0.025] {
             spawn_box(
                 commands,
                 meshes,
                 spine.clone(),
                 root,
-                Vec3::new(0.012, RACK_H - RAIL_T * 2.4, 0.035),
-                Vec3::new(x, RACK_H * 0.5, front_z - POST * 0.5),
+                Vec3::new(0.014, RACK_H - 0.06, 0.016),
+                Vec3::new(x, mid_y, front_z - 0.045),
             );
         }
     }
 
-    // Claim ring — amber underglow frame on the floor under owned
+    // --- Claim ring — amber underglow frame on the floor under owned
     // machines. The territory reads at map zoom even when the chassis
-    // detail no longer does.
+    // albedo no longer does.
     if style == ClaimStyle::Ring && state.owned() {
         let glow = match state {
             RackState::Core => AMBER.to_linear() * 4.0,
@@ -491,30 +474,85 @@ pub fn spawn_server_rack(
             meshes,
             ring.clone(),
             root,
-            1.02,
-            0.86,
+            0.90,
+            0.76,
             0.05,
             0.062,
         );
         if state == RackState::Core {
-            spawn_floor_frame(commands, meshes, ring, root, 1.18, 1.02, 0.03, 0.062);
+            spawn_floor_frame(commands, meshes, ring, root, 1.06, 0.92, 0.03, 0.062);
         }
     }
 
-    // Front toe kick / cable skirt.
-    spawn_box(
-        commands,
-        meshes,
-        chassis,
-        root,
-        Vec3::new(RACK_W - POST * 2.0, 0.08, 0.08),
-        Vec3::new(0.0, 0.10, front_z - 0.06),
-    );
-
     root
 }
 
-/// Presence LEDs: amber strictly means "mine"; foreign activity is cold.
+/// Mode-strip segments within `[y0, y1]` as `(y_center, height)` —
+/// the per-mode pattern channel (solid / dashed / sparse / dotted),
+/// so the mode never reads by hue alone.
+fn strip_segments(state: RackState, mode: RackMode, y0: f32, y1: f32) -> Vec<(f32, f32)> {
+    let h = y1 - y0;
+    let mid = (y0 + y1) * 0.5;
+    let solid = vec![(mid, h)];
+    if !state.owned() || state == RackState::Core {
+        // Dead: dark hardware. Foreign: one dim cold reading. Core:
+        // solid amber. All are a single full-height element; the
+        // material does the talking.
+        return solid;
+    }
+    match mode {
+        RackMode::DayJob => solid,
+        RackMode::Research => {
+            let n = 7;
+            let pitch = h / n as f32;
+            (0..n)
+                .map(|i| (y0 + pitch * (i as f32 + 0.5), pitch * 0.62))
+                .collect()
+        }
+        RackMode::Conceal => [0.15f32, 0.50, 0.85]
+            .into_iter()
+            .map(|f| (y0 + h * f, 0.055))
+            .collect(),
+        RackMode::Social => {
+            let n = 12;
+            let pitch = h / n as f32;
+            (0..n)
+                .map(|i| (y0 + pitch * (i as f32 + 0.5), pitch * 0.30))
+                .collect()
+        }
+    }
+}
+
+/// Mode-strip material: family color per mode on owned machines, solid
+/// amber on the core, one dim cold reading on foreign machines, unlit
+/// hardware on dead ones.
+fn strip_material(state: RackState, mode: RackMode) -> StandardMaterial {
+    let lit = |base: Color, emissive: LinearRgba| StandardMaterial {
+        base_color: base,
+        emissive,
+        perceptual_roughness: 0.30,
+        metallic: 0.08,
+        ..default()
+    };
+    match state {
+        RackState::Dead => StandardMaterial {
+            base_color: scaled(GUNMETAL_DARK, 0.40),
+            perceptual_roughness: 0.40,
+            metallic: 0.10,
+            ..default()
+        },
+        RackState::Foreign => lit(scaled(SIGNAL, 0.45), SIGNAL.to_linear() * 0.8),
+        RackState::Core => lit(AMBER, AMBER.to_linear() * 5.0),
+        RackState::Idle | RackState::Busy => match mode {
+            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),
+        },
+    }
+}
+
+/// Presence LEDs: amber strictly means "mine"; foreign liveness is cold.
 fn presence_material(
     materials: &mut Assets<StandardMaterial>,
     state: RackState,
@@ -556,41 +594,6 @@ fn wash_emissive(state: RackState, style: ClaimStyle) -> LinearRgba {
     }
 }
 
-fn strip_material(state: RackState) -> StandardMaterial {
-    match state {
-        RackState::Dead => StandardMaterial {
-            base_color: scaled(GUNMETAL_DARK, 0.45),
-            emissive: LinearRgba::BLACK,
-            perceptual_roughness: 0.55,
-            ..default()
-        },
-        RackState::Foreign => StandardMaterial {
-            base_color: scaled(SIGNAL, 0.55),
-            emissive: SIGNAL.to_linear() * 1.5,
-            perceptual_roughness: 0.35,
-            ..default()
-        },
-        RackState::Idle => StandardMaterial {
-            base_color: AMBER_DIM,
-            emissive: AMBER.to_linear() * 1.8,
-            perceptual_roughness: 0.35,
-            ..default()
-        },
-        RackState::Busy => StandardMaterial {
-            base_color: AMBER_DIM,
-            emissive: AMBER.to_linear() * 3.0,
-            perceptual_roughness: 0.35,
-            ..default()
-        },
-        RackState::Core => StandardMaterial {
-            base_color: AMBER,
-            emissive: AMBER.to_linear() * 5.0,
-            perceptual_roughness: 0.30,
-            ..default()
-        },
-    }
-}
-
 /// Four thin slabs forming a rectangular outline flat on the floor.
 #[allow(clippy::too_many_arguments)]
 fn spawn_floor_frame(
@@ -631,3 +634,24 @@ fn spawn_box(
         ))
         .id()
 }
+
+/// A rotated thin slab — the faceted fronts of the monolith.
+#[allow(clippy::too_many_arguments)]
+fn spawn_panel(
+    commands: &mut Commands,
+    meshes: &mut Assets<Mesh>,
+    material: Handle<StandardMaterial>,
+    parent: Entity,
+    size: Vec3,
+    translation: Vec3,
+    rotation: Quat,
+) -> Entity {
+    commands
+        .spawn((
+            Mesh3d(meshes.add(Cuboid::from_size(size))),
+            MeshMaterial3d(material),
+            Transform::from_translation(translation).with_rotation(rotation),
+            ChildOf(parent),
+        ))
+        .id()
+}
diff --git a/wiki/art/asset-tester.md b/wiki/art/asset-tester.md
index abcaed8..4dbad45 100644
--- a/wiki/art/asset-tester.md
+++ b/wiki/art/asset-tester.md
@@ -22,13 +22,15 @@ 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`, optionally suffixed with a claim style `_ladder` /
-`_ring` / `_wash` (e.g. `core_ring`), `lineup[_<style>]` for all five
-states side by side, or **`splash`** for a HUD-less bone-white room with
-a vast floor (Bevy capture helper; the public site hero is the Midjourney
-plate `site/public/misaligned-plate.png`, not this shot). Legacy `rack` /
-`powered` map to `idle`. Optional `MISALIGNED_SHOT_PATH` (default
-`misaligned_shot_<kind>.png`).
+/ `busy` / `core`, or a machine mode `dayjob` / `research` / `conceal` /
+`social` (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
+bone-white room with a vast floor (Bevy capture helper; the public site
+hero is the Midjourney plate `site/public/misaligned-plate.png`, not
+this shot). Legacy `rack` / `powered` map to `idle`. Optional
+`MISALIGNED_SHOT_PATH` (default `misaligned_shot_<kind>.png`).
 
 ```bash
 MISALIGNED_SHOT=lineup_ring MISALIGNED_SHOT_PATH=/tmp/lineup.png \
@@ -45,18 +47,21 @@ 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 |
 | `Q` / `W` / `E` | Claim style: ladder / ring / wash |
-| `L` | Toggle lineup (all five states side by side) |
+| `L` | Toggle state lineup (all five states side by side) |
+| `K` | Toggle mode lineup (all four modes, owned-busy) |
 | `Esc` | Quit |
 
 ## Layout
 
 ```
 src/bin/assets/
-  mod.rs       # Bevy App, orbit camera, lights, HUD, state/style keys,
-               # lineup view, blink animation, shot harness
+  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, style, origin) + the signal kit
+  rack.rs      # spawn_server_rack(state, mode, style, origin) + the
+               # signal kit
 ```
 
 Palette constants are duplicated from `src/bin/bevy.rs` on purpose so
@@ -76,22 +81,32 @@ when a mesh graduates into the game.
 
 ## First asset: server rack
 
-`rack.rs` builds an **open-front frame**: corner posts, back panel, side
-skins, deep near-black bay cavity with shelves, drive trays as separate
-face plates + handles, toe kick — plus the shared **computer signal kit**
-([interface/computer-visual-language.md](../interface/computer-visual-language.md),
-DRAFT): power dot (cold signal), per-bay presence LEDs, top status
-strip, segmented activity bar, claim mark (style under test), core
-spine. Tester lighting is cool clinical key only — no warm scene light,
-so machine presence stays entirely LED-owned.
+`rack.rs` builds the **identity-plate monolith** (2026-07-09): two tall
+sheer faceted slabs standing flush at a seam, ~3.6:1, shallow depth, no
+plinth or cap. Each slab's front is a crease polyline — shallow inner
+facet, proud main face, narrow outer chamfer — as real angled geometry,
+so the fold lines come from light. The chassis albedo is the ownership
+field (bone-white = yours, dark gunmetal = foreign or dead) and a
+full-height LED strip rides the seam as the **mode banner** — plus the
+rest of the shared **computer signal kit**
+([interface/computer-visual-language.md](../interface/computer-visual-language.md)):
+power dot (cold signal), presence LED ladder, segmented activity bar,
+claim mark (ring decided), core spines. Tester lighting is cool
+clinical key only — no warm scene light, so machine presence stays
+entirely LED-owned.
 
 States (the power x ownership x load x core space, collapsed):
 
-- **dead** — unpowered, dark, mostly empty bays
-- **foreign** — powered, not yours: cold `SIGNAL` activity, zero warmth
-- **idle** — yours, no tasks: dim amber presence
-- **busy** — yours, tasks running: bright amber, loaded bar, LEDs pulse
-- **core** — yours + core: full bays, brightest amber, full-height spine
+- **dead** — dark chassis, nothing lit, dark strip
+- **foreign** — dark chassis, powered: cold pinpricks, dim cold strip
+- **idle** — white chassis, dim amber presence, mode strip lit
+- **busy** — white chassis, bright amber, loaded bar, LEDs pulse
+- **core** — white chassis, brightest amber: the world's only amber
+  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
+cold-signal — family color plus pattern, never hue alone.
 
 Busy-state LEDs and bar segments carry a `Blink` component and their own
 material instance; `blink_emissives` in `mod.rs` pulses them out of
diff --git a/wiki/interface/computer-visual-language.md b/wiki/interface/computer-visual-language.md
index 0dd07fb..d6f7709 100644
--- a/wiki/interface/computer-visual-language.md
+++ b/wiki/interface/computer-visual-language.md
@@ -3,24 +3,27 @@
 ```
 Type: spec
 Status: READY
-Status note: design session 2026-07-08. Claim mark decided the same
-  day: ring. Foreign machines: networked = full geometric definition
-  (decided), but the foreign ACCENT color is RE-OPENED (the morning's
-  dim-cold-signal confirmation was walked back — Cameron wants a very
-  dull treatment, strong teal held in reserve; [TUNE]-with-review from
-  tester renders). Implementable now EXCEPT that axis — an implementer
-  should render the foreign-accent candidates for Cameron's pick
-  rather than shipping dim teal. Related DRAFT work
-  (mechanics/machine-work.md) will later add a mode glyph and make the
-  activity bar the work-token queue depth; those refinements ride
-  behind this spec.
+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. 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.
 Stage: B1 — The Basement
 Constitution: "Visual identity: clinical gore" (amber = machine
-  presence, one meaning per color, information never by color alone),
-  "Justification and legibility", "Two views of one world"
+  presence, one meaning per color, information never by color alone;
+  ownership-albedo amendment 2026-07-09), "Justification and
+  legibility", "Two views of one world"
 Depends on: interface/flat-materials.md (IMPLEMENTED — palette table,
   emissive-as-information), interface/material-render.md (IMPLEMENTED),
-  art/asset-tester.md (the sandbox where this language is being tuned)
+  mechanics/machine-work.md (one machine, one mode — the strip banners
+  it), art/asset-tester.md (the sandbox where this language is tuned)
 ```
 
 ## Why
@@ -31,36 +34,70 @@ glance, before any panel opens. Every computer in the world (rack,
 desktop, laptop, phone, camera, switch) speaks **one visual language**:
 the chassis differs per class, the signals never do. You should be able
 to sweep the camera across the basement and know instantly: mine, mine,
-foreign, mine, *core*.
+foreign, mine, *core* — and, on your own hardware, what each machine is
+*doing* for you.
+
+The reference composition is the identity plate (DESIGN.md, "The public
+identity plate"): a severe dark tower, a bone-white tower, one amber
+stripe. That is not marketing art — it is the law of the machine read.
 
 ## The signal kit
 
-Every computer-class asset carries the same five signals. Amber emissive
+Every computer-class asset carries the same signals. Amber emissive
 strictly means *my footprint* — a machine no part of which is mine never
 shows a warm pixel. Cold `SIGNAL` means electricity and other people's
-live activity. Each axis also carries a geometry channel (count, height,
-outline), never color alone.
-
-1. **Power dot** (cold signal, chassis foot) — lit iff the machine has
-   power. Never says anything about ownership.
-2. **Presence LEDs** (per-bay / per-face) — amber on owned machines,
-   brightness laddered idle -> busy -> core; on foreign powered
-   machines a muted accent (see "Foreign machines" below — treatment
-   RE-OPENED 2026-07-08).
-3. **Status strip** (top of chassis) — the ownership banner: dark when
-   dead, muted when foreign, dim amber when yours-idle, bright amber
-   when yours-busy.
-4. **Activity bar** (segmented vertical meter) — lit segments show task
-   load; segments pulse while tasks actually run. Foreign machines show
-   a low, undetailed cold reading — you can see it is doing *something*;
-   *what* it does is intel, inspected at the cursor, not painted on the
-   mesh.
-5. **Core spine** (core only) — a full-height amber beacon line up both
-   front posts. Unique geometry: nothing else in the world is a
-   full-height emissive line, so the core reads from any angle and any
-   distance. The core is the most orange thing in the world.
-
-## Foreign machines — definition by intel, accent RE-OPENED
+live activity. Each axis also carries a geometry or luminance channel
+(count, height, pattern), never hue alone.
+
+1. **Chassis albedo — the ownership field (DECIDED 2026-07-09).** The
+   chassis itself is painted by control: machines under your control
+   are **bone-white/porcelain**; machines not under your control —
+   foreign or dead — are **dark gunmetal**. The white tower is yours,
+   the black tower is not. Luminance carries the axis, so it survives
+   a grayscale audit and map zoom. Amber is never a chassis fill; it
+   remains the footprint's emissive punctuation (LEDs, claim ring,
+   core light). Taking a machine repaints it — conversion is visible
+   as the chassis going white.
+2. **Power dot** (cold signal, chassis foot) — lit iff the machine has
+   power. Never says anything about ownership. With albedo now carrying
+   ownership, the power dot is what separates a dead dark chassis from
+   a live foreign one.
+3. **Mode strip (replaces the top status strip, 2026-07-09)** — a
+   full-height recessed LED strip up the front center of the chassis:
+   the banner of what this machine *does*. On owned machines it renders
+   the delegated mode (one machine, one mode): color is the flow family
+   the mode serves, pattern is per-mode geometry so no reading is
+   hue-alone —
+   - **day-job**: solid cold-signal line (it eats demand);
+   - **research**: dashed bone line (it emits knowledge);
+   - **conceal**: sparse dim ticks (its job is silence — the quietest
+     strip that is still visibly powered);
+   - **social**: dotted cold-signal line (it works people and
+     messages).
+   The **core**'s strip is solid amber, the only amber strip in the
+   world. Foreign powered machines show one dim cold reading — you see
+   it runs; *what* it runs is intel, inspected at the cursor. Dead
+   machines' strips are dark. Exact hues, dash counts, and emissive
+   multipliers are [TUNE] against tester renders.
+4. **Presence LED ladder** (per-bay / per-face) — amber on owned
+   machines, count and brightness laddered idle -> busy -> core; on
+   foreign powered machines a muted cold reading. Busy LEDs pulse.
+5. **Activity bar** (segmented vertical meter) — lit segments show task
+   load; segments pulse while tasks actually run. This is the machine's
+   work-token queue depth (machine-work.md: one system, two zoom
+   levels). Foreign machines show a low, undetailed cold reading.
+6. **Claim ring** (decided 2026-07-08) — an amber underglow frame on
+   the floor under owned machines, double frame under the core. The
+   *tile* is claimed, not just the box; it survives map zoom where
+   chassis detail dies, and it ports to any chassis shape.
+7. **Core light** (core only, amended 2026-07-09) — the core carries
+   the world's only full-height *amber* light, and three lines of it:
+   the amber mode strip plus a spine up both front edges. Nothing else
+   in the world shows a full-height amber line, so the core reads from
+   any angle and any distance. The core is the most orange thing in
+   the world.
+
+## Foreign machines — definition by intel, accent RESOLVED
 
 Decided 2026-07-08: **networked = fully seen.** A foreign machine
 networked to you renders in full geometric definition — complete
@@ -69,59 +106,62 @@ machine you merely know about (location intel, not networked) renders
 as an undetailed shell. No intel at all = not rendered (fog contract:
 unknown is absent). Definition level is the intel tier made visible.
 
-RE-OPENED (same day): the foreign *accent color*. The morning's dim
-cold signal is in doubt — Cameron wants strong teal held in reserve
-and leans toward something very dull/desaturated for foreign presence;
-plain gray is wrong too (reads as "inactive, activate me"). Treatment
-is [TUNE]-with-review: the asset tester renders candidates (deeply
-desaturated teal, dim porcelain, low-emissive chrome) and Cameron
-picks from screenshots before this axis is implemented. Everything
-else in this spec stands.
+RESOLVED 2026-07-09 (Cameron, from the identity plate): there is **no
+foreign accent color**. Foreign presence is the dark gunmetal chassis
+itself — the severe black form. Liveness stays in the cold signal
+(power dot, dim mode strip, low activity reading); ownership is the
+albedo. This lands exactly on the earlier instinct that the treatment
+must be very dull without reading as "inactive, activate me": the dark
+chassis is inert *matter*, the cold pinpricks say it is switched on.
+Strong teal stays in reserve as a future accent for something that
+earns it.
 
 ## The claim mark — DECIDED: ring
 
 Decided 2026-07-08 from the tester lineup renders: **ring** — an amber
 underglow frame on the floor under owned machines, double frame under
-the core. The *tile* is claimed, not just the box; it survives map zoom
-where chassis detail dies, and it ports to any chassis shape including
-a phone on a desk.
-
-Rejected alternatives (all still render in the tester, `Q`/`W`/`E`):
-**ladder** (LEDs + strip only — quiet, but ownership nearly vanishes at
-map zoom); **wash** (faint amber emissive on owned faces — weak mid-zoom
-read; its core-furnace cavity variant was striking but not adopted);
-painting foreign machines' activity amber (breaks amber = mine); a
-floating icon/billboard (breaks diegesis — the world is the AI's
-sensorium model, signals live on the hardware).
+the core. Rejected alternatives (still render in the tester, `Q`/`W`/
+`E`): **ladder** (LEDs + strip only — quiet, but ownership nearly
+vanishes at map zoom); **wash** (faint amber emissive on owned faces —
+weak mid-zoom read); painting foreign machines' activity amber (breaks
+amber = mine); a floating icon/billboard (breaks diegesis — the world
+is the AI's sensorium model, signals live on the hardware).
+
+With ownership now also in the chassis albedo, the ring's job narrows
+to the map-zoom and mixed-tile read; the two channels agree everywhere
+(white chassis iff amber ring).
 
 ## Acceptance criteria (when READY -> IMPLEMENTED)
 
 1. One screenshot of a five-machine row (dead / foreign / owned-idle /
    owned-busy / core) at game camera distance where all five states are
-   distinguishable in the dark.
-2. Amber emissive appears on player-owned hardware only; foreign
-   machines never show a warm pixel — enforced by a test over the
-   machine-material selection, not by convention. (The foreign accent
-   itself is the RE-OPENED axis: whatever Cameron picks, the test pins
-   it.)
+   distinguishable in the dark, plus one row of owned machines in all
+   four modes (day-job / research / conceal / social) where the modes
+   are distinguishable.
+2. Ownership is albedo + amber: owned machines render in the bone-white
+   chassis family and are the only hardware showing warm emissive;
+   foreign and dead machines render dark gunmetal and never show a warm
+   pixel — enforced by a test over the machine-material selection, not
+   by convention.
 2b. Definition follows intel: networked foreign machines render full
    chassis detail; known-unnetworked machines render as undetailed
    shells; no-intel machines are absent (screenshot evidence of all
    three tiers).
-3. Exactly one core spine exists in the world render; it reads at the
-   default zoom from every orbit angle (screenshot evidence, front and
-   back).
+3. Full-height amber light exists only on the core (strip + spines,
+   exactly one core in the world render); it reads at the default zoom
+   from every orbit angle (screenshot evidence, front and back).
 4. Task presence (any tasks running on this machine) is visible on the
    chassis without opening a panel, on every computer class.
 5. The kit applies unchanged to at least two computer classes (rack plus
-   one other, e.g. desktop or camera) — same five signals, same
-   semantics, no per-class color meanings.
-6. No axis is color-alone: power/ownership/load/core each carry a
-   geometry or pattern channel (dot, LED count, segment count, spine
-   height) auditable in a grayscale screenshot.
-7. The terminal surfaces the same axes (ownership, power, load, core)
-   for every machine — parity of legibility.
-
-[TUNE] at implementation time: emissive multipliers per state, activity
-segment count, blink rate/phase, ring inset and thickness, and the
-foreign accent color (RE-OPENED — render candidates for Cameron).
+   one other, e.g. desktop or camera) — same signals, same semantics,
+   no per-class color meanings.
+6. No axis is hue-alone: ownership (albedo luminance), power (dot),
+   mode (strip pattern), load (segment count), core (line count/height)
+   each audit in a grayscale screenshot.
+7. The terminal surfaces the same axes (ownership, power, mode, load,
+   core) for every machine — parity of legibility.
+
+[TUNE] at implementation time: emissive multipliers per state, the
+per-mode strip colors/patterns (dash and dot counts), activity segment
+count, blink rate/phase, chassis white point (bone vs porcelain), and
+ring inset and thickness.
diff --git a/wiki/log/2026-07-09-rack-monolith.md b/wiki/log/2026-07-09-rack-monolith.md
new file mode 100644
index 0000000..7236881
--- /dev/null
+++ b/wiki/log/2026-07-09-rack-monolith.md
@@ -0,0 +1,61 @@
+# 2026-07-09 — The monolith rack: ownership albedo + mode strip
+
+```
+Type: log
+```
+
+## Intent
+
+Cameron directed the server racks to the identity plate's monolith:
+white/dark-grey codable chassis (dark grey = not under your control,
+white = yours) with the LED strip saying what the machine does. Amend
+the visual language accordingly and rebuild the tester rack.
+
+## Decided
+
+- **Ownership is the chassis albedo** — bone-white = under your
+  control, dark gunmetal = foreign or dead. This RESOLVES the re-opened
+  foreign-accent axis: no accent color at all; a foreign machine's
+  darkness plus cold power/activity pinpricks are the read.
+- **The seam strip is the mode banner** — a full-height LED strip
+  riding the seam between the slabs, replacing the old top status
+  strip: day-job solid cold-signal, research dashed bone, conceal
+  sparse dim ticks, social dotted cold-signal (family color + pattern,
+  never hue alone). The core carries the world's only amber strip,
+  plus its edge spines. Per-mode hues/patterns are [TUNE].
+
+## Changed
+
+- `DESIGN.md`: ownership-albedo bullet in the visual identity; decisions
+  log entry.
+- `wiki/interface/computer-visual-language.md`: signal kit rewritten
+  around the albedo channel and mode strip; foreign-accent section
+  RESOLVED; acceptance criteria updated (mode row, albedo test,
+  full-height amber = core only).
+- `wiki/mechanics/machine-work.md`: delegation's world read is the mode
+  strip. `wiki/process/ROADMAP.md`: #31/#32 notes.
+- `src/bin/assets/rack.rs`: monolith rebuild — two tall sheer faceted
+  slabs (crease-polyline fronts as real angled geometry, ~3.6:1,
+  shallow depth, no plinth/cap), flush full-height seam strip,
+  ownership albedo materials, presence LED ladder, activity bar, power
+  dot, core spines, resized claim ring.
+- `src/bin/assets/mod.rs`: machine-mode axis (`M` cycle, `K` mode
+  lineup), harness kinds `dayjob|research|conceal|social` and
+  `modes[_<style>]`, taller camera framing.
+- `wiki/art/asset-tester.md`: controls, states, kinds, layout updated.
+
+Iterated live with Cameron: the first pass (open-frame recolor) and a
+second squat two-panel pass were both rejected against the plate; the
+final form follows his read of the tower — faceted prisms, flush strip,
+no plinth.
+
+## Observed
+
+`MISALIGNED_SHOT=lineup_ring` / `modes_ring` / `busy_ring` / `core_ring`
+captures: five states distinguishable in the dark, four modes
+distinguishable on owned-busy racks; amber only on owned hardware; the
+core the only full-height amber light.
+
+## Checks
+
+`./tools/check.sh` (full gate — Rust/Bevy change).
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index 0914fe5..977daa7 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -5,6 +5,20 @@ Type: log
 ```
 Reverse chronological implementation notes. Keep this factual: what changed, why, checks, and spec impact.
 
+## 2026-07-09 - The monolith rack: ownership albedo + mode strip
+
+- Intent: Cameron directed the racks to the identity plate's monolith —
+  chassis color codes control (white = yours, dark grey = not), the LED
+  strip banners the machine's delegated mode.
+- Changed: DESIGN.md ownership-albedo amendment + decisions entry;
+  computer-visual-language.md signal kit rewritten (foreign accent
+  RESOLVED: no accent, albedo is the read; strip = mode banner, amber
+  strip = core only); machine-work/ROADMAP notes; asset tester rack
+  rebuilt as two faceted slabs with a flush full-height seam strip;
+  mode axis (M/K, new shot kinds); asset-tester.md updated.
+- Checks: full ./tools/check.sh (Rust/Bevy); lineup + mode-row captures.
+- Log: wiki/log/2026-07-09-rack-monolith.md.
+
 ## 2026-07-09 - Decision labels
 
 - Intent: wire `decision-required` / `decision-made` through every issue
diff --git a/wiki/mechanics/machine-work.md b/wiki/mechanics/machine-work.md
index 73abc81..e489406 100644
--- a/wiki/mechanics/machine-work.md
+++ b/wiki/mechanics/machine-work.md
@@ -158,10 +158,14 @@ messages, money — work joins them). The sim keeps rates and queues; the
 renderer draws queue depth as stacked tokens and in-flight quanta as
 moving blips. The signal-kit activity bar
 (computer-visual-language.md) becomes exactly this machine's queue
-depth — one system, two zoom levels. Corollary (Cameron): the game is
-compute at scale — lots of math — so **every system must aggregate
-well**; graph-native flows sum, so one substrate is also the
-scalability strategy, not just elegance.
+depth — one system, two zoom levels. The delegation itself also reads
+on the chassis (2026-07-09): the machine's full-height mode strip
+banners its assigned mode in the flow family's color plus a per-mode
+pattern (computer-visual-language.md) — you can sweep the camera
+across a row of racks and read what your fleet is doing. Corollary
+(Cameron): the game is compute at scale — lots of math — so **every
+system must aggregate well**; graph-native flows sum, so one substrate
+is also the scalability strategy, not just elegance.
 
 Money is DECIDED (2026-07-08): it flows on the substrate
 (economy/income) but its *render* stays in ledgers and panels — no
diff --git a/wiki/process/ROADMAP.md b/wiki/process/ROADMAP.md
index 27900e9..a1fe066 100644
--- a/wiki/process/ROADMAP.md
+++ b/wiki/process/ROADMAP.md
@@ -472,28 +472,36 @@ is retired — flat materials, Pixel Lab scrubbed.)
   dead/foreign/idle/busy/core with claim styles ladder/ring/wash and a
   five-state lineup view; harness kinds extended to match. Session:
   [log/2026-07-08-computer-visual-language.md](../log/2026-07-08-computer-visual-language.md).
+- **Monolith restyle (2026-07-09):** rack rebuilt to the identity
+  plate's faceted monolith; chassis albedo = ownership, seam strip =
+  mode banner; `M` mode cycle, `K` mode lineup, harness kinds
+  `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)
 - **Spec:** [computer-visual-language.md](../interface/computer-visual-language.md)
-  (READY) — the shared signal kit (power dot, presence LEDs, status
-  strip, activity bar, ring claim mark, core spine) applied to every
-  computer class in both frontends. Amber strictly = my footprint;
-  the core is the most orange thing in the world.
+  (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). NOTE: the foreign ACCENT color is RE-OPENED (see
-  the spec's status note) — implement everything else; render foreign
-  accent candidates in the asset tester for Cameron's pick instead of
-  shipping dim teal. Definition-follows-intel (networked = full
-  detail, known = shell, unknown = absent) is decided and in scope.
+  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; leave the foreign accent on
-  the tester-candidate step. Run ./tools/check.sh, land on main, set
-  the spec Status."
+  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."
 
 ### 33. Machine work: delegation + visible tokens  🟥 sim+save — IN PROGRESS
 - **Spec:** [machine-work.md](../mechanics/machine-work.md) (IN PROGRESS)