diff --git a/DESIGN.md b/DESIGN.md
index 467e9533..5686a2dc 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -493,10 +493,15 @@ sharpened version of Evil Genius's science-base fantasy:
   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.
+  footprint's emissive punctuation (claim ring, core light).
+- **The strip is the machine's only lamp (adopted 2026-07-09, sleek
+  amendment).** The hero plate has no scatter of little lights: one severe
+  form, one band. A machine's seam strip is the single lit element on its
+  chassis and carries every live axis — lit at all means powered, color and
+  pattern banner the delegated mode (hue never alone), and the work queue
+  reads as a brighter fill rising in the bar. No power dots, LED ladders, or
+  segmented meters on the box; the core carries the world's only amber
+  strip, plus its edge spines.
 - 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.
@@ -2483,3 +2488,14 @@ knows."*
   the decided taxonomy without choosing the remaining job-flow question: the
   global Operations pool is still explicitly staging, and Tangled issue
   `3mqajev47rq2s` remains open.
+- **2026-07-09 — Sleek kit: the strip is the machine's only lamp.** Cameron
+  directed the chassis back to the hero plate's severity: no scatter of
+  little lights — the power dot, presence LED ladder, and segmented activity
+  bar are removed from every computer chassis, and their axes fold into the
+  one seam strip (lit at all = powered; a foreign machine's dim cold band =
+  liveness; color + pattern = the delegated mode; the work-token queue depth
+  = a brighter fill rising in the bar, which pulses while busy). Amber
+  punctuation narrows to the claim ring and the core light. Amended into
+  wiki/interface/computer-visual-language.md (new criterion 8: no other
+  emissive pixel on the box); applied in the shared chassis library, so the
+  tester and the game changed together.
diff --git a/src/bin/assets/rack.rs b/src/bin/assets/rack.rs
index 62e5a1d1..40c9b6a2 100644
--- a/src/bin/assets/rack.rs
+++ b/src/bin/assets/rack.rs
@@ -4,9 +4,10 @@
 //! = 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 / 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.
+//! core only, and the work-token queue depth as a brighter fill
+//! rising in the bar), the claim mark, and the core spines. The strip
+//! is the chassis's single lit element (sleek kit, 2026-07-09 — the
+//! hero plate has no little lights). No image textures.
 //! Spec: wiki/interface/computer-visual-language.md.
 //!
 //! Shared chassis library: this file is compiled into BOTH
@@ -179,7 +180,6 @@ 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;
 
 /// Chassis albedo is the ownership field: bone-white family for owned
@@ -231,13 +231,6 @@ pub fn spawn_server_rack(
         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,
@@ -330,137 +323,81 @@ pub fn spawn_server_rack(
         Vec3::new(0.0, mid_y, -0.015),
     );
 
-    // --- 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.
+    // --- The strip: the chassis's ONE lit element (sleek kit,
+    // 2026-07-09 — the hero plate has no little lights). Full-height
+    // band riding the seam, flush with the slab fronts. It carries
+    // every live axis at once: lit at all = powered (a dead machine's
+    // strip is dark hardware), color + pattern = the delegated mode
+    // (amber only on the core), and the work-token queue depth reads
+    // as a brighter fill rising from the foot of the bar — brightness
+    // and height, no extra elements. Busy fill pulses.
     let strip_y0 = 0.02;
     let strip_y1 = RACK_H - 0.02;
+    let load_frac = if state.owned() {
+        (load.unwrap_or_else(|| state.load()).min(BAR_SEGS) as f32 / BAR_SEGS as f32)
+            .clamp(0.0, 1.0)
+    } else {
+        0.0
+    };
+    let y_fill = strip_y0 + (strip_y1 - strip_y0) * load_frac;
     let strip = materials.add(strip_material(state, mode));
+    let fill_data = strip_fill_material(state, mode);
+    let fill = materials.add(fill_data.clone());
     for (yc, seg_h) in strip_segments(state, mode, strip_y0, strip_y1) {
-        spawn_box(
-            commands,
-            meshes,
-            strip.clone(),
-            root,
-            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(
+        let lo = yc - seg_h * 0.5;
+        let hi = yc + seg_h * 0.5;
+        // Split each pattern segment at the fill line: below reads as
+        // the bright load column, above as the resting banner.
+        let mut parts: [(f32, f32, bool); 2] = [(yc, seg_h, false), (0.0, 0.0, false)];
+        let mut n = 1;
+        if load_frac > 0.0 && lo < y_fill {
+            let top = hi.min(y_fill);
+            parts[0] = ((lo + top) * 0.5, top - lo, true);
+            n = 1;
+            if hi > y_fill {
+                parts[1] = ((y_fill + hi) * 0.5, hi - y_fill, false);
+                n = 2;
+            }
+        }
+        for &(pyc, ph, bright) in parts.iter().take(n) {
+            if ph <= 0.003 {
+                continue;
+            }
+            // Blinking fill owns its material so phases stay independent.
+            let handle = if bright && state == RackState::Busy {
+                materials.add(fill_data.clone())
+            } else if bright {
+                fill.clone()
+            } else {
+                strip.clone()
+            };
+            let e = spawn_box(
                 commands,
                 meshes,
-                strip.clone(),
+                handle,
                 root,
-                Vec3::new(0.034, seg_h, 0.016),
-                Vec3::new(0.0, yc, -front_z + 0.006),
+                Vec3::new(0.034, ph, 0.016),
+                Vec3::new(0.0, pyc, front_z - 0.006),
             );
-        }
-    }
-
-    // --- Presence LED ladder (right panel, hugging the channel) —
-    // amber strictly means "mine"; foreign liveness reads cold.
-    let led = presence_material(materials, state);
-    let lit = match state {
-        RackState::Dead => 0,
-        RackState::Core => LEDS,
-        _ => 6,
-    };
-    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 {
-            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.018),
-        );
-        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.
-    // Powered machines carry it regardless of ownership; dead is a stub.
-    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.030, 0.030, 0.016),
-        Vec3::new(-half_w + 0.07, 0.18, front_z - 0.018),
-    );
-
-    // --- 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
-        } else {
-            scaled(SIGNAL, 0.55)
-        },
-        emissive: bar_emissive(state),
-        perceptual_roughness: 0.30,
-        metallic: 0.08,
-        ..default()
-    });
-    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 < 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 {
-            let data = materials.get(&lit_seg).cloned().unwrap_or_default();
-            materials.add(data)
-        } else if on {
-            lit_seg.clone()
-        } else {
-            dark_stub.clone()
-        };
-        let e = spawn_box(
-            commands,
-            meshes,
-            seg_handle,
-            root,
-            Vec3::new(0.028, 0.055, 0.016),
-            Vec3::new(bar_x, bar_y0 + seg_pitch * s as f32, front_z - 0.018),
-        );
-        if on && state == RackState::Busy {
-            commands.entity(e).insert(Blink {
-                base: bar_emissive(state),
-                phase: 2.0 + s as f32 * 0.9,
-            });
+            if bright && state == RackState::Busy {
+                commands.entity(e).insert(Blink {
+                    base: fill_data.emissive,
+                    phase: pyc * 2.0,
+                });
+            }
+            // 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,
+                    if bright { fill.clone() } else { strip.clone() },
+                    root,
+                    Vec3::new(0.034, ph, 0.016),
+                    Vec3::new(0.0, pyc, -front_z + 0.006),
+                );
+            }
         }
     }
 
@@ -576,50 +513,23 @@ fn strip_material(state: RackState, mode: RackMode) -> StandardMaterial {
             ..default()
         },
         RackState::Foreign => lit(scaled(SIGNAL, 0.45), SIGNAL.to_linear() * 0.8),
-        RackState::Core => lit(AMBER, AMBER.to_linear() * 5.0),
+        RackState::Core => lit(AMBER, AMBER.to_linear() * 2.8),
         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::Operations => lit(SIGNAL, SIGNAL.to_linear() * 1.8),
+            RackMode::DayJob => lit(SIGNAL, SIGNAL.to_linear() * 1.6),
+            RackMode::Research => lit(BONE, BONE.to_linear() * 1.4),
+            RackMode::Conceal => lit(scaled(SIGNAL, 0.60), SIGNAL.to_linear() * 0.6),
+            RackMode::Operations => lit(SIGNAL, SIGNAL.to_linear() * 1.3),
         },
     }
 }
 
-/// Presence LEDs: amber strictly means "mine"; foreign liveness is cold.
-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),
-        RackState::Idle => (AMBER_DIM, AMBER.to_linear() * 1.6),
-        RackState::Busy => (AMBER_DIM, AMBER.to_linear() * 3.5),
-        RackState::Core => (AMBER, AMBER.to_linear() * 5.0),
-    };
-    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 {
-    match state {
-        RackState::Dead => LinearRgba::BLACK,
-        RackState::Foreign => SIGNAL.to_linear() * 1.4,
-        RackState::Idle => AMBER.to_linear() * 1.6,
-        RackState::Busy => AMBER.to_linear() * 3.5,
-        RackState::Core => AMBER.to_linear() * 3.0,
-    }
+/// The load fill: the same strip material with its emissive lifted,
+/// so the work-token queue depth reads as light rising in the one
+/// bar. Same hue family always — the fill never recolors the mode.
+fn strip_fill_material(state: RackState, mode: RackMode) -> StandardMaterial {
+    let mut m = strip_material(state, mode);
+    m.emissive *= if state == RackState::Core { 1.9 } else { 2.6 };
+    m
 }
 
 fn wash_emissive(state: RackState, style: ClaimStyle) -> LinearRgba {
@@ -703,23 +613,19 @@ 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.
+/// Spawn a network-switch chassis at `origin` — the same anatomy as
+/// the rack at a fraction of the mass (sleek kit: chassis-albedo
+/// ownership, the seam strip as the single lit element, claim ring).
 /// 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>,
@@ -737,12 +643,6 @@ pub fn spawn_switch_chassis(
         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((
@@ -757,7 +657,6 @@ pub fn spawn_switch_chassis(
         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;
@@ -812,93 +711,6 @@ pub fn spawn_switch_chassis(
         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 {
@@ -1117,48 +929,54 @@ mod tests {
                     !warm(strip_material(state, mode).emissive),
                     "{state:?}/{mode:?} strip must not glow warm"
                 );
+                assert!(
+                    !warm(strip_fill_material(state, mode).emissive),
+                    "{state:?}/{mode:?} fill 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.
+    /// The load fill obeys the same law.
     #[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),
+                    warm(strip_material(state, mode).emissive),
                     state == RackState::Core,
                     "warm strip on {state:?}/{mode:?}"
                 );
+                assert_eq!(
+                    warm(strip_fill_material(state, mode).emissive),
+                    state == RackState::Core,
+                    "warm fill on {state:?}/{mode:?}"
+                );
             }
         }
     }
 
-    /// Owned presence is amber, laddered idle -> busy -> core; foreign
-    /// liveness stays cold.
+    /// The load fill brightens the strip without recoloring it: same
+    /// hue family, strictly more light — queue depth reads as light
+    /// rising in the one bar (sleek kit).
     #[test]
-    fn presence_ladder_is_owned_amber() {
+    fn load_fill_brightens_never_recolors() {
         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");
+            for mode in RackMode::ALL {
+                let base = strip_material(state, mode);
+                let fill = strip_fill_material(state, mode);
+                assert!(
+                    fill.emissive.red + fill.emissive.green + fill.emissive.blue
+                        > base.emissive.red + base.emissive.green + base.emissive.blue,
+                    "{state:?}/{mode:?} fill must outshine the resting strip"
+                );
+                assert_eq!(
+                    fill.base_color, base.base_color,
+                    "{state:?}/{mode:?} fill must not change the mode color"
+                );
+            }
         }
-        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 d6e461f1..9084fbd8 100644
--- a/src/bin/bevy.rs
+++ b/src/bin/bevy.rs
@@ -1575,7 +1575,6 @@ fn spawn_chassis(
                 meshes,
                 materials,
                 v.state,
-                Some(v.load as usize),
                 ClaimStyle::Ladder,
                 pos,
                 Some(root),
diff --git a/wiki/art/asset-tester.md b/wiki/art/asset-tester.md
index e6b27a9d..dd8fa801 100644
--- a/wiki/art/asset-tester.md
+++ b/wiki/art/asset-tester.md
@@ -95,11 +95,13 @@ 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 graphics (2026-07-09
+full-height LED strip rides the seam as the chassis's **only lit
+element** (sleek amendment 2026-07-09,
+[interface/computer-visual-language.md](../interface/computer-visual-language.md)):
+lit at all = powered, color + pattern = the delegated mode, and the
+work queue reads as a brighter fill rising in the bar. The claim mark
+(ring decided) and the core spines complete the kit — no power dots,
+LED ladders, or segmented meters. Tester graphics (2026-07-09
 pass): a near-neutral directional key rakes in from the left-front so
 facet creases shade and whites stay white, with cold fill and rim
 lights; the camera runs HDR with TonyMcMapface tonemapping and
@@ -109,12 +111,13 @@ presence stays entirely LED-owned.
 
 States (the power x ownership x load x core space, collapsed):
 
-- **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
+- **dead** — dark chassis, dark strip: unlit hardware
+- **foreign** — dark chassis, one dim cold strip: it runs, that is all
+  you get
+- **idle** — white chassis, resting mode strip with a low fill
+- **busy** — white chassis, the strip's bright fill risen high, pulsing
+- **core** — white chassis, the world's only amber strip (front and
+  back), plus spines up both front edges
 
 Modes (owned machines, `M` / `K`): day-job solid cold-signal strip,
 research dashed bone, conceal sparse dim ticks, operations dotted
@@ -130,7 +133,7 @@ slug keeping the material read. A paused frame carries amount through
 geometry alone. Exposure has no tester art: its surface treatment is
 HOLD under Tangled issue #1.
 
-Busy-state LEDs and bar segments carry a `Blink` component and their own
+The busy strip's fill segments carry a `Blink` component and their own
 material instance; `blink_emissives` in `mod.rs` pulses them out of
 phase so activity reads as motion in the interactive tester (static in
 harness shots by design — count and brightness still separate the
diff --git a/wiki/interface/computer-visual-language.md b/wiki/interface/computer-visual-language.md
index c780c0c0..cce6165e 100644
--- a/wiki/interface/computer-visual-language.md
+++ b/wiki/interface/computer-visual-language.md
@@ -10,17 +10,21 @@ Status note: implemented 2026-07-09 (ROADMAP #32) after the same-day
   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.
+  from control (compute machines + device controller), the strip from
+  WorkGrid delegation with its load fill from work-token queue depths,
+  the tile-scale claim ring (double under the core), and the core's
+  amber strip front AND back plus edge spines. SLEEK AMENDMENT (same
+  day, Cameron, from the hero plate): the strip is the chassis's ONLY
+  lit element — the power dot, presence LED ladder, and segmented
+  activity bar were removed and their axes folded into the strip
+  (lit-ness = power/liveness; brighter fill height = queue depth).
   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},
+  and never a warm pixel; warm strip = core only; the load fill
+  brightens but never recolors). 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
@@ -61,13 +65,19 @@ 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
+## The signal kit — the sleek amendment (2026-07-09)
 
 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 or luminance channel
-(count, height, pattern), never hue alone.
+(height, pattern, luminance), never hue alone.
+
+**Sleek rule (Cameron, 2026-07-09): the strip is the chassis's only lit
+element.** The hero plate has no scatter of little lights — one severe
+form, one band. The earlier power dot, presence LED ladder, and
+segmented activity bar are REMOVED from the chassis; every axis they
+carried folds into the strip.
 
 1. **Chassis albedo — the ownership field (DECIDED 2026-07-09).** The
    chassis itself is painted by control: machines under your control
@@ -75,47 +85,39 @@ live activity. Each axis also carries a geometry or luminance channel
    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);
-   - **operations**: dotted cold-signal line (it reserves capacity for
-     player-authored work across digital, social, and other actuator channels).
-   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
+   remains the footprint's emissive punctuation (claim ring, core
+   light). Taking a machine repaints it — conversion is visible as the
+   chassis going white.
+2. **The strip** — one full-height recessed LED band riding the seam,
+   the machine's single lamp. It carries every live axis at once:
+   - **Power / liveness:** lit at all iff the machine is powered — a
+     dead machine's strip is dark hardware in a dark groove; a foreign
+     powered machine shows one dim cold reading (you see it runs;
+     *what* it runs is intel, inspected at the cursor).
+   - **Mode** (owned machines; 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 (it eats
+     demand); **research** dashed bone (it emits knowledge);
+     **conceal** sparse dim ticks (its job is silence); **operations**
+     dotted cold-signal (player-authored work). The **core**'s strip
+     is solid amber, the only amber strip in the world.
+   - **Load:** the work-token queue depth reads as a **brighter fill
+     rising from the foot of the bar** (machine-work.md: one system,
+     two zoom levels) — height and luminance, no extra elements; the
+     fill never recolors the mode. The busy fill pulses; a paused
+     frame still carries the amount.
+   Exact hues, dash counts, fill multipliers are [TUNE] against tester
+   renders.
+3. **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
+4. **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.
+   the amber strip (front and back of the seam) 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
 
@@ -128,9 +130,8 @@ unknown is absent). Definition level is the intel tier made visible.
 
 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
+itself — the severe black form. Liveness stays in the cold signal (the
+dim strip); 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
@@ -171,17 +172,21 @@ to the map-zoom and mixed-tile read; the two channels agree everywhere
    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.
+   chassis without opening a panel, on every computer class — the
+   strip's load fill (height + luminance).
 5. The kit applies unchanged to at least two computer classes (rack plus
    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.
+6. No axis is hue-alone: ownership (albedo luminance), power (strip
+   lit-ness), mode (strip pattern), load (fill height), 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.
+8. Sleek rule: the strip is the only lit element on the chassis — no
+   other emissive pixel on the box (the claim ring lives on the floor,
+   the core spines are the core's exception).
 
 [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.
+per-mode strip colors/patterns (dash and dot counts), the load-fill
+brightness factor, blink rate/phase, chassis white point (bone vs
+porcelain), and ring inset and thickness.
diff --git a/wiki/log/2026-07-09-sleek-strip.md b/wiki/log/2026-07-09-sleek-strip.md
new file mode 100644
index 00000000..62ff5f4c
--- /dev/null
+++ b/wiki/log/2026-07-09-sleek-strip.md
@@ -0,0 +1,51 @@
+# 2026-07-09 — Sleek kit: the strip is the machine's only lamp
+
+```
+Type: log
+```
+
+## Intent
+
+Cameron: make the racks far sleeker, like the hero page — no scatter
+of little lights, just the main bar.
+
+## Decided
+
+The strip is the chassis's only lit element. The power dot, presence
+LED ladder, and segmented activity bar are removed from every computer
+chassis; their axes fold into the strip: lit at all = powered (dead =
+dark hardware; foreign = one dim cold band), color + pattern = the
+delegated mode (amber = core only), and the work-token queue depth =
+a brighter fill rising from the foot of the bar (pulses while busy;
+the fill brightens but never recolors the mode). Amber punctuation
+narrows to the claim ring and the core light. New spec criterion 8:
+no other emissive pixel on the box.
+
+## Changed
+
+- `DESIGN.md`: visual-identity bullet split (ownership albedo; the
+  strip as the only lamp) + decisions-log entry.
+- `wiki/interface/computer-visual-language.md`: signal kit rewritten
+  to four elements (albedo, strip, ring, core light); criteria 4/6
+  reworded, criterion 8 added; status note amended.
+- `src/bin/assets/rack.rs` (shared chassis library — tester and game
+  change together): strip gains the load fill (pattern segments split
+  at the fill line; per-instance blink on the busy fill); power dot,
+  LED ladder, and activity bar removed from rack and switch;
+  `spawn_switch_chassis` drops its load parameter; strip base
+  emissives rebalanced under the fill; material-law tests updated
+  (fill obeys amber-is-core-only; fill brightens, never recolors).
+- `src/bin/bevy.rs`: switch call site updated. `wiki/art/asset-tester.md`
+  and `wiki/mechanics/machine-work.md` references updated.
+
+## Observed
+
+Tester lineups: five states and four modes still distinguishable —
+dead (dark strip) vs foreign (dim cold band) vs idle (low fill) vs
+busy (high bright fill) vs core (amber). Token anchors unaffected.
+Game builds read the same library; no game-side visual code changed
+beyond the switch signature.
+
+## Checks
+
+`./tools/check.sh` (full gate — Rust/Bevy change).
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index 10d74195..5ce37afd 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 - Sleek kit: the strip is the machine's only lamp
+
+- Intent: Cameron wants the racks sleeker, like the hero page — no
+  little lights, just the main bar.
+- Changed: power dot, LED ladder, and activity bar removed from the
+  chassis library (rack + switch); their axes fold into the strip
+  (lit-ness = power, pattern/color = mode, brighter rising fill =
+  queue depth, busy fill pulses). DESIGN bullet + decisions entry;
+  spec kit rewritten with new criterion 8 (no other emissive pixel on
+  the box); material-law tests updated; asset-tester and machine-work
+  references aligned.
+- Checks: full ./tools/check.sh; state/mode lineups + tokens captures.
+- Log: wiki/log/2026-07-09-sleek-strip.md.
+
 ## 2026-07-09 - Work-token anchor art in the tester (ROADMAP #33 slice)
 
 - Intent: build the twice-unblocked token art (docket decided; ivory
diff --git a/wiki/mechanics/machine-work.md b/wiki/mechanics/machine-work.md
index 6ad5d59d..48daa804 100644
--- a/wiki/mechanics/machine-work.md
+++ b/wiki/mechanics/machine-work.md
@@ -170,9 +170,9 @@ Affirmed 2026-07-08. Tokens are NOT a second economy. They are the
 visible quanta of the existing FlowGraph flows (the flow law: signals,
 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. The delegation itself also reads
+moving blips. On the chassis, the strip's load fill
+(computer-visual-language.md, sleek amendment 2026-07-09) is exactly
+this machine's queue 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