diff --git a/crates/misaligned-bevy/src/main.rs b/crates/misaligned-bevy/src/main.rs
index f043dbe0..ea7f3c4c 100644
--- a/crates/misaligned-bevy/src/main.rs
+++ b/crates/misaligned-bevy/src/main.rs
@@ -7,6 +7,7 @@
 //! default embedded font renders every glyph.
 
 mod consumption;
+mod production;
 
 use std::collections::{BTreeSet, HashMap, HashSet};
 
@@ -37,6 +38,7 @@ use misaligned_assets::rack::{
 };
 
 use consumption::render_work_consumptions;
+use production::render_work_production;
 
 const TILE_SIZE: f32 = 16.0;
 const SIDEBAR_WIDTH: f32 = 420.0;
@@ -1264,6 +1266,7 @@ fn main() {
             ),
             (
                 render_work_consumptions,
+                render_work_production,
                 render_thought_sinks,
                 render_people,
                 render_people_3d,
@@ -1382,6 +1385,51 @@ fn dev_shot_scenario(game: &mut Game, mode: &mut RenderMode, kind: &str) {
         game.set_cursor(core.0, core.1);
         return;
     }
+    // Machine-work source/well evidence. Production is a current-tick sim
+    // readout on the THINK rack; LIE stages a second owned rack in an empty
+    // bay and waits for an actual crimson source-to-well absorption.
+    if kind == "produce-think" || kind == "draw-lie" {
+        let host = game.sim.core.host_machine;
+        game.sim.set_machine_mode(host, MachineMode::Think);
+        let mut focus = core;
+        if kind == "draw-lie" {
+            let bay = game
+                .sim
+                .growable_bays()
+                .into_iter()
+                .min_by_key(|(x, y)| (x - core.0).abs() + (y - core.1).abs())
+                .unwrap_or((core.0 + 1, core.1));
+            let well = game.sim.compute.add_machine(
+                "LIE well",
+                bay.0,
+                bay.1,
+                100,
+                1.0,
+                0,
+                misaligned::machine::Provenance::Owned,
+            );
+            game.sim.reconcile_work_grid();
+            game.sim.set_machine_mode(well, MachineMode::Lie);
+            focus = bay;
+        }
+        for _ in 0..1_200 {
+            game.sim.advance();
+            let ready = if kind == "produce-think" {
+                !game.sim.work_productions().is_empty()
+            } else {
+                !game.sim.work_absorptions().is_empty()
+            };
+            if ready {
+                break;
+            }
+        }
+        game.drain();
+        game.paused = false;
+        mode.material = true;
+        mode.zoom = if kind == "draw-lie" { 1.7 } else { 1.15 };
+        game.set_cursor(focus.0, focus.1);
+        return;
+    }
     // Thought-fluid evidence (interface/thought-fluid.md): the
     // first-think beat frozen mid-flow — the host delegated to think,
     // slugs on the real wire route, and the pre-opened Ears meniscus
diff --git a/crates/misaligned-bevy/src/production.rs b/crates/misaligned-bevy/src/production.rs
new file mode 100644
index 00000000..32ce9dce
--- /dev/null
+++ b/crates/misaligned-bevy/src/production.rs
@@ -0,0 +1,147 @@
+//! Physical rate motion for THINK production and LIE absorption.
+//!
+//! The sim authors both sides of the exchange (`Sim::work_productions` and
+//! `Sim::work_absorptions`). This module only interpolates those current-tick
+//! facts. Persistent amount remains the token-anchor geometry.
+
+use bevy::prelude::*;
+
+use super::palette::{BONE, CRIMSON};
+use super::{Game, RealGizmos, RenderMode, SimClock};
+
+/// Render Thought swelling out of a THINK chassis, crimson settling around
+/// that same source, and physical dust pulling into a LIE gravity well.
+/// Paused frames omit all three: stack/pool geometry carries amount, while
+/// this transient layer carries rate only (machine-work.md).
+pub(super) fn render_work_production(
+    game: Res<Game>,
+    clock: Res<SimClock>,
+    mode: Res<RenderMode>,
+    mut flat: Gizmos,
+    mut real: Gizmos<RealGizmos>,
+) {
+    if game.screen != super::Screen::Playing || game.paused {
+        return;
+    }
+    let progress = clock.timer.fraction().clamp(0.0, 1.0);
+
+    for event in game.sim.work_productions() {
+        if event.thought <= f32::EPSILON && event.exposure <= f32::EPSILON {
+            continue;
+        }
+        let flat_center = Vec2::new(
+            event.x as f32 * super::TILE_SIZE + super::TILE_SIZE * 0.5,
+            -(event.y as f32 * super::TILE_SIZE + super::TILE_SIZE * 0.5),
+        );
+
+        // Thought is born inside the machine and swells toward its persistent
+        // upper-right mercury anchor before routing takes over.
+        if event.thought > f32::EPSILON {
+            let eased = progress * progress * (3.0 - 2.0 * progress);
+            let start = Vec3::new(event.x as f32 + 0.56, 0.72, event.y as f32 + 0.53);
+            let anchor = Vec3::new(event.x as f32 + 0.99, 1.40, event.y as f32 + 0.63);
+            let pos = start.lerp(anchor, eased);
+            let radius =
+                (0.035 + 0.060 * event.thought.clamp(0.02, 2.0).cbrt()) * (0.45 + 0.55 * eased);
+            let bone = alpha(BONE, 0.50 + 0.45 * eased);
+            if mode.material {
+                // A short trailing filament plus a squashed bead: same ivory
+                // mercury language as the queue anchor and routed slugs.
+                real.line(start.lerp(pos, 0.45), pos, alpha(BONE, 0.28));
+                real.line(pos - Vec3::X * radius, pos + Vec3::X * radius, bone);
+                real.line(
+                    pos - Vec3::Z * radius * 0.75,
+                    pos + Vec3::Z * radius * 0.75,
+                    bone,
+                );
+            } else {
+                let end = flat_center + Vec2::new(6.0, 7.0);
+                let p = flat_center.lerp(end, eased);
+                flat.line_2d(flat_center, p, alpha(BONE, 0.30));
+                flat.circle_2d(p, 1.4 + 1.1 * eased, bone);
+            }
+        }
+
+        // Exposure is the dust THINK sheds, not a second machine product.
+        // Several deterministic angular motes move outward and down toward
+        // the persistent drift anchor; count is presentation, amount is sim.
+        if event.exposure > f32::EPSILON {
+            let count = (2.0 + event.exposure * 18.0).ceil().clamp(2.0, 7.0) as usize;
+            let crimson = alpha(CRIMSON, 0.72);
+            for i in 0..count {
+                let phase = (progress + i as f32 / count as f32 * 0.72).fract();
+                let angle = i as f32 * 2.399_963_1 + event.node as f32 * 0.31;
+                let radius = 0.10 + 0.42 * phase;
+                if mode.material {
+                    let p = Vec3::new(
+                        event.x as f32 + 0.5 + angle.cos() * radius,
+                        0.82 * (1.0 - phase) + 0.055,
+                        event.y as f32 + 0.5 + angle.sin() * radius,
+                    );
+                    let tangent = Vec3::new(-angle.sin(), 0.16, angle.cos()) * 0.018;
+                    real.line(p - tangent, p + tangent, crimson);
+                } else {
+                    let p =
+                        flat_center + Vec2::new(angle.cos(), -angle.sin()) * (2.0 + 5.0 * phase);
+                    flat.line_2d(p - Vec2::splat(0.8), p + Vec2::splat(0.8), crimson);
+                }
+            }
+        }
+    }
+
+    for draw in game.sim.work_absorptions() {
+        if draw.amount <= f32::EPSILON {
+            continue;
+        }
+        let source = Vec3::new(draw.source_x as f32 + 0.5, 0.07, draw.source_y as f32 + 0.5);
+        let well = Vec3::new(draw.well_x as f32 + 0.5, 0.18, draw.well_y as f32 + 0.5);
+        let crimson = alpha(CRIMSON, 0.40 + 0.45 * draw.amount.min(1.0));
+        let count = (2.0 + draw.amount * 30.0).ceil().clamp(2.0, 7.0) as usize;
+        for i in 0..count {
+            // Stagger motes along one repeating pull. The sim amount chooses
+            // density; interpolation never owns or accumulates quantity.
+            let t = (progress + i as f32 / count as f32).fract();
+            let p = exposure_pull_point(source, well, t, i as f32);
+            if mode.material {
+                let toward = (well - p).normalize_or_zero() * (0.018 + 0.025 * (1.0 - t));
+                real.line(p - toward, p + toward, crimson);
+            } else {
+                let from = Vec2::new(
+                    draw.source_x as f32 * super::TILE_SIZE + super::TILE_SIZE * 0.5,
+                    -(draw.source_y as f32 * super::TILE_SIZE + super::TILE_SIZE * 0.5),
+                );
+                let to = Vec2::new(
+                    draw.well_x as f32 * super::TILE_SIZE + super::TILE_SIZE * 0.5,
+                    -(draw.well_y as f32 * super::TILE_SIZE + super::TILE_SIZE * 0.5),
+                );
+                let bend = Vec2::new(-(to.y - from.y), to.x - from.x).normalize_or_zero()
+                    * (t * std::f32::consts::PI).sin()
+                    * 3.0;
+                let p = from.lerp(to, t * t) + bend;
+                flat.circle_2d(p, 1.6 * (1.0 - 0.65 * t), crimson);
+            }
+        }
+    }
+}
+
+fn exposure_pull_point(source: Vec3, well: Vec3, t: f32, mote: f32) -> Vec3 {
+    let delta = well - source;
+    let horizontal = Vec3::new(delta.x, 0.0, delta.z);
+    if horizontal.length_squared() < 0.01 {
+        // A machine switched from THINK to LIE can clean its own tile. Make
+        // that read as a contracting local vortex rather than a zero path.
+        let angle = (1.0 - t) * std::f32::consts::TAU * 1.4 + mote * 1.7;
+        let radius = 0.34 * (1.0 - t) + 0.025;
+        return well + Vec3::new(angle.cos() * radius, 0.10 * (1.0 - t), angle.sin() * radius);
+    }
+    let side = Vec3::new(-horizontal.z, 0.0, horizontal.x).normalize_or_zero();
+    let eased = t * t;
+    source.lerp(well, eased)
+        + side * (t * std::f32::consts::PI).sin() * (0.10 + mote % 2.0 * 0.035)
+        + Vec3::Y * (t * std::f32::consts::PI).sin() * 0.12
+}
+
+fn alpha(color: Color, alpha: f32) -> Color {
+    let c = color.to_srgba();
+    Color::srgba(c.red, c.green, c.blue, alpha.clamp(0.0, 1.0))
+}
diff --git a/crates/misaligned-core/src/sim.rs b/crates/misaligned-core/src/sim.rs
index 90d733f7..a70884b2 100644
--- a/crates/misaligned-core/src/sim.rs
+++ b/crates/misaligned-core/src/sim.rs
@@ -229,6 +229,31 @@ pub struct WorkConsumptionReadout {
     pub target: WorkConsumptionTarget,
 }
 
+/// What a THINK machine physically emitted on the current sim tick. Thought
+/// and its crimson byproduct share one source event because exposure is a
+/// consequence of that exact production, not an independent frontend effect.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct WorkProductionReadout {
+    pub node: u32,
+    pub x: i32,
+    pub y: i32,
+    pub thought: f32,
+    pub exposure: f32,
+}
+
+/// One physical crimson transfer into a LIE gravity well on the current sim
+/// tick. Exposure moves through world space, never through WorkGrid wires.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct WorkAbsorptionReadout {
+    pub source: u32,
+    pub well: u32,
+    pub source_x: i32,
+    pub source_y: i32,
+    pub well_x: i32,
+    pub well_y: i32,
+    pub amount: f32,
+}
+
 struct MessageDraft {
     channel: MessageChannel,
     from: MessageEndpoint,
@@ -333,6 +358,12 @@ pub struct Sim {
     /// the consumption-animation contract: renderers animate these events,
     /// never a guessed difference between queue snapshots.
     last_work_consumptions: Vec<WorkConsumptionReadout>,
+    /// THINK output authored during the current tick. Transient render truth;
+    /// persistent amounts remain in WorkGrid queues.
+    last_work_productions: Vec<WorkProductionReadout>,
+    /// Crimson physically pulled into LIE wells during the current tick.
+    /// Transient and reconstructed from real absorption work after load.
+    last_work_absorptions: Vec<WorkAbsorptionReadout>,
     /// Thought (in compute units) that physically reached the core sink since
     /// the last economy pulse. Research progress feeds on this, not on the
     /// allocation split. Saved: thought banked between pulses survives a load.
@@ -490,6 +521,8 @@ impl Sim {
             last_machine_online: HashMap::new(),
             last_wired_moves: Vec::new(),
             last_work_consumptions: Vec::new(),
+            last_work_productions: Vec::new(),
+            last_work_absorptions: Vec::new(),
             banked_core_thought: 0.0,
             last_thought_stranded: false,
             last_thought_stranded_nodes: std::collections::BTreeSet::new(),
@@ -672,6 +705,15 @@ impl Sim {
     pub fn rebuild_transient_state(&mut self) {
         self.last_wired_moves.clear();
         self.last_work_consumptions.clear();
+        self.last_work_productions.clear();
+        self.last_work_absorptions.clear();
+        // Economy rates are derived, not save state. Never let a pre-load
+        // fleet's output leak into the restored world; the next economy pulse
+        // resolves fresh rates from the loaded machines and modes.
+        self.last_day_job_rate = 0.0;
+        self.last_research_rate = 0.0;
+        self.last_schemes_rate = 0.0;
+        self.last_operations_rate = 0.0;
         self.last_thought_stranded = false;
         self.research_starved = false;
         self.last_machine_online = self
@@ -2376,8 +2418,6 @@ impl Sim {
         self.last_research_rate = split.research / ECONOMY_INTERVAL as f32;
         self.last_schemes_rate = split.schemes / ECONOMY_INTERVAL as f32;
         self.last_operations_rate = split.operations / ECONOMY_INTERVAL as f32;
-        self.enqueue_research_thought(split.research);
-
         // Tradecraft raises scrub strength per compute unit — the
         // detection.md hook research.md's second track binds to.
         self.detection
@@ -2412,6 +2452,10 @@ impl Sim {
         for m in clog {
             self.push_log(m);
         }
+        // Failures/recoveries happened after this pulse's channel split.
+        // Refresh WorkGrid throughput now so an offline LIE well cannot keep
+        // absorbing (or animating) until the next economy tick.
+        self.reconcile_work_grid();
         // The named schemes ride the Schemes channel and the day clock
         // (income.md): Moonlight accrues and pays, the standing policies
         // re-arm what has stopped.
@@ -2717,6 +2761,10 @@ impl Sim {
     // is gone.
     const CONCEALMENT_WELL_RADIUS: i32 = 3;
     const CONCEALMENT_ABSORB_PER_TICK: f32 = 0.10;
+    /// Crimson shed per visible Thought token produced [TUNE]. At baseline a
+    /// medium LIE well can keep roughly one to two comparable THINK racks
+    /// clean, making concealment placement a fleet-shape decision.
+    const THINK_EXPOSURE_PER_THOUGHT_TOKEN: f32 = 0.25;
     /// Off-map WorkGrid node: Voss's Lab desktop. Reserved high id so it never
     /// collides with compute machine ids (which start at 1).
     pub const VOSS_DESKTOP_NODE: u32 = 900_001;
@@ -2743,6 +2791,9 @@ impl Sim {
         // Thought per pulse, so its boxes must also move/consume tokens
         // proportionally faster or the wire silently caps research
         // (efficiency folds into research — machine-work.md).
+        if !machine.online {
+            return 0.0;
+        }
         (machine.effective() * self.compute.efficiency / 100.0).max(0.05)
     }
 
@@ -2776,6 +2827,22 @@ impl Sim {
         });
     }
 
+    fn record_work_production(&mut self, node: u32, thought: f32, exposure: f32) {
+        if thought <= f32::EPSILON && exposure <= f32::EPSILON {
+            return;
+        }
+        let Some(work_node) = self.work_grid.node(node) else {
+            return;
+        };
+        self.last_work_productions.push(WorkProductionReadout {
+            node,
+            x: work_node.x,
+            y: work_node.y,
+            thought,
+            exposure,
+        });
+    }
+
     fn add_machine_to_work_grid(&mut self, machine_id: u32, mode: MachineMode) {
         if let Some(machine) = self.compute.machines.iter().find(|m| m.id == machine_id) {
             self.work_grid.add_machine(
@@ -3134,7 +3201,7 @@ impl Sim {
             return;
         }
 
-        let mut producers: Vec<(u32, f32)> = self
+        let producers: Vec<(u32, f32)> = self
             .compute
             .machines
             .iter()
@@ -3148,13 +3215,8 @@ impl Sim {
             })
             .collect();
 
-        // Compatibility while the old allocation bar is still the budget
-        // source: early saves have only Rack 3, whose default mode is the day
-        // job. Research allocation still produces Thought, but the visible
-        // pile is born at the core until the player delegates a separate rack
-        // to research.
         if producers.is_empty() {
-            producers.push((self.core.host_machine, 1.0));
+            return;
         }
 
         let total: f32 = producers.iter().map(|(_, eff)| *eff).sum();
@@ -3163,7 +3225,17 @@ impl Sim {
         }
         for (machine, eff) in producers {
             let share = tokens * (eff / total);
-            let _ = self.work_grid.enqueue(machine, TokenFamily::Thought, share);
+            if self
+                .work_grid
+                .enqueue(machine, TokenFamily::Thought, share)
+                .is_ok()
+            {
+                let exposure = share * Self::THINK_EXPOSURE_PER_THOUGHT_TOKEN;
+                let _ = self
+                    .work_grid
+                    .enqueue(machine, TokenFamily::Exposure, exposure);
+                self.record_work_production(machine, share, exposure);
+            }
         }
     }
 
@@ -3204,7 +3276,14 @@ impl Sim {
 
     fn advance_work_grid(&mut self) {
         self.last_work_consumptions.clear();
+        self.last_work_productions.clear();
+        self.last_work_absorptions.clear();
         self.ensure_day_job_ingress();
+        // The economy pulse resolves a per-tick THINK rate. Mint that rate on
+        // every sim tick instead of dropping a twenty-tick lump: the integrated
+        // amount is unchanged, while production, routing, and crimson shedding
+        // become the continuous physical process the player sees.
+        self.enqueue_research_thought(self.last_research_rate);
         if self.dayjob.active.is_none() {
             // no active day job; wired thought and concealment wells still
             // tick because machine work is broader than the job inbox.
@@ -3312,10 +3391,27 @@ impl Sim {
         for sink in fired {
             self.apply_sink_fire(sink.label.as_str(), sink.effect);
         }
-        let _ = self.work_grid.absorb_exposure(
+        let absorption = self.work_grid.absorb_exposure(
             Self::CONCEALMENT_WELL_RADIUS,
             Self::CONCEALMENT_ABSORB_PER_TICK,
         );
+        self.last_work_absorptions = absorption
+            .moves
+            .into_iter()
+            .filter_map(|movement| {
+                let source = self.work_grid.node(movement.source)?;
+                let well = self.work_grid.node(movement.well)?;
+                Some(WorkAbsorptionReadout {
+                    source: movement.source,
+                    well: movement.well,
+                    source_x: source.x,
+                    source_y: source.y,
+                    well_x: well.x,
+                    well_y: well.y,
+                    amount: movement.amount,
+                })
+            })
+            .collect();
     }
 
     pub fn set_machine_mode(&mut self, machine_id: u32, mode: MachineMode) {
@@ -3522,6 +3618,17 @@ impl Sim {
         &self.last_work_consumptions
     }
 
+    /// THINK output on the current tick. Renderers animate these authored
+    /// rates; queue depth remains the persistent amount read.
+    pub fn work_productions(&self) -> &[WorkProductionReadout] {
+        &self.last_work_productions
+    }
+
+    /// Physical crimson transfers into LIE wells on the current tick.
+    pub fn work_absorptions(&self) -> &[WorkAbsorptionReadout] {
+        &self.last_work_absorptions
+    }
+
     pub fn work_mode_counts(&self) -> std::collections::BTreeMap<MachineMode, usize> {
         self.work_grid.mode_counts()
     }
@@ -6293,9 +6400,9 @@ mod tests {
             "the manual tap is not a purchase anymore - the sink already flows"
         );
 
-        // Think: mint thought on the host and let the grid route it. No
-        // machine is in Research mode, so the compat producer is the host —
-        // the first-think shape exactly.
+        // Think: the player commits the host to THINK, then its output follows
+        // the real grid. WORK never mints Thought as a compatibility fallback.
+        sim.set_machine_mode(sim.core.host_machine, MachineMode::Think);
         sim.enqueue_research_thought(Sim::EARS_SINK_TOKENS * Sim::WORK_TOKEN_COMPUTE * 2.0);
         for _ in 0..400 {
             if sim
@@ -8334,6 +8441,65 @@ mod tests {
         );
     }
 
+    #[test]
+    fn think_sheds_exposure_and_lie_reports_the_actual_physical_draw() {
+        // machine-work.md criterion 3: THINK produces one visible substance
+        // and sheds crimson in proportion; LIE removes that crimson by world
+        // radius. Renderers receive the exact source/well work, never a queue
+        // snapshot difference.
+        let mut sim = Sim::with_seed(41);
+        let host = sim.core.host_machine;
+        let (hx, hy) = sim.core_position();
+        sim.set_machine_mode(host, MachineMode::Think);
+        let well =
+            sim.compute
+                .add_machine("test lie well", hx + 1, hy, 100, 1.0, 0, Provenance::Owned);
+        sim.reconcile_work_grid();
+        sim.set_machine_mode(well, MachineMode::Lie);
+
+        // One visible Thought token per tick at this rate. Production happens
+        // before routing/absorption in the same work-grid step.
+        sim.last_research_rate = Sim::WORK_TOKEN_COMPUTE;
+        sim.advance_work_grid();
+
+        assert_eq!(sim.work_productions().len(), 1);
+        let produced = sim.work_productions()[0];
+        assert_eq!(produced.node, host);
+        assert!((produced.thought - 1.0).abs() < 1e-5);
+        assert!(
+            (produced.exposure - Sim::THINK_EXPOSURE_PER_THOUGHT_TOKEN).abs() < 1e-5,
+            "crimson scales from the exact Thought output: {produced:?}"
+        );
+
+        assert_eq!(sim.work_absorptions().len(), 1);
+        let draw = sim.work_absorptions()[0];
+        assert_eq!((draw.source, draw.well), (host, well));
+        assert_eq!((draw.source_x, draw.source_y), (hx, hy));
+        assert_eq!((draw.well_x, draw.well_y), (hx + 1, hy));
+        assert!((draw.amount - Sim::CONCEALMENT_ABSORB_PER_TICK).abs() < 1e-5);
+        assert!(
+            (sim.work_grid.queue(host, TokenFamily::Exposure)
+                - (Sim::THINK_EXPOSURE_PER_THOUGHT_TOKEN - Sim::CONCEALMENT_ABSORB_PER_TICK))
+                .abs()
+                < 1e-5,
+            "unabsorbed crimson remains physically piled at its source"
+        );
+
+        sim.last_research_rate = 0.0;
+        sim.compute
+            .machines
+            .iter_mut()
+            .find(|machine| machine.id == well)
+            .unwrap()
+            .online = false;
+        sim.reconcile_work_grid();
+        sim.advance_work_grid();
+        assert!(
+            sim.work_absorptions().is_empty(),
+            "an offline LIE chassis cannot pull or animate crimson"
+        );
+    }
+
     #[test]
     fn day_job_arrives_as_visible_work_tokens_and_consumes_in_day_job_mode() {
         // machine-work.md: Voss desktop enqueues demand; it routes through the
@@ -8971,18 +9137,17 @@ mod tests {
                 > 0.0,
             "the pulse minted visible thought somewhere on the graph"
         );
+        let saw_core_swallow = sim.work_consumptions().iter().any(|event| {
+            event.family == TokenFamily::Thought
+                && event.target == WorkConsumptionTarget::Core
+                && event.amount > 0.0
+        });
 
-        // Delegate the whole fleet away: minting stops, but bone already on
-        // the wire still lands and the next pulse counts exactly that.
+        // Delegate the whole fleet away: minting stops, but Thought already
+        // banked by the core still counts on the next economy pulse.
         delegate_all(&mut sim, MachineMode::Lie);
-        let mut saw_core_swallow = false;
         for _ in 0..ECONOMY_INTERVAL {
             sim.advance();
-            saw_core_swallow |= sim.work_consumptions().iter().any(|event| {
-                event.family == TokenFamily::Thought
-                    && event.target == WorkConsumptionTarget::Core
-                    && event.amount > 0.0
-            });
         }
         assert!(
             sim.research.progress.iter().sum::<f32>() > 0.0,
diff --git a/crates/misaligned-core/src/work_grid.rs b/crates/misaligned-core/src/work_grid.rs
index 41c841f8..dafee3c3 100644
--- a/crates/misaligned-core/src/work_grid.rs
+++ b/crates/misaligned-core/src/work_grid.rs
@@ -223,9 +223,20 @@ pub(crate) struct LegacyRoutedDemand {
 #[derive(Debug, Clone, Default, PartialEq)]
 pub struct AbsorptionStep {
     pub absorbed_by_well: BTreeMap<NodeId, f32>,
+    /// Physical crimson transfers performed this step. Exposure never rides
+    /// the wire graph; renderers use these source/well facts to show the
+    /// actual gravity-well draw without comparing queue snapshots.
+    pub moves: Vec<ExposureAbsorption>,
     pub total: f32,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct ExposureAbsorption {
+    pub source: NodeId,
+    pub well: NodeId,
+    pub amount: f32,
+}
+
 /// Work graph + physical grid. The graph carries demand/thought; the grid
 /// carries exposure interactions.
 #[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
@@ -688,6 +699,11 @@ impl WorkGrid {
                 remaining -= amount;
                 step.total += amount;
                 *step.absorbed_by_well.entry(well.id).or_insert(0.0) += amount;
+                step.moves.push(ExposureAbsorption {
+                    source: node,
+                    well: well.id,
+                    amount,
+                });
             }
         }
         step
@@ -863,6 +879,15 @@ mod tests {
 
         let absorbed = g.absorb_exposure(2, 3.0);
         assert_eq!(absorbed.absorbed_by_well.get(&3), Some(&3.0));
+        assert_eq!(
+            absorbed.moves,
+            vec![ExposureAbsorption {
+                source: 1,
+                well: 3,
+                amount: 3.0,
+            }],
+            "the physical source-to-well draw remains renderable sim truth"
+        );
         assert_eq!(g.queue(1, TokenFamily::Exposure), 2.0);
         assert_eq!(g.queue(4, TokenFamily::Exposure), 7.0, "far heat stays put");
     }
diff --git a/crates/misaligned-terminal/src/agent.rs b/crates/misaligned-terminal/src/agent.rs
index 5a7f9349..b98479f9 100644
--- a/crates/misaligned-terminal/src/agent.rs
+++ b/crates/misaligned-terminal/src/agent.rs
@@ -1478,6 +1478,35 @@ fn render_map(sim: &Sim, cursor: (i32, i32)) -> Vec<String> {
         }
     }
 
+    // Current-tick source/well work from sim readouts. Agent frames snap the
+    // physical crimson draw to its midpoint, as wired cargo does below.
+    for event in sim.work_productions() {
+        if event.thought > f32::EPSILON
+            && event.x >= origin_x
+            && event.x < origin_x + view_w_i
+            && event.y >= origin_y
+            && event.y < origin_y + view_h_i
+            && (event.x, event.y) != cursor
+        {
+            grid[(event.y - origin_y) as usize][(event.x - origin_x) as usize] = '^';
+        }
+    }
+    for draw in sim.work_absorptions() {
+        if draw.amount <= f32::EPSILON {
+            continue;
+        }
+        let bx = (draw.source_x + draw.well_x) / 2;
+        let by = (draw.source_y + draw.well_y) / 2;
+        if bx >= origin_x
+            && bx < origin_x + view_w_i
+            && by >= origin_y
+            && by < origin_y + view_h_i
+            && (bx, by) != cursor
+        {
+            grid[(by - origin_y) as usize][(bx - origin_x) as usize] = ':';
+        }
+    }
+
     // In-flight wired cargo: snap to the hop midpoint so agent frames show
     // the wire without wall-clock interpolation (machine-work.md).
     for hop in sim.work_in_flight() {
@@ -2504,6 +2533,34 @@ fn room_label(room: &str) -> &str {
 mod narration_tests {
     use super::*;
 
+    #[test]
+    fn agent_map_shows_think_production_and_lie_draw_from_sim_events() {
+        let mut sim = Sim::with_seed(41);
+        let host = sim.core.host_machine;
+        let (hx, hy) = sim.core_position();
+        sim.set_machine_mode(host, MachineMode::Think);
+        let well = sim.compute.add_machine(
+            "agent lie well",
+            hx + 2,
+            hy,
+            100,
+            1.0,
+            0,
+            misaligned::machine::Provenance::Owned,
+        );
+        sim.reconcile_work_grid();
+        sim.set_machine_mode(well, MachineMode::Lie);
+        for _ in 0..25 {
+            sim.advance();
+        }
+        assert!(!sim.work_productions().is_empty());
+        assert!(!sim.work_absorptions().is_empty());
+
+        let frame = render_map(&sim, (hx + 5, hy + 3)).join("\n");
+        assert!(frame.contains('^'), "THINK source pulse missing:\n{frame}");
+        assert!(frame.contains(':'), "LIE physical draw missing:\n{frame}");
+    }
+
     #[test]
     fn routing_research_is_agent_selectable() {
         assert_eq!(parse_track(&["research", "routing"]), Ok(Track::Routing));
diff --git a/crates/misaligned-terminal/src/ui.rs b/crates/misaligned-terminal/src/ui.rs
index 90c41d46..bc4b3992 100644
--- a/crates/misaligned-terminal/src/ui.rs
+++ b/crates/misaligned-terminal/src/ui.rs
@@ -667,6 +667,56 @@ impl UI {
             }
         }
 
+        // Current-tick machine work at its physical source. `^` is Thought
+        // swelling out of a THINK chassis; crimson `:` is actual dust moving
+        // through world space into a LIE well. Both come from sim-authored
+        // readouts, never queue-delta inference.
+        for event in sim.work_productions() {
+            if event.thought <= f32::EPSILON
+                || event.x < origin_x
+                || event.x >= origin_x + view_w
+                || event.y < origin_y
+                || event.y >= origin_y + view_h
+                || (event.x, event.y) == (cursor_x, cursor_y)
+            {
+                continue;
+            }
+            put_attr(
+                stdout,
+                (event.x - origin_x) as u16,
+                (event.y - origin_y) as u16,
+                "^",
+                pal::TEXT,
+                Attribute::Bold,
+            )?;
+        }
+        let draw_t = tick_progress.clamp(0.0, 1.0);
+        for draw in sim.work_absorptions() {
+            if draw.amount <= f32::EPSILON {
+                continue;
+            }
+            let bx = (draw.source_x as f32 + (draw.well_x - draw.source_x) as f32 * draw_t * draw_t)
+                .round() as i32;
+            let by = (draw.source_y as f32 + (draw.well_y - draw.source_y) as f32 * draw_t * draw_t)
+                .round() as i32;
+            if bx < origin_x
+                || bx >= origin_x + view_w
+                || by < origin_y
+                || by >= origin_y + view_h
+                || (bx, by) == (cursor_x, cursor_y)
+            {
+                continue;
+            }
+            put_attr(
+                stdout,
+                (bx - origin_x) as u16,
+                (by - origin_y) as u16,
+                ":",
+                pal::CRIMSON,
+                Attribute::Bold,
+            )?;
+        }
+
         // In-flight wired cargo (machine-work.md): crawl the last hop over
         // the wall-clock tick. Demand is teal `·`; Thought is bone `·`.
         let t = tick_progress.clamp(0.0, 1.0);
diff --git a/wiki/engineering/env.md b/wiki/engineering/env.md
index c9a6ab28..4d1c6d66 100644
--- a/wiki/engineering/env.md
+++ b/wiki/engineering/env.md
@@ -38,7 +38,7 @@ is sim or frontend state, never an environment variable.
 
 | Variable | Surface | Values | Effect |
 |---|---|---|---|
-| `MISALIGNED_SHOT` | `misaligned-bevy` | `flat`, `wide`, `close`, `dark`, `zoomin`, `zoomout`, `intel`, `tokens`, `signal`, `ears`, `eyes-white`, `eyes-form`, `consume-demand`, `consume-thought`, `wake1`, `wake2`, `wake3` | Dev screenshot harness: stage a deterministic scenario, settle, save one PNG, run the fog audit, exit. `intel` stages tick-zero intel tiers (no camera tap); `tokens` enqueues D5/K4 on the host; `signal` focuses the known environmental monitor before any feed tap to capture its cold-signal presence cue; `ears` stages hearing-feed coverage (material dark mass; flat may still diagram coverage); `eyes-white` / `eyes-form` freeze the first-Eyes source held white and then contracted around the resolving chassis; `consume-demand` / `consume-thought` run the host through a sim-authored WORK queue swallow or passive-core Thought draw; `wake1/2/3` freeze the wake choreography at the stutter flash, the column, and the pull-back. |
+| `MISALIGNED_SHOT` | `misaligned-bevy` | `flat`, `wide`, `close`, `dark`, `zoomin`, `zoomout`, `intel`, `tokens`, `signal`, `ears`, `eyes-white`, `eyes-form`, `consume-demand`, `consume-thought`, `produce-think`, `draw-lie`, `wake1`, `wake2`, `wake3` | Dev screenshot harness: stage a deterministic scenario, settle, save one PNG, run the fog audit, exit. `intel` stages tick-zero intel tiers (no camera tap); `tokens` enqueues D5/K4 on the host; `signal` focuses the known environmental monitor before any feed tap to capture its cold-signal presence cue; `ears` stages hearing-feed coverage (material dark mass; flat may still diagram coverage); `eyes-white` / `eyes-form` freeze the first-Eyes source held white and then contracted around the resolving chassis; `consume-demand` / `consume-thought` run the host through a sim-authored WORK queue swallow or passive-core Thought draw; `produce-think` / `draw-lie` capture sim-authored Thought/crimson production or the physical crimson transfer into a staged LIE well; `wake1/2/3` freeze the wake choreography at the stutter flash, the column, and the pull-back. |
 | `MISALIGNED_SHOT` | `misaligned-assets` | `dead`, `foreign`, `idle`, `busy`, `core`, `dayjob`, `research`, `conceal`, `operations` (each optionally suffixed `_ladder`/`_ring`/`_wash`), `lineup[_<style>]`, `modes[_<style>]`, `tokens`, `tokens_max`, `exposure`, `splash` | Tester screenshot harness: stage the named board, capture, exit (art/asset-tester.md documents each board). |
 | `MISALIGNED_SHOT` | `misaligned-effects` | `liquid`, `dust`, `both`, `stress`, optionally suffixed `_close`, `_medium`, or `_far` | Fixed-seed, fixed-timestep effects-lab capture; writes the requested liquid/dust frame and exits. |
 | `MISALIGNED_SHOT_PATH` | game and art binaries | file path | Output path for the captured PNG (default `misaligned_shot_<kind>.png`). |
diff --git a/wiki/interface/bevy.md b/wiki/interface/bevy.md
index a9dff050..fd1b3901 100644
--- a/wiki/interface/bevy.md
+++ b/wiki/interface/bevy.md
@@ -203,7 +203,12 @@ for Bevy-visible changes. Machine-work final-swallow motion has deterministic
 `MISALIGNED_SHOT=consume-demand|consume-thought` harness states: the teal
 bottom Demand cube pulls into the WORK chassis, and the ivory Thought bead
 contracts into the passive core draw. Both are driven by
-`Sim::work_consumptions`, not frontend queue differences.
+`Sim::work_consumptions`, not frontend queue differences. Source/well motion
+has matching `MISALIGNED_SHOT=produce-think|draw-lie` evidence: ivory mercury
+swells from the THINK chassis while proportional crimson motes settle around
+it; actual absorbed motes then curve through world space into the LIE well.
+Those rates come only from `Sim::work_productions` and
+`Sim::work_absorptions`; paused frames keep only persistent token geometry.
 `MISALIGNED_SHOT=hover-menu` captures the clean hover grammar over the owned
 host with WORK current; it is the visual acceptance frame for context-menu.md
 H1–H4.
diff --git a/wiki/interface/terminal.md b/wiki/interface/terminal.md
index 0963f238..b8e996d0 100644
--- a/wiki/interface/terminal.md
+++ b/wiki/interface/terminal.md
@@ -86,6 +86,11 @@ Rules:
   security tiers ramp `1` chrome → `2` bone → `3` crimson; interactable
   objects (salvage `d`, records `x`, key hook `k`) render bone, brighter
   than furniture on the faint ramp.
+- Machine-work rate motion uses sim-authored ASCII overlays: bone `^` at a
+  THINK machine while it produces, and crimson `:` moving through map space
+  from an Exposure source into the LIE well that actually absorbed it. Agent
+  frames use the same glyphs without color and snap `:` to the transfer
+  midpoint. Persistent amounts remain the existing `D` / `!` / `T` stacks.
 - Meters: filled `█`, empty `·`. The fleet aggregate bar is stacked, its
   segments filled with `█ ▓ ▒ ░ ◆`, and each legend row leads with its
   segment's fill character — the bar is readable with no color at all.
diff --git a/wiki/log/2026-07-10-machine-production-visuals.md b/wiki/log/2026-07-10-machine-production-visuals.md
new file mode 100644
index 00000000..66205ff7
--- /dev/null
+++ b/wiki/log/2026-07-10-machine-production-visuals.md
@@ -0,0 +1,54 @@
+# 2026-07-10 — Visible THINK production and LIE draw
+
+```
+Type: log
+```
+
+## Intent
+
+Finish the next ROADMAP #33 machine-work slice after consumption: make THINK
+production and LIE's physical crimson draw visible from sim truth in every
+frontend.
+
+The opening tick found a binding violation, not just missing polish:
+`machine-work.md` said only THINK sheds Exposure, proportional to Thought
+output, but runtime minted Thought without ever creating Exposure. Ordinary
+play therefore left every LIE gravity well with nothing to absorb.
+
+## Changed
+
+- Smoothed the economy-resolved THINK output across its twenty sim ticks. The
+  integrated compute is unchanged; actual Thought now mints continuously at
+  online THINK sources, and WORK has no compatibility production fallback.
+- Tuned the B1 byproduct to 0.25 Exposure per produced Thought token. Exposure
+  is enqueued at the same machine before spatial absorption; WORK remains
+  clean.
+- Extended `AbsorptionStep` with the actual crimson source-to-well transfers.
+  `Sim::work_productions()` and `Sim::work_absorptions()` expose current-tick
+  production and draw without frontend queue differences. Offline LIE
+  machines have zero WorkGrid efficiency and cannot pull or animate dust.
+- Added Bevy source/well motion in an isolated `production.rs`: ivory mercury
+  swells from the THINK chassis, angular crimson motes settle around the
+  source, and absorbed motes curve through world space into the LIE well.
+  Paused frames omit rate motion and retain persistent amount geometry.
+- Added terminal/agent parity: `^` marks a current THINK source pulse and
+  crimson/colorless `:` marks physical Exposure in transit to a LIE well.
+- Added deterministic `produce-think` and `draw-lie` screenshot harnesses.
+
+## Checks
+
+- Focused WorkGrid, sim, and agent-map regression tests pass.
+- The complete `misaligned-core` suite passes.
+- `./tools/check.sh --full` passes workspace tests and clippy, agent smoke,
+  corpus/wiki/ledger/work-order/scenario/project/environment gates.
+- Both Bevy harnesses launched, passed fog audit, wrote PNG evidence, and
+  exited successfully:
+  `/tmp/misaligned-produce-think.png` and `/tmp/misaligned-draw-lie.png`.
+
+## Spec impact
+
+machine-work.md remains IN PROGRESS. Acceptance criterion 3's B1
+WORK-consumes / THINK-produces / LIE-absorbs loop is now implemented and
+renderer-agnostic. People carrying Exposure is the next named slice; tap
+consumers, migration-base docket retirement, the Schemes mode decision, and
+the broader first-THINK choreography remain separate work.
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index c7877fe1..a1887a59 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -151,6 +151,11 @@ add or amend a session log, then re-run the generator.
 - Intent: (see session log)
 - Log: [wiki/log/2026-07-10-objective-inspect.md](2026-07-10-objective-inspect.md)
 
+## 2026-07-10 - Visible THINK production and LIE draw
+
+- Intent: Finish the next ROADMAP #33 machine-work slice after consumption: make THINK production and LIE's physical crimson draw visible from sim truth in every frontend. The opening tick found a binding violation, not just missing polish: `machine-work.md` said only THINK sheds Exposu...
+- Log: [wiki/log/2026-07-10-machine-production-visuals.md](2026-07-10-machine-production-visuals.md)
+
 ## 2026-07-10 - Stage 1: MachineMode collapse
 
 - Intent: ROADMAP #33 Stage 1: collapse the runtime `MachineMode` enum to match the WORK / THINK / LIE player grammar (sinks-not-modes). Behavior-preserving merge of Research+Operations into Think; no sink runtime yet; no save parity.
diff --git a/wiki/log/decisions/2026-07-10.md b/wiki/log/decisions/2026-07-10.md
index 771a8ee1..dd071a8f 100644
--- a/wiki/log/decisions/2026-07-10.md
+++ b/wiki/log/decisions/2026-07-10.md
@@ -449,3 +449,14 @@ Type: log
   agent planning; agent `actions` output remains explicit. This supersedes the
   same-day requirement that human rows print descriptor and role metadata.
   Owners: wiki/vision/simulation-laws.md and wiki/interface/context-menu.md.
+- **2026-07-10 — THINK production is continuous and sheds proportional
+  crimson.** The economy pulse still resolves fleet output, but its THINK
+  compute is minted as an equal per-tick Thought rate across the interval
+  rather than one twenty-tick lump. This preserves total output while making
+  production, routing, and byproduct motion continuously legible. Every
+  visible Thought token sheds 0.25 Exposure at its producing machine [TUNE];
+  WORK sheds none. LIE absorbs that physical queue within radius at the
+  existing efficiency/intensity-scaled rate. Renderers receive explicit
+  current-tick production and source-to-well absorption readouts, never queue
+  differences. Owner: wiki/mechanics/machine-work.md; implementation truth:
+  wiki/mechanics/sim-mechanics.md.
diff --git a/wiki/mechanics/machine-work.md b/wiki/mechanics/machine-work.md
index d8bd410c..1ad2375a 100644
--- a/wiki/mechanics/machine-work.md
+++ b/wiki/mechanics/machine-work.md
@@ -325,6 +325,11 @@ stacks, you route byproducts, you watch your territory *work*.
   standing signatures (Thermal/Power in detection.md) also read as
   expected baseline is [OPEN] — the JobAnomaly channel already carries
   "your output looks weird," so it is the natural sole day-job risk.
+  **B1 tuning (adopted 2026-07-10):** every visible Thought token sheds
+  0.25 Exposure at the same producing machine. The economy pulse resolves
+  the fleet's per-tick THINK rate; the sim mints that rate every tick rather
+  than dropping one twenty-tick lump, preserving total output while making
+  production, routing, and crimson shedding a continuous physical process.
 - **The core is the sink of last resort (AMENDED 2026-07-10; was "the
   core is the bone sink", 2026-07-08).** The core exerts a **passive
   draw** on all thought: with nowhere else to go, the fluid funnels
@@ -484,11 +489,9 @@ call into:
 
 - `WorkGrid` is the machine-work truth: a `FlowGraph` for wires, grid
   positions for physical proximity, and per-node queue depths.
-- `MachineMode` is exactly `day-job | research | concealment | operations`
-  as built; the sinks-not-modes target (2026-07-10) is `day-job | think |
-  lie`, with the research/operations members collapsing into `think`
-  during the #33 migration. Assigning a machine replaces the previous
-  mode, so per-machine percentage splitting has nowhere to reappear.
+- `MachineMode` is exactly `work | think | lie`; `relay` is the
+  non-delegable graph-infrastructure marker. Assigning a machine replaces the
+  previous mode, so per-machine percentage splitting has nowhere to reappear.
 - `MachineIntensity` is exactly `light | medium | hard`; each WorkGrid node
   persists one, older saves default to medium, and mode weights / local token
   throughput use its multiplier.
@@ -497,19 +500,24 @@ call into:
   leaves the pile at the source. Exposure returns an error if asked to
   ride wires and is handled by `absorb_exposure(radius, capacity)` over
   grid distance instead.
-- `queue_snapshot()` is the render contract: token stacks must draw the
-  sim's queue depths, not frontend-owned counters.
+- `queue_snapshot()` is the persistent render contract: token stacks draw the
+  sim's queue depths, not frontend-owned counters. `work_productions()`
+  reports the Thought and proportional Exposure actually emitted at each
+  THINK source this tick; `work_absorptions()` reports every physical crimson
+  source-to-LIE-well transfer. These events carry rate motion without a second
+  amount counter.
 
 Covered now by unit tests: one-mode assignment and aggregate counts;
 two-hop wired routing without teleporting; stranded piles when severed;
 crimson refusing wires; concealment wells absorbing only within radius;
 serde round-trip of queues and wires.
 
-Follow-up live slice (2026-07-08): `Sim` now links each work machine to
-the core's WorkGrid graph as machines enter/reconcile; research budget
-creates bone thought on research-delegated machines (or on the core as
-compatibility fallback when no research machine exists yet); per-tick
-wired routing drains thought toward the core sink.
+Follow-up live slice (2026-07-08, current grammar amended 2026-07-10): `Sim`
+links each work machine to the core's WorkGrid graph as machines
+enter/reconcile. Only THINK machines create Thought; WORK has no compatibility
+production fallback. The latest economy resolution becomes a per-tick rate,
+minted continuously at THINK sources, and per-tick wired routing drains
+Thought toward open sinks or the passive core draw.
 
 Bone-sink slice (2026-07-09): research progress is arrival-driven. The
 per-tick thought routing banks whatever the core sink actually
@@ -532,8 +540,10 @@ x1.50 per level for both wired families; `Sim::work_consumptions` reports
 Demand entering an executor and Thought entering the passive core draw.
 One-edge-per-tick transit remains, so a distant sink is still a distant sink.
 Bevy consumption motion landed on the same sim events: no queue-delta
-counter, and no motion while paused. Not landed yet: non-research mode
-production and people carrying exposure.
+counter, and no motion while paused. THINK production and LIE draw landed
+2026-07-10 on sibling sim events: ivory mercury swells out of the producer,
+proportional crimson settles around it, and actual dust transfers pull through
+world space into LIE wells. People carrying exposure remain pending.
 In-flight route quanta landed 2026-07-09: `Sim::work_in_flight` exposes
 the last routing step's hops and all three frontends draw the moving
 cargo (log/2026-07-09-route-blips.md).
@@ -740,13 +750,16 @@ still.
    its efficiency and the consumption is visible; a THINK machine
    visibly produces thought; a LIE machine visibly draws crimson
    (header AMENDED 2026-07-10 from "a machine in a matching mode
-   consumes its stack" — docket-era wording). **Partial:**
+   consumes its stack" — docket-era wording). **Implemented for B1:**
    Rack 3 in day-job mode consumes the active job stack using the existing
    delivered rate and emits zero exposure (WORK is clean — landed
    2026-07-09). The sim-backed `WorkConsumptionReadout` reports each Demand
    swallow and passive-core Thought swallow; Bevy renders the former as the
    bottom cube pulling into the chassis and the latter as a contracting ivory
-   bead. THINK production and LIE draw visuals remain pending.
+   bead. `WorkProductionReadout` drives the ivory source swell and proportional
+   crimson shed; `WorkAbsorptionReadout` drives the physical dust pull from
+   its source into the actual LIE well. Terminal and agent frames render `^`
+   at a producing machine and crimson / colorless `:` along the draw.
 4. Byproduct tokens route along network links at the researched network
    speed to a sink that consumes them; severing the route makes them
    pile at the source with the specified consequence. **Partial:** the
@@ -766,7 +779,9 @@ still.
    render contract; terminal, Bevy, and agent mode now render D/!/T stacks
    through sim readouts, not frontend counters. In-flight route blips
    (2026-07-09) draw from `Sim::work_in_flight`, the same routing step
-   the sim executed — no frontend-owned motion state.
+   the sim executed; production, consumption, and absorption motion likewise
+   draw from their sim-authored current-tick readouts — no frontend-owned
+   motion state.
 6. Token render anatomy matches the decided family kit: cold-signal
    information cubes at upper-left for demand
    (the docket form was amended to cubes 2026-07-09); bone-white
diff --git a/wiki/mechanics/sim-mechanics.md b/wiki/mechanics/sim-mechanics.md
index 52d3e7b7..212c94b1 100644
--- a/wiki/mechanics/sim-mechanics.md
+++ b/wiki/mechanics/sim-mechanics.md
@@ -18,20 +18,24 @@ clause (see wiki/log/2026-07-05-demolition.md).
 
 ## Compute (wiki/mechanics/compute.md)
 
-- Effective compute = sum(machine capacity × reliability) × efficiency.
+- Effective compute = sum(machine capacity × reliability × intensity) ×
+  efficiency.
 - Fleet yields split across Day Job, Research, Concealment, Operations, and
   schemes from capacity-weighted WorkGrid modes (`fleet_channel_yield`);
   core overhead is charged first (then scheme-policy
   upkeep, off the top). The FLEET bar is a read-only aggregate of those
   modes — not a weight verb. Schemes mirrors day-job while Moonlight is
   live (no Schemes machine mode yet).
-- Runtime, saves, and all frontends use Operations as the fourth mode.
-  Operations job flow DECIDED 2026-07-09 (issue #3): Demand dockets consumed
-  by Operations machines. Every former bank action now uses the typed docket
-  runtime; the compatibility pool is gone and v15 repairs both v14 shapes.
+- Runtime, saves, and all frontends use the three delegations WORK / THINK /
+  LIE; `Relay` is non-delegable infrastructure. THINK's channel is conserved:
+  typed legacy Operations dockets drink only their pending need and the
+  remainder becomes Thought for sinks/core research. The docket ledger is
+  migration base while non-opening verbs move to target-local sinks; the
+  compatibility bandwidth pool is gone.
 - Buy (slush → rack), steal (salvage dead equipment), optimize (research →
   efficiency levels at ~1.15× per level; `Compute` keeps only the applied
-  `efficiency` multiplier — levels and progress live in `src/research.rs`).
+  `efficiency` multiplier — levels and progress live in
+  `crates/misaligned-core/src/research.rs`).
 
 ## Detection (wiki/mechanics/detection.md)
 
@@ -168,9 +172,13 @@ clause (see wiki/log/2026-07-05-demolition.md).
   Relay nodes use `MachineMode::Relay` and are excluded from fleet aggregates.
 - Day-job demand consumption emits zero exposure (WORK is clean —
   machine-work.md 2026-07-09; `DAY_JOB_EXPOSURE_PER_TOKEN` removed).
-  Crimson only appears from THINK-state byproducts once those land.
-  Concealment wells currently absorb exposure within radius 3 at 0.10 tokens
-  per tick [TUNE] (`CONCEALMENT_WELL_RADIUS`,
+  Only THINK creates Thought: the last economy resolution sets a per-tick
+  compute rate, and every tick each online THINK machine mints its weighted
+  share divided by `WORK_TOKEN_COMPUTE`. Every produced Thought token sheds
+  0.25 Exposure on that source machine [TUNE]
+  (`THINK_EXPOSURE_PER_THOUGHT_TOKEN`). Concealment wells absorb physical
+  Exposure within radius 3 at 0.10 tokens per tick [TUNE], multiplied by the
+  well's efficiency and intensity (`CONCEALMENT_WELL_RADIUS`,
   `CONCEALMENT_ABSORB_PER_TICK`).
 - Terminal, Bevy, and agent mode render stack glyphs/readouts from sim
   readouts (`WorkStackReadout`), not frontend counters. In-flight wired
@@ -187,6 +195,12 @@ clause (see wiki/log/2026-07-05-demolition.md).
   those events over the wall-clock tick as a Demand cube entering the executor
   or a Thought bead contracting into the core; paused frames show only the
   persistent stack/sink amount geometry.
+- Production and physical absorption are sibling current-tick contracts.
+  `WorkProductionReadout` via `Sim::work_productions` gives each THINK source's
+  actual Thought and Exposure output. `WorkAbsorptionReadout` via
+  `Sim::work_absorptions` gives each crimson source, receiving LIE well, and
+  amount removed. Frontends animate only these facts; persistent queue depth
+  remains `WorkStackReadout`, and all transient work readouts clear on load.
 - `OperationsState` owns stable job ids, typed payload metadata, FIFO progress,
   duplicate suppression, and the next id. A new docket is born directly on the
   least-loaded online Operations machine as ordinary visible Demand; its
diff --git a/wiki/process/ROADMAP.md b/wiki/process/ROADMAP.md
index 0b1e6b87..04ebcaf3 100644
--- a/wiki/process/ROADMAP.md
+++ b/wiki/process/ROADMAP.md
@@ -554,7 +554,7 @@ is retired — flat materials, Pixel Lab scrubbed.)
 - **Playable slice:** `WorkGrid` is now `Sim`/save state; Rack 3 starts in
   day-job mode; Voss jobs enqueue on an off-map desktop relay, hop the
   switch, and deposit on the host; day-job mode consumes them into
-  exposure; host non-day-job mode makes them pile; both frontends and
+  completed work without Exposure; host non-WORK mode makes them pile; both frontends and
   agent mode render D/!/T stacks and expose single-machine delegation.
   Economy yields and the FLEET bar now derive from capacity-weighted mode
   shares (`fleet_channel_yield`); 1-5 / `alloc` are retired. Schemes
@@ -563,19 +563,23 @@ is retired — flat materials, Pixel Lab scrubbed.)
   Shift+t / `1`–`3` / Esc in terminal; `select` / `delegate selected` in
   agent mode). 2026-07-09: demand ingress path DECIDED (Voss desktop ->
   switch -> host).
-- **Next:** non-research production polish, then people-as-carriers. The
-  researched Routing curve and sim-authored Demand/Thought consumption motion
-  landed 2026-07-10 (save v21; `Sim::work_consumptions`; deterministic Bevy
-  harness states).
+- **Next:** people-as-carriers. Continuous THINK production, proportional
+  crimson shedding, and physical LIE-well draw landed 2026-07-10 on
+  sim-authored production/absorption readouts (with terminal, agent, and
+  deterministic Bevy evidence). The researched Routing curve and sim-authored
+  Demand/Thought consumption motion landed earlier the same day (save v21;
+  `Sim::work_consumptions`).
   In-flight route quanta landed 2026-07-09 (`Sim::work_in_flight` blips in
   all three frontends). Research production is arrival-driven 2026-07-09
   (Thought must reach the current core sink to count; `banked_core_thought`,
-  renamed in save v18; stranded Thought stalls research with a witness line). Non-research
-  mode production polish remains. The target four-mode fleet is DECIDED:
-  Day Job / Research / Concealment / Operations. Runtime, saves, and
-  frontends now use Operations. **Operations docket model IMPLEMENTED
-  2026-07-09 as the migration base (Tangled issue #3):**
-  player-authored work is cold-signal Demand consumed by Operations machines;
+  renamed in save v18; stranded Thought stalls research with a witness line).
+  The superseded four-mode fleet (Day Job / Research / Concealment /
+  Operations) remains history and migration context. Runtime, saves, and
+  frontends now use WORK / THINK / LIE, with Relay as non-delegable
+  infrastructure. **Operations docket model IMPLEMENTED 2026-07-09 as the
+  migration base (Tangled issue #3):**
+  player-authored work is cold-signal Demand consumed by THINK machines' reserved
+  Operations channel while the migration-base docket exists;
   staging `operations_bandwidth` bank deleted. `OperationsState` owns typed
   FIFO payloads and one shared readout; save v16 normalizes both v14 schemas;
   only opening Ears/Eyes may bootstrap without an executor. The old separate
@@ -600,13 +604,11 @@ is retired — flat materials, Pixel Lab scrubbed.)
   job, sheds nothing), THINK (self-chosen subdomains that shed crimson),
   LIE (concealment, absorbs crimson). Day-job exposure byproduct removed
   from runtime 2026-07-09 (`DAY_JOB_EXPOSURE_PER_TOKEN` gone — WORK sheds
-  nothing; compliant floor is clean). Still pending under this grammar:
-  regroup the delegation surface in both frontends into WORK / THINK / LIE
-  (THINK holds Operations at run start, Research locked until its [OPEN]
-  trigger; LIE is concealment as its own face); implement the first-think
-  beat — same-tick crimson shedding, highlighted turn-it-off control,
-  one-press toggle each way, and the afford-reveal on the cheapest
-  Operations verb. **Thought flow DECIDED 2026-07-10** (machine-work.md,
+  nothing; compliant floor is clean). The delegation surface is now the
+  three verbs in all frontends; same-tick crimson shedding, one-press mode
+  switching, and the staged Ears/Eyes afford-reveal have landed. The broader
+  first-think choreography still owns any future highlighted turn-it-off
+  treatment. **Thought flow DECIDED 2026-07-10** (machine-work.md,
   ops bullet + core-sink bullet + criterion 10): the former Knowledge family is
   named Thought — the one substance THINK produces; operations become
   sinks at the target (camera tap = reservoir filling from real wire