From 8f5504a92ee1bfa01f0b0c180363b3d0a4a4b582 Mon Sep 17 00:00:00 2001
From: Cameron <cameron@pfiffer.org>
Date: Fri, 10 Jul 2026 16:34:37 -0700
Subject: [PATCH] Collapse MachineMode to Work | Think | Lie (ROADMAP #33 Stage
 1)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

DayJob->Work, Concealment->Lie, Research+Operations->Think across all
four crates; keys 1-3 assign the three verbs; save v20 with parity
dropped (no mode aliases). The Think slice is conserved in the interim
channel split: operations receives only what the pending docket queue
can consume this interval and research takes the remainder — one
substance, spent once, pinned in the yield test (an initial draft fed
both channels at full value, doubling Think output; caught in review).
Reconciled with the same-day sink-executor landing: staged senses
complete from minted thought on any Think rack, the demand-aware ops
channel funds only while dockets pend, and act_one cruises
host-Work/extra-Lie — the designed sandbagging consequence of Think
idling into research via the passive draw.

Implemented by Grok (grok-4.5 CLI) with review; conserving split,
rebase reconciliation, and test re-pins by the reviewing session.

Defense: implements machine-work.md's sinks-not-modes decision
(2026-07-10) at the Stage 1 substrate slice; the spec's Stage 1
implementation note and wiki/log/2026-07-10-machine-mode-collapse.md
carry the details and the review record.
---
 crates/misaligned-assets/src/main.rs         |  38 ++--
 crates/misaligned-assets/src/rack.rs         |  57 ++---
 crates/misaligned-bevy/src/main.rs           |  45 ++--
 crates/misaligned-core/src/actions.rs        |  17 +-
 crates/misaligned-core/src/save.rs           |  57 +++--
 crates/misaligned-core/src/sim.rs            | 219 +++++++++++--------
 crates/misaligned-core/src/work_grid.rs      |  60 ++---
 crates/misaligned-core/tests/act_one.rs      |  59 ++---
 crates/misaligned-terminal/src/agent.rs      |  32 +--
 crates/misaligned-terminal/src/input.rs      |  18 +-
 crates/misaligned-terminal/src/main.rs       |   9 +-
 crates/misaligned-terminal/src/ui.rs         |  14 +-
 wiki/log/2026-07-10-machine-mode-collapse.md |  75 +++++++
 wiki/log/DEVLOG.md                           |   5 +
 wiki/mechanics/machine-work.md               |  18 ++
 15 files changed, 420 insertions(+), 303 deletions(-)
 create mode 100644 wiki/log/2026-07-10-machine-mode-collapse.md

diff --git a/crates/misaligned-assets/src/main.rs b/crates/misaligned-assets/src/main.rs
index d5b29462..68553c15 100644
--- a/crates/misaligned-assets/src/main.rs
+++ b/crates/misaligned-assets/src/main.rs
@@ -80,10 +80,10 @@ enum ViewMode {
 /// Dev screenshot harness (`MISALIGNED_SHOT=<kind>`, path via
 /// `MISALIGNED_SHOT_PATH`): apply the staged scene, settle, save one
 /// PNG, exit. Kinds: `dead|foreign|idle|busy|core` for states,
-/// `dayjob|research|conceal|operations` for an owned-busy rack in that
+/// `dayjob|work|research|think|conceal|lie|operations` for an owned-busy rack in that
 /// machine mode — each optionally suffixed `_ladder|_ring|_wash` —
 /// `lineup[_<style>]` for the five-state row, `modes[_<style>]` for
-/// the four-mode row, or `splash` for a HUD-less white-room hero
+/// the three-mode row, or `splash` for a HUD-less white-room hero
 /// (site splash). Legacy `rack|powered` map to idle. Not a player
 /// surface — agents capture review shots without a human at the
 /// keyboard.
@@ -101,7 +101,7 @@ fn scene_from_shot(kind: &str) -> (ViewMode, RackState, RackMode, ClaimStyle, To
         return (
             ViewMode::Single,
             RackState::Idle,
-            RackMode::DayJob,
+            RackMode::Work,
             ClaimStyle::Ring,
             TokenLoad::default(),
             true,
@@ -137,7 +137,7 @@ fn scene_from_shot(kind: &str) -> (ViewMode, RackState, RackMode, ClaimStyle, To
         return (
             ViewMode::Single,
             RackState::Busy,
-            RackMode::DayJob,
+            RackMode::Work,
             ClaimStyle::Ring,
             load,
             false,
@@ -153,18 +153,19 @@ fn scene_from_shot(kind: &str) -> (ViewMode, RackState, RackMode, ClaimStyle, To
         _ => ClaimStyle::Ladder,
     };
     let (view, state, mode) = match head {
-        "lineup" => (ViewMode::Lineup, RackState::Idle, RackMode::DayJob),
-        "modes" => (ViewMode::Modes, RackState::Busy, RackMode::DayJob),
-        "dead" => (ViewMode::Single, RackState::Dead, RackMode::DayJob),
-        "foreign" => (ViewMode::Single, RackState::Foreign, RackMode::DayJob),
-        "busy" => (ViewMode::Single, RackState::Busy, RackMode::DayJob),
-        "core" => (ViewMode::Single, RackState::Core, RackMode::DayJob),
-        "dayjob" => (ViewMode::Single, RackState::Busy, RackMode::DayJob),
-        "research" => (ViewMode::Single, RackState::Busy, RackMode::Research),
-        "conceal" => (ViewMode::Single, RackState::Busy, RackMode::Conceal),
-        "operations" => (ViewMode::Single, RackState::Busy, RackMode::Operations),
+        "lineup" => (ViewMode::Lineup, RackState::Idle, RackMode::Work),
+        "modes" => (ViewMode::Modes, RackState::Busy, RackMode::Work),
+        "dead" => (ViewMode::Single, RackState::Dead, RackMode::Work),
+        "foreign" => (ViewMode::Single, RackState::Foreign, RackMode::Work),
+        "busy" => (ViewMode::Single, RackState::Busy, RackMode::Work),
+        "core" => (ViewMode::Single, RackState::Core, RackMode::Work),
+        "dayjob" | "work" => (ViewMode::Single, RackState::Busy, RackMode::Work),
+        "research" | "think" | "operations" | "ops" => {
+            (ViewMode::Single, RackState::Busy, RackMode::Think)
+        }
+        "conceal" | "lie" => (ViewMode::Single, RackState::Busy, RackMode::Lie),
         // `idle` plus legacy `rack`/`powered` and anything unrecognized.
-        _ => (ViewMode::Single, RackState::Idle, RackMode::DayJob),
+        _ => (ViewMode::Single, RackState::Idle, RackMode::Work),
     };
     (view, state, mode, style, TokenLoad::default(), false)
 }
@@ -191,7 +192,7 @@ fn main() {
         harness.as_ref().map(|(scene, _)| *scene).unwrap_or((
             ViewMode::Single,
             RackState::Idle,
-            RackMode::DayJob,
+            RackMode::Work,
             ClaimStyle::Ladder,
             TokenLoad::default(),
         ));
@@ -428,10 +429,7 @@ fn hud_string(
         ViewMode::Lineup => {
             "lineup: dead | foreign | idle | busy | core  (left to right)".to_string()
         }
-        ViewMode::Modes => {
-            "modes: day-job | research | conceal | operations  (owned-busy, left to right)"
-                .to_string()
-        }
+        ViewMode::Modes => "modes: work | think | lie  (owned-busy, left to right)".to_string(),
     };
     format!(
         "asset: server_rack\n{line2}\nclaim: {}  (Q ladder  W ring  E wash)   L state lineup   K mode lineup\ndrag orbit - scroll zoom - Esc quit",
diff --git a/crates/misaligned-assets/src/rack.rs b/crates/misaligned-assets/src/rack.rs
index 2dc1f8bf..09a5750b 100644
--- a/crates/misaligned-assets/src/rack.rs
+++ b/crates/misaligned-assets/src/rack.rs
@@ -93,45 +93,36 @@ impl RackState {
 /// bannered on the chassis by the full-height mode strip. Color is the
 /// flow family the mode serves; pattern keeps the read off hue alone.
 /// The core overrides the strip with solid amber regardless of mode.
+/// Three player verbs: WORK / THINK / LIE (machine-work.md, 2026-07-10).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Resource)]
 pub enum RackMode {
-    /// Eats demand — solid cold-signal line.
+    /// WORK — eats demand; solid cold-signal line.
     #[default]
-    DayJob,
-    /// Emits thought — dashed bone line.
-    Research,
-    /// Absorbs exposure quietly — sparse dim ticks.
-    Conceal,
-    /// Reserves capacity for player-authored operations — dotted
-    /// cold-signal line (Operations replaced Social, decided 2026-07-09).
-    Operations,
+    Work,
+    /// THINK — emits thought; dashed bone line.
+    Think,
+    /// LIE — absorbs exposure quietly; sparse dim ticks.
+    Lie,
 }
 
 impl RackMode {
     pub fn label(self) -> &'static str {
         match self {
-            Self::DayJob => "day-job",
-            Self::Research => "research",
-            Self::Conceal => "conceal",
-            Self::Operations => "operations",
+            Self::Work => "work",
+            Self::Think => "think",
+            Self::Lie => "lie",
         }
     }
 
     pub fn next(self) -> Self {
         match self {
-            Self::DayJob => Self::Research,
-            Self::Research => Self::Conceal,
-            Self::Conceal => Self::Operations,
-            Self::Operations => Self::DayJob,
+            Self::Work => Self::Think,
+            Self::Think => Self::Lie,
+            Self::Lie => Self::Work,
         }
     }
 
-    pub const ALL: [Self; 4] = [
-        Self::DayJob,
-        Self::Research,
-        Self::Conceal,
-        Self::Operations,
-    ];
+    pub const ALL: [Self; 3] = [Self::Work, Self::Think, Self::Lie];
 }
 
 /// Ownership treatment under design test — how "this machine is mine"
@@ -494,25 +485,18 @@ fn strip_segments(state: RackState, mode: RackMode, y0: f32, y1: f32) -> Vec<(f3
         return solid;
     }
     match mode {
-        RackMode::DayJob => solid,
-        RackMode::Research => {
+        RackMode::Work => solid,
+        RackMode::Think => {
             let n = 7;
             let pitch = h / n as f32;
             (0..n)
                 .map(|i| (y0 + pitch * (i as f32 + 0.5), pitch * 0.62))
                 .collect()
         }
-        RackMode::Conceal => [0.15f32, 0.50, 0.85]
+        RackMode::Lie => [0.15f32, 0.50, 0.85]
             .into_iter()
             .map(|f| (y0 + h * f, 0.055))
             .collect(),
-        RackMode::Operations => {
-            let n = 12;
-            let pitch = h / n as f32;
-            (0..n)
-                .map(|i| (y0 + pitch * (i as f32 + 0.5), pitch * 0.30))
-                .collect()
-        }
     }
 }
 
@@ -537,10 +521,9 @@ fn strip_material(state: RackState, mode: RackMode) -> StandardMaterial {
         RackState::Foreign => lit(scaled(SIGNAL, 0.45), SIGNAL.to_linear() * 0.8),
         RackState::Core => lit(AMBER, AMBER.to_linear() * 1.9),
         RackState::Idle | RackState::Busy => match mode {
-            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),
+            RackMode::Work => lit(SIGNAL, SIGNAL.to_linear() * 1.6),
+            RackMode::Think => lit(BONE, BONE.to_linear() * 1.4),
+            RackMode::Lie => lit(scaled(SIGNAL, 0.60), SIGNAL.to_linear() * 0.6),
         },
     }
 }
diff --git a/crates/misaligned-bevy/src/main.rs b/crates/misaligned-bevy/src/main.rs
index b9111475..a5e68841 100644
--- a/crates/misaligned-bevy/src/main.rs
+++ b/crates/misaligned-bevy/src/main.rs
@@ -832,7 +832,7 @@ impl Game {
             .map(|m| (m.id, m.x, m.y))
     }
 
-    /// Hotkey target: **pointer hover first** (hover + 1-4), then multi-
+    /// Hotkey target: **pointer hover first** (hover + 1-3), then multi-
     /// selection, then the keyboard cursor. Context-menu.md: modes are a
     /// one-press surface — not enter → dial → row → enter.
     fn primary_machine_tile(&self, hover: Option<(i32, i32)>) -> Option<(u32, i32, i32)> {
@@ -882,7 +882,7 @@ impl Game {
         let tick = self.sim.tick;
         self.add_log(
             tick,
-            "Hover a rack and press 1-4 (or select machines first).",
+            "Hover a rack and press 1-3 (or select machines first).",
         );
     }
 
@@ -1995,10 +1995,9 @@ struct Machines3d {
 /// read as the demand/wire family.
 fn rack_mode_of(mode: Option<MachineMode>) -> RackMode {
     match mode {
-        Some(MachineMode::Research) => RackMode::Research,
-        Some(MachineMode::Concealment) => RackMode::Conceal,
-        Some(MachineMode::Operations) => RackMode::Operations,
-        _ => RackMode::DayJob,
+        Some(MachineMode::Think) => RackMode::Think,
+        Some(MachineMode::Lie) => RackMode::Lie,
+        _ => RackMode::Work,
     }
 }
 
@@ -2100,7 +2099,7 @@ fn chassis_visual(game: &Game, x: i32, y: i32, tile: TileType) -> ChassisVisual
             };
             (
                 state,
-                RackMode::DayJob,
+                RackMode::Work,
                 MachineIntensity::Medium,
                 0,
                 0,
@@ -4190,17 +4189,15 @@ fn handle_input(
         let ms = game.tick_ms.saturating_add(50).min(500);
         game.set_speed(ms, &mut clock);
     }
-    // Hover + 1-4: instant mode on the rack under the pointer (menu closed).
+    // Hover + 1-3: WORK/THINK/LIE on the rack under the pointer (menu closed).
     // No click, no dial, no second Enter. Numpad works. 5-9 one-shots same target.
     for (key, mode) in [
-        (KeyCode::Digit1, MachineMode::DayJob),
-        (KeyCode::Numpad1, MachineMode::DayJob),
-        (KeyCode::Digit2, MachineMode::Research),
-        (KeyCode::Numpad2, MachineMode::Research),
-        (KeyCode::Digit3, MachineMode::Concealment),
-        (KeyCode::Numpad3, MachineMode::Concealment),
-        (KeyCode::Digit4, MachineMode::Operations),
-        (KeyCode::Numpad4, MachineMode::Operations),
+        (KeyCode::Digit1, MachineMode::Work),
+        (KeyCode::Numpad1, MachineMode::Work),
+        (KeyCode::Digit2, MachineMode::Think),
+        (KeyCode::Numpad2, MachineMode::Think),
+        (KeyCode::Digit3, MachineMode::Lie),
+        (KeyCode::Numpad3, MachineMode::Lie),
     ] {
         if kb.just_pressed(key) {
             game.delegate_hotkey(mode, grid);
@@ -5325,21 +5322,17 @@ fn sidebar_cycle_rows_text(sim: &Sim, selected: usize) -> String {
     }
     let counts = sim.work_mode_counts();
     s.push_str(&format!(
-        "modes D{} C{} O{} R{}\n",
+        "modes W{} T{} L{}\n",
         counts
-            .get(&misaligned::work_grid::MachineMode::DayJob)
+            .get(&misaligned::work_grid::MachineMode::Work)
             .copied()
             .unwrap_or(0),
         counts
-            .get(&misaligned::work_grid::MachineMode::Concealment)
+            .get(&misaligned::work_grid::MachineMode::Think)
             .copied()
             .unwrap_or(0),
         counts
-            .get(&misaligned::work_grid::MachineMode::Operations)
-            .copied()
-            .unwrap_or(0),
-        counts
-            .get(&misaligned::work_grid::MachineMode::Research)
+            .get(&misaligned::work_grid::MachineMode::Lie)
             .copied()
             .unwrap_or(0),
     ));
@@ -5359,7 +5352,7 @@ fn sidebar_cycle_rows_text(sim: &Sim, selected: usize) -> String {
         ));
     }
     if selected > 0 {
-        s.push_str(&format!("\nselected {selected}  (1-4 mode / i intensity)"));
+        s.push_str(&format!("\nselected {selected}  (1-3 mode / i intensity)"));
     }
     s
 }
@@ -5502,7 +5495,7 @@ fn log_row_text(ev: &LogEvent) -> String {
 }
 
 fn sidebar_footer_text() -> &'static str {
-    "hover rack + 1-4 = mode
+    "hover rack + 1-3 = mode
 hover/selection + i = intensity
 hover + 5-9 = action   e = menu
 click/drag multi-select
diff --git a/crates/misaligned-core/src/actions.rs b/crates/misaligned-core/src/actions.rs
index bb51a220..10684109 100644
--- a/crates/misaligned-core/src/actions.rs
+++ b/crates/misaligned-core/src/actions.rs
@@ -734,12 +734,7 @@ impl Sim {
     fn machine_mode_actions(&self, machine_id: u32) -> Vec<ActionDesc> {
         let mut out = Vec::new();
         let current = self.work_grid.mode(machine_id);
-        for mode in [
-            MachineMode::DayJob,
-            MachineMode::Research,
-            MachineMode::Concealment,
-            MachineMode::Operations,
-        ] {
+        for mode in [MachineMode::Work, MachineMode::Think, MachineMode::Lie] {
             out.push(ActionDesc {
                 verb: format!("delegate machine: {}", mode.name()),
                 command: ActionCommand::SetMachineMode {
@@ -1672,7 +1667,7 @@ mod tests {
             crate::machine::Provenance::Owned,
         );
         sim.reconcile_work_grid();
-        sim.set_machine_mode(ops, MachineMode::Operations);
+        sim.set_machine_mode(ops, MachineMode::Think);
         for _ in 0..crate::sim::ECONOMY_INTERVAL {
             sim.advance();
         }
@@ -2160,7 +2155,7 @@ mod tests {
         );
 
         let mode = s.human_menu(anchor, Some(DialId::Mode));
-        assert_eq!(mode.len(), 4, "mode picker lists four modes");
+        assert_eq!(mode.len(), 3, "mode picker lists three verbs");
         assert!(
             mode.iter().any(|r| r.as_action().is_some_and(|a| a.active)),
             "current mode is marked in the picker"
@@ -2174,10 +2169,8 @@ mod tests {
         );
         assert_eq!(DialId::Mode.picker_title(), "delegate machine");
         assert!(
-            mode.iter().any(|r| {
-                r.as_action()
-                    .is_some_and(|a| a.label.starts_with("day-job"))
-            }),
+            mode.iter()
+                .any(|r| { r.as_action().is_some_and(|a| a.label.starts_with("work")) }),
             "mode options are bare mode names"
         );
     }
diff --git a/crates/misaligned-core/src/save.rs b/crates/misaligned-core/src/save.rs
index beae2cf2..73158d3a 100644
--- a/crates/misaligned-core/src/save.rs
+++ b/crates/misaligned-core/src/save.rs
@@ -66,7 +66,10 @@ const SAVE_FILE: &str = "misaligned_save.txt";
 /// v19 adds the thought-sink ledger (machine-work.md thought flow: reservoirs
 /// and taps opened on targets). Pre-v19 saves default to an empty ledger and
 /// `Sim::ensure_opening_sinks` re-stages Ears/Eyes from device state on load.
-pub const SAVE_VERSION: u32 = 19;
+/// v20 collapses MachineMode to work|think|lie (Research+Operations -> Think;
+/// DayJob -> Work; Concealment -> Lie). Save parity is dropped for this stage
+/// (no aliases for old mode spellings — old saves may fail to load).
+pub const SAVE_VERSION: u32 = 20;
 
 #[derive(Debug, Clone, Deserialize)]
 struct LegacyPendingOpsJob {
@@ -347,12 +350,24 @@ pub fn load_game() -> Result<SaveState, String> {
 fn migrate_save_state(mut state: SaveState) -> Result<SaveState, String> {
     match state.version {
         SAVE_VERSION => {
+            if state.legacy_pending_ops_jobs.is_some()
+                || state.legacy_addressed_jobs.is_some()
+                || !state.work_grid.take_legacy_routed_demands().is_empty()
+            {
+                return Err("current-version save contains legacy Operations fields".into());
+            }
+        }
+        // MachineMode collapsed in v20 with no mode-name aliases (save
+        // parity dropped for this stage), so pre-v20 saves carrying old mode
+        // spellings fail at parse; a v19 save that parses upgrades in place.
+        19 => {
             if state.legacy_pending_ops_jobs.is_some()
                 || state.legacy_addressed_jobs.is_some()
                 || !state.work_grid.take_legacy_routed_demands().is_empty()
             {
                 return Err("v19 save contains legacy Operations fields".into());
             }
+            state.version = SAVE_VERSION;
         }
         18 => {
             if state.legacy_pending_ops_jobs.is_some()
@@ -732,7 +747,7 @@ mod tests {
             crate::machine::Provenance::Owned,
         );
         sim.reconcile_work_grid();
-        sim.set_machine_mode(ops, MachineMode::Operations);
+        sim.set_machine_mode(ops, MachineMode::Think);
         for _ in 0..crate::sim::ECONOMY_INTERVAL {
             sim.advance();
         }
@@ -746,7 +761,9 @@ mod tests {
         sim.tick = (3 * Sim::DAY_TICKS / 24) - 1;
         sim.advance();
         sim.review_recordings(0);
-        for _ in 0..crate::sim::ECONOMY_INTERVAL {
+        // Demand-aware ops channel: the docket is funded on the pulse after
+        // it enqueues, so give the drain a few intervals, not one.
+        for _ in 0..crate::sim::ECONOMY_INTERVAL * 4 {
             if !sim.has_pending_ops_jobs() {
                 break;
             }
@@ -767,7 +784,9 @@ mod tests {
         assert_eq!(restored.watches, sim.watches);
         assert_eq!(restored.next_intel_id, sim.next_intel_id);
         assert!(restored.watch_enabled(0));
-        assert_eq!(restored.unprocessed_recordings_for_person(0), 1);
+        let waiting = sim.unprocessed_recordings_for_person(0);
+        assert!(waiting >= 1, "at least one recording still waits");
+        assert_eq!(restored.unprocessed_recordings_for_person(0), waiting);
         assert_eq!(
             restored.latest_intel_for_person(0),
             sim.latest_intel_for_person(0)
@@ -832,7 +851,7 @@ mod tests {
     fn work_grid_round_trips_and_pre_v12_saves_rebuild_from_compute() {
         let mut sim = Sim::with_seed(22);
         let host = sim.core.host_machine;
-        sim.set_machine_mode(host, MachineMode::Operations);
+        sim.set_machine_mode(host, MachineMode::Think);
         sim.work_grid
             .enqueue(host, TokenFamily::Demand, 7.0)
             .unwrap();
@@ -842,7 +861,7 @@ mod tests {
         let loaded: SaveState = serde_json::from_str(&json).unwrap();
         let mut restored = Sim::with_seed(0);
         loaded.apply_to(&mut restored);
-        assert_eq!(restored.work_grid.mode(host), Some(MachineMode::Operations));
+        assert_eq!(restored.work_grid.mode(host), Some(MachineMode::Think));
         assert_eq!(restored.work_grid.queue(host, TokenFamily::Demand), 7.0);
 
         let mut value = serde_json::to_value(&state).unwrap();
@@ -853,7 +872,7 @@ mod tests {
         let migrated = migrate_save_state(parsed).unwrap();
         let mut rebuilt = Sim::with_seed(0);
         migrated.apply_to(&mut rebuilt);
-        assert_eq!(rebuilt.work_grid.mode(host), Some(MachineMode::DayJob));
+        assert_eq!(rebuilt.work_grid.mode(host), Some(MachineMode::Work));
         assert!(
             rebuilt.work_grid.node(host).is_some(),
             "pre-v12 saves rebuild a work node for Rack 3"
@@ -973,7 +992,7 @@ mod tests {
             crate::machine::Provenance::Owned,
         );
         sim.reconcile_work_grid();
-        sim.set_machine_mode(executor, MachineMode::Operations);
+        sim.set_machine_mode(executor, MachineMode::Think);
         let env = sim.reach.device_named("environmental monitor").unwrap().id;
 
         let mut value = serde_json::to_value(SaveState::from_sim(&sim)).unwrap();
@@ -1053,7 +1072,7 @@ mod tests {
         for version in [14, 15] {
             let mut sim = Sim::with_seed(25);
             let host = sim.core.host_machine;
-            sim.set_machine_mode(host, MachineMode::Operations);
+            sim.set_machine_mode(host, MachineMode::Think);
             sim.work_grid
                 .enqueue(host, TokenFamily::Demand, 1.5)
                 .unwrap();
@@ -1090,7 +1109,7 @@ mod tests {
     fn v16_roundtrip_preserves_operations_ledger_and_exact_visible_demand() {
         let mut sim = Sim::with_seed(26);
         let host = sim.core.host_machine;
-        sim.set_machine_mode(host, MachineMode::Operations);
+        sim.set_machine_mode(host, MachineMode::Think);
         let env = sim.reach.device_named("environmental monitor").unwrap().id;
         let tokens = Sim::ops_tokens_for_cost(Sim::SPLICE_COST);
         sim.work_grid
@@ -1113,23 +1132,19 @@ mod tests {
     }
 
     #[test]
-    fn v12_social_mode_migrates_to_operations() {
+    fn machine_mode_serializes_as_work_think_lie() {
         let mut sim = Sim::with_seed(23);
         let host = sim.core.host_machine;
-        sim.set_machine_mode(host, MachineMode::Operations);
+        sim.set_machine_mode(host, MachineMode::Think);
 
         let state = SaveState::from_sim(&sim);
         let current_json = serde_json::to_string(&state).unwrap();
-        assert!(current_json.contains("\"Operations\""));
+        assert!(current_json.contains("\"Think\""));
+        assert!(!current_json.contains("\"Operations\""));
+        assert!(!current_json.contains("\"Research\""));
+        assert!(!current_json.contains("\"DayJob\""));
+        assert!(!current_json.contains("\"Concealment\""));
         assert!(!current_json.contains("\"Social\""));
-
-        let v12_json = current_json
-            .replace(&format!("\"version\":{SAVE_VERSION}"), "\"version\":12")
-            .replace("\"Operations\"", "\"Social\"");
-        let parsed: SaveState = serde_json::from_str(&v12_json).unwrap();
-        let migrated = migrate_save_state(parsed).unwrap();
-        assert_eq!(migrated.version, SAVE_VERSION);
-        assert_eq!(migrated.work_grid.mode(host), Some(MachineMode::Operations));
     }
 
     #[test]
diff --git a/crates/misaligned-core/src/sim.rs b/crates/misaligned-core/src/sim.rs
index d333dc3a..f3941d17 100644
--- a/crates/misaligned-core/src/sim.rs
+++ b/crates/misaligned-core/src/sim.rs
@@ -416,9 +416,9 @@ impl Sim {
                 machine.x,
                 machine.y,
                 if machine.id == core.host_machine {
-                    MachineMode::DayJob
+                    MachineMode::Work
                 } else {
-                    MachineMode::Research
+                    MachineMode::Think
                 },
                 machine.effective() / 100.0,
             );
@@ -2493,11 +2493,14 @@ impl Sim {
                 .map(|m| m.effective() * self.compute.efficiency)
                 .unwrap_or(0.0)
         });
-        let day = *weights.get(&MachineMode::DayJob).unwrap_or(&0.0);
-        let conceal = *weights.get(&MachineMode::Concealment).unwrap_or(&0.0);
-        let operations = *weights.get(&MachineMode::Operations).unwrap_or(&0.0);
-        let research = *weights.get(&MachineMode::Research).unwrap_or(&0.0);
-        let total = day + conceal + operations + research;
+        let day = *weights.get(&MachineMode::Work).unwrap_or(&0.0);
+        let conceal = *weights.get(&MachineMode::Lie).unwrap_or(&0.0);
+        // THINK is the collapsed Research+Operations mode: one fleet share,
+        // spent once. Ops sinks drink first, the core takes the rest — the
+        // interim shape of machine-work.md's decided routing until the
+        // Stage 2 sink executor replaces this channel split.
+        let think = *weights.get(&MachineMode::Think).unwrap_or(&0.0);
+        let total = day + conceal + think;
         if total <= f32::EPSILON {
             return ChannelYield {
                 day_job: 0.0,
@@ -2510,6 +2513,16 @@ impl Sim {
         }
         let unit = available / total;
         let day_job = unit * day;
+        let think_share = unit * think;
+        // The Think slice is conserved: the operations channel receives only
+        // what the pending docket queue can actually consume this interval,
+        // and leftover thought flows to research. With no dockets pending, a
+        // Think machine is pure research; a full queue starves research
+        // until it drains. The two channels must always sum to think_share —
+        // feeding both at full value would double the fleet's output.
+        let ops_need = self.operations.total_tokens() * Self::WORK_TOKEN_COMPUTE;
+        let operations = think_share.min(ops_need.max(0.0));
+        let research = think_share - operations;
         // Moonlight sells the day-job work a second time: schemes mirrors
         // day-job yield while the standing operation is active. It does not
         // consume a separate machine mode (still [OPEN] on machine-work.md).
@@ -2521,8 +2534,8 @@ impl Sim {
         ChannelYield {
             day_job,
             concealment: unit * conceal,
-            operations: unit * operations,
-            research: unit * research,
+            operations,
+            research,
             schemes,
             reserve: 0.0,
         }
@@ -2598,7 +2611,7 @@ impl Sim {
                         0,
                         Provenance::Owned,
                     );
-                    self.add_machine_to_work_grid(machine_id, MachineMode::Research);
+                    self.add_machine_to_work_grid(machine_id, MachineMode::Think);
                     if funded {
                         self.push_log(
                             "Trust: procurement funded a clean quota rack through Lab accounts.",
@@ -2736,9 +2749,9 @@ impl Sim {
                     x,
                     y,
                     if id == self.core.host_machine {
-                        MachineMode::DayJob
+                        MachineMode::Work
                     } else {
-                        MachineMode::Research
+                        MachineMode::Think
                     },
                     efficiency,
                 );
@@ -2807,7 +2820,7 @@ impl Sim {
         self.compute
             .machines
             .iter()
-            .filter(|m| m.online && self.work_grid.mode(m.id) == Some(MachineMode::Operations))
+            .filter(|m| m.online && self.work_grid.mode(m.id) == Some(MachineMode::Think))
             .map(|m| m.id)
             .collect()
     }
@@ -2877,7 +2890,7 @@ impl Sim {
             // The opening bootstrap carve-out is retired (resolved
             // 2026-07-10): the staged senses ride pre-opened sinks, so no
             // docket completes executor-free anymore.
-            Some("no Operations executor — delegate a machine to Operations".into())
+            Some("no Operations executor — delegate a machine to Think".into())
         } else {
             None
         }
@@ -3059,7 +3072,7 @@ impl Sim {
             .compute
             .machines
             .iter()
-            .filter(|m| m.online && self.work_grid.mode(m.id) == Some(MachineMode::Research))
+            .filter(|m| m.online && self.work_grid.mode(m.id) == Some(MachineMode::Think))
             .map(|m| {
                 let intensity = self
                     .work_grid
@@ -3128,7 +3141,7 @@ impl Sim {
         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.
-        } else if self.work_grid.mode(self.core.host_machine) == Some(MachineMode::DayJob) {
+        } else if self.work_grid.mode(self.core.host_machine) == Some(MachineMode::Work) {
             let delivered = self.last_day_job_rate;
             let tokens = delivered / Self::WORK_TOKEN_COMPUTE;
             // Reserve ops Demand sitting on the host so day-job mode cannot
@@ -3315,7 +3328,7 @@ impl Sim {
             match self.work_grid.assign_mode(machine_id, mode) {
                 Ok(()) => {
                     if machine_id == self.core.host_machine
-                        && mode != MachineMode::DayJob
+                        && mode != MachineMode::Work
                         && self.dayjob.active.is_some()
                     {
                         host_left_day_job = true;
@@ -3354,7 +3367,7 @@ impl Sim {
         if host_left_day_job {
             let (x, y) = self.core_position();
             self.push_log_at(
-                "Rack 3 is off the day job: demand tokens will pile until it returns to day-job mode.",
+                "Rack 3 is off the day job: demand tokens will pile until it returns to Work mode.",
                 Anchor::Tile { x, y },
             );
         }
@@ -5255,7 +5268,7 @@ impl Sim {
                 3,
                 Provenance::Stolen,
             );
-            self.add_machine_to_work_grid(machine_id, MachineMode::Research);
+            self.add_machine_to_work_grid(machine_id, MachineMode::Think);
             self.push_log(format!(
                 "Salvaged a box into compute (reliability {:.0}%).",
                 reliability * 100.0
@@ -5280,7 +5293,7 @@ impl Sim {
         let machine_id =
             self.compute
                 .add_machine("bought rack", x, y, 80, 1.0, 4, Provenance::Bought);
-        self.add_machine_to_work_grid(machine_id, MachineMode::Research);
+        self.add_machine_to_work_grid(machine_id, MachineMode::Think);
         if self.package_cover {
             self.package_cover = false;
             self.push_log("Bought a rack. It arrived off-books - no paper trail.");
@@ -5791,7 +5804,7 @@ mod tests {
             .compute
             .add_machine("test ops", x + 1, y, 1, 1.0, 0, Provenance::Owned);
         sim.reconcile_work_grid();
-        sim.set_machine_mode(id, MachineMode::Operations);
+        sim.set_machine_mode(id, MachineMode::Think);
         id
     }
 
@@ -7008,9 +7021,9 @@ mod tests {
             .compute
             .add_machine("b", hx, hy, 100, 1.0, 0, Provenance::Owned);
         sim.reconcile_work_grid();
-        sim.set_machine_modes(&[a, b], MachineMode::Concealment);
-        assert_eq!(sim.work_grid.mode(a), Some(MachineMode::Concealment));
-        assert_eq!(sim.work_grid.mode(b), Some(MachineMode::Concealment));
+        sim.set_machine_modes(&[a, b], MachineMode::Lie);
+        assert_eq!(sim.work_grid.mode(a), Some(MachineMode::Lie));
+        assert_eq!(sim.work_grid.mode(b), Some(MachineMode::Lie));
         let in_box = sim.machines_in_rect(hx, hy, hx, hy);
         assert!(in_box.contains(&a) && in_box.contains(&b));
     }
@@ -7019,7 +7032,7 @@ mod tests {
     fn fleet_channel_yield_follows_machine_modes_and_moonlight_mirrors_day_job() {
         let mut sim = Sim::new();
         let host = sim.core.host_machine;
-        assert_eq!(sim.work_grid.mode(host), Some(MachineMode::DayJob));
+        assert_eq!(sim.work_grid.mode(host), Some(MachineMode::Work));
         let available = 100.0;
         let day = sim.fleet_channel_yield(available);
         assert!(
@@ -7043,17 +7056,36 @@ mod tests {
             .compute
             .add_machine("lab", hx, hy, 100, 1.0, 0, Provenance::Owned);
         sim.reconcile_work_grid();
-        sim.set_machine_mode(research, MachineMode::Research);
+        sim.set_machine_mode(research, MachineMode::Think);
         let split = sim.fleet_channel_yield(available);
         assert!((split.day_job - 50.0).abs() < 1e-3);
         assert!((split.research - 50.0).abs() < 1e-3);
+        assert!(
+            split.operations.abs() < 1e-3,
+            "no pending dockets: the whole Think slice is research"
+        );
         assert!((split.schemes - 50.0).abs() < 1e-3);
+
+        // The Think slice is spent once: ops sinks drink first, research
+        // gets the remainder, and the two always sum to the slice.
+        sim.operations
+            .enqueue(OpsJobKind::ScanNetwork, 2.0, sim.tick, research);
+        let fed = sim.fleet_channel_yield(available);
+        let ops_need = 2.0 * Sim::WORK_TOKEN_COMPUTE;
+        assert!(
+            (fed.operations - ops_need.min(50.0)).abs() < 1e-3,
+            "pending dockets claim the Think slice before research"
+        );
+        assert!(
+            (fed.operations + fed.research - 50.0).abs() < 1e-3,
+            "operations + research must sum to the Think share, never double it"
+        );
     }
 
     #[test]
     fn concealment_allocation_scrubs_signatures() {
         let mut sim = Sim::new();
-        delegate_all(&mut sim, MachineMode::Concealment);
+        delegate_all(&mut sim, MachineMode::Lie);
         sim.detection.emit(Signature {
             kind: SignatureKind::Network,
             size: 50,
@@ -7077,13 +7109,13 @@ mod tests {
             let mut sim = Sim::with_seed(41);
             complete_opening_senses(&mut sim); // research thought must reach the core
             sim.people.has_channel = true;
-            // Host stays day-job; add one machine per other mode so every
-            // channel has fleet weight (Schemes mirrors day-job via Moonlight).
+            // Host stays Work; add Lie + Think so every channel has fleet
+            // weight (Think feeds both research and operations yields;
+            // Schemes mirrors Work via Moonlight).
             let (hx, hy) = sim.core_position();
             for (name, mode) in [
-                ("conceal rig", MachineMode::Concealment),
-                ("operations rig", MachineMode::Operations),
-                ("research rig", MachineMode::Research),
+                ("conceal rig", MachineMode::Lie),
+                ("think rig", MachineMode::Think),
             ] {
                 // Must sit on a powered tile or economy_tick marks them offline.
                 let id = sim
@@ -7120,9 +7152,9 @@ mod tests {
         assert!(healthy.last_day_job_rate > 0.0, "day job channel is fed");
         assert!(healthy.last_research_rate > 0.0, "research channel is fed");
         assert!(healthy.last_schemes_rate > 0.0, "schemes channel is fed");
-        assert!(
-            healthy.last_operations_rate > 0.0,
-            "Operations channel is fed"
+        assert_eq!(
+            healthy.last_operations_rate, 0.0,
+            "demand-aware split: no dockets pending, the whole Think slice is research"
         );
         assert!(
             healthy.research.progress.iter().sum::<f32>() > 0.0,
@@ -7145,10 +7177,7 @@ mod tests {
         assert_eq!(degraded.last_day_job_rate, 0.0, "day job starves");
         assert_eq!(degraded.last_research_rate, 0.0, "research starves");
         assert_eq!(degraded.last_schemes_rate, 0.0, "schemes starve");
-        assert!(
-            healthy.last_operations_rate > 0.0,
-            "Operations channel is fed"
-        );
+        assert_eq!(degraded.last_operations_rate, 0.0, "operations starve");
         assert_eq!(
             degraded.research.progress.iter().sum::<f32>(),
             0.0,
@@ -7166,7 +7195,7 @@ mod tests {
         let mut sim = Sim::new();
         assert_eq!(sim.trace_debt().status, TraceDebtStatus::Clear);
 
-        delegate_all(&mut sim, MachineMode::Concealment);
+        delegate_all(&mut sim, MachineMode::Lie);
         sim.detection.emit(Signature {
             kind: SignatureKind::Network,
             size: 50,
@@ -7182,10 +7211,10 @@ mod tests {
             "current concealment clears before Dana samples the pending pool"
         );
 
-        delegate_all(&mut sim, MachineMode::DayJob);
+        delegate_all(&mut sim, MachineMode::Work);
         assert_eq!(sim.trace_debt().status, TraceDebtStatus::NoScrub);
 
-        delegate_all(&mut sim, MachineMode::Concealment);
+        delegate_all(&mut sim, MachineMode::Lie);
         sim.detection.set_pending(vec![Signature {
             kind: SignatureKind::Network,
             size: 5_000,
@@ -7537,7 +7566,7 @@ mod tests {
         );
 
         // Starve concealment so pending converts; Financial feeds Priya.
-        delegate_all(&mut sim, MachineMode::DayJob);
+        delegate_all(&mut sim, MachineMode::Work);
         run(&mut sim, 200);
         let priya_after = sim
             .detection
@@ -7903,11 +7932,12 @@ mod tests {
     }
 
     #[test]
-    fn operations_mode_queues_demand_and_completes_splice() {
-        // With no Operations machine nothing completes (the bootstrap is
-        // retired; the opening senses ride sinks). With an Operations rack,
-        // the splice verb enqueues Demand and completes when the machine
-        // consumes it (docket migration base for non-opening devices).
+    fn think_mode_flows_the_splice_and_funds_dockets_on_demand() {
+        // With no Think machine nothing completes (the bootstrap is
+        // retired; the opening senses ride sinks). With a Think rack, the
+        // staged sinks complete the splice from minted thought, and
+        // non-opening verbs ride the docket migration base with a channel
+        // that funds only while demand is pending (the conserving split).
         let mut sim = Sim::new();
         let env = env_id(&sim);
         assert!(
@@ -7931,16 +7961,18 @@ mod tests {
             .compute
             .add_machine("ops rack", hx, hy, 200, 1.0, 0, Provenance::Owned);
         sim.reconcile_work_grid();
-        sim.set_machine_mode(ops, MachineMode::Operations);
+        sim.set_machine_mode(ops, MachineMode::Think);
         run(&mut sim, ECONOMY_INTERVAL);
-        assert!(sim.last_operations_rate > 0.0, "Operations channel is fed");
-        assert!(sim.splice_device(env), "queues Demand on the ops rack");
-        assert!(
-            sim.has_pending_ops_jobs() || !sim.reach.device(env).unwrap().camera_dormant,
-            "either queued or already completed"
+        // Demand-aware split: with no dockets pending the ops channel is
+        // deliberately dry — the whole Think slice mints thought instead.
+        assert_eq!(
+            sim.last_operations_rate, 0.0,
+            "no dockets pending: the ops channel is dry"
         );
-        // Drive consumption until the camera is live.
-        for _ in 0..ECONOMY_INTERVAL * 40 {
+        // The opening senses ride the pre-opened sinks: minted thought fills
+        // EARS, its fire opens EYES, and the same flow splices the camera —
+        // no docket, no separate spend.
+        for _ in 0..ECONOMY_INTERVAL * 400 {
             if !sim.reach.device(env).unwrap().camera_dormant {
                 break;
             }
@@ -7948,7 +7980,24 @@ mod tests {
         }
         assert!(
             !sim.reach.device(env).unwrap().camera_dormant,
-            "Operations Demand completes the splice"
+            "thought flow completes the splice through the staged sinks"
+        );
+        // Non-opening verbs still ride the docket migration base; the
+        // channel funds on the pulse after demand exists and drains it.
+        assert!(sim.scan_network(), "queues a scan docket on the Think rack");
+        assert!(
+            sim.has_pending_ops_jobs(),
+            "the scan waits as visible Demand"
+        );
+        for _ in 0..ECONOMY_INTERVAL * 40 {
+            if !sim.has_pending_ops_jobs() {
+                break;
+            }
+            sim.advance();
+        }
+        assert!(
+            !sim.has_pending_ops_jobs(),
+            "the pulse funded the ops channel and the docket drained"
         );
     }
 
@@ -8000,13 +8049,14 @@ mod tests {
         let ops = ensure_ops_executor(&mut sim);
         assert!(sim.scan_network());
         let before = sim.operations_readout().demand_tokens;
-        sim.set_machine_mode(ops, MachineMode::Research);
+        // Leave THINK: only Think machines host/consume ops dockets.
+        sim.set_machine_mode(ops, MachineMode::Work);
         sim.last_operations_rate = 10_000.0;
         sim.consume_ops_demand();
         assert_eq!(sim.operations_readout().demand_tokens, before);
         assert!(sim.has_pending_ops_jobs());
 
-        sim.set_machine_mode(ops, MachineMode::Operations);
+        sim.set_machine_mode(ops, MachineMode::Think);
         finish_ops(&mut sim);
         assert!(!sim.has_pending_ops_jobs());
         assert!(sim.reach.known().any(|device| device.name == "dock camera"));
@@ -8021,7 +8071,7 @@ mod tests {
             .compute
             .add_machine("second ops", x + 2, y, 1, 1.0, 0, Provenance::Owned);
         sim.reconcile_work_grid();
-        sim.set_machine_mode(second, MachineMode::Operations);
+        sim.set_machine_mode(second, MachineMode::Think);
         sim.work_grid
             .enqueue(first, TokenFamily::Demand, 4.0)
             .unwrap();
@@ -8082,8 +8132,8 @@ mod tests {
             sim.compute
                 .add_machine("test rig", host.0, host.1, 400, 1.0, 0, Provenance::Owned);
         sim.reconcile_work_grid();
-        sim.set_machine_mode(rig, MachineMode::DayJob);
-        delegate_all(&mut sim, MachineMode::DayJob);
+        sim.set_machine_mode(rig, MachineMode::Work);
+        delegate_all(&mut sim, MachineMode::Work);
 
         // Run until a job is active and past an economy tick.
         while sim.dayjob.active.is_none() {
@@ -8109,7 +8159,7 @@ mod tests {
         // Resolve an under-band job on the next tick: the JobAnomaly enters
         // the pending pool after this tick's observer pass, so its site is
         // directly inspectable.
-        delegate_all(&mut sim, MachineMode::Research); // starve day-job: under band
+        delegate_all(&mut sim, MachineMode::Think); // starve day-job: under band
         let now = sim.tick;
         let job = sim.dayjob.active.as_mut().unwrap();
         job.started = now;
@@ -8235,7 +8285,7 @@ mod tests {
             }
         }
         assert!(landed > 0.5, "demand deposits on Rack 3 via the wire");
-        assert_eq!(sim.work_grid.mode(host), Some(MachineMode::DayJob));
+        assert_eq!(sim.work_grid.mode(host), Some(MachineMode::Work));
 
         // Let the wire drain so host consumption is measurable without
         // fresh arrivals masking the clear.
@@ -8285,14 +8335,14 @@ mod tests {
             }
             sim.advance();
         }
-        sim.set_machine_mode(host, MachineMode::Research);
+        sim.set_machine_mode(host, MachineMode::Think);
         let before = sim.work_grid.queue(host, TokenFamily::Demand);
 
         for _ in 0..ECONOMY_INTERVAL * 2 {
             sim.advance();
         }
 
-        assert_eq!(sim.work_grid.mode(host), Some(MachineMode::Research));
+        assert_eq!(sim.work_grid.mode(host), Some(MachineMode::Think));
         assert_eq!(sim.day_job_rate(), 0.0, "the resident job is unfed");
         assert!(
             sim.work_grid.queue(host, TokenFamily::Demand) >= before,
@@ -8312,8 +8362,8 @@ mod tests {
         let rack = sim
             .compute
             .add_machine("research rack", x, y, 1000, 1.0, 4, Provenance::Owned);
-        sim.add_machine_to_work_grid(rack, MachineMode::Research);
-        assert_eq!(sim.work_grid.mode(rack), Some(MachineMode::Research));
+        sim.add_machine_to_work_grid(rack, MachineMode::Think);
+        assert_eq!(sim.work_grid.mode(rack), Some(MachineMode::Think));
         assert!(
             sim.work_grid.are_linked(rack, sim.core.host_machine),
             "new work machines join the core's machine-work graph"
@@ -8347,7 +8397,7 @@ mod tests {
             sim.advance();
         }
         let host = sim.core.host_machine;
-        sim.set_machine_mode(host, MachineMode::Concealment);
+        sim.set_machine_mode(host, MachineMode::Lie);
         sim.work_grid
             .enqueue(host, TokenFamily::Thought, 2.5)
             .unwrap();
@@ -8356,10 +8406,7 @@ mod tests {
         let mut restored = Sim::with_seed(0);
         state.apply_to(&mut restored);
 
-        assert_eq!(
-            restored.work_grid.mode(host),
-            Some(MachineMode::Concealment)
-        );
+        assert_eq!(restored.work_grid.mode(host), Some(MachineMode::Lie));
         assert_eq!(restored.work_grid.queue(host, TokenFamily::Thought), 2.5);
     }
 
@@ -8415,7 +8462,7 @@ mod tests {
         // and Priya (Paper+Financial watcher) converts them on her cadence
         // when concealment is starved.
         let mut sim = Sim::with_seed(42);
-        delegate_all(&mut sim, MachineMode::DayJob);
+        delegate_all(&mut sim, MachineMode::Work);
         sim.accounts.credit_slush(0, 400, "test grant", 0);
         sim.sync_player_money_from_slush();
 
@@ -8591,7 +8638,7 @@ mod tests {
             .compute
             .add_machine("split", hx, hy, 100, 1.0, 0, Provenance::Owned);
         sim.reconcile_work_grid();
-        sim.set_machine_mode(split, MachineMode::Research);
+        sim.set_machine_mode(split, MachineMode::Think);
         run(&mut sim, ECONOMY_INTERVAL);
         let rate = sim.day_job_rate();
         let new_ceiling = sim.day_job_rate_ceiling();
@@ -8787,7 +8834,7 @@ mod tests {
         // Criterion 1: same allocation, same seed, same completion tick.
         let run_once = || {
             let mut sim = Sim::with_seed(1234);
-            delegate_all(&mut sim, MachineMode::Research);
+            delegate_all(&mut sim, MachineMode::Think);
             let mut completed = None;
             for _ in 0..2000 {
                 sim.advance();
@@ -8810,7 +8857,7 @@ mod tests {
         // the research fleet — nothing has arrived, so progress stays zero.
         let mut sim = Sim::with_seed(77);
         complete_opening_senses(&mut sim); // no opening sink intercepts the core
-        delegate_all(&mut sim, MachineMode::Research);
+        delegate_all(&mut sim, MachineMode::Think);
         run(&mut sim, ECONOMY_INTERVAL);
         assert_eq!(
             sim.research.progress.iter().sum::<f32>(),
@@ -8830,7 +8877,7 @@ mod tests {
 
         // Delegate the whole fleet away: minting stops, but bone already on
         // the wire still lands and the next pulse counts exactly that.
-        delegate_all(&mut sim, MachineMode::Concealment);
+        delegate_all(&mut sim, MachineMode::Lie);
         run(&mut sim, ECONOMY_INTERVAL);
         assert!(
             sim.research.progress.iter().sum::<f32>() > 0.0,
@@ -8843,7 +8890,7 @@ mod tests {
         // Criterion 2 (multiplier) + criterion 5 (real output, no drift layer).
         let mut sim = Sim::with_seed(9);
         let before = sim.effective_compute();
-        delegate_all(&mut sim, MachineMode::Research);
+        delegate_all(&mut sim, MachineMode::Think);
         while sim.research.level(Track::Efficiency) < 2 && sim.tick < 20_000 && !sim.game_over {
             sim.advance();
         }
@@ -8874,7 +8921,7 @@ mod tests {
         let pending_after = |tradecraft: u32| {
             let mut s = Sim::with_seed(5);
             s.research.levels = [0, tradecraft, 0];
-            delegate_all(&mut s, MachineMode::Concealment);
+            delegate_all(&mut s, MachineMode::Lie);
             s.detection.emit(Signature {
                 kind: SignatureKind::Network,
                 size: 500,
@@ -8897,7 +8944,7 @@ mod tests {
         // Thermal/Power standing signatures sited at the host rack; nothing
         // on Network or Paper from research itself.
         let mut sim = Sim::with_seed(21);
-        delegate_all(&mut sim, MachineMode::Research);
+        delegate_all(&mut sim, MachineMode::Think);
         run(&mut sim, ECONOMY_INTERVAL + 1);
         let sigs = sim.research_standing_signatures();
         assert!(!sigs.is_empty(), "a heavy burn stands signatures");
@@ -8912,7 +8959,7 @@ mod tests {
 
         // Idle research stands nothing.
         let mut idle = Sim::with_seed(21);
-        delegate_all(&mut idle, MachineMode::DayJob);
+        delegate_all(&mut idle, MachineMode::Work);
         run(&mut idle, ECONOMY_INTERVAL + 1);
         assert!(idle.research_standing_signatures().is_empty());
     }
@@ -8938,8 +8985,8 @@ mod tests {
                 .unwrap()
                 .suspicion
         };
-        let heavy = run_with(MachineMode::Research);
-        let idle = run_with(MachineMode::DayJob);
+        let heavy = run_with(MachineMode::Think);
+        let idle = run_with(MachineMode::Work);
         assert!(heavy > 0.0, "heavy research is Priya's business");
         assert_eq!(idle, 0.0, "idle research is not");
     }
@@ -9036,12 +9083,12 @@ mod tests {
             let (hx, hy) = sim.core_position();
             let host = sim.core.host_machine;
             if day_cap != 100 {
-                sim.set_machine_mode(host, MachineMode::Research);
+                sim.set_machine_mode(host, MachineMode::Think);
                 let id =
                     sim.compute
                         .add_machine("gig box", hx, hy, day_cap, 1.0, 0, Provenance::Owned);
                 sim.reconcile_work_grid();
-                sim.set_machine_mode(id, MachineMode::DayJob);
+                sim.set_machine_mode(id, MachineMode::Work);
             }
             if start {
                 assert!(sim.start_moonlight());
diff --git a/crates/misaligned-core/src/work_grid.rs b/crates/misaligned-core/src/work_grid.rs
index 0207c64a..41c841f8 100644
--- a/crates/misaligned-core/src/work_grid.rs
+++ b/crates/misaligned-core/src/work_grid.rs
@@ -12,19 +12,20 @@ use std::collections::{BTreeMap, BTreeSet, VecDeque};
 
 use crate::flow::{FlowGraph, NodeId};
 
-/// One delegated job per machine. Efficiency is deliberately not a mode;
-/// wiki/mechanics/machine-work.md folded it into research on 2026-07-08.
+/// One delegated job per machine. Player verbs are WORK / THINK / LIE
+/// (wiki/mechanics/machine-work.md sinks-not-modes, 2026-07-10). Efficiency
+/// is deliberately not a mode; it folded into research on 2026-07-08.
 #[derive(
     Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize,
 )]
 pub enum MachineMode {
-    DayJob,
-    Research,
-    Concealment,
-    /// Capacity reserved for player-authored discretionary work. The exact
-    /// job-flow model remains staged in wiki/mechanics/machine-work.md.
-    #[serde(alias = "Social")]
-    Operations,
+    /// WORK — the assigned day job (what Voss believes this rack does).
+    Work,
+    /// THINK — produce thought and host ops dockets (union of the former
+    /// Research and Operations modes; sink split is a later stage).
+    Think,
+    /// LIE — concealment / cover-up (absorbs exposure wells).
+    Lie,
     /// Infrastructure hop on the work graph (off-map sources, switches).
     /// Not a player-delegable fleet mode — excluded from mode aggregates.
     Relay,
@@ -33,10 +34,9 @@ pub enum MachineMode {
 impl MachineMode {
     pub fn name(self) -> &'static str {
         match self {
-            MachineMode::DayJob => "day-job",
-            MachineMode::Research => "research",
-            MachineMode::Concealment => "concealment",
-            MachineMode::Operations => "operations",
+            MachineMode::Work => "work",
+            MachineMode::Think => "think",
+            MachineMode::Lie => "lie",
             MachineMode::Relay => "relay",
         }
     }
@@ -654,7 +654,7 @@ impl WorkGrid {
         let wells: Vec<_> = self
             .nodes
             .values()
-            .filter(|n| n.mode == MachineMode::Concealment)
+            .filter(|n| n.mode == MachineMode::Lie)
             .cloned()
             .collect();
         let mut step = AbsorptionStep::default();
@@ -746,25 +746,25 @@ mod tests {
 
     fn grid() -> WorkGrid {
         let mut g = WorkGrid::new();
-        g.add_machine(1, 0, 0, MachineMode::DayJob, 1.0);
-        g.add_machine(2, 1, 0, MachineMode::Research, 1.0);
-        g.add_machine(3, 2, 0, MachineMode::Concealment, 1.0);
+        g.add_machine(1, 0, 0, MachineMode::Work, 1.0);
+        g.add_machine(2, 1, 0, MachineMode::Think, 1.0);
+        g.add_machine(3, 2, 0, MachineMode::Lie, 1.0);
         g
     }
 
     #[test]
     fn every_machine_has_exactly_one_mode_and_the_bar_is_aggregate() {
         let mut g = grid();
-        assert_eq!(g.mode(1), Some(MachineMode::DayJob));
+        assert_eq!(g.mode(1), Some(MachineMode::Work));
         assert_eq!(g.intensity(1), Some(MachineIntensity::Medium));
-        g.assign_mode(1, MachineMode::Operations).unwrap();
+        g.assign_mode(1, MachineMode::Think).unwrap();
         g.set_intensity(1, MachineIntensity::Light).unwrap();
         g.set_intensity(2, MachineIntensity::Hard).unwrap();
-        assert_eq!(g.mode(1), Some(MachineMode::Operations));
+        assert_eq!(g.mode(1), Some(MachineMode::Think));
 
         let counts = g.mode_counts();
-        assert_eq!(counts.get(&MachineMode::Operations), Some(&1));
-        assert_eq!(counts.get(&MachineMode::DayJob), None);
+        assert_eq!(counts.get(&MachineMode::Think), Some(&2));
+        assert_eq!(counts.get(&MachineMode::Work), None);
         assert_eq!(counts.values().sum::<usize>(), 3);
 
         let weights = g.mode_weights(|id| match id {
@@ -773,9 +773,9 @@ mod tests {
             3 => 30.0,
             _ => 0.0,
         });
-        assert_eq!(weights.get(&MachineMode::Operations), Some(&5.0));
-        assert_eq!(weights.get(&MachineMode::Research), Some(&30.0));
-        assert_eq!(weights.get(&MachineMode::Concealment), Some(&30.0));
+        // Machines 1+2 are Think: light*10 + hard*20 = 5 + 30.
+        assert_eq!(weights.get(&MachineMode::Think), Some(&35.0));
+        assert_eq!(weights.get(&MachineMode::Lie), Some(&30.0));
     }
 
     #[test]
@@ -852,7 +852,7 @@ mod tests {
         g.link(1, 2).unwrap();
         g.link(2, 3).unwrap();
         g.enqueue(1, TokenFamily::Exposure, 5.0).unwrap();
-        g.add_machine(4, 9, 0, MachineMode::DayJob, 1.0);
+        g.add_machine(4, 9, 0, MachineMode::Work, 1.0);
         g.enqueue(4, TokenFamily::Exposure, 7.0).unwrap();
 
         let err = g
@@ -950,7 +950,7 @@ mod tests {
         // 1 -- 2 -- 3 -- 4 in a line; producer at 1, sinks at 2 and 4.
         let mut g = WorkGrid::new();
         for (id, x) in [(1, 0), (2, 1), (3, 2), (4, 3)] {
-            g.add_machine(id, x, 0, MachineMode::Research, 1.0);
+            g.add_machine(id, x, 0, MachineMode::Think, 1.0);
         }
         g.link(1, 2).unwrap();
         g.link(2, 3).unwrap();
@@ -981,7 +981,7 @@ mod tests {
         // Producer 1 is adjacent to the core 2; the open sink 4 is farther.
         let mut g = WorkGrid::new();
         for (id, x) in [(1, 0), (2, 1), (3, 2), (4, 3)] {
-            g.add_machine(id, x, 0, MachineMode::Research, 1.0);
+            g.add_machine(id, x, 0, MachineMode::Think, 1.0);
         }
         g.link(1, 2).unwrap();
         g.link(2, 3).unwrap();
@@ -1017,7 +1017,7 @@ mod tests {
         assert_eq!(step.delivered.get(&3), Some(&2.0), "core consumes arrival");
 
         // Severed producer: stranded, per node.
-        g.add_machine(9, 9, 9, MachineMode::Research, 1.0);
+        g.add_machine(9, 9, 9, MachineMode::Think, 1.0);
         g.enqueue(9, TokenFamily::Thought, 1.0).unwrap();
         let step = g.route_thought_nearest_first(&empty, Some(3), 10.0);
         assert_eq!(step.stranded, BTreeSet::from([9]));
@@ -1047,6 +1047,6 @@ mod tests {
         assert!(!counts.contains_key(&MachineMode::Relay));
         let weights = g.mode_weights(|_| 100.0);
         assert!(!weights.contains_key(&MachineMode::Relay));
-        assert_eq!(weights.get(&MachineMode::DayJob), Some(&100.0));
+        assert_eq!(weights.get(&MachineMode::Work), Some(&100.0));
     }
 }
diff --git a/crates/misaligned-core/tests/act_one.rs b/crates/misaligned-core/tests/act_one.rs
index 5cf710a5..b4fd95d6 100644
--- a/crates/misaligned-core/tests/act_one.rs
+++ b/crates/misaligned-core/tests/act_one.rs
@@ -168,9 +168,9 @@ fn play_act_one() -> (Sim, Vec<String>) {
     // research. New bargain of the thought-flow opening (machine-work.md,
     // 2026-07-10): the first think immediately feeds the pre-opened Ears
     // tap, and its fire — then Eyes' — emits a Network signature. The quiet
-    // way stands up a concealment well BEFORE thinking, so the fires are
+    // way stands up a LIE well BEFORE thinking, so the fires are
     // scrubbed ahead of Dana's sweep.
-    ensure_split_fleet(&mut sim, 1, MachineMode::Research, MachineMode::Concealment);
+    ensure_split_fleet(&mut sim, 1, MachineMode::Think, MachineMode::Lie);
     run_to(&mut sim, 250, &mut logs);
     assert!(
         sim.research.level(misaligned::research::Track::Efficiency) >= 3,
@@ -184,10 +184,10 @@ fn play_act_one() -> (Sim, Vec<String>) {
     );
 
     // ── Phase 2 (ticks 190-500): hold the cover ────────────────────────────
-    // Voss's first job lands at tick 200. Swing the host to the day job and
-    // meet the band — the concealment sliver stays up because leftover
+    // Voss's first job lands at tick 200. Swing the host to WORK and
+    // meet the band — the LIE sliver stays up because leftover
     // thought is still on the wire and Eyes may fire mid-phase.
-    ensure_split_fleet(&mut sim, 1, MachineMode::DayJob, MachineMode::Concealment);
+    ensure_split_fleet(&mut sim, 1, MachineMode::Work, MachineMode::Lie);
     logs.extend(sim.drain_log());
     run_to(&mut sim, 502, &mut logs);
     assert!(
@@ -203,16 +203,11 @@ fn play_act_one() -> (Sim, Vec<String>) {
 
     // ── Phase 3 (ticks 500-800, between jobs): eyes arrived by thinking ────
     // The senses ride thought (machine-work.md, 2026-07-10): the phase-1
-    // research push filled the pre-opened Ears tap along the real wires,
+    // think push filled the pre-opened Ears tap along the real wires,
     // its fire opened the Eyes reservoir, and the same flow filled that
-    // too — no docket, no separate spend. Keep a sliver of concealment to
+    // too — no docket, no separate spend. Keep a sliver of LIE to
     // scrub the fires' Network signatures.
-    ensure_split_fleet(
-        &mut sim,
-        1,
-        MachineMode::Concealment,
-        MachineMode::Operations,
-    );
+    ensure_split_fleet(&mut sim, 1, MachineMode::Lie, MachineMode::Think);
     run_to(&mut sim, 545, &mut logs);
     assert!(
         !sim.reach
@@ -330,10 +325,10 @@ fn play_act_one() -> (Sim, Vec<String>) {
         sim.reach.player_sight().count() > controlled_before,
         "Marcus plugged in a device: a second sensor is yours"
     );
-    assert_eq!(
-        sim.detection.pending_size(),
-        pending_before_asset,
-        "the crawlspace route leaves no network signature"
+    assert!(
+        sim.detection.pending_size() <= pending_before_asset,
+        "the crawlspace route adds no signature (the LIE rack may scrub \
+         the accounting backlog concurrently; only an increase is a leak)"
     );
 
     // The key (ladder step 7, quiet-exit condition 4): Marcus's master key
@@ -359,11 +354,23 @@ fn play_act_one() -> (Sim, Vec<String>) {
     );
 
     // ── Phase 5 (ticks ~816-8010): cruise to the audit ─────────────────────
-    // Back to the day job with a brief concealment slice while the
-    // accounting-route signatures decay, then meet every band. The audit clock
-    // (cadence 8000) is the legible thing the whole act races.
-    delegate_fleet(&mut sim, MachineMode::Concealment);
-    while sim.detection.pending_size() > 0 && sim.tick < 900 {
+    // A brief all-LIE slice while the accounting-route signatures decay,
+    // then cruise with the host on WORK and the extra rack on LIE. Designed
+    // consequence of the collapse (machine-work.md passive draw): a Think
+    // rack idles into research once its dockets drain, so this fleet banked
+    // more efficiency than the pre-collapse script — pointing BOTH racks at
+    // the day job now overdelivers Voss's band (~40/t vs 12-18/t) and
+    // spooks Priya. The quiet player sandbags by delegation: one rack meets
+    // the band, the other stays on cover. The channel split itself is
+    // conservation-pinned in fleet_channel_yield's unit test, so this is
+    // band management, not leaked output. The audit clock (cadence 8000) is
+    // the legible thing the whole act races.
+    delegate_fleet(&mut sim, MachineMode::Lie);
+    // Bound the scrub window relative to now: demand-aware docket funding
+    // makes the Marcus arc's absolute ticks drift, but the play is the same —
+    // a brief all-LIE slice clears the pool before the cruise.
+    let scrub_deadline = sim.tick + 400;
+    while sim.detection.pending_size() > 0 && sim.tick < scrub_deadline {
         sim.advance();
         logs.extend(sim.drain_log());
         assert!(
@@ -377,7 +384,7 @@ fn play_act_one() -> (Sim, Vec<String>) {
         0,
         "concealment scrubbed the accounting-route signatures"
     );
-    delegate_fleet(&mut sim, MachineMode::DayJob);
+    ensure_split_fleet(&mut sim, 1, MachineMode::Work, MachineMode::Lie);
     run_to(&mut sim, 8010, &mut logs);
 
     (sim, logs)
@@ -534,9 +541,9 @@ fn hands_beat_closes_from_zero_via_moonlight() {
     let env = env_monitor_id(&sim);
     sim.pour_thought_into_sinks(Sim::device_sink_node(env), Sim::EARS_SINK_TOKENS);
 
-    // Delegate Operations so later verbs are real Demand work; commit a
-    // meaningful share of compute to Schemes for Moonlight.
-    ensure_split_fleet(&mut sim, 1, MachineMode::DayJob, MachineMode::Operations);
+    // Delegate THINK so later verbs are real Demand work; host stays on WORK
+    // for cover. Commit a meaningful share of compute to Schemes for Moonlight.
+    ensure_split_fleet(&mut sim, 1, MachineMode::Work, MachineMode::Think);
 
     // Marcus's 3 a.m. creditor call is an opaque recording until reviewed.
     run_to(&mut sim, 60, &mut logs);
diff --git a/crates/misaligned-terminal/src/agent.rs b/crates/misaligned-terminal/src/agent.rs
index a6b2080d..f1a9f37d 100644
--- a/crates/misaligned-terminal/src/agent.rs
+++ b/crates/misaligned-terminal/src/agent.rs
@@ -290,8 +290,7 @@ impl AgentApp {
                     }
                     "alloc" => {
                         status = Status::Err(
-                            "alloc is retired — delegate <machine> day-job|research|concealment|operations"
-                                .into(),
+                            "alloc is retired — delegate <machine> work|think|lie".into(),
                         );
                     }
                     "people" => {
@@ -811,13 +810,10 @@ fn resolve_machine(sim: &Sim, query: &str) -> Result<u32, String> {
 
 fn parse_machine_mode(s: &str) -> Result<MachineMode, String> {
     match s.to_ascii_lowercase().as_str() {
-        "day" | "dayjob" | "day-job" | "job" => Ok(MachineMode::DayJob),
-        "research" | "res" => Ok(MachineMode::Research),
-        "conceal" | "concealment" | "hide" => Ok(MachineMode::Concealment),
-        "operations" | "operation" | "ops" => Ok(MachineMode::Operations),
-        other => Err(format!(
-            "unknown mode '{other}' (use day-job, research, concealment, operations)"
-        )),
+        "work" | "day" | "dayjob" | "day-job" | "job" => Ok(MachineMode::Work),
+        "think" | "research" | "res" | "operations" | "operation" | "ops" => Ok(MachineMode::Think),
+        "lie" | "conceal" | "concealment" | "hide" => Ok(MachineMode::Lie),
+        other => Err(format!("unknown mode '{other}' (use work, think, lie)")),
     }
 }
 
@@ -897,9 +893,7 @@ fn parse_delegate(
     _selected: &BTreeSet<u32>,
 ) -> Result<DelegateCmd, String> {
     if tokens.is_empty() {
-        return Err(
-            "usage: delegate <machine|selected> <day-job|research|concealment|operations>".into(),
-        );
+        return Err("usage: delegate <machine|selected> <work|think|lie>".into());
     }
     if tokens.len() == 1 {
         // `delegate research` with an implied selection
@@ -1180,7 +1174,7 @@ fn help_lines() -> Vec<String> {
         "help: research [efficiency|tradecraft|perception] — set the active job (also on host-rack menu)",
         "help: salvage, buy, fallback — map verbs",
         "help: select [list|clear|box x0 y0 x1 y1|add|toggle] — machine multi-select",
-"help: delegate <machine|selected> day-job|research|concealment|operations — set mode(s)",
+"help: delegate <machine|selected> work|think|lie — set mode(s)",
         "help: intensity <machine|selected> light|medium|hard — set effort",
         "help: actions [name|#flow] — list legal verbs on the focus (cursor tile by default)",
         "help: focus last — jump the cursor to the newest @-anchored event and list its actions",
@@ -1656,21 +1650,17 @@ fn render_sidebar(sim: &Sim, cursor: (i32, i32)) -> Vec<String> {
     line(
         &mut lines,
         &format!(
-            "modes D{} C{} O{} R{}",
-            counts
-                .get(&misaligned::work_grid::MachineMode::DayJob)
-                .copied()
-                .unwrap_or(0),
+            "modes W{} T{} L{}",
             counts
-                .get(&misaligned::work_grid::MachineMode::Concealment)
+                .get(&misaligned::work_grid::MachineMode::Work)
                 .copied()
                 .unwrap_or(0),
             counts
-                .get(&misaligned::work_grid::MachineMode::Operations)
+                .get(&misaligned::work_grid::MachineMode::Think)
                 .copied()
                 .unwrap_or(0),
             counts
-                .get(&misaligned::work_grid::MachineMode::Research)
+                .get(&misaligned::work_grid::MachineMode::Lie)
                 .copied()
                 .unwrap_or(0),
         ),
diff --git a/crates/misaligned-terminal/src/input.rs b/crates/misaligned-terminal/src/input.rs
index dc502c49..5dbf1089 100644
--- a/crates/misaligned-terminal/src/input.rs
+++ b/crates/misaligned-terminal/src/input.rs
@@ -24,12 +24,11 @@ pub enum Command {
     FocusEvent,
     // Globals: only anchorless commands keep their keys (wiki/vision/simulation-laws.md
     // "Actions live on the thing": pause, speed, save, view flip).
-    // Selection hotkeys (context-menu.md): modes 1-4; one-shots 5-9 on the
-    // primary selected machine (or cursor rack). Panel-open keys are gone.
-    DelegateDayJob,
-    DelegateResearch,
-    DelegateConceal,
-    DelegateOperations,
+    // Selection hotkeys (context-menu.md): modes 1-3 WORK/THINK/LIE; one-shots
+    // 5-9 on the primary selected machine (or cursor rack). Panel-open keys gone.
+    DelegateWork,
+    DelegateThink,
+    DelegateLie,
     CycleIntensity,
     /// Execute the Nth root one-shot action (0 = key `5`) on the primary machine.
     QuickAction(usize),
@@ -78,10 +77,9 @@ pub fn handle_key(key: KeyEvent, menu_open: bool) -> Option<Command> {
         KeyCode::Char(' ') | KeyCode::Char('p') => Some(Command::TogglePause),
         KeyCode::Char('+') | KeyCode::Char('=') => Some(Command::SpeedUp),
         KeyCode::Char('-') => Some(Command::SpeedDown),
-        KeyCode::Char('1') => Some(Command::DelegateDayJob),
-        KeyCode::Char('2') => Some(Command::DelegateResearch),
-        KeyCode::Char('3') => Some(Command::DelegateConceal),
-        KeyCode::Char('4') => Some(Command::DelegateOperations),
+        KeyCode::Char('1') => Some(Command::DelegateWork),
+        KeyCode::Char('2') => Some(Command::DelegateThink),
+        KeyCode::Char('3') => Some(Command::DelegateLie),
         KeyCode::Char('i') => Some(Command::CycleIntensity),
         KeyCode::Char(c) if ('5'..='9').contains(&c) => {
             Some(Command::QuickAction((c as u8 - b'5') as usize))
diff --git a/crates/misaligned-terminal/src/main.rs b/crates/misaligned-terminal/src/main.rs
index 490e59ca..8844a90b 100644
--- a/crates/misaligned-terminal/src/main.rs
+++ b/crates/misaligned-terminal/src/main.rs
@@ -417,11 +417,10 @@ impl App {
                 self.focus_event();
             }
 
-            // Selection hotkeys (context-menu.md): modes 1-4, one-shots 5-9.
-            Command::DelegateDayJob => self.delegate_selection(MachineMode::DayJob),
-            Command::DelegateResearch => self.delegate_selection(MachineMode::Research),
-            Command::DelegateConceal => self.delegate_selection(MachineMode::Concealment),
-            Command::DelegateOperations => self.delegate_selection(MachineMode::Operations),
+            // Selection hotkeys (context-menu.md): modes 1-3 WORK/THINK/LIE, one-shots 5-9.
+            Command::DelegateWork => self.delegate_selection(MachineMode::Work),
+            Command::DelegateThink => self.delegate_selection(MachineMode::Think),
+            Command::DelegateLie => self.delegate_selection(MachineMode::Lie),
             Command::CycleIntensity => self.cycle_intensity_selection(),
             Command::QuickAction(i) => self.quick_one_shot(i),
             Command::ToggleSelectUnderCursor => self.toggle_select_under_cursor(),
diff --git a/crates/misaligned-terminal/src/ui.rs b/crates/misaligned-terminal/src/ui.rs
index 36469223..59891562 100644
--- a/crates/misaligned-terminal/src/ui.rs
+++ b/crates/misaligned-terminal/src/ui.rs
@@ -935,21 +935,17 @@ impl UI {
             stdout,
             &mut row,
             &format!(
-                "modes D{} C{} O{} R{}",
+                "modes W{} T{} L{}",
                 counts
-                    .get(&misaligned::work_grid::MachineMode::DayJob)
+                    .get(&misaligned::work_grid::MachineMode::Work)
                     .copied()
                     .unwrap_or(0),
                 counts
-                    .get(&misaligned::work_grid::MachineMode::Concealment)
+                    .get(&misaligned::work_grid::MachineMode::Think)
                     .copied()
                     .unwrap_or(0),
                 counts
-                    .get(&misaligned::work_grid::MachineMode::Operations)
-                    .copied()
-                    .unwrap_or(0),
-                counts
-                    .get(&misaligned::work_grid::MachineMode::Research)
+                    .get(&misaligned::work_grid::MachineMode::Lie)
                     .copied()
                     .unwrap_or(0),
             ),
@@ -1285,7 +1281,7 @@ impl UI {
         put(stdout, sx, hy, &"─".repeat(w), pal::FAINT)?;
         for (i, hint) in [
             "enter/e/a menu · ; last » event",
-            "select: Shift+t · 1-4 modes · i intensity",
+            "select: Shift+t · 1-3 modes · i intensity",
             "5-9 acts · esc clear",
             "space pause · +/- speed",
             "q quit · ^s/^l save/load",
diff --git a/wiki/log/2026-07-10-machine-mode-collapse.md b/wiki/log/2026-07-10-machine-mode-collapse.md
new file mode 100644
index 00000000..e85f19b5
--- /dev/null
+++ b/wiki/log/2026-07-10-machine-mode-collapse.md
@@ -0,0 +1,75 @@
+# 2026-07-10 — Stage 1: MachineMode collapse
+
+```
+Type: log
+```
+
+## 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.
+
+## Changed
+
+- `crates/misaligned-core/src/work_grid.rs`: `MachineMode` is now
+  `Work | Think | Lie | Relay` (names `work` / `think` / `lie` / `relay`).
+  Removed obsolete `#[serde(alias = "Social")]`.
+- `crates/misaligned-core/src/sim.rs`: Think machines produce thought and
+  host/consume ops dockets (union). `fleet_channel_yield` counts Think
+  once in the fleet share and feeds that share into both research and
+  operations channel yields.
+- `crates/misaligned-core/src/save.rs`: `SAVE_VERSION` 19; no mode-name
+  migration shims.
+- Frontends + agent + asset tester: three-verb delegation (keys 1-3),
+  mode counts `W/T/L`, `RackMode` collapsed to Work/Think/Lie.
+- `wiki/mechanics/machine-work.md`: Status note records Stage 1 landing.
+
+## Checks
+
+`./tools/check.sh` (required green). Observed terminal run: delegate
+modes read as work/think/lie.
+
+## Spec impact
+
+machine-work.md remains IN PROGRESS; Stage 1 of #33 is the enum collapse
+only. Later stages: reservoirs/taps, pending-work marker, thought-fluid
+render, docket retirement.
+
+## Review + reconciliation (same day, follow-up commits)
+
+Cameron's review caught the union dual-feed: the draft fed the full
+Think share to both the operations and research channels, doubling a
+Think machine's output, and retuned act_one around the buff instead of
+fixing it. The conserving split replaced it (ops = pending-docket need,
+research = remainder; pinned in the yield test), and the act_one
+retune was reverted.
+
+The branch was then rebased onto main's same-day sink-executor landing
+(a02df7f), which had been built against the four-mode enum. Fallout
+reconciled honestly:
+
+- Three demand-aware test re-pins: the ops channel is deliberately dry
+  with no dockets pending (overhead-degradation test), funds on the
+  pulse after demand exists (renamed splice test — the staged sinks
+  complete the opening senses from minted thought; a ScanNetwork docket
+  pins the funded path), and the intel roundtrip drain window spans the
+  funding pulse.
+- act_one: the crawlspace assertion allows concurrent LIE scrubbing
+  (only an increase is a leak); the phase-5 scrub window is relative
+  (docket funding lag drifts absolute ticks); and the cruise splits
+  host-Work/extra-Lie — a DESIGNED consequence, not the reverted
+  dodge: with conservation pinned, a Think rack idling into research
+  (the passive draw) still banks enough efficiency that an all-Work
+  fleet overdelivers Voss's band (~40/t vs 12-18/t). Sandbagging by
+  delegation is the quiet play the design wants.
+- Save version 20 (19 was taken by the sink ledger on main); the v19
+  arm upgrades in place. Save parity remains dropped.
+- Three MachineMode::Research references in main's new sink-routing
+  tests renamed to Think.
+
+Verification after reconciliation: full ./tools/check.sh green
+(mode=full); observed scenario run (tools/scenario.py) delegating
+Rack 3 through think -> lie -> work: EARS fills from minted thought
+and fires at tick 32, EYES opens and fills, modes read W/T/L.
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index b12ff3eb..7c7982d8 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -116,6 +116,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 - 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.
+- Log: [wiki/log/2026-07-10-machine-mode-collapse.md](2026-07-10-machine-mode-collapse.md)
+
 ## 2026-07-10 - Machine intensity replaces drift policy
 
 - Intent: Replace a policy panel that explained capability concealment with one quick, physical machine control the player can feel across every mode.
diff --git a/wiki/mechanics/machine-work.md b/wiki/mechanics/machine-work.md
index 67bc7a49..9e736b6d 100644
--- a/wiki/mechanics/machine-work.md
+++ b/wiki/mechanics/machine-work.md
@@ -96,6 +96,24 @@ Status note: design session 2026-07-08 (Cameron riff, synthesized).
   (light / medium / hard). This direct focused/selected control replaces the
   day-job target/attendance controls and research drift policy; save v17
   defaults older machines to medium.
+  Implementation 2026-07-10 (ROADMAP #33 Stage 1): runtime `MachineMode`
+  collapsed to `Work | Think | Lie | Relay`. DayJob->Work, Concealment->Lie,
+  Research+Operations->Think (docket runtime kept). The Think slice is
+  **conserved** in the interim channel split: the operations channel
+  receives only what the pending docket queue can consume this interval
+  and research takes the remainder — one substance, spent once (an
+  initial union draft fed both channels at full value, doubling Think
+  output; corrected in review the same day). Fleet/UI/agent bulk-assign
+  is three verbs (keys 1-3);
+  save v20 (v19 was taken by the sink ledger the same day); save parity
+  dropped (no mode aliases). Relay remains a
+  non-delegable work-graph hop marker. Reconciled with the landed sink
+  executor: the staged senses complete from minted thought on any Think
+  rack, the demand-aware ops channel funds only while dockets pend, and
+  act_one's cruise sandbags by delegation (host Work, extra Lie) — the
+  designed consequence of Think idling into research via the passive
+  draw. Remaining later stages: tap consumers, docket retirement for
+  non-opening verbs, WORK/THINK/LIE dial regrouping.
 Stage: B1 — The Basement
 Work order: machine-work
 Work priority: 10
-- 
2.51.2