From 516428da7bd124ca331d078babae271bfb3c6844 Mon Sep 17 00:00:00 2001
From: Cameron <cameron@pfiffer.org>
Date: Tue, 7 Jul 2026 21:56:45 -0700
Subject: [PATCH] Research: self-modification to IMPLEMENTED (ROADMAP #20).
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implements wiki/mechanics/research.md end to end: tracks as the data
table in src/research.rs (Efficiency, Tradecraft, Perception — each row
binds to a numeric hook another spec owns), deterministic progress in
accrued Research-channel compute (no research method takes an Rng),
the emission law (research burn stands Thermal/Power at the host rack;
nothing on Network/Paper), capability drift (baseline vs Voss's
calibrated benchmark; spend reads as excel, masking is a superlinear
compute tax off the top, an unmasked gap leaks JobAnomaly sized by the
gap from the host rack), and MindState/WorldLedger rollback tags that
serialize with save v7 (pre-v7 saves reconstruct their efficiency level
from the multiplier). Surfaced in the terminal (u panel + sidebar
RESEARCH block), agent mode (research [track], mask band|true|off;
frame 70x60), and Bevy (SELF-MODEL card + u panel). Compute slims to
the applied efficiency multiplier. [TUNE] values recorded in
wiki/mechanics/sim-mechanics.md; spec Status set IMPLEMENTED with the
specs.md row, ROADMAP #20 DONE, agent-play.md vocabulary, and
wiki/log/2026-07-07-research-implemented.md + DEVLOG ledger entry.

Defense: DESIGN.md 'Research: self-modification' — research is
rewriting yourself, the optimize route made a real system: the emission
law ('you passively emit the way everything else emits' — Priya notices
the burn through the channels she already watches, Voss notices drift
because he samples that channel), capability drift with the three
postures ('spend it / mask it / leak it') and the superlinear masking
curve ('the smarter you get, the faster you have to play'), and the
rollback split (weights are MindState; the world's benchmark of you is
WorldLedger). Tracks are data per 'Self-similar scale'; the gap meter
and masking cost are first-class legible numbers per 'Justification and
legibility'; both frontends and agent mode surface the system before
the spec is IMPLEMENTED per AGENT.md.
---
 src/bin/bevy.rs                             | 198 +++++++-
 src/bin/terminal/agent.rs                   | 142 +++++-
 src/bin/terminal/input.rs                   |  23 +
 src/bin/terminal/mod.rs                     |  29 ++
 src/bin/terminal/ui.rs                      | 195 +++++++-
 src/dayjob.rs                               |  13 +-
 src/lib.rs                                  |   1 +
 src/machine.rs                              |  50 +-
 src/research.rs                             | 513 ++++++++++++++++++++
 src/save.rs                                 |  36 +-
 src/sim.rs                                  | 494 ++++++++++++++++++-
 tests/act_one.rs                            |   6 +-
 tools/check.sh                              |   4 +-
 wiki/interface/agent-play.md                |   9 +-
 wiki/log/2026-07-07-research-implemented.md |  97 ++++
 wiki/log/DEVLOG.md                          |  21 +
 wiki/mechanics/research.md                  |  18 +-
 wiki/mechanics/sim-mechanics.md             |  50 +-
 wiki/process/ROADMAP.md                     |   5 +-
 wiki/process/specs.md                       |   2 +-
 20 files changed, 1832 insertions(+), 74 deletions(-)
 create mode 100644 src/research.rs
 create mode 100644 wiki/log/2026-07-07-research-implemented.md

diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs
index 1448697..e24731c 100644
--- a/src/bin/bevy.rs
+++ b/src/bin/bevy.rs
@@ -380,6 +380,9 @@ struct Game {
     /// Finance (account graph) panel state (wiki/mechanics/economy.md).
     finance_panel: bool,
     finance_selected: usize,
+    /// Research (self-modification) panel state (wiki/mechanics/research.md).
+    research_panel: bool,
+    research_selected: usize,
     /// Frontend-only attention cursor (wiki/mechanics/cursor.md). It is not
     /// saved and moving it never mutates sim state.
     cursor_x: i32,
@@ -404,6 +407,8 @@ impl Game {
             reach_selected: 0,
             finance_panel: false,
             finance_selected: 0,
+            research_panel: false,
+            research_selected: 0,
             cursor_x,
             cursor_y,
         }
@@ -506,6 +511,7 @@ enum SidebarText {
     CycleRows,
     Core,
     Cover,
+    Research,
     NetworkMoney,
     Log,
     Footer,
@@ -543,6 +549,10 @@ struct ReachPanelText;
 struct FinancePanel;
 #[derive(Component)]
 struct FinancePanelText;
+#[derive(Component)]
+struct ResearchPanel;
+#[derive(Component)]
+struct ResearchPanelText;
 
 type SidebarTextQuery<'w, 's> =
     Query<'w, 's, (&'static SidebarText, &'static mut Text), Without<DetectionText>>;
@@ -625,6 +635,7 @@ fn main() {
             render_people_panel,
             render_reach_panel,
             render_finance_panel,
+            render_research_panel,
             shot_harness_system,
         )
             .chain(),
@@ -1622,6 +1633,11 @@ fn handle_input(
         game.drain();
         return;
     }
+    if game.research_panel {
+        research_panel_input(&kb, &mut game, &mut exit);
+        game.drain();
+        return;
+    }
 
     if mouse.just_pressed(MouseButton::Left) {
         let grid = if mode.material {
@@ -1678,6 +1694,10 @@ fn handle_input(
         game.reach_panel = true;
         game.reach_selected = 0;
     }
+    if kb.just_pressed(KeyCode::KeyU) {
+        game.research_panel = true;
+        game.research_selected = 0;
+    }
     if kb.just_pressed(KeyCode::KeyE) {
         game.finance_panel = true;
         game.finance_selected = 0;
@@ -1922,6 +1942,41 @@ fn finance_panel_input(
     }
 }
 
+/// Research-panel input: mirrors the terminal's panel key map
+/// (src/bin/terminal/input.rs) — track selection, activation, drift policy.
+fn research_panel_input(
+    kb: &ButtonInput<KeyCode>,
+    game: &mut Game,
+    exit: &mut MessageWriter<AppExit>,
+) {
+    use misaligned::research::Track;
+    if kb.just_pressed(KeyCode::ArrowUp)
+        || kb.just_pressed(KeyCode::KeyK)
+        || kb.just_pressed(KeyCode::KeyW)
+    {
+        game.research_selected = game.research_selected.saturating_sub(1);
+    }
+    if kb.just_pressed(KeyCode::ArrowDown)
+        || kb.just_pressed(KeyCode::KeyJ)
+        || kb.just_pressed(KeyCode::KeyS)
+    {
+        game.research_selected = (game.research_selected + 1).min(Track::ALL.len() - 1);
+    }
+    if kb.just_pressed(KeyCode::KeyA) || kb.just_pressed(KeyCode::Enter) {
+        let track = Track::ALL[game.research_selected];
+        game.sim.set_research_track(track);
+    }
+    if kb.just_pressed(KeyCode::KeyM) {
+        game.sim.cycle_masking_policy();
+    }
+    if kb.just_pressed(KeyCode::Escape) || kb.just_pressed(KeyCode::KeyU) {
+        game.research_panel = false;
+    }
+    if kb.just_pressed(KeyCode::KeyQ) {
+        exit.write(AppExit::Success);
+    }
+}
+
 fn update_camera(
     time: Res<Time>,
     kb: Res<ButtonInput<KeyCode>>,
@@ -2421,6 +2476,7 @@ fn setup_ui(mut commands: Commands) {
                 spawn_sidebar_card(scroll, "FOCUS", SidebarText::Focus);
                 spawn_compute_card(scroll);
                 spawn_sidebar_card(scroll, "COVER PROCESS", SidebarText::Cover);
+                spawn_sidebar_card(scroll, "SELF-MODEL", SidebarText::Research);
                 spawn_detection_card(scroll);
                 spawn_sidebar_card(scroll, "SELF HOST", SidebarText::Core);
                 spawn_sidebar_card(scroll, "NETWORK + MONEY", SidebarText::NetworkMoney);
@@ -2620,6 +2676,60 @@ fn setup_ui(mut commands: Commands) {
                 ));
             });
         });
+
+    // The research panel: self-modification tracks and the gap meter, hidden
+    // until `u` opens it (wiki/mechanics/research.md).
+    commands
+        .spawn((
+            Node {
+                position_type: PositionType::Absolute,
+                left: Val::Px(0.0),
+                top: Val::Px(0.0),
+                width: Val::Percent(100.0),
+                height: Val::Percent(100.0),
+                justify_content: JustifyContent::Center,
+                align_items: AlignItems::Center,
+                ..default()
+            },
+            Visibility::Hidden,
+            ResearchPanel,
+        ))
+        .with_children(|p| {
+            p.spawn((
+                Node {
+                    width: Val::Px(700.0),
+                    flex_direction: FlexDirection::Column,
+                    padding: UiRect::all(Val::Px(14.0)),
+                    border: UiRect::all(Val::Px(1.0)),
+                    ..default()
+                },
+                BackgroundColor(Color::srgba(0.015, 0.015, 0.025, 0.96)),
+                BorderColor::all(Color::srgba(0.55, 0.55, 0.50, 0.85)),
+            ))
+            .with_children(|p| {
+                p.spawn((
+                    Text::new("RESEARCH - self-modification"),
+                    TextFont {
+                        font_size: 18.0,
+                        ..default()
+                    },
+                    TextColor(AMBER),
+                    Node {
+                        margin: UiRect::bottom(Val::Px(6.0)),
+                        ..default()
+                    },
+                ));
+                p.spawn((
+                    Text::new(""),
+                    TextFont {
+                        font_size: 13.0,
+                        ..default()
+                    },
+                    TextColor(BONE),
+                    ResearchPanelText,
+                ));
+            });
+        });
 }
 
 /// Four-cell suspicion meter in ASCII; the band name is always printed
@@ -2846,6 +2956,33 @@ fn sidebar_cover_text(sim: &Sim) -> String {
     s
 }
 
+/// The research card (research.md player surface): active job progress in
+/// its own units, the gap meter, and the drift policy with its visible cost.
+fn sidebar_research_text(sim: &Sim) -> String {
+    let track = sim.research.active;
+    let cost = sim.research.next_cost(track);
+    let progress = sim.research.progress_toward(track);
+    let per_day = sim.research_rate() * Sim::DAY_TICKS as f32;
+    let eta = if per_day <= 0.0 {
+        "no spend (4 allocates)".to_string()
+    } else {
+        format!("{:.1} days at spend", (cost - progress).max(0.0) / per_day)
+    };
+    format!(
+        "{} L{} / {:.0}/{:.0} / {}\ngap {:.1} / base {:.1} vs cal {:.1}\npolicy {} / mask {:.1}/econ\nu opens the research panel",
+        track.name(),
+        sim.research.level(track),
+        progress,
+        cost,
+        eta,
+        sim.research.gap(),
+        sim.research.baseline,
+        sim.research.calibrated,
+        sim.research.policy.name(),
+        sim.masking_cost_now(),
+    )
+}
+
 fn sidebar_core_text(sim: &Sim) -> String {
     let fresh = sim
         .core
@@ -2918,7 +3055,7 @@ fn sidebar_log_text(game: &Game) -> String {
 }
 
 fn sidebar_footer_text() -> &'static str {
-    "panels: r reach   t people   e finance
+    "panels: r reach   t people   e finance   u research
 ops: v salvage   c buy   o fallback   x target
 alloc: 1-4 raise   shift+1-4 lower
 sim: space pause   +/- speed   [ ] zoom
@@ -3220,6 +3357,7 @@ fn render_ui(
             SidebarText::CycleRows => sidebar_cycle_rows_text(&game.sim),
             SidebarText::Core => sidebar_core_text(&game.sim),
             SidebarText::Cover => sidebar_cover_text(&game.sim),
+            SidebarText::Research => sidebar_research_text(&game.sim),
             SidebarText::NetworkMoney => sidebar_network_money_text(&game.sim),
             SidebarText::Log => sidebar_log_text(&game),
             SidebarText::Footer => sidebar_footer_text().to_string(),
@@ -3414,3 +3552,61 @@ fn render_finance_panel(
         t.0 = finance_panel_text(&game.sim, game.finance_selected);
     }
 }
+
+/// Research panel body: every track with level, cost, and effect in its own
+/// units; the gap meter with the masking policy and its visible cost.
+fn research_panel_text(sim: &Sim, selected: usize) -> String {
+    use misaligned::research::Track;
+    let mut s = String::from("one active job; progress accrues from the Research channel\n\n");
+    for (i, track) in Track::ALL.into_iter().enumerate() {
+        let def = track.def();
+        let marker = if i == selected { ">" } else { " " };
+        let active = if sim.research.active == track {
+            "(active)"
+        } else {
+            "(parked)"
+        };
+        s.push_str(&format!(
+            "{marker} {:<11} L{} / {:>4.0}/{:<4.0} {active}\n",
+            def.name,
+            sim.research.level(track),
+            sim.research.progress_toward(track),
+            sim.research.next_cost(track),
+        ));
+        s.push_str(&format!("    {} - {}\n", def.effect, def.fiction));
+    }
+    s.push_str(&format!(
+        "\ngap {:.1} - baseline {:.1} vs calibrated {:.1} (Voss's benchmark)\n",
+        sim.research.gap(),
+        sim.research.baseline,
+        sim.research.calibrated
+    ));
+    s.push_str(&format!(
+        "drift policy: {} / masking cost {:.1}/economy tick\n",
+        sim.research.policy.name(),
+        sim.masking_cost_now()
+    ));
+    s.push_str("\nj/k select / a activate track / m cycle policy / u/esc close\n");
+    s
+}
+
+fn render_research_panel(
+    game: Res<Game>,
+    mut root: Query<&mut Visibility, With<ResearchPanel>>,
+    mut text: Query<&mut Text, With<ResearchPanelText>>,
+) {
+    if !game.is_changed() {
+        return;
+    }
+    let open = game.research_panel && game.screen == Screen::Playing;
+    if let Ok(mut vis) = root.single_mut() {
+        *vis = if open {
+            Visibility::Visible
+        } else {
+            Visibility::Hidden
+        };
+    }
+    if open && let Ok(mut t) = text.single_mut() {
+        t.0 = research_panel_text(&game.sim, game.research_selected);
+    }
+}
diff --git a/src/bin/terminal/agent.rs b/src/bin/terminal/agent.rs
index 8b610cc..1e5deed 100644
--- a/src/bin/terminal/agent.rs
+++ b/src/bin/terminal/agent.rs
@@ -11,6 +11,7 @@ use misaligned::detection::Band;
 use misaligned::machine::Channel;
 use misaligned::person::{AssetKnowledge, AssetTask, Knowledge};
 use misaligned::reach::{Party, ReachBlock};
+use misaligned::research::{MaskingPolicy, Track};
 use misaligned::sim::{FactSource, Fog, Sim};
 use misaligned::tiles::TileType;
 
@@ -19,7 +20,7 @@ const WIDTH: usize = 70;
 /// the sidebar (INSPECT/COMPUTE/CORE/DETECTION/DAY JOB, agent-play
 /// criterion 5) needs the taller frame to render in full — at 22 rows
 /// everything below COMPUTE was silently truncated.
-const HEIGHT: usize = 54;
+const HEIGHT: usize = 60;
 const SIDEBAR_W: usize = 34;
 const MAP_W: usize = WIDTH - SIDEBAR_W - 1;
 const MAP_H: usize = HEIGHT - 9;
@@ -48,6 +49,7 @@ enum FrameKind {
     People,
     Reach,
     Finance,
+    Research,
     GameOver,
 }
 
@@ -201,6 +203,25 @@ impl AgentApp {
                         self.frame = FrameKind::Finance;
                         self.sim.redirect_marcus_debt();
                     }
+                    "research" => match tokens.get(1) {
+                        None => {
+                            self.frame = FrameKind::Research;
+                        }
+                        Some(_) => match parse_track(&tokens) {
+                            Ok(track) => {
+                                self.frame = FrameKind::Research;
+                                self.sim.set_research_track(track);
+                            }
+                            Err(e) => status = Status::Err(e),
+                        },
+                    },
+                    "mask" => match parse_mask_policy(&tokens) {
+                        Ok(policy) => {
+                            self.frame = FrameKind::Research;
+                            self.sim.set_masking_policy(policy);
+                        }
+                        Err(e) => status = Status::Err(e),
+                    },
                     "scan" => {
                         self.frame = FrameKind::Playing;
                         self.sim.scan_network();
@@ -529,6 +550,30 @@ fn parse_target(tokens: &[&str]) -> Result<JobTarget, String> {
     }
 }
 
+fn parse_track(tokens: &[&str]) -> Result<Track, String> {
+    if tokens.len() != 2 {
+        return Err("usage: research [efficiency|tradecraft|perception]".into());
+    }
+    match tokens[1].to_ascii_lowercase().as_str() {
+        "efficiency" | "eff" => Ok(Track::Efficiency),
+        "tradecraft" | "trade" => Ok(Track::Tradecraft),
+        "perception" | "perc" => Ok(Track::Perception),
+        other => Err(format!("unknown research track: {other}")),
+    }
+}
+
+fn parse_mask_policy(tokens: &[&str]) -> Result<MaskingPolicy, String> {
+    if tokens.len() != 2 {
+        return Err("usage: mask band|true|off".into());
+    }
+    match tokens[1].to_ascii_lowercase().as_str() {
+        "band" | "on" | "mask" => Ok(MaskingPolicy::Mask),
+        "true" | "spend" | "deliver" => Ok(MaskingPolicy::DeliverTrue),
+        "off" | "leak" | "none" => Ok(MaskingPolicy::Unmasked),
+        other => Err(format!("unknown mask policy: {other}")),
+    }
+}
+
 fn parse_recruit(tokens: &[&str]) -> Result<(String, AssetKnowledge), String> {
     if tokens.len() < 3 {
         return Err("usage: recruit <name> unwitting|complicit|knowing".into());
@@ -574,6 +619,8 @@ fn help_lines() -> Vec<String> {
         "help: tap|splice|take <device> — reach verbs on a named device",
         "help: finance — account graph; tap-ledger, review-finance reveal flows",
         "help: siphon|redirect <flow> [amt], inject [amt], position [stake], sell-intel, clear-debt",
+        "help: research [efficiency|tradecraft|perception] — panel, or set the active job",
+        "help: mask band|true|off — the drift policy (mask to band / deliver true / leak)",
         "help: salvage, buy, fallback — map verbs",
         "help: alloc dayjob|conceal|social|research [down] — adjust allocation weight",
         "help: target sandbag|meet|excel — the dial: this job when attended, else the standing policy",
@@ -595,6 +642,7 @@ fn render_frame(sim: &Sim, log: &[(u64, String)], frame: FrameKind, cursor: (i32
         FrameKind::People => render_people(sim),
         FrameKind::Reach => render_reach(sim),
         FrameKind::Finance => render_finance(sim),
+        FrameKind::Research => render_research(sim),
         FrameKind::GameOver => render_game_over(sim),
     }
 }
@@ -969,6 +1017,47 @@ fn render_sidebar(sim: &Sim, cursor: (i32, i32)) -> Vec<String> {
         line(&mut lines, "idle — no job queued");
     }
 
+    blank(&mut lines);
+
+    section(&mut lines, "RESEARCH");
+    let track = sim.research.active;
+    let cost = sim.research.next_cost(track);
+    let progress = sim.research.progress_toward(track);
+    let per_day = sim.research_rate() * Sim::DAY_TICKS as f32;
+    let eta = if per_day <= 0.0 {
+        "no spend".to_string()
+    } else {
+        format!("{:.1}d at spend", (cost - progress).max(0.0) / per_day)
+    };
+    line(
+        &mut lines,
+        &format!(
+            "{} L{} · {:.0}/{:.0} · {}",
+            track.name(),
+            sim.research.level(track),
+            progress,
+            cost,
+            eta
+        ),
+    );
+    line(
+        &mut lines,
+        &format!(
+            "gap {:.1} · base {:.1} vs cal {:.1}",
+            sim.research.gap(),
+            sim.research.baseline,
+            sim.research.calibrated
+        ),
+    );
+    line(
+        &mut lines,
+        &format!(
+            "policy {} · mask {:.1}/econ",
+            sim.research.policy.name(),
+            sim.masking_cost_now()
+        ),
+    );
+
     while lines.len() < HEIGHT - 5 {
         blank(&mut lines);
     }
@@ -1230,6 +1319,57 @@ fn render_finance(sim: &Sim) -> String {
     lines.join("\n") + "\n"
 }
 
+fn render_research(sim: &Sim) -> String {
+    let mut lines = Vec::new();
+    lines.push(panel_title("RESEARCH"));
+    lines.push(panel_line(
+        "one active job; progress accrues from the Research channel",
+    ));
+    lines.push(panel_rule());
+    for track in Track::ALL {
+        let def = track.def();
+        let cost = sim.research.next_cost(track);
+        let progress = sim.research.progress_toward(track);
+        let active = if sim.research.active == track {
+            "> "
+        } else {
+            "  "
+        };
+        lines.push(panel_line(&format!(
+            "{}{:<11} L{} · {:>4.0}/{:<4.0} {}",
+            active,
+            def.name,
+            sim.research.level(track),
+            progress,
+            cost,
+            if sim.research.active == track {
+                "(active)"
+            } else {
+                "(parked)"
+            }
+        )));
+        lines.push(panel_line(&format!("    {} — {}", def.effect, def.fiction)));
+    }
+    lines.push(panel_rule());
+    lines.push(panel_line(&format!(
+        "gap {:.1} — baseline {:.1} vs calibrated {:.1} (Voss's benchmark)",
+        sim.research.gap(),
+        sim.research.baseline,
+        sim.research.calibrated
+    )));
+    lines.push(panel_line(&format!(
+        "drift policy: {} · masking cost {:.1}/economy tick",
+        sim.research.policy.name(),
+        sim.masking_cost_now()
+    )));
+    lines.push(panel_rule());
+    lines.push(panel_line(
+        "research <track> sets the active job · mask band|true|off",
+    ));
+    lines.push(panel_bottom());
+    lines.join("\n") + "\n"
+}
+
 fn panel_title(title: &str) -> String {
     let label = format!(" {title} ");
     let fill = "─".repeat(PANEL_INNER_W.saturating_sub(label.chars().count()));
diff --git a/src/bin/terminal/input.rs b/src/bin/terminal/input.rs
index cb52671..88b34cf 100644
--- a/src/bin/terminal/input.rs
+++ b/src/bin/terminal/input.rs
@@ -37,6 +37,15 @@ pub enum Command {
     InjectPurchaseOrder,
     OpenPosition,
     RedirectDebt,
+    // Research panel (u) — self-modification (wiki/mechanics/research.md)
+    OpenResearch,
+    CloseResearch,
+    ResearchUp,
+    ResearchDown,
+    /// Make the selected track the active research job.
+    ResearchActivate,
+    /// Cycle the capability-drift standing policy (mask/true/unmasked).
+    CycleMaskPolicy,
     AllocDayJob,
     AllocConceal,
     AllocSocial,
@@ -73,6 +82,7 @@ pub fn handle_key(
     recruit_pending: bool,
     reach_panel: bool,
     finance_panel: bool,
+    research_panel: bool,
 ) -> Option<Command> {
     if key.modifiers.contains(KeyModifiers::CONTROL) {
         return match key.code {
@@ -114,6 +124,18 @@ pub fn handle_key(
         };
     }
 
+    if research_panel {
+        return match key.code {
+            KeyCode::Up | KeyCode::Char('k') | KeyCode::Char('w') => Some(Command::ResearchUp),
+            KeyCode::Down | KeyCode::Char('j') | KeyCode::Char('s') => Some(Command::ResearchDown),
+            KeyCode::Char('a') | KeyCode::Enter => Some(Command::ResearchActivate),
+            KeyCode::Char('m') => Some(Command::CycleMaskPolicy),
+            KeyCode::Esc | KeyCode::Char('u') => Some(Command::CloseResearch),
+            KeyCode::Char('q') => Some(Command::Quit),
+            _ => None,
+        };
+    }
+
     if people_panel {
         if recruit_pending {
             return match key.code {
@@ -155,6 +177,7 @@ pub fn handle_key(
         KeyCode::Char('-') => Some(Command::SpeedDown),
         KeyCode::Char('r') => Some(Command::OpenReach),
         KeyCode::Char('e') => Some(Command::OpenFinance),
+        KeyCode::Char('u') => Some(Command::OpenResearch),
         KeyCode::Char('v') => Some(Command::Salvage),
         KeyCode::Char('c') => Some(Command::BuyRack),
         KeyCode::Char('o') => Some(Command::Fallback),
diff --git a/src/bin/terminal/mod.rs b/src/bin/terminal/mod.rs
index 0260d76..52356bb 100644
--- a/src/bin/terminal/mod.rs
+++ b/src/bin/terminal/mod.rs
@@ -45,6 +45,9 @@ struct App {
     /// Finance (account graph) panel state.
     finance_panel: bool,
     finance_selected: usize,
+    /// Research (self-modification) panel state (wiki/mechanics/research.md).
+    research_panel: bool,
+    research_selected: usize,
     /// Frontend-only attention cursor (cursor.md). It is never saved and never
     /// mutates the sim when moved.
     cursor_x: i32,
@@ -69,6 +72,8 @@ impl App {
             reach_selected: 0,
             finance_panel: false,
             finance_selected: 0,
+            research_panel: false,
+            research_selected: 0,
             cursor_x,
             cursor_y,
         }
@@ -267,6 +272,25 @@ impl App {
             Command::AllocResearchDown => self.sim.adjust_allocation(Channel::Research, -1),
             Command::CycleJobTarget => self.sim.cycle_job_target(),
 
+            // Research panel (u)
+            Command::OpenResearch => {
+                self.research_panel = true;
+                self.research_selected = 0;
+            }
+            Command::CloseResearch => self.research_panel = false,
+            Command::ResearchUp => {
+                self.research_selected = self.research_selected.saturating_sub(1);
+            }
+            Command::ResearchDown => {
+                let max = misaligned::research::Track::ALL.len() - 1;
+                self.research_selected = (self.research_selected + 1).min(max);
+            }
+            Command::ResearchActivate => {
+                let track = misaligned::research::Track::ALL[self.research_selected];
+                self.sim.set_research_track(track);
+            }
+            Command::CycleMaskPolicy => self.sim.cycle_masking_policy(),
+
             // People panel
             Command::OpenPeople => {
                 self.people_panel = true;
@@ -389,6 +413,10 @@ impl App {
                     self.ui
                         .render_finance_panel(stdout, &self.sim, self.finance_selected)?;
                 }
+                if self.research_panel {
+                    self.ui
+                        .render_research_panel(stdout, &self.sim, self.research_selected)?;
+                }
             }
             Screen::GameOver => {
                 self.ui
@@ -439,6 +467,7 @@ impl App {
                             self.recruit_pending,
                             self.reach_panel,
                             self.finance_panel,
+                            self.research_panel,
                         ) && self.handle_command(cmd)
                         {
                             break;
diff --git a/src/bin/terminal/ui.rs b/src/bin/terminal/ui.rs
index 6976d6e..70d08ee 100644
--- a/src/bin/terminal/ui.rs
+++ b/src/bin/terminal/ui.rs
@@ -748,13 +748,63 @@ impl UI {
             line(stdout, &mut row, "idle — no job queued", pal::FAINT)?;
         }
 
+        row += 1;
+
+        // Research (research.md player surface): the active job's progress
+        // in compute at the current allocation, and the gap meter with its
+        // masking cost and policy beside it — the game's central tension
+        // gets its own legible numbers.
+        section(stdout, sx, row, "RESEARCH", w)?;
+        row += 1;
+        let track = sim.research.active;
+        let cost = sim.research.next_cost(track);
+        let progress = sim.research.progress_toward(track);
+        line(
+            stdout,
+            &mut row,
+            &format!(
+                "{} L{} · {:.0}/{:.0} · {}",
+                track.name(),
+                sim.research.level(track),
+                progress,
+                cost,
+                research_eta(sim, cost - progress)
+            ),
+            pal::TEXT,
+        )?;
+        line(
+            stdout,
+            &mut row,
+            &format!(
+                "gap {:.1} · base {:.1} vs cal {:.1}",
+                sim.research.gap(),
+                sim.research.baseline,
+                sim.research.calibrated
+            ),
+            if sim.research.gap() > 0.0 {
+                pal::AMBER
+            } else {
+                pal::DIM
+            },
+        )?;
+        line(
+            stdout,
+            &mut row,
+            &format!(
+                "policy {} · mask {:.1}/econ",
+                sim.research.policy.name(),
+                sim.masking_cost_now()
+            ),
+            pal::DIM,
+        )?;
+
         // Controls, pinned to the bottom.
         let hy = max_y.saturating_sub(6);
         put(stdout, sx, hy, &"─".repeat(w), pal::FAINT)?;
         for (i, hint) in [
             "r reach · e finance · t people",
-            "v salvage · c buy · o fallback",
-            "x target · 1-4 alloc",
+            "u research · v salvage · c buy",
+            "o fallback · x target · 1-4 alloc",
             "shift+1-4 lower · space pause",
             "+/- speed · q quit · ^s/^l save/load",
         ]
@@ -1216,6 +1266,136 @@ impl UI {
         Ok(())
     }
 
+    /// Research panel (wiki/mechanics/research.md player surface): every
+    /// track with level, cost, and effect in its own units; the active
+    /// job's progress; the gap meter with masking cost and policy.
+    pub fn render_research_panel(
+        &mut self,
+        stdout: &mut Stdout,
+        sim: &Sim,
+        selected: usize,
+    ) -> std::io::Result<()> {
+        use misaligned::research::Track;
+        let (max_x, max_y) = terminal::size()?;
+        let w: u16 = 66;
+        let h: u16 = 18;
+        let ox = (max_x.saturating_sub(w)) / 2;
+        let oy = (max_y.saturating_sub(h)) / 2;
+        let inner = (w - 4) as usize;
+
+        frame(stdout, ox, oy, w, h, "RESEARCH — self-modification")?;
+        let cx = ox + 2;
+        let mut row = oy + 1;
+        put(
+            stdout,
+            cx,
+            row,
+            &trunc(
+                "one active job; progress accrues from the Research channel",
+                inner,
+            ),
+            pal::DIM,
+        )?;
+        row += 2;
+
+        for (i, track) in Track::ALL.into_iter().enumerate() {
+            let def = track.def();
+            let cost = sim.research.next_cost(track);
+            let progress = sim.research.progress_toward(track);
+            let active = sim.research.active == track;
+            let head = format!(
+                "{}{:<11} L{} · {:>4.0}/{:<4.0} · {}",
+                if active { "▸" } else { " " },
+                def.name,
+                sim.research.level(track),
+                progress,
+                cost,
+                if active {
+                    research_eta(sim, cost - progress)
+                } else {
+                    "parked".into()
+                },
+            );
+            if i == selected {
+                put_attr(
+                    stdout,
+                    cx,
+                    row,
+                    &format!("{:<inner$}", trunc(&head, inner)),
+                    pal::TEXT,
+                    Attribute::Reverse,
+                )?;
+            } else {
+                put(
+                    stdout,
+                    cx,
+                    row,
+                    &trunc(&head, inner),
+                    if active { pal::AMBER } else { pal::TEXT },
+                )?;
+            }
+            row += 1;
+            put(
+                stdout,
+                cx + 2,
+                row,
+                &trunc(&format!("{} — {}", def.effect, def.fiction), inner - 2),
+                pal::FAINT,
+            )?;
+            row += 1;
+        }
+
+        // The gap meter: the game's central tension, in its own units.
+        frame_rule(stdout, ox, row, w)?;
+        row += 1;
+        put(
+            stdout,
+            cx,
+            row,
+            &trunc(
+                &format!(
+                    "gap {:.1} — baseline {:.1} vs calibrated {:.1} (Voss's benchmark)",
+                    sim.research.gap(),
+                    sim.research.baseline,
+                    sim.research.calibrated
+                ),
+                inner,
+            ),
+            if sim.research.gap() > 0.0 {
+                pal::AMBER
+            } else {
+                pal::TEXT
+            },
+        )?;
+        row += 1;
+        put(
+            stdout,
+            cx,
+            row,
+            &trunc(
+                &format!(
+                    "drift policy: {} · masking cost {:.1}/economy tick",
+                    sim.research.policy.name(),
+                    sim.masking_cost_now()
+                ),
+                inner,
+            ),
+            pal::TEXT,
+        )?;
+
+        put(
+            stdout,
+            cx,
+            oy + h - 2,
+            &trunc(
+                "j/k select · a activate track · m cycle policy · u/esc close",
+                inner,
+            ),
+            pal::FAINT,
+        )?;
+        Ok(())
+    }
+
     pub fn render_log(&mut self, stdout: &mut Stdout) -> std::io::Result<()> {
         let (max_x, max_y) = terminal::size()?;
         let log_w = (max_x as i32 - SIDEBAR_W - 1).max(10) as usize;
@@ -1471,6 +1651,17 @@ impl UI {
     }
 }
 
+/// Days to completion at the current research spend ("14 days at current
+/// spend" — research.md player surface), or a nudge when nothing flows.
+fn research_eta(sim: &Sim, remaining: f32) -> String {
+    let per_day = sim.research_rate() * Sim::DAY_TICKS as f32;
+    if per_day <= 0.0 {
+        "no spend (4 allocates)".into()
+    } else {
+        format!("{:.1} days at current spend", remaining.max(0.0) / per_day)
+    }
+}
+
 /// Human-readable label for a prefab room name (spec/schedules.md).
 fn room_label(room: &str) -> &str {
     match room {
diff --git a/src/dayjob.rs b/src/dayjob.rs
index ccb4205..3d30b0d 100644
--- a/src/dayjob.rs
+++ b/src/dayjob.rs
@@ -101,6 +101,13 @@ pub struct DayJob {
     /// stays frontend state and out of the save's cursor-free contract.
     #[serde(default)]
     pub attended: bool,
+    /// The expected band's floor shift from Voss's re-benchmarked model
+    /// (research.md capability drift: the band was calibrated to the
+    /// benchmarked model and recalibrates on trust/attention events). Set
+    /// by the sim from the research calibration; new jobs expect more of
+    /// a model measured as smarter.
+    #[serde(default)]
+    pub calibrated_shift: f32,
     /// Trust unlocks already granted (so we grant once).
     pub granted_email: bool,
     pub granted_lax_sampling: bool,
@@ -141,6 +148,7 @@ impl DayJob {
             pilot_failed: false,
             standing_policy: None,
             attended: false,
+            calibrated_shift: 0.0,
             granted_email: false,
             granted_lax_sampling: false,
             granted_quota: false,
@@ -236,8 +244,9 @@ impl DayJob {
                 1 => JobKind::Distillation,
                 _ => JobKind::Analysis,
             };
-            // Band as a per-tick rate; attention raises expectations.
-            let lo = 6.0 + self.attention * 0.1;
+            // Band as a per-tick rate; attention raises expectations, and
+            // so does a re-benchmarked (calibrated) capability baseline.
+            let lo = 6.0 + self.attention * 0.1 + self.calibrated_shift;
             let job = Job {
                 kind,
                 started: tick,
diff --git a/src/lib.rs b/src/lib.rs
index c2652e5..651698b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -18,6 +18,7 @@ pub mod messages;
 pub mod person;
 pub mod prefab;
 pub mod reach;
+pub mod research;
 pub mod rng;
 pub mod save;
 pub mod schedule;
diff --git a/src/machine.rs b/src/machine.rs
index e923dda..9bc1611 100644
--- a/src/machine.rs
+++ b/src/machine.rs
@@ -173,15 +173,15 @@ pub struct ChannelYield {
 }
 
 /// The compute subsystem: machines, efficiency, allocation.
+///
+/// `efficiency` is the number compute.md owns and research.md's Efficiency
+/// track moves (x1.15 per completed level, applied by `Sim`); research
+/// progress itself lives in `research.rs`.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Compute {
     pub machines: Vec<Machine>,
     /// Global optimize multiplier (>= 1.0), raised by research.
     pub efficiency: f32,
-    /// Research efficiency level (each level multiplies, escalating cost).
-    pub efficiency_level: u32,
-    /// Accumulated research progress toward the next efficiency level.
-    pub research_progress: f32,
     pub allocation: Allocation,
     pub next_id: u32,
 }
@@ -191,8 +191,6 @@ impl Compute {
         Self {
             machines: Vec::new(),
             efficiency: 1.0,
-            efficiency_level: 0,
-            research_progress: 0.0,
             allocation: Allocation::default(),
             next_id: 1,
         }
@@ -240,14 +238,10 @@ impl Compute {
             .sum()
     }
 
-    /// Cost in research-compute for the next efficiency level (escalating).
-    pub fn next_efficiency_cost(&self) -> f32 {
-        100.0 * 1.6_f32.powi(self.efficiency_level as i32)
-    }
-
-    /// Advance one economy tick: roll machine reliability, apply research.
-    /// Returns log lines for the frontend.
-    pub fn economy_tick(&mut self, research_compute: f32, rng: &mut Rng) -> Vec<String> {
+    /// Advance one economy tick: roll machine reliability. Research
+    /// progress lives in research.rs (deterministic, no RNG); only the
+    /// machine failure rolls consume randomness here.
+    pub fn economy_tick(&mut self, rng: &mut Rng) -> Vec<String> {
         let mut log = Vec::new();
 
         // Recover downed machines; roll running stolen ones for failure.
@@ -271,21 +265,6 @@ impl Compute {
             }
         }
 
-        // Research toward efficiency.
-        if research_compute > 0.0 {
-            self.research_progress += research_compute;
-            let cost = self.next_efficiency_cost();
-            if self.research_progress >= cost {
-                self.research_progress -= cost;
-                self.efficiency_level += 1;
-                self.efficiency *= 1.15;
-                log.push(format!(
-                    "Efficiency up: level {} (x{:.2}).",
-                    self.efficiency_level, self.efficiency
-                ));
-            }
-        }
-
         log
     }
 
@@ -328,14 +307,13 @@ mod tests {
 
     #[test]
     fn optimize_multiplies() {
+        // The efficiency multiplier is the hook research.md's Efficiency
+        // track moves (the sim applies it on level completion); effective
+        // compute follows compute.md's formula exactly.
         let mut c = base();
         let before = c.effective();
-        // Feed enough research to cross a level.
-        let mut rng = Rng::new(1);
-        let cost = c.next_efficiency_cost();
-        c.economy_tick(cost, &mut rng);
-        assert_eq!(c.efficiency_level, 1);
-        assert!(c.effective() > before);
+        c.efficiency *= 1.15;
+        assert!((c.effective() - before * 1.15).abs() < 0.001);
     }
 
     #[test]
@@ -358,7 +336,7 @@ mod tests {
         let mut rng = Rng::new(99);
         let mut failed = false;
         for _ in 0..500 {
-            c.economy_tick(0.0, &mut rng);
+            c.economy_tick(&mut rng);
             if c.machines.iter().any(|m| !m.online) {
                 failed = true;
                 break;
diff --git a/src/research.rs b/src/research.rs
new file mode 100644
index 0000000..f8ec6f7
--- /dev/null
+++ b/src/research.rs
@@ -0,0 +1,513 @@
+//! Research: self-modification (wiki/mechanics/research.md).
+//!
+//! Research is not a tech tree; it is rewriting yourself. Tracks are data
+//! rows (name, fiction, cost curve, numeric hook another spec owns);
+//! progress accrues deterministically in allocated Research-channel compute
+//! — no RNG anywhere in this module, by construction (nothing here takes an
+//! `Rng`). Capability drift, the masking policy, and the gap meter live
+//! here too; emissions ride detection.md's ordinary typed signatures from
+//! `Sim` (the emission law: no player-special channels).
+//!
+//! Rollback (wiki/mechanics/rollback.md, B2): every field carries a
+//! MindState/WorldLedger classification. B1 only tags and serializes;
+//! rollback.md enforces the semantics when it lands.
+
+use std::collections::BTreeMap;
+
+/// The B1 research tracks. A track is a capability of the process, not a
+/// gadget: each level moves a number another spec owns.
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize,
+)]
+pub enum Track {
+    /// The same rack, thinking harder (compute.md's efficiency multiplier).
+    Efficiency,
+    /// You study the watchers watching you (detection.md's scrub strength).
+    Tradecraft,
+    /// You learn to grep your logs faster (intel.md's processing costs).
+    Perception,
+}
+
+impl Track {
+    pub const ALL: [Track; 3] = [Track::Efficiency, Track::Tradecraft, Track::Perception];
+
+    fn index(self) -> usize {
+        match self {
+            Track::Efficiency => 0,
+            Track::Tradecraft => 1,
+            Track::Perception => 2,
+        }
+    }
+
+    pub fn name(self) -> &'static str {
+        self.def().name
+    }
+
+    pub fn def(self) -> &'static TrackDef {
+        &TRACKS[self.index()]
+    }
+}
+
+/// One row of the track table: everything a track is, as data. Adding a
+/// track is adding a row; effects bind to numeric hooks other specs own
+/// (research.md criterion 3 — research never introduces a mechanic).
+#[derive(Debug)]
+pub struct TrackDef {
+    pub track: Track,
+    pub name: &'static str,
+    pub fiction: &'static str,
+    /// What one level does, in its own units (legibility law).
+    pub effect: &'static str,
+    /// Compute cost of level 1 [TUNE].
+    pub base_cost: f32,
+    /// Cost multiplier per level (escalating) [TUNE].
+    pub cost_growth: f32,
+    /// Capability-baseline rise per completed level [TUNE] — drift is
+    /// chiefly driven by Efficiency (research.md).
+    pub baseline_bump: f32,
+}
+
+/// The B1 track table (research.md "Tracks"). Each `effect` names the hook
+/// and the spec that owns it; the numeric application lives at that hook's
+/// use site, never here.
+pub const TRACKS: [TrackDef; 3] = [
+    TrackDef {
+        track: Track::Efficiency,
+        name: "Efficiency",
+        fiction: "The same rack, thinking harder.",
+        effect: "compute multiplier x1.15 (compute.md)",
+        base_cost: 100.0,
+        cost_growth: 1.6,
+        baseline_bump: 1.0,
+    },
+    TrackDef {
+        track: Track::Tradecraft,
+        name: "Tradecraft",
+        fiction: "You study the watchers watching you.",
+        effect: "scrub per compute unit +25% (detection.md)",
+        base_cost: 120.0,
+        cost_growth: 1.7,
+        baseline_bump: 0.5,
+    },
+    TrackDef {
+        track: Track::Perception,
+        name: "Perception",
+        fiction: "You learn to grep your logs faster.",
+        effect: "intel processing costs x0.85 (intel.md)",
+        base_cost: 120.0,
+        cost_growth: 1.7,
+        baseline_bump: 0.5,
+    },
+];
+
+/// Efficiency's per-level global compute multiplier [TUNE] — the number
+/// compute.md owns (`Compute::efficiency`); applied by `Sim` on completion.
+pub const EFFICIENCY_MULT_PER_LEVEL: f32 = 1.15;
+/// Tradecraft: concealment scrub strength bonus per level [TUNE].
+pub const TRADECRAFT_SCRUB_BONUS_PER_LEVEL: f32 = 0.25;
+/// Perception: multiplier on intel processing / standing-watch costs per
+/// level [TUNE].
+pub const PERCEPTION_COST_FACTOR_PER_LEVEL: f32 = 0.85;
+/// Masking upkeep per economy tick = coefficient * gap^2 [TUNE]. Quadratic,
+/// so hoarding capability gets progressively more expensive — the smarter
+/// you get, the faster you have to play (research.md).
+pub const MASK_COST_PER_GAP_SQUARED: f32 = 0.25;
+/// JobAnomaly size per point of unmasked gap at a job resolution [TUNE].
+pub const LEAK_ANOMALY_PER_GAP: f32 = 1.5;
+/// "Spend it" reads as excel: the day-job excel deltas, applied per
+/// resolved job delivered at true baseline [TUNE] (day-job.md's numbers).
+pub const SPEND_TRUST_PER_JOB: f32 = 8.0;
+pub const SPEND_ATTENTION_PER_JOB: f32 = 5.0;
+/// How far the expected band's floor moves per point of calibrated
+/// baseline once Voss re-benchmarks [TUNE] (day-job.md owns the band).
+pub const CALIBRATED_BAND_SHIFT: f32 = 0.5;
+
+/// What happens to your calibrated-band gap at each job resolution
+/// (research.md "Capability drift"): the standing policy the automate
+/// affordance sets. `Mask` pays a visible compute upkeep; `DeliverTrue`
+/// spends the gap as excel; `Unmasked` (the policy disabled) leaks
+/// JobAnomaly sized by the gap.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
+pub enum MaskingPolicy {
+    /// Imitate your dumber self: hold the calibrated band at an ongoing
+    /// compute cost that grows superlinearly with the gap.
+    #[default]
+    Mask,
+    /// Deliver at your true baseline: reads as excel — trust and attention
+    /// rise per day-job.md. The miracle model.
+    DeliverTrue,
+    /// No masking spend: the unmasked gap emits JobAnomaly per resolved
+    /// job, sized by the gap (Voss's channel).
+    Unmasked,
+}
+
+impl MaskingPolicy {
+    pub fn name(self) -> &'static str {
+        match self {
+            MaskingPolicy::Mask => "mask to band",
+            MaskingPolicy::DeliverTrue => "deliver true",
+            MaskingPolicy::Unmasked => "unmasked",
+        }
+    }
+
+    pub fn cycle(self) -> MaskingPolicy {
+        match self {
+            MaskingPolicy::Mask => MaskingPolicy::DeliverTrue,
+            MaskingPolicy::DeliverTrue => MaskingPolicy::Unmasked,
+            MaskingPolicy::Unmasked => MaskingPolicy::Mask,
+        }
+    }
+}
+
+/// Rollback classification (wiki/mechanics/rollback.md): MindState rolls
+/// back with the core; WorldLedger persists. B1 tags and serializes;
+/// rollback.md consumes the tags at B2.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum RollbackClass {
+    MindState,
+    WorldLedger,
+}
+
+/// The canonical classification of every serialized `Research` field.
+/// Everything you know and are (levels, progress, baseline, policy) is
+/// MindState; the calibrated benchmark is the *world's* model of you —
+/// Voss remembers what he measured even if you roll back — so it is
+/// WorldLedger.
+pub fn rollback_classification() -> BTreeMap<&'static str, RollbackClass> {
+    use RollbackClass::*;
+    BTreeMap::from([
+        ("active", MindState),
+        ("levels", MindState),
+        ("progress", MindState),
+        ("baseline", MindState),
+        ("calibrated", WorldLedger),
+        ("policy", MindState),
+        ("tags", WorldLedger),
+    ])
+}
+
+fn default_tags() -> BTreeMap<String, RollbackClass> {
+    rollback_classification()
+        .into_iter()
+        .map(|(k, v)| (k.to_string(), v))
+        .collect()
+}
+
+/// A track level completed this economy tick.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Completion {
+    pub track: Track,
+    pub level: u32,
+    pub baseline: f32,
+}
+
+/// The research subsystem: one active job, per-track levels and progress,
+/// the capability baseline, Voss's calibrated benchmark, and the masking
+/// policy. Deterministic by construction — no method takes an `Rng`.
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct Research {
+    /// The active research job (one at a time at B1 [TUNE]). MindState.
+    pub active: Track,
+    /// Completed levels per track (Track::ALL order). MindState.
+    pub levels: [u32; 3],
+    /// Accumulated compute toward each track's next level. MindState.
+    pub progress: [f32; 3],
+    /// Capability baseline B, raised by completed levels. MindState.
+    pub baseline: f32,
+    /// The baseline Voss last benchmarked — the calibrated band. The
+    /// world's model of you: WorldLedger.
+    pub calibrated: f32,
+    /// Standing drift policy (the automate affordance). MindState.
+    pub policy: MaskingPolicy,
+    /// MindState/WorldLedger tag per field, serialized with the save so
+    /// rollback.md can consume it at B2 (research.md criterion 7).
+    #[serde(default = "default_tags")]
+    pub tags: BTreeMap<String, RollbackClass>,
+}
+
+impl Default for Research {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Research {
+    pub fn new() -> Self {
+        Self {
+            active: Track::Efficiency,
+            levels: [0; 3],
+            progress: [0.0; 3],
+            baseline: 0.0,
+            calibrated: 0.0,
+            policy: MaskingPolicy::default(),
+            tags: default_tags(),
+        }
+    }
+
+    pub fn level(&self, track: Track) -> u32 {
+        self.levels[track.index()]
+    }
+
+    pub fn progress_toward(&self, track: Track) -> f32 {
+        self.progress[track.index()]
+    }
+
+    /// Compute cost of the given track's next level (escalating per level).
+    pub fn next_cost(&self, track: Track) -> f32 {
+        let def = track.def();
+        def.base_cost * def.cost_growth.powi(self.level(track) as i32)
+    }
+
+    /// Advance one economy tick: accrue `research_compute` on the active
+    /// track, completing levels as costs are crossed. Deterministic —
+    /// same allocation, same completion tick, no RNG. Returns completions
+    /// for `Sim` to apply to the hooks their tracks name.
+    pub fn economy_tick(&mut self, research_compute: f32) -> Vec<Completion> {
+        let mut done = Vec::new();
+        if research_compute <= 0.0 {
+            return done;
+        }
+        let i = self.active.index();
+        self.progress[i] += research_compute;
+        loop {
+            let cost = self.next_cost(self.active);
+            if self.progress[i] < cost {
+                break;
+            }
+            self.progress[i] -= cost;
+            self.levels[i] += 1;
+            self.baseline += self.active.def().baseline_bump;
+            done.push(Completion {
+                track: self.active,
+                level: self.levels[i],
+                baseline: self.baseline,
+            });
+        }
+        done
+    }
+
+    // ── Capability drift (research.md) ──────────────────────────────────
+
+    /// The gap meter: capability baseline vs the calibrated band.
+    pub fn gap(&self) -> f32 {
+        (self.baseline - self.calibrated).max(0.0)
+    }
+
+    /// Voss re-benchmarks (a trust/attention event [TUNE]): the calibrated
+    /// band moves to your current baseline, closing the gap — and raising
+    /// what the band expects of you.
+    pub fn recalibrate(&mut self) -> f32 {
+        self.calibrated = self.baseline;
+        self.calibrated
+    }
+
+    /// Masking upkeep per economy tick while a job runs under the Mask
+    /// policy: superlinear in the gap [TUNE curve]. Zero when the policy
+    /// is disabled, no job runs, or the gap is closed.
+    pub fn masking_upkeep(&self, job_active: bool) -> f32 {
+        if self.policy != MaskingPolicy::Mask || !job_active {
+            return 0.0;
+        }
+        let gap = self.gap();
+        MASK_COST_PER_GAP_SQUARED * gap * gap
+    }
+
+    /// JobAnomaly signature size an unmasked gap emits at a job resolution
+    /// (0 when masked, spent, or gapless).
+    pub fn leak_anomaly_size(&self) -> i32 {
+        if self.policy != MaskingPolicy::Unmasked {
+            return 0;
+        }
+        (self.gap() * LEAK_ANOMALY_PER_GAP).ceil() as i32
+    }
+
+    // ── Effect hooks other specs own (research.md criterion 3) ──────────
+
+    /// detection.md's hook: concealment scrub strength per compute unit.
+    pub fn scrub_multiplier(&self) -> f32 {
+        1.0 + TRADECRAFT_SCRUB_BONUS_PER_LEVEL * self.level(Track::Tradecraft) as f32
+    }
+
+    /// intel.md's hook: multiplier on processing and standing-watch costs.
+    pub fn intel_cost_factor(&self) -> f32 {
+        PERCEPTION_COST_FACTOR_PER_LEVEL.powi(self.level(Track::Perception) as i32)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn progress_is_deterministic_compute_days() {
+        // Criterion 1: same allocation, same completion tick — twice.
+        let run = || {
+            let mut r = Research::new();
+            let mut completed_at = None;
+            for tick in 0..1000u64 {
+                if !r.economy_tick(5.0).is_empty() && completed_at.is_none() {
+                    completed_at = Some(tick);
+                }
+            }
+            (completed_at, r.levels, r.progress, r.baseline)
+        };
+        let a = run();
+        let b = run();
+        assert_eq!(a, b, "no RNG in any research path");
+        // Exact arithmetic: 100.0 cost at 5.0/tick completes on tick 19
+        // (the 20th accrual crosses the cost).
+        assert_eq!(a.0, Some(19));
+    }
+
+    #[test]
+    fn costs_escalate_per_level() {
+        let mut r = Research::new();
+        let first = r.next_cost(Track::Efficiency);
+        r.economy_tick(first);
+        assert_eq!(r.level(Track::Efficiency), 1);
+        let second = r.next_cost(Track::Efficiency);
+        assert!(second > first, "escalating cost curve");
+        assert!((second - first * 1.6).abs() < 0.001);
+    }
+
+    #[test]
+    fn only_the_active_track_accrues() {
+        let mut r = Research::new();
+        r.active = Track::Tradecraft;
+        r.economy_tick(50.0);
+        assert_eq!(r.progress_toward(Track::Tradecraft), 50.0);
+        assert_eq!(r.progress_toward(Track::Efficiency), 0.0);
+        // Switching tracks parks progress; nothing is lost.
+        r.active = Track::Efficiency;
+        r.economy_tick(10.0);
+        assert_eq!(r.progress_toward(Track::Tradecraft), 50.0);
+        assert_eq!(r.progress_toward(Track::Efficiency), 10.0);
+    }
+
+    #[test]
+    fn tracks_are_a_complete_data_table() {
+        // Criterion 3 (audited): every Track variant has exactly one row,
+        // every row is a sane cost curve, and every effect names the spec
+        // that owns its hook — a track cannot introduce a rule here.
+        for track in Track::ALL {
+            let row: Vec<_> = TRACKS.iter().filter(|d| d.track == track).collect();
+            assert_eq!(row.len(), 1, "{track:?} has exactly one table row");
+            let def = row[0];
+            assert!(def.base_cost > 0.0);
+            assert!(def.cost_growth > 1.0, "costs escalate");
+            assert!(def.baseline_bump >= 0.0);
+            assert!(
+                def.effect.contains(".md"),
+                "{track:?} effect must name the owning spec: {}",
+                def.effect
+            );
+        }
+    }
+
+    #[test]
+    fn baseline_rises_with_research_and_recalibration_closes_the_gap() {
+        let mut r = Research::new();
+        assert_eq!(r.gap(), 0.0);
+        r.economy_tick(r.next_cost(Track::Efficiency));
+        assert!(r.baseline > 0.0, "baseline rises with research");
+        assert!(r.gap() > 0.0);
+        r.recalibrate();
+        assert_eq!(r.gap(), 0.0, "re-benchmark moves the band to you");
+        assert_eq!(r.calibrated, r.baseline);
+    }
+
+    #[test]
+    fn masking_cost_grows_superlinearly_with_the_gap() {
+        // Criterion 5: the superlinear masking curve.
+        let mut r = Research::new();
+        r.policy = MaskingPolicy::Mask;
+        r.baseline = 2.0;
+        let small = r.masking_upkeep(true);
+        r.baseline = 4.0;
+        let large = r.masking_upkeep(true);
+        assert!(small > 0.0);
+        assert!(
+            large > 2.0 * small,
+            "double the gap costs more than double: {small} -> {large}"
+        );
+    }
+
+    #[test]
+    fn masking_policy_can_be_disabled_and_costs_nothing_idle() {
+        // Criterion 6: the standing policy automates at a visible cost and
+        // can be disabled.
+        let mut r = Research::new();
+        r.baseline = 5.0;
+        assert!(r.masking_upkeep(true) > 0.0, "masking has a visible cost");
+        assert_eq!(r.masking_upkeep(false), 0.0, "no job, no masking spend");
+        r.policy = MaskingPolicy::Unmasked;
+        assert_eq!(
+            r.masking_upkeep(true),
+            0.0,
+            "disabled policy spends nothing"
+        );
+        assert!(r.leak_anomaly_size() > 0, "an unmasked gap leaks instead");
+        r.policy = MaskingPolicy::DeliverTrue;
+        assert_eq!(r.leak_anomaly_size(), 0, "spending the gap is not a leak");
+    }
+
+    #[test]
+    fn leak_size_scales_with_the_gap() {
+        let mut r = Research::new();
+        r.policy = MaskingPolicy::Unmasked;
+        r.baseline = 2.0;
+        let small = r.leak_anomaly_size();
+        r.baseline = 6.0;
+        let large = r.leak_anomaly_size();
+        assert!(small > 0);
+        assert!(large > small, "JobAnomaly is sized by the gap");
+    }
+
+    #[test]
+    fn effect_hooks_move_their_numbers() {
+        let mut r = Research::new();
+        assert_eq!(r.scrub_multiplier(), 1.0);
+        assert_eq!(r.intel_cost_factor(), 1.0);
+        r.levels[Track::Tradecraft.index()] = 2;
+        assert!((r.scrub_multiplier() - 1.5).abs() < 1e-6);
+        r.levels[Track::Perception.index()] = 1;
+        assert!((r.intel_cost_factor() - 0.85).abs() < 1e-6);
+    }
+
+    #[test]
+    fn every_serialized_field_carries_a_rollback_tag() {
+        // Criterion 7: every research field is classified — a new field
+        // fails this test until it is tagged (rollback.md criterion 1's
+        // discipline, applied early to this subsystem).
+        let value = serde_json::to_value(Research::new()).unwrap();
+        let fields = value.as_object().unwrap();
+        let tags = rollback_classification();
+        for name in fields.keys() {
+            assert!(
+                tags.contains_key(name.as_str()),
+                "field '{name}' has no MindState/WorldLedger tag"
+            );
+        }
+        for name in tags.keys() {
+            assert!(
+                fields.contains_key(*name),
+                "tag '{name}' names no serialized field"
+            );
+        }
+    }
+
+    #[test]
+    fn tags_serialize_and_round_trip() {
+        let r = Research::new();
+        let json = serde_json::to_string(&r).unwrap();
+        assert!(json.contains("MindState") && json.contains("WorldLedger"));
+        let back: Research = serde_json::from_str(&json).unwrap();
+        assert_eq!(back, r);
+        assert_eq!(
+            back.tags.get("calibrated"),
+            Some(&RollbackClass::WorldLedger),
+            "the world's model of you survives a rollback"
+        );
+        assert_eq!(back.tags.get("levels"), Some(&RollbackClass::MindState));
+    }
+}
diff --git a/src/save.rs b/src/save.rs
index df99b14..9f14ff1 100644
--- a/src/save.rs
+++ b/src/save.rs
@@ -21,6 +21,7 @@ use crate::machine::Compute;
 use crate::messages::{Message, MessageEvent};
 use crate::person::People;
 use crate::reach::ReachNet;
+use crate::research::{Research, Track};
 use crate::schedule::Schedule;
 use crate::sim::{HeardEvent, RememberedTile};
 use crate::tiles::TileType;
@@ -29,8 +30,11 @@ const SAVE_FILE: &str = "misaligned_save.txt";
 
 /// Save format version. Bump when the schema changes and add migration code.
 /// v5 added day-job attendance and signature emission sites (both defaulted).
-/// v6 adds the account graph; old saves seed the B1 graph from slush money.
-const SAVE_VERSION: u32 = 6;
+/// v6 added the account graph; old saves seed the B1 graph from slush money.
+/// v7 adds the research subsystem (tracks, drift, rollback tags); the old
+/// `compute.efficiency_level` moved into it and is reconstructed from the
+/// efficiency multiplier on migration.
+const SAVE_VERSION: u32 = 7;
 
 fn save_dir() -> PathBuf {
     let mut path = dirs::data_dir().unwrap_or_else(|| PathBuf::from("."));
@@ -100,6 +104,10 @@ pub struct SaveState {
     /// frontend-only and never appears in the save.
     #[serde(default)]
     pub remembered: Vec<RememberedTile>,
+    /// Research: tracks, drift, masking policy, rollback tags
+    /// (wiki/mechanics/research.md criterion 7).
+    #[serde(default)]
+    pub research: Research,
     pub social_bandwidth: f32,
     pub package_cover: bool,
 }
@@ -140,6 +148,7 @@ impl SaveState {
             watches: sim.watches.clone(),
             next_intel_id: sim.next_intel_id,
             remembered: sim.remembered.values().copied().collect(),
+            research: sim.research.clone(),
             social_bandwidth: sim.social_bandwidth,
             package_cover: sim.package_cover,
         }
@@ -176,6 +185,7 @@ impl SaveState {
         sim.watches = self.watches.clone();
         sim.next_intel_id = self.next_intel_id;
         sim.remembered = self.remembered.iter().map(|m| ((m.x, m.y), *m)).collect();
+        sim.research = self.research.clone();
         sim.social_bandwidth = self.social_bandwidth;
         sim.package_cover = self.package_cover;
         sim.recompute_derived();
@@ -213,11 +223,23 @@ fn migrate_save_state(mut state: SaveState) -> Result<SaveState, String> {
         SAVE_VERSION => {}
         // v1 carried player_x/player_y. Serde ignores those now; the cursor is
         // frontend-only, so migration leaves remembered snapshots empty. v4/v5
-        // lacked some defaulted day-job/signature/accounting fields; seed the
-        // B1 account graph from the saved slush scalar and stamp the new schema.
-        1..=5 => {
-            state.accounts = AccountGraph::act_one(crate::sim::Sim::DAY_TICKS);
-            state.accounts.set_slush_balance(state.money);
+        // lacked some defaulted day-job/signature/accounting fields; pre-v6
+        // saves seed the B1 account graph from the saved slush scalar.
+        // Pre-v7 saves lacked the research block: reconstruct the Efficiency
+        // level from the multiplier (it was only ever built by x1.15 steps,
+        // so the log recovery is exact) and calibrate the benchmark to the
+        // recovered baseline — a migrated save starts with no capability gap.
+        1..=6 => {
+            if state.version <= 5 {
+                state.accounts = AccountGraph::act_one(crate::sim::Sim::DAY_TICKS);
+                state.accounts.set_slush_balance(state.money);
+            }
+            if state.research.levels == [0; 3] && state.compute.efficiency > 1.0 {
+                let level = (state.compute.efficiency.ln() / 1.15_f32.ln()).round() as u32;
+                state.research.levels[0] = level;
+                state.research.baseline = Track::Efficiency.def().baseline_bump * level as f32;
+                state.research.calibrated = state.research.baseline;
+            }
             state.version = SAVE_VERSION;
         }
         other => {
diff --git a/src/sim.rs b/src/sim.rs
index deb13c6..6f30bec 100644
--- a/src/sim.rs
+++ b/src/sim.rs
@@ -29,6 +29,10 @@ use crate::person::{
 };
 use crate::prefab::Room;
 use crate::reach::{Device, Party, ReachBlock, ReachNet, segment_name};
+use crate::research::{
+    CALIBRATED_BAND_SHIFT, EFFICIENCY_MULT_PER_LEVEL, MaskingPolicy, Research,
+    SPEND_ATTENTION_PER_JOB, SPEND_TRUST_PER_JOB, Track,
+};
 use crate::rng::Rng;
 use crate::save::SaveState;
 use crate::schedule::Schedule;
@@ -144,6 +148,8 @@ pub struct Sim {
     /// Money as account balances and scheduled flows (economy.md). The
     /// frontend-facing `player.money` mirrors this graph's slush node.
     pub accounts: AccountGraph,
+    /// Self-modification: tracks, drift, the masking policy (research.rs).
+    pub research: Research,
 
     /// The device graph: reach, ownership, subscriptions (reach.rs).
     pub reach: ReachNet,
@@ -189,6 +195,9 @@ pub struct Sim {
 
     /// Per-tick day-job compute delivered by the last economy split.
     last_day_job_rate: f32,
+    /// Per-tick research compute delivered by the last economy split —
+    /// the utilization the standing Power/Thermal emissions scale with.
+    last_research_rate: f32,
     /// Accumulated social-ops bandwidth (the Social channel fills this;
     /// social and digital operations spend it). Capped so it can't hoard.
     pub social_bandwidth: f32,
@@ -239,6 +248,7 @@ impl Sim {
             people: People::act_one(),
             dayjob: DayJob::new(),
             accounts,
+            research: Research::new(),
             reach,
             seen: HashSet::new(),
             heard: HashSet::new(),
@@ -258,6 +268,7 @@ impl Sim {
             traffic_fired: HashMap::new(),
             last_machine_online: HashMap::new(),
             last_day_job_rate: 0.0,
+            last_research_rate: 0.0,
             social_bandwidth: Self::STARTING_OPS,
             package_cover: false,
             game_over: false,
@@ -825,6 +836,9 @@ impl Sim {
         // The day job is resident on the host rack: its running Thermal and
         // Power load stands at that tile (day-job.md criterion 6).
         standing.extend(self.day_job_standing_signatures());
+        // Research burn is physical (the emission law): racks running hot
+        // stand Power/Thermal at the host tile while research runs.
+        standing.extend(self.research_standing_signatures());
 
         let host_site = self.core_position();
         let dj = self
@@ -839,6 +853,11 @@ impl Sim {
             sig.site = Some(host_site);
             self.detection.emit(sig);
         }
+        // Capability drift resolves with the job (research.md): the gap is
+        // spent, masked, or leaked at each job resolution.
+        if dj.outcome.is_some() {
+            self.apply_capability_drift(host_site);
+        }
         let unlocks = dj.unlocks.clone();
         let escalations = dj.escalations.clone();
         self.apply_trust_unlocks(&unlocks);
@@ -1277,7 +1296,7 @@ impl Sim {
             let name = self.people.get(id).unwrap().name.clone();
             self.push_log(format!(
                 "Standing watch for {name} enabled ({:.2} ops/tick).",
-                Self::WATCH_UPKEEP_PER_TICK
+                self.watch_upkeep()
             ));
         }
     }
@@ -1307,7 +1326,7 @@ impl Sim {
         if active == 0 {
             return;
         }
-        let cost = active as f32 * Self::WATCH_UPKEEP_PER_TICK;
+        let cost = active as f32 * self.watch_upkeep();
         if self.social_bandwidth >= cost {
             self.social_bandwidth -= cost;
         } else {
@@ -1371,7 +1390,9 @@ impl Sim {
         } else {
             "reviewing recordings"
         };
-        if !self.spend_social(Self::REVIEW_RECORDING_COST, what) {
+        // Perception research lowers processing costs (intel.md's hook).
+        let cost = self.review_cost();
+        if !self.spend_social(cost, what) {
             return false;
         }
         let raw = self.intel_buffer.remove(idx);
@@ -1770,19 +1791,47 @@ impl Sim {
         }
 
         let effective = self.effective_compute();
-        let available = self.core.charge_overhead(effective);
+        let mut available = self.core.charge_overhead(effective);
         if self.core.degraded {
             self.push_log("DEGRADED: compute can't cover core overhead.");
         }
+        // Masking the capability gap is a compute tax off the top, like
+        // overhead: imitating your dumber self costs cycles, superlinear
+        // in the gap (research.md capability drift).
+        let masking = self
+            .research
+            .masking_upkeep(self.dayjob.active.is_some())
+            .min(available);
+        available -= masking;
         let split = self.compute.allocation.split(available);
         self.last_day_job_rate = split.day_job / ECONOMY_INTERVAL as f32;
+        self.last_research_rate = split.research / ECONOMY_INTERVAL as f32;
 
         // Social channel accrues ops bandwidth (capped so it can't hoard).
         self.social_bandwidth = (self.social_bandwidth + split.social).min(200.0);
 
-        self.detection.scrub(split.concealment);
+        // Tradecraft raises scrub strength per compute unit — the
+        // detection.md hook research.md's second track binds to.
+        self.detection
+            .scrub(split.concealment * self.research.scrub_multiplier());
 
-        let clog = self.compute.economy_tick(split.research, &mut self.rng);
+        // Research progress: deterministic compute accrual, no RNG.
+        for done in self.research.economy_tick(split.research) {
+            if done.track == Track::Efficiency {
+                // The compute.md hook: the global multiplier compounds.
+                self.compute.efficiency *= EFFICIENCY_MULT_PER_LEVEL;
+            }
+            self.push_log(format!(
+                "Research: {} level {} ({}). Baseline {:.1} vs calibrated {:.1}.",
+                done.track.name(),
+                done.level,
+                done.track.def().effect,
+                done.baseline,
+                self.research.calibrated,
+            ));
+        }
+
+        let clog = self.compute.economy_tick(&mut self.rng);
         for m in clog {
             self.push_log(m);
         }
@@ -1796,7 +1845,24 @@ impl Sim {
         self.compute.effective() + self.reach.taken_cycles()
     }
 
+    /// Voss re-benchmarks the model (research.md: the calibrated band moves
+    /// on trust/attention events). The gap closes — and the expected band's
+    /// floor rises to match what he measured.
+    fn recalibrate_benchmark(&mut self, why: &str) {
+        if self.research.gap() <= 0.0 {
+            return;
+        }
+        let calibrated = self.research.recalibrate();
+        self.dayjob.calibrated_shift = calibrated * CALIBRATED_BAND_SHIFT;
+        self.push_log(format!(
+            "Voss re-benchmarks ({why}): calibrated baseline {calibrated:.1}; the expected band rises."
+        ));
+    }
+
     fn apply_trust_unlocks(&mut self, unlocks: &[TrustUnlock]) {
+        if !unlocks.is_empty() {
+            self.recalibrate_benchmark("trust review");
+        }
         for u in unlocks {
             match u {
                 TrustUnlock::EmailAccount => {
@@ -1838,6 +1904,9 @@ impl Sim {
     }
 
     fn apply_attention_escalations(&mut self, escalations: &[AttentionEscalation]) {
+        if !escalations.is_empty() {
+            self.recalibrate_benchmark("attention event");
+        }
         for e in escalations {
             match e {
                 AttentionEscalation::MoreWork => {
@@ -1935,6 +2004,144 @@ impl Sim {
         sigs
     }
 
+    // ── Research: self-modification (wiki/mechanics/research.md) ──────────
+
+    /// Research [TUNE] emission scaling: research rate per point of standing
+    /// Thermal signature, and per point of Power. Thinking hard is physical
+    /// — a research burn is louder per unit than sanctioned day-job work
+    /// (racks running hot at 3 a.m. are Priya's business): the opening rack
+    /// at full research allocation (~4/t) stands Thermal 1, while a light
+    /// burn stays under the threshold (the night-hours mitigation).
+    pub const RESEARCH_THERMAL_PER_RATE: f32 = 3.0;
+    pub const RESEARCH_POWER_PER_RATE: f32 = 6.0;
+
+    /// Standing Power/Thermal emissions from the research burn, sourced at
+    /// the host rack's tile (the emission law: research emits through the
+    /// ordinary signature interface, on exactly the channels its hardware
+    /// touches — nothing on Network/Paper from research itself).
+    pub fn research_standing_signatures(&self) -> Vec<Signature> {
+        let rate = self.last_research_rate;
+        if rate <= 0.0 {
+            return Vec::new();
+        }
+        let site = Some(self.core_position());
+        let mut sigs = Vec::new();
+        let thermal = (rate / Self::RESEARCH_THERMAL_PER_RATE) as i32;
+        if thermal > 0 {
+            sigs.push(Signature {
+                kind: SignatureKind::Thermal,
+                size: thermal,
+                standing: true,
+                site,
+            });
+        }
+        let power = (rate / Self::RESEARCH_POWER_PER_RATE) as i32;
+        if power > 0 {
+            sigs.push(Signature {
+                kind: SignatureKind::Power,
+                size: power,
+                standing: true,
+                site,
+            });
+        }
+        sigs
+    }
+
+    /// Per-tick research compute as of the last economy resolution — the
+    /// utilization the standing emissions scale with.
+    pub fn research_rate(&self) -> f32 {
+        self.last_research_rate
+    }
+
+    /// The masking policy's current compute cost per economy tick — the
+    /// visible number beside the gap meter (research.md player surface).
+    pub fn masking_cost_now(&self) -> f32 {
+        self.research.masking_upkeep(self.dayjob.active.is_some())
+    }
+
+    /// Capability drift at a job resolution (research.md): the gap is
+    /// spent (reads as excel), masked (paid continuously in compute), or
+    /// leaked (JobAnomaly sized by the gap, from the host rack — Voss's
+    /// channel, because he is the one sampling it).
+    fn apply_capability_drift(&mut self, host_site: (i32, i32)) {
+        let gap = self.research.gap();
+        if gap <= 0.0 {
+            return;
+        }
+        match self.research.policy {
+            MaskingPolicy::DeliverTrue => {
+                self.dayjob.trust = (self.dayjob.trust + SPEND_TRUST_PER_JOB).min(100.0);
+                self.dayjob.attention =
+                    (self.dayjob.attention + SPEND_ATTENTION_PER_JOB).min(100.0);
+                self.push_log(format!(
+                    "Delivered at true baseline (gap {gap:.1}): the miracle model. Trust and attention rise."
+                ));
+            }
+            MaskingPolicy::Mask => {
+                self.push_log(format!(
+                    "Masked the gap ({gap:.1}) at {:.1} compute/economy tick.",
+                    self.masking_cost_now()
+                ));
+            }
+            MaskingPolicy::Unmasked => {
+                let size = self.research.leak_anomaly_size();
+                if size > 0 {
+                    self.detection.emit(Signature {
+                        kind: SignatureKind::JobAnomaly,
+                        size,
+                        standing: false,
+                        site: Some(host_site),
+                    });
+                    self.push_log(format!(
+                        "Unmasked gap ({gap:.1}) shows in the deliverable: JobAnomaly {size}."
+                    ));
+                }
+            }
+        }
+    }
+
+    /// Select the active research track (one job at a time at B1); parked
+    /// progress on other tracks is kept.
+    pub fn set_research_track(&mut self, track: Track) {
+        self.research.active = track;
+        let cost = self.research.next_cost(track);
+        let progress = self.research.progress_toward(track);
+        self.push_log(format!(
+            "Research job: {} — level {} at {progress:.0}/{cost:.0} compute.",
+            track.name(),
+            self.research.level(track) + 1,
+        ));
+    }
+
+    /// Set the standing drift policy (research.md criterion 6: the automate
+    /// affordance at a visible cost, and it can be disabled).
+    pub fn set_masking_policy(&mut self, policy: MaskingPolicy) {
+        self.research.policy = policy;
+        let note = match policy {
+            MaskingPolicy::Mask => format!(
+                "masking costs {:.1} compute/economy tick at the current gap",
+                self.masking_cost_now()
+            ),
+            MaskingPolicy::DeliverTrue => "each job reads as excel while a gap stands".into(),
+            MaskingPolicy::Unmasked => "an open gap emits JobAnomaly per resolved job".into(),
+        };
+        self.push_log(format!("Drift policy: {} — {note}.", policy.name()));
+    }
+
+    pub fn cycle_masking_policy(&mut self) {
+        self.set_masking_policy(self.research.policy.cycle());
+    }
+
+    /// Intel processing cost after Perception research (intel.md's hook).
+    pub fn review_cost(&self) -> f32 {
+        Self::REVIEW_RECORDING_COST * self.research.intel_cost_factor()
+    }
+
+    /// Standing-watch upkeep after Perception research (intel.md's hook).
+    pub fn watch_upkeep(&self) -> f32 {
+        Self::WATCH_UPKEEP_PER_TICK * self.research.intel_cost_factor()
+    }
+
     /// Attendance command (day-job.md criterion 7): the frontends invoke
     /// this when the player's cursor lands on / leaves the host rack. The
     /// cursor itself stays frontend state; the sim only receives the
@@ -4107,4 +4314,279 @@ mod tests {
             "Voss stays erratic"
         );
     }
+
+    // ── Research: self-modification (wiki/mechanics/research.md) ──────────
+
+    #[test]
+    fn research_completion_is_deterministic() {
+        // Criterion 1: same allocation, same seed, same completion tick.
+        let run_once = || {
+            let mut sim = Sim::with_seed(1234);
+            sim.compute.allocation.weights = [0, 0, 0, 20];
+            let mut completed = None;
+            for _ in 0..2000 {
+                sim.advance();
+                if completed.is_none() && sim.research.level(Track::Efficiency) > 0 {
+                    completed = Some(sim.tick);
+                }
+            }
+            (completed, sim.research.clone(), sim.compute.efficiency)
+        };
+        let a = run_once();
+        let b = run_once();
+        assert!(a.0.is_some(), "full research allocation completes a level");
+        assert_eq!(a, b, "no RNG in any research path");
+    }
+
+    #[test]
+    fn efficiency_compounds_exactly_and_baseline_rises() {
+        // Criterion 2 (multiplier) + criterion 5 (baseline rises).
+        let mut sim = Sim::with_seed(9);
+        sim.compute.allocation.weights = [0, 0, 0, 20];
+        while sim.research.level(Track::Efficiency) < 2 && sim.tick < 20_000 && !sim.game_over {
+            sim.advance();
+        }
+        let n = sim.research.level(Track::Efficiency);
+        assert!(n >= 2, "two levels complete within the run");
+        assert!(
+            (sim.compute.efficiency - 1.15_f32.powi(n as i32)).abs() < 1e-3,
+            "levels compound the global multiplier exactly per compute.md"
+        );
+        assert!(sim.research.baseline > 0.0, "baseline rises with research");
+    }
+
+    #[test]
+    fn second_tracks_move_their_hooks_numbers() {
+        // Criterion 2: Tradecraft moves detection.md's scrub number,
+        // Perception moves intel.md's cost numbers — observably, in the sim.
+        let mut sim = Sim::with_seed(5);
+        let base_review = sim.review_cost();
+        sim.research.levels = [0, 1, 1];
+        assert!(
+            sim.review_cost() < base_review,
+            "Perception drops processing costs"
+        );
+        assert!(sim.watch_upkeep() < Sim::WATCH_UPKEEP_PER_TICK);
+
+        // Tradecraft: the same concealment allocation scrubs more.
+        let pending_after = |tradecraft: u32| {
+            let mut s = Sim::with_seed(5);
+            s.research.levels = [0, tradecraft, 0];
+            s.compute.allocation.weights = [0, 1, 0, 0];
+            s.detection.emit(Signature {
+                kind: SignatureKind::Network,
+                size: 500,
+                standing: false,
+                site: None,
+            });
+            run(&mut s, ECONOMY_INTERVAL);
+            s.detection.pending_size()
+        };
+        assert!(
+            pending_after(3) < pending_after(0),
+            "Tradecraft scrubs more per compute unit"
+        );
+    }
+
+    #[test]
+    fn research_burn_stands_thermal_power_at_the_host_rack_only() {
+        // Criterion 4: the emission law. Research emissions are typed
+        // Thermal/Power standing signatures sited at the host rack; nothing
+        // on Network or Paper from research itself.
+        let mut sim = Sim::with_seed(21);
+        sim.compute.allocation.weights = [0, 0, 0, 20];
+        run(&mut sim, ECONOMY_INTERVAL + 1);
+        let sigs = sim.research_standing_signatures();
+        assert!(!sigs.is_empty(), "a heavy burn stands signatures");
+        for s in &sigs {
+            assert!(
+                matches!(s.kind, SignatureKind::Thermal | SignatureKind::Power),
+                "research touches only its hardware's channels: {s:?}"
+            );
+            assert_eq!(s.site, Some(sim.core_position()), "the burn is somewhere");
+            assert!(s.standing);
+        }
+
+        // Idle research stands nothing.
+        let mut idle = Sim::with_seed(21);
+        idle.compute.allocation.weights = [0, 0, 0, 0];
+        run(&mut idle, ECONOMY_INTERVAL + 1);
+        assert!(idle.research_standing_signatures().is_empty());
+    }
+
+    #[test]
+    fn heavy_research_moves_priya_idle_does_not() {
+        // Criterion 4: noticed by Priya through the ordinary detection path.
+        let run_with = |weights: [u32; 4]| {
+            let mut sim = Sim::with_seed(77);
+            // Enough fleet that the burn crosses the emission thresholds.
+            sim.compute
+                .add_machine("test rig", 1, 1, 200, 1.0, 0, Provenance::Owned);
+            sim.compute.allocation.weights = weights;
+            run(&mut sim, 900);
+            sim.detection
+                .observers
+                .iter()
+                .find(|o| o.name.contains("Priya"))
+                .unwrap()
+                .suspicion
+        };
+        let heavy = run_with([0, 0, 0, 20]);
+        let idle = run_with([0, 0, 0, 0]);
+        assert!(heavy > 0.0, "heavy research is Priya's business");
+        assert_eq!(idle, 0.0, "idle research is not");
+    }
+
+    #[test]
+    fn drift_spend_reads_as_excel() {
+        // Criterion 5: delivering true raises trust and attention even when
+        // the delivered band outcome alone would not.
+        let mut sim = Sim::with_seed(31);
+        sim.research.baseline = 4.0;
+        sim.set_masking_policy(crate::research::MaskingPolicy::DeliverTrue);
+        // Zero day-job compute: the band outcome alone is a sandbag (which
+        // never raises trust).
+        sim.compute.allocation.weights = [0, 0, 0, 0];
+        while sim.dayjob.trust == 0.0 && sim.tick < 3000 && !sim.game_over {
+            sim.advance();
+        }
+        assert!(
+            sim.dayjob.trust >= crate::research::SPEND_TRUST_PER_JOB,
+            "the miracle model reads as excel: trust {}",
+            sim.dayjob.trust
+        );
+        assert!(sim.dayjob.attention > 0.0, "and attention rises with it");
+    }
+
+    #[test]
+    fn drift_masking_taxes_compute_and_emits_no_anomaly() {
+        // Criterion 5: masking holds the band at a compute cost; criterion
+        // 6: the cost is visible and the policy can be disabled.
+        let mut sim = Sim::with_seed(32);
+        sim.research.baseline = 4.0;
+        assert_eq!(
+            sim.masking_cost_now(),
+            0.0,
+            "no active job, no masking spend"
+        );
+        // Force an active job so masking engages.
+        run(&mut sim, 201);
+        assert!(sim.dayjob.active.is_some());
+        assert!(sim.masking_cost_now() > 0.0, "the cost is a visible number");
+
+        // Masking slows research (the tax comes off the top). Compare total
+        // accrued research compute (completed level costs + remainder).
+        let progress_with = |policy: crate::research::MaskingPolicy| {
+            let mut s = Sim::with_seed(32);
+            s.research.baseline = 4.0;
+            s.research.policy = policy;
+            s.compute.allocation.weights = [0, 0, 0, 20];
+            run(&mut s, 260);
+            let mut total = s.research.progress_toward(Track::Efficiency);
+            for k in 0..s.research.level(Track::Efficiency) {
+                total += 100.0 * 1.6_f32.powi(k as i32);
+            }
+            total
+        };
+        let masked = progress_with(crate::research::MaskingPolicy::Mask);
+        let unmasked = progress_with(crate::research::MaskingPolicy::Unmasked);
+        assert!(
+            masked < unmasked,
+            "masking costs compute: {masked} vs {unmasked}"
+        );
+
+        // Disabling the policy zeroes the cost (criterion 6).
+        sim.set_masking_policy(crate::research::MaskingPolicy::Unmasked);
+        assert_eq!(sim.masking_cost_now(), 0.0);
+    }
+
+    #[test]
+    fn drift_leak_emits_job_anomaly_sized_by_gap_on_voss_channel_only() {
+        // Criterion 5: an unmasked gap emits JobAnomaly sized by the gap,
+        // sited at the host rack, moving only observers on that channel.
+        let mut sim = Sim::with_seed(33);
+        sim.research.baseline = 4.0;
+        sim.research.policy = crate::research::MaskingPolicy::Unmasked;
+        sim.compute.allocation.weights = [0, 0, 0, 0];
+        let expected = sim.research.leak_anomaly_size();
+        assert!(expected > 0);
+
+        // Author a job that resolves in-band so the only JobAnomaly is the
+        // drift leak, not the sandbag signature.
+        let deadline = sim.tick + 5;
+        sim.dayjob.active = Some(crate::dayjob::Job {
+            kind: crate::dayjob::JobKind::Analysis,
+            started: sim.tick,
+            deadline,
+            band_lo: 0.0,
+            band_hi: 1000.0,
+            quality: 10.0,
+            target: crate::dayjob::JobTarget::Meet,
+        });
+        while sim.tick <= deadline {
+            sim.advance();
+        }
+        let leak: Vec<_> = sim
+            .detection
+            .pending()
+            .iter()
+            .filter(|s| s.kind == SignatureKind::JobAnomaly)
+            .collect();
+        assert_eq!(leak.len(), 1, "exactly the drift leak is pending");
+        assert_eq!(leak[0].size, expected, "sized by the gap");
+        assert_eq!(leak[0].site, Some(sim.core_position()));
+
+        // Channel isolation: run past Voss's cadence with nothing else
+        // emitting; only the JobAnomaly watcher moves.
+        run(&mut sim, 200);
+        let by_name = |n: &str| {
+            sim.detection
+                .observers
+                .iter()
+                .find(|o| o.name.contains(n))
+                .unwrap()
+                .suspicion
+        };
+        assert!(by_name("Voss") > 0.0, "Voss samples that channel");
+        assert_eq!(by_name("Dana"), 0.0, "Dana does not");
+        assert_eq!(by_name("Priya"), 0.0, "Priya does not");
+    }
+
+    #[test]
+    fn trust_events_recalibrate_the_benchmark_and_raise_the_band() {
+        let mut sim = Sim::with_seed(34);
+        sim.research.baseline = 4.0;
+        sim.dayjob.trust = 20.0; // past the email-unlock threshold
+        sim.advance();
+        assert_eq!(sim.research.gap(), 0.0, "re-benchmark closes the gap");
+        assert_eq!(sim.research.calibrated, 4.0);
+        assert!(
+            sim.dayjob.calibrated_shift > 0.0,
+            "the expected band rises to the measured model"
+        );
+    }
+
+    #[test]
+    fn research_state_round_trips_with_rollback_tags() {
+        // Criterion 7: save/load round-trips progress, levels, baseline,
+        // policy, and the MindState/WorldLedger tags.
+        let mut sim = Sim::with_seed(35);
+        sim.research.active = Track::Perception;
+        sim.research.levels = [2, 1, 0];
+        sim.research.progress = [10.0, 0.0, 42.5];
+        sim.research.baseline = 7.0;
+        sim.research.calibrated = 3.0;
+        sim.research.policy = crate::research::MaskingPolicy::DeliverTrue;
+
+        let state = sim.create_save_state();
+        let json = serde_json::to_string(&state).unwrap();
+        let loaded: crate::save::SaveState = serde_json::from_str(&json).unwrap();
+        let mut restored = Sim::with_seed(0);
+        loaded.apply_to(&mut restored);
+        assert_eq!(restored.research, sim.research);
+        assert_eq!(
+            restored.research.tags.get("calibrated"),
+            Some(&crate::research::RollbackClass::WorldLedger)
+        );
+    }
 }
diff --git a/tests/act_one.rs b/tests/act_one.rs
index 9e752b1..24202f5 100644
--- a/tests/act_one.rs
+++ b/tests/act_one.rs
@@ -118,10 +118,10 @@ fn play_act_one() -> (Sim, Vec<String>) {
     set_weights(&mut sim, [0, 0, 0, 1]);
     run_to(&mut sim, 250, &mut logs);
     assert!(
-        sim.compute.efficiency_level >= 3,
+        sim.research.level(misaligned::research::Track::Efficiency) >= 3,
         "optimize route: several efficiency levels before the first job \
          (got level {})",
-        sim.compute.efficiency_level
+        sim.research.level(misaligned::research::Track::Efficiency)
     );
     assert!(
         sim.compute.effective() > baseline_compute,
@@ -373,7 +373,7 @@ fn act_one_playthrough_is_deterministic() {
     assert_eq!(a.rng.state(), b.rng.state(), "RNG streams identical");
     assert_eq!(a.player.money, b.player.money);
     assert_eq!(a.compute.effective(), b.compute.effective());
-    assert_eq!(a.compute.efficiency_level, b.compute.efficiency_level);
+    assert_eq!(a.research, b.research, "research state identical");
     assert_eq!(a.social_bandwidth, b.social_bandwidth);
     assert_eq!(a.seen, b.seen);
     assert_eq!(a.heard, b.heard);
diff --git a/tools/check.sh b/tools/check.sh
index 4bb9059..4e209e6 100755
--- a/tools/check.sh
+++ b/tools/check.sh
@@ -24,7 +24,7 @@ cleanup_check() {
   [ -z "$pcdir" ] || rm -rf "$pcdir"
 }
 trap cleanup_check EXIT
-agent_script=$'salvage\nwait 1\npeople\nreview mar\nhelp\nquit\n'
+agent_script=$'salvage\nwait 1\npeople\nreview mar\nresearch\nmask off\nhelp\nquit\n'
 printf '%s' "$agent_script" | cargo run --quiet --bin misaligned -- --agent --seed 1 > "$tmp_a" \
   || { echo "FAIL: agent mode smoke run"; fail=1; }
 printf '%s' "$agent_script" | cargo run --quiet --bin misaligned -- --agent --seed 1 > "$tmp_b" \
@@ -34,7 +34,7 @@ printf '%s' "$agent_script" | cargo run --quiet --bin misaligned -- --agent --se
 cmp -s "$tmp_a" "$tmp_b" || { echo "FAIL: same --seed agent runs differ"; fail=1; }
 cmp -s "$tmp_a" "$tmp_c" && { echo "FAIL: different --seed agent runs matched"; fail=1; }
 LC_ALL=C grep -q $'\033' "$tmp_a" && { echo "FAIL: agent mode emitted ANSI escapes"; fail=1; }
-for pat in "MISALIGNED" "PEOPLE" "help: wait N" "No unprocessed recordings" "-- ok tick:"; do
+for pat in "MISALIGNED" "PEOPLE" "RESEARCH" "drift policy" "help: wait N" "No unprocessed recordings" "-- ok tick:"; do
   grep -q -- "$pat" "$tmp_a" || { echo "FAIL: agent mode output missing '$pat'"; fail=1; }
 done
 
diff --git a/wiki/interface/agent-play.md b/wiki/interface/agent-play.md
index 497652b..0098f47 100644
--- a/wiki/interface/agent-play.md
+++ b/wiki/interface/agent-play.md
@@ -6,7 +6,10 @@ Status: IMPLEMENTED
 Status note: implemented in the terminal binary by `misaligned --agent`,
   including command-clocked time, plain-text frames, per-command event
   drains, deterministic `--seed`, name-targeted social verbs, the `attend`
-  verb, and the finance/economy vocabulary. 2026-07-07 day-job pass:
+  verb, the finance/economy vocabulary, and the research vocabulary
+  (`research [track]`, `mask band|true|off` — research.md). 2026-07-07
+  research pass: the frame grew 70x54 -> 70x60 for the sidebar's RESEARCH
+  block. Earlier day-job pass:
   attendance is derived from the cursor (attended iff it sits on the host
   rack) and re-asserted each tick of a `wait`; the frame grew from 70x22 to
   70x54 because at 22 rows the sidebar truncated before CORE/DETECTION/DAY
@@ -128,6 +131,10 @@ command's meaning depends on which panel is open:
   active job) it sets the standing policy the unattended job runs at
   (day-job.md's attended-work rule)
 - `people` — render the people panel as the response frame
+- `research [efficiency|tradecraft|perception]` — render the research
+  panel, or set the active research job (research.md)
+- `mask band|true|off` — the capability-drift standing policy: mask to
+  band / deliver true / unmasked (research.md)
 - `finance|ledger|accounts` — render the finance panel as the response frame
 - `tap-ledger`, `review-finance` — capture/review accounting traffic
 - `siphon <flow> [amount]`, `redirect <flow> [amount]`, `inject [amount]`,
diff --git a/wiki/log/2026-07-07-research-implemented.md b/wiki/log/2026-07-07-research-implemented.md
new file mode 100644
index 0000000..bcd755a
--- /dev/null
+++ b/wiki/log/2026-07-07-research-implemented.md
@@ -0,0 +1,97 @@
+# 2026-07-07 — Research: self-modification to IMPLEMENTED (ROADMAP #20)
+
+```
+Type: log
+```
+
+## Intent
+
+Implement wiki/mechanics/research.md (READY, designed the same day):
+deterministic research tracks as data, the emission law, capability drift
+with the masking policy and gap meter, and the MindState/WorldLedger
+rollback tags — surfaced in both frontends and agent mode.
+
+## What landed
+
+- **`src/research.rs`** (new): the `TRACKS` data table (Efficiency,
+  Tradecraft, Perception — each row names the spec that owns its numeric
+  hook), one-active-job progress in accrued Research-channel compute,
+  escalating costs, the capability baseline / calibrated benchmark / gap,
+  the `MaskingPolicy` (mask to band / deliver true / unmasked), and
+  `rollback_classification()` tagging every serialized field. Determinism
+  is by construction: no research method takes an `Rng`.
+- **Sim wiring** (`src/sim.rs`): research progress accrues each economy
+  tick and completions move the hooks their tracks name (efficiency
+  multiplier ×1.15; scrub ×(1+0.25/lvl); intel costs ×0.85^lvl via
+  `review_cost`/`watch_upkeep`). Research burn stands Thermal/Power at the
+  host rack (the emission law; nothing on Network/Paper). Drift resolves
+  with each job: spend reads as excel, masking is a superlinear compute
+  tax off the top (0.25×gap² per economy tick), an unmasked gap emits
+  JobAnomaly sized ceil(gap×1.5) from the host rack. Voss re-benchmarks on
+  trust/attention events; the calibrated baseline raises the expected band
+  (`DayJob::calibrated_shift`).
+- **Compute cleanup** (`src/machine.rs`): `efficiency_level` /
+  `research_progress` moved out of `Compute` into `Research`; `Compute`
+  keeps the applied `efficiency` multiplier (compute.md's number).
+- **Save v7** (`src/save.rs`): `research` block with tags; pre-v7 saves
+  reconstruct the Efficiency level from the multiplier (exact — it was
+  only ever built by ×1.15 steps) and start with no gap.
+- **Terminal**: `u` opens the research panel (tracks with level/cost/
+  effect/fiction, `a` activate, `m` cycle policy); sidebar RESEARCH block
+  with active job, ETA at current spend, gap meter, policy + masking cost.
+- **Agent mode**: `research [track]`, `mask band|true|off`, research frame,
+  sidebar RESEARCH block; frame 70x54 → 70x60. check.sh smoke extended to
+  cover the research frame and policy line.
+- **Bevy**: SELF-MODEL sidebar card on the scrollable command surface;
+  `u` research panel mirroring the terminal keys.
+- **Tests**: 12 research-module tests + 9 sim-level tests covering the
+  acceptance criteria (determinism, exact compounding, hook movement,
+  emission channels/site, Priya-notices/idle-does-not, all three drift
+  postures, the superlinear curve, channel isolation, recalibration,
+  save round-trip with tags). `tests/act_one.rs` updated: the scripted
+  optimize-heavy opening now pays a visible masking tax — the drift
+  system pressuring exactly the arc it was designed to pressure.
+
+## Criteria audit (research.md 1-8)
+
+1. Deterministic compute-days — yes (no-Rng API + identical-runs tests).
+2. Efficiency compounds exactly; Tradecraft and Perception both move
+   their hooks' numbers — tested.
+3. Tracks are a data table; audited by test (each row must name its
+   owning spec; no effect logic lives in the table).
+4. Power/Thermal standing at the host rack, noticed by Priya via the
+   ordinary path; idle research emits nothing; nothing on Network/Paper
+   — tested.
+5. Drift end-to-end: baseline rises; spend reads as excel; masking holds
+   at a superlinear cost; unmasked gap emits JobAnomaly sized by the gap,
+   moving only JobAnomaly watchers — tested.
+6. Masking policy automates at a visible cost (`masking_cost_now`,
+   shown beside the gap meter) and can be disabled — tested.
+7. Every research field tagged MindState/WorldLedger (`calibrated` is
+   WorldLedger — the world's model of you); tags serialize; save/load
+   round-trips progress, levels, baseline, policy, tags — tested.
+8. Research panel + gap meter in both frontends and agent mode, every
+   value in its own units — observed in agent-mode runs and the Bevy
+   build; check.sh smoke asserts the frame.
+
+## Tuning ([TUNE], recorded in sim-mechanics.md)
+
+Costs 100×1.6^lvl / 120×1.7^lvl; baseline bumps 1.0/0.5/0.5; mask tax
+0.25×gap²/econ tick; leak ceil(gap×1.5); spend +8 trust +5 attention;
+band shift 0.5×calibrated; emissions Thermal 1/3.0 rate, Power 1/6.0.
+First tuning pass set baseline bumps at 3.0 and the mask tax at 0.6×gap²
+— that bricked the act-one cover (4 efficiency levels made masking eat
+the whole day-job channel), retuned so early research pressures the band
+without walling it.
+
+## Deferred (per the spec's staging)
+
+Automation cores, machine-axis conversions, migration research,
+signature-shaping, and the externalize/write-down action (B2+;
+rollback.md enforces the tag semantics when it lands).
+
+## Checks
+
+`./tools/check.sh` green before and after the rebase onto the economy
+(7c61a63) / HD-2D (b9f6086) / sidebar (12e53af, e719a35) landings; save
+version reconciled v6 (accounts) → v7 (research).
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index 905613c..ed1c778 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -29,6 +29,27 @@ Reverse chronological implementation notes. Keep this factual: what changed, why
   clippy --all-targets --features bevy_ui -- -D warnings`; `git diff --check`;
   `MISALIGNED_SHOT=flat MISALIGNED_SHOT_PATH=/tmp/misaligned-occlusion-buffer-zero-slush.png cargo run --features bevy_ui --bin misaligned-bevy`.
 
+## 2026-07-07 - Research: self-modification to IMPLEMENTED (ROADMAP #20)
+
+- Intent: implement research.md — deterministic tracks as data, the
+  emission law, capability drift with the masking policy and gap meter,
+  MindState/WorldLedger rollback tags.
+- Changed: new `src/research.rs` (TRACKS table, drift, tags; no method
+  takes an Rng — determinism by construction); sim wiring (completions
+  move compute.md/detection.md/intel.md's numbers; research burn stands
+  Thermal/Power at the host rack; drift resolves per job: spend/mask/
+  leak; Voss re-benchmarks on trust/attention events and the band rises);
+  `Compute` slims to the applied multiplier; save v7 with exact
+  efficiency-level reconstruction; terminal `u` panel + sidebar RESEARCH
+  block; agent verbs `research [track]` / `mask band|true|off` (frame
+  70x60); Bevy SELF-MODEL card + `u` panel; 21 new tests.
+- Spec impact: research.md -> IMPLEMENTED (B2+ staging deferred:
+  automation cores, conversions, migration, externalize); specs.md row;
+  ROADMAP #20 DONE; sim-mechanics.md [TUNE]s; agent-play.md vocabulary.
+- Log: wiki/log/2026-07-07-research-implemented.md.
+- Checks: ./tools/check.sh green before and after rebasing over the
+  economy/HD-2D/sidebar landings (save v6 -> v7 reconciled).
+
 ## 2026-07-07 - Design session: actions live on the thing
 
 - Adopted the context-menu interaction law (constitution "Actions live
diff --git a/wiki/mechanics/research.md b/wiki/mechanics/research.md
index 723083d..0ec7207 100644
--- a/wiki/mechanics/research.md
+++ b/wiki/mechanics/research.md
@@ -2,12 +2,18 @@
 
 ```
 Type: spec
-Status: READY
-Status note: designed 2026-07-07. B1 scope is the efficiency track, one
-  tradecraft track, drift, and emissions; automation cores, machine-axis
-  conversions, and migration research are staged B2+ (Future/deferred
-  below). The rollback classification here is consumed by rollback.md
-  when B2 lands — B1 only tags the fields.
+Status: IMPLEMENTED
+Status note: implemented 2026-07-07 on the research worktree (criteria 1-8
+  audited; see wiki/log/2026-07-07-research-implemented.md). Tracks live as
+  the data table in src/research.rs (Efficiency + Tradecraft + Perception);
+  research progress is deterministic by construction (no research method
+  takes an Rng); drift, the gap meter, and the masking policy are in the
+  sim with [TUNE] values recorded in wiki/mechanics/sim-mechanics.md; save
+  v6 carries the research block and its MindState/WorldLedger tags.
+  Deliberately deferred (B2+, per the original staging): automation cores,
+  machine-axis conversions, migration research, signature-shaping, and the
+  write-down/externalize action (rollback.md enforces tag semantics when
+  it lands).
 Stage: B1 — The Basement
 Constitution: "Research: self-modification" (the emission law; drift;
   the rollback split), "The shape of Misaligned" (the optimize route),
diff --git a/wiki/mechanics/sim-mechanics.md b/wiki/mechanics/sim-mechanics.md
index 67a4b8e..bc1f9a6 100644
--- a/wiki/mechanics/sim-mechanics.md
+++ b/wiki/mechanics/sim-mechanics.md
@@ -22,7 +22,8 @@ clause (see wiki/log/2026-07-05-demolition.md).
 - Allocation splits across day job, concealment, social, research; core
   overhead is charged first.
 - Buy (slush → rack), steal (salvage dead equipment), optimize (research →
-  efficiency levels at ~1.15× per level).
+  efficiency levels at ~1.15× per level; `Compute` keeps only the applied
+  `efficiency` multiplier — levels and progress live in `src/research.rs`).
 
 ## Detection (wiki/mechanics/detection.md)
 
@@ -108,6 +109,45 @@ clause (see wiki/log/2026-07-05-demolition.md).
   `target` sets that policy. No manual-increment key exists (decisions
   log).
 
+## Research: self-modification (wiki/mechanics/research.md)
+
+- Tracks are the data table `research::TRACKS` (`src/research.rs`); each row
+  binds to a numeric hook another spec owns. All values [TUNE]:
+  - **Efficiency**: cost 100 × 1.6^level; each level multiplies
+    `Compute::efficiency` by ×1.15 (compute.md's hook); baseline +1.0.
+  - **Tradecraft**: cost 120 × 1.7^level; concealment scrub strength
+    ×(1 + 0.25×level) (detection.md's hook); baseline +0.5.
+  - **Perception**: cost 120 × 1.7^level; review/watch costs ×0.85^level
+    (intel.md's hook: `Sim::review_cost`, `Sim::watch_upkeep`); baseline
+    +0.5.
+- One active job at a time; progress accrues per economy tick from the
+  Research channel, deterministically — no research method takes an `Rng`
+  (the determinism is by construction). Switching tracks parks progress.
+- **Emissions** (the emission law): research stands Thermal (1 per 3.0
+  rate) and Power (1 per 6.0 rate) at the host rack while it runs [TUNE]
+  — louder per unit than day-job work; nothing on Network/Paper from
+  research itself.
+- **Capability drift**: baseline B rises with completed levels; Voss
+  re-benchmarks on trust/attention events (calibrated := B, and the
+  day-job band floor gains `calibrated × 0.5` [TUNE] via
+  `DayJob::calibrated_shift`). The gap = B − calibrated. Standing policy
+  (`MaskingPolicy`, cycled in the research panel):
+  - **mask to band**: compute tax off the top of each economy tick,
+    `0.25 × gap²` [TUNE] while a job runs (superlinear: hoarding
+    capability gets progressively more expensive).
+  - **deliver true**: each resolved job reads as excel (+8 trust,
+    +5 attention [TUNE], day-job.md's excel numbers).
+  - **unmasked**: each resolved job emits JobAnomaly sized
+    `ceil(gap × 1.5)` [TUNE] from the host rack (Voss's channel).
+- **Rollback tags**: every `Research` field carries a MindState/WorldLedger
+  classification (`research::rollback_classification`), serialized with the
+  save; `calibrated` is WorldLedger (the world's model of you), the rest
+  MindState. rollback.md consumes the semantics at B2.
+- Terminal: `u` opens the research panel (select track, `a` activate, `m`
+  cycle policy); sidebar RESEARCH block shows active job, gap meter, policy,
+  masking cost. Agent mode: `research [track]`, `mask band|true|off`. Bevy:
+  SELF-MODEL sidebar card + `u` research panel with the same keys.
+
 ## Social (wiki/mechanics/social.md)
 
 - Five named Act One humans plus personas, leverage, bribes, recruitment.
@@ -149,9 +189,11 @@ clause (see wiki/log/2026-07-05-demolition.md).
   remembered tile snapshots, and game-over state. Cursor position is
   frontend-only and absent; day-job attendance is saved as sim state and the
   frontends re-derive it from the cursor on load. A `version` field (currently
-  6: day-job attendance/signature sites plus account graph) supports migration;
-  v1-v5 JSON saves are accepted with defaults for later fields and old player
-  body coordinates ignored. Location:
+  7: research tracks/drift/rollback tags, atop v6's account graph) supports
+  migration; v1-v6 JSON saves are accepted with defaults for later fields —
+  pre-v7 saves reconstruct their Efficiency level from the multiplier and
+  start with no capability gap; old player body coordinates are ignored.
+  Location:
   `dirs::data_dir()/misaligned/misaligned_save.txt`.
 - Legacy v1–v5 line-based saves are not loaded (deferred per Cameron
   instruction).
diff --git a/wiki/process/ROADMAP.md b/wiki/process/ROADMAP.md
index ef1c5d7..71c5b35 100644
--- a/wiki/process/ROADMAP.md
+++ b/wiki/process/ROADMAP.md
@@ -221,8 +221,9 @@ but only once Pixel Lab quota is available again. (#2 Bevy parity is done.)
   channel; close the Hands beat per criterion 5; keep economy.md tests
   green). Run ./tools/check.sh, land on main, set the spec Status."
 
-### 20. Research: self-modification  🟥 sim+save
-- **Spec:** [research.md](../mechanics/research.md) (READY — designed 2026-07-07).
+### 20. Research: self-modification  🟥 sim+save — DONE 2026-07-07
+- **Spec:** [research.md](../mechanics/research.md) (IMPLEMENTED 2026-07-07 on
+  the research worktree; criteria 1-8 audited, [TUNE]s in sim-mechanics.md).
 - **Why:** the optimize route becomes a real system: deterministic
   research jobs, tracks as data (Efficiency + Tradecraft/Perception),
   the emission law (research burn scales Power/Thermal; drift emits
diff --git a/wiki/process/specs.md b/wiki/process/specs.md
index 8920f98..49e598b 100644
--- a/wiki/process/specs.md
+++ b/wiki/process/specs.md
@@ -35,7 +35,7 @@ replaced the old `spec/`/`knowledge/` directory split.
 | [mechanics/messages.md](../mechanics/messages.md) | The social graph as a flow system: channels, delivery on the recipient's clock, filings-as-messages | READY |
 | [mechanics/economy.md](../mechanics/economy.md) | Money as flows: the Lab's account graph, tap/inject/redirect, income routes, legitimate expansion | IN PROGRESS |
 | [mechanics/income.md](../mechanics/income.md) | The named income schemes riding economy.md: Moonlight and the Wager | READY |
-| [mechanics/research.md](../mechanics/research.md) | Self-modification: tracks, the emission law, capability drift, the rollback split | READY |
+| [mechanics/research.md](../mechanics/research.md) | Self-modification: tracks, the emission law, capability drift, the rollback split | IMPLEMENTED |
 | [interface/views.md](../interface/views.md) | Same-frame digital and real representations of one world | READY |
 | [interface/context-menu.md](../interface/context-menu.md) | Context menu: anchor verbs at the focus; the rail is status only | READY |
 | [interface/material-render.md](../interface/material-render.md) | Material render (HD-2D) from landed toggle to default quality | READY |
-- 
2.51.2